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