JAL-2416 order score models by order of addition rather than name
[jalview.git] / src / jalview / urls / UrlLinkTableModel.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21
22 package jalview.urls;
23
24 import jalview.bin.Cache;
25 import jalview.urls.api.UrlProviderI;
26 import jalview.util.UrlLink;
27
28 import java.util.Iterator;
29 import java.util.List;
30
31 import javax.swing.RowFilter.Entry;
32 import javax.swing.event.TableModelEvent;
33 import javax.swing.event.TableModelListener;
34 import javax.swing.table.AbstractTableModel;
35 import javax.swing.table.TableModel;
36
37 /**
38  * TableModel for UrlLinks table
39  * 
40  * @author $author$
41  * @version $Revision$
42  */
43
44 public class UrlLinkTableModel extends AbstractTableModel
45 {
46   // local storage of data
47   private List<UrlLinkDisplay> data;
48
49   // supplier of url data
50   private UrlProviderI dataProvider;
51
52   // list of columns to display in table in correct order
53   private List<String> displayColumns;
54
55   // row in table which is currently the primary
56   private int primaryRow;
57
58   /**
59    * UrlLinkTableModel constructor
60    * 
61    * @param baseData
62    *          base data set to be presented in table
63    * @param entryNames
64    *          keys of entries in baseData's nested hashmap. Should match order
65    *          in displayColNames
66    * @param displayColNames
67    *          names of columns to display in order.
68    * @param keyColName
69    *          name of column corresponding to keys in baseData
70    */
71   public UrlLinkTableModel(UrlProviderI baseData)
72   {
73     dataProvider = baseData;
74     data = baseData.getLinksForTable();
75     displayColumns = UrlLinkDisplay.getDisplayColumnNames();
76
77     // find the primary row
78     primaryRow = 0;
79     Iterator<UrlLinkDisplay> it = data.iterator();
80     while (it.hasNext())
81     {
82       if (it.next().getIsPrimary())
83       {
84         break;
85       }
86       else
87       {
88         primaryRow++;
89       }
90     }
91
92     // set up listener which updates data source when table changes
93     this.addTableModelListener(new TableModelListener()
94     {
95       @Override
96       public void tableChanged(TableModelEvent e)
97       {
98         try
99         {
100           // update the UrlProvider from data list
101           dataProvider.setUrlData(data);
102         } catch (IllegalArgumentException ex)
103         {
104           Cache.log.error(ex.getMessage());
105         }
106       }
107     });
108
109   }
110
111   @Override
112   public int getRowCount()
113   {
114     if (data == null)
115     {
116       return 0;
117     }
118     else
119     {
120       return data.size();
121     }
122   }
123
124   @Override
125   public int getColumnCount()
126   {
127     return displayColumns.size();
128   }
129
130   @Override
131   public Object getValueAt(int rowIndex, int columnIndex)
132   {
133     return data.get(rowIndex).getValue(columnIndex);
134   }
135
136   @Override
137   public boolean isCellEditable(int rowIndex, int columnIndex)
138   {
139     return data.get(rowIndex).isEditable(columnIndex);
140   }
141
142   /**
143    * Determine if a row is editable indirectly (rather than directly in table as
144    * in isCellEditable)
145    * 
146    * @param rowIndex
147    * @return true if row can be edited indirectly
148    */
149   public boolean isRowEditable(int rowIndex)
150   {
151     // to edit, row must be a user entered row
152     return (dataProvider.isUserEntry(data.get(rowIndex).getId()));
153   }
154
155   /**
156    * Determine if a row is deletable
157    * 
158    * @param rowIndex
159    *          the row to be tested
160    * @return true if row can be deleted
161    */
162   public boolean isRowDeletable(int rowIndex)
163   {
164     // to delete, row must be a user entered row, and not the default row
165     return (dataProvider.isUserEntry(data.get(rowIndex).getId()) && !data
166             .get(rowIndex).getIsPrimary());
167   }
168
169   @Override
170   public void setValueAt(Object aValue, int rowIndex, int columnIndex)
171   {
172     if (columnIndex == UrlLinkDisplay.PRIMARY)
173     {
174       // Default url column: exactly one row must always be true
175       if (rowIndex != primaryRow)
176       {
177         // selected row is not currently the default
178         // set the current default to false
179         data.get(primaryRow).setValue(columnIndex, false);
180         fireTableRowsUpdated(primaryRow, primaryRow);
181
182         // set the default to be the selected row
183         primaryRow = rowIndex;
184         data.get(rowIndex).setValue(columnIndex, aValue);
185
186         fireTableRowsUpdated(rowIndex, rowIndex);
187       }
188     }
189     else
190     {
191       data.get(rowIndex).setValue(columnIndex, aValue);
192       fireTableRowsUpdated(rowIndex, rowIndex);
193     }
194   }
195
196   @Override
197   public Class<?> getColumnClass(int columnIndex)
198   {
199     return getValueAt(0, columnIndex).getClass();
200   }
201
202   @Override
203   public String getColumnName(int columnIndex)
204   {
205     return displayColumns.get(columnIndex);
206   }
207
208   public void removeRow(int rowIndex)
209   {
210     // remove the row from data
211     data.remove(rowIndex);
212
213     // update default row
214     if (primaryRow > rowIndex)
215     {
216       primaryRow--;
217     }
218
219     // fire update which will update data source
220     fireTableRowsDeleted(rowIndex, rowIndex);
221   }
222
223   public int insertRow(String name, String url)
224   {
225     // add a row to the data
226     UrlLink link = new UrlLink(name, url, name);
227     UrlLinkDisplay u = new UrlLinkDisplay(name, link, true, false);
228     int index = data.size();
229     data.add(u);
230
231     // fire update which will update data source
232     fireTableRowsInserted(index, index);
233     return index;
234   }
235
236   public int getPrimaryColumn()
237   {
238     return UrlLinkDisplay.PRIMARY;
239   }
240
241   public int getNameColumn()
242   {
243     return UrlLinkDisplay.NAME;
244   }
245
246   public int getDatabaseColumn()
247   {
248     return UrlLinkDisplay.DATABASE;
249   }
250
251   public int getIdColumn()
252   {
253     return UrlLinkDisplay.ID;
254   }
255
256   public int getUrlColumn()
257   {
258     return UrlLinkDisplay.URL;
259   }
260
261   public int getSelectedColumn()
262   {
263     return UrlLinkDisplay.SELECTED;
264   }
265
266   public boolean isUserEntry(
267           Entry<? extends TableModel, ? extends Object> entry)
268   {
269     return dataProvider
270             .isUserEntry(entry.getStringValue(UrlLinkDisplay.ID));
271   }
272
273   public boolean isUniqueName(String name)
274   {
275     return !dataProvider.contains(name);
276   }
277 }