2 * Jalview - A Sequence Alignment Editor and Viewer
\r
3 * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
\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
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
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
19 package jalview.gui;
\r
21 import jalview.datamodel.*;
\r
24 import java.awt.image.*;
\r
26 import javax.swing.*;
\r
33 * @version $Revision$
\r
35 public class SeqCanvas extends JComponent
\r
37 final FeatureRenderer fr;
\r
38 final SequenceRenderer sr;
\r
44 SearchResults searchResults = null;
\r
45 boolean fastPaint = false;
\r
55 * Creates a new SeqCanvas object.
\r
57 * @param av DOCUMENT ME!
\r
59 public SeqCanvas(AlignViewport av)
\r
62 fr = new FeatureRenderer(av);
\r
63 sr = new SequenceRenderer(av);
\r
64 setLayout(new BorderLayout());
\r
65 PaintRefresher.Register(this, av.alignment);
\r
66 setBackground(Color.white);
\r
69 MCview.PDBCanvas pdbCanvas;
\r
70 public SequenceRenderer getSequenceRenderer()
\r
75 public FeatureRenderer getFeatureRenderer()
\r
80 public void setPDBCanvas(MCview.PDBCanvas pc)
\r
85 public AlignViewport getViewport()
\r
94 * @param g DOCUMENT ME!
\r
95 * @param startx DOCUMENT ME!
\r
96 * @param endx DOCUMENT ME!
\r
97 * @param ypos DOCUMENT ME!
\r
99 void drawNorthScale(Graphics g, int startx, int endx, int ypos)
\r
101 int scalestartx = startx - (startx % 10) + 10;
\r
103 g.setColor(Color.black);
\r
106 for (int i = scalestartx; i < endx; i += 10)
\r
109 if(av.hasHiddenColumns)
\r
110 value = av.getColumnSelection().adjustForHiddenColumns(value);
\r
112 g.drawString( String.valueOf(value), (i - startx - 1) * av.charWidth,
\r
113 ypos - (av.charHeight / 2));
\r
115 g.drawLine(((i - startx - 1) * av.charWidth) + (av.charWidth / 2),
\r
116 (ypos + 2) - (av.charHeight / 2),
\r
117 ((i - startx - 1) * av.charWidth) + (av.charWidth / 2), ypos -
\r
125 * @param g DOCUMENT ME!
\r
126 * @param startx DOCUMENT ME!
\r
127 * @param endx DOCUMENT ME!
\r
128 * @param ypos DOCUMENT ME!
\r
130 void drawWestScale(Graphics g, int startx, int endx, int ypos)
\r
132 FontMetrics fm = getFontMetrics(av.getFont());
\r
133 ypos += av.charHeight;
\r
135 if(av.hasHiddenColumns)
\r
136 startx = av.getColumnSelection().adjustForHiddenColumns(startx);
\r
139 for (int i = 0; i < av.alignment.getHeight(); i++)
\r
141 SequenceI seq = av.alignment.getSequenceAt(i);
\r
142 int index = startx;
\r
145 while (index < endx)
\r
147 if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
\r
154 value = av.alignment.getSequenceAt(i).findPosition(index);
\r
161 int x = LABEL_WEST - fm.stringWidth(String.valueOf(value))-av.charWidth/2;
\r
162 g.drawString(value + "", x,
\r
163 (ypos + (i * av.charHeight)) - (av.charHeight / 5));
\r
171 * @param g DOCUMENT ME!
\r
172 * @param startx DOCUMENT ME!
\r
173 * @param endx DOCUMENT ME!
\r
174 * @param ypos DOCUMENT ME!
\r
176 void drawEastScale(Graphics g, int startx, int endx, int ypos)
\r
178 ypos += av.charHeight;
\r
180 if(av.hasHiddenColumns)
\r
181 endx = av.getColumnSelection().adjustForHiddenColumns(endx);
\r
185 for (int i = 0; i < av.alignment.getHeight(); i++)
\r
187 seq = av.alignment.getSequenceAt(i);
\r
191 while (index > startx)
\r
193 if (jalview.util.Comparison.isGap(seq.getCharAt(index)))
\r
200 value = seq.findPosition(index);
\r
207 g.drawString(String.valueOf(value), 0,
\r
208 (ypos + (i * av.charHeight)) - (av.charHeight / 5));
\r
216 * @param horizontal DOCUMENT ME!
\r
217 * @param vertical DOCUMENT ME!
\r
219 public void fastPaint(int horizontal, int vertical)
\r
229 gg.copyArea(horizontal * av.charWidth,
\r
230 vertical * av.charHeight,
\r
233 -horizontal * av.charWidth,
\r
234 -vertical * av.charHeight);
\r
236 int sr = av.startRes;
\r
237 int er = av.endRes;
\r
238 int ss = av.startSeq;
\r
239 int es = av.endSeq;
\r
244 if (horizontal > 0) // scrollbar pulled right, image to the left
\r
247 transX = (er - sr - horizontal) * av.charWidth;
\r
248 sr = er - horizontal;
\r
250 else if (horizontal < 0)
\r
252 er = sr - horizontal-1;
\r
254 else if (vertical > 0) // scroll down
\r
256 ss = es - vertical;
\r
258 if (ss < av.startSeq)
\r
259 { // ie scrolling too fast, more than a page at a time
\r
264 transY = imgHeight - (vertical * av.charHeight);
\r
267 else if (vertical < 0)
\r
269 es = ss - vertical;
\r
271 if (es > av.endSeq)
\r
277 gg.translate(transX, transY);
\r
278 drawPanel(gg, sr, er, ss, es, 0);
\r
279 gg.translate(-transX, -transY);
\r
285 * Definitions of startx and endx (hopefully):
\r
286 * SMJS This is what I'm working towards!
\r
287 * startx is the first residue (starting at 0) to display.
\r
288 * endx is the last residue to display (starting at 0).
\r
289 * starty is the first sequence to display (starting at 0).
\r
290 * endy is the last sequence to display (starting at 0).
\r
291 * NOTE 1: The av limits are set in setFont in this class and
\r
292 * in the adjustment listener in SeqPanel when the scrollbars move.
\r
295 // Set this to false to force a full panel paint
\r
296 public void paintComponent(Graphics g)
\r
298 super.paintComponent(g);
\r
302 if ( img != null && (fastPaint
\r
303 || (getVisibleRect().width != g.getClipBounds().width)
\r
304 || (getVisibleRect().height != g.getClipBounds().height)))
\r
306 g.drawImage(img, 0, 0, this);
\r
312 // this draws the whole of the alignment
\r
313 imgWidth = getWidth();
\r
314 imgHeight = getHeight();
\r
316 imgWidth -= (imgWidth % av.charWidth);
\r
317 imgHeight -= (imgHeight % av.charHeight);
\r
319 if ((imgWidth < 1) || (imgHeight < 1))
\r
324 img = new BufferedImage(imgWidth, imgHeight, BufferedImage.TYPE_INT_RGB);
\r
325 gg = (Graphics2D) img.getGraphics();
\r
326 gg.setFont(av.getFont());
\r
329 gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
\r
330 RenderingHints.VALUE_ANTIALIAS_ON);
\r
332 gg.setColor(Color.white);
\r
333 gg.fillRect(0, 0, imgWidth, imgHeight);
\r
336 if (av.getWrapAlignment())
\r
338 drawWrappedPanel(gg, getWidth(), getHeight(), av.startRes);
\r
342 drawPanel(gg, av.startRes, av.endRes, av.startSeq, av.endSeq, 0);
\r
345 g.drawImage(img, 0, 0, this);
\r
347 if (pdbCanvas != null)
\r
349 pdbCanvas.updateSeqColours();
\r
357 * @param cwidth DOCUMENT ME!
\r
359 * @return DOCUMENT ME!
\r
361 public int getWrappedCanvasWidth(int cwidth)
\r
363 FontMetrics fm = getFontMetrics(av.getFont());
\r
368 if (av.scaleRightWrapped)
\r
370 LABEL_EAST = fm.stringWidth(getMask());
\r
373 if (av.scaleLeftWrapped)
\r
375 LABEL_WEST = fm.stringWidth(getMask());
\r
378 return (cwidth - LABEL_EAST - LABEL_WEST) / av.charWidth;
\r
383 * Generates a string of zeroes.
\r
388 String mask = "00";
\r
389 for (int i = av.alignment.getWidth(); i > 0; i /= 10)
\r
399 * @param g DOCUMENT ME!
\r
400 * @param canvasWidth DOCUMENT ME!
\r
401 * @param canvasHeight DOCUMENT ME!
\r
402 * @param startRes DOCUMENT ME!
\r
404 public void drawWrappedPanel(Graphics g, int canvasWidth, int canvasHeight,
\r
408 AlignmentI al = av.getAlignment();
\r
410 FontMetrics fm = getFontMetrics(av.getFont());
\r
413 if (av.scaleRightWrapped)
\r
415 LABEL_EAST = fm.stringWidth(getMask());
\r
419 if (av.scaleLeftWrapped)
\r
421 LABEL_WEST = fm.stringWidth(getMask());
\r
424 int hgap = av.charHeight;
\r
425 if(av.scaleAboveWrapped)
\r
426 hgap += av.charHeight;
\r
428 int cWidth = (canvasWidth - LABEL_EAST - LABEL_WEST) / av.charWidth;
\r
429 int cHeight = av.getAlignment().getHeight() * av.charHeight;
\r
431 av.setWrappedWidth(cWidth);
\r
433 av.endRes = av.startRes + cWidth;
\r
439 while ((ypos <= canvasHeight) && (startRes < av.alignment.getWidth()))
\r
441 endx = startRes + cWidth -1;
\r
443 if (endx > al.getWidth())
\r
445 endx = al.getWidth();
\r
448 g.setFont(av.getFont());
\r
449 g.setColor(Color.black);
\r
451 if (av.scaleLeftWrapped)
\r
453 drawWestScale(g, startRes, endx, ypos);
\r
456 if (av.scaleRightWrapped)
\r
458 g.translate(canvasWidth - LABEL_EAST, 0);
\r
459 drawEastScale(g, startRes, endx, ypos);
\r
460 g.translate(-(canvasWidth - LABEL_EAST), 0);
\r
463 g.translate(LABEL_WEST, 0);
\r
465 if (av.scaleAboveWrapped)
\r
467 drawNorthScale(g, startRes, endx, ypos);
\r
470 // When printing we have an extra clipped region,
\r
471 // the Printable page which we need to account for here
\r
472 Shape clip = g.getClip();
\r
476 g.setClip(0, 0, cWidth * av.charWidth, canvasHeight);
\r
480 g.setClip(0, (int) clip.getBounds().getY(),
\r
481 cWidth * av.charWidth, (int) clip.getBounds().getHeight());
\r
484 drawPanel(g, startRes, endx, 0, al.getHeight(), ypos);
\r
486 if(av.showAnnotation)
\r
488 g.translate(0, cHeight + ypos + 3);
\r
489 if(annotations==null)
\r
490 annotations = new AnnotationPanel(av);
\r
492 annotations.drawComponent( (Graphics2D) g, startRes, endx+1);
\r
493 g.translate(0, -cHeight - ypos);
\r
496 g.translate(-LABEL_WEST, 0);
\r
498 ypos += cHeight+getAnnotationHeight()+hgap;
\r
499 if(av.showAnnotation)
\r
502 startRes += cWidth;
\r
506 AnnotationPanel annotations;
\r
507 int getAnnotationHeight()
\r
509 if(!av.showAnnotation)
\r
512 if(annotations==null)
\r
513 annotations = new AnnotationPanel(av);
\r
515 return annotations.adjustPanelHeight();
\r
521 * @param g1 DOCUMENT ME!
\r
522 * @param startRes DOCUMENT ME!
\r
523 * @param endRes DOCUMENT ME!
\r
524 * @param startSeq DOCUMENT ME!
\r
525 * @param endSeq DOCUMENT ME!
\r
526 * @param offset DOCUMENT ME!
\r
528 void drawPanel(Graphics g1, int startRes, int endRes,
\r
529 int startSeq, int endSeq, int offset)
\r
531 if(!av.hasHiddenColumns)
\r
533 draw(g1, startRes, endRes, startSeq, endSeq, offset);
\r
537 java.util.Vector regions = av.getColumnSelection().getHiddenColumns();
\r
540 int blockStart = startRes;
\r
541 int blockEnd = endRes;
\r
543 for (int i = 0; i < regions.size(); i++)
\r
545 int[] region = (int[]) regions.elementAt(i);
\r
546 int hideStart = region[0];
\r
547 int hideEnd = region[1];
\r
549 if (hideStart <= blockStart)
\r
551 blockStart += (hideEnd - hideStart) + 1;
\r
555 blockEnd = hideStart - 1;
\r
557 g1.translate(screenY * av.charWidth, 0);
\r
559 draw(g1, blockStart, blockEnd, startSeq, endSeq, offset);
\r
561 g1.setColor(Color.blue);
\r
562 g1.drawLine( (blockEnd - blockStart + 1) * av.charWidth - 1,
\r
564 (blockEnd - blockStart + 1) * av.charWidth - 1,
\r
565 startSeq + (endSeq - startSeq) * av.charHeight + offset);
\r
566 g1.drawLine( (blockEnd - blockStart + 1) * av.charWidth,
\r
568 (blockEnd - blockStart + 1) * av.charWidth,
\r
569 startSeq + (endSeq - startSeq) * av.charHeight + offset);
\r
571 g1.translate( -screenY * av.charWidth, 0);
\r
572 screenY += blockEnd - blockStart + 1;
\r
573 blockStart = hideEnd + 1;
\r
576 if (screenY <= (endRes - startRes))
\r
578 blockEnd = blockStart + (endRes - startRes) - screenY;
\r
579 g1.translate(screenY * av.charWidth, 0);
\r
580 draw(g1, blockStart, blockEnd, startSeq, endSeq, offset);
\r
581 g1.translate( -screenY * av.charWidth, 0);
\r
590 //int startRes, int endRes, int startSeq, int endSeq, int x, int y,
\r
591 // int x1, int x2, int y1, int y2, int startx, int starty,
\r
592 void draw(Graphics g,
\r
593 int startRes, int endRes,
\r
594 int startSeq, int endSeq,
\r
597 g.setFont(av.getFont());
\r
598 sr.prepare(g, av.renderGaps);
\r
602 /// First draw the sequences
\r
603 /////////////////////////////
\r
604 for (int i = startSeq; i < endSeq; i++)
\r
606 nextSeq = av.alignment.getSequenceAt(i);
\r
608 sr.drawSequence(nextSeq, av.alignment.findAllGroups(nextSeq),
\r
610 offset + ( (i - startSeq) * av.charHeight));
\r
612 if (av.showSequenceFeatures)
\r
614 fr.drawSequence(g, nextSeq, startRes, endRes,
\r
615 offset + ((i - startSeq) * av.charHeight));
\r
618 /// Highlight search Results once all sequences have been drawn
\r
619 //////////////////////////////////////////////////////////
\r
620 if (searchResults != null)
\r
622 int[] visibleResults = searchResults.getResults(nextSeq, startRes, endRes);
\r
623 if (visibleResults != null)
\r
624 for (int r = 0; r < visibleResults.length; r += 2)
\r
626 sr.drawHighlightedText(nextSeq, visibleResults[r],
\r
627 visibleResults[r + 1],
\r
628 (visibleResults[r] - startRes) * av.charWidth,
\r
629 offset + ( (i - startSeq) * av.charHeight));
\r
633 if(av.cursorMode && cursorY==i
\r
634 && cursorX>=startRes && cursorX<=endRes)
\r
636 sr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * av.charWidth,
\r
637 offset + ( (i - startSeq) * av.charHeight));
\r
641 if(av.getSelectionGroup()!=null || av.alignment.getGroups().size()>0)
\r
642 drawGroupsBoundaries(g, startRes, endRes, startSeq, endSeq, offset);
\r
646 void drawGroupsBoundaries(Graphics g1,
\r
647 int startRes, int endRes,
\r
648 int startSeq, int endSeq,
\r
651 Graphics2D g = (Graphics2D)g1;
\r
653 /////////////////////////////////////
\r
654 // Now outline any areas if necessary
\r
655 /////////////////////////////////////
\r
656 SequenceGroup group = av.getSelectionGroup();
\r
661 int groupIndex = -1;
\r
663 if ((group == null) && (av.alignment.getGroups().size() > 0))
\r
665 group = (SequenceGroup) av.alignment.getGroups().elementAt(0);
\r
675 boolean inGroup = false;
\r
679 for (i = startSeq; i < endSeq; i++)
\r
681 sx = (group.getStartRes() - startRes) * av.charWidth;
\r
682 sy = offset + ((i - startSeq) * av.charHeight);
\r
683 ex = (((group.getEndRes() + 1) - group.getStartRes()) * av.charWidth) -
\r
686 if(sx+ex<0 || sx>imgWidth)
\r
691 if ( (sx <= (endRes-startRes)*av.charWidth) &&
\r
692 group.sequences.contains(av.alignment.getSequenceAt(
\r
695 if ((bottom == -1) &&
\r
696 !group.sequences.contains(
\r
697 av.alignment.getSequenceAt(i + 1)))
\r
699 bottom = sy + av.charHeight;
\r
704 if (((top == -1) && (i == 0)) ||
\r
705 !group.sequences.contains(
\r
706 av.alignment.getSequenceAt(i - 1)))
\r
714 if (group == av.getSelectionGroup())
\r
716 g.setStroke(new BasicStroke(1,
\r
717 BasicStroke.CAP_BUTT,
\r
718 BasicStroke.JOIN_ROUND, 3f,
\r
719 new float[] { 5f, 3f }, 0f));
\r
720 g.setColor(Color.RED);
\r
724 g.setStroke(new BasicStroke());
\r
725 g.setColor(group.getOutlineColour());
\r
733 if (sx >= 0 && sx < imgWidth)
\r
734 g.drawLine(sx, oldY, sx, sy);
\r
736 if (sx + ex < imgWidth)
\r
737 g.drawLine(sx + ex, oldY, sx + ex, sy);
\r
745 if (sx + ex > imgWidth)
\r
748 else if (sx + ex >= (endRes - startRes + 1) * av.charWidth)
\r
749 ex = (endRes - startRes + 1) * av.charWidth;
\r
753 g.drawLine(sx, top, sx + ex, top);
\r
759 g.drawLine(sx, bottom, sx + ex, bottom);
\r
770 sy = offset + ( (i - startSeq) * av.charHeight);
\r
771 if (sx >= 0 && sx < imgWidth)
\r
772 g.drawLine(sx, oldY, sx, sy);
\r
774 if (sx + ex < imgWidth)
\r
775 g.drawLine(sx + ex, oldY, sx + ex, sy);
\r
783 if (sx + ex > imgWidth)
\r
785 else if (sx + ex >= (endRes - startRes + 1) * av.charWidth)
\r
786 ex = (endRes - startRes + 1) * av.charWidth;
\r
790 g.drawLine(sx, top, sx + ex, top);
\r
796 g.drawLine(sx, bottom - 1, sx + ex, bottom - 1);
\r
805 if (groupIndex >= av.alignment.getGroups().size())
\r
810 group = (SequenceGroup) av.alignment.getGroups().elementAt(groupIndex);
\r
812 g.setStroke(new BasicStroke());
\r
814 while (groupIndex < av.alignment.getGroups().size());
\r
823 * @param results DOCUMENT ME!
\r
825 public void highlightSearchResults(SearchResults results)
\r
829 searchResults = results;
\r