Remove start end for now??
[jalview.git] / src / jalview / gui / SeqCanvas.java
1 /*\r
2  * Jalview - A Sequence Alignment Editor and Viewer\r
3  * Copyright (C) 2005 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.image.*;\r
25 \r
26 import javax.swing.*;\r
27 \r
28 \r
29 /**\r
30  * DOCUMENT ME!\r
31  *\r
32  * @author $author$\r
33  * @version $Revision$\r
34  */\r
35 public class SeqCanvas extends JComponent\r
36 {\r
37     final FeatureRenderer fr;\r
38     final SequenceRenderer sr;\r
39     BufferedImage img;\r
40     Graphics2D gg;\r
41     int imgWidth;\r
42     int imgHeight;\r
43     AlignViewport av;\r
44     SearchResults searchResults = null;\r
45     boolean fastPaint = false;\r
46     int LABEL_WEST;\r
47     int LABEL_EAST;\r
48 \r
49 \r
50     int cursorX = 0;\r
51     int cursorY = 0;\r
52 \r
53 \r
54     /**\r
55      * Creates a new SeqCanvas object.\r
56      *\r
57      * @param av DOCUMENT ME!\r
58      */\r
59     public SeqCanvas(AlignViewport av)\r
60     {\r
61         this.av = 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
67     }\r
68 \r
69     MCview.PDBCanvas pdbCanvas;\r
70     public SequenceRenderer getSequenceRenderer()\r
71     {\r
72       return sr;\r
73     }\r
74 \r
75     public FeatureRenderer getFeatureRenderer()\r
76     {\r
77       return fr;\r
78     }\r
79 \r
80     public void setPDBCanvas(MCview.PDBCanvas pc)\r
81     {\r
82       pdbCanvas = pc;\r
83     }\r
84 \r
85     public AlignViewport getViewport()\r
86     {\r
87       return av;\r
88     }\r
89 \r
90 \r
91     /**\r
92      * DOCUMENT ME!\r
93      *\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
98      */\r
99     void drawNorthScale(Graphics g, int startx, int endx, int ypos)\r
100     {\r
101         int scalestartx = startx - (startx % 10) + 10;\r
102 \r
103         g.setColor(Color.black);\r
104 \r
105         // NORTH SCALE\r
106         for (int i = scalestartx; i < endx; i += 10)\r
107         {\r
108             int value = i;\r
109             if(av.hasHiddenColumns)\r
110                 value = av.getColumnSelection().adjustForHiddenColumns(value);\r
111 \r
112             g.drawString( String.valueOf(value), (i - startx - 1) * av.charWidth,\r
113                 ypos - (av.charHeight / 2));\r
114 \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
118                 2);\r
119         }\r
120     }\r
121 \r
122     /**\r
123      * DOCUMENT ME!\r
124      *\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
129      */\r
130     void drawWestScale(Graphics g, int startx, int endx, int ypos)\r
131     {\r
132         FontMetrics fm = getFontMetrics(av.getFont());\r
133         ypos += av.charHeight;\r
134 \r
135         if(av.hasHiddenColumns)\r
136         {\r
137           startx = av.getColumnSelection().adjustForHiddenColumns(startx);\r
138           endx = av.getColumnSelection().adjustForHiddenColumns(endx);\r
139         }\r
140 \r
141         int maxwidth = av.alignment.getWidth();\r
142         if (av.hasHiddenColumns)\r
143             maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;\r
144 \r
145         // WEST SCALE\r
146         for (int i = 0; i < av.alignment.getHeight(); i++)\r
147         {\r
148             SequenceI seq = av.alignment.getSequenceAt(i);\r
149             int index = startx;\r
150             int value = -1;\r
151 \r
152             while (index < endx)\r
153             {\r
154                 if (jalview.util.Comparison.isGap(seq.getCharAt(index)))\r
155                 {\r
156                     index++;\r
157 \r
158                     continue;\r
159                 }\r
160 \r
161                 value = av.alignment.getSequenceAt(i).findPosition(index);\r
162 \r
163                 break;\r
164             }\r
165 \r
166             if (value != -1)\r
167             {\r
168                 int x = LABEL_WEST - fm.stringWidth(String.valueOf(value))-av.charWidth/2;\r
169                 g.drawString(value + "", x,\r
170                     (ypos + (i * av.charHeight)) - (av.charHeight / 5));\r
171             }\r
172         }\r
173     }\r
174 \r
175     /**\r
176      * DOCUMENT ME!\r
177      *\r
178      * @param g DOCUMENT ME!\r
179      * @param startx DOCUMENT ME!\r
180      * @param endx DOCUMENT ME!\r
181      * @param ypos DOCUMENT ME!\r
182      */\r
183     void drawEastScale(Graphics g, int startx, int endx, int ypos)\r
184     {\r
185         ypos += av.charHeight;\r
186 \r
187         if(av.hasHiddenColumns)\r
188                 endx = av.getColumnSelection().adjustForHiddenColumns(endx);\r
189 \r
190         SequenceI seq;\r
191         // EAST SCALE\r
192         for (int i = 0; i < av.alignment.getHeight(); i++)\r
193         {\r
194             seq = av.alignment.getSequenceAt(i);\r
195             int index = endx;\r
196             int value = -1;\r
197 \r
198             while (index > startx)\r
199             {\r
200                 if (jalview.util.Comparison.isGap(seq.getCharAt(index)))\r
201                 {\r
202                     index--;\r
203 \r
204                     continue;\r
205                 }\r
206 \r
207                 value = seq.findPosition(index);\r
208 \r
209                 break;\r
210             }\r
211 \r
212             if (value != -1)\r
213             {\r
214                 g.drawString(String.valueOf(value), 0,\r
215                     (ypos + (i * av.charHeight)) - (av.charHeight / 5));\r
216             }\r
217         }\r
218     }\r
219 \r
220     /**\r
221      * DOCUMENT ME!\r
222      *\r
223      * @param horizontal DOCUMENT ME!\r
224      * @param vertical DOCUMENT ME!\r
225      */\r
226     public void fastPaint(int horizontal, int vertical)\r
227     {\r
228         if (gg == null)\r
229         {\r
230             return;\r
231         }\r
232 \r
233 \r
234         fastPaint = true;\r
235 \r
236         gg.copyArea(horizontal * av.charWidth,\r
237                     vertical * av.charHeight,\r
238                     imgWidth,\r
239                     imgHeight,\r
240                     -horizontal * av.charWidth,\r
241                     -vertical * av.charHeight);\r
242 \r
243         int sr = av.startRes;\r
244         int er = av.endRes;\r
245         int ss = av.startSeq;\r
246         int es = av.endSeq;\r
247         int transX = 0;\r
248         int transY = 0;\r
249 \r
250 \r
251         if (horizontal > 0) // scrollbar pulled right, image to the left\r
252         {\r
253             er ++;\r
254             transX = (er - sr - horizontal) * av.charWidth;\r
255             sr = er - horizontal;\r
256         }\r
257         else if (horizontal < 0)\r
258         {\r
259             er = sr - horizontal-1;\r
260         }\r
261         else if (vertical > 0) // scroll down\r
262         {\r
263             ss = es - vertical;\r
264 \r
265             if (ss < av.startSeq)\r
266             { // ie scrolling too fast, more than a page at a time\r
267                 ss = av.startSeq;\r
268             }\r
269             else\r
270             {\r
271                 transY = imgHeight - (vertical * av.charHeight);\r
272             }\r
273         }\r
274         else if (vertical < 0)\r
275         {\r
276             es = ss - vertical;\r
277 \r
278             if (es > av.endSeq)\r
279             {\r
280                 es = av.endSeq;\r
281             }\r
282         }\r
283 \r
284         gg.translate(transX, transY);\r
285         drawPanel(gg, sr, er, ss, es, 0);\r
286         gg.translate(-transX, -transY);\r
287 \r
288         repaint();\r
289     }\r
290 \r
291     /**\r
292      * Definitions of startx and endx (hopefully):\r
293      * SMJS This is what I'm working towards!\r
294      *   startx is the first residue (starting at 0) to display.\r
295      *   endx   is the last residue to display (starting at 0).\r
296      *   starty is the first sequence to display (starting at 0).\r
297      *   endy   is the last sequence to display (starting at 0).\r
298      * NOTE 1: The av limits are set in setFont in this class and\r
299      * in the adjustment listener in SeqPanel when the scrollbars move.\r
300      */\r
301 \r
302     // Set this to false to force a full panel paint\r
303     public void paintComponent(Graphics g)\r
304     {\r
305         super.paintComponent(g);\r
306 \r
307 \r
308 \r
309         if ( img != null && (fastPaint\r
310              || (getVisibleRect().width != g.getClipBounds().width)\r
311              || (getVisibleRect().height != g.getClipBounds().height)))\r
312         {\r
313             g.drawImage(img, 0, 0, this);\r
314             fastPaint = false;\r
315             return;\r
316         }\r
317 \r
318 \r
319         // this draws the whole of the alignment\r
320         imgWidth = getWidth();\r
321         imgHeight = getHeight();\r
322 \r
323         imgWidth -= (imgWidth % av.charWidth);\r
324         imgHeight -= (imgHeight % av.charHeight);\r
325 \r
326         if ((imgWidth < 1) || (imgHeight < 1))\r
327         {\r
328             return;\r
329         }\r
330 \r
331         img = new BufferedImage(imgWidth, imgHeight, BufferedImage.TYPE_INT_RGB);\r
332         gg = (Graphics2D) img.getGraphics();\r
333         gg.setFont(av.getFont());\r
334 \r
335         if (av.antiAlias)\r
336           gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,\r
337                               RenderingHints.VALUE_ANTIALIAS_ON);\r
338 \r
339         gg.setColor(Color.white);\r
340         gg.fillRect(0, 0, imgWidth, imgHeight);\r
341 \r
342 \r
343         if (av.getWrapAlignment())\r
344         {\r
345             drawWrappedPanel(gg, getWidth(), getHeight(), av.startRes);\r
346         }\r
347         else\r
348         {\r
349             drawPanel(gg, av.startRes, av.endRes, av.startSeq, av.endSeq, 0);\r
350         }\r
351 \r
352         g.drawImage(img, 0, 0, this);\r
353 \r
354         if (pdbCanvas != null)\r
355         {\r
356            pdbCanvas.updateSeqColours();\r
357         }\r
358 \r
359     }\r
360 \r
361     /**\r
362      * DOCUMENT ME!\r
363      *\r
364      * @param cwidth DOCUMENT ME!\r
365      *\r
366      * @return DOCUMENT ME!\r
367      */\r
368     public int getWrappedCanvasWidth(int cwidth)\r
369     {\r
370         FontMetrics fm = getFontMetrics(av.getFont());\r
371 \r
372         LABEL_EAST = 0;\r
373         LABEL_WEST = 0;\r
374 \r
375         if (av.scaleRightWrapped)\r
376         {\r
377             LABEL_EAST = fm.stringWidth(getMask());\r
378         }\r
379 \r
380         if (av.scaleLeftWrapped)\r
381         {\r
382             LABEL_WEST = fm.stringWidth(getMask());\r
383         }\r
384 \r
385         return (cwidth - LABEL_EAST - LABEL_WEST) / av.charWidth;\r
386     }\r
387 \r
388 \r
389     /**\r
390      * Generates a string of zeroes.\r
391      * @return String\r
392      */\r
393     String getMask()\r
394     {\r
395       String mask = "00";\r
396       for (int i = av.alignment.getWidth(); i > 0; i /= 10)\r
397       {\r
398         mask += "0";\r
399       }\r
400       return mask;\r
401     }\r
402 \r
403     /**\r
404      * DOCUMENT ME!\r
405      *\r
406      * @param g DOCUMENT ME!\r
407      * @param canvasWidth DOCUMENT ME!\r
408      * @param canvasHeight DOCUMENT ME!\r
409      * @param startRes DOCUMENT ME!\r
410      */\r
411     public void drawWrappedPanel(Graphics g, int canvasWidth, int canvasHeight,\r
412         int startRes)\r
413     {\r
414         AlignmentI al = av.getAlignment();\r
415 \r
416         FontMetrics fm = getFontMetrics(av.getFont());\r
417 \r
418 \r
419         if (av.scaleRightWrapped)\r
420         {\r
421             LABEL_EAST = fm.stringWidth(getMask());\r
422         }\r
423 \r
424 \r
425         if (av.scaleLeftWrapped)\r
426         {\r
427             LABEL_WEST = fm.stringWidth(getMask());\r
428         }\r
429 \r
430         int hgap = av.charHeight;\r
431         if(av.scaleAboveWrapped)\r
432           hgap += av.charHeight;\r
433 \r
434         int cWidth = (canvasWidth - LABEL_EAST - LABEL_WEST) / av.charWidth;\r
435         int cHeight = av.getAlignment().getHeight() * av.charHeight;\r
436 \r
437         av.setWrappedWidth(cWidth);\r
438 \r
439         av.endRes = av.startRes + cWidth;\r
440 \r
441 \r
442         int endx;\r
443         int ypos = hgap;\r
444         int maxwidth = av.alignment.getWidth();\r
445 \r
446         if(av.hasHiddenColumns)\r
447           maxwidth = av.getColumnSelection().findColumnPosition(maxwidth)-1;\r
448 \r
449         while ((ypos <= canvasHeight) && (startRes < maxwidth))\r
450         {\r
451           endx = startRes + cWidth -1;\r
452 \r
453           if (endx > maxwidth)\r
454           {\r
455             endx = maxwidth;\r
456           }\r
457 \r
458             g.setFont(av.getFont());\r
459             g.setColor(Color.black);\r
460 \r
461             if (av.scaleLeftWrapped)\r
462             {\r
463                 drawWestScale(g, startRes, endx, ypos);\r
464             }\r
465 \r
466             if (av.scaleRightWrapped)\r
467             {\r
468                 g.translate(canvasWidth - LABEL_EAST, 0);\r
469                 drawEastScale(g, startRes, endx, ypos);\r
470                 g.translate(-(canvasWidth - LABEL_EAST), 0);\r
471             }\r
472 \r
473             g.translate(LABEL_WEST, 0);\r
474 \r
475             if (av.scaleAboveWrapped)\r
476             {\r
477                 drawNorthScale(g, startRes, endx, ypos);\r
478             }\r
479 \r
480             if (av.hasHiddenColumns && av.showHiddenMarkers)\r
481             {\r
482               g.setColor(Color.blue);\r
483               int res;\r
484               for (int i = 0; i < av.getColumnSelection().getHiddenColumns().size();\r
485                    i++)\r
486               {\r
487                 res = av.getColumnSelection().findHiddenRegionPosition(i) -\r
488                     startRes;\r
489 \r
490                 if (res < 0 || res > endx - startRes)\r
491                   continue;\r
492 \r
493                 gg.fillPolygon(new int[]\r
494                                {res * av.charWidth - av.charHeight / 4,\r
495                                res * av.charWidth + av.charHeight / 4,\r
496                                res * av.charWidth},\r
497                                new int[]\r
498                                {\r
499                                ypos - (av.charHeight / 2),\r
500                                ypos - (av.charHeight / 2),\r
501                                ypos - (av.charHeight / 2) + 8\r
502                 }, 3);\r
503 \r
504               }\r
505             }\r
506 \r
507 \r
508 \r
509             // When printing we have an extra clipped region,\r
510             // the Printable page which we need to account for here\r
511             Shape clip = g.getClip();\r
512 \r
513             if (clip == null)\r
514             {\r
515                 g.setClip(0, 0, cWidth * av.charWidth, canvasHeight);\r
516             }\r
517             else\r
518             {\r
519                 g.setClip(0, (int) clip.getBounds().getY(),\r
520                     cWidth * av.charWidth, (int) clip.getBounds().getHeight());\r
521             }\r
522 \r
523             drawPanel(g, startRes, endx, 0, al.getHeight(), ypos);\r
524 \r
525             if(av.showAnnotation)\r
526             {\r
527               g.translate(0, cHeight + ypos + 3);\r
528               if(annotations==null)\r
529                 annotations = new AnnotationPanel(av);\r
530 \r
531               annotations.drawComponent( (Graphics2D) g, startRes, endx+1);\r
532               g.translate(0, -cHeight - ypos);\r
533             }\r
534             g.setClip(clip);\r
535             g.translate(-LABEL_WEST, 0);\r
536 \r
537             ypos += cHeight+getAnnotationHeight()+hgap;\r
538             if(av.showAnnotation)\r
539               ypos -= 3;\r
540 \r
541             startRes += cWidth;\r
542         }\r
543     }\r
544 \r
545     AnnotationPanel annotations;\r
546     int getAnnotationHeight()\r
547     {\r
548       if(!av.showAnnotation)\r
549         return 0;\r
550 \r
551       if(annotations==null)\r
552         annotations = new AnnotationPanel(av);\r
553 \r
554       return annotations.adjustPanelHeight();\r
555     }\r
556 \r
557     /**\r
558      * DOCUMENT ME!\r
559      *\r
560      * @param g1 DOCUMENT ME!\r
561      * @param startRes DOCUMENT ME!\r
562      * @param endRes DOCUMENT ME!\r
563      * @param startSeq DOCUMENT ME!\r
564      * @param endSeq DOCUMENT ME!\r
565      * @param offset DOCUMENT ME!\r
566      */\r
567     void drawPanel(Graphics g1, int startRes, int endRes,\r
568                     int startSeq, int endSeq, int offset)\r
569     {\r
570       if(!av.hasHiddenColumns)\r
571       {\r
572         draw(g1, startRes, endRes, startSeq, endSeq, offset);\r
573       }\r
574       else\r
575       {\r
576         java.util.Vector regions = av.getColumnSelection().getHiddenColumns();\r
577 \r
578         int screenY = 0;\r
579         int blockStart = startRes;\r
580         int blockEnd = endRes;\r
581 \r
582         for (int i = 0; i < regions.size(); i++)\r
583         {\r
584           int[] region = (int[]) regions.elementAt(i);\r
585           int hideStart = region[0];\r
586           int hideEnd = region[1];\r
587 \r
588           if (hideStart <= blockStart)\r
589           {\r
590             blockStart += (hideEnd - hideStart) + 1;\r
591             continue;\r
592           }\r
593 \r
594           blockEnd = hideStart - 1;\r
595 \r
596           g1.translate(screenY * av.charWidth, 0);\r
597 \r
598           draw(g1, blockStart, blockEnd, startSeq, endSeq, offset);\r
599 \r
600           if(av.getShowHiddenMarkers())\r
601           {\r
602             g1.setColor(Color.blue);\r
603             g1.drawLine( (blockEnd - blockStart + 1) * av.charWidth - 1,\r
604                         startSeq + offset,\r
605                         (blockEnd - blockStart + 1) * av.charWidth - 1,\r
606                         startSeq + (endSeq - startSeq) * av.charHeight + offset);\r
607           }\r
608 \r
609           g1.translate( -screenY * av.charWidth, 0);\r
610           screenY += blockEnd - blockStart + 1;\r
611           blockStart = hideEnd + 1;\r
612         }\r
613 \r
614         if (screenY <= (endRes - startRes))\r
615         {\r
616           blockEnd = blockStart + (endRes - startRes) - screenY;\r
617           g1.translate(screenY * av.charWidth, 0);\r
618           draw(g1, blockStart, blockEnd, startSeq, endSeq, offset);\r
619 \r
620           g1.translate( -screenY * av.charWidth, 0);\r
621         }\r
622       }\r
623 \r
624     }\r
625 \r
626 \r
627 \r
628 \r
629     //int startRes, int endRes, int startSeq, int endSeq, int x, int y,\r
630     // int x1, int x2, int y1, int y2, int startx, int starty,\r
631     void draw(Graphics g,\r
632                    int startRes, int endRes,\r
633                    int startSeq, int endSeq,\r
634                    int offset)\r
635    {\r
636       g.setFont(av.getFont());\r
637       sr.prepare(g, av.renderGaps);\r
638 \r
639       SequenceI nextSeq;\r
640 \r
641         /// First draw the sequences\r
642         /////////////////////////////\r
643         for (int i = startSeq; i < endSeq; i++)\r
644         {\r
645             nextSeq = av.alignment.getSequenceAt(i);\r
646 \r
647             sr.drawSequence(nextSeq, av.alignment.findAllGroups(nextSeq),\r
648                             startRes, endRes,\r
649                             offset + ( (i - startSeq) * av.charHeight));\r
650 \r
651             if (av.showSequenceFeatures)\r
652             {\r
653                 fr.drawSequence(g, nextSeq, startRes, endRes,\r
654                     offset + ((i - startSeq) * av.charHeight));\r
655             }\r
656 \r
657             /// Highlight search Results once all sequences have been drawn\r
658             //////////////////////////////////////////////////////////\r
659             if (searchResults != null)\r
660             {\r
661               int[] visibleResults = searchResults.getResults(nextSeq, startRes, endRes);\r
662               if (visibleResults != null)\r
663                 for (int r = 0; r < visibleResults.length; r += 2)\r
664                 {\r
665                   sr.drawHighlightedText(nextSeq, visibleResults[r],\r
666                                          visibleResults[r + 1],\r
667                                          (visibleResults[r] - startRes) * av.charWidth,\r
668                                          offset + ( (i - startSeq) * av.charHeight));\r
669                 }\r
670             }\r
671 \r
672             if(av.cursorMode && cursorY==i\r
673                && cursorX>=startRes && cursorX<=endRes)\r
674             {\r
675               sr.drawCursor(nextSeq, cursorX, (cursorX - startRes) * av.charWidth,\r
676                             offset + ( (i - startSeq) * av.charHeight));\r
677             }\r
678           }\r
679 \r
680           if(av.getSelectionGroup()!=null || av.alignment.getGroups().size()>0)\r
681             drawGroupsBoundaries(g, startRes, endRes, startSeq, endSeq, offset);\r
682 \r
683    }\r
684 \r
685    void drawGroupsBoundaries(Graphics g1,\r
686                    int startRes, int endRes,\r
687                    int startSeq, int endSeq,\r
688                    int offset)\r
689    {\r
690        Graphics2D g = (Graphics2D)g1;\r
691         //\r
692         /////////////////////////////////////\r
693         // Now outline any areas if necessary\r
694         /////////////////////////////////////\r
695         SequenceGroup group = av.getSelectionGroup();\r
696 \r
697         int sx = -1;\r
698         int sy = -1;\r
699         int ex = -1;\r
700         int groupIndex = -1;\r
701 \r
702         if ((group == null) && (av.alignment.getGroups().size() > 0))\r
703         {\r
704             group = (SequenceGroup) av.alignment.getGroups().elementAt(0);\r
705             groupIndex = 0;\r
706         }\r
707 \r
708         if (group != null)\r
709         {\r
710             do\r
711             {\r
712                 int oldY = -1;\r
713                 int i = 0;\r
714                 boolean inGroup = false;\r
715                 int top = -1;\r
716                 int bottom = -1;\r
717 \r
718                 for (i = startSeq; i < endSeq; i++)\r
719                 {\r
720                     sx = (group.getStartRes() - startRes) * av.charWidth;\r
721                     sy = offset + ((i - startSeq) * av.charHeight);\r
722                     ex = (((group.getEndRes() + 1) - group.getStartRes()) * av.charWidth) -\r
723                         1;\r
724 \r
725                     if(sx+ex<0 || sx>imgWidth)\r
726                     {\r
727                       continue;\r
728                     }\r
729 \r
730                     if ( (sx <= (endRes-startRes)*av.charWidth) &&\r
731                             group.getSequences(false).\r
732                             contains(av.alignment.getSequenceAt(i)))\r
733                     {\r
734                         if ((bottom == -1) &&\r
735                                 !group.getSequences(false).contains(\r
736                                     av.alignment.getSequenceAt(i + 1)))\r
737                         {\r
738                             bottom = sy + av.charHeight;\r
739                         }\r
740 \r
741                         if (!inGroup)\r
742                         {\r
743                             if (((top == -1) && (i == 0)) ||\r
744                                     !group.getSequences(false).contains(\r
745                                         av.alignment.getSequenceAt(i - 1)))\r
746                             {\r
747                                 top = sy;\r
748                             }\r
749 \r
750                             oldY = sy;\r
751                             inGroup = true;\r
752 \r
753                             if (group == av.getSelectionGroup())\r
754                             {\r
755                                 g.setStroke(new BasicStroke(1,\r
756                                         BasicStroke.CAP_BUTT,\r
757                                         BasicStroke.JOIN_ROUND, 3f,\r
758                                         new float[] { 5f, 3f }, 0f));\r
759                                 g.setColor(Color.RED);\r
760                             }\r
761                             else\r
762                             {\r
763                                 g.setStroke(new BasicStroke());\r
764                                 g.setColor(group.getOutlineColour());\r
765                             }\r
766                         }\r
767                     }\r
768                     else\r
769                     {\r
770                       if (inGroup)\r
771                       {\r
772                         if (sx >= 0 && sx < imgWidth)\r
773                           g.drawLine(sx, oldY, sx, sy);\r
774 \r
775                         if (sx + ex < imgWidth)\r
776                           g.drawLine(sx + ex, oldY, sx + ex, sy);\r
777 \r
778                         if (sx < 0)\r
779                         {\r
780                           ex += sx;\r
781                           sx = 0;\r
782                         }\r
783 \r
784                         if (sx + ex > imgWidth)\r
785                           ex = imgWidth;\r
786 \r
787                         else if (sx + ex >= (endRes - startRes + 1) * av.charWidth)\r
788                           ex = (endRes - startRes + 1) * av.charWidth;\r
789 \r
790                         if (top != -1)\r
791                         {\r
792                           g.drawLine(sx, top, sx + ex, top);\r
793                           top = -1;\r
794                         }\r
795 \r
796                         if (bottom != -1)\r
797                         {\r
798                           g.drawLine(sx, bottom, sx + ex, bottom);\r
799                           bottom = -1;\r
800                         }\r
801 \r
802                         inGroup = false;\r
803                         }\r
804                     }\r
805                 }\r
806 \r
807                 if (inGroup)\r
808                 {\r
809                   sy = offset + ( (i - startSeq) * av.charHeight);\r
810                   if (sx >= 0 && sx < imgWidth)\r
811                     g.drawLine(sx, oldY, sx, sy);\r
812 \r
813                   if (sx + ex < imgWidth)\r
814                     g.drawLine(sx + ex, oldY, sx + ex, sy);\r
815 \r
816                   if (sx < 0)\r
817                   {\r
818                     ex += sx;\r
819                     sx = 0;\r
820                   }\r
821 \r
822                   if (sx + ex > imgWidth)\r
823                     ex = imgWidth;\r
824                   else if (sx + ex >= (endRes - startRes + 1) * av.charWidth)\r
825                     ex = (endRes - startRes + 1) * av.charWidth;\r
826 \r
827                   if (top != -1)\r
828                   {\r
829                     g.drawLine(sx, top, sx + ex, top);\r
830                     top = -1;\r
831                   }\r
832 \r
833                   if (bottom != -1)\r
834                   {\r
835                     g.drawLine(sx, bottom - 1, sx + ex, bottom - 1);\r
836                     bottom = -1;\r
837                   }\r
838 \r
839                     inGroup = false;\r
840                 }\r
841 \r
842                 groupIndex++;\r
843 \r
844                 if (groupIndex >= av.alignment.getGroups().size())\r
845                 {\r
846                     break;\r
847                 }\r
848 \r
849                 group = (SequenceGroup) av.alignment.getGroups().elementAt(groupIndex);\r
850 \r
851                 g.setStroke(new BasicStroke());\r
852             }\r
853             while (groupIndex < av.alignment.getGroups().size());\r
854 \r
855         }\r
856 \r
857     }\r
858 \r
859     /**\r
860      * DOCUMENT ME!\r
861      *\r
862      * @param results DOCUMENT ME!\r
863      */\r
864     public void highlightSearchResults(SearchResults results)\r
865     {\r
866         img = null;\r
867 \r
868         searchResults = results;\r
869 \r
870         repaint();\r
871     }\r
872 }\r