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