src/jalview/appletgui/ScalePanel.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.4)
   3  * Copyright (C) 2008 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18  */
  19 package jalview.appletgui;
  20
  21 import java.awt.*;
  22 import java.awt.event.*;
  23
  24 import jalview.datamodel.*;
  25
  26 public class ScalePanel extends Panel implements MouseMotionListener,
  27         MouseListener
  28 {
  29
  30   protected int offy = 4;
  31
  32   public int width;
  33
  34   protected AlignViewport av;
  35
  36   AlignmentPanel ap;
  37
  38   boolean stretchingGroup = false;
  39
  40   int min; // used by mouseDragged to see if user
  41
  42   int max; // used by mouseDragged to see if user
  43
  44   boolean mouseDragging = false;
  45
  46   int[] reveal;
  47
  48   public ScalePanel(AlignViewport av, AlignmentPanel ap)
  49   {
  50     setLayout(null);
  51     this.av = av;
  52     this.ap = ap;
  53
  54     addMouseListener(this);
  55     addMouseMotionListener(this);
  56
  57   }
  58
  59   public void mousePressed(MouseEvent evt)
  60   {
  61     int x = (evt.getX() / av.getCharWidth()) + av.getStartRes();
  62     final int res;
  63
  64     if (av.hasHiddenColumns)
  65     {
  66       res = av.getColumnSelection().adjustForHiddenColumns(x);
  67     }
  68     else
  69     {
  70       res = x;
  71     }
  72
  73     min = res;
  74     max = res;
  75     if ((evt.getModifiers() & InputEvent.BUTTON3_MASK) == InputEvent.BUTTON3_MASK)
  76     {
  77       PopupMenu pop = new PopupMenu();
  78       if (reveal != null)
  79       {
  80         MenuItem item = new MenuItem("Reveal");
  81         item.addActionListener(new ActionListener()
  82         {
  83           public void actionPerformed(ActionEvent e)
  84           {
  85             av.showColumn(reveal[0]);
  86             reveal = null;
  87             ap.paintAlignment(true);
  88             if (ap.overviewPanel != null)
  89             {
  90               ap.overviewPanel.updateOverviewImage();
  91             }
  92           }
  93         });
  94         pop.add(item);
  95
  96         if (av.getColumnSelection().getHiddenColumns().size() > 1)
  97         {
  98           item = new MenuItem("Reveal All");
  99           item.addActionListener(new ActionListener()
 100           {
 101             public void actionPerformed(ActionEvent e)
 102             {
 103               av.showAllHiddenColumns();
 104               reveal = null;
 105               ap.paintAlignment(true);
 106               if (ap.overviewPanel != null)
 107               {
 108                 ap.overviewPanel.updateOverviewImage();
 109               }
 110             }
 111           });
 112           pop.add(item);
 113         }
 114         this.add(pop);
 115         pop.show(this, evt.getX(), evt.getY());
 116       }
 117       else if (av.getColumnSelection().contains(res))
 118       {
 119         MenuItem item = new MenuItem("Hide Columns");
 120         item.addActionListener(new ActionListener()
 121         {
 122           public void actionPerformed(ActionEvent e)
 123           {
 124             av.hideColumns(res, res);
 125             if (av.getSelectionGroup() != null
 126                     && av.getSelectionGroup().getSize() == av.alignment
 127                             .getHeight())
 128             {
 129               av.setSelectionGroup(null);
 130             }
 131
 132             ap.paintAlignment(true);
 133             if (ap.overviewPanel != null)
 134             {
 135               ap.overviewPanel.updateOverviewImage();
 136             }
 137           }
 138         });
 139         pop.add(item);
 140         this.add(pop);
 141         pop.show(this, evt.getX(), evt.getY());
 142       }
 143     }
 144     else
 145     // LEFT MOUSE TO SELECT
 146     {
 147       if (!evt.isControlDown() && !evt.isShiftDown())
 148       {
 149         av.getColumnSelection().clear();
 150       }
 151
 152       av.getColumnSelection().addElement(res);
 153       SequenceGroup sg = new SequenceGroup();
 154       for (int i = 0; i < av.alignment.getSequences().size(); i++)
 155       {
 156         sg.addSequence(av.alignment.getSequenceAt(i), false);
 157       }
 158
 159       sg.setStartRes(res);
 160       sg.setEndRes(res);
 161       av.setSelectionGroup(sg);
 162
 163       if (evt.isShiftDown())
 164       {
 165         int min = Math.min(av.getColumnSelection().getMin(), res);
 166         int max = Math.max(av.getColumnSelection().getMax(), res);
 167         for (int i = min; i < max; i++)
 168         {
 169           av.getColumnSelection().addElement(i);
 170         }
 171         sg.setStartRes(min);
 172         sg.setEndRes(max);
 173       }
 174     }
 175
 176     ap.paintAlignment(true);
 177   }
 178
 179   public void mouseReleased(MouseEvent evt)
 180   {
 181     mouseDragging = false;
 182
 183     int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
 184
 185     if (res > av.alignment.getWidth())
 186     {
 187       res = av.alignment.getWidth() - 1;
 188     }
 189
 190     if (av.hasHiddenColumns)
 191     {
 192       res = av.getColumnSelection().adjustForHiddenColumns(res);
 193     }
 194
 195     if (!stretchingGroup)
 196     {
 197       ap.paintAlignment(false);
 198
 199       return;
 200     }
 201
 202     SequenceGroup sg = av.getSelectionGroup();
 203
 204     if (res > sg.getStartRes())
 205     {
 206       sg.setEndRes(res);
 207     }
 208     else if (res < sg.getStartRes())
 209     {
 210       sg.setStartRes(res);
 211     }
 212
 213     stretchingGroup = false;
 214     ap.paintAlignment(false);
 215   }
 216
 217   public void mouseDragged(MouseEvent evt)
 218   {
 219     mouseDragging = true;
 220
 221     int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
 222     if (res < 0)
 223     {
 224       res = 0;
 225     }
 226
 227     if (av.hasHiddenColumns)
 228     {
 229       res = av.getColumnSelection().adjustForHiddenColumns(res);
 230     }
 231
 232     if (res > av.alignment.getWidth())
 233     {
 234       res = av.alignment.getWidth() - 1;
 235     }
 236
 237     if (res < min)
 238     {
 239       min = res;
 240     }
 241
 242     if (res > max)
 243     {
 244       max = res;
 245     }
 246
 247     SequenceGroup sg = av.getSelectionGroup();
 248
 249     if (sg != null)
 250     {
 251       stretchingGroup = true;
 252
 253       if (!av.getColumnSelection().contains(res))
 254       {
 255         av.getColumnSelection().addElement(res);
 256       }
 257
 258       if (res > sg.getStartRes())
 259       {
 260         sg.setEndRes(res);
 261       }
 262       if (res < sg.getStartRes())
 263       {
 264         sg.setStartRes(res);
 265       }
 266
 267       int col;
 268       for (int i = min; i <= max; i++)
 269       {
 270         col = av.getColumnSelection().adjustForHiddenColumns(i);
 271
 272         if ((col < sg.getStartRes()) || (col > sg.getEndRes()))
 273         {
 274           av.getColumnSelection().removeElement(col);
 275         }
 276         else
 277         {
 278           av.getColumnSelection().addElement(col);
 279         }
 280       }
 281
 282       ap.paintAlignment(false);
 283     }
 284   }
 285
 286   public void mouseEntered(MouseEvent evt)
 287   {
 288     if (mouseDragging)
 289     {
 290       ap.seqPanel.scrollCanvas(null);
 291     }
 292   }
 293
 294   public void mouseExited(MouseEvent evt)
 295   {
 296     if (mouseDragging)
 297     {
 298       ap.seqPanel.scrollCanvas(evt);
 299     }
 300   }
 301
 302   public void mouseClicked(MouseEvent evt)
 303   {
 304
 305   }
 306
 307   public void mouseMoved(MouseEvent evt)
 308   {
 309     if (!av.hasHiddenColumns)
 310     {
 311       return;
 312     }
 313
 314     int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
 315
 316     res = av.getColumnSelection().adjustForHiddenColumns(res);
 317
 318     reveal = null;
 319     for (int i = 0; i < av.getColumnSelection().getHiddenColumns().size(); i++)
 320     {
 321       int[] region = (int[]) av.getColumnSelection().getHiddenColumns()
 322               .elementAt(i);
 323       if (res + 1 == region[0] || res - 1 == region[1])
 324       {
 325         reveal = region;
 326         break;
 327       }
 328     }
 329
 330     repaint();
 331   }
 332
 333   public void update(Graphics g)
 334   {
 335     paint(g);
 336   }
 337
 338   public void paint(Graphics g)
 339   {
 340     drawScale(g, av.getStartRes(), av.getEndRes(), getSize().width,
 341             getSize().height);
 342   }
 343
 344   // scalewidth will normally be screenwidth,
 345   public void drawScale(Graphics gg, int startx, int endx, int width,
 346           int height)
 347   {
 348     gg.setFont(av.getFont());
 349
 350     // Fill in the background
 351     gg.setColor(Color.white);
 352     gg.fillRect(0, 0, width, height);
 353     gg.setColor(Color.black);
 354
 355     // Fill the selected columns
 356     ColumnSelection cs = av.getColumnSelection();
 357     gg.setColor(new Color(220, 0, 0));
 358
 359     for (int i = 0; i < cs.size(); i++)
 360     {
 361       int sel = cs.columnAt(i);
 362       if (av.hasHiddenColumns)
 363       {
 364         sel = av.getColumnSelection().findColumnPosition(sel);
 365       }
 366
 367       if ((sel >= startx) && (sel <= endx))
 368       {
 369         gg.fillRect((sel - startx) * av.charWidth, 0, av.charWidth,
 370                 getSize().height);
 371       }
 372     }
 373
 374     // Draw the scale numbers
 375     gg.setColor(Color.black);
 376
 377     int scalestartx = (startx / 10) * 10;
 378
 379     FontMetrics fm = gg.getFontMetrics(av.getFont());
 380     int y = av.charHeight - fm.getDescent();
 381
 382     if ((scalestartx % 10) == 0)
 383     {
 384       scalestartx += 5;
 385     }
 386
 387     String string;
 388     int maxX = 0;
 389
 390     for (int i = scalestartx; i < endx; i += 5)
 391     {
 392       if ((i % 10) == 0)
 393       {
 394         string = String.valueOf(av.getColumnSelection()
 395                 .adjustForHiddenColumns(i));
 396         if ((i - startx - 1) * av.charWidth > maxX)
 397         {
 398           gg.drawString(string, (i - startx - 1) * av.charWidth, y);
 399           maxX = (i - startx + 1) * av.charWidth + fm.stringWidth(string);
 400         }
 401
 402         gg
 403                 .drawLine(
 404                         (int) (((i - startx - 1) * av.charWidth) + (av.charWidth / 2)),
 405                         y + 2,
 406                         (int) (((i - startx - 1) * av.charWidth) + (av.charWidth / 2)),
 407                         y + (fm.getDescent() * 2));
 408
 409       }
 410       else
 411       {
 412         gg
 413                 .drawLine(
 414                         (int) (((i - startx - 1) * av.charWidth) + (av.charWidth / 2)),
 415                         y + fm.getDescent(),
 416                         (int) (((i - startx - 1) * av.charWidth) + (av.charWidth / 2)),
 417                         y + (fm.getDescent() * 2));
 418       }
 419     }
 420
 421     if (av.hasHiddenColumns)
 422     {
 423       gg.setColor(Color.blue);
 424       int res;
 425       if (av.getShowHiddenMarkers())
 426       {
 427         for (int i = 0; i < av.getColumnSelection().getHiddenColumns()
 428                 .size(); i++)
 429         {
 430
 431           res = av.getColumnSelection().findHiddenRegionPosition(i)
 432                   - startx;
 433
 434           if (res < 0 || res > endx - scalestartx)
 435           {
 436             continue;
 437           }
 438
 439           gg.fillPolygon(new int[]
 440           { res * av.charWidth - av.charHeight / 4,
 441               res * av.charWidth + av.charHeight / 4, res * av.charWidth },
 442                   new int[]
 443                   { y - av.charHeight / 2, y - av.charHeight / 2, y + 8 },
 444                   3);
 445
 446         }
 447       }
 448
 449       if (reveal != null && reveal[0] > startx && reveal[0] < endx)
 450       {
 451         gg.drawString("Reveal Columns", reveal[0] * av.charWidth, 0);
 452       }
 453     }
 454
 455   }
 456
 457 }