src/jalview/gui/ScalePanel.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.gui;
  22
  23 import jalview.datamodel.ColumnSelection;
  24 import jalview.datamodel.SequenceGroup;
  25 import jalview.datamodel.SequenceI;
  26 import jalview.renderer.ScaleRenderer;
  27 import jalview.renderer.ScaleRenderer.ScaleMark;
  28 import jalview.util.MessageManager;
  29
  30 import java.awt.Color;
  31 import java.awt.FontMetrics;
  32 import java.awt.Graphics;
  33 import java.awt.Graphics2D;
  34 import java.awt.RenderingHints;
  35 import java.awt.event.ActionEvent;
  36 import java.awt.event.ActionListener;
  37 import java.awt.event.MouseEvent;
  38 import java.awt.event.MouseListener;
  39 import java.awt.event.MouseMotionListener;
  40 import java.util.List;
  41
  42 import javax.swing.JMenuItem;
  43 import javax.swing.JPanel;
  44 import javax.swing.JPopupMenu;
  45 import javax.swing.ToolTipManager;
  46
  47 /**
  48  * The panel containing the sequence ruler (when not in wrapped mode), and
  49  * supports a range of mouse operations to select, hide or reveal columns.
  50  */
  51 public class ScalePanel extends JPanel implements MouseMotionListener,
  52         MouseListener
  53 {
  54   protected int offy = 4;
  55
  56   public int width;
  57
  58   protected AlignViewport av;
  59
  60   AlignmentPanel ap;
  61
  62   boolean stretchingGroup = false;
  63
  64   /*
  65    * min, max hold the extent of a mouse drag action
  66    */
  67   int min;
  68
  69   int max;
  70
  71   boolean mouseDragging = false;
  72
  73   /*
  74    * holds a hidden column range when the mouse is over an adjacent column
  75    */
  76   int[] reveal;
  77
  78   /**
  79    * Constructor
  80    *
  81    * @param av
  82    * @param ap
  83    */
  84   public ScalePanel(AlignViewport av, AlignmentPanel ap)
  85   {
  86     this.av = av;
  87     this.ap = ap;
  88
  89     addMouseListener(this);
  90     addMouseMotionListener(this);
  91   }
  92
  93   /**
  94    * DOCUMENT ME!
  95    *
  96    * @param evt
  97    *          DOCUMENT ME!
  98    */
  99   @Override
 100   public void mousePressed(MouseEvent evt)
 101   {
 102     int x = (evt.getX() / av.getCharWidth()) + av.getStartRes();
 103     final int res;
 104
 105     if (av.hasHiddenColumns())
 106     {
 107       x = av.getColumnSelection().adjustForHiddenColumns(x);
 108     }
 109
 110     if (x >= av.getAlignment().getWidth())
 111     {
 112       res = av.getAlignment().getWidth() - 1;
 113     }
 114     else
 115     {
 116       res = x;
 117     }
 118
 119     min = res;
 120     max = res;
 121
 122     if (evt.isPopupTrigger())
 123     {
 124       rightMouseButtonPressed(evt, res);
 125     }
 126     else
 127     {
 128       leftMouseButtonPressed(evt, res);
 129     }
 130   }
 131
 132   /**
 133    * Handles right mouse button press. If pressed in a selected column, opens
 134    * context menu for 'Hide Columns'. If pressed on a hidden columns marker,
 135    * opens context menu for 'Reveal / Reveal All'. Else does nothing.
 136    *
 137    * @param evt
 138    * @param res
 139    */
 140   protected void rightMouseButtonPressed(MouseEvent evt, final int res)
 141   {
 142     JPopupMenu pop = new JPopupMenu();
 143     if (reveal != null)
 144     {
 145       JMenuItem item = new JMenuItem(
 146               MessageManager.getString("label.reveal"));
 147       item.addActionListener(new ActionListener()
 148       {
 149         @Override
 150         public void actionPerformed(ActionEvent e)
 151         {
 152           av.showColumn(reveal[0]);
 153           reveal = null;
 154           ap.paintAlignment(true);
 155           if (ap.overviewPanel != null)
 156           {
 157             ap.overviewPanel.updateOverviewImage();
 158           }
 159           av.sendSelection();
 160         }
 161       });
 162       pop.add(item);
 163
 164       if (av.getColumnSelection().hasHiddenColumns())
 165       {
 166         item = new JMenuItem(MessageManager.getString("action.reveal_all"));
 167         item.addActionListener(new ActionListener()
 168         {
 169           @Override
 170           public void actionPerformed(ActionEvent e)
 171           {
 172             av.showAllHiddenColumns();
 173             reveal = null;
 174             ap.paintAlignment(true);
 175             if (ap.overviewPanel != null)
 176             {
 177               ap.overviewPanel.updateOverviewImage();
 178             }
 179             av.sendSelection();
 180           }
 181         });
 182         pop.add(item);
 183       }
 184       pop.show(this, evt.getX(), evt.getY());
 185     }
 186     else if (av.getColumnSelection().contains(res))
 187     {
 188       JMenuItem item = new JMenuItem(
 189               MessageManager.getString("label.hide_columns"));
 190       item.addActionListener(new ActionListener()
 191       {
 192         @Override
 193         public void actionPerformed(ActionEvent e)
 194         {
 195           av.hideColumns(res, res);
 196           if (av.getSelectionGroup() != null
 197                   && av.getSelectionGroup().getSize() == av.getAlignment()
 198                           .getHeight())
 199           {
 200             av.setSelectionGroup(null);
 201           }
 202
 203           ap.paintAlignment(true);
 204           if (ap.overviewPanel != null)
 205           {
 206             ap.overviewPanel.updateOverviewImage();
 207           }
 208           av.sendSelection();
 209         }
 210       });
 211       pop.add(item);
 212       pop.show(this, evt.getX(), evt.getY());
 213     }
 214   }
 215
 216   /**
 217    * Handles left mouse button press
 218    *
 219    * @param evt
 220    * @param res
 221    */
 222   protected void leftMouseButtonPressed(MouseEvent evt, final int res)
 223   {
 224     if (!evt.isControlDown() && !evt.isShiftDown())
 225     {
 226       av.getColumnSelection().clear();
 227     }
 228
 229     av.getColumnSelection().addElement(res);
 230     SequenceGroup sg = new SequenceGroup();
 231     // try to be as quick as possible
 232     SequenceI[] iVec = av.getAlignment().getSequencesArray();
 233     for (int i = 0; i < iVec.length; i++)
 234     {
 235       sg.addSequence(iVec[i], false);
 236       iVec[i] = null;
 237     }
 238     iVec = null;
 239     sg.setStartRes(res);
 240     sg.setEndRes(res);
 241
 242     if (evt.isShiftDown())
 243     {
 244       int min = Math.min(av.getColumnSelection().getMin(), res);
 245       int max = Math.max(av.getColumnSelection().getMax(), res);
 246       for (int i = min; i < max; i++)
 247       {
 248         av.getColumnSelection().addElement(i);
 249       }
 250       sg.setStartRes(min);
 251       sg.setEndRes(max);
 252     }
 253     av.setSelectionGroup(sg);
 254     ap.paintAlignment(false);
 255     av.sendSelection();
 256   }
 257
 258   /**
 259    * DOCUMENT ME!
 260    *
 261    * @param evt
 262    *          DOCUMENT ME!
 263    */
 264   @Override
 265   public void mouseReleased(MouseEvent evt)
 266   {
 267     mouseDragging = false;
 268
 269     int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
 270
 271     if (av.hasHiddenColumns())
 272     {
 273       res = av.getColumnSelection().adjustForHiddenColumns(res);
 274     }
 275
 276     if (res >= av.getAlignment().getWidth())
 277     {
 278       res = av.getAlignment().getWidth() - 1;
 279     }
 280
 281     if (!stretchingGroup)
 282     {
 283       ap.paintAlignment(false);
 284
 285       return;
 286     }
 287
 288     SequenceGroup sg = av.getSelectionGroup();
 289
 290     if (sg != null)
 291     {
 292       if (res > sg.getStartRes())
 293       {
 294         sg.setEndRes(res);
 295       }
 296       else if (res < sg.getStartRes())
 297       {
 298         sg.setStartRes(res);
 299       }
 300     }
 301     stretchingGroup = false;
 302     ap.paintAlignment(false);
 303     av.sendSelection();
 304   }
 305
 306   /**
 307    * DOCUMENT ME!
 308    *
 309    * @param evt
 310    *          DOCUMENT ME!
 311    */
 312   @Override
 313   public void mouseDragged(MouseEvent evt)
 314   {
 315     mouseDragging = true;
 316
 317     int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
 318     if (res < 0)
 319     {
 320       res = 0;
 321     }
 322
 323     if (av.hasHiddenColumns())
 324     {
 325       res = av.getColumnSelection().adjustForHiddenColumns(res);
 326     }
 327
 328     if (res >= av.getAlignment().getWidth())
 329     {
 330       res = av.getAlignment().getWidth() - 1;
 331     }
 332
 333     if (res < min)
 334     {
 335       min = res;
 336     }
 337
 338     if (res > max)
 339     {
 340       max = res;
 341     }
 342
 343     SequenceGroup sg = av.getSelectionGroup();
 344
 345     if (sg != null)
 346     {
 347       stretchingGroup = true;
 348
 349       if (!av.getColumnSelection().contains(res))
 350       {
 351         av.getColumnSelection().addElement(res);
 352       }
 353
 354       if (res > sg.getStartRes())
 355       {
 356         sg.setEndRes(res);
 357       }
 358       if (res < sg.getStartRes())
 359       {
 360         sg.setStartRes(res);
 361       }
 362
 363       int col;
 364       for (int i = min; i <= max; i++)
 365       {
 366         col = i; // av.getColumnSelection().adjustForHiddenColumns(i);
 367
 368         if ((col < sg.getStartRes()) || (col > sg.getEndRes()))
 369         {
 370           av.getColumnSelection().removeElement(col);
 371         }
 372         else
 373         {
 374           av.getColumnSelection().addElement(col);
 375         }
 376       }
 377
 378       ap.paintAlignment(false);
 379     }
 380   }
 381
 382   @Override
 383   public void mouseEntered(MouseEvent evt)
 384   {
 385     if (mouseDragging)
 386     {
 387       ap.getSeqPanel().scrollCanvas(null);
 388     }
 389   }
 390
 391   @Override
 392   public void mouseExited(MouseEvent evt)
 393   {
 394     if (mouseDragging)
 395     {
 396       ap.getSeqPanel().scrollCanvas(evt);
 397     }
 398   }
 399
 400   @Override
 401   public void mouseClicked(MouseEvent evt)
 402   {
 403   }
 404
 405   @Override
 406   public void mouseMoved(MouseEvent evt)
 407   {
 408     this.setToolTipText(null);
 409     reveal = null;
 410     if (!av.hasHiddenColumns())
 411     {
 412       return;
 413     }
 414
 415     int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
 416
 417     res = av.getColumnSelection().adjustForHiddenColumns(res);
 418
 419     if (av.getColumnSelection().getHiddenColumns() != null)
 420     {
 421       for (int[] region : av.getColumnSelection().getHiddenColumns())
 422       {
 423         if (res + 1 == region[0] || res - 1 == region[1])
 424         {
 425           reveal = region;
 426           ToolTipManager.sharedInstance().registerComponent(this);
 427           this.setToolTipText(MessageManager
 428                   .getString("label.reveal_hidden_columns"));
 429           break;
 430         }
 431       }
 432     }
 433     repaint();
 434   }
 435
 436   /**
 437    * DOCUMENT ME!
 438    *
 439    * @param g
 440    *          DOCUMENT ME!
 441    */
 442   @Override
 443   public void paintComponent(Graphics g)
 444   {
 445     drawScale(g, av.getStartRes(), av.getEndRes(), getWidth(), getHeight());
 446   }
 447
 448   // scalewidth will normally be screenwidth,
 449   public void drawScale(Graphics g, int startx, int endx, int width,
 450           int height)
 451   {
 452     Graphics2D gg = (Graphics2D) g;
 453     gg.setFont(av.getFont());
 454
 455     if (av.antiAlias)
 456     {
 457       gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
 458               RenderingHints.VALUE_ANTIALIAS_ON);
 459     }
 460
 461     // Fill in the background
 462     gg.setColor(Color.white);
 463     gg.fillRect(0, 0, width, height);
 464     gg.setColor(Color.black);
 465
 466     // Fill the selected columns
 467     ColumnSelection cs = av.getColumnSelection();
 468     int avCharWidth = av.getCharWidth(), avCharHeight = av.getCharHeight();
 469
 470     if (cs != null)
 471     {
 472       gg.setColor(new Color(220, 0, 0));
 473
 474       for (int sel : cs.getSelected())
 475       {
 476         // TODO: JAL-2001 - provide a fast method to list visible selected in a
 477         // given range
 478
 479         if (av.hasHiddenColumns())
 480         {
 481           if (cs.isVisible(sel))
 482           {
 483             sel = cs.findColumnPosition(sel);
 484           }
 485           else
 486           {
 487             continue;
 488           }
 489         }
 490
 491         if ((sel >= startx) && (sel <= endx))
 492         {
 493           gg.fillRect((sel - startx) * avCharWidth, 0, avCharWidth,
 494                   getHeight());
 495         }
 496       }
 497     }
 498
 499     int widthx = 1 + endx - startx;
 500
 501     FontMetrics fm = gg.getFontMetrics(av.getFont());
 502     int y = avCharHeight;
 503     int yOf = fm.getDescent();
 504     y -= yOf;
 505     if (av.hasHiddenColumns())
 506     {
 507       // draw any hidden column markers
 508       gg.setColor(Color.blue);
 509       int res;
 510       if (av.getShowHiddenMarkers()
 511               && av.getColumnSelection().getHiddenColumns() != null)
 512       {
 513         for (int i = 0; i < av.getColumnSelection().getHiddenColumns()
 514                 .size(); i++)
 515         {
 516           res = av.getColumnSelection().findHiddenRegionPosition(i)
 517                   - startx;
 518
 519           if (res < 0 || res > widthx)
 520           {
 521             continue;
 522           }
 523
 524           gg.fillPolygon(new int[] {
 525               -1 + res * avCharWidth - avCharHeight / 4,
 526               -1 + res * avCharWidth + avCharHeight / 4,
 527               -1 + res * avCharWidth }, new int[] { y, y, y + 2 * yOf }, 3);
 528         }
 529       }
 530     }
 531     // Draw the scale numbers
 532     gg.setColor(Color.black);
 533
 534     int maxX = 0;
 535     List<ScaleMark> marks = new ScaleRenderer().calculateMarks(av, startx,
 536             endx);
 537
 538     for (ScaleMark mark : marks)
 539     {
 540       boolean major = mark.major;
 541       int mpos = mark.column; // (i - startx - 1)
 542       String mstring = mark.text;
 543       if (mstring != null)
 544       {
 545         if (mpos * avCharWidth > maxX)
 546         {
 547           gg.drawString(mstring, mpos * avCharWidth, y);
 548           maxX = (mpos + 2) * avCharWidth + fm.stringWidth(mstring);
 549         }
 550       }
 551       if (major)
 552       {
 553         gg.drawLine((mpos * avCharWidth) + (avCharWidth / 2), y + 2,
 554                 (mpos * avCharWidth) + (avCharWidth / 2), y + (yOf * 2));
 555       }
 556       else
 557       {
 558         gg.drawLine((mpos * avCharWidth) + (avCharWidth / 2), y + yOf,
 559                 (mpos * avCharWidth) + (avCharWidth / 2), y + (yOf * 2));
 560       }
 561     }
 562   }
 563
 564 }