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