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