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