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