src/jalview/gui/OverviewCanvas.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.api.AlignViewportI;
  24 import jalview.bin.Cache;
  25 import jalview.renderer.OverviewRenderer;
  26 import jalview.renderer.OverviewResColourFinder;
  27 import jalview.viewmodel.OverviewDimensions;
  28
  29 import java.awt.Color;
  30 import java.awt.Dimension;
  31 import java.awt.Graphics;
  32 import java.awt.image.BufferedImage;
  33
  34 import javax.swing.JComponent;
  35
  36 public class OverviewCanvas extends JComponent
  37 {
  38   private static final Color TRANS_GREY = new Color(100, 100, 100, 25);
  39
  40   // This is set true if the alignment view changes whilst
  41   // the overview is being calculated
  42   private volatile boolean restart = false;
  43
  44   private volatile boolean updaterunning = false;
  45
  46   private boolean dispose = false;
  47
  48   private BufferedImage miniMe;
  49
  50   private BufferedImage lastMiniMe = null;
  51
  52   // Can set different properties in this seqCanvas than
  53   // main visible SeqCanvas
  54   private SequenceRenderer sr;
  55
  56   private jalview.renderer.seqfeatures.FeatureRenderer fr;
  57
  58   private OverviewDimensions od;
  59
  60   private OverviewRenderer or = null;
  61
  62   private AlignViewportI av;
  63
  64   private OverviewResColourFinder cf;
  65
  66   private ProgressPanel progressPanel;
  67
  68   public OverviewCanvas(OverviewDimensions overviewDims,
  69           AlignViewportI alignvp, ProgressPanel pp)
  70   {
  71     od = overviewDims;
  72     av = alignvp;
  73     progressPanel = pp;
  74
  75     sr = new SequenceRenderer(av);
  76     sr.renderGaps = false;
  77     fr = new jalview.renderer.seqfeatures.FeatureRenderer(av);
  78
  79     boolean useLegacy = Cache.getDefault(Preferences.USE_LEGACY_GAP, false);
  80     Color gapCol = Cache.getDefaultColour(Preferences.GAP_COLOUR,
  81             jalview.renderer.OverviewResColourFinder.OVERVIEW_DEFAULT_GAP);
  82     Color hiddenCol = Cache.getDefaultColour(Preferences.HIDDEN_COLOUR,
  83             jalview.renderer.OverviewResColourFinder.OVERVIEW_DEFAULT_HIDDEN);
  84     cf = new OverviewResColourFinder(useLegacy, gapCol, hiddenCol);
  85
  86     setSize(od.getWidth(), od.getHeight());
  87   }
  88
  89   /**
  90    * Update the overview dimensions object used by the canvas (e.g. if we change
  91    * from showing hidden columns to hiding them or vice versa)
  92    *
  93    * @param overviewDims
  94    */
  95   public void resetOviewDims(OverviewDimensions overviewDims)
  96   {
  97     od = overviewDims;
  98   }
  99
 100   /**
 101    * Signals to drawing code that the associated alignment viewport has changed
 102    * and a redraw will be required
 103    */
 104   public boolean restartDraw()
 105   {
 106     synchronized (this)
 107     {
 108       if (updaterunning)
 109       {
 110         restart = true;
 111         if (or != null)
 112         {
 113           or.setRedraw(true);
 114         }
 115       }
 116       else
 117       {
 118         updaterunning = true;
 119       }
 120       return restart;
 121     }
 122   }
 123
 124   /**
 125    * Draw the overview sequences
 126    *
 127    * @param showSequenceFeatures
 128    *          true if sequence features are to be shown
 129    * @param showAnnotation
 130    *          true if the annotation is to be shown
 131    * @param transferRenderer
 132    *          the renderer to transfer feature colouring from
 133    */
 134   public void draw(boolean showSequenceFeatures, boolean showAnnotation,
 135           FeatureRenderer transferRenderer)
 136   {
 137     miniMe = null;
 138
 139     if (showSequenceFeatures)
 140     {
 141       fr.transferSettings(transferRenderer);
 142     }
 143
 144     setPreferredSize(new Dimension(od.getWidth(), od.getHeight()));
 145
 146     or = new OverviewRenderer(fr, od, av.getAlignment(),
 147             av.getResidueShading(), cf);
 148
 149     or.addPropertyChangeListener(progressPanel);
 150
 151     miniMe = or.draw(od.getRows(av.getAlignment()),
 152             od.getColumns(av.getAlignment()));
 153
 154     Graphics mg = miniMe.getGraphics();
 155
 156     if (showAnnotation)
 157     {
 158       mg.translate(0, od.getSequencesHeight());
 159       or.drawGraph(mg, av.getAlignmentConservationAnnotation(),
 160               av.getCharWidth(), od.getGraphHeight(),
 161               od.getColumns(av.getAlignment()));
 162       mg.translate(0, -od.getSequencesHeight());
 163     }
 164     System.gc();
 165
 166     or.removePropertyChangeListener(progressPanel);
 167     or = null;
 168     if (restart)
 169     {
 170       restart = false;
 171       if (!dispose)
 172       {
 173         draw(showSequenceFeatures, showAnnotation, transferRenderer);
 174       }
 175     }
 176     else
 177     {
 178       updaterunning = false;
 179       lastMiniMe = miniMe;
 180     }
 181   }
 182
 183   @Override
 184   public void paintComponent(Graphics g)
 185   {
 186     // super.paintComponent(g);
 187
 188     if (restart)
 189     {
 190       if (lastMiniMe == null)
 191       {
 192         g.setColor(Color.white);
 193         g.fillRect(0, 0, getWidth(), getHeight());
 194       }
 195       else
 196       {
 197         g.drawImage(lastMiniMe, 0, 0, getWidth(), getHeight(), this);
 198       }
 199       g.setColor(TRANS_GREY);
 200       g.fillRect(0, 0, getWidth(), getHeight());
 201     }
 202     else if (lastMiniMe != null)
 203     {
 204       // is this a resize?
 205       if ((getWidth() > 0) && (getHeight() > 0)
 206               && ((getWidth() != od.getWidth())
 207                       || (getHeight() != od.getHeight())))
 208       {
 209         // if there is annotation, scale the alignment and annotation
 210         // separately
 211         if (od.getGraphHeight() > 0)
 212         {
 213           BufferedImage topImage = lastMiniMe.getSubimage(0, 0,
 214                   od.getWidth(), od.getSequencesHeight());
 215           BufferedImage bottomImage = lastMiniMe.getSubimage(0,
 216                   od.getSequencesHeight(), od.getWidth(),
 217                   od.getGraphHeight());
 218
 219           // must be done at this point as we rely on using old width/height
 220           // above, and new width/height below
 221           od.setWidth(getWidth());
 222           od.setHeight(getHeight());
 223
 224           // stick the images back together so lastMiniMe is consistent in the
 225           // event of a repaint - BUT probably not thread safe
 226           lastMiniMe = new BufferedImage(od.getWidth(), od.getHeight(),
 227                   BufferedImage.TYPE_INT_RGB);
 228           Graphics lg = lastMiniMe.getGraphics();
 229           lg.drawImage(topImage, 0, 0, od.getWidth(),
 230                   od.getSequencesHeight(), null);
 231           lg.drawImage(bottomImage, 0, od.getSequencesHeight(),
 232                   od.getWidth(), od.getGraphHeight(), this);
 233           lg.dispose();
 234         }
 235         else
 236         {
 237           od.setWidth(getWidth());
 238           od.setHeight(getHeight());
 239         }
 240
 241         // make sure the box is in the right place
 242         od.setBoxPosition(av.getAlignment().getHiddenSequences(),
 243                 av.getAlignment().getHiddenColumns());
 244       }
 245       // fall back to normal behaviour
 246       g.drawImage(lastMiniMe, 0, 0, getWidth(), getHeight(), this);
 247     }
 248     else
 249     {
 250       g.drawImage(lastMiniMe, 0, 0, getWidth(), getHeight(), this);
 251     }
 252
 253     // draw the box
 254     g.setColor(Color.red);
 255     od.drawBox(g);
 256   }
 257
 258
 259   public void dispose()
 260   {
 261     dispose = true;
 262     synchronized (this)
 263     {
 264       restart = true;
 265       if (or != null)
 266       {
 267         or.setRedraw(true);
 268       }
 269     }
 270   }
 271 }