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