src/jalview/appletgui/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.appletgui;
  22
  23 import jalview.datamodel.ColumnSelection;
  24 import jalview.datamodel.HiddenColumns;
  25 import jalview.datamodel.SequenceGroup;
  26 import jalview.renderer.ScaleRenderer;
  27 import jalview.renderer.ScaleRenderer.ScaleMark;
  28 import jalview.util.MessageManager;
  29 import jalview.viewmodel.ViewportListenerI;
  30 import jalview.viewmodel.ViewportRanges;
  31
  32 import java.awt.Color;
  33 import java.awt.FontMetrics;
  34 import java.awt.Graphics;
  35 import java.awt.MenuItem;
  36 import java.awt.Panel;
  37 import java.awt.PopupMenu;
  38 import java.awt.event.ActionEvent;
  39 import java.awt.event.ActionListener;
  40 import java.awt.event.InputEvent;
  41 import java.awt.event.MouseEvent;
  42 import java.awt.event.MouseListener;
  43 import java.awt.event.MouseMotionListener;
  44 import java.beans.PropertyChangeEvent;
  45 import java.util.Iterator;
  46 import java.util.List;
  47
  48 public class ScalePanel extends Panel
  49         implements MouseMotionListener, MouseListener, ViewportListenerI
  50 {
  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   int min; // used by mouseDragged to see if user
  63
  64   int max; // used by mouseDragged to see if user
  65
  66   boolean mouseDragging = false;
  67
  68   int[] reveal;
  69
  70   public ScalePanel(AlignViewport av, AlignmentPanel ap)
  71   {
  72     setLayout(null);
  73     this.av = av;
  74     this.ap = ap;
  75
  76     addMouseListener(this);
  77     addMouseMotionListener(this);
  78
  79     av.getRanges().addPropertyChangeListener(this);
  80   }
  81
  82   @Override
  83   public void mousePressed(MouseEvent evt)
  84   {
  85     int x = (evt.getX() / av.getCharWidth()) + av.getRanges().getStartRes();
  86     final int res;
  87
  88     if (av.hasHiddenColumns())
  89     {
  90       res = av.getAlignment().getHiddenColumns().visibleToAbsoluteColumn(x);
  91     }
  92     else
  93     {
  94       res = x;
  95     }
  96
  97     min = res;
  98     max = res;
  99     if ((evt.getModifiers()
 100             & InputEvent.BUTTON3_MASK) == InputEvent.BUTTON3_MASK)
 101     {
 102       rightMouseButtonPressed(evt, res);
 103     }
 104     else
 105     {
 106       leftMouseButtonPressed(evt, res);
 107     }
 108   }
 109
 110   /**
 111    * Handles left mouse button pressed (selection / clear selections)
 112    *
 113    * @param evt
 114    * @param res
 115    */
 116   protected void leftMouseButtonPressed(MouseEvent evt, final int res)
 117   {
 118     if (!evt.isControlDown() && !evt.isShiftDown())
 119     {
 120       av.getColumnSelection().clear();
 121     }
 122
 123     av.getColumnSelection().addElement(res);
 124     SequenceGroup sg = new SequenceGroup();
 125     for (int i = 0; i < av.getAlignment().getSequences().size(); i++)
 126     {
 127       sg.addSequence(av.getAlignment().getSequenceAt(i), false);
 128     }
 129
 130     sg.setStartRes(res);
 131     sg.setEndRes(res);
 132     av.setSelectionGroup(sg);
 133
 134     if (evt.isShiftDown())
 135     {
 136       int min = Math.min(av.getColumnSelection().getMin(), res);
 137       int max = Math.max(av.getColumnSelection().getMax(), res);
 138       for (int i = min; i < max; i++)
 139       {
 140         av.getColumnSelection().addElement(i);
 141       }
 142       sg.setStartRes(min);
 143       sg.setEndRes(max);
 144     }
 145     ap.paintAlignment(false, false);
 146     av.sendSelection();
 147   }
 148
 149   /**
 150    * Handles right mouse button press. If pressed in a selected column, opens
 151    * context menu for 'Hide Columns'. If pressed on a hidden columns marker,
 152    * opens context menu for 'Reveal / Reveal All'. Else does nothing.
 153    *
 154    * @param evt
 155    * @param res
 156    */
 157   protected void rightMouseButtonPressed(MouseEvent evt, final int res)
 158   {
 159     PopupMenu pop = new PopupMenu();
 160     if (reveal != null)
 161     {
 162       MenuItem item = new MenuItem(
 163               MessageManager.getString("label.reveal"));
 164       item.addActionListener(new ActionListener()
 165       {
 166         @Override
 167         public void actionPerformed(ActionEvent e)
 168         {
 169           av.showColumn(reveal[0]);
 170           reveal = null;
 171           ap.paintAlignment(true, true);
 172           av.sendSelection();
 173         }
 174       });
 175       pop.add(item);
 176
 177       if (av.getAlignment().getHiddenColumns().hasMultiHiddenColumnRegions())
 178       {
 179         item = new MenuItem(MessageManager.getString("action.reveal_all"));
 180         item.addActionListener(new ActionListener()
 181         {
 182           @Override
 183           public void actionPerformed(ActionEvent e)
 184           {
 185             av.showAllHiddenColumns();
 186             reveal = null;
 187             ap.paintAlignment(true, true);
 188             av.sendSelection();
 189           }
 190         });
 191         pop.add(item);
 192       }
 193       this.add(pop);
 194       pop.show(this, evt.getX(), evt.getY());
 195     }
 196     else if (av.getColumnSelection().contains(res))
 197     {
 198       MenuItem item = new MenuItem(
 199               MessageManager.getString("label.hide_columns"));
 200       item.addActionListener(new ActionListener()
 201       {
 202         @Override
 203         public void actionPerformed(ActionEvent e)
 204         {
 205           av.hideColumns(res, res);
 206           if (av.getSelectionGroup() != null && av.getSelectionGroup()
 207                   .getSize() == av.getAlignment().getHeight())
 208           {
 209             av.setSelectionGroup(null);
 210           }
 211
 212           ap.paintAlignment(true, true);
 213           av.sendSelection();
 214         }
 215       });
 216       pop.add(item);
 217       this.add(pop);
 218       pop.show(this, evt.getX(), evt.getY());
 219     }
 220   }
 221
 222   @Override
 223   public void mouseReleased(MouseEvent evt)
 224   {
 225     mouseDragging = false;
 226
 227     int res = (evt.getX() / av.getCharWidth())
 228             + av.getRanges().getStartRes();
 229
 230     if (res > av.getAlignment().getWidth())
 231     {
 232       res = av.getAlignment().getWidth() - 1;
 233     }
 234
 235     if (av.hasHiddenColumns())
 236     {
 237       res = av.getAlignment().getHiddenColumns()
 238               .visibleToAbsoluteColumn(res);
 239     }
 240
 241     if (!stretchingGroup)
 242     {
 243       ap.paintAlignment(false, false);
 244
 245       return;
 246     }
 247
 248     SequenceGroup sg = av.getSelectionGroup();
 249
 250     if (res > sg.getStartRes())
 251     {
 252       sg.setEndRes(res);
 253     }
 254     else if (res < sg.getStartRes())
 255     {
 256       sg.setStartRes(res);
 257     }
 258
 259     stretchingGroup = false;
 260     ap.paintAlignment(false, false);
 261     av.sendSelection();
 262   }
 263
 264   /**
 265    * Action on dragging the mouse in the scale panel is to expand or shrink the
 266    * selection group range (including any hidden columns that it spans)
 267    *
 268    * @param evt
 269    */
 270   @Override
 271   public void mouseDragged(MouseEvent evt)
 272   {
 273     mouseDragging = true;
 274     ColumnSelection cs = av.getColumnSelection();
 275
 276     int res = (evt.getX() / av.getCharWidth())
 277             + av.getRanges().getStartRes();
 278     res = Math.max(0, res);
 279     res = av.getAlignment().getHiddenColumns().visibleToAbsoluteColumn(res);
 280     res = Math.min(res, av.getAlignment().getWidth() - 1);
 281     min = Math.min(res, min);
 282     max = Math.max(res, max);
 283
 284     SequenceGroup sg = av.getSelectionGroup();
 285     if (sg != null)
 286     {
 287       stretchingGroup = true;
 288       cs.stretchGroup(res, sg, min, max);
 289       ap.paintAlignment(false, false);
 290     }
 291   }
 292
 293   @Override
 294   public void mouseEntered(MouseEvent evt)
 295   {
 296     if (mouseDragging)
 297     {
 298       ap.seqPanel.scrollCanvas(null);
 299     }
 300   }
 301
 302   @Override
 303   public void mouseExited(MouseEvent evt)
 304   {
 305     if (mouseDragging)
 306     {
 307       ap.seqPanel.scrollCanvas(evt);
 308     }
 309   }
 310
 311   @Override
 312   public void mouseClicked(MouseEvent evt)
 313   {
 314
 315   }
 316
 317   @Override
 318   public void mouseMoved(MouseEvent evt)
 319   {
 320     if (!av.hasHiddenColumns())
 321     {
 322       return;
 323     }
 324
 325     int res = (evt.getX() / av.getCharWidth())
 326             + av.getRanges().getStartRes();
 327
 328     reveal = av.getAlignment().getHiddenColumns()
 329             .getRegionWithEdgeAtRes(res);
 330
 331     repaint();
 332   }
 333
 334   @Override
 335   public void update(Graphics g)
 336   {
 337     paint(g);
 338   }
 339
 340   @Override
 341   public void paint(Graphics g)
 342   {
 343     /*
 344      * shouldn't get called in wrapped mode as the scale above is
 345      * drawn instead by SeqCanvas.drawNorthScale
 346      */
 347     if (!av.getWrapAlignment())
 348     {
 349       drawScale(g, av.getRanges().getStartRes(), av.getRanges().getEndRes(),
 350               getSize().width, getSize().height);
 351     }
 352   }
 353
 354   // scalewidth will normally be screenwidth,
 355   public void drawScale(Graphics gg, int startx, int endx, int width,
 356           int height)
 357   {
 358     gg.setFont(av.getFont());
 359     // Fill in the background
 360     gg.setColor(Color.white);
 361     gg.fillRect(0, 0, width, height);
 362     gg.setColor(Color.black);
 363
 364     // Fill the selected columns
 365     ColumnSelection cs = av.getColumnSelection();
 366     HiddenColumns hidden = av.getAlignment().getHiddenColumns();
 367     int avCharWidth = av.getCharWidth();
 368     int avcharHeight = av.getCharHeight();
 369     if (cs != null)
 370     {
 371       gg.setColor(new Color(220, 0, 0));
 372       boolean hasHiddenColumns = hidden.hasHiddenColumns();
 373       for (int sel : cs.getSelected())
 374       {
 375         // TODO: JAL-2001 - provide a fast method to list visible selected in a
 376         // given range
 377         if (hasHiddenColumns)
 378         {
 379           if (hidden.isVisible(sel))
 380           {
 381             sel = hidden.absoluteToVisibleColumn(sel);
 382           }
 383           else
 384           {
 385             continue;
 386           }
 387         }
 388
 389         if ((sel >= startx) && (sel <= endx))
 390         {
 391           gg.fillRect((sel - startx) * avCharWidth, 0, avCharWidth,
 392                   getSize().height);
 393         }
 394       }
 395     }
 396
 397     // Draw the scale numbers
 398     gg.setColor(Color.black);
 399
 400     int maxX = 0;
 401     List<ScaleMark> marks = new ScaleRenderer().calculateMarks(av, startx,
 402             endx);
 403
 404     FontMetrics fm = gg.getFontMetrics(av.getFont());
 405     int y = avcharHeight;
 406     int yOf = fm.getDescent();
 407     y -= yOf;
 408     for (ScaleMark mark : marks)
 409     {
 410       boolean major = mark.major;
 411       int mpos = mark.column; // (i - startx - 1)
 412       String mstring = mark.text;
 413       if (mstring != null)
 414       {
 415         if (mpos * avCharWidth > maxX)
 416         {
 417           gg.drawString(mstring, mpos * avCharWidth, y);
 418           maxX = (mpos + 2) * avCharWidth + fm.stringWidth(mstring);
 419         }
 420       }
 421       if (major)
 422       {
 423         gg.drawLine((mpos * avCharWidth) + (avCharWidth / 2), y + 2,
 424                 (mpos * avCharWidth) + (avCharWidth / 2), y + (yOf * 2));
 425       }
 426       else
 427       {
 428         gg.drawLine((mpos * avCharWidth) + (avCharWidth / 2), y + yOf,
 429                 (mpos * avCharWidth) + (avCharWidth / 2), y + (yOf * 2));
 430       }
 431     }
 432
 433     if (av.hasHiddenColumns())
 434     {
 435       gg.setColor(Color.blue);
 436       int res;
 437       if (av.getShowHiddenMarkers())
 438       {
 439         int widthx = 1 + endx - startx;
 440         Iterator<Integer> it = hidden.getStartRegionIterator(startx,
 441                 startx + widthx + 1);
 442         while (it.hasNext())
 443         {
 444           res = it.next() - startx;
 445
 446           gg.fillPolygon(
 447                   new int[]
 448                   { -1 + res * avCharWidth - avcharHeight / 4, -1 + res * avCharWidth + avcharHeight / 4,
 449               -1 + res * avCharWidth }, new int[]
 450           { y, y, y + 2 * yOf }, 3);
 451         }
 452       }
 453     }
 454   }
 455
 456   @Override
 457   public void propertyChange(PropertyChangeEvent evt)
 458   {
 459     // Respond to viewport change events (e.g. alignment panel was scrolled)
 460     // Both scrolling and resizing change viewport ranges: scrolling changes
 461     // both start and end points, but resize only changes end values.
 462     // Here we only want to fastpaint on a scroll, with resize using a normal
 463     // paint, so scroll events are identified as changes to the horizontal or
 464     // vertical start value.
 465     if (evt.getPropertyName().equals(ViewportRanges.STARTRES)
 466             || evt.getPropertyName().equals(ViewportRanges.STARTRESANDSEQ)
 467             || evt.getPropertyName().equals(ViewportRanges.MOVE_VIEWPORT))
 468     {
 469       // scroll event, repaint panel
 470       repaint();
 471     }
 472   }
 473
 474 }