src/jalview/gui/AnnotationLabels.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
   3  * Copyright (C) 2014 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.Alignment;
  24 import jalview.datamodel.AlignmentAnnotation;
  25 import jalview.datamodel.Annotation;
  26 import jalview.datamodel.Sequence;
  27 import jalview.datamodel.SequenceGroup;
  28 import jalview.datamodel.SequenceI;
  29 import jalview.io.FormatAdapter;
  30 import jalview.util.MessageManager;
  31
  32 import java.awt.Color;
  33 import java.awt.Dimension;
  34 import java.awt.Font;
  35 import java.awt.FontMetrics;
  36 import java.awt.Graphics;
  37 import java.awt.Graphics2D;
  38 import java.awt.Image;
  39 import java.awt.MediaTracker;
  40 import java.awt.RenderingHints;
  41 import java.awt.Toolkit;
  42 import java.awt.datatransfer.StringSelection;
  43 import java.awt.event.ActionEvent;
  44 import java.awt.event.ActionListener;
  45 import java.awt.event.MouseEvent;
  46 import java.awt.event.MouseListener;
  47 import java.awt.event.MouseMotionListener;
  48 import java.awt.geom.AffineTransform;
  49 import java.awt.image.BufferedImage;
  50 import java.util.Arrays;
  51 import java.util.Vector;
  52 import java.util.regex.Pattern;
  53
  54 import javax.swing.JCheckBoxMenuItem;
  55 import javax.swing.JMenuItem;
  56 import javax.swing.JPanel;
  57 import javax.swing.JPopupMenu;
  58 import javax.swing.SwingUtilities;
  59 import javax.swing.ToolTipManager;
  60
  61 /**
  62  * DOCUMENT ME!
  63  *
  64  * @author $author$
  65  * @version $Revision$
  66  */
  67 public class AnnotationLabels extends JPanel implements MouseListener,
  68         MouseMotionListener, ActionListener
  69 {
  70   String TOGGLE_LABELSCALE = MessageManager.getString("label.scale_label_to_column");
  71
  72   String ADDNEW = MessageManager.getString("label.add_new_row");
  73
  74   String EDITNAME = MessageManager.getString("label.edit_label_description");
  75
  76   String HIDE = MessageManager.getString("label.hide_row");
  77
  78   String DELETE = MessageManager.getString("label.delete_row");
  79
  80   String SHOWALL = MessageManager.getString("label.show_all_hidden_rows");
  81
  82   String OUTPUT_TEXT = MessageManager.getString("label.export_annotation");
  83
  84   String COPYCONS_SEQ = MessageManager.getString("label.copy_consensus_sequence");
  85
  86   boolean resizePanel = false;
  87
  88   Image image;
  89
  90   AlignmentPanel ap;
  91
  92   AlignViewport av;
  93
  94   boolean resizing = false;
  95
  96   MouseEvent dragEvent;
  97
  98   int oldY;
  99
 100   int selectedRow;
 101
 102   int scrollOffset = 0;
 103
 104   Font font = new Font("Arial", Font.PLAIN, 11);
 105
 106   private boolean hasHiddenRows;
 107
 108   /**
 109    * Creates a new AnnotationLabels object.
 110    *
 111    * @param ap
 112    *          DOCUMENT ME!
 113    */
 114   public AnnotationLabels(AlignmentPanel ap)
 115   {
 116     this.ap = ap;
 117     av = ap.av;
 118     ToolTipManager.sharedInstance().registerComponent(this);
 119
 120     java.net.URL url = getClass().getResource("/images/idwidth.gif");
 121     Image temp = null;
 122
 123     if (url != null)
 124     {
 125       temp = java.awt.Toolkit.getDefaultToolkit().createImage(url);
 126     }
 127
 128     try
 129     {
 130       MediaTracker mt = new MediaTracker(this);
 131       mt.addImage(temp, 0);
 132       mt.waitForID(0);
 133     } catch (Exception ex)
 134     {
 135     }
 136
 137     BufferedImage bi = new BufferedImage(temp.getHeight(this),
 138             temp.getWidth(this), BufferedImage.TYPE_INT_RGB);
 139     Graphics2D g = (Graphics2D) bi.getGraphics();
 140     g.rotate(Math.toRadians(90));
 141     g.drawImage(temp, 0, -bi.getWidth(this), this);
 142     image = bi;
 143
 144     addMouseListener(this);
 145     addMouseMotionListener(this);
 146     addMouseWheelListener(ap.annotationPanel);
 147   }
 148
 149   public AnnotationLabels(AlignViewport av)
 150   {
 151     this.av = av;
 152   }
 153
 154   /**
 155    * DOCUMENT ME!
 156    *
 157    * @param y
 158    *          DOCUMENT ME!
 159    */
 160   public void setScrollOffset(int y)
 161   {
 162     scrollOffset = y;
 163     repaint();
 164   }
 165
 166   /**
 167    * sets selectedRow to -2 if no annotation preset, -1 if no visible row is at
 168    * y
 169    *
 170    * @param y
 171    *          coordinate position to search for a row
 172    */
 173   void getSelectedRow(int y)
 174   {
 175     int height = 0;
 176     AlignmentAnnotation[] aa = ap.av.getAlignment()
 177             .getAlignmentAnnotation();
 178     selectedRow = -2;
 179     if (aa != null)
 180     {
 181       for (int i = 0; i < aa.length; i++)
 182       {
 183         selectedRow = -1;
 184         if (!aa[i].visible)
 185         {
 186           continue;
 187         }
 188
 189         height += aa[i].height;
 190
 191         if (y < height)
 192         {
 193           selectedRow = i;
 194
 195           break;
 196         }
 197       }
 198     }
 199   }
 200
 201   /**
 202    * DOCUMENT ME!
 203    *
 204    * @param evt
 205    *          DOCUMENT ME!
 206    */
 207   public void actionPerformed(ActionEvent evt)
 208   {
 209     AlignmentAnnotation[] aa = ap.av.getAlignment()
 210             .getAlignmentAnnotation();
 211
 212     if (evt.getActionCommand().equals(ADDNEW))
 213     {
 214       AlignmentAnnotation newAnnotation = new AlignmentAnnotation(null,
 215               null, new Annotation[ap.av.getAlignment().getWidth()]);
 216
 217       if (!editLabelDescription(newAnnotation))
 218       {
 219         return;
 220       }
 221
 222       ap.av.getAlignment().addAnnotation(newAnnotation);
 223       ap.av.getAlignment().setAnnotationIndex(newAnnotation, 0);
 224     }
 225     else if (evt.getActionCommand().equals(EDITNAME))
 226     {
 227       editLabelDescription(aa[selectedRow]);
 228       repaint();
 229     }
 230     else if (evt.getActionCommand().equals(HIDE))
 231     {
 232       aa[selectedRow].visible = false;
 233     }
 234     else if (evt.getActionCommand().equals(DELETE))
 235     {
 236       ap.av.getAlignment().deleteAnnotation(aa[selectedRow]);
 237     }
 238     else if (evt.getActionCommand().equals(SHOWALL))
 239     {
 240       for (int i = 0; i < aa.length; i++)
 241       {
 242         if (!aa[i].visible && aa[i].annotations != null)
 243         {
 244           aa[i].visible = true;
 245         }
 246       }
 247     }
 248     else if (evt.getActionCommand().equals(OUTPUT_TEXT))
 249     {
 250       new AnnotationExporter().exportAnnotations(ap,
 251               new AlignmentAnnotation[]
 252               { aa[selectedRow] }, null, null);
 253     }
 254     else if (evt.getActionCommand().equals(COPYCONS_SEQ))
 255     {
 256       SequenceI cons = null;
 257       if (aa[selectedRow].groupRef != null)
 258       {
 259         cons = aa[selectedRow].groupRef.getConsensusSeq();
 260       }
 261       else
 262       {
 263         cons = av.getConsensusSeq();
 264       }
 265       if (cons != null)
 266       {
 267         copy_annotseqtoclipboard(cons);
 268       }
 269
 270     }
 271     else if (evt.getActionCommand().equals(TOGGLE_LABELSCALE))
 272     {
 273       aa[selectedRow].scaleColLabel = !aa[selectedRow].scaleColLabel;
 274     }
 275
 276     refresh();
 277
 278   }
 279
 280   /**
 281    * Redraw sensibly.
 282    */
 283   protected void refresh()
 284   {
 285     ap.validateAnnotationDimensions(false);
 286     ap.addNotify();
 287     ap.repaint();
 288   }
 289
 290   /**
 291    * DOCUMENT ME!
 292    *
 293    * @param e
 294    *          DOCUMENT ME!
 295    */
 296   boolean editLabelDescription(AlignmentAnnotation annotation)
 297   {
 298     EditNameDialog dialog = new EditNameDialog(annotation.label,
 299             annotation.description, "       Annotation Name ",
 300             "Annotation Description ", "Edit Annotation Name/Description",
 301             ap.alignFrame);
 302
 303     if (!dialog.accept)
 304     {
 305       return false;
 306     }
 307
 308     annotation.label = dialog.getName();
 309
 310     String text = dialog.getDescription();
 311     if (text != null && text.length() == 0)
 312     {
 313       text = null;
 314     }
 315     annotation.description = text;
 316
 317     return true;
 318   }
 319
 320   /**
 321    * DOCUMENT ME!
 322    *
 323    * @param evt
 324    *          DOCUMENT ME!
 325    */
 326   public void mousePressed(MouseEvent evt)
 327   {
 328     getSelectedRow(evt.getY() - scrollOffset);
 329     oldY = evt.getY();
 330   }
 331
 332   /**
 333    * DOCUMENT ME!
 334    *
 335    * @param evt
 336    *          DOCUMENT ME!
 337    */
 338   public void mouseReleased(MouseEvent evt)
 339   {
 340     int start = selectedRow;
 341     getSelectedRow(evt.getY() - scrollOffset);
 342     int end = selectedRow;
 343
 344     if (start != end)
 345     {
 346       // Swap these annotations
 347       AlignmentAnnotation startAA = ap.av.getAlignment()
 348               .getAlignmentAnnotation()[start];
 349       if (end == -1)
 350       {
 351         end = ap.av.getAlignment().getAlignmentAnnotation().length - 1;
 352       }
 353       AlignmentAnnotation endAA = ap.av.getAlignment()
 354               .getAlignmentAnnotation()[end];
 355
 356       ap.av.getAlignment().getAlignmentAnnotation()[end] = startAA;
 357       ap.av.getAlignment().getAlignmentAnnotation()[start] = endAA;
 358     }
 359
 360     resizePanel = false;
 361     dragEvent = null;
 362     repaint();
 363     ap.annotationPanel.repaint();
 364   }
 365
 366   /**
 367    * DOCUMENT ME!
 368    *
 369    * @param evt
 370    *          DOCUMENT ME!
 371    */
 372   public void mouseEntered(MouseEvent evt)
 373   {
 374     if (evt.getY() < 10)
 375     {
 376       resizePanel = true;
 377       repaint();
 378     }
 379   }
 380
 381   /**
 382    * DOCUMENT ME!
 383    *
 384    * @param evt
 385    *          DOCUMENT ME!
 386    */
 387   public void mouseExited(MouseEvent evt)
 388   {
 389     if (dragEvent == null)
 390     {
 391       resizePanel = false;
 392       repaint();
 393     }
 394   }
 395
 396   /**
 397    * DOCUMENT ME!
 398    *
 399    * @param evt
 400    *          DOCUMENT ME!
 401    */
 402   public void mouseDragged(MouseEvent evt)
 403   {
 404     dragEvent = evt;
 405
 406     if (resizePanel)
 407     {
 408       Dimension d = ap.annotationScroller.getPreferredSize();
 409       int dif = evt.getY() - oldY;
 410
 411       dif /= ap.av.charHeight;
 412       dif *= ap.av.charHeight;
 413
 414       if ((d.height - dif) > 20)
 415       {
 416         ap.annotationScroller.setPreferredSize(new Dimension(d.width,
 417                 d.height - dif));
 418         d = ap.annotationSpaceFillerHolder.getPreferredSize();
 419         ap.annotationSpaceFillerHolder.setPreferredSize(new Dimension(
 420                 d.width, d.height - dif));
 421         ap.paintAlignment(true);
 422       }
 423
 424       ap.addNotify();
 425     }
 426     else
 427     {
 428       repaint();
 429     }
 430   }
 431
 432   /**
 433    * DOCUMENT ME!
 434    *
 435    * @param evt
 436    *          DOCUMENT ME!
 437    */
 438   public void mouseMoved(MouseEvent evt)
 439   {
 440     resizePanel = evt.getY() < 10;
 441
 442     getSelectedRow(evt.getY() - scrollOffset);
 443
 444     if (selectedRow > -1
 445             && ap.av.getAlignment().getAlignmentAnnotation().length > selectedRow)
 446     {
 447       AlignmentAnnotation aa = ap.av.getAlignment()
 448               .getAlignmentAnnotation()[selectedRow];
 449
 450       StringBuffer desc = new StringBuffer();
 451       if (aa.description != null
 452               && !aa.description.equals("New description"))
 453       {
 454         // TODO: we could refactor and merge this code with the code in
 455         // jalview.gui.SeqPanel.mouseMoved(..) that formats sequence feature
 456         // tooltips
 457         desc.append(aa.getDescription(true).trim());
 458         // check to see if the description is an html fragment.
 459         if (desc.length() < 6
 460                 || (desc.substring(0, 6).toLowerCase().indexOf("<html>") < 0))
 461         {
 462           // clean the description ready for embedding in html
 463           desc = new StringBuffer(Pattern.compile("<").matcher(desc)
 464                   .replaceAll("&lt;"));
 465           desc.insert(0, "<html>");
 466         }
 467         else
 468         {
 469           // remove terminating html if any
 470           int i = desc.substring(desc.length() - 7).toLowerCase()
 471                   .lastIndexOf("</html>");
 472           if (i > -1)
 473           {
 474             desc.setLength(desc.length() - 7 + i);
 475           }
 476         }
 477         if (aa.hasScore())
 478         {
 479           desc.append("<br/>");
 480         }
 481         // if (aa.hasProperties())
 482         // {
 483         // desc.append("<table>");
 484         // for (String prop : aa.getProperties())
 485         // {
 486         // desc.append("<tr><td>" + prop + "</td><td>"
 487         // + aa.getProperty(prop) + "</td><tr>");
 488         // }
 489         // desc.append("</table>");
 490         // }
 491       }
 492       else
 493       {
 494         // begin the tooltip's html fragment
 495         desc.append("<html>");
 496       }
 497       if (aa.hasScore())
 498       {
 499         // TODO: limit precision of score to avoid noise from imprecise doubles
 500         // (64.7 becomes 64.7+/some tiny value).
 501         desc.append(" Score: " + aa.score);
 502       }
 503
 504       if (desc.length() > 6)
 505       {
 506         desc.append("</html>");
 507         this.setToolTipText(desc.toString());
 508       }
 509       else
 510       {
 511         this.setToolTipText(null);
 512       }
 513     }
 514
 515   }
 516
 517   /**
 518    * DOCUMENT ME!
 519    *
 520    * @param evt
 521    *          DOCUMENT ME!
 522    */
 523   public void mouseClicked(MouseEvent evt)
 524   {
 525     final AlignmentAnnotation[] aa = ap.av.getAlignment()
 526             .getAlignmentAnnotation();
 527     if (SwingUtilities.isLeftMouseButton(evt))
 528     {
 529       if (selectedRow > -1 && selectedRow < aa.length)
 530       {
 531         if (aa[selectedRow].groupRef != null)
 532         {
 533           if (evt.getClickCount() >= 2)
 534           {
 535             // todo: make the ap scroll to the selection - not necessary, first
 536             // click highlights/scrolls, second selects
 537             ap.seqPanel.ap.idPanel.highlightSearchResults(null);
 538             ap.av.setSelectionGroup(// new SequenceGroup(
 539             aa[selectedRow].groupRef); // );
 540             ap.paintAlignment(false);
 541             PaintRefresher.Refresh(ap, ap.av.getSequenceSetId());
 542             ap.av.sendSelection();
 543           }
 544           else
 545           {
 546             ap.seqPanel.ap.idPanel
 547                     .highlightSearchResults(aa[selectedRow].groupRef
 548                             .getSequences(null));
 549           }
 550           return;
 551         }
 552         else if (aa[selectedRow].sequenceRef != null)
 553         {
 554           if (evt.getClickCount() == 1)
 555           {
 556             ap.seqPanel.ap.idPanel.highlightSearchResults(Arrays
 557                     .asList(new SequenceI[]
 558                     { aa[selectedRow].sequenceRef }));
 559           }
 560           else if (evt.getClickCount() >= 2)
 561           {
 562             ap.seqPanel.ap.idPanel.highlightSearchResults(null);
 563             SequenceGroup sg = ap.av.getSelectionGroup();
 564             if (sg!=null)
 565             {
 566               // we make a copy rather than edit the current selection if no modifiers pressed
 567               // see Enhancement JAL-1557
 568               if (!(evt.isControlDown() || evt.isShiftDown()))
 569               {
 570                 sg = new SequenceGroup(sg);
 571                 sg.clear();
 572                 sg.addSequence(aa[selectedRow].sequenceRef, false);
 573               } else {
 574                 if (evt.isControlDown())
 575                 {
 576                   sg.addOrRemove(aa[selectedRow].sequenceRef, true);
 577                 } else {
 578                   // notionally, we should also add intermediate sequences from last added sequence ?
 579                   sg.addSequence(aa[selectedRow].sequenceRef, true);
 580                 }
 581               }
 582             } else {
 583               sg = new SequenceGroup();
 584               sg.setStartRes(0);
 585               sg.setEndRes(ap.av.getAlignment().getWidth()-1);
 586               sg.addSequence(aa[selectedRow].sequenceRef, false);
 587             }
 588             ap.av.setSelectionGroup(sg);
 589             ap.av.sendSelection();
 590             ap.paintAlignment(false);
 591             PaintRefresher.Refresh(ap, ap.av.getSequenceSetId());
 592           }
 593
 594         }
 595       }
 596     }
 597     if (!SwingUtilities.isRightMouseButton(evt))
 598     {
 599       return;
 600     }
 601
 602     JPopupMenu pop = new JPopupMenu(
 603             MessageManager.getString("label.annotations"));
 604     JMenuItem item = new JMenuItem(ADDNEW);
 605     item.addActionListener(this);
 606     pop.add(item);
 607     if (selectedRow < 0)
 608     {
 609       if (hasHiddenRows)
 610       { // let the user make everything visible again
 611         item = new JMenuItem(SHOWALL);
 612         item.addActionListener(this);
 613         pop.add(item);
 614       }
 615       pop.show(this, evt.getX(), evt.getY());
 616       return;
 617     }
 618     item = new JMenuItem(EDITNAME);
 619     item.addActionListener(this);
 620     pop.add(item);
 621     item = new JMenuItem(HIDE);
 622     item.addActionListener(this);
 623     pop.add(item);
 624     // JAL-1264 hide all sequence-specific annotations of this type
 625     final String label = aa[selectedRow].label;
 626     if (selectedRow < aa.length)
 627     {
 628       if (aa[selectedRow].sequenceRef != null)
 629       {
 630         JMenuItem hideType = new JMenuItem();
 631         String text = MessageManager.getString("label.hide_all") + " " + label;
 632         hideType.setText(text);
 633         hideType.addActionListener(new ActionListener()
 634         {
 635           @Override
 636           public void actionPerformed(ActionEvent e)
 637           {
 638             for (AlignmentAnnotation ann : ap.av.getAlignment()
 639                     .getAlignmentAnnotation())
 640             {
 641               if (ann.sequenceRef != null && ann.label != null
 642                       && ann.label.equals(label))
 643               {
 644                 ann.visible = false;
 645               }
 646             }
 647             refresh();
 648           }
 649         });
 650         pop.add(hideType);
 651       }
 652     }
 653     item = new JMenuItem(DELETE);
 654     item.addActionListener(this);
 655     pop.add(item);
 656     if (hasHiddenRows)
 657     {
 658       item = new JMenuItem(SHOWALL);
 659       item.addActionListener(this);
 660       pop.add(item);
 661     }
 662     item = new JMenuItem(OUTPUT_TEXT);
 663     item.addActionListener(this);
 664     pop.add(item);
 665     // TODO: annotation object should be typed for autocalculated/derived
 666     // property methods
 667     if (selectedRow < aa.length)
 668     {
 669       if (!aa[selectedRow].autoCalculated)
 670       {
 671         if (aa[selectedRow].graph == AlignmentAnnotation.NO_GRAPH)
 672         {
 673           // display formatting settings for this row.
 674           pop.addSeparator();
 675           // av and sequencegroup need to implement same interface for
 676           item = new JCheckBoxMenuItem(TOGGLE_LABELSCALE,
 677                   aa[selectedRow].scaleColLabel);
 678           item.addActionListener(this);
 679           pop.add(item);
 680         }
 681       }
 682       else if (label.indexOf("Consensus") > -1)
 683       {
 684         pop.addSeparator();
 685         // av and sequencegroup need to implement same interface for
 686         final JCheckBoxMenuItem cbmi = new JCheckBoxMenuItem(
 687                         MessageManager.getString("label.ignore_gaps_consensus"),
 688                 (aa[selectedRow].groupRef != null) ? aa[selectedRow].groupRef
 689                         .getIgnoreGapsConsensus() : ap.av
 690                         .getIgnoreGapsConsensus());
 691         final AlignmentAnnotation aaa = aa[selectedRow];
 692         cbmi.addActionListener(new ActionListener()
 693         {
 694           public void actionPerformed(ActionEvent e)
 695           {
 696             if (aaa.groupRef != null)
 697             {
 698               // TODO: pass on reference to ap so the view can be updated.
 699               aaa.groupRef.setIgnoreGapsConsensus(cbmi.getState());
 700               ap.annotationPanel.paint(ap.annotationPanel.getGraphics());
 701             }
 702             else
 703             {
 704               ap.av.setIgnoreGapsConsensus(cbmi.getState(), ap);
 705             }
 706           }
 707         });
 708         pop.add(cbmi);
 709         // av and sequencegroup need to implement same interface for
 710         if (aaa.groupRef != null)
 711         {
 712           final JCheckBoxMenuItem chist = new JCheckBoxMenuItem(
 713                           MessageManager.getString("label.show_group_histogram"),
 714                   aa[selectedRow].groupRef.isShowConsensusHistogram());
 715           chist.addActionListener(new ActionListener()
 716           {
 717             public void actionPerformed(ActionEvent e)
 718             {
 719               // TODO: pass on reference
 720               // to ap
 721               // so the
 722               // view
 723               // can be
 724               // updated.
 725               aaa.groupRef.setShowConsensusHistogram(chist.getState());
 726               ap.repaint();
 727               // ap.annotationPanel.paint(ap.annotationPanel.getGraphics());
 728             }
 729           });
 730           pop.add(chist);
 731           final JCheckBoxMenuItem cprofl = new JCheckBoxMenuItem(
 732                           MessageManager.getString("label.show_group_logo"),
 733                   aa[selectedRow].groupRef.isShowSequenceLogo());
 734           cprofl.addActionListener(new ActionListener()
 735           {
 736             public void actionPerformed(ActionEvent e)
 737             {
 738               // TODO: pass on reference
 739               // to ap
 740               // so the
 741               // view
 742               // can be
 743               // updated.
 744               aaa.groupRef.setshowSequenceLogo(cprofl.getState());
 745               ap.repaint();
 746               // ap.annotationPanel.paint(ap.annotationPanel.getGraphics());
 747             }
 748           });
 749           pop.add(cprofl);
 750           final JCheckBoxMenuItem cproflnorm = new JCheckBoxMenuItem(
 751                           MessageManager.getString("label.normalise_group_logo"),
 752                   aa[selectedRow].groupRef.isNormaliseSequenceLogo());
 753           cproflnorm.addActionListener(new ActionListener()
 754           {
 755             public void actionPerformed(ActionEvent e)
 756             {
 757
 758               // TODO: pass on reference
 759               // to ap
 760               // so the
 761               // view
 762               // can be
 763               // updated.
 764               aaa.groupRef.setNormaliseSequenceLogo(cproflnorm.getState());
 765               // automatically enable logo display if we're clicked
 766               aaa.groupRef.setshowSequenceLogo(true);
 767               ap.repaint();
 768               // ap.annotationPanel.paint(ap.annotationPanel.getGraphics());
 769             }
 770           });
 771           pop.add(cproflnorm);
 772         }
 773         else
 774         {
 775           final JCheckBoxMenuItem chist = new JCheckBoxMenuItem(
 776                           MessageManager.getString("label.show_histogram"), av.isShowConsensusHistogram());
 777           chist.addActionListener(new ActionListener()
 778           {
 779             public void actionPerformed(ActionEvent e)
 780             {
 781               // TODO: pass on reference
 782               // to ap
 783               // so the
 784               // view
 785               // can be
 786               // updated.
 787               av.setShowConsensusHistogram(chist.getState());
 788               ap.alignFrame.setMenusForViewport();
 789               ap.repaint();
 790               // ap.annotationPanel.paint(ap.annotationPanel.getGraphics());
 791             }
 792           });
 793           pop.add(chist);
 794           final JCheckBoxMenuItem cprof = new JCheckBoxMenuItem(
 795                           MessageManager.getString("label.show_logo"), av.isShowSequenceLogo());
 796           cprof.addActionListener(new ActionListener()
 797           {
 798             public void actionPerformed(ActionEvent e)
 799             {
 800               // TODO: pass on reference
 801               // to ap
 802               // so the
 803               // view
 804               // can be
 805               // updated.
 806               av.setShowSequenceLogo(cprof.getState());
 807               ap.alignFrame.setMenusForViewport();
 808               ap.repaint();
 809               // ap.annotationPanel.paint(ap.annotationPanel.getGraphics());
 810             }
 811           });
 812           pop.add(cprof);
 813           final JCheckBoxMenuItem cprofnorm = new JCheckBoxMenuItem(
 814                           MessageManager.getString("label.normalise_logo"), av.isNormaliseSequenceLogo());
 815           cprofnorm.addActionListener(new ActionListener()
 816           {
 817             public void actionPerformed(ActionEvent e)
 818             {
 819               // TODO: pass on reference
 820               // to ap
 821               // so the
 822               // view
 823               // can be
 824               // updated.
 825               av.setShowSequenceLogo(true);
 826               av.setNormaliseSequenceLogo(cprofnorm.getState());
 827               ap.alignFrame.setMenusForViewport();
 828               ap.repaint();
 829               // ap.annotationPanel.paint(ap.annotationPanel.getGraphics());
 830             }
 831           });
 832           pop.add(cprofnorm);
 833         }
 834         final JMenuItem consclipbrd = new JMenuItem(COPYCONS_SEQ);
 835         consclipbrd.addActionListener(this);
 836         pop.add(consclipbrd);
 837       }
 838     }
 839     pop.show(this, evt.getX(), evt.getY());
 840   }
 841
 842   /**
 843    * do a single sequence copy to jalview and the system clipboard
 844    *
 845    * @param sq
 846    *          sequence to be copied to clipboard
 847    */
 848   protected void copy_annotseqtoclipboard(SequenceI sq)
 849   {
 850     SequenceI[] seqs = new SequenceI[]
 851     { sq };
 852     String[] omitHidden = null;
 853     SequenceI[] dseqs = new SequenceI[]
 854     { sq.getDatasetSequence() };
 855     if (dseqs[0] == null)
 856     {
 857       dseqs[0] = new Sequence(sq);
 858       dseqs[0].setSequence(jalview.analysis.AlignSeq.extractGaps(
 859               jalview.util.Comparison.GapChars, sq.getSequenceAsString()));
 860
 861       sq.setDatasetSequence(dseqs[0]);
 862     }
 863     Alignment ds = new Alignment(dseqs);
 864     if (av.hasHiddenColumns())
 865     {
 866       omitHidden = av.getColumnSelection().getVisibleSequenceStrings(0,
 867               sq.getLength(), seqs);
 868     }
 869
 870     String output = new FormatAdapter().formatSequences("Fasta", seqs,
 871             omitHidden);
 872
 873     Toolkit.getDefaultToolkit().getSystemClipboard()
 874             .setContents(new StringSelection(output), Desktop.instance);
 875
 876     Vector hiddenColumns = null;
 877     if (av.hasHiddenColumns())
 878     {
 879       hiddenColumns = new Vector();
 880       for (int i = 0; i < av.getColumnSelection().getHiddenColumns().size(); i++)
 881       {
 882         int[] region = (int[]) av.getColumnSelection().getHiddenColumns()
 883                 .elementAt(i);
 884
 885         hiddenColumns.addElement(new int[]
 886         { region[0], region[1] });
 887       }
 888     }
 889
 890     Desktop.jalviewClipboard = new Object[]
 891     { seqs, ds, // what is the dataset of a consensus sequence ? need to flag
 892         // sequence as special.
 893         hiddenColumns };
 894   }
 895
 896   /**
 897    * DOCUMENT ME!
 898    *
 899    * @param g1
 900    *          DOCUMENT ME!
 901    */
 902   public void paintComponent(Graphics g)
 903   {
 904
 905     int width = getWidth();
 906     if (width == 0)
 907     {
 908       width = ap.calculateIdWidth().width + 4;
 909     }
 910
 911     Graphics2D g2 = (Graphics2D) g;
 912     if (av.antiAlias)
 913     {
 914       g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
 915               RenderingHints.VALUE_ANTIALIAS_ON);
 916     }
 917
 918     drawComponent(g2, true, width);
 919
 920   }
 921
 922   /**
 923    * Draw the full set of annotation Labels for the alignment at the given
 924    * cursor
 925    *
 926    * @param g
 927    *          Graphics2D instance (needed for font scaling)
 928    * @param width
 929    *          Width for scaling labels
 930    *
 931    */
 932   public void drawComponent(Graphics g, int width)
 933   {
 934     drawComponent(g, false, width);
 935   }
 936
 937   private final boolean debugRedraw = false;
 938
 939   /**
 940    * Draw the full set of annotation Labels for the alignment at the given
 941    * cursor
 942    *
 943    * @param g
 944    *          Graphics2D instance (needed for font scaling)
 945    * @param clip
 946    *          - true indicates that only current visible area needs to be
 947    *          rendered
 948    * @param width
 949    *          Width for scaling labels
 950    */
 951   public void drawComponent(Graphics g, boolean clip, int width)
 952   {
 953     if (av.getFont().getSize() < 10)
 954     {
 955       g.setFont(font);
 956     }
 957     else
 958     {
 959       g.setFont(av.getFont());
 960     }
 961
 962     FontMetrics fm = g.getFontMetrics(g.getFont());
 963     g.setColor(Color.white);
 964     g.fillRect(0, 0, getWidth(), getHeight());
 965
 966     g.translate(0, scrollOffset);
 967     g.setColor(Color.black);
 968
 969     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
 970     int fontHeight = g.getFont().getSize();
 971     int y = 0;
 972     int x = 0;
 973     int graphExtras = 0;
 974     int offset = 0;
 975     Font baseFont = g.getFont();
 976     FontMetrics baseMetrics = fm;
 977     int ofontH = fontHeight;
 978     int sOffset = 0;
 979     int visHeight = 0;
 980     int[] visr = (ap != null && ap.annotationPanel != null) ? ap.annotationPanel
 981             .getVisibleVRange() : null;
 982     if (clip && visr != null)
 983     {
 984       sOffset = visr[0];
 985       visHeight = visr[1];
 986     }
 987     boolean visible = true, before = false, after = false;
 988     if (aa != null)
 989     {
 990       hasHiddenRows = false;
 991       int olY = 0;
 992       for (int i = 0; i < aa.length; i++)
 993       {
 994         visible = true;
 995         if (!aa[i].visible)
 996         {
 997           hasHiddenRows = true;
 998           continue;
 999         }
1000         olY = y;
1001         y += aa[i].height;
1002         if (clip)
1003         {
1004           if (y < sOffset)
1005           {
1006             if (!before)
1007             {
1008               if (debugRedraw)
1009               {
1010                 System.out.println("before vis: " + i);
1011               }
1012               before = true;
1013             }
1014             // don't draw what isn't visible
1015             continue;
1016           }
1017           if (olY > visHeight)
1018           {
1019
1020             if (!after)
1021             {
1022               if (debugRedraw)
1023               {
1024                 System.out.println("Scroll offset: " + sOffset
1025                         + " after vis: " + i);
1026               }
1027               after = true;
1028             }
1029             // don't draw what isn't visible
1030             continue;
1031           }
1032         }
1033         g.setColor(Color.black);
1034
1035         offset = -aa[i].height / 2;
1036
1037         if (aa[i].hasText)
1038         {
1039           offset += fm.getHeight() / 2;
1040           offset -= fm.getDescent();
1041         }
1042         else
1043         {
1044           offset += fm.getDescent();
1045         }
1046
1047         x = width - fm.stringWidth(aa[i].label) - 3;
1048
1049         if (aa[i].graphGroup > -1)
1050         {
1051           int groupSize = 0;
1052           // TODO: JAL-1291 revise rendering model so the graphGroup map is
1053           // computed efficiently for all visible labels
1054           for (int gg = 0; gg < aa.length; gg++)
1055           {
1056             if (aa[gg].graphGroup == aa[i].graphGroup)
1057             {
1058               groupSize++;
1059             }
1060           }
1061           if (groupSize * (fontHeight + 8) < aa[i].height)
1062           {
1063             graphExtras = (aa[i].height - (groupSize * (fontHeight + 8))) / 2;
1064           }
1065           else
1066           {
1067             // scale font to fit
1068             float h = aa[i].height / (float) groupSize, s;
1069             if (h < 9)
1070             {
1071               visible = false;
1072             }
1073             else
1074             {
1075               fontHeight = -8 + (int) h;
1076               s = ((float) fontHeight) / (float) ofontH;
1077               Font f = baseFont.deriveFont(AffineTransform
1078                       .getScaleInstance(s, s));
1079               g.setFont(f);
1080               fm = g.getFontMetrics();
1081               graphExtras = (aa[i].height - (groupSize * (fontHeight + 8))) / 2;
1082             }
1083           }
1084           if (visible)
1085           {
1086             for (int gg = 0; gg < aa.length; gg++)
1087             {
1088               if (aa[gg].graphGroup == aa[i].graphGroup)
1089               {
1090                 x = width - fm.stringWidth(aa[gg].label) - 3;
1091                 g.drawString(aa[gg].label, x, y - graphExtras);
1092
1093                 if (aa[gg]._linecolour != null)
1094                 {
1095
1096                   g.setColor(aa[gg]._linecolour);
1097                   g.drawLine(x, y - graphExtras + 3,
1098                           x + fm.stringWidth(aa[gg].label), y - graphExtras
1099                                   + 3);
1100                 }
1101
1102                 g.setColor(Color.black);
1103                 graphExtras += fontHeight + 8;
1104               }
1105             }
1106           }
1107           g.setFont(baseFont);
1108           fm = baseMetrics;
1109           fontHeight = ofontH;
1110         }
1111         else
1112         {
1113           g.drawString(aa[i].label, x, y + offset);
1114         }
1115       }
1116     }
1117
1118     if (resizePanel)
1119     {
1120       g.drawImage(image, 2, 0 - scrollOffset, this);
1121     }
1122     else if (dragEvent != null && aa != null)
1123     {
1124       g.setColor(Color.lightGray);
1125       g.drawString(aa[selectedRow].label, dragEvent.getX(),
1126               dragEvent.getY() - scrollOffset);
1127     }
1128
1129     if (!av.wrapAlignment && ((aa == null) || (aa.length < 1)))
1130     {
1131       g.drawString(MessageManager.getString("label.right_click"), 2, 8);
1132       g.drawString(MessageManager.getString("label.to_add_annotation"), 2,
1133               18);
1134     }
1135   }
1136 }