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