src/jalview/gui/AnnotationLabels.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 java.awt.Color;
  24 import java.awt.Cursor;
  25 import java.awt.Dimension;
  26 import java.awt.Font;
  27 import java.awt.FontMetrics;
  28 import java.awt.Graphics;
  29 import java.awt.Graphics2D;
  30 import java.awt.RenderingHints;
  31 import java.awt.Toolkit;
  32 import java.awt.datatransfer.StringSelection;
  33 import java.awt.event.ActionEvent;
  34 import java.awt.event.ActionListener;
  35 import java.awt.event.MouseEvent;
  36 import java.awt.event.MouseListener;
  37 import java.awt.event.MouseMotionListener;
  38 import java.awt.geom.AffineTransform;
  39 import java.util.Arrays;
  40 import java.util.Collections;
  41 import java.util.Iterator;
  42 import java.util.Locale;
  43
  44 import javax.swing.JCheckBoxMenuItem;
  45 import javax.swing.JMenuItem;
  46 import javax.swing.JPanel;
  47 import javax.swing.JPopupMenu;
  48 import javax.swing.SwingUtilities;
  49 import javax.swing.ToolTipManager;
  50
  51 import jalview.analysis.AlignSeq;
  52 import jalview.analysis.AlignmentUtils;
  53 import jalview.datamodel.Alignment;
  54 import jalview.datamodel.AlignmentAnnotation;
  55 import jalview.datamodel.Annotation;
  56 import jalview.datamodel.ContactMatrixI;
  57 import jalview.datamodel.GroupSet;
  58 import jalview.datamodel.HiddenColumns;
  59 import jalview.datamodel.Sequence;
  60 import jalview.datamodel.SequenceGroup;
  61 import jalview.datamodel.SequenceI;
  62 import jalview.io.FileFormat;
  63 import jalview.io.FormatAdapter;
  64 import jalview.util.Comparison;
  65 import jalview.util.MessageManager;
  66 import jalview.util.Platform;
  67
  68 /**
  69  * The panel that holds the labels for alignment annotations, providing
  70  * tooltips, context menus, drag to reorder rows, and drag to adjust panel
  71  * height
  72  */
  73 public class AnnotationLabels extends JPanel
  74         implements MouseListener, MouseMotionListener, ActionListener
  75 {
  76   private static final String HTML_END_TAG = "</html>";
  77
  78   private static final String HTML_START_TAG = "<html>";
  79
  80   /**
  81    * width in pixels within which height adjuster arrows are shown and active
  82    */
  83   private static final int HEIGHT_ADJUSTER_WIDTH = 50;
  84
  85   /**
  86    * height in pixels for allowing height adjuster to be active
  87    */
  88   private static int HEIGHT_ADJUSTER_HEIGHT = 10;
  89
  90   private static final Font font = new Font("Arial", Font.PLAIN, 11);
  91
  92   private static final String TOGGLE_LABELSCALE = MessageManager
  93           .getString("label.scale_label_to_column");
  94
  95   private static final String ADDNEW = MessageManager
  96           .getString("label.add_new_row");
  97
  98   private static final String EDITNAME = MessageManager
  99           .getString("label.edit_label_description");
 100
 101   private static final String HIDE = MessageManager
 102           .getString("label.hide_row");
 103
 104   private static final String DELETE = MessageManager
 105           .getString("label.delete_row");
 106
 107   private static final String SHOWALL = MessageManager
 108           .getString("label.show_all_hidden_rows");
 109
 110   private static final String OUTPUT_TEXT = MessageManager
 111           .getString("label.export_annotation");
 112
 113   private static final String COPYCONS_SEQ = MessageManager
 114           .getString("label.copy_consensus_sequence");
 115
 116   private final boolean debugRedraw = false;
 117
 118   private AlignmentPanel ap;
 119
 120   AlignViewport av;
 121
 122   private MouseEvent dragEvent;
 123
 124   private int oldY;
 125
 126   private int selectedRow;
 127
 128   private int scrollOffset = 0;
 129
 130   private boolean hasHiddenRows;
 131
 132   private boolean resizePanel = false;
 133
 134   /**
 135    * Creates a new AnnotationLabels object
 136    *
 137    * @param ap
 138    */
 139   public AnnotationLabels(AlignmentPanel ap)
 140   {
 141
 142     this.ap = ap;
 143     av = ap.av;
 144     ToolTipManager.sharedInstance().registerComponent(this);
 145
 146     addMouseListener(this);
 147     addMouseMotionListener(this);
 148     addMouseWheelListener(ap.getAnnotationPanel());
 149   }
 150
 151   public AnnotationLabels(AlignViewport av)
 152   {
 153     this.av = av;
 154   }
 155
 156   /**
 157    * DOCUMENT ME!
 158    *
 159    * @param y
 160    *          DOCUMENT ME!
 161    */
 162   public void setScrollOffset(int y)
 163   {
 164     scrollOffset = y;
 165     repaint();
 166   }
 167
 168   /**
 169    * sets selectedRow to -2 if no annotation preset, -1 if no visible row is at
 170    * y
 171    *
 172    * @param y
 173    *          coordinate position to search for a row
 174    */
 175   void getSelectedRow(int y)
 176   {
 177     int height = 0;
 178     AlignmentAnnotation[] aa = ap.av.getAlignment()
 179             .getAlignmentAnnotation();
 180     selectedRow = -2;
 181     if (aa != null)
 182     {
 183       for (int i = 0; i < aa.length; i++)
 184       {
 185         selectedRow = -1;
 186         if (!aa[i].visible)
 187         {
 188           continue;
 189         }
 190
 191         height += aa[i].height;
 192
 193         if (y < height)
 194         {
 195           selectedRow = i;
 196
 197           break;
 198         }
 199       }
 200     }
 201   }
 202
 203   /**
 204    * DOCUMENT ME!
 205    *
 206    * @param evt
 207    *          DOCUMENT ME!
 208    */
 209   @Override
 210   public void actionPerformed(ActionEvent evt)
 211   {
 212     AlignmentAnnotation[] aa = ap.av.getAlignment()
 213             .getAlignmentAnnotation();
 214
 215     String action = evt.getActionCommand();
 216     if (ADDNEW.equals(action))
 217     {
 218       /*
 219        * non-returning dialog
 220        */
 221       AlignmentAnnotation newAnnotation = new AlignmentAnnotation(null,
 222               null, new Annotation[ap.av.getAlignment().getWidth()]);
 223       editLabelDescription(newAnnotation, true);
 224     }
 225     else if (EDITNAME.equals(action))
 226     {
 227       /*
 228        * non-returning dialog
 229        */
 230       editLabelDescription(aa[selectedRow], false);
 231     }
 232     else if (HIDE.equals(action))
 233     {
 234       aa[selectedRow].visible = false;
 235     }
 236     else if (DELETE.equals(action))
 237     {
 238       ap.av.getAlignment().deleteAnnotation(aa[selectedRow]);
 239       ap.av.getCalcManager().removeWorkerForAnnotation(aa[selectedRow]);
 240     }
 241     else if (SHOWALL.equals(action))
 242     {
 243       for (int i = 0; i < aa.length; i++)
 244       {
 245         if (!aa[i].visible && aa[i].annotations != null)
 246         {
 247           aa[i].visible = true;
 248         }
 249       }
 250     }
 251     else if (OUTPUT_TEXT.equals(action))
 252     {
 253       new AnnotationExporter(ap).exportAnnotation(aa[selectedRow]);
 254     }
 255     else if (COPYCONS_SEQ.equals(action))
 256     {
 257       SequenceI cons = null;
 258       if (aa[selectedRow].groupRef != null)
 259       {
 260         cons = aa[selectedRow].groupRef.getConsensusSeq();
 261       }
 262       else
 263       {
 264         cons = av.getConsensusSeq();
 265       }
 266       if (cons != null)
 267       {
 268         copy_annotseqtoclipboard(cons);
 269       }
 270     }
 271     else if (TOGGLE_LABELSCALE.equals(action))
 272     {
 273       aa[selectedRow].scaleColLabel = !aa[selectedRow].scaleColLabel;
 274     }
 275
 276     ap.refresh(true);
 277   }
 278
 279   /**
 280    * Shows a dialog where the annotation name and description may be edited. If
 281    * parameter addNew is true, then on confirmation, a new AlignmentAnnotation
 282    * is added, else an existing annotation is updated.
 283    *
 284    * @param annotation
 285    * @param addNew
 286    */
 287   void editLabelDescription(AlignmentAnnotation annotation, boolean addNew)
 288   {
 289     String name = MessageManager.getString("label.annotation_name");
 290     String description = MessageManager
 291             .getString("label.annotation_description");
 292     String title = MessageManager
 293             .getString("label.edit_annotation_name_description");
 294     EditNameDialog dialog = new EditNameDialog(annotation.label,
 295             annotation.description, name, description);
 296
 297     dialog.showDialog(ap.alignFrame, title, () -> {
 298       annotation.label = dialog.getName();
 299       String text = dialog.getDescription();
 300       if (text != null && text.length() == 0)
 301       {
 302         text = null;
 303       }
 304       annotation.description = text;
 305       if (addNew)
 306       {
 307         ap.av.getAlignment().addAnnotation(annotation);
 308         ap.av.getAlignment().setAnnotationIndex(annotation, 0);
 309       }
 310       ap.refresh(true);
 311     });
 312   }
 313
 314   @Override
 315   public void mousePressed(MouseEvent evt)
 316   {
 317     getSelectedRow(evt.getY() - getScrollOffset());
 318     oldY = evt.getY();
 319     if (evt.isPopupTrigger())
 320     {
 321       showPopupMenu(evt);
 322     }
 323   }
 324
 325   /**
 326    * Build and show the Pop-up menu at the right-click mouse position
 327    *
 328    * @param evt
 329    */
 330   void showPopupMenu(MouseEvent evt)
 331   {
 332     evt.consume();
 333     final AlignmentAnnotation[] aa = ap.av.getAlignment()
 334             .getAlignmentAnnotation();
 335
 336     JPopupMenu pop = new JPopupMenu(
 337             MessageManager.getString("label.annotations"));
 338     JMenuItem item = new JMenuItem(ADDNEW);
 339     item.addActionListener(this);
 340     pop.add(item);
 341     if (selectedRow < 0)
 342     {
 343       if (hasHiddenRows)
 344       { // let the user make everything visible again
 345         item = new JMenuItem(SHOWALL);
 346         item.addActionListener(this);
 347         pop.add(item);
 348       }
 349       pop.show(this, evt.getX(), evt.getY());
 350       return;
 351     }
 352     item = new JMenuItem(EDITNAME);
 353     item.addActionListener(this);
 354     pop.add(item);
 355     item = new JMenuItem(HIDE);
 356     item.addActionListener(this);
 357     pop.add(item);
 358     // JAL-1264 hide all sequence-specific annotations of this type
 359     if (selectedRow < aa.length)
 360     {
 361       if (aa[selectedRow].sequenceRef != null)
 362       {
 363         final String label = aa[selectedRow].label;
 364         JMenuItem hideType = new JMenuItem();
 365         String text = MessageManager.getString("label.hide_all") + " "
 366                 + label;
 367         hideType.setText(text);
 368         hideType.addActionListener(new ActionListener()
 369         {
 370           @Override
 371           public void actionPerformed(ActionEvent e)
 372           {
 373             AlignmentUtils.showOrHideSequenceAnnotations(
 374                     ap.av.getAlignment(), Collections.singleton(label),
 375                     null, false, false);
 376             ap.refresh(true);
 377           }
 378         });
 379         pop.add(hideType);
 380       }
 381     }
 382     item = new JMenuItem(DELETE);
 383     item.addActionListener(this);
 384     pop.add(item);
 385     if (hasHiddenRows)
 386     {
 387       item = new JMenuItem(SHOWALL);
 388       item.addActionListener(this);
 389       pop.add(item);
 390     }
 391     item = new JMenuItem(OUTPUT_TEXT);
 392     item.addActionListener(this);
 393     pop.add(item);
 394     // TODO: annotation object should be typed for autocalculated/derived
 395     // property methods
 396     if (selectedRow < aa.length)
 397     {
 398       final String label = aa[selectedRow].label;
 399       if (!aa[selectedRow].autoCalculated)
 400       {
 401         if (aa[selectedRow].graph == AlignmentAnnotation.NO_GRAPH)
 402         {
 403           // display formatting settings for this row.
 404           pop.addSeparator();
 405           // av and sequencegroup need to implement same interface for
 406           item = new JCheckBoxMenuItem(TOGGLE_LABELSCALE,
 407                   aa[selectedRow].scaleColLabel);
 408           item.addActionListener(this);
 409           pop.add(item);
 410         }
 411       }
 412       else if (label.indexOf("Consensus") > -1)
 413       {
 414         addConsensusMenuOptions(ap, aa[selectedRow], pop);
 415
 416         final JMenuItem consclipbrd = new JMenuItem(COPYCONS_SEQ);
 417         consclipbrd.addActionListener(this);
 418         pop.add(consclipbrd);
 419       }
 420
 421       addColourOrFilterByOptions(ap,aa[selectedRow],pop);
 422
 423       if (aa[selectedRow].graph == AlignmentAnnotation.CONTACT_MAP)
 424       {
 425         addContactMatrixOptions(ap,aa[selectedRow],pop);
 426           // Set/adjust threshold for grouping ?
 427           // colour alignment by this [type]
 428           // select/hide columns by this row
 429
 430         }
 431       }
 432
 433     pop.show(this, evt.getX(), evt.getY());
 434   }
 435
 436   static void addColourOrFilterByOptions(final AlignmentPanel ap,
 437           final AlignmentAnnotation alignmentAnnotation, final JPopupMenu pop)
 438   {
 439     JMenuItem item;
 440     item = new JMenuItem(MessageManager.getString("label.colour_by_annotation"));
 441     item.addActionListener(new ActionListener()
 442     {
 443
 444       @Override
 445       public void actionPerformed(ActionEvent e)
 446       {
 447         AnnotationColourChooser.displayFor(ap.av, ap,alignmentAnnotation,false);
 448       };
 449     });
 450     pop.add(item);
 451     if (alignmentAnnotation.sequenceRef!=null)
 452     {
 453       item = new JMenuItem(MessageManager.getString("label.colour_by_annotation")+" ("+MessageManager.getString("label.per_seq")+")");
 454       item.addActionListener(new ActionListener()
 455       {
 456         @Override
 457         public void actionPerformed(ActionEvent e)
 458         {
 459           AnnotationColourChooser.displayFor(ap.av, ap,alignmentAnnotation,true);
 460         };
 461       });
 462       pop.add(item);
 463     }
 464     item = new JMenuItem(MessageManager.getString("action.select_by_annotation"));
 465     item.addActionListener(new ActionListener()
 466     {
 467
 468       @Override
 469       public void actionPerformed(ActionEvent e)
 470       {
 471         AnnotationColumnChooser.displayFor(ap.av,ap,alignmentAnnotation);
 472       };
 473     });
 474     pop.add(item);
 475   }
 476   static void addContactMatrixOptions(final AlignmentPanel ap,
 477           final AlignmentAnnotation alignmentAnnotation, final JPopupMenu pop)
 478   {
 479
 480     final ContactMatrixI cm = ap.av.getContactMatrix(alignmentAnnotation);
 481     JMenuItem item;
 482     if (cm != null)
 483     {
 484       pop.addSeparator();
 485
 486       if (cm.hasGroups())
 487       {
 488         JCheckBoxMenuItem chitem = new JCheckBoxMenuItem("Show Groups on Matrix");
 489         boolean showGroups = alignmentAnnotation.isShowGroupsForContactMatrix();
 490         final AlignmentAnnotation sel_row=alignmentAnnotation;
 491         chitem.setState(showGroups);
 492         chitem.addActionListener(new ActionListener()
 493         {
 494
 495           @Override
 496           public void actionPerformed(ActionEvent e)
 497           {
 498             sel_row.setShowGroupsForContactMatrix(chitem.getState());
 499             ap.getAnnotationPanel()
 500             .paint(ap.getAnnotationPanel().getGraphics());
 501           }
 502         });
 503         pop.add(chitem);
 504       }
 505       if (cm.hasTree())
 506       {
 507         item = new JMenuItem("Show Tree for Matrix");
 508         item.addActionListener(new ActionListener()
 509         {
 510
 511           @Override
 512           public void actionPerformed(ActionEvent e)
 513           {
 514
 515             ap.alignFrame.showContactMapTree(alignmentAnnotation, cm);
 516
 517           }
 518         });
 519         pop.add(item);
 520       }
 521       else
 522       {
 523         item = new JMenuItem("Calculate Tree for Matrix");
 524         item.addActionListener(new ActionListener()
 525         {
 526           // TODO - refactor to analysis background thread
 527           @Override
 528           public void actionPerformed(ActionEvent e)
 529           {
 530             new Thread(new Runnable()
 531             {
 532               @Override
 533               public void run()
 534               {
 535                 AlignmentAnnotation alan = alignmentAnnotation;
 536                 cm.setGroupSet(GroupSet.makeGroups(cm, 5f, true));
 537                 ap.alignFrame.showContactMapTree(alan, cm);
 538               }
 539             }).start();
 540           }
 541         });
 542         pop.add(item);
 543       }
 544     }
 545   }
 546
 547   /**
 548    * A helper method that adds menu options for calculation and visualisation of
 549    * group and/or alignment consensus annotation to a popup menu. This is
 550    * designed to be reusable for either unwrapped mode (popup menu is shown on
 551    * component AnnotationLabels), or wrapped mode (popup menu is shown on
 552    * IdPanel when the mouse is over an annotation label).
 553    *
 554    * @param ap
 555    * @param ann
 556    * @param pop
 557    */
 558   static void addConsensusMenuOptions(AlignmentPanel ap,
 559           AlignmentAnnotation ann, JPopupMenu pop)
 560   {
 561     pop.addSeparator();
 562
 563     final JCheckBoxMenuItem cbmi = new JCheckBoxMenuItem(
 564             MessageManager.getString("label.ignore_gaps_consensus"),
 565             (ann.groupRef != null) ? ann.groupRef.getIgnoreGapsConsensus()
 566                     : ap.av.isIgnoreGapsConsensus());
 567     final AlignmentAnnotation aaa = ann;
 568     cbmi.addActionListener(new ActionListener()
 569     {
 570       @Override
 571       public void actionPerformed(ActionEvent e)
 572       {
 573         if (aaa.groupRef != null)
 574         {
 575           aaa.groupRef.setIgnoreGapsConsensus(cbmi.getState());
 576           ap.getAnnotationPanel()
 577                   .paint(ap.getAnnotationPanel().getGraphics());
 578         }
 579         else
 580         {
 581           ap.av.setIgnoreGapsConsensus(cbmi.getState(), ap);
 582         }
 583         ap.alignmentChanged();
 584       }
 585     });
 586     pop.add(cbmi);
 587
 588     if (aaa.groupRef != null)
 589     {
 590       /*
 591        * group consensus options
 592        */
 593       final JCheckBoxMenuItem chist = new JCheckBoxMenuItem(
 594               MessageManager.getString("label.show_group_histogram"),
 595               ann.groupRef.isShowConsensusHistogram());
 596       chist.addActionListener(new ActionListener()
 597       {
 598         @Override
 599         public void actionPerformed(ActionEvent e)
 600         {
 601           aaa.groupRef.setShowConsensusHistogram(chist.getState());
 602           ap.repaint();
 603         }
 604       });
 605       pop.add(chist);
 606       final JCheckBoxMenuItem cprofl = new JCheckBoxMenuItem(
 607               MessageManager.getString("label.show_group_logo"),
 608               ann.groupRef.isShowSequenceLogo());
 609       cprofl.addActionListener(new ActionListener()
 610       {
 611         @Override
 612         public void actionPerformed(ActionEvent e)
 613         {
 614           aaa.groupRef.setshowSequenceLogo(cprofl.getState());
 615           ap.repaint();
 616         }
 617       });
 618       pop.add(cprofl);
 619       final JCheckBoxMenuItem cproflnorm = new JCheckBoxMenuItem(
 620               MessageManager.getString("label.normalise_group_logo"),
 621               ann.groupRef.isNormaliseSequenceLogo());
 622       cproflnorm.addActionListener(new ActionListener()
 623       {
 624         @Override
 625         public void actionPerformed(ActionEvent e)
 626         {
 627           aaa.groupRef.setNormaliseSequenceLogo(cproflnorm.getState());
 628           // automatically enable logo display if we're clicked
 629           aaa.groupRef.setshowSequenceLogo(true);
 630           ap.repaint();
 631         }
 632       });
 633       pop.add(cproflnorm);
 634     }
 635     else
 636     {
 637       /*
 638        * alignment consensus options
 639        */
 640       final JCheckBoxMenuItem chist = new JCheckBoxMenuItem(
 641               MessageManager.getString("label.show_histogram"),
 642               ap.av.isShowConsensusHistogram());
 643       chist.addActionListener(new ActionListener()
 644       {
 645         @Override
 646         public void actionPerformed(ActionEvent e)
 647         {
 648           ap.av.setShowConsensusHistogram(chist.getState());
 649           ap.alignFrame.setMenusForViewport();
 650           ap.repaint();
 651         }
 652       });
 653       pop.add(chist);
 654       final JCheckBoxMenuItem cprof = new JCheckBoxMenuItem(
 655               MessageManager.getString("label.show_logo"),
 656               ap.av.isShowSequenceLogo());
 657       cprof.addActionListener(new ActionListener()
 658       {
 659         @Override
 660         public void actionPerformed(ActionEvent e)
 661         {
 662           ap.av.setShowSequenceLogo(cprof.getState());
 663           ap.alignFrame.setMenusForViewport();
 664           ap.repaint();
 665         }
 666       });
 667       pop.add(cprof);
 668       final JCheckBoxMenuItem cprofnorm = new JCheckBoxMenuItem(
 669               MessageManager.getString("label.normalise_logo"),
 670               ap.av.isNormaliseSequenceLogo());
 671       cprofnorm.addActionListener(new ActionListener()
 672       {
 673         @Override
 674         public void actionPerformed(ActionEvent e)
 675         {
 676           ap.av.setShowSequenceLogo(true);
 677           ap.av.setNormaliseSequenceLogo(cprofnorm.getState());
 678           ap.alignFrame.setMenusForViewport();
 679           ap.repaint();
 680         }
 681       });
 682       pop.add(cprofnorm);
 683     }
 684   }
 685
 686   /**
 687    * Reorders annotation rows after a drag of a label
 688    *
 689    * @param evt
 690    */
 691   @Override
 692   public void mouseReleased(MouseEvent evt)
 693   {
 694     if (evt.isPopupTrigger())
 695     {
 696       showPopupMenu(evt);
 697       return;
 698     }
 699
 700     int start = selectedRow;
 701     getSelectedRow(evt.getY() - getScrollOffset());
 702     int end = selectedRow;
 703
 704     /*
 705      * if dragging to resize instead, start == end
 706      */
 707     if (start != end)
 708     {
 709       // Swap these annotations
 710       AlignmentAnnotation startAA = ap.av.getAlignment()
 711               .getAlignmentAnnotation()[start];
 712       if (end == -1)
 713       {
 714         end = ap.av.getAlignment().getAlignmentAnnotation().length - 1;
 715       }
 716       AlignmentAnnotation endAA = ap.av.getAlignment()
 717               .getAlignmentAnnotation()[end];
 718
 719       ap.av.getAlignment().getAlignmentAnnotation()[end] = startAA;
 720       ap.av.getAlignment().getAlignmentAnnotation()[start] = endAA;
 721     }
 722
 723     resizePanel = false;
 724     dragEvent = null;
 725     repaint();
 726     ap.getAnnotationPanel().repaint();
 727   }
 728
 729   /**
 730    * Removes the height adjuster image on leaving the panel, unless currently
 731    * dragging it
 732    */
 733   @Override
 734   public void mouseExited(MouseEvent evt)
 735   {
 736     if (resizePanel && dragEvent == null)
 737     {
 738       resizePanel = false;
 739       repaint();
 740     }
 741   }
 742
 743   /**
 744    * A mouse drag may be either an adjustment of the panel height (if flag
 745    * resizePanel is set on), or a reordering of the annotation rows. The former
 746    * is dealt with by this method, the latter in mouseReleased.
 747    *
 748    * @param evt
 749    */
 750   @Override
 751   public void mouseDragged(MouseEvent evt)
 752   {
 753     dragEvent = evt;
 754
 755     if (resizePanel)
 756     {
 757       Dimension d = ap.annotationScroller.getPreferredSize();
 758       int dif = evt.getY() - oldY;
 759
 760       dif /= ap.av.getCharHeight();
 761       dif *= ap.av.getCharHeight();
 762
 763       if ((d.height - dif) > 20)
 764       {
 765         ap.annotationScroller
 766                 .setPreferredSize(new Dimension(d.width, d.height - dif));
 767         d = ap.annotationSpaceFillerHolder.getPreferredSize();
 768         ap.annotationSpaceFillerHolder
 769                 .setPreferredSize(new Dimension(d.width, d.height - dif));
 770         ap.paintAlignment(true, false);
 771       }
 772
 773       ap.addNotify();
 774     }
 775     else
 776     {
 777       repaint();
 778     }
 779   }
 780
 781   /**
 782    * Updates the tooltip as the mouse moves over the labels
 783    *
 784    * @param evt
 785    */
 786   @Override
 787   public void mouseMoved(MouseEvent evt)
 788   {
 789     showOrHideAdjuster(evt);
 790
 791     getSelectedRow(evt.getY() - getScrollOffset());
 792
 793     if (selectedRow > -1 && ap.av.getAlignment()
 794             .getAlignmentAnnotation().length > selectedRow)
 795     {
 796       AlignmentAnnotation[] anns = ap.av.getAlignment()
 797               .getAlignmentAnnotation();
 798       AlignmentAnnotation aa = anns[selectedRow];
 799
 800       String desc = getTooltip(aa);
 801       this.setToolTipText(desc);
 802       String msg = getStatusMessage(aa, anns);
 803       ap.alignFrame.setStatus(msg);
 804     }
 805   }
 806
 807   /**
 808    * Constructs suitable text to show in the status bar when over an annotation
 809    * label, containing the associated sequence name (if any), and the annotation
 810    * labels (or all labels for a graph group annotation)
 811    *
 812    * @param aa
 813    * @param anns
 814    * @return
 815    */
 816   static String getStatusMessage(AlignmentAnnotation aa,
 817           AlignmentAnnotation[] anns)
 818   {
 819     if (aa == null)
 820     {
 821       return null;
 822     }
 823
 824     StringBuilder msg = new StringBuilder(32);
 825     if (aa.sequenceRef != null)
 826     {
 827       msg.append(aa.sequenceRef.getName()).append(" : ");
 828     }
 829
 830     if (aa.graphGroup == -1)
 831     {
 832       msg.append(aa.label);
 833     }
 834     else if (anns != null)
 835     {
 836       boolean first = true;
 837       for (int i = anns.length - 1; i >= 0; i--)
 838       {
 839         if (anns[i].graphGroup == aa.graphGroup)
 840         {
 841           if (!first)
 842           {
 843             msg.append(", ");
 844           }
 845           msg.append(anns[i].label);
 846           first = false;
 847         }
 848       }
 849     }
 850
 851     return msg.toString();
 852   }
 853
 854   /**
 855    * Answers a tooltip, formatted as html, containing the annotation description
 856    * (prefixed by associated sequence id if applicable), and the annotation
 857    * (non-positional) score if it has one. Answers null if neither description
 858    * nor score is found.
 859    *
 860    * @param aa
 861    * @return
 862    */
 863   static String getTooltip(AlignmentAnnotation aa)
 864   {
 865     if (aa == null)
 866     {
 867       return null;
 868     }
 869     StringBuilder tooltip = new StringBuilder();
 870     if (aa.description != null && !aa.description.equals("New description"))
 871     {
 872       // TODO: we could refactor and merge this code with the code in
 873       // jalview.gui.SeqPanel.mouseMoved(..) that formats sequence feature
 874       // tooltips
 875       String desc = aa.getDescription(true).trim();
 876       if (!desc.toLowerCase(Locale.ROOT).startsWith(HTML_START_TAG))
 877       {
 878         tooltip.append(HTML_START_TAG);
 879         desc = desc.replace("<", "&lt;");
 880       }
 881       else if (desc.toLowerCase(Locale.ROOT).endsWith(HTML_END_TAG))
 882       {
 883         desc = desc.substring(0, desc.length() - HTML_END_TAG.length());
 884       }
 885       tooltip.append(desc);
 886     }
 887     else
 888     {
 889       // begin the tooltip's html fragment
 890       tooltip.append(HTML_START_TAG);
 891     }
 892     if (aa.hasScore())
 893     {
 894       if (tooltip.length() > HTML_START_TAG.length())
 895       {
 896         tooltip.append("<br/>");
 897       }
 898       // TODO: limit precision of score to avoid noise from imprecise
 899       // doubles
 900       // (64.7 becomes 64.7+/some tiny value).
 901       tooltip.append(" Score: ").append(String.valueOf(aa.score));
 902     }
 903
 904     if (tooltip.length() > HTML_START_TAG.length())
 905     {
 906       return tooltip.append(HTML_END_TAG).toString();
 907     }
 908
 909     /*
 910      * nothing in the tooltip (except "<html>")
 911      */
 912     return null;
 913   }
 914
 915   /**
 916    * Shows the height adjuster image if the mouse moves into the top left
 917    * region, or hides it if the mouse leaves the regio
 918    *
 919    * @param evt
 920    */
 921   protected void showOrHideAdjuster(MouseEvent evt)
 922   {
 923     boolean was = resizePanel;
 924     resizePanel = evt.getY() < HEIGHT_ADJUSTER_HEIGHT
 925             && evt.getX() < HEIGHT_ADJUSTER_WIDTH;
 926
 927     if (resizePanel != was)
 928     {
 929       setCursor(Cursor
 930               .getPredefinedCursor(resizePanel ? Cursor.S_RESIZE_CURSOR
 931                       : Cursor.DEFAULT_CURSOR));
 932       repaint();
 933     }
 934   }
 935
 936   @Override
 937   public void mouseClicked(MouseEvent evt)
 938   {
 939     final AlignmentAnnotation[] aa = ap.av.getAlignment()
 940             .getAlignmentAnnotation();
 941     if (!evt.isPopupTrigger() && SwingUtilities.isLeftMouseButton(evt))
 942     {
 943       if (selectedRow > -1 && selectedRow < aa.length)
 944       {
 945         if (aa[selectedRow].groupRef != null)
 946         {
 947           if (evt.getClickCount() >= 2)
 948           {
 949             // todo: make the ap scroll to the selection - not necessary, first
 950             // click highlights/scrolls, second selects
 951             ap.getSeqPanel().ap.getIdPanel().highlightSearchResults(null);
 952             // process modifiers
 953             SequenceGroup sg = ap.av.getSelectionGroup();
 954             if (sg == null || sg == aa[selectedRow].groupRef
 955                     || !(Platform.isControlDown(evt) || evt.isShiftDown()))
 956             {
 957               if (Platform.isControlDown(evt) || evt.isShiftDown())
 958               {
 959                 // clone a new selection group from the associated group
 960                 ap.av.setSelectionGroup(
 961                         new SequenceGroup(aa[selectedRow].groupRef));
 962               }
 963               else
 964               {
 965                 // set selection to the associated group so it can be edited
 966                 ap.av.setSelectionGroup(aa[selectedRow].groupRef);
 967               }
 968             }
 969             else
 970             {
 971               // modify current selection with associated group
 972               int remainToAdd = aa[selectedRow].groupRef.getSize();
 973               for (SequenceI sgs : aa[selectedRow].groupRef.getSequences())
 974               {
 975                 if (jalview.util.Platform.isControlDown(evt))
 976                 {
 977                   sg.addOrRemove(sgs, --remainToAdd == 0);
 978                 }
 979                 else
 980                 {
 981                   // notionally, we should also add intermediate sequences from
 982                   // last added sequence ?
 983                   sg.addSequence(sgs, --remainToAdd == 0);
 984                 }
 985               }
 986             }
 987
 988             ap.paintAlignment(false, false);
 989             PaintRefresher.Refresh(ap, ap.av.getSequenceSetId());
 990             ap.av.sendSelection();
 991           }
 992           else
 993           {
 994             ap.getSeqPanel().ap.getIdPanel().highlightSearchResults(
 995                     aa[selectedRow].groupRef.getSequences(null));
 996           }
 997           return;
 998         }
 999         else if (aa[selectedRow].sequenceRef != null)
1000         {
1001           if (evt.getClickCount() == 1)
1002           {
1003             ap.getSeqPanel().ap.getIdPanel()
1004                     .highlightSearchResults(Arrays.asList(new SequenceI[]
1005                     { aa[selectedRow].sequenceRef }));
1006           }
1007           else if (evt.getClickCount() >= 2)
1008           {
1009             ap.getSeqPanel().ap.getIdPanel().highlightSearchResults(null);
1010             SequenceGroup sg = ap.av.getSelectionGroup();
1011             if (sg != null)
1012             {
1013               // we make a copy rather than edit the current selection if no
1014               // modifiers pressed
1015               // see Enhancement JAL-1557
1016               if (!(Platform.isControlDown(evt) || evt.isShiftDown()))
1017               {
1018                 sg = new SequenceGroup(sg);
1019                 sg.clear();
1020                 sg.addSequence(aa[selectedRow].sequenceRef, false);
1021               }
1022               else
1023               {
1024                 if (Platform.isControlDown(evt))
1025                 {
1026                   sg.addOrRemove(aa[selectedRow].sequenceRef, true);
1027                 }
1028                 else
1029                 {
1030                   // notionally, we should also add intermediate sequences from
1031                   // last added sequence ?
1032                   sg.addSequence(aa[selectedRow].sequenceRef, true);
1033                 }
1034               }
1035             }
1036             else
1037             {
1038               sg = new SequenceGroup();
1039               sg.setStartRes(0);
1040               sg.setEndRes(ap.av.getAlignment().getWidth() - 1);
1041               sg.addSequence(aa[selectedRow].sequenceRef, false);
1042             }
1043             ap.av.setSelectionGroup(sg);
1044             ap.paintAlignment(false, false);
1045             PaintRefresher.Refresh(ap, ap.av.getSequenceSetId());
1046             ap.av.sendSelection();
1047           }
1048
1049         }
1050       }
1051       return;
1052     }
1053   }
1054
1055   /**
1056    * do a single sequence copy to jalview and the system clipboard
1057    *
1058    * @param sq
1059    *          sequence to be copied to clipboard
1060    */
1061   protected void copy_annotseqtoclipboard(SequenceI sq)
1062   {
1063     SequenceI[] seqs = new SequenceI[] { sq };
1064     String[] omitHidden = null;
1065     SequenceI[] dseqs = new SequenceI[] { sq.getDatasetSequence() };
1066     if (dseqs[0] == null)
1067     {
1068       dseqs[0] = new Sequence(sq);
1069       dseqs[0].setSequence(AlignSeq.extractGaps(Comparison.GapChars,
1070               sq.getSequenceAsString()));
1071
1072       sq.setDatasetSequence(dseqs[0]);
1073     }
1074     Alignment ds = new Alignment(dseqs);
1075     if (av.hasHiddenColumns())
1076     {
1077       Iterator<int[]> it = av.getAlignment().getHiddenColumns()
1078               .getVisContigsIterator(0, sq.getLength(), false);
1079       omitHidden = new String[] { sq.getSequenceStringFromIterator(it) };
1080     }
1081
1082     int[] alignmentStartEnd = new int[] { 0, ds.getWidth() - 1 };
1083     if (av.hasHiddenColumns())
1084     {
1085       alignmentStartEnd = av.getAlignment().getHiddenColumns()
1086               .getVisibleStartAndEndIndex(av.getAlignment().getWidth());
1087     }
1088
1089     String output = new FormatAdapter().formatSequences(FileFormat.Fasta,
1090             seqs, omitHidden, alignmentStartEnd);
1091
1092     Toolkit.getDefaultToolkit().getSystemClipboard()
1093             .setContents(new StringSelection(output), Desktop.instance);
1094
1095     HiddenColumns hiddenColumns = null;
1096
1097     if (av.hasHiddenColumns())
1098     {
1099       hiddenColumns = new HiddenColumns(
1100               av.getAlignment().getHiddenColumns());
1101     }
1102
1103     Desktop.jalviewClipboard = new Object[] { seqs, ds, // what is the dataset
1104                                                         // of a consensus
1105                                                         // sequence ? need to
1106                                                         // flag
1107         // sequence as special.
1108         hiddenColumns };
1109   }
1110
1111   /**
1112    * DOCUMENT ME!
1113    *
1114    * @param g1
1115    *          DOCUMENT ME!
1116    */
1117   @Override
1118   public void paintComponent(Graphics g)
1119   {
1120
1121     int width = getWidth();
1122     if (width == 0)
1123     {
1124       width = ap.calculateIdWidth().width;
1125     }
1126
1127     Graphics2D g2 = (Graphics2D) g;
1128     if (av.antiAlias)
1129     {
1130       g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
1131               RenderingHints.VALUE_ANTIALIAS_ON);
1132     }
1133
1134     drawComponent(g2, true, width);
1135
1136   }
1137
1138   /**
1139    * Draw the full set of annotation Labels for the alignment at the given
1140    * cursor
1141    *
1142    * @param g
1143    *          Graphics2D instance (needed for font scaling)
1144    * @param width
1145    *          Width for scaling labels
1146    *
1147    */
1148   public void drawComponent(Graphics g, int width)
1149   {
1150     drawComponent(g, false, width);
1151   }
1152
1153   /**
1154    * Draw the full set of annotation Labels for the alignment at the given
1155    * cursor
1156    *
1157    * @param g
1158    *          Graphics2D instance (needed for font scaling)
1159    * @param clip
1160    *          - true indicates that only current visible area needs to be
1161    *          rendered
1162    * @param width
1163    *          Width for scaling labels
1164    */
1165   public void drawComponent(Graphics g, boolean clip, int width)
1166   {
1167     if (av.getFont().getSize() < 10)
1168     {
1169       g.setFont(font);
1170     }
1171     else
1172     {
1173       g.setFont(av.getFont());
1174     }
1175
1176     FontMetrics fm = g.getFontMetrics(g.getFont());
1177     g.setColor(Color.white);
1178     g.fillRect(0, 0, getWidth(), getHeight());
1179
1180     g.translate(0, getScrollOffset());
1181     g.setColor(Color.black);
1182     SequenceI lastSeqRef = null;
1183     String lastLabel = null;
1184     AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
1185     int fontHeight = g.getFont().getSize();
1186     int y = 0;
1187     int x = 0;
1188     int graphExtras = 0;
1189     int offset = 0;
1190     Font baseFont = g.getFont();
1191     FontMetrics baseMetrics = fm;
1192     int ofontH = fontHeight;
1193     int sOffset = 0;
1194     int visHeight = 0;
1195     int[] visr = (ap != null && ap.getAnnotationPanel() != null)
1196             ? ap.getAnnotationPanel().getVisibleVRange()
1197             : null;
1198     if (clip && visr != null)
1199     {
1200       sOffset = visr[0];
1201       visHeight = visr[1];
1202     }
1203     boolean visible = true, before = false, after = false;
1204     if (aa != null)
1205     {
1206       hasHiddenRows = false;
1207       int olY = 0;
1208       int nexAA = 0;
1209       for (int i = 0; i < aa.length; i++)
1210       {
1211         visible = true;
1212         if (!aa[i].visible)
1213         {
1214           hasHiddenRows = true;
1215           continue;
1216         }
1217         olY = y;
1218         // look ahead to next annotation
1219         for (nexAA = i + 1; nexAA < aa.length
1220                 && !aa[nexAA].visible; nexAA++)
1221           ;
1222         y += aa[i].height;
1223         if (clip)
1224         {
1225           if (y < sOffset)
1226           {
1227             if (!before)
1228             {
1229               if (debugRedraw)
1230               {
1231                 System.out.println("before vis: " + i);
1232               }
1233               before = true;
1234             }
1235             // don't draw what isn't visible
1236             continue;
1237           }
1238           if (olY > visHeight)
1239           {
1240
1241             if (!after)
1242             {
1243               if (debugRedraw)
1244               {
1245                 System.out.println(
1246                         "Scroll offset: " + sOffset + " after vis: " + i);
1247               }
1248               after = true;
1249             }
1250             // don't draw what isn't visible
1251             continue;
1252           }
1253         }
1254         g.setColor(Color.black);
1255
1256         offset = -aa[i].height / 2;
1257
1258         if (aa[i].hasText)
1259         {
1260           offset += fm.getHeight() / 2;
1261           offset -= fm.getDescent();
1262         }
1263         else
1264         {
1265           offset += fm.getDescent();
1266         }
1267         String label = aa[i].label;
1268         boolean vertBar = false;
1269         if ((lastLabel != null && lastLabel.equals(label)))
1270         {
1271           label = aa[i].description;
1272         }
1273         else
1274         {
1275           if (nexAA < aa.length && label.equals(aa[nexAA].label)) // &&
1276                                                                   // aa[nexY].sequenceRef==aa[i].sequenceRef)
1277           {
1278             lastLabel = label;
1279             // next label is the same as this label
1280             label = aa[i].description;
1281           }
1282           else
1283           {
1284             lastLabel = label;
1285           }
1286         }
1287         if (aa[i].sequenceRef != null)
1288         {
1289           if (aa[i].sequenceRef != lastSeqRef)
1290           {
1291             label = aa[i].sequenceRef.getName() + " " + label;
1292             // TODO record relationship between sequence and this annotation and
1293             // display it here
1294           }
1295           else
1296           {
1297             vertBar = true;
1298           }
1299         }
1300         x = width - fm.stringWidth(label) - 3;
1301
1302         if (aa[i].graphGroup > -1)
1303         {
1304           int groupSize = 0;
1305           // TODO: JAL-1291 revise rendering model so the graphGroup map is
1306           // computed efficiently for all visible labels
1307           for (int gg = 0; gg < aa.length; gg++)
1308           {
1309             if (aa[gg].graphGroup == aa[i].graphGroup)
1310             {
1311               groupSize++;
1312             }
1313           }
1314           if (groupSize * (fontHeight + 8) < aa[i].height)
1315           {
1316             graphExtras = (aa[i].height - (groupSize * (fontHeight + 8)))
1317                     / 2;
1318           }
1319           else
1320           {
1321             // scale font to fit
1322             float h = aa[i].height / (float) groupSize, s;
1323             if (h < 9)
1324             {
1325               visible = false;
1326             }
1327             else
1328             {
1329               fontHeight = -8 + (int) h;
1330               s = ((float) fontHeight) / (float) ofontH;
1331               Font f = baseFont
1332                       .deriveFont(AffineTransform.getScaleInstance(s, s));
1333               g.setFont(f);
1334               fm = g.getFontMetrics();
1335               graphExtras = (aa[i].height - (groupSize * (fontHeight + 8)))
1336                       / 2;
1337             }
1338           }
1339           if (visible)
1340           {
1341             for (int gg = 0; gg < aa.length; gg++)
1342             {
1343               if (aa[gg].graphGroup == aa[i].graphGroup)
1344               {
1345                 x = width - fm.stringWidth(aa[gg].label) - 3;
1346                 g.drawString(aa[gg].label, x, y - graphExtras);
1347
1348                 if (aa[gg]._linecolour != null)
1349                 {
1350
1351                   g.setColor(aa[gg]._linecolour);
1352                   g.drawLine(x, y - graphExtras + 3,
1353                           x + fm.stringWidth(aa[gg].label),
1354                           y - graphExtras + 3);
1355                 }
1356
1357                 g.setColor(Color.black);
1358                 graphExtras += fontHeight + 8;
1359               }
1360             }
1361           }
1362           g.setFont(baseFont);
1363           fm = baseMetrics;
1364           fontHeight = ofontH;
1365         }
1366         else
1367         {
1368           if (vertBar)
1369           {
1370             g.drawLine(width - 3, y + offset - fontHeight, width - 3,
1371                     (int) (y - 1.5 * aa[i].height - offset - fontHeight));
1372             // g.drawLine(20, y + offset, x - 20, y + offset);
1373
1374           }
1375           g.drawString(label, x, y + offset);
1376         }
1377         lastSeqRef = aa[i].sequenceRef;
1378       }
1379     }
1380
1381     if (!resizePanel && dragEvent != null && aa != null)
1382     {
1383       g.setColor(Color.lightGray);
1384       g.drawString(
1385               (aa[selectedRow].sequenceRef == null ? ""
1386                       : aa[selectedRow].sequenceRef.getName())
1387                       + aa[selectedRow].label,
1388               dragEvent.getX(), dragEvent.getY() - getScrollOffset());
1389     }
1390
1391     if (!av.getWrapAlignment() && ((aa == null) || (aa.length < 1)))
1392     {
1393       g.drawString(MessageManager.getString("label.right_click"), 2, 8);
1394       g.drawString(MessageManager.getString("label.to_add_annotation"), 2,
1395               18);
1396     }
1397   }
1398
1399   public int getScrollOffset()
1400   {
1401     return scrollOffset;
1402   }
1403
1404   @Override
1405   public void mouseEntered(MouseEvent e)
1406   {
1407   }
1408 }