import jalview.api.AlignmentViewPanel;
import jalview.bin.Cache;
import jalview.datamodel.AlignmentI;
-import jalview.datamodel.SearchResults;
+import jalview.datamodel.SearchResultsI;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
import jalview.structure.StructureSelectionManager;
import jalview.util.MessageManager;
import jalview.util.Platform;
+import jalview.viewmodel.ViewportListenerI;
+import jalview.viewmodel.ViewportRanges;
import java.awt.BorderLayout;
import java.awt.Color;
* @version $Revision: 1.161 $
*/
public class AlignmentPanel extends GAlignmentPanel implements
- AdjustmentListener, Printable, AlignmentViewPanel
+ AdjustmentListener, Printable, AlignmentViewPanel,
+ ViewportListenerI
{
public AlignViewport av;
+ ViewportRanges vpRanges;
+
OverviewPanel overviewPanel;
private SeqPanel seqPanel;
// this value is set false when selection area being dragged
boolean fastPaint = true;
- int hextent = 0;
+ private int hextent = 0;
- int vextent = 0;
+ private int vextent = 0;
/*
* Flag set while scrolling to follow complementary cDNA/protein scroll. When
{
alignFrame = af;
this.av = av;
+ vpRanges = av.getRanges();
setSeqPanel(new SeqPanel(av, this));
setIdPanel(new IdPanel(av, this));
}
};
av.addPropertyChangeListener(propertyChangeListener);
+
+ av.getRanges().addPropertyChangeListener(this);
fontChanged();
adjustAnnotationHeight();
updateLayout();
* Highlight the given results on the alignment.
*
*/
- public void highlightSearchResults(SearchResults results)
+ public void highlightSearchResults(SearchResultsI results)
{
scrollToPosition(results);
getSeqPanel().seqCanvas.highlightSearchResults(results);
*
* @param results
*/
- public boolean scrollToPosition(SearchResults results)
+ public boolean scrollToPosition(SearchResultsI results)
{
return scrollToPosition(results, 0, true, false);
}
* @param redrawOverview
* @return
*/
- public boolean scrollToPosition(SearchResults searchResults,
+ public boolean scrollToPosition(SearchResultsI searchResults,
boolean redrawOverview)
{
return scrollToPosition(searchResults, 0, redrawOverview, false);
* if true, try to centre the search results horizontally in the view
* @return false if results were not found
*/
- public boolean scrollToPosition(SearchResults results,
+ public boolean scrollToPosition(SearchResultsI results,
int verticalOffset, boolean redrawOverview, boolean centre)
{
int startv, endv, starts, ends;
*/
if (centre)
{
- int offset = (av.getEndRes() - av.getStartRes() + 1) / 2 - 1;
+ int offset = (vpRanges.getEndRes() - vpRanges.getStartRes() + 1) / 2 - 1;
start = Math.max(start - offset, 0);
end = end + offset - 1;
}
// + av.getStartSeq() + ", ends=" + av.getEndSeq());
if (!av.getWrapAlignment())
{
- if ((startv = av.getStartRes()) >= start)
+ if ((startv = vpRanges.getStartRes()) >= start)
{
/*
* Scroll left to make start of search results visible
// setScrollValues(start - 1, seqIndex); // plus one residue
setScrollValues(start, seqIndex);
}
- else if ((endv = av.getEndRes()) <= end)
+ else if ((endv = vpRanges.getEndRes()) <= end)
{
/*
* Scroll right to make end of search results visible
// setScrollValues(startv + 1 + end - endv, seqIndex); // plus one
setScrollValues(startv + end - endv, seqIndex);
}
- else if ((starts = av.getStartSeq()) > seqIndex)
+ else if ((starts = vpRanges.getStartSeq()) > seqIndex)
{
/*
* Scroll up to make start of search results visible
*/
- setScrollValues(av.getStartRes(), seqIndex);
+ setScrollValues(vpRanges.getStartRes(), seqIndex);
}
- else if ((ends = av.getEndSeq()) <= seqIndex)
+ else if ((ends = vpRanges.getEndSeq()) <= seqIndex)
{
/*
* Scroll down to make end of search results visible
*/
- setScrollValues(av.getStartRes(), starts + seqIndex - ends + 1);
+ setScrollValues(vpRanges.getStartRes(), starts + seqIndex - ends
+ + 1);
}
/*
* Else results are already visible - no need to scroll
{
int cwidth = getSeqPanel().seqCanvas
.getWrappedCanvasWidth(getSeqPanel().seqCanvas.getWidth());
- if (res < av.getStartRes() || res >= (av.getStartRes() + cwidth))
+ if (res < vpRanges.getStartRes()
+ || res >= (vpRanges.getStartRes() + cwidth))
{
vscroll.setValue((res / cwidth));
- av.startRes = vscroll.getValue() * cwidth;
}
}
fontChanged();
setAnnotationVisible(av.isShowAnnotation());
boolean wrap = av.getWrapAlignment();
- av.startSeq = 0;
+ vpRanges.setStartSeq(0);
scalePanelHolder.setVisible(!wrap);
hscroll.setVisible(!wrap);
idwidthAdjuster.setVisible(!wrap);
*/
public void setScrollValues(int x, int y)
{
- // System.err.println("Scroll " + this.av.viewName + " to " + x + "," + y);
if (av == null || av.getAlignment() == null)
{
return;
}
- int width = av.getAlignment().getWidth();
- int height = av.getAlignment().getHeight();
- if (av.hasHiddenColumns())
+ if (av.getWrapAlignment())
{
- width = av.getColumnSelection().findColumnPosition(width);
+ setScrollingForWrappedPanel(x);
}
+ else
+ {
- av.setEndRes((x + (getSeqPanel().seqCanvas.getWidth() / av
- .getCharWidth())) - 1);
+ int width = av.getAlignment().getWidth();
+ int height = av.getAlignment().getHeight();
- hextent = getSeqPanel().seqCanvas.getWidth() / av.getCharWidth();
- vextent = getSeqPanel().seqCanvas.getHeight() / av.getCharHeight();
+ if (av.hasHiddenColumns())
+ {
+ // reset the width to exclude hidden columns
+ width = av.getColumnSelection().findColumnPosition(width);
+ }
- if (hextent > width)
- {
- hextent = width;
- }
+ hextent = getSeqPanel().seqCanvas.getWidth() / av.getCharWidth();
+ vextent = getSeqPanel().seqCanvas.getHeight() / av.getCharHeight();
- if (vextent > height)
- {
- vextent = height;
- }
+ if (hextent > width)
+ {
+ hextent = width;
+ }
- if ((hextent + x) > width)
- {
- x = width - hextent;
- }
+ if (vextent > height)
+ {
+ vextent = height;
+ }
- if ((vextent + y) > height)
- {
- y = height - vextent;
- }
+ if ((hextent + x) > width)
+ {
+ x = width - hextent;
+ }
- if (y < 0)
- {
- y = 0;
- }
+ if ((vextent + y) > height)
+ {
+ y = height - vextent;
+ }
- if (x < 0)
- {
- x = 0;
- }
+ if (y < 0)
+ {
+ y = 0;
+ }
- /*
- * each scroll adjustment triggers adjustmentValueChanged, which resets the
- * 'do not scroll complement' flag; ensure it is the same for both
- * operations
- */
- boolean flag = isDontScrollComplement();
- hscroll.setValues(x, hextent, 0, width);
- setDontScrollComplement(flag);
- vscroll.setValues(y, vextent, 0, height);
+ if (x < 0)
+ {
+ x = 0;
+ }
+
+ // update the scroll values
+ hscroll.setValues(x, hextent, 0, width);
+ vscroll.setValues(y, vextent, 0, height);
+ }
}
/**
@Override
public void adjustmentValueChanged(AdjustmentEvent evt)
{
- int oldX = av.getStartRes();
- int oldY = av.getStartSeq();
+ int oldX = vpRanges.getStartRes();
+ int oldY = vpRanges.getStartSeq();
- if (evt.getSource() == hscroll)
- {
- int x = hscroll.getValue();
- av.setStartRes(x);
- av.setEndRes((x + (getSeqPanel().seqCanvas.getWidth() / av
- .getCharWidth())) - 1);
- }
-
- if (evt.getSource() == vscroll)
+ if (av.getWrapAlignment())
{
- int offy = vscroll.getValue();
-
- if (av.getWrapAlignment())
+ if (evt.getSource() == hscroll)
+ {
+ return; // no horizontal scroll when wrapped
+ }
+ else if (evt.getSource() == vscroll)
{
- if (offy > -1)
+ int offy = vscroll.getValue();
+ int rowSize = getSeqPanel().seqCanvas
+ .getWrappedCanvasWidth(getSeqPanel().seqCanvas.getWidth());
+
+ // if we're scrolling to the position we're already at, stop
+ // this prevents infinite recursion of events when the scroll/viewport
+ // ranges values are the same
+ if (offy * rowSize == oldX)
+ {
+ return;
+ }
+ else if (offy > -1)
{
- int rowSize = getSeqPanel().seqCanvas
- .getWrappedCanvasWidth(getSeqPanel().seqCanvas.getWidth());
- av.setStartRes(offy * rowSize);
- av.setEndRes((offy + 1) * rowSize);
+ vpRanges.setStartEndRes(offy * rowSize, (offy + 1) * rowSize);
}
else
{
@Override
public void run()
{
- setScrollValues(av.getStartRes(), av.getStartSeq());
+ setScrollValues(vpRanges.getStartRes(),
+ vpRanges.getStartSeq());
}
});
}
}
- else
- {
- av.setStartSeq(offy);
- av.setEndSeq(offy
- + (getSeqPanel().seqCanvas.getHeight() / av.getCharHeight()));
- }
- }
-
- if (overviewPanel != null)
- {
- overviewPanel.setBoxPosition();
- }
-
- int scrollX = av.startRes - oldX;
- int scrollY = av.startSeq - oldY;
-
- if (av.getWrapAlignment() || !fastPaint)
- {
repaint();
}
else
{
- // Make sure we're not trying to draw a panel
- // larger than the visible window
- if (scrollX > av.endRes - av.startRes)
+ // horizontal scroll
+ if (evt.getSource() == hscroll)
{
- scrollX = av.endRes - av.startRes;
- }
- else if (scrollX < av.startRes - av.endRes)
- {
- scrollX = av.startRes - av.endRes;
- }
+ int x = hscroll.getValue();
- if (scrollX != 0 || scrollY != 0)
+ // if we're scrolling to the position we're already at, stop
+ // this prevents infinite recursion of events when the scroll/viewport
+ // ranges values are the same
+ if (x == oldX)
+ {
+ return;
+ }
+ vpRanges.setStartEndRes(x,
+ (x + (getSeqPanel().seqCanvas.getWidth() / av
+ .getCharWidth())) - 1);
+ }
+ else if (evt.getSource() == vscroll)
{
- getIdPanel().getIdCanvas().fastPaint(scrollY);
- getSeqPanel().seqCanvas.fastPaint(scrollX, scrollY);
- getScalePanel().repaint();
+ int offy = vscroll.getValue();
- if (av.isShowAnnotation() && scrollX != 0)
+ // if we're scrolling to the position we're already at, stop
+ // this prevents infinite recursion of events when the scroll/viewport
+ // ranges values are the same
+ if (offy == oldY)
{
- getAnnotationPanel().fastPaint(scrollX);
+ return;
}
+ vpRanges.setStartEndSeq(
+ offy,
+ offy
+ + (getSeqPanel().seqCanvas.getHeight() / av
+ .getCharHeight()) - 1);
+ }
+ if (!fastPaint)
+ {
+ repaint();
}
- }
- /*
- * If there is one, scroll the (Protein/cDNA) complementary alignment to
- * match, unless we are ourselves doing that.
- */
- if (isDontScrollComplement())
- {
- setDontScrollComplement(false);
- }
- else
- {
- av.scrollComplementaryAlignment();
}
}
validate();
/*
- * set scroll bar positions; first suppress this being 'followed' in any
- * complementary split pane
+ * set scroll bar positions
*/
- setDontScrollComplement(true);
+ setScrollValues(vpRanges.getStartRes(), vpRanges.getStartSeq());
+ }
- if (av.getWrapAlignment())
+ /*
+ * Set vertical scroll bar parameters for wrapped panel
+ * @param res
+ * the residue to scroll to
+ */
+ private void setScrollingForWrappedPanel(int res)
+ {
+ // get the width of the alignment in residues
+ int maxwidth = av.getAlignment().getWidth();
+ if (av.hasHiddenColumns())
{
- int maxwidth = av.getAlignment().getWidth();
-
- if (av.hasHiddenColumns())
- {
- maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
- }
-
- int canvasWidth = getSeqPanel().seqCanvas
- .getWrappedCanvasWidth(getSeqPanel().seqCanvas.getWidth());
- if (canvasWidth > 0)
- {
- int max = maxwidth
- / getSeqPanel().seqCanvas
- .getWrappedCanvasWidth(getSeqPanel().seqCanvas
- .getWidth()) + 1;
- vscroll.setMaximum(max);
- vscroll.setUnitIncrement(1);
- vscroll.setVisibleAmount(1);
- }
+ maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
}
- else
+
+ // get the width of the canvas in residues
+ int canvasWidth = getSeqPanel().seqCanvas
+ .getWrappedCanvasWidth(getSeqPanel().seqCanvas.getWidth());
+ if (canvasWidth > 0)
{
- setScrollValues(av.getStartRes(), av.getStartSeq());
+ // position we want to scroll to is number of canvasWidth's to get there
+ int current = res / canvasWidth;
+
+ // max scroll position: add one because extent is 1 and scrollbar value
+ // can only be set to at most max - extent
+ int max = maxwidth / canvasWidth + 1;
+ vscroll.setUnitIncrement(1);
+ vscroll.setValues(current, 1, 0, max);
}
}
}
else
{
- return printUnwrapped(pwidth, pheight, pi, pg);
+ return printUnwrapped(pwidth, pheight, pi, pg, pg);
}
}
* @throws PrinterException
* DOCUMENT ME!
*/
- public int printUnwrapped(int pwidth, int pheight, int pi,
- Graphics... pg)
+ /**
+ * Draws the alignment image, including sequence ids, sequences, and
+ * annotation labels and annotations if shown, on either one or two Graphics
+ * context.
+ *
+ * @param pageWidth
+ * @param pageHeight
+ * @param pi
+ * @param idGraphics
+ * the graphics context for sequence ids and annotation labels
+ * @param alignmentGraphics
+ * the graphics context for sequences and annotations (may or may not
+ * be the same context as idGraphics)
+ * @return
+ * @throws PrinterException
+ */
+ public int printUnwrapped(int pageWidth, int pageHeight, int pi,
+ Graphics idGraphics, Graphics alignmentGraphics)
throws PrinterException
{
- boolean isMultiGraphics = pg.length > 1;
- int G0 = 0; // Graphic index of idPanel graphics in multi-graphics mode or
- // entire graphics for non mulit-graphics mode
- int G1 = 0; // Graphic index of alignmentPanel graphics for multi-graphics
- // mode
- if (isMultiGraphics)
- {
- G0 = 0;
- G1 = 1;
- }
-
- int idWidth = getVisibleIdWidth(false);
- FontMetrics fm = getFontMetrics(av.getFont());
- int scaleHeight = av.getCharHeight() + fm.getDescent();
+ final int idWidth = getVisibleIdWidth(false);
- pg[G0].setColor(Color.white);
- pg[G0].fillRect(0, 0, pwidth, pheight);
- pg[G0].setFont(av.getFont());
-
- // //////////////////////////////////
- // / How many sequences and residues can we fit on a printable page?
- int totalRes = (pwidth - idWidth) / av.getCharWidth();
+ /*
+ * Get the horizontal offset to where we draw the sequences.
+ * This is idWidth if using a single Graphics context, else zero.
+ */
+ final int alignmentGraphicsOffset = idGraphics != alignmentGraphics ? 0 : idWidth;
- int totalSeq = (pheight - scaleHeight) / av.getCharHeight() - 1;
+ FontMetrics fm = getFontMetrics(av.getFont());
+ int charHeight = av.getCharHeight();
+ int scaleHeight = charHeight + fm.getDescent();
- int pagesWide = (av.getAlignment().getWidth() / totalRes) + 1;
+ idGraphics.setColor(Color.white);
+ idGraphics.fillRect(0, 0, pageWidth, pageHeight);
+ idGraphics.setFont(av.getFont());
- // ///////////////////////////
- // / Only print these sequences and residues on this page
- int startRes;
+ /*
+ * How many sequences and residues can we fit on a printable page?
+ */
+ int totalRes = (pageWidth - idWidth) / av.getCharWidth();
- // ///////////////////////////
- // / Only print these sequences and residues on this page
- int endRes;
+ int totalSeq = (pageHeight - scaleHeight) / charHeight - 1;
- // ///////////////////////////
- // / Only print these sequences and residues on this page
- int startSeq;
+ int alignmentWidth = av.getAlignment().getWidth();
+ int pagesWide = (alignmentWidth / totalRes) + 1;
- // ///////////////////////////
- // / Only print these sequences and residues on this page
- int endSeq;
- startRes = (pi % pagesWide) * totalRes;
- endRes = (startRes + totalRes) - 1;
+ final int startRes = (pi % pagesWide) * totalRes;
+ int endRes = (startRes + totalRes) - 1;
- if (endRes > (av.getAlignment().getWidth() - 1))
+ if (endRes > (alignmentWidth - 1))
{
- endRes = av.getAlignment().getWidth() - 1;
+ endRes = alignmentWidth - 1;
}
- startSeq = (pi / pagesWide) * totalSeq;
- endSeq = startSeq + totalSeq;
+ final int startSeq = (pi / pagesWide) * totalSeq;
+ int endSeq = startSeq + totalSeq;
- if (endSeq > av.getAlignment().getHeight())
+ int alignmentHeight = av.getAlignment().getHeight();
+ if (endSeq > alignmentHeight)
{
- endSeq = av.getAlignment().getHeight();
+ endSeq = alignmentHeight;
}
- int pagesHigh = ((av.getAlignment().getHeight() / totalSeq) + 1)
- * pheight;
+ int pagesHigh = ((alignmentHeight / totalSeq) + 1)
+ * pageHeight;
if (av.isShowAnnotation())
{
pagesHigh += getAnnotationPanel().adjustPanelHeight() + 3;
}
- pagesHigh /= pheight;
+ pagesHigh /= pageHeight;
if (pi >= (pagesWide * pagesHigh))
{
return Printable.NO_SUCH_PAGE;
}
+ final int alignmentDrawnHeight = (endSeq - startSeq) * charHeight
+ + 3;
- // draw Scale
- if (isMultiGraphics)
- {
- pg[G1].translate(0, 0);
- getScalePanel().drawScale(pg[G1], startRes, endRes,
- pwidth - idWidth, scaleHeight);
- pg[G1].translate(-idWidth, scaleHeight);
- }
- else
- {
- pg[G0].translate(idWidth, 0);
- getScalePanel().drawScale(pg[G0], startRes, endRes, pwidth - idWidth,
- scaleHeight);
- pg[G0].translate(-idWidth, scaleHeight);
- }
+ /*
+ * draw the Scale at horizontal offset, then reset to top left (0, 0)
+ */
+ alignmentGraphics.translate(alignmentGraphicsOffset, 0);
+ getScalePanel().drawScale(alignmentGraphics, startRes, endRes,
+ pageWidth - idWidth, scaleHeight);
+ alignmentGraphics.translate(-alignmentGraphicsOffset, 0);
- // //////////////
- // Draw the ids
+ /*
+ * Draw the sequence ids, offset for scale height,
+ * then reset to top left (0, 0)
+ */
+ idGraphics.translate(0, scaleHeight);
+ idGraphics.setFont(getIdPanel().getIdCanvas().getIdfont());
Color currentColor = null;
Color currentTextColor = null;
- if (isMultiGraphics)
- {
- pg[G0].translate(0, scaleHeight);
- }
- pg[G0].setFont(getIdPanel().getIdCanvas().getIdfont());
-
SequenceI seq;
for (int i = startSeq; i < endSeq; i++)
{
if ((av.getSelectionGroup() != null)
&& av.getSelectionGroup().getSequences(null).contains(seq))
{
+ /*
+ * gray out ids of sequences in selection group (if any)
+ */
currentColor = Color.gray;
currentTextColor = Color.black;
}
currentTextColor = Color.black;
}
- pg[G0].setColor(currentColor);
- pg[G0].fillRect(0, (i - startSeq) * av.getCharHeight(), idWidth,
- av.getCharHeight());
+ idGraphics.setColor(currentColor);
+ idGraphics.fillRect(0, (i - startSeq) * charHeight, idWidth,
+ charHeight);
- pg[G0].setColor(currentTextColor);
+ idGraphics.setColor(currentTextColor);
int xPos = 0;
+ String displayId = seq.getDisplayId(av.getShowJVSuffix());
if (av.isRightAlignIds())
{
- fm = pg[G0].getFontMetrics();
+ fm = idGraphics.getFontMetrics();
xPos = idWidth
- - fm.stringWidth(seq.getDisplayId(av.getShowJVSuffix()))
+ - fm.stringWidth(displayId)
- 4;
}
- pg[G0].drawString(seq.getDisplayId(av.getShowJVSuffix()), xPos,
- (((i - startSeq) * av.getCharHeight()) + av.getCharHeight())
- - (av.getCharHeight() / 5));
+ idGraphics.drawString(displayId, xPos,
+ (((i - startSeq) * charHeight) + charHeight)
+ - (charHeight / 5));
}
+ idGraphics.setFont(av.getFont());
+ idGraphics.translate(0, -scaleHeight);
- pg[G0].setFont(av.getFont());
-
+ /*
+ * draw the sequences, offset for scale height, and id width (if using a
+ * single graphics context), then reset to (0, scale height)
+ */
+ alignmentGraphics.translate(alignmentGraphicsOffset, scaleHeight);
+ getSeqPanel().seqCanvas.drawPanel(alignmentGraphics, startRes, endRes,
+ startSeq, endSeq, 0);
+ alignmentGraphics.translate(-alignmentGraphicsOffset, 0);
- // draw main sequence panel
- pg[G0].translate(idWidth, 0);
- if (isMultiGraphics)
- {
- pg[G1].translate(idWidth, 0);
- getSeqPanel().seqCanvas.drawPanel(pg[G1], startRes, endRes,
- startSeq, endSeq, 0);
- }
- else
+ if (av.isShowAnnotation() && (endSeq == alignmentHeight))
{
- getSeqPanel().seqCanvas.drawPanel(pg[G0], startRes, endRes, startSeq,
- endSeq, 0);
- }
+ /*
+ * draw annotation labels; drawComponent() translates by
+ * getScrollOffset(), so compensate for that first;
+ * then reset to (0, scale height)
+ */
+ int offset = getAlabels().getScrollOffset();
+ idGraphics.translate(0, -offset);
+ idGraphics.translate(0, alignmentDrawnHeight);
+ getAlabels().drawComponent(idGraphics, idWidth);
+ idGraphics.translate(0, -alignmentDrawnHeight);
- if (av.isShowAnnotation() && (endSeq == av.getAlignment().getHeight()))
- {
- // draw annotation label - need to offset for current scroll position
- int offset = -getAlabels().getScrollOffset();
- pg[G0].translate(0, offset);
- pg[G0].translate(-idWidth - 3,
- (endSeq - startSeq) * av.getCharHeight() + 3);
- getAlabels().drawComponent(pg[G0], idWidth);
- pg[G0].translate(idWidth + 3, 0);
- pg[G0].translate(0, -offset);
- if (isMultiGraphics)
- {
- // draw annotation - need to offset for current scroll position
- pg[G1].translate(0, offset);
- pg[G1].translate(-idWidth - 3,
- (endSeq - startSeq) * av.getCharHeight() + 3);
- pg[G1].translate(idWidth + 3, 0);
- getAnnotationPanel().renderer.drawComponent(getAnnotationPanel(),
- av, pg[G1], -1, startRes, endRes + 1);
- pg[G1].translate(0, -offset);
- }
- else
- {
- getAnnotationPanel().renderer.drawComponent(getAnnotationPanel(),
- av, pg[G0], -1, startRes, endRes + 1);
- pg[G0].translate(0, -offset);
- }
+ /*
+ * draw the annotations starting at
+ * (idOffset, alignmentHeight) from (0, scaleHeight)
+ */
+ alignmentGraphics.translate(alignmentGraphicsOffset, alignmentDrawnHeight);
+ getAnnotationPanel().renderer.drawComponent(getAnnotationPanel(), av,
+ alignmentGraphics, -1, startRes, endRes + 1);
}
return Printable.PAGE_EXISTS;
aDimension.getWidth(), aDimension.getHeight()
+ boarderBottomOffset, file, imageTitle,
alignFrame, pSessionId, headless);
+ Graphics graphics = im.getGraphics();
if (av.getWrapAlignment())
{
- if (im.getGraphics() != null)
+ if (graphics != null)
{
printWrappedAlignment(aDimension.getWidth(),
aDimension.getHeight() + boarderBottomOffset, 0,
- im.getGraphics());
+ graphics);
im.writeImage();
}
}
else
{
- if (im.getGraphics() != null)
+ if (graphics != null)
{
printUnwrapped(aDimension.getWidth(), aDimension.getHeight(),
- 0, im.getGraphics());
+ 0, graphics, graphics);
im.writeImage();
}
}
* @param verticalOffset
* the number of visible sequences to show above the mapped region
*/
- public void scrollToCentre(SearchResults sr, int verticalOffset)
+ public void scrollToCentre(SearchResultsI sr, int verticalOffset)
{
/*
* To avoid jumpy vertical scrolling (if some sequences are gapped or not
* mapped), we can make the scroll-to location a sequence above the one
* actually mapped.
*/
- SequenceI mappedTo = sr.getResultSequence(0);
+ SequenceI mappedTo = sr.getResults().get(0).getSequence();
List<SequenceI> seqs = av.getAlignment().getSequences();
/*
{
return this.dontScrollComplement;
}
+
+ /**
+ * Redraw sensibly.
+ *
+ * @adjustHeight if true, try to recalculate panel height for visible
+ * annotations
+ */
+ protected void refresh(boolean adjustHeight)
+ {
+ validateAnnotationDimensions(adjustHeight);
+ addNotify();
+ if (adjustHeight)
+ {
+ // sort, repaint, update overview
+ paintAlignment(true);
+ }
+ else
+ {
+ // lightweight repaint
+ repaint();
+ }
+ }
+
+ @Override
+ /**
+ * Property change event fired when a change is made to the viewport ranges
+ * object associated with this alignment panel's viewport
+ */
+ public void propertyChange(PropertyChangeEvent evt)
+ {
+ // update this panel's scroll values based on the new viewport ranges values
+ int x = vpRanges.getStartRes();
+ int y = vpRanges.getStartSeq();
+ setScrollValues(x, y);
+
+ // now update any complementary alignment (its viewport ranges object
+ // is different so does not get automatically updated)
+ av.scrollComplementaryAlignment();
+ }
}
git://source.jalview.org / jalview.git / blobdiff