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()) // Mac: mousePressed
 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       if (evt.isPopupTrigger()) // Windows: mouseReleased
 285       {
 286         rightMouseButtonPressed(evt, res);
 287       }
 288       else
 289       {
 290         ap.paintAlignment(false);
 291       }
 292       return;
 293     }
 294
 295     SequenceGroup sg = av.getSelectionGroup();
 296
 297     if (sg != null)
 298     {
 299       if (res > sg.getStartRes())
 300       {
 301         sg.setEndRes(res);
 302       }
 303       else if (res < sg.getStartRes())
 304       {
 305         sg.setStartRes(res);
 306       }
 307     }
 308     stretchingGroup = false;
 309     ap.paintAlignment(false);
 310     av.sendSelection();
 311   }
 312
 313   /**
 314    * DOCUMENT ME!
 315    *
 316    * @param evt
 317    *          DOCUMENT ME!
 318    */
 319   @Override
 320   public void mouseDragged(MouseEvent evt)
 321   {
 322     mouseDragging = true;
 323
 324     int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
 325     if (res < 0)
 326     {
 327       res = 0;
 328     }
 329
 330     if (av.hasHiddenColumns())
 331     {
 332       res = av.getColumnSelection().adjustForHiddenColumns(res);
 333     }
 334
 335     if (res >= av.getAlignment().getWidth())
 336     {
 337       res = av.getAlignment().getWidth() - 1;
 338     }
 339
 340     if (res < min)
 341     {
 342       min = res;
 343     }
 344
 345     if (res > max)
 346     {
 347       max = res;
 348     }
 349
 350     SequenceGroup sg = av.getSelectionGroup();
 351
 352     if (sg != null)
 353     {
 354       stretchingGroup = true;
 355
 356       if (!av.getColumnSelection().contains(res))
 357       {
 358         av.getColumnSelection().addElement(res);
 359       }
 360
 361       if (res > sg.getStartRes())
 362       {
 363         sg.setEndRes(res);
 364       }
 365       if (res < sg.getStartRes())
 366       {
 367         sg.setStartRes(res);
 368       }
 369
 370       int col;
 371       for (int i = min; i <= max; i++)
 372       {
 373         col = i; // av.getColumnSelection().adjustForHiddenColumns(i);
 374
 375         if ((col < sg.getStartRes()) || (col > sg.getEndRes()))
 376         {
 377           av.getColumnSelection().removeElement(col);
 378         }
 379         else
 380         {
 381           av.getColumnSelection().addElement(col);
 382         }
 383       }
 384
 385       ap.paintAlignment(false);
 386     }
 387   }
 388
 389   @Override
 390   public void mouseEntered(MouseEvent evt)
 391   {
 392     if (mouseDragging)
 393     {
 394       ap.getSeqPanel().scrollCanvas(null);
 395     }
 396   }
 397
 398   @Override
 399   public void mouseExited(MouseEvent evt)
 400   {
 401     if (mouseDragging)
 402     {
 403       ap.getSeqPanel().scrollCanvas(evt);
 404     }
 405   }
 406
 407   @Override
 408   public void mouseClicked(MouseEvent evt)
 409   {
 410   }
 411
 412   @Override
 413   public void mouseMoved(MouseEvent evt)
 414   {
 415     this.setToolTipText(null);
 416     reveal = null;
 417     if (!av.hasHiddenColumns())
 418     {
 419       return;
 420     }
 421
 422     int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
 423
 424     res = av.getColumnSelection().adjustForHiddenColumns(res);
 425
 426     if (av.getColumnSelection().getHiddenColumns() != null)
 427     {
 428       for (int[] region : av.getColumnSelection().getHiddenColumns())
 429       {
 430         if (res + 1 == region[0] || res - 1 == region[1])
 431         {
 432           reveal = region;
 433           ToolTipManager.sharedInstance().registerComponent(this);
 434           this.setToolTipText(MessageManager
 435                   .getString("label.reveal_hidden_columns"));
 436           break;
 437         }
 438       }
 439     }
 440     repaint();
 441   }
 442
 443   /**
 444    * DOCUMENT ME!
 445    *
 446    * @param g
 447    *          DOCUMENT ME!
 448    */
 449   @Override
 450   public void paintComponent(Graphics g)
 451   {
 452     drawScale(g, av.getStartRes(), av.getEndRes(), getWidth(), getHeight());
 453   }
 454
 455   // scalewidth will normally be screenwidth,
 456   public void drawScale(Graphics g, int startx, int endx, int width,
 457           int height)
 458   {
 459     Graphics2D gg = (Graphics2D) g;
 460     gg.setFont(av.getFont());
 461
 462     if (av.antiAlias)
 463     {
 464       gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
 465               RenderingHints.VALUE_ANTIALIAS_ON);
 466     }
 467
 468     // Fill in the background
 469     gg.setColor(Color.white);
 470     gg.fillRect(0, 0, width, height);
 471     gg.setColor(Color.black);
 472
 473     // Fill the selected columns
 474     ColumnSelection cs = av.getColumnSelection();
 475     int avCharWidth = av.getCharWidth(), avCharHeight = av.getCharHeight();
 476
 477     if (cs != null)
 478     {
 479       gg.setColor(new Color(220, 0, 0));
 480
 481       for (int sel : cs.getSelected())
 482       {
 483         // TODO: JAL-2001 - provide a fast method to list visible selected in a
 484         // given range
 485
 486         if (av.hasHiddenColumns())
 487         {
 488           if (cs.isVisible(sel))
 489           {
 490             sel = cs.findColumnPosition(sel);
 491           }
 492           else
 493           {
 494             continue;
 495           }
 496         }
 497
 498         if ((sel >= startx) && (sel <= endx))
 499         {
 500           gg.fillRect((sel - startx) * avCharWidth, 0, avCharWidth,
 501                   getHeight());
 502         }
 503       }
 504     }
 505
 506     int widthx = 1 + endx - startx;
 507
 508     FontMetrics fm = gg.getFontMetrics(av.getFont());
 509     int y = avCharHeight;
 510     int yOf = fm.getDescent();
 511     y -= yOf;
 512     if (av.hasHiddenColumns())
 513     {
 514       // draw any hidden column markers
 515       gg.setColor(Color.blue);
 516       int res;
 517       if (av.getShowHiddenMarkers()
 518               && av.getColumnSelection().getHiddenColumns() != null)
 519       {
 520         for (int i = 0; i < av.getColumnSelection().getHiddenColumns()
 521                 .size(); i++)
 522         {
 523           res = av.getColumnSelection().findHiddenRegionPosition(i)
 524                   - startx;
 525
 526           if (res < 0 || res > widthx)
 527           {
 528             continue;
 529           }
 530
 531           gg.fillPolygon(new int[] {
 532               -1 + res * avCharWidth - avCharHeight / 4,
 533               -1 + res * avCharWidth + avCharHeight / 4,
 534               -1 + res * avCharWidth }, new int[] { y, y, y + 2 * yOf }, 3);
 535         }
 536       }
 537     }
 538     // Draw the scale numbers
 539     gg.setColor(Color.black);
 540
 541     int maxX = 0;
 542     List<ScaleMark> marks = new ScaleRenderer().calculateMarks(av, startx,
 543             endx);
 544
 545     for (ScaleMark mark : marks)
 546     {
 547       boolean major = mark.major;
 548       int mpos = mark.column; // (i - startx - 1)
 549       String mstring = mark.text;
 550       if (mstring != null)
 551       {
 552         if (mpos * avCharWidth > maxX)
 553         {
 554           gg.drawString(mstring, mpos * avCharWidth, y);
 555           maxX = (mpos + 2) * avCharWidth + fm.stringWidth(mstring);
 556         }
 557       }
 558       if (major)
 559       {
 560         gg.drawLine((mpos * avCharWidth) + (avCharWidth / 2), y + 2,
 561                 (mpos * avCharWidth) + (avCharWidth / 2), y + (yOf * 2));
 562       }
 563       else
 564       {
 565         gg.drawLine((mpos * avCharWidth) + (avCharWidth / 2), y + yOf,
 566                 (mpos * avCharWidth) + (avCharWidth / 2), y + (yOf * 2));
 567       }
 568     }
 569   }
 570
 571 }