JAL-2668 fix broken factory method for colour scheme
[jalview.git] / src / jalview / gui / PaintRefresher.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 package jalview.gui;
22
23 import jalview.datamodel.AlignmentI;
24 import jalview.datamodel.SequenceI;
25
26 import java.awt.Component;
27 import java.util.ArrayList;
28 import java.util.HashMap;
29 import java.util.Iterator;
30 import java.util.List;
31 import java.util.Map;
32
33 /**
34  * Route datamodel/view update events for a sequence set to any display
35  * components involved TODO: JV3 refactor to abstract gui/view package
36  * 
37  * @author $author$
38  * @version $Revision$
39  */
40 public class PaintRefresher
41 {
42   static Map<String, List<Component>> components = new HashMap<String, List<Component>>();
43
44   /**
45    * Add the given component to those registered under the given sequence set
46    * id. Does nothing if already added.
47    * 
48    * @param comp
49    * @param al
50    */
51   public static void Register(Component comp, String seqSetId)
52   {
53     if (components.containsKey(seqSetId))
54     {
55       List<Component> comps = components.get(seqSetId);
56       if (!comps.contains(comp))
57       {
58         comps.add(comp);
59       }
60     }
61     else
62     {
63       List<Component> vcoms = new ArrayList<Component>();
64       vcoms.add(comp);
65       components.put(seqSetId, vcoms);
66     }
67   }
68
69   /**
70    * Remove this component from all registrations. Also removes a registered
71    * sequence set id if there are no remaining components registered against it.
72    * 
73    * @param comp
74    */
75   public static void RemoveComponent(Component comp)
76   {
77     if (components == null)
78     {
79       return;
80     }
81
82     Iterator<String> it = components.keySet().iterator();
83     while (it.hasNext())
84     {
85       List<Component> comps = components.get(it.next());
86       comps.remove(comp);
87       if (comps.isEmpty())
88       {
89         it.remove();
90       }
91     }
92   }
93
94   public static void Refresh(Component source, String id)
95   {
96     Refresh(source, id, false, false);
97   }
98
99   public static void Refresh(Component source, String id,
100           boolean alignmentChanged, boolean validateSequences)
101   {
102     List<Component> comps = components.get(id);
103
104     if (comps == null)
105     {
106       return;
107     }
108
109     for (Component comp : comps)
110     {
111       if (comp == source)
112       {
113         continue;
114       }
115
116       if (validateSequences && comp instanceof AlignmentPanel
117               && source instanceof AlignmentPanel)
118       {
119         validateSequences(((AlignmentPanel) source).av.getAlignment(),
120                 ((AlignmentPanel) comp).av.getAlignment());
121       }
122
123       if (comp instanceof AlignmentPanel && alignmentChanged)
124       {
125         ((AlignmentPanel) comp).alignmentChanged();
126       }
127
128       comp.repaint();
129     }
130   }
131
132   static void validateSequences(AlignmentI source, AlignmentI comp)
133   {
134     SequenceI[] a1;
135     if (source.getHiddenSequences().getSize() > 0)
136     {
137       a1 = source.getHiddenSequences().getFullAlignment()
138               .getSequencesArray();
139     }
140     else
141     {
142       a1 = source.getSequencesArray();
143     }
144
145     SequenceI[] a2;
146     if (comp.getHiddenSequences().getSize() > 0)
147     {
148       a2 = comp.getHiddenSequences().getFullAlignment().getSequencesArray();
149     }
150     else
151     {
152       a2 = comp.getSequencesArray();
153     }
154
155     int i, iSize = a1.length, j, jSize = a2.length;
156
157     if (iSize == jSize)
158     {
159       return;
160     }
161
162     boolean exists = false;
163     for (i = 0; i < iSize; i++)
164     {
165       exists = false;
166
167       for (j = 0; j < jSize; j++)
168       {
169         if (a2[j] == a1[i])
170         {
171           exists = true;
172           break;
173         }
174       }
175
176       if (!exists)
177       {
178         if (i < comp.getHeight())
179         {
180           // TODO: the following does not trigger any recalculation of
181           // height/etc, or maintain the dataset
182           if (comp.getDataset() != source.getDataset())
183           {
184             // raise an implementation warning here - not sure if this situation
185             // will ever occur
186             System.err.println(
187                     "IMPLEMENTATION PROBLEM: DATASET out of sync due to an insert whilst calling PaintRefresher.validateSequences(AlignmentI, ALignmentI)");
188           }
189           List<SequenceI> alsq;
190           synchronized (alsq = comp.getSequences())
191           {
192             alsq.add(i, a1[i]);
193           }
194         }
195         else
196         {
197           comp.addSequence(a1[i]);
198         }
199
200         if (comp.getHiddenSequences().getSize() > 0)
201         {
202           a2 = comp.getHiddenSequences().getFullAlignment()
203                   .getSequencesArray();
204         }
205         else
206         {
207           a2 = comp.getSequencesArray();
208         }
209
210         jSize = a2.length;
211       }
212     }
213
214     iSize = a1.length;
215     jSize = a2.length;
216
217     for (j = 0; j < jSize; j++)
218     {
219       exists = false;
220       for (i = 0; i < iSize; i++)
221       {
222         if (a2[j] == a1[i])
223         {
224           exists = true;
225           break;
226         }
227       }
228
229       if (!exists)
230       {
231         comp.deleteSequence(a2[j]);
232       }
233     }
234   }
235
236   static AlignmentPanel[] getAssociatedPanels(String id)
237   {
238     List<Component> comps = components.get(id);
239     if (comps == null)
240     {
241       return new AlignmentPanel[0];
242     }
243     List<AlignmentPanel> tmp = new ArrayList<AlignmentPanel>();
244     for (Component comp : comps)
245     {
246       if (comp instanceof AlignmentPanel)
247       {
248         tmp.add((AlignmentPanel) comp);
249       }
250     }
251     return tmp.toArray(new AlignmentPanel[tmp.size()]);
252   }
253
254 }