Merge branch 'releases/Release_2_11_4_Branch'
[jalview.git] / gui / AnnotationPanel.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.AlignmentAnnotation;
24 import jalview.datamodel.Annotation;
25 import jalview.datamodel.ColumnSelection;
26 import jalview.datamodel.SequenceI;
27 import jalview.renderer.AnnotationRenderer;
28 import jalview.renderer.AwtRenderPanelI;
29 import jalview.util.MessageManager;
30
31 import java.awt.AlphaComposite;
32 import java.awt.Color;
33 import java.awt.Dimension;
34 import java.awt.FontMetrics;
35 import java.awt.Graphics;
36 import java.awt.Graphics2D;
37 import java.awt.Image;
38 import java.awt.Rectangle;
39 import java.awt.RenderingHints;
40 import java.awt.event.ActionEvent;
41 import java.awt.event.ActionListener;
42 import java.awt.event.AdjustmentEvent;
43 import java.awt.event.AdjustmentListener;
44 import java.awt.event.MouseEvent;
45 import java.awt.event.MouseListener;
46 import java.awt.event.MouseMotionListener;
47 import java.awt.event.MouseWheelEvent;
48 import java.awt.event.MouseWheelListener;
49 import java.awt.image.BufferedImage;
50
51 import javax.swing.JColorChooser;
52 import javax.swing.JMenuItem;
53 import javax.swing.JOptionPane;
54 import javax.swing.JPanel;
55 import javax.swing.JPopupMenu;
56 import javax.swing.Scrollable;
57 import javax.swing.ToolTipManager;
58
59 /**
60  * AnnotationPanel displays visible portion of annotation rows below unwrapped
61  * alignment
62  * 
63  * @author $author$
64  * @version $Revision$
65  */
66 public class AnnotationPanel extends JPanel implements AwtRenderPanelI,
67         MouseListener, MouseWheelListener, MouseMotionListener,
68         ActionListener, AdjustmentListener, Scrollable
69 {
70   String HELIX = MessageManager.getString("label.helix");
71
72   String SHEET = MessageManager.getString("label.sheet");
73
74   /**
75    * For RNA secondary structure "stems" aka helices
76    */
77   String STEM = MessageManager.getString("label.rna_helix");
78
79   String LABEL = MessageManager.getString("label.label");
80
81   String REMOVE = MessageManager.getString("label.remove_annotation");
82
83   String COLOUR = MessageManager.getString("action.colour");
84
85   public final Color HELIX_COLOUR = Color.red.darker();
86
87   public final Color SHEET_COLOUR = Color.green.darker().darker();
88
89   public final Color STEM_COLOUR = Color.blue.darker();
90
91   /** DOCUMENT ME!! */
92   public AlignViewport av;
93
94   AlignmentPanel ap;
95
96   public int activeRow = -1;
97
98   public BufferedImage image;
99
100   public volatile BufferedImage fadedImage;
101
102   Graphics2D gg;
103
104   public FontMetrics fm;
105
106   public int imgWidth = 0;
107
108   boolean fastPaint = false;
109
110   // Used For mouse Dragging and resizing graphs
111   int graphStretch = -1;
112
113   int graphStretchY = -1;
114
115   int min; // used by mouseDragged to see if user
116
117   int max; // used by mouseDragged to see if user
118
119   boolean mouseDragging = false;
120
121   boolean MAC = false;
122
123   // for editing cursor
124   int cursorX = 0;
125
126   int cursorY = 0;
127
128   public final AnnotationRenderer renderer;
129
130   private MouseWheelListener[] _mwl;
131
132   /**
133    * Creates a new AnnotationPanel object.
134    * 
135    * @param ap
136    *          DOCUMENT ME!
137    */
138   public AnnotationPanel(AlignmentPanel ap)
139   {
140
141     MAC = jalview.util.Platform.isAMac();
142
143     ToolTipManager.sharedInstance().registerComponent(this);
144     ToolTipManager.sharedInstance().setInitialDelay(0);
145     ToolTipManager.sharedInstance().setDismissDelay(10000);
146     this.ap = ap;
147     av = ap.av;
148     this.setLayout(null);
149     addMouseListener(this);
150     addMouseMotionListener(this);
151     ap.annotationScroller.getVerticalScrollBar()
152             .addAdjustmentListener(this);
153     // save any wheel listeners on the scroller, so we can propagate scroll
154     // events to them.
155     _mwl = ap.annotationScroller.getMouseWheelListeners();
156     // and then set our own listener to consume all mousewheel events
157     ap.annotationScroller.addMouseWheelListener(this);
158     renderer = new AnnotationRenderer();
159   }
160
161   public AnnotationPanel(AlignViewport av)
162   {
163     this.av = av;
164     renderer = new AnnotationRenderer();
165   }
166
167   @Override
168   public void mouseWheelMoved(MouseWheelEvent e)
169   {
170     if (e.isShiftDown())
171     {
172       e.consume();
173       if (e.getWheelRotation() > 0)
174       {
175         ap.scrollRight(true);
176       }
177       else
178       {
179         ap.scrollRight(false);
180       }
181     }
182     else
183     {
184       // TODO: find the correct way to let the event bubble up to
185       // ap.annotationScroller
186       for (MouseWheelListener mwl : _mwl)
187       {
188         if (mwl != null)
189         {
190           mwl.mouseWheelMoved(e);
191         }
192         if (e.isConsumed())
193         {
194           break;
195         }
196       }
197     }
198   }
199
200   @Override
201   public Dimension getPreferredScrollableViewportSize()
202   {
203     return getPreferredSize();
204   }
205
206   @Override
207   public int getScrollableBlockIncrement(Rectangle visibleRect,
208           int orientation, int direction)
209   {
210     return 30;
211   }
212
213   @Override
214   public boolean getScrollableTracksViewportHeight()
215   {
216     return false;
217   }
218
219   @Override
220   public boolean getScrollableTracksViewportWidth()
221   {
222     return true;
223   }
224
225   @Override
226   public int getScrollableUnitIncrement(Rectangle visibleRect,
227           int orientation, int direction)
228   {
229     return 30;
230   }
231
232   /*
233    * (non-Javadoc)
234    * 
235    * @see
236    * java.awt.event.AdjustmentListener#adjustmentValueChanged(java.awt.event
237    * .AdjustmentEvent)
238    */
239   @Override
240   public void adjustmentValueChanged(AdjustmentEvent evt)
241   {
242     // update annotation label display
243     ap.getAlabels().setScrollOffset(-evt.getValue());
244   }
245
246   /**
247    * Calculates the height of the annotation displayed in the annotation panel.
248    * Callers should normally call the ap.adjustAnnotationHeight method to ensure
249    * all annotation associated components are updated correctly.
250    * 
251    */
252   public int adjustPanelHeight()
253   {
254     int height = av.calcPanelHeight();
255     this.setPreferredSize(new Dimension(1, height));
256     if (ap != null)
257     {
258       // revalidate only when the alignment panel is fully constructed
259       ap.validate();
260     }
261
262     return height;
263   }
264
265   /**
266    * DOCUMENT ME!
267    * 
268    * @param evt
269    *          DOCUMENT ME!
270    */
271   @Override
272   public void actionPerformed(ActionEvent evt)
273   {
274     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
275     if (aa == null)
276     {
277       return;
278     }
279     Annotation[] anot = aa[activeRow].annotations;
280
281     if (anot.length < av.getColumnSelection().getMax())
282     {
283       Annotation[] temp = new Annotation[av.getColumnSelection().getMax() + 2];
284       System.arraycopy(anot, 0, temp, 0, anot.length);
285       anot = temp;
286       aa[activeRow].annotations = anot;
287     }
288
289     if (evt.getActionCommand().equals(REMOVE))
290     {
291       for (int sel : av.getColumnSelection().getSelected())
292       {
293         anot[sel] = null;
294       }
295     }
296     else if (evt.getActionCommand().equals(LABEL))
297     {
298       String exMesg = collectAnnotVals(anot, LABEL);
299       String label = JOptionPane.showInputDialog(this,
300               MessageManager.getString("label.enter_label"), exMesg);
301
302       if (label == null)
303       {
304         return;
305       }
306
307       if ((label.length() > 0) && !aa[activeRow].hasText)
308       {
309         aa[activeRow].hasText = true;
310       }
311
312       for (int index : av.getColumnSelection().getSelected())
313       {
314         if (!av.getColumnSelection().isVisible(index))
315         {
316           continue;
317         }
318
319         if (anot[index] == null)
320         {
321           anot[index] = new Annotation(label, "", ' ', 0); // TODO: verify that
322           // null exceptions
323           // aren't raised
324           // elsewhere.
325         }
326         else
327         {
328           anot[index].displayCharacter = label;
329         }
330       }
331     }
332     else if (evt.getActionCommand().equals(COLOUR))
333     {
334       Color col = JColorChooser.showDialog(this,
335               MessageManager.getString("label.select_foreground_colour"),
336               Color.black);
337
338       for (int index : av.getColumnSelection().getSelected())
339       {
340         if (!av.getColumnSelection().isVisible(index))
341         {
342           continue;
343         }
344
345         if (anot[index] == null)
346         {
347           anot[index] = new Annotation("", "", ' ', 0);
348         }
349
350         anot[index].colour = col;
351       }
352     }
353     else
354     // HELIX OR SHEET
355     {
356       char type = 0;
357       String symbol = "\u03B1";
358
359       if (evt.getActionCommand().equals(HELIX))
360       {
361         type = 'H';
362       }
363       else if (evt.getActionCommand().equals(SHEET))
364       {
365         type = 'E';
366         symbol = "\u03B2";
367       }
368
369       // Added by LML to color stems
370       else if (evt.getActionCommand().equals(STEM))
371       {
372         type = 'S';
373         symbol = "\u03C3";
374       }
375
376       if (!aa[activeRow].hasIcons)
377       {
378         aa[activeRow].hasIcons = true;
379       }
380
381       String label = JOptionPane.showInputDialog(MessageManager
382               .getString("label.enter_label_for_the_structure"), symbol);
383
384       if (label == null)
385       {
386         return;
387       }
388
389       if ((label.length() > 0) && !aa[activeRow].hasText)
390       {
391         aa[activeRow].hasText = true;
392         if (evt.getActionCommand().equals(STEM))
393         {
394           aa[activeRow].showAllColLabels = true;
395         }
396       }
397       for (int index : av.getColumnSelection().getSelected())
398       {
399         if (!av.getColumnSelection().isVisible(index))
400         {
401           continue;
402         }
403
404         if (anot[index] == null)
405         {
406           anot[index] = new Annotation(label, "", type, 0);
407         }
408
409         anot[index].secondaryStructure = type != 'S' ? type : label
410                 .length() == 0 ? ' ' : label.charAt(0);
411         anot[index].displayCharacter = label;
412
413       }
414     }
415     av.getAlignment().validateAnnotation(aa[activeRow]);
416     ap.alignmentChanged();
417
418     adjustPanelHeight();
419     repaint();
420
421     return;
422   }
423
424   private String collectAnnotVals(Annotation[] anot, String label2)
425   {
426     String collatedInput = "";
427     String last = "";
428     ColumnSelection viscols = av.getColumnSelection();
429     // TODO: refactor and save av.getColumnSelection for efficiency
430     for (int index : viscols.getSelected())
431     {
432       // always check for current display state - just in case
433       if (!viscols.isVisible(index))
434       {
435         continue;
436       }
437       String tlabel = null;
438       if (anot[index] != null)
439       { // LML added stem code
440         if (label2.equals(HELIX) || label2.equals(SHEET)
441                 || label2.equals(STEM) || label2.equals(LABEL))
442         {
443           tlabel = anot[index].description;
444           if (tlabel == null || tlabel.length() < 1)
445           {
446             if (label2.equals(HELIX) || label2.equals(SHEET)
447                     || label2.equals(STEM))
448             {
449               tlabel = "" + anot[index].secondaryStructure;
450             }
451             else
452             {
453               tlabel = "" + anot[index].displayCharacter;
454             }
455           }
456         }
457         if (tlabel != null && !tlabel.equals(last))
458         {
459           if (last.length() > 0)
460           {
461             collatedInput += " ";
462           }
463           collatedInput += tlabel;
464         }
465       }
466     }
467     return collatedInput;
468   }
469
470   /**
471    * DOCUMENT ME!
472    * 
473    * @param evt
474    *          DOCUMENT ME!
475    */
476   @Override
477   public void mousePressed(MouseEvent evt)
478   {
479
480     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
481     if (aa == null)
482     {
483       return;
484     }
485
486     int height = 0;
487     activeRow = -1;
488
489     for (int i = 0; i < aa.length; i++)
490     {
491       if (aa[i].visible)
492       {
493         height += aa[i].height;
494       }
495
496       if (evt.getY() < height)
497       {
498         if (aa[i].editable)
499         {
500           activeRow = i;
501         }
502         else if (aa[i].graph > 0)
503         {
504           // Stretch Graph
505           graphStretch = i;
506           graphStretchY = evt.getY();
507         }
508
509         break;
510       }
511     }
512
513     if (evt.isPopupTrigger() && activeRow != -1)
514     {
515       if (av.getColumnSelection() == null)
516       {
517         return;
518       }
519
520       JPopupMenu pop = new JPopupMenu(
521               MessageManager.getString("label.structure_type"));
522       JMenuItem item;
523       /*
524        * Just display the needed structure options
525        */
526       if (av.getAlignment().isNucleotide() == true)
527       {
528         item = new JMenuItem(STEM);
529         item.addActionListener(this);
530         pop.add(item);
531       }
532       else
533       {
534         item = new JMenuItem(HELIX);
535         item.addActionListener(this);
536         pop.add(item);
537         item = new JMenuItem(SHEET);
538         item.addActionListener(this);
539         pop.add(item);
540       }
541       item = new JMenuItem(LABEL);
542       item.addActionListener(this);
543       pop.add(item);
544       item = new JMenuItem(COLOUR);
545       item.addActionListener(this);
546       pop.add(item);
547       item = new JMenuItem(REMOVE);
548       item.addActionListener(this);
549       pop.add(item);
550       pop.show(this, evt.getX(), evt.getY());
551
552       return;
553     }
554
555     if (aa == null)
556     {
557       return;
558     }
559
560     ap.getScalePanel().mousePressed(evt);
561
562   }
563
564   /**
565    * DOCUMENT ME!
566    * 
567    * @param evt
568    *          DOCUMENT ME!
569    */
570   @Override
571   public void mouseReleased(MouseEvent evt)
572   {
573     graphStretch = -1;
574     graphStretchY = -1;
575     mouseDragging = false;
576     ap.getScalePanel().mouseReleased(evt);
577   }
578
579   /**
580    * DOCUMENT ME!
581    * 
582    * @param evt
583    *          DOCUMENT ME!
584    */
585   @Override
586   public void mouseEntered(MouseEvent evt)
587   {
588     ap.getScalePanel().mouseEntered(evt);
589   }
590
591   /**
592    * DOCUMENT ME!
593    * 
594    * @param evt
595    *          DOCUMENT ME!
596    */
597   @Override
598   public void mouseExited(MouseEvent evt)
599   {
600     ap.getScalePanel().mouseExited(evt);
601   }
602
603   /**
604    * DOCUMENT ME!
605    * 
606    * @param evt
607    *          DOCUMENT ME!
608    */
609   @Override
610   public void mouseDragged(MouseEvent evt)
611   {
612     if (graphStretch > -1)
613     {
614       av.getAlignment().getAlignmentAnnotation()[graphStretch].graphHeight += graphStretchY
615               - evt.getY();
616       if (av.getAlignment().getAlignmentAnnotation()[graphStretch].graphHeight < 0)
617       {
618         av.getAlignment().getAlignmentAnnotation()[graphStretch].graphHeight = 0;
619       }
620       graphStretchY = evt.getY();
621       adjustPanelHeight();
622       ap.paintAlignment(true);
623     }
624     else
625     {
626       ap.getScalePanel().mouseDragged(evt);
627     }
628   }
629
630   /**
631    * DOCUMENT ME!
632    * 
633    * @param evt
634    *          DOCUMENT ME!
635    */
636   @Override
637   public void mouseMoved(MouseEvent evt)
638   {
639     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
640
641     if (aa == null)
642     {
643       this.setToolTipText(null);
644       return;
645     }
646
647     int row = -1;
648     int height = 0;
649
650     for (int i = 0; i < aa.length; i++)
651     {
652       if (aa[i].visible)
653       {
654         height += aa[i].height;
655       }
656
657       if (evt.getY() < height)
658       {
659         row = i;
660
661         break;
662       }
663     }
664
665     if (row == -1)
666     {
667       this.setToolTipText(null);
668       return;
669     }
670
671     int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
672
673     if (av.hasHiddenColumns())
674     {
675       res = av.getColumnSelection().adjustForHiddenColumns(res);
676     }
677
678     if (row > -1 && aa[row].annotations != null
679             && res < aa[row].annotations.length)
680     {
681       if (aa[row].graphGroup > -1)
682       {
683         StringBuffer tip = new StringBuffer("<html>");
684         for (int gg = 0; gg < aa.length; gg++)
685         {
686           if (aa[gg].graphGroup == aa[row].graphGroup
687                   && aa[gg].annotations[res] != null)
688           {
689             tip.append(aa[gg].label + " "
690                     + aa[gg].annotations[res].description + "<br>");
691           }
692         }
693         if (tip.length() != 6)
694         {
695           tip.setLength(tip.length() - 4);
696           this.setToolTipText(tip.toString() + "</html>");
697         }
698       }
699       else if (aa[row].annotations[res] != null
700               && aa[row].annotations[res].description != null
701               && aa[row].annotations[res].description.length() > 0)
702       {
703         this.setToolTipText(JvSwingUtils.wrapTooltip(true,
704                 aa[row].annotations[res].description));
705       }
706       else
707       {
708         // clear the tooltip.
709         this.setToolTipText(null);
710       }
711
712       if (aa[row].annotations[res] != null)
713       {
714         StringBuffer text = new StringBuffer("Sequence position "
715                 + (res + 1));
716
717         if (aa[row].annotations[res].description != null)
718         {
719           text.append("  " + aa[row].annotations[res].description);
720         }
721
722         ap.alignFrame.statusBar.setText(text.toString());
723       }
724     }
725     else
726     {
727       this.setToolTipText(null);
728     }
729   }
730
731   /**
732    * DOCUMENT ME!
733    * 
734    * @param evt
735    *          DOCUMENT ME!
736    */
737   @Override
738   public void mouseClicked(MouseEvent evt)
739   {
740     // if (activeRow != -1)
741     // {
742     // AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
743     // AlignmentAnnotation anot = aa[activeRow];
744     // }
745   }
746
747   // TODO mouseClicked-content and drawCursor are quite experimental!
748   public void drawCursor(Graphics graphics, SequenceI seq, int res, int x1,
749           int y1)
750   {
751     int pady = av.getCharHeight() / 5;
752     int charOffset = 0;
753     graphics.setColor(Color.black);
754     graphics.fillRect(x1, y1, av.getCharWidth(), av.getCharHeight());
755
756     if (av.validCharWidth)
757     {
758       graphics.setColor(Color.white);
759
760       char s = seq.getCharAt(res);
761
762       charOffset = (av.getCharWidth() - fm.charWidth(s)) / 2;
763       graphics.drawString(String.valueOf(s), charOffset + x1,
764               (y1 + av.getCharHeight()) - pady);
765     }
766
767   }
768
769   private volatile boolean imageFresh = false;
770
771   /**
772    * DOCUMENT ME!
773    * 
774    * @param g
775    *          DOCUMENT ME!
776    */
777   @Override
778   public void paintComponent(Graphics g)
779   {
780     g.setColor(Color.white);
781     g.fillRect(0, 0, getWidth(), getHeight());
782
783     if (image != null)
784     {
785       if (fastPaint || (getVisibleRect().width != g.getClipBounds().width)
786               || (getVisibleRect().height != g.getClipBounds().height))
787       {
788         g.drawImage(image, 0, 0, this);
789         fastPaint = false;
790         return;
791       }
792     }
793     imgWidth = (av.endRes - av.startRes + 1) * av.getCharWidth();
794     if (imgWidth < 1)
795     {
796       return;
797     }
798     if (image == null || imgWidth != image.getWidth(this)
799             || image.getHeight(this) != getHeight())
800     {
801       try
802       {
803         image = new BufferedImage(imgWidth, ap.getAnnotationPanel()
804                 .getHeight(), BufferedImage.TYPE_INT_RGB);
805       } catch (OutOfMemoryError oom)
806       {
807         try
808         {
809           System.gc();
810         } catch (Exception x)
811         {
812         }
813         ;
814         new OOMWarning(
815                 "Couldn't allocate memory to redraw screen. Please restart Jalview",
816                 oom);
817         return;
818       }
819       gg = (Graphics2D) image.getGraphics();
820
821       if (av.antiAlias)
822       {
823         gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
824                 RenderingHints.VALUE_ANTIALIAS_ON);
825       }
826
827       gg.setFont(av.getFont());
828       fm = gg.getFontMetrics();
829       gg.setColor(Color.white);
830       gg.fillRect(0, 0, imgWidth, image.getHeight());
831       imageFresh = true;
832     }
833
834     drawComponent(gg, av.startRes, av.endRes + 1);
835     imageFresh = false;
836     g.drawImage(image, 0, 0, this);
837   }
838
839   /**
840    * set true to enable redraw timing debug output on stderr
841    */
842   private final boolean debugRedraw = false;
843
844   /**
845    * non-Thread safe repaint
846    * 
847    * @param horizontal
848    *          repaint with horizontal shift in alignment
849    */
850   public void fastPaint(int horizontal)
851   {
852     if ((horizontal == 0) || gg == null
853             || av.getAlignment().getAlignmentAnnotation() == null
854             || av.getAlignment().getAlignmentAnnotation().length < 1
855             || av.isCalcInProgress())
856     {
857       repaint();
858       return;
859     }
860     long stime = System.currentTimeMillis();
861     gg.copyArea(0, 0, imgWidth, getHeight(),
862             -horizontal * av.getCharWidth(), 0);
863     long mtime = System.currentTimeMillis();
864     int sr = av.startRes;
865     int er = av.endRes + 1;
866     int transX = 0;
867
868     if (horizontal > 0) // scrollbar pulled right, image to the left
869     {
870       transX = (er - sr - horizontal) * av.getCharWidth();
871       sr = er - horizontal;
872     }
873     else if (horizontal < 0)
874     {
875       er = sr - horizontal;
876     }
877
878     gg.translate(transX, 0);
879
880     drawComponent(gg, sr, er);
881
882     gg.translate(-transX, 0);
883     long dtime = System.currentTimeMillis();
884     fastPaint = true;
885     repaint();
886     long rtime = System.currentTimeMillis();
887     if (debugRedraw)
888     {
889       System.err.println("Scroll:\t" + horizontal + "\tCopyArea:\t"
890               + (mtime - stime) + "\tDraw component:\t" + (dtime - mtime)
891               + "\tRepaint call:\t" + (rtime - dtime));
892     }
893
894   }
895
896   private volatile boolean lastImageGood = false;
897
898   /**
899    * DOCUMENT ME!
900    * 
901    * @param g
902    *          DOCUMENT ME!
903    * @param startRes
904    *          DOCUMENT ME!
905    * @param endRes
906    *          DOCUMENT ME!
907    */
908   public void drawComponent(Graphics g, int startRes, int endRes)
909   {
910     BufferedImage oldFaded = fadedImage;
911     if (av.isCalcInProgress())
912     {
913       if (image == null)
914       {
915         lastImageGood = false;
916         return;
917       }
918       // We'll keep a record of the old image,
919       // and draw a faded image until the calculation
920       // has completed
921       if (lastImageGood
922               && (fadedImage == null || fadedImage.getWidth() != imgWidth || fadedImage
923                       .getHeight() != image.getHeight()))
924       {
925         // System.err.println("redraw faded image ("+(fadedImage==null ?
926         // "null image" : "") + " lastGood="+lastImageGood+")");
927         fadedImage = new BufferedImage(imgWidth, image.getHeight(),
928                 BufferedImage.TYPE_INT_RGB);
929
930         Graphics2D fadedG = (Graphics2D) fadedImage.getGraphics();
931
932         fadedG.setColor(Color.white);
933         fadedG.fillRect(0, 0, imgWidth, image.getHeight());
934
935         fadedG.setComposite(AlphaComposite.getInstance(
936                 AlphaComposite.SRC_OVER, .3f));
937         fadedG.drawImage(image, 0, 0, this);
938
939       }
940       // make sure we don't overwrite the last good faded image until all
941       // calculations have finished
942       lastImageGood = false;
943
944     }
945     else
946     {
947       if (fadedImage != null)
948       {
949         oldFaded = fadedImage;
950       }
951       fadedImage = null;
952     }
953
954     g.setColor(Color.white);
955     g.fillRect(0, 0, (endRes - startRes) * av.getCharWidth(), getHeight());
956
957     g.setFont(av.getFont());
958     if (fm == null)
959     {
960       fm = g.getFontMetrics();
961     }
962
963     if ((av.getAlignment().getAlignmentAnnotation() == null)
964             || (av.getAlignment().getAlignmentAnnotation().length < 1))
965     {
966       g.setColor(Color.white);
967       g.fillRect(0, 0, getWidth(), getHeight());
968       g.setColor(Color.black);
969       if (av.validCharWidth)
970       {
971         g.drawString(MessageManager
972                 .getString("label.alignment_has_no_annotations"), 20, 15);
973       }
974
975       return;
976     }
977     lastImageGood = renderer.drawComponent(this, av, g, activeRow,
978             startRes, endRes);
979     if (!lastImageGood && fadedImage == null)
980     {
981       fadedImage = oldFaded;
982     }
983   }
984
985   @Override
986   public FontMetrics getFontMetrics()
987   {
988     return fm;
989   }
990
991   @Override
992   public Image getFadedImage()
993   {
994     return fadedImage;
995   }
996
997   @Override
998   public int getFadedImageWidth()
999   {
1000     return imgWidth;
1001   }
1002
1003   private int[] bounds = new int[2];
1004
1005   @Override
1006   public int[] getVisibleVRange()
1007   {
1008     if (ap != null && ap.getAlabels() != null)
1009     {
1010       int sOffset = -ap.getAlabels().getScrollOffset();
1011       int visHeight = sOffset + ap.annotationSpaceFillerHolder.getHeight();
1012       bounds[0] = sOffset;
1013       bounds[1] = visHeight;
1014       return bounds;
1015     }
1016     else
1017     {
1018       return null;
1019     }
1020   }
1021 }