src/jalview/gui/AnnotationPanel.java

   1 /*\r
   2  * Jalview - A Sequence Alignment Editor and Viewer\r
   3  * Copyright (C) 2006 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
   4  *\r
   5  * This program is free software; you can redistribute it and/or\r
   6  * modify it under the terms of the GNU General Public License\r
   7  * as published by the Free Software Foundation; either version 2\r
   8  * of the License, or (at your option) any later version.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful,\r
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13  * GNU General Public License for more details.\r
  14  *\r
  15  * You should have received a copy of the GNU General Public License\r
  16  * along with this program; if not, write to the Free Software\r
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
  18  */\r
  19 package jalview.gui;\r
  20 \r
  21 import jalview.datamodel.*;\r
  22 \r
  23 import java.awt.*;\r
  24 import java.awt.event.*;\r
  25 import java.awt.image.*;\r
  26 \r
  27 import javax.swing.*;\r
  28 \r
  29 \r
  30 /**\r
  31  * DOCUMENT ME!\r
  32  *\r
  33  * @author $author$\r
  34  * @version $Revision$\r
  35  */\r
  36 public class AnnotationPanel extends JPanel implements MouseListener,\r
  37     MouseMotionListener, ActionListener, AdjustmentListener\r
  38 {\r
  39     final String HELIX = "Helix";\r
  40     final String SHEET = "Sheet";\r
  41     final String LABEL = "Label";\r
  42     final String REMOVE = "Remove Annotation";\r
  43     final String COLOUR = "Colour";\r
  44     final Color HELIX_COLOUR = Color.red.darker();\r
  45     final Color SHEET_COLOUR = Color.green.darker().darker();\r
  46 \r
  47     /** DOCUMENT ME!! */\r
  48     AlignViewport av;\r
  49     AlignmentPanel ap;\r
  50     int activeRow = -1;\r
  51     BufferedImage image;\r
  52     Graphics2D gg;\r
  53     FontMetrics fm;\r
  54     int imgWidth = 0;\r
  55     boolean fastPaint = false;\r
  56 \r
  57     //Used For mouse Dragging and resizing graphs\r
  58     int graphStretch = -1;\r
  59     int graphStretchY = -1;\r
  60     int min; //used by mouseDragged to see if user\r
  61     int max; //used by mouseDragged to see if user\r
  62     boolean mouseDragging = false;\r
  63 \r
  64     boolean MAC = false;\r
  65 \r
  66     /**\r
  67      * Creates a new AnnotationPanel object.\r
  68      *\r
  69      * @param ap DOCUMENT ME!\r
  70      */\r
  71     public AnnotationPanel(AlignmentPanel ap)\r
  72     {\r
  73 \r
  74     if(System.getProperty("os.name").startsWith("Mac"))\r
  75       MAC = true;\r
  76 \r
  77         ToolTipManager.sharedInstance().registerComponent(this);\r
  78         ToolTipManager.sharedInstance().setInitialDelay(0);\r
  79         ToolTipManager.sharedInstance().setDismissDelay(10000);\r
  80         this.ap = ap;\r
  81         av = ap.av;\r
  82         this.setLayout(null);\r
  83         addMouseListener(this);\r
  84         addMouseMotionListener(this);\r
  85         ap.annotationScroller.getVerticalScrollBar().addAdjustmentListener(this);\r
  86     }\r
  87 \r
  88     public AnnotationPanel(AlignViewport av)\r
  89     {\r
  90       this.av = av;\r
  91     }\r
  92 \r
  93 \r
  94     /**\r
  95      * DOCUMENT ME!\r
  96      *\r
  97      * @param evt DOCUMENT ME!\r
  98      */\r
  99     public void adjustmentValueChanged(AdjustmentEvent evt)\r
 100     {\r
 101         ap.alabels.setScrollOffset(-evt.getValue());\r
 102     }\r
 103 \r
 104     /**\r
 105      * DOCUMENT ME!\r
 106      */\r
 107     public int adjustPanelHeight()\r
 108     {\r
 109         // setHeight of panels\r
 110         image = null;\r
 111         AlignmentAnnotation[] aa = av.alignment.getAlignmentAnnotation();\r
 112         int height = 0;\r
 113 \r
 114         if (aa != null)\r
 115         {\r
 116             for (int i = 0; i < aa.length; i++)\r
 117             {\r
 118                 if (!aa[i].visible)\r
 119                 {\r
 120                     continue;\r
 121                 }\r
 122 \r
 123                 aa[i].height = 0;\r
 124 \r
 125                 if (aa[i].hasText)\r
 126                 {\r
 127                     aa[i].height += av.charHeight;\r
 128                 }\r
 129 \r
 130                 if (aa[i].hasIcons)\r
 131                 {\r
 132                     aa[i].height += 16;\r
 133                 }\r
 134 \r
 135                 if (aa[i].graph>0)\r
 136                 {\r
 137                     aa[i].height += aa[i].graphHeight;\r
 138                 }\r
 139 \r
 140                 if (aa[i].height == 0)\r
 141                 {\r
 142                     aa[i].height = 20;\r
 143                 }\r
 144 \r
 145                 height += aa[i].height;\r
 146             }\r
 147         }\r
 148         else\r
 149         {\r
 150             height = 20;\r
 151         }\r
 152 \r
 153         this.setPreferredSize(new Dimension(1, height));\r
 154 \r
 155         return height;\r
 156     }\r
 157 \r
 158 \r
 159 \r
 160     /**\r
 161      * DOCUMENT ME!\r
 162      *\r
 163      * @param evt DOCUMENT ME!\r
 164      */\r
 165     public void actionPerformed(ActionEvent evt)\r
 166     {\r
 167         AlignmentAnnotation[] aa = av.alignment.getAlignmentAnnotation();\r
 168         Annotation[] anot = aa[activeRow].annotations;\r
 169 \r
 170         if (evt.getActionCommand().equals(REMOVE))\r
 171         {\r
 172             for (int i = 0; i < av.getColumnSelection().size(); i++)\r
 173             {\r
 174                 anot[av.getColumnSelection().columnAt(i)] = null;\r
 175             }\r
 176         }\r
 177         else if (evt.getActionCommand().equals(LABEL))\r
 178         {\r
 179             String label = JOptionPane.showInputDialog(this, "Enter Label ",\r
 180                     "Enter label", JOptionPane.QUESTION_MESSAGE);\r
 181 \r
 182             if (label == null)\r
 183             {\r
 184                 return;\r
 185             }\r
 186 \r
 187             if ((label.length() > 0) && !aa[activeRow].hasText)\r
 188             {\r
 189                 aa[activeRow].hasText = true;\r
 190             }\r
 191 \r
 192             for (int i = 0; i < av.getColumnSelection().size(); i++)\r
 193             {\r
 194                 int index = av.getColumnSelection().columnAt(i);\r
 195 \r
 196                 if (anot[index] == null)\r
 197                 {\r
 198                     anot[index] = new Annotation(label, "", ' ', 0);\r
 199                 }\r
 200 \r
 201                 anot[index].displayCharacter = label;\r
 202             }\r
 203         }\r
 204         else if (evt.getActionCommand().equals(COLOUR))\r
 205         {\r
 206             Color col = JColorChooser.showDialog(this,\r
 207                     "Choose foreground colour", Color.black);\r
 208 \r
 209             for (int i = 0; i < av.getColumnSelection().size(); i++)\r
 210             {\r
 211                 int index = av.getColumnSelection().columnAt(i);\r
 212 \r
 213                 if (anot[index] == null)\r
 214                 {\r
 215                     anot[index] = new Annotation("", "", ' ', 0);\r
 216                 }\r
 217 \r
 218                 anot[index].colour = col;\r
 219             }\r
 220         }\r
 221         else // HELIX OR SHEET\r
 222         {\r
 223             char type = 0;\r
 224             String symbol = "\u03B1";\r
 225 \r
 226             if (evt.getActionCommand().equals(HELIX))\r
 227             {\r
 228                 type = 'H';\r
 229             }\r
 230             else if (evt.getActionCommand().equals(SHEET))\r
 231             {\r
 232                 type = 'E';\r
 233                 symbol = "\u03B2";\r
 234             }\r
 235 \r
 236             if (!aa[activeRow].hasIcons)\r
 237             {\r
 238                 aa[activeRow].hasIcons = true;\r
 239             }\r
 240 \r
 241             String label = JOptionPane.showInputDialog("Enter a label for the structure?",\r
 242                     symbol);\r
 243 \r
 244             if (label == null)\r
 245             {\r
 246                 return;\r
 247             }\r
 248 \r
 249             if ((label.length() > 0) && !aa[activeRow].hasText)\r
 250             {\r
 251                 aa[activeRow].hasText = true;\r
 252             }\r
 253 \r
 254             for (int i = 0; i < av.getColumnSelection().size(); i++)\r
 255             {\r
 256                 int index = av.getColumnSelection().columnAt(i);\r
 257 \r
 258                 if (anot[index] == null)\r
 259                 {\r
 260                     anot[index] = new Annotation(label, "", type, 0);\r
 261                 }\r
 262 \r
 263                 anot[index].secondaryStructure = type;\r
 264                 anot[index].displayCharacter = label;\r
 265             }\r
 266         }\r
 267 \r
 268         adjustPanelHeight();\r
 269         repaint();\r
 270 \r
 271         return;\r
 272     }\r
 273 \r
 274     /**\r
 275      * DOCUMENT ME!\r
 276      *\r
 277      * @param evt DOCUMENT ME!\r
 278      */\r
 279     public void mousePressed(MouseEvent evt)\r
 280     {\r
 281 \r
 282 \r
 283         AlignmentAnnotation[] aa = av.alignment.getAlignmentAnnotation();\r
 284         if(aa==null)\r
 285           return;\r
 286 \r
 287 \r
 288         int height = 0;\r
 289         activeRow = -1;\r
 290 \r
 291 \r
 292         for (int i = 0; i < aa.length; i++)\r
 293         {\r
 294             if (aa[i].visible)\r
 295             {\r
 296               height += aa[i].height;\r
 297             }\r
 298 \r
 299             if (evt.getY() < height)\r
 300             {\r
 301                 if (aa[i].editable)\r
 302                 {\r
 303                     activeRow = i;\r
 304                 }\r
 305                 else if(aa[i].graph>0)\r
 306                 {\r
 307                     //Stretch Graph\r
 308                     graphStretch = i;\r
 309                     graphStretchY = evt.getY();\r
 310                 }\r
 311 \r
 312                 break;\r
 313             }\r
 314         }\r
 315 \r
 316 \r
 317         if (SwingUtilities.isRightMouseButton(evt) && activeRow!=-1)\r
 318         {\r
 319             if (av.getColumnSelection() == null)\r
 320             {\r
 321                 return;\r
 322             }\r
 323 \r
 324             JPopupMenu pop = new JPopupMenu("Structure type");\r
 325             JMenuItem item = new JMenuItem(HELIX);\r
 326             item.addActionListener(this);\r
 327             pop.add(item);\r
 328             item = new JMenuItem(SHEET);\r
 329             item.addActionListener(this);\r
 330             pop.add(item);\r
 331             item = new JMenuItem(LABEL);\r
 332             item.addActionListener(this);\r
 333             pop.add(item);\r
 334             item = new JMenuItem(COLOUR);\r
 335             item.addActionListener(this);\r
 336             pop.add(item);\r
 337             item = new JMenuItem(REMOVE);\r
 338             item.addActionListener(this);\r
 339             pop.add(item);\r
 340             pop.show(this, evt.getX(), evt.getY());\r
 341 \r
 342             return;\r
 343         }\r
 344 \r
 345         if (aa == null)\r
 346         {\r
 347             return;\r
 348         }\r
 349 \r
 350         int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();\r
 351 \r
 352         min = res;\r
 353         max = res;\r
 354 \r
 355         if (av.getColumnSelection().contains(res))\r
 356           av.getColumnSelection().removeElement(res);\r
 357         else\r
 358         {\r
 359             av.getColumnSelection().addElement(res);\r
 360             SequenceGroup sg = new SequenceGroup();\r
 361 \r
 362             for (int i = 0; i < av.alignment.getSequences().size(); i++)\r
 363             {\r
 364                 sg.addSequence(av.alignment.getSequenceAt(i), false);\r
 365             }\r
 366 \r
 367             sg.setStartRes(res);\r
 368             sg.setEndRes(res);\r
 369             av.setSelectionGroup(sg);\r
 370         }\r
 371 \r
 372         ap.repaint();\r
 373 \r
 374     }\r
 375 \r
 376     /**\r
 377      * DOCUMENT ME!\r
 378      *\r
 379      * @param evt DOCUMENT ME!\r
 380      */\r
 381     public void mouseReleased(MouseEvent evt)\r
 382     {\r
 383       graphStretch = -1;\r
 384       graphStretchY = -1;\r
 385       mouseDragging = false;\r
 386     }\r
 387 \r
 388     /**\r
 389      * DOCUMENT ME!\r
 390      *\r
 391      * @param evt DOCUMENT ME!\r
 392      */\r
 393     public void mouseEntered(MouseEvent evt)\r
 394     {\r
 395       if(mouseDragging)\r
 396         ap.seqPanel.scrollCanvas(null);\r
 397     }\r
 398 \r
 399     /**\r
 400      * DOCUMENT ME!\r
 401      *\r
 402      * @param evt DOCUMENT ME!\r
 403      */\r
 404     public void mouseExited(MouseEvent evt)\r
 405     {\r
 406       if(mouseDragging)\r
 407         ap.seqPanel.scrollCanvas(evt);\r
 408     }\r
 409 \r
 410 \r
 411     /**\r
 412      * DOCUMENT ME!\r
 413      *\r
 414      * @param evt DOCUMENT ME!\r
 415      */\r
 416     public void mouseDragged(MouseEvent evt)\r
 417     {\r
 418       if(graphStretch>-1)\r
 419       {\r
 420         av.alignment.getAlignmentAnnotation()[graphStretch].graphHeight += graphStretchY - evt.getY();\r
 421         if(av.alignment.getAlignmentAnnotation()[graphStretch].graphHeight <0)\r
 422           av.alignment.getAlignmentAnnotation()[graphStretch].graphHeight = 0;\r
 423         graphStretchY = evt.getY();\r
 424         adjustPanelHeight();\r
 425         ap.repaint();\r
 426       }\r
 427       else\r
 428       {\r
 429         mouseDragging = true;\r
 430 \r
 431         int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();\r
 432 \r
 433         SequenceGroup sg = av.getSelectionGroup();\r
 434 \r
 435         if (res < min)\r
 436         {\r
 437             min = res;\r
 438         }\r
 439 \r
 440         if (res > max)\r
 441         {\r
 442             max = res;\r
 443         }\r
 444 \r
 445         if (sg != null)\r
 446         {\r
 447             if (!av.getColumnSelection().contains(res))\r
 448             {\r
 449                 av.getColumnSelection().addElement(res);\r
 450             }\r
 451 \r
 452             if (res > sg.getStartRes())\r
 453             {\r
 454                 sg.setEndRes(res);\r
 455             }\r
 456             else if (res < sg.getStartRes())\r
 457             {\r
 458                 sg.setStartRes(res);\r
 459             }\r
 460 \r
 461             for (int i = min; i <= max; i++)\r
 462             {\r
 463                 if ((i < sg.getStartRes()) || (i > sg.getEndRes()))\r
 464                 {\r
 465                     av.getColumnSelection().removeElement(i);\r
 466                 }\r
 467                 else\r
 468                 {\r
 469                     av.getColumnSelection().addElement(i);\r
 470                 }\r
 471             }\r
 472 \r
 473             ap.repaint();\r
 474         }\r
 475 \r
 476       }\r
 477     }\r
 478 \r
 479     /**\r
 480      * DOCUMENT ME!\r
 481      *\r
 482      * @param evt DOCUMENT ME!\r
 483      */\r
 484     public void mouseMoved(MouseEvent evt)\r
 485     {\r
 486         AlignmentAnnotation[] aa = av.alignment.getAlignmentAnnotation();\r
 487 \r
 488         if (aa == null)\r
 489         {\r
 490             return;\r
 491         }\r
 492 \r
 493         int row = -1;\r
 494         int height = 0;\r
 495 \r
 496         for (int i = 0; i < aa.length; i++)\r
 497         {\r
 498             if (aa[i].visible)\r
 499             {\r
 500                 height += aa[i].height;\r
 501             }\r
 502 \r
 503             if (evt.getY() < height)\r
 504             {\r
 505                 row = i;\r
 506 \r
 507                 break;\r
 508             }\r
 509         }\r
 510 \r
 511         int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();\r
 512 \r
 513         if(av.hasHiddenColumns)\r
 514           res = av.getColumnSelection().adjustForHiddenColumns(res);\r
 515 \r
 516         if (row > -1 && res<aa[row].annotations.length)\r
 517         {\r
 518             if(aa[row].graphGroup>-1)\r
 519             {\r
 520               StringBuffer tip = new StringBuffer("<html>");\r
 521               for (int gg = 0; gg < aa.length; gg++)\r
 522               {\r
 523                 if (aa[gg].graphGroup == aa[row].graphGroup && aa[gg].annotations[res]!=null)\r
 524                   tip.append(aa[gg].label+" "+aa[gg].annotations[res].description+"<br>" );\r
 525               }\r
 526               if(tip.length()!=6)\r
 527               {\r
 528                 tip.setLength(tip.length() - 4);\r
 529                 this.setToolTipText(tip.toString() + "</html>");\r
 530               }\r
 531             }\r
 532             else if(aa[row].annotations[res] != null)\r
 533               this.setToolTipText(aa[row].annotations[res].description);\r
 534 \r
 535             if(aa[row].annotations[res]!=null)\r
 536             {\r
 537               StringBuffer text = new StringBuffer("Sequence position " +\r
 538                                                    (res + 1) + "  " +\r
 539                                                    aa[row].annotations[res].description);\r
 540 \r
 541               ap.alignFrame.statusBar.setText(text.toString());\r
 542             }\r
 543         }\r
 544     }\r
 545 \r
 546     /**\r
 547      * DOCUMENT ME!\r
 548      *\r
 549      * @param evt DOCUMENT ME!\r
 550      */\r
 551     public void mouseClicked(MouseEvent evt)\r
 552     {\r
 553     }\r
 554 \r
 555     /**\r
 556      * DOCUMENT ME!\r
 557      *\r
 558      * @param g DOCUMENT ME!\r
 559      */\r
 560     public void paintComponent(Graphics g)\r
 561     {\r
 562       g.setColor(Color.white);\r
 563       g.fillRect(0, 0, getWidth(), getHeight());\r
 564 \r
 565       if(image!=null)\r
 566       {if (fastPaint\r
 567             || (getVisibleRect().width != g.getClipBounds().width)\r
 568             || (getVisibleRect().height != g.getClipBounds().height))\r
 569         {\r
 570           g.drawImage(image, 0, 0, this);\r
 571           fastPaint = false;\r
 572           return;\r
 573         }\r
 574       }\r
 575       imgWidth = (av.endRes - av.startRes + 1) * av.charWidth;\r
 576 \r
 577       if (image == null || imgWidth != image.getWidth()\r
 578           || image.getHeight(this) != getHeight())\r
 579       {\r
 580         image = new BufferedImage(imgWidth, ap.annotationPanel.getHeight(),\r
 581                                   BufferedImage.TYPE_INT_RGB);\r
 582         gg = (Graphics2D) image.getGraphics();\r
 583 \r
 584         if(av.antiAlias)\r
 585         gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,\r
 586                             RenderingHints.VALUE_ANTIALIAS_ON);\r
 587 \r
 588         gg.setFont(av.getFont());\r
 589         fm = gg.getFontMetrics();\r
 590       }\r
 591 \r
 592 \r
 593       drawComponent(gg, av.startRes, av.endRes + 1);\r
 594       g.drawImage(image, 0, 0, this);\r
 595     }\r
 596 \r
 597     /**\r
 598      * DOCUMENT ME!\r
 599      *\r
 600      * @param horizontal DOCUMENT ME!\r
 601      */\r
 602     public void fastPaint(int horizontal)\r
 603     {\r
 604         if ((horizontal == 0) || gg==null ||\r
 605                 (av.alignment.getAlignmentAnnotation() == null) ||\r
 606                 (av.alignment.getAlignmentAnnotation().length < 1))\r
 607         {\r
 608             repaint();\r
 609             return;\r
 610         }\r
 611 \r
 612         gg.copyArea(0, 0, imgWidth, getHeight(), -horizontal * av.charWidth, 0);\r
 613 \r
 614         int sr = av.startRes;\r
 615         int er = av.endRes + 1;\r
 616         int transX = 0;\r
 617 \r
 618         if (horizontal > 0) // scrollbar pulled right, image to the left\r
 619         {\r
 620             transX = (er - sr - horizontal) * av.charWidth;\r
 621             sr = er - horizontal;\r
 622         }\r
 623         else if (horizontal < 0)\r
 624         {\r
 625             er = sr - horizontal;\r
 626         }\r
 627 \r
 628         gg.translate(transX, 0);\r
 629 \r
 630         drawComponent(gg, sr, er);\r
 631 \r
 632         gg.translate(-transX, 0);\r
 633 \r
 634         fastPaint = true;\r
 635 \r
 636         repaint();\r
 637 \r
 638     }\r
 639 \r
 640     /**\r
 641      * DOCUMENT ME!\r
 642      *\r
 643      * @param g DOCUMENT ME!\r
 644      * @param startRes DOCUMENT ME!\r
 645      * @param endRes DOCUMENT ME!\r
 646      */\r
 647     public void drawComponent(Graphics g, int startRes, int endRes)\r
 648     {\r
 649       g.setFont(av.getFont());\r
 650 \r
 651       if (fm == null)\r
 652         fm = g.getFontMetrics();\r
 653 \r
 654 \r
 655         g.setColor(Color.white);\r
 656         g.fillRect(0, 0, (endRes - startRes) * av.charWidth, getHeight());\r
 657 \r
 658         if ( (av.alignment.getAlignmentAnnotation() == null) ||\r
 659                 (av.alignment.getAlignmentAnnotation().length < 1))\r
 660         {\r
 661             g.setColor(Color.white);\r
 662             g.fillRect(0, 0, getWidth(), getHeight());\r
 663             g.setColor(Color.black);\r
 664             if(av.validCharWidth)\r
 665               g.drawString("Alignment has no annotations", 20, 15);\r
 666 \r
 667             return;\r
 668         }\r
 669 \r
 670 \r
 671         AlignmentAnnotation[] aa = av.alignment.getAlignmentAnnotation();\r
 672 \r
 673         int x = 0, y = 0;\r
 674         int column=0;\r
 675         char lastSS;\r
 676         int lastSSX;\r
 677         int iconOffset = av.charHeight / 2;\r
 678         boolean validRes = false;\r
 679 \r
 680         boolean [] graphGroupDrawn = new boolean[aa.length];\r
 681 \r
 682 \r
 683         //\u03B2 \u03B1\r
 684         for (int i = 0; i < aa.length; i++)\r
 685         {\r
 686             AlignmentAnnotation row = aa[i];\r
 687 \r
 688             if (!row.visible)\r
 689             {\r
 690                 continue;\r
 691             }\r
 692 \r
 693 \r
 694             lastSS = ' ';\r
 695             lastSSX = 0;\r
 696 \r
 697             if (row.graph>0)\r
 698             {\r
 699                 if(row.graphGroup>-1 && graphGroupDrawn[ row.graphGroup ] )\r
 700                   continue;\r
 701 \r
 702                 // this is so that we draw the characters below the graph\r
 703                 y += row.height;\r
 704 \r
 705                 if (row.hasText)\r
 706                 {\r
 707                     y -= av.charHeight;\r
 708                 }\r
 709             }\r
 710 \r
 711             if (av.updatingConsensus && aa[i].label.equals("Consensus"))\r
 712             {\r
 713               g.setColor(Color.darkGray);\r
 714               g.drawString("Recalculating Consensus....", 20, y - 5);\r
 715               y += av.charHeight;\r
 716               continue;\r
 717             }\r
 718             else if (av.updatingConservation && aa[i].label.equals("Conservation"))\r
 719             {\r
 720               g.setColor(Color.darkGray);\r
 721               g.drawString("Recalculating Conservation.....", 20, y - 5);\r
 722               y += av.charHeight;\r
 723               continue;\r
 724             }\r
 725             else if (av.updatingConservation && aa[i].label.equals("Quality"))\r
 726             {\r
 727               g.setColor(Color.darkGray);\r
 728               g.drawString("Recalculating Quality....", 20, y - 5);\r
 729               continue;\r
 730             }\r
 731 \r
 732 \r
 733             if (row.hasText)\r
 734             {\r
 735                 iconOffset = av.charHeight / 2 + 4;\r
 736             }\r
 737             else\r
 738             {\r
 739                 iconOffset = 0;\r
 740             }\r
 741 \r
 742             x = 0;\r
 743             while (x < endRes-startRes)\r
 744             {\r
 745               if (av.hasHiddenColumns)\r
 746               {\r
 747                 column = av.getColumnSelection().adjustForHiddenColumns(startRes+x);\r
 748                 if (column > row.annotations.length-1)\r
 749                 {\r
 750                   break;\r
 751                 }\r
 752               }\r
 753               else\r
 754                 column = startRes+x;\r
 755 \r
 756 \r
 757                 if ((row.annotations.length <= column) ||\r
 758                         (row.annotations[column] == null))\r
 759                 {\r
 760                     validRes = false;\r
 761                 }\r
 762                 else\r
 763                 {\r
 764                     validRes = true;\r
 765                 }\r
 766 \r
 767 \r
 768                 if (activeRow == i)\r
 769                 {\r
 770                     g.setColor(Color.red);\r
 771 \r
 772                     if (av.getColumnSelection() != null)\r
 773                     {\r
 774                         for (int n = 0; n < av.getColumnSelection().size(); n++)\r
 775                         {\r
 776                             int v = av.getColumnSelection().columnAt(n);\r
 777 \r
 778                             if (v == column)\r
 779                             {\r
 780                                 g.fillRect(x * av.charWidth, y,\r
 781                                     av.charWidth, av.charHeight);\r
 782                             }\r
 783                         }\r
 784                     }\r
 785                 }\r
 786 \r
 787                 if (av.validCharWidth && validRes &&\r
 788                         (row.annotations[column].displayCharacter.length() > 0))\r
 789                 {\r
 790 \r
 791                     int charOffset = (av.charWidth -\r
 792                         fm.charWidth(row.annotations[column].displayCharacter.charAt(\r
 793                                 0))) / 2;\r
 794                     g.setColor(row.annotations[column].colour);\r
 795 \r
 796                     if (column == 0 || row.graph>0)\r
 797                     {\r
 798                         g.drawString(row.annotations[column].displayCharacter,\r
 799                                      (x*av.charWidth)+charOffset,\r
 800                             y + iconOffset );\r
 801                     }\r
 802                     else if (\r
 803                         row.annotations[column - 1] == null\r
 804                         ||(!row.annotations[column].displayCharacter.equals(\r
 805                             row.annotations[column - 1].displayCharacter)\r
 806                         ||\r
 807                   (row.annotations[column].displayCharacter.length() <2 &&\r
 808                    row.annotations[column].secondaryStructure==' ')))\r
 809                     {\r
 810                         g.drawString(row.annotations[column].displayCharacter,\r
 811                                      x*av.charWidth+charOffset,\r
 812                                      y + iconOffset );\r
 813                     }\r
 814                 }\r
 815 \r
 816                 if (row.hasIcons)\r
 817                 {\r
 818                     if (!validRes ||\r
 819                             (row.annotations[column].secondaryStructure != lastSS))\r
 820                     {\r
 821                         switch (lastSS)\r
 822                         {\r
 823                         case 'H':\r
 824                           g.setColor(HELIX_COLOUR);\r
 825                           if (MAC)\r
 826                           {\r
 827                             //Off by 1 offset when drawing rects and ovals\r
 828                             //to offscreen image on the MAC\r
 829                             g.fillRoundRect(lastSSX, y + 4 + iconOffset,\r
 830                                             (x*av.charWidth) - lastSSX, 7, 8, 8);\r
 831                             break;\r
 832                           }\r
 833 \r
 834                           int sCol = (lastSSX / av.charWidth) + startRes;\r
 835                           int x1 = lastSSX;\r
 836                           int x2 = (x*av.charWidth);\r
 837 \r
 838                          if(sCol==0 ||\r
 839                             row.annotations[sCol-1]==null ||\r
 840                             row.annotations[sCol-1].secondaryStructure!='H')\r
 841                          {\r
 842                            g.fillArc(lastSSX, y+4+iconOffset, av.charWidth, 8, 90,180) ;\r
 843                            x1 += av.charWidth/2;\r
 844                          }\r
 845 \r
 846                           if(row.annotations[column]==null ||\r
 847                              row.annotations[column].secondaryStructure!='H')\r
 848                           {\r
 849                             g.fillArc((x*av.charWidth)-av.charWidth,\r
 850                                       y+4+iconOffset, av.charWidth, 8, 270,180);\r
 851                             x2 -= av.charWidth/2;\r
 852                           }\r
 853 \r
 854                           g.fillRect(x1, y+4+iconOffset, x2-x1, 8);\r
 855                               break;\r
 856 \r
 857                         case 'E':\r
 858                             g.setColor(SHEET_COLOUR);\r
 859                             g.fillRect(lastSSX, y + 4 + iconOffset,\r
 860                                 (x*av.charWidth) - lastSSX - 4, 7);\r
 861                             g.fillPolygon(new int[] { (x*av.charWidth) - 4,\r
 862                                           (x*av.charWidth) - 4,\r
 863                                           (x*av.charWidth) },\r
 864                                 new int[]\r
 865                                 {\r
 866                                     y + iconOffset, y + 14 + iconOffset,\r
 867                                     y + 8 + iconOffset\r
 868                                 }, 3);\r
 869 \r
 870                             break;\r
 871 \r
 872 \r
 873                         default:\r
 874                             g.setColor(Color.gray);\r
 875                             g.fillRect(lastSSX, y + 6 + iconOffset,\r
 876                                 (x*av.charWidth) - lastSSX, 2);\r
 877 \r
 878                             break;\r
 879                         }\r
 880 \r
 881                         if (validRes)\r
 882                         {\r
 883                             lastSS = row.annotations[column].secondaryStructure;\r
 884                         }\r
 885                         else\r
 886                         {\r
 887                             lastSS = ' ';\r
 888                         }\r
 889 \r
 890                         lastSSX = (x*av.charWidth);\r
 891                     }\r
 892                 }\r
 893 \r
 894 \r
 895             column++;\r
 896             x++;\r
 897             }\r
 898 \r
 899             if(column>=row.annotations.length)\r
 900                 column = row.annotations.length-1;\r
 901 \r
 902           //  x ++;\r
 903 \r
 904             if (row.hasIcons)\r
 905             {\r
 906               switch (lastSS)\r
 907               {\r
 908                 case 'H':\r
 909                   g.setColor(HELIX_COLOUR);\r
 910                   if (MAC)\r
 911                   {\r
 912                     //Off by 1 offset when drawing rects and ovals\r
 913                     //to offscreen image on the MAC\r
 914                     g.fillRoundRect(lastSSX, y + 4 + iconOffset,\r
 915                                     (x*av.charWidth) - lastSSX, 7, 8, 8);\r
 916                     break;\r
 917                   }\r
 918 \r
 919                   int sCol = (lastSSX / av.charWidth) + startRes;\r
 920                   int x1 = lastSSX;\r
 921                   int x2 = (x*av.charWidth);\r
 922 \r
 923                   if (sCol == 0 ||\r
 924                       row.annotations[sCol - 1] == null ||\r
 925                       row.annotations[sCol - 1].secondaryStructure != 'H')\r
 926                   {\r
 927                     g.fillArc(lastSSX, y + 4 + iconOffset, av.charWidth, 8, 90, 180);\r
 928                     x1 += av.charWidth / 2;\r
 929                   }\r
 930 \r
 931                   if (row.annotations[column] == null ||\r
 932                       row.annotations[column].secondaryStructure != 'H')\r
 933                   {\r
 934                     g.fillArc((x*av.charWidth) - av.charWidth,\r
 935                               y + 4 + iconOffset, av.charWidth, 8, 270,\r
 936                               180);\r
 937                     x2 -= av.charWidth / 2;\r
 938                   }\r
 939 \r
 940                   g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8);\r
 941 \r
 942                   break;\r
 943 \r
 944                 case 'E':\r
 945                   g.setColor(SHEET_COLOUR);\r
 946 \r
 947                   if (row.annotations[endRes] == null\r
 948                       || row.annotations[endRes].secondaryStructure != 'E')\r
 949                   {\r
 950                     g.fillRect(lastSSX, y + 4 + iconOffset,\r
 951                                (x*av.charWidth) - lastSSX - 4, 7);\r
 952                     g.fillPolygon(new int[]\r
 953                                   {(x*av.charWidth) - 4,\r
 954                                   (x*av.charWidth) - 4,\r
 955                                  (x*av.charWidth)},\r
 956                                   new int[]\r
 957                                   {\r
 958                                   y + iconOffset, y + 14 + iconOffset,\r
 959                                   y + 7 + iconOffset\r
 960                     }, 3);\r
 961                   }\r
 962                   else\r
 963                    {\r
 964                      g.fillRect(lastSSX, y + 4 + iconOffset,\r
 965                                 (x+1) * av.charWidth - lastSSX, 7);\r
 966                    }\r
 967                   break;\r
 968 \r
 969                 default:\r
 970                   g.setColor(Color.gray);\r
 971                   if(!av.wrapAlignment || endRes==av.endRes)\r
 972                   g.fillRect(lastSSX, y + 6 + iconOffset,\r
 973                              (x*av.charWidth) - lastSSX, 2);\r
 974 \r
 975                   break;\r
 976               }\r
 977           }\r
 978 \r
 979             if (row.graph>0 && row.graphHeight>0)\r
 980             {\r
 981                 if(row.graph == AlignmentAnnotation.LINE_GRAPH )\r
 982                 {\r
 983                   if(row.graphGroup>-1 && !graphGroupDrawn[row.graphGroup])\r
 984                    {\r
 985                      float groupmax=-999999, groupmin=9999999;\r
 986                      for(int gg=0; gg<aa.length; gg++)\r
 987                      {\r
 988                        if(aa[gg].graphGroup!=row.graphGroup)\r
 989                          continue;\r
 990 \r
 991                        if(aa[gg]!=row)\r
 992                          aa[gg].visible = false;\r
 993 \r
 994                        if(aa[gg].graphMax>groupmax)\r
 995                          groupmax = aa[gg].graphMax;\r
 996                        if(aa[gg].graphMin<groupmin)\r
 997                          groupmin = aa[gg].graphMin;\r
 998                      }\r
 999 \r
1000                      for (int gg = 0; gg < aa.length; gg++)\r
1001                      {\r
1002                        if (aa[gg].graphGroup == row.graphGroup)\r
1003                        {\r
1004                          drawLineGraph(g, aa[gg], startRes, endRes, y,\r
1005                                        groupmin, groupmax,\r
1006                                        row.graphHeight);\r
1007                        }\r
1008                      }\r
1009 \r
1010                      graphGroupDrawn[ row.graphGroup ] = true;\r
1011                    }\r
1012                    else\r
1013                      drawLineGraph(g, row, startRes, endRes,\r
1014                                    y, row.graphMin, row.graphMax, row.graphHeight  );\r
1015                 }\r
1016                 else if(row.graph == AlignmentAnnotation.BAR_GRAPH )\r
1017                    drawBarGraph(g, row, startRes, endRes,\r
1018                                 row.graphMin, row.graphMax, y);\r
1019             }\r
1020 \r
1021             if (row.graph>0 && row.hasText)\r
1022             {\r
1023                 y += av.charHeight;\r
1024             }\r
1025 \r
1026             if (row.graph==0)\r
1027             {\r
1028                 y += aa[i].height;\r
1029             }\r
1030         }\r
1031     }\r
1032 \r
1033     public void drawLineGraph(Graphics g, AlignmentAnnotation aa,\r
1034                               int sRes, int eRes,\r
1035                               int y,\r
1036                               float min, float max,\r
1037                               int graphHeight)\r
1038     {\r
1039       if(sRes>aa.annotations.length)\r
1040         return;\r
1041 \r
1042 \r
1043       int x = 0;\r
1044 \r
1045       //Adjustment for fastpaint to left\r
1046       if(eRes<av.endRes)\r
1047         eRes++;\r
1048 \r
1049       eRes = Math.min(eRes, aa.annotations.length);\r
1050 \r
1051       if(sRes==0)\r
1052       {\r
1053         x++;\r
1054       }\r
1055 \r
1056       int y1=y, y2=y;\r
1057       float range = max - min;\r
1058 \r
1059       ////Draw origin\r
1060       if(min<0)\r
1061         y2 = y - (int)((0-min / range)*graphHeight);\r
1062 \r
1063       g.setColor(Color.gray);\r
1064       g.drawLine(x-av.charWidth,y2,(eRes-sRes+1)*av.charWidth,y2);\r
1065 \r
1066       eRes = Math.min(eRes, aa.annotations.length);\r
1067 \r
1068       int column;\r
1069       int aaMax = aa.annotations.length-1;\r
1070 \r
1071       while( x < eRes - sRes )\r
1072       {\r
1073         column = sRes + x;\r
1074         if(av.hasHiddenColumns)\r
1075         {\r
1076           column = av.getColumnSelection().adjustForHiddenColumns(column);\r
1077         }\r
1078 \r
1079         if (column > aaMax)\r
1080         {\r
1081           break;\r
1082         }\r
1083 \r
1084         if(aa.annotations[column]==null || aa.annotations[column-1]==null)\r
1085         {\r
1086           x++;\r
1087           continue;\r
1088         }\r
1089 \r
1090 \r
1091           g.setColor(aa.annotations[column].colour);\r
1092           y1 = y - (int) (((aa.annotations[column-1].value-min) / range) * graphHeight);\r
1093           y2 = y - (int) (((aa.annotations[column].value-min) / range) * graphHeight);\r
1094 \r
1095           g.drawLine(x*av.charWidth-av.charWidth/2, y1, x*av.charWidth+av.charWidth/2, y2);\r
1096           x ++;\r
1097        }\r
1098 \r
1099        if(aa.threshold!=null)\r
1100        {\r
1101            g.setColor(aa.threshold.colour);\r
1102            Graphics2D g2 = (Graphics2D)g;\r
1103            g2.setStroke(new BasicStroke(1,\r
1104                                          BasicStroke.CAP_SQUARE,\r
1105                                          BasicStroke.JOIN_ROUND, 3f,\r
1106                                          new float[] { 5f, 3f }, 0f));\r
1107 \r
1108            y2 = (int)(y - ((aa.threshold.value-min) / range)*graphHeight);\r
1109            g.drawLine(0,y2,(eRes-sRes)*av.charWidth,y2);\r
1110            g2.setStroke(new BasicStroke());\r
1111       }\r
1112     }\r
1113 \r
1114     public void drawBarGraph(Graphics g, AlignmentAnnotation aa,\r
1115                              int sRes, int eRes,\r
1116                              float min, float max,\r
1117                              int y)\r
1118     {\r
1119       if(sRes>aa.annotations.length)\r
1120         return;\r
1121 \r
1122       eRes = Math.min(eRes, aa.annotations.length);\r
1123 \r
1124       int x=0, y1=y, y2=y;\r
1125 \r
1126       float range = max - min;\r
1127 \r
1128       if(min<0)\r
1129         y2 = y - (int)((0-min / (range))*aa.graphHeight);\r
1130 \r
1131       g.setColor(Color.gray);\r
1132 \r
1133       g.drawLine(x,y2,(eRes-sRes)*av.charWidth,y2);\r
1134 \r
1135       int column;\r
1136       int aaMax = aa.annotations.length-1;\r
1137 \r
1138       while( x < eRes-sRes )\r
1139       {\r
1140         column = sRes + x;\r
1141         if(av.hasHiddenColumns)\r
1142         {\r
1143           column = av.getColumnSelection().adjustForHiddenColumns(column);\r
1144         }\r
1145 \r
1146         if(column > aaMax)\r
1147         {\r
1148             break;\r
1149         }\r
1150 \r
1151         if (aa.annotations[column] == null)\r
1152         {\r
1153           x ++;\r
1154           continue;\r
1155         }\r
1156 \r
1157           g.setColor(aa.annotations[column].colour);\r
1158           y1 = y - (int) (((aa.annotations[column].value-min) / (range)) * aa.graphHeight);\r
1159 \r
1160           if(y1-y2>0)\r
1161             g.fillRect(x*av.charWidth, y2, av.charWidth, y1-y2 );\r
1162           else\r
1163             g.fillRect(x*av.charWidth, y1, av.charWidth, y2-y1 );\r
1164 \r
1165           x ++ ;\r
1166 \r
1167       }\r
1168       if(aa.threshold!=null)\r
1169       {\r
1170           g.setColor(aa.threshold.colour);\r
1171           Graphics2D g2 = (Graphics2D)g;\r
1172           g2.setStroke(new BasicStroke(1,\r
1173                                         BasicStroke.CAP_SQUARE,\r
1174                                         BasicStroke.JOIN_ROUND, 3f,\r
1175                                         new float[] { 5f, 3f }, 0f));\r
1176 \r
1177           y2 = (int)(y - ((aa.threshold.value-min) / range)*aa.graphHeight);\r
1178           g.drawLine(0,y2,(eRes-sRes)*av.charWidth,y2);\r
1179           g2.setStroke(new BasicStroke());\r
1180       }\r
1181     }\r
1182 \r
1183     // used by overview window\r
1184     public void drawGraph(Graphics g, AlignmentAnnotation aa, int width, int y, int sRes, int eRes)\r
1185     {\r
1186       eRes = Math.min(eRes, aa.annotations.length);\r
1187       g.setColor(Color.white);\r
1188       g.fillRect(0, 0, width, y);\r
1189       g.setColor(new Color(0, 0, 180));\r
1190 \r
1191       int x = 0, height;\r
1192 \r
1193       for (int j = sRes; j < eRes; j++)\r
1194       {\r
1195         if (aa.annotations[j] != null)\r
1196         {\r
1197           g.setColor(aa.annotations[j].colour);\r
1198 \r
1199           height = (int) ( (aa.annotations[j].value / aa.graphMax) * y);\r
1200           if (height > y)\r
1201             height = y;\r
1202 \r
1203           g.fillRect(x, y - height, av.charWidth, height);\r
1204         }\r
1205           x += av.charWidth;\r
1206       }\r
1207     }\r
1208 \r
1209 }\r