tidy imports
[jalview.git] / src / jalview / appletgui / AlignmentPanel.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
3  * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle
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 of the License, or (at your option) any later version.
10  * 
11  * Jalview is distributed in the hope that it will be useful, but 
12  * WITHOUT ANY WARRANTY; without even the implied warranty 
13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
14  * PURPOSE.  See the GNU General Public License for more details.
15  * 
16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 package jalview.appletgui;
19
20 import java.awt.*;
21 import java.awt.event.*;
22 import java.util.Hashtable;
23 import java.util.Vector;
24
25 import jalview.api.AlignmentViewPanel;
26 import jalview.datamodel.*;
27 import jalview.structure.StructureSelectionManager;
28
29 public class AlignmentPanel extends Panel implements AdjustmentListener, AlignmentViewPanel
30 {
31
32   public AlignViewport av;
33
34   OverviewPanel overviewPanel;
35
36   SeqPanel seqPanel;
37
38   IdPanel idPanel;
39
40   IdwidthAdjuster idwidthAdjuster;
41
42   public AlignFrame alignFrame;
43
44   ScalePanel scalePanel;
45
46   AnnotationPanel annotationPanel;
47
48   AnnotationLabels alabels;
49
50   // this value is set false when selection area being dragged
51   boolean fastPaint = true;
52   
53   public void finalize() {
54     alignFrame=null;
55     av=null;
56     seqPanel=null;
57     seqPanelHolder=null;
58     sequenceHolderPanel=null;
59     scalePanel=null;
60     scalePanelHolder=null;
61     annotationPanel=null;
62     annotationPanelHolder=null;
63     annotationSpaceFillerHolder=null;
64   }
65   public AlignmentPanel(AlignFrame af, final AlignViewport av)
66   {
67     try
68     {
69       jbInit();
70     } catch (Exception e)
71     {
72       e.printStackTrace();
73     }
74
75     alignFrame = af;
76     this.av = av;
77     seqPanel = new SeqPanel(av, this);
78     idPanel = new IdPanel(av, this);
79     scalePanel = new ScalePanel(av, this);
80     idwidthAdjuster = new IdwidthAdjuster(this);
81     annotationPanel = new AnnotationPanel(this);
82     annotationPanelHolder.add(annotationPanel, BorderLayout.CENTER);
83
84     sequenceHolderPanel.add(annotationPanelHolder, BorderLayout.SOUTH);
85
86     alabels = new AnnotationLabels(this);
87
88     setAnnotationVisible(av.showAnnotation);
89
90     idPanelHolder.add(idPanel, BorderLayout.CENTER);
91     idSpaceFillerPanel1.add(idwidthAdjuster, BorderLayout.CENTER);
92     annotationSpaceFillerHolder.add(alabels, BorderLayout.CENTER);
93     scalePanelHolder.add(scalePanel, BorderLayout.CENTER);
94     seqPanelHolder.add(seqPanel, BorderLayout.CENTER);
95
96     fontChanged();
97     setScrollValues(0, 0);
98
99     apvscroll.addAdjustmentListener(this);
100     hscroll.addAdjustmentListener(this);
101     vscroll.addAdjustmentListener(this);
102
103     addComponentListener(new ComponentAdapter()
104     {
105       public void componentResized(ComponentEvent evt)
106       {
107         setScrollValues(av.getStartRes(), av.getStartSeq());
108         if (getSize().height>0 && annotationPanelHolder.getSize().height>0) {
109           validateAnnotationDimensions(false);
110         }
111         repaint();
112       }
113       
114     });
115
116     Dimension d = calculateIdWidth();
117     idPanel.idCanvas.setSize(d);
118
119     hscrollFillerPanel.setSize(d.width, annotationPanel.getSize().height);
120
121     idPanel.idCanvas.setSize(d.width, seqPanel.seqCanvas.getSize().height);
122     annotationSpaceFillerHolder.setSize(d.width,
123             annotationPanel.getSize().height);
124     alabels.setSize(d.width, annotationPanel.getSize().height);
125     final AlignmentPanel ap = this;
126     av.addPropertyChangeListener(new java.beans.PropertyChangeListener()
127     {
128       public void propertyChange(java.beans.PropertyChangeEvent evt)
129       {
130         if (evt.getPropertyName().equals("alignment"))
131         {
132           PaintRefresher.Refresh(ap, av.getSequenceSetId(), true, true);
133           alignmentChanged();
134         }
135       }
136     });
137
138   }
139
140   public SequenceRenderer getSequenceRenderer()
141   {
142     return seqPanel.seqCanvas.sr;
143   }
144
145   public FeatureRenderer getFeatureRenderer()
146   {
147     return seqPanel.seqCanvas.fr;
148   }
149
150   public void alignmentChanged()
151   {
152     av.alignmentChanged(this);
153
154     if (overviewPanel != null)
155     {
156       overviewPanel.updateOverviewImage();
157     }
158
159     alignFrame.updateEditMenuBar();
160
161     repaint();
162   }
163
164   public void fontChanged()
165   {
166     // set idCanvas bufferedImage to null
167     // to prevent drawing old image
168     idPanel.idCanvas.image = null;
169     FontMetrics fm = getFontMetrics(av.getFont());
170
171     scalePanel.setSize(new Dimension(10, av.charHeight + fm.getDescent()));
172     idwidthAdjuster.setSize(new Dimension(10, av.charHeight
173             + fm.getDescent()));
174     av.updateSequenceIdColours();
175     annotationPanel.image = null;
176     int ap = annotationPanel.adjustPanelHeight(false);
177     Dimension d = calculateIdWidth();
178     d.setSize(d.width + 4, seqPanel.seqCanvas.getSize().height);
179     alabels.setSize(d.width + 4, ap);
180     
181     idPanel.idCanvas.setSize(d);
182     hscrollFillerPanel.setSize(d);
183     
184     validateAnnotationDimensions(false);
185     annotationPanel.repaint();
186     validate();
187     repaint();
188
189     if (overviewPanel != null)
190     {
191       overviewPanel.updateOverviewImage();
192     }
193   }
194
195   public void setIdWidth(int w, int h)
196   {
197     idPanel.idCanvas.setSize(w, h);
198     idPanelHolder.setSize(w, idPanelHolder.getSize().height);
199     annotationSpaceFillerHolder.setSize(w,annotationSpaceFillerHolder.getSize().height);
200     alabels.setSize(w, alabels.getSize().height);
201     validate();
202   }
203
204   Dimension calculateIdWidth()
205   {
206     if (av.nullFrame == null)
207     {
208       av.nullFrame = new Frame();
209       av.nullFrame.addNotify();
210     }
211
212     Graphics g = av.nullFrame.getGraphics();
213
214     FontMetrics fm = g.getFontMetrics(av.font);
215     AlignmentI al = av.getAlignment();
216
217     int i = 0;
218     int idWidth = 0;
219     String id;
220     while (i < al.getHeight() && al.getSequenceAt(i) != null)
221     {
222       SequenceI s = al.getSequenceAt(i);
223       id = s.getDisplayId(av.getShowJVSuffix());
224
225       if (fm.stringWidth(id) > idWidth)
226       {
227         idWidth = fm.stringWidth(id);
228       }
229       i++;
230     }
231
232     // Also check annotation label widths
233     i = 0;
234     if (al.getAlignmentAnnotation() != null)
235     {
236       fm = g.getFontMetrics(av.nullFrame.getFont());
237       while (i < al.getAlignmentAnnotation().length)
238       {
239         String label = al.getAlignmentAnnotation()[i].label;
240         if (fm.stringWidth(label) > idWidth)
241         {
242           idWidth = fm.stringWidth(label);
243         }
244         i++;
245       }
246     }
247
248     return new Dimension(idWidth, idPanel.idCanvas.getSize().height);
249   }
250
251   /**
252    * Highlight the given results on the alignment.
253    * 
254    */
255   public void highlightSearchResults(SearchResults results)
256   {
257     scrollToPosition(results);
258     seqPanel.seqCanvas.highlightSearchResults(results);
259   }
260
261   /**
262    * scroll the view to show the position of the highlighted region in results
263    * (if any) and redraw the overview
264    * 
265    * @param results
266    * @return false if results were not found
267    */
268   public boolean scrollToPosition(SearchResults results)
269   {
270     return scrollToPosition(results, true);
271   }
272
273   /**
274    * scroll the view to show the position of the highlighted region in results
275    * (if any)
276    * 
277    * @param results
278    * @param redrawOverview
279    *          - when set, the overview will be recalculated (takes longer)
280    * @return false if results were not found
281    */
282   public boolean scrollToPosition(SearchResults results,
283           boolean redrawOverview)
284   {
285           
286     // do we need to scroll the panel?
287     if (results != null && results.getSize() > 0)
288     {
289       AlignmentI alignment=av.getAlignment();
290       int seqIndex = alignment.findIndex(results);
291       if (seqIndex == -1)
292       {
293         return false;
294       }
295       SequenceI seq = alignment.getSequenceAt(seqIndex);
296       int[] r = results.getResults(seq, 0,alignment.getWidth());
297       if (r == null)
298       {
299         if (av.applet.debug) {// DEBUG
300           System.out.println("DEBUG: scroll didn't happen - results not within alignment : "+seq.getStart()+","+seq.getEnd());
301         }
302         return false;
303       }
304       if (av.applet.debug) {
305         // DEBUG
306         /*System.out.println("DEBUG: scroll: start=" + r[0]
307                 + " av.getStartRes()=" + av.getStartRes() + " end=" + r[1]
308                 + " seq.end=" + seq.getEnd() + " av.getEndRes()="
309                 + av.getEndRes() + " hextent=" + hextent);
310          */
311       }
312       int start = r[0];
313       int end = r[1];
314       if (start < 0)
315       {
316         return false;
317       }
318       if (end == seq.getEnd())
319       {
320         return false;
321       }
322       return scrollTo(start, end, seqIndex, false, redrawOverview);
323     }
324     return true;
325   }
326   public boolean scrollTo(int ostart, int end, int seqIndex, boolean scrollToNearest, boolean redrawOverview)
327   {
328             int startv, endv, starts, ends, width;
329
330           int start=-1;
331     if (av.hasHiddenColumns())
332     {
333       start = av.getColumnSelection().findColumnPosition(ostart);
334       end = av.getColumnSelection().findColumnPosition(end);
335       if (start == end)
336       {
337         if (!scrollToNearest && !av.getColumnSelection().isVisible(ostart))
338         {
339           // don't scroll - position isn't visible
340           return false;
341         }
342       }
343     }
344     else
345     {
346       start = ostart;
347     }
348     if (!av.wrapAlignment)
349     {
350           /*
351           int spos=av.getStartRes(),sqpos=av.getStartSeq();
352           if ((startv = av.getStartRes()) >= start)
353           {
354                   spos=start-1;
355 //                seqIn
356 //            setScrollValues(start - 1, seqIndex);
357           }
358           else if ((endv = av.getEndRes()) <= end)
359           {
360 //            setScrollValues(spos=startv + 1 + end - endv, seqIndex);
361                   spos=startv + 1 + end - endv;
362           }
363           else if ((starts = av.getStartSeq()) > seqIndex)
364           {
365             setScrollValues(av.getStartRes(), seqIndex);
366           }
367           else if ((ends = av.getEndSeq()) <= seqIndex)
368           {
369             setScrollValues(av.getStartRes(), starts + seqIndex - ends + 1);
370           }
371
372           /* */
373         if ((av.getStartRes() > end)
374                 || (av.getEndRes() < start)
375                 || ((av.getStartSeq() > seqIndex) || (av.getEndSeq() < seqIndex)))
376         {
377           if (start > av.getAlignment().getWidth() - hextent)
378           {
379             start = av.getAlignment().getWidth() - hextent;
380             if (start < 0)
381             {
382               start = 0;
383             }
384
385           }
386           if (seqIndex > av.getAlignment().getHeight() - vextent)
387           {
388             seqIndex = av.getAlignment().getHeight() - vextent;
389             if (seqIndex < 0)
390             {
391               seqIndex = 0;
392             }
393           }
394           // System.out.println("trying to scroll to: "+start+" "+seqIndex);
395           setScrollValues(start, seqIndex);
396         }/**/
397       }
398       else
399       {
400         scrollToWrappedVisible(start);
401       }
402     if (redrawOverview && overviewPanel != null)
403     {
404       overviewPanel.setBoxPosition();
405     }
406     paintAlignment(redrawOverview);
407     return true;
408   }
409
410   void scrollToWrappedVisible(int res)
411   {
412     int cwidth = seqPanel.seqCanvas
413             .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
414     if (res <= av.getStartRes() || res >= (av.getStartRes() + cwidth))
415     {
416       vscroll.setValue(res / cwidth);
417       av.startRes = vscroll.getValue() * cwidth;
418     }
419   }
420
421   public OverviewPanel getOverviewPanel()
422   {
423     return overviewPanel;
424   }
425
426   public void setOverviewPanel(OverviewPanel op)
427   {
428     overviewPanel = op;
429   }
430
431   public void setAnnotationVisible(boolean b)
432   {
433     if (!av.wrapAlignment)
434     {
435       annotationSpaceFillerHolder.setVisible(b);
436       annotationPanelHolder.setVisible(b);
437     }
438     validate();
439     repaint();
440   }
441   
442   /**
443    * automatically adjust annotation panel height for new annotation whilst
444    * ensuring the alignment is still visible.
445    */
446   public void adjustAnnotationHeight()
447   {
448     // TODO: display vertical annotation scrollbar if necessary
449     // this is called after loading new annotation onto alignment
450     if (alignFrame.getSize().height == 0)
451     {
452       System.out.println("NEEDS FIXING");
453     }
454     fontChanged();
455     validateAnnotationDimensions(true);
456     apvscroll.addNotify();
457     hscroll.addNotify();
458     validate();
459     paintAlignment(true);
460   }
461   /**
462    * calculate the annotation dimensions and refresh slider values accordingly.
463    * need to do repaints/notifys afterwards. 
464    */
465   protected void validateAnnotationDimensions(boolean adjustPanelHeight) {
466     boolean modified=false;
467     int height = annotationPanel.calcPanelHeight();
468     int minsize=0;
469     if (hscroll.isVisible())
470     {
471       height += (minsize=hscroll.getPreferredSize().height);
472     }
473     if (apvscroll.isVisible()) {
474       minsize+=apvscroll.getPreferredSize().height;
475     }
476     int mheight = height;
477     Dimension d=sequenceHolderPanel.getSize(),e=idPanel.getSize(); 
478     int seqandannot=d.height-scalePanelHolder.getSize().height;
479     // sets initial preferred height
480     if ((height+40) > seqandannot / 2)
481     {
482       height = seqandannot / 2;
483     }
484     if (!adjustPanelHeight)
485     {
486       // maintain same window layout whilst updating sliders
487       height=annotationPanelHolder.getSize().height;
488     }
489             
490     if (seqandannot-height<5)
491     {
492       height = seqandannot;
493     }
494     annotationPanel.setSize(new Dimension(d.width,height));
495     alabels.setSize(new Dimension(e.width,height));
496     annotationSpaceFillerHolder.setSize(new Dimension(e.width, height));
497     annotationPanelHolder.setSize(new Dimension(d.width, height));
498     seqPanelHolder.setSize(d.width,seqandannot-height);
499     seqPanel.seqCanvas.setSize(d.width, seqPanel.seqCanvas.getSize().height);
500     int s=apvscroll.getValue();
501     if (s>mheight-height)
502     {
503       s = 0;
504     }
505     apvscroll.setValues(s, height, 0, mheight);
506     annotationPanel.setScrollOffset(apvscroll.getValue());
507     alabels.setScrollOffset(apvscroll.getValue());
508   }
509   
510   public void setWrapAlignment(boolean wrap)
511   {
512     av.startSeq = 0;
513     av.startRes = 0;
514     scalePanelHolder.setVisible(!wrap);
515
516     hscroll.setVisible(!wrap);
517     idwidthAdjuster.setVisible(!wrap);
518
519     if (wrap)
520     {
521       annotationPanelHolder.setVisible(false);
522       annotationSpaceFillerHolder.setVisible(false);
523     }
524     else if (av.showAnnotation)
525     {
526       annotationPanelHolder.setVisible(true);
527       annotationSpaceFillerHolder.setVisible(true);
528     }
529
530     idSpaceFillerPanel1.setVisible(!wrap);
531
532     fontChanged(); // This is so that the scalePanel is resized correctly
533
534     validate();
535     repaint();
536
537   }
538
539   int hextent = 0;
540
541   int vextent = 0;
542
543   // return value is true if the scroll is valid
544   public boolean scrollUp(boolean up)
545   {
546     if (up)
547     {
548       if (vscroll.getValue() < 1)
549       {
550         return false;
551       }
552       setScrollValues(hscroll.getValue(), vscroll.getValue() - 1);
553     }
554     else
555     {
556       if (vextent + vscroll.getValue() >= av.getAlignment().getHeight())
557       {
558         return false;
559       }
560       setScrollValues(hscroll.getValue(), vscroll.getValue() + 1);
561     }
562
563     repaint();
564     return true;
565   }
566
567   public boolean scrollRight(boolean right)
568   {
569     if (!right)
570     {
571       if (hscroll.getValue() < 1)
572       {
573         return false;
574       }
575       setScrollValues(hscroll.getValue() - 1, vscroll.getValue());
576     }
577     else
578     {
579       if (hextent + hscroll.getValue() >= av.getAlignment().getWidth())
580       {
581         return false;
582       }
583       setScrollValues(hscroll.getValue() + 1, vscroll.getValue());
584     }
585
586     repaint();
587     return true;
588   }
589
590   public void setScrollValues(int x, int y)
591   {
592     int width = av.getAlignment().getWidth();
593     int height = av.getAlignment().getHeight();
594
595     if (av.hasHiddenColumns())
596     {
597       width = av.getColumnSelection().findColumnPosition(width);
598     }
599     if (x<0) { x = 0; };
600
601     hextent = seqPanel.seqCanvas.getSize().width / av.charWidth;
602     vextent = seqPanel.seqCanvas.getSize().height / av.charHeight;
603     
604     if (hextent > width)
605     {
606       hextent = width;
607     }
608
609     if (vextent > height)
610     {
611       vextent = height;
612     }
613
614     if ((hextent + x) > width)
615     {
616       System.err.println("hextent was "+hextent+" and x was "+x);
617
618       x = width - hextent;
619     }
620
621     if ((vextent + y) > height)
622     {
623       y = height - vextent;
624     }
625
626     if (y < 0)
627     {
628       y = 0;
629     }
630
631     if (x < 0)
632     {
633       System.err.println("x was "+x);
634       x = 0;
635     }
636
637     av.setStartSeq(y);
638
639     int endSeq = y + vextent;
640     if (endSeq > av.getAlignment().getHeight())
641     {
642       endSeq = av.getAlignment().getHeight();
643     }
644
645     av.setEndSeq(endSeq);
646     av.setStartRes(x);
647     av.setEndRes((x + (seqPanel.seqCanvas.getSize().width / av.charWidth)) - 1);
648
649     hscroll.setValues(x, hextent, 0, width);
650     vscroll.setValues(y, vextent, 0, height);
651
652     if (overviewPanel != null)
653     {
654       overviewPanel.setBoxPosition();
655     }
656     sendViewPosition();
657
658
659   }
660
661   public void adjustmentValueChanged(AdjustmentEvent evt)
662   {
663     int oldX = av.getStartRes();
664     int oldY = av.getStartSeq();
665
666     if (evt == null || evt.getSource() == apvscroll)
667     {
668       annotationPanel.setScrollOffset(apvscroll.getValue());
669       alabels.setScrollOffset(apvscroll.getValue());
670       // annotationPanel.image=null;
671       // alabels.image=null;
672       // alabels.repaint();
673       // annotationPanel.repaint();
674     }
675     if (evt == null || evt.getSource() == hscroll)
676     {
677       int x = hscroll.getValue();
678       av.setStartRes(x);
679       av.setEndRes(x + seqPanel.seqCanvas.getSize().width
680               / av.getCharWidth() - 1);
681     }
682
683     if (evt == null || evt.getSource() == vscroll)
684     {
685       int offy = vscroll.getValue();
686       if (av.getWrapAlignment())
687       {
688         int rowSize = seqPanel.seqCanvas
689                 .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
690         av.setStartRes(vscroll.getValue() * rowSize);
691         av.setEndRes((vscroll.getValue() + 1) * rowSize);
692       }
693       else
694       {
695         av.setStartSeq(offy);
696         av.setEndSeq(offy + seqPanel.seqCanvas.getSize().height
697                 / av.getCharHeight());
698       }
699     }
700
701     if (overviewPanel != null)
702     {
703       overviewPanel.setBoxPosition();
704     }
705
706     int scrollX = av.startRes - oldX;
707     int scrollY = av.startSeq - oldY;
708
709     if (av.getWrapAlignment() || !fastPaint || av.MAC)
710     {
711       repaint();
712     }
713     else
714     {
715       // Make sure we're not trying to draw a panel
716       // larger than the visible window
717       if (scrollX > av.endRes - av.startRes)
718       {
719         scrollX = av.endRes - av.startRes;
720       }
721       else if (scrollX < av.startRes - av.endRes)
722       {
723         scrollX = av.startRes - av.endRes;
724       }
725
726       idPanel.idCanvas.fastPaint(scrollY);
727       seqPanel.seqCanvas.fastPaint(scrollX, scrollY);
728
729       scalePanel.repaint();
730       if (av.getShowAnnotation())
731       {
732         annotationPanel.fastPaint(av.getStartRes() - oldX);
733       }
734     }
735     sendViewPosition();
736
737   }
738   private void sendViewPosition()
739   {
740     StructureSelectionManager.getStructureSelectionManager(av.applet).sendViewPosition(this, av.startRes, av.endRes, av.startSeq, av.endSeq);
741   }
742
743   public void paintAlignment(boolean updateOverview)
744   {
745     repaint();
746
747     if (updateOverview)
748     {
749       jalview.structure.StructureSelectionManager
750               .getStructureSelectionManager(av.applet).sequenceColoursChanged(this);
751
752       if (overviewPanel != null)
753       {
754         overviewPanel.updateOverviewImage();
755       }
756     }
757   }
758
759   public void update(Graphics g)
760   {
761     paint(g);
762   }
763
764   public void paint(Graphics g)
765   {
766     invalidate();
767     Dimension d = idPanel.idCanvas.getSize();
768     idPanel.idCanvas.setSize(d.width, seqPanel.seqCanvas.getSize().height);
769     
770     if (av.getWrapAlignment())
771     {
772       int maxwidth = av.getAlignment().getWidth();
773
774       if (av.hasHiddenColumns())
775       {
776         maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
777       }
778
779       int canvasWidth = seqPanel.seqCanvas
780               .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
781
782       if (canvasWidth > 0)
783       {
784         int max = maxwidth / canvasWidth;
785         vscroll.setMaximum(1 + max);
786         vscroll.setUnitIncrement(1);
787         vscroll.setVisibleAmount(1);
788       }
789     }
790     else
791     {
792       setScrollValues(av.getStartRes(), av.getStartSeq());
793     }
794
795     alabels.repaint();
796
797     seqPanel.seqCanvas.repaint();
798     scalePanel.repaint();
799     annotationPanel.repaint();
800     idPanel.idCanvas.repaint();
801   }
802
803   protected Panel sequenceHolderPanel = new Panel();
804
805   protected Scrollbar vscroll = new Scrollbar();
806
807   protected Scrollbar hscroll = new Scrollbar();
808
809   protected Panel seqPanelHolder = new Panel();
810
811   BorderLayout borderLayout1 = new BorderLayout();
812
813   BorderLayout borderLayout3 = new BorderLayout();
814
815   protected Panel scalePanelHolder = new Panel();
816
817   protected Panel idPanelHolder = new Panel();
818
819   BorderLayout borderLayout5 = new BorderLayout();
820
821   protected Panel idSpaceFillerPanel1 = new Panel();
822
823   public Panel annotationSpaceFillerHolder = new Panel();
824
825   BorderLayout borderLayout6 = new BorderLayout();
826
827   BorderLayout borderLayout7 = new BorderLayout();
828
829   Panel hscrollHolder = new Panel();
830
831   BorderLayout borderLayout10 = new BorderLayout();
832
833   protected Panel hscrollFillerPanel = new Panel();
834
835   BorderLayout borderLayout11 = new BorderLayout();
836
837   BorderLayout borderLayout4 = new BorderLayout();
838
839   BorderLayout borderLayout2 = new BorderLayout();
840
841   Panel annotationPanelHolder = new Panel();
842
843   protected Scrollbar apvscroll = new Scrollbar();
844
845   BorderLayout borderLayout12 = new BorderLayout();
846
847   private void jbInit() throws Exception
848   {
849     // idPanelHolder.setPreferredSize(new Dimension(70, 10));
850     this.setLayout(borderLayout7);
851
852     //sequenceHolderPanel.setPreferredSize(new Dimension(150, 150));
853     sequenceHolderPanel.setLayout(borderLayout3);
854     seqPanelHolder.setLayout(borderLayout1);
855     scalePanelHolder.setBackground(Color.white);
856
857     // scalePanelHolder.setPreferredSize(new Dimension(10, 30));
858     scalePanelHolder.setLayout(borderLayout6);
859     idPanelHolder.setLayout(borderLayout5);
860     idSpaceFillerPanel1.setBackground(Color.white);
861
862     // idSpaceFillerPanel1.setPreferredSize(new Dimension(10, 30));
863     idSpaceFillerPanel1.setLayout(borderLayout11);
864     annotationSpaceFillerHolder.setBackground(Color.white);
865
866     // annotationSpaceFillerHolder.setPreferredSize(new Dimension(10, 80));
867     annotationSpaceFillerHolder.setLayout(borderLayout4);
868     hscroll.setOrientation(Scrollbar.HORIZONTAL);
869     hscrollHolder.setLayout(borderLayout10);
870     hscrollFillerPanel.setBackground(Color.white);
871     apvscroll.setOrientation(Scrollbar.VERTICAL);
872     apvscroll.setVisible(true);
873     apvscroll.addAdjustmentListener(this);
874
875     annotationPanelHolder.setBackground(Color.white);
876     annotationPanelHolder.setLayout(borderLayout12);
877     annotationPanelHolder.add(apvscroll, BorderLayout.EAST);
878     // hscrollFillerPanel.setPreferredSize(new Dimension(70, 10));
879     hscrollHolder.setBackground(Color.white);
880
881     // annotationScroller.setPreferredSize(new Dimension(10, 80));
882     // this.setPreferredSize(new Dimension(220, 166));
883     seqPanelHolder.setBackground(Color.white);
884     idPanelHolder.setBackground(Color.white);
885     sequenceHolderPanel.add(scalePanelHolder, BorderLayout.NORTH);
886     sequenceHolderPanel.add(seqPanelHolder, BorderLayout.CENTER);
887     seqPanelHolder.add(vscroll, BorderLayout.EAST);
888
889     // Panel3.add(secondaryPanelHolder, BorderLayout.SOUTH);
890     this.add(idPanelHolder, BorderLayout.WEST);
891     idPanelHolder.add(idSpaceFillerPanel1, BorderLayout.NORTH);
892     idPanelHolder.add(annotationSpaceFillerHolder, BorderLayout.SOUTH);
893     this.add(hscrollHolder, BorderLayout.SOUTH);
894     hscrollHolder.add(hscroll, BorderLayout.CENTER);
895     hscrollHolder.add(hscrollFillerPanel, BorderLayout.WEST);
896     this.add(sequenceHolderPanel, BorderLayout.CENTER);
897   }
898
899   /**
900    * hides or shows dynamic annotation rows based on groups and av state flags
901    */
902   public void updateAnnotation()
903   {
904     updateAnnotation(false);
905   }
906
907   public void updateAnnotation(boolean applyGlobalSettings)
908   {
909     // TODO: this should be merged with other annotation update stuff - that
910     // sits on AlignViewport
911     boolean updateCalcs = false;
912     boolean conv = av.isShowGroupConservation();
913     boolean cons = av.isShowGroupConsensus();
914     boolean showprf = av.isShowSequenceLogo();
915     boolean showConsHist = av.isShowConsensusHistogram();
916
917     boolean sortg = true;
918
919     // remove old automatic annotation
920     // add any new annotation
921
922     Vector gr = av.getAlignment().getGroups(); // OrderedBy(av.alignment.getSequencesArray());
923     // intersect alignment annotation with alignment groups
924
925     AlignmentAnnotation[] aan = av.getAlignment().getAlignmentAnnotation();
926     Hashtable oldrfs = new Hashtable();
927     if (aan != null)
928     {
929       for (int an = 0; an < aan.length; an++)
930       {
931         if (aan[an].autoCalculated && aan[an].groupRef != null)
932         {
933           oldrfs.put(aan[an].groupRef, aan[an].groupRef);
934           av.getAlignment().deleteAnnotation(aan[an]);
935           aan[an] = null;
936         }
937       }
938     }
939     SequenceGroup sg;
940     if (gr != null)
941     {
942       for (int g = 0; g < gr.size(); g++)
943       {
944         updateCalcs = false;
945         sg = (SequenceGroup) gr.elementAt(g);
946         if (applyGlobalSettings || !oldrfs.containsKey(sg))
947         {
948           // set defaults for this group's conservation/consensus
949           sg.setshowSequenceLogo(showprf);
950           sg.setShowConsensusHistogram(showConsHist);
951         }
952         if (conv)
953         {
954           updateCalcs = true;
955           av.getAlignment().addAnnotation(sg.getConservationRow(), 0);
956         }
957         if (cons)
958         {
959           updateCalcs = true;
960           av.getAlignment().addAnnotation(sg.getConsensus(), 0);
961         }
962         // refresh the annotation rows
963         if (updateCalcs)
964         {
965           sg.recalcConservation();
966         }
967       }
968     }
969     oldrfs.clear();
970     adjustAnnotationHeight();
971   }
972
973   @Override
974   public AlignmentI getAlignment()
975   {
976     return av.getAlignment();
977   }
978   @Override
979   public StructureSelectionManager getStructureSelectionManager()
980   {
981     return StructureSelectionManager.getStructureSelectionManager(av.applet);
982   }
983   @Override
984   public void raiseOOMWarning(String string, OutOfMemoryError error)
985   {
986     // TODO: JAL-960
987     System.err.println("Out of memory whilst '"+string+"'");
988     error.printStackTrace();
989   }
990
991 }