private final SequenceRenderer seqRdr;
- private boolean fastPaint = false;
+ boolean fastPaint = false;
private boolean fastpainting = false;
*/
public void fastPaint(int horizontal, int vertical)
{
- // System.err.println("<<SeqCanvas fastPaint " + fastpainting + " "
- // + horizontal + " " + vertical);
+
// effectively:
// if (horizontal != 0 && vertical != 0)
// throw new InvalidArgumentException();
gg.copyArea(horizontal * charWidth, vertical * charHeight,
img.getWidth(), img.getHeight(), -horizontal * charWidth,
-vertical * charHeight);
-
- /** @j2sNative xxi = this.img */
-
gg.translate(transX, transY);
drawPanel(gg, startRes, endRes, startSeq, endSeq, 0);
gg.translate(-transX, -transY);
@Override
public void paintComponent(Graphics g)
{
+
+ if (av.getAlignPanel().getHoldRepaint())
+ {
+ return;
+ }
int charHeight = av.getCharHeight();
int charWidth = av.getCharWidth();
- int width = getWidth();
- int height = getHeight();
+ int availWidth = getWidth();
+ int availHeight = getHeight();
+
+ availWidth -= (availWidth % charWidth);
+ availHeight -= (availHeight % charHeight);
- width -= (width % charWidth);
- height -= (height % charHeight);
+ // BH 2019 can't possibly fastPaint if either width or height is 0
- // BH 2019 can't possibly fastPaint if width and height are 0
- if (width == 0 || height == 0)
+ if (availWidth == 0 || availHeight == 0)
{
return;
}
int endRes = ranges.getEndRes();
int endSeq = ranges.getEndSeq();
- // System.err.println(">>SeqCanvas paintComponent " + fastPaint + "\n"
- // + getVisibleRect() + "\n" + g.getClipBounds());
- // System.err.println(">>>>>>>>>>>>>>>>SeqCanvas paintComponent "
- // + startRes + " " + endRes + " " + startSeq + " " + endSeq);
+ // [JAL-3226] problem that JavaScript (or Java) may consolidate multiple
+ // repaint() requests in unpredictable ways. In this case, the issue was
+ // that in response to a CTRL-C/CTRL-V paste request, in Java a fast
+ // repaint request preceded two full requests, thus resulting
+ // in a full request for paint. In constrast, in JavaScript, the three
+ // requests were bundled together into one, so the fastPaint flag was
+ // still present for the second and third request.
+ //
+ // This resulted in incomplete painting.
+ //
+ // The solution was to set seqCanvas.fastPaint and idCanvas.fastPaint false
+ // in PaintRefresher when the target to be painted is one of those two
+ // components.
+ //
+ // BH 2019.04.22
+ //
+ // An initial idea; can be removed once we determine this issue is closed:
+ // if (av.isFastPaintDisabled())
+ // {
+ // fastPaint = false;
+ // }
+
Rectangle vis, clip;
if (img != null
&& (fastPaint
|| vis.height != clip.height))
{
g.drawImage(img, 0, 0, this);
- // System.err.println(">>>>>>>>>>>>>>>>SeqCanvas paintComponent FAST");
drawSelectionGroup((Graphics2D) g, startRes, endRes, startSeq,
endSeq);
fastPaint = false;
- //System.out.println("SeqCanvas fast paint");
}
else
{
-
- System.out.println("SeqCanvas full paint");
- /*
- * img is a cached version of the last view we drew.
- * If we have no img or the size has changed, make a new one
- */
- if (img == null || width != img.getWidth()
- || height != img.getHeight())
+ // img is a cached version of the last view we drew.
+ // If we have no img or the size has changed, make a new one.
+ //
+ if (img == null || availWidth != img.getWidth()
+ || availHeight != img.getHeight())
{
- img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+ img = new BufferedImage(availWidth, availHeight,
+ BufferedImage.TYPE_INT_RGB);
}
-
+
Graphics2D gg = (Graphics2D) img.getGraphics();
gg.setFont(av.getFont());
}
gg.setColor(Color.white);
- gg.fillRect(0, 0, img.getWidth(), img.getHeight());
+ gg.fillRect(0, 0, availWidth, availHeight);
if (av.getWrapAlignment())
{
- drawWrappedPanel(gg, width, height, ranges.getStartRes());
+ drawWrappedPanel(gg, availWidth, availHeight, ranges.getStartRes());
}
else
{
}
/**
- * Returns the visible width of the canvas in residues, after allowing for
- * East or West scales (if shown)
+ * Using the current font, determine fields labelWidthEast and labelWidthWest,
+ * and return the number of residues that can fill the remaining width.
*
- * @param canvasWidth
+ * @param width
* the width in pixels (possibly including scales)
*
- * @return
+ * @return the visible width in residues, after allowing for East or West
+ * scales (if shown)
+ *
*/
- public int getWrappedCanvasWidth(int canvasWidth)
+ public int getWrappedCanvasWidth(int width)
{
int charWidth = av.getCharWidth();
FontMetrics fm = getFontMetrics(av.getFont());
- int labelWidth = 0;
-
- if (av.getScaleRightWrapped() || av.getScaleLeftWrapped())
- {
- labelWidth = getLabelWidth(fm);
- }
+ int labelWidth = (av.getScaleRightWrapped() || av.getScaleLeftWrapped()
+ ? getLabelWidth(fm)
+ : 0);
labelWidthEast = av.getScaleRightWrapped() ? labelWidth : 0;
labelWidthWest = av.getScaleLeftWrapped() ? labelWidth : 0;
- return (canvasWidth - labelWidthEast - labelWidthWest) / charWidth;
+ return (width - labelWidthEast - labelWidthWest) / charWidth;
}
/**
maxWidth = Math.max(maxWidth, alignment.getSequenceAt(i).getEnd());
}
+ // quick int log10
int length = 0;
for (int i = maxWidth; i > 0; i /= 10)
{
* window
*
* @param g
- * @param canvasWidth
+ * @param availWidth
* available width in pixels
- * @param canvasHeight
+ * @param availHeight
* available height in pixels
* @param startColumn
* the first column (0...) of the alignment to draw
*/
- public void drawWrappedPanel(Graphics g, int canvasWidth,
- int canvasHeight, final int startColumn)
+ public void drawWrappedPanel(Graphics g, int availWidth, int availHeight,
+ final int startColumn)
{
- int wrappedWidthInResidues = calculateWrappedGeometry(canvasWidth,
- canvasHeight);
+ int wrappedWidthInResidues = calculateWrappedGeometry(availWidth,
+ availHeight);
av.setWrappedWidth(wrappedWidthInResidues);
// we need to call this again to make sure the startColumn +
// wrappedWidthInResidues values are used to calculate wrappedVisibleWidths
// correctly.
- calculateWrappedGeometry(canvasWidth, canvasHeight);
+ calculateWrappedGeometry(availWidth, availHeight);
/*
* draw one width at a time (excluding any scales shown),
{
int endColumn = Math
.min(maxWidth, start + wrappedWidthInResidues - 1);
- drawWrappedWidth(g, ypos, start, endColumn, canvasHeight);
+ drawWrappedWidth(g, ypos, start, endColumn, availHeight);
ypos += wrappedRepeatHeightPx;
start += wrappedWidthInResidues;
currentWidth++;
* <li>whether scales are shown left, right or above the alignment</li>
* </ul>
*
- * @param canvasWidth
- * @param canvasHeight
+ * @param availWidth
+ * @param availHeight
* @return the number of residue columns in each width
*/
- protected int calculateWrappedGeometry(int canvasWidth, int canvasHeight)
+ protected int calculateWrappedGeometry(int availWidth, int availHeight)
{
int charHeight = av.getCharHeight();
* ensuring a part height includes at least one sequence
*/
ViewportRanges ranges = av.getRanges();
- wrappedVisibleWidths = canvasHeight / wrappedRepeatHeightPx;
- int remainder = canvasHeight % wrappedRepeatHeightPx;
+ wrappedVisibleWidths = availHeight / wrappedRepeatHeightPx;
+ int remainder = availHeight % wrappedRepeatHeightPx;
if (remainder >= (wrappedSpaceAboveAlignment + charHeight))
{
wrappedVisibleWidths++;
/*
* compute width in residues; this also sets East and West label widths
*/
- int wrappedWidthInResidues = getWrappedCanvasWidth(canvasWidth);
+ int wrappedWidthInResidues = getWrappedCanvasWidth(availWidth);
/*
* limit visibleWidths to not exceed width of alignment
public void propertyChange(PropertyChangeEvent evt)
{
String eventName = evt.getPropertyName();
- // System.err.println(">>SeqCanvas propertyChange " + eventName);
- if (eventName.equals(SequenceGroup.SEQ_GROUP_CHANGED))
+
+ // BH 2019.07.27 removes dead code introduced in aad3650 and simplifies
+ // logic, emphasizing no check for ENDRES or ENDSEQ
+
+ // Both scrolling and resizing change viewport ranges: scrolling changes
+ // both start and end points, but resize only changes end values.
+ // Here we only want to fastpaint on a scroll, with resize using a normal
+ // paint, so scroll events are identified as changes to the horizontal or
+ // vertical start value.
+
+ // Make sure we're not trying to draw a panel
+ // larger than the visible window
+ int scrollX = 0;
+ int scrollY = 0;
+ switch (eventName)
{
+ case SequenceGroup.SEQ_GROUP_CHANGED:
fastPaint = true;
repaint();
return;
- }
- else if (eventName.equals(ViewportRanges.MOVE_VIEWPORT))
- {
+ case ViewportRanges.MOVE_VIEWPORT:
fastPaint = false;
- // System.err.println("!!!! fastPaint false from MOVE_VIEWPORT");
repaint();
return;
- }
-
- int scrollX = 0;
- if (eventName.equals(ViewportRanges.STARTRES)
- || eventName.equals(ViewportRanges.STARTRESANDSEQ))
- {
- // Make sure we're not trying to draw a panel
- // larger than the visible window
- if (eventName.equals(ViewportRanges.STARTRES))
- {
- scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
- }
- else
+ case ViewportRanges.STARTSEQ:
+ // meaning STARTOREND
+ // typically scroll, but possibly just the end changed
+ fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
+ return;
+ case ViewportRanges.ENDRES:
+ case ViewportRanges.ENDSEQ:
+ // meaning second event along with "START" -- ENDONLY,NOTSTART
+ // TODO: ignore??
+ return;
+ case ViewportRanges.STARTRES:
+ // meaning STARTOREND
+ scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
+ break;
+ case ViewportRanges.STARTRESANDSEQ:
+ scrollX = ((int[]) evt.getNewValue())[0]
+ - ((int[]) evt.getOldValue())[0];
+ scrollY = ((int[]) evt.getNewValue())[1]
+ - ((int[]) evt.getOldValue())[1];
+
+ // System.out.println("SC dx dy " + scrollX + " " + scrollY);
+
+ if (scrollX != 0 && scrollY != 0)
{
- scrollX = ((int[]) evt.getNewValue())[0]
- - ((int[]) evt.getOldValue())[0];
- }
- ViewportRanges vpRanges = av.getRanges();
+ // all sorts of problems in JavaScript if this is commented out.
+ repaint();
+ return;
- int range = vpRanges.getEndRes() - vpRanges.getStartRes() + 1;
- if (scrollX > range)
- {
- scrollX = range;
- }
- else if (scrollX < -range)
- {
- scrollX = -range;
}
+ break;
}
+
+ ViewportRanges vpRanges = av.getRanges();
+ int range = vpRanges.getEndRes() - vpRanges.getStartRes() + 1;
+ scrollX = Math.max(Math.min(scrollX, range), -range);
+ // only STARTRES or STARTRESANDSEQ:
+ if (av.getWrapAlignment())
+ {
+ fastPaintWrapped(scrollX);
+ }
+ else
+ {
+ fastPaint(scrollX, scrollY);
+ }
+
+ // BH 2019.07.27 was:
+ // if (eventName.equals(SequenceGroup.SEQ_GROUP_CHANGED))
+ // {
+ // fastPaint = true;
+ // repaint();
+ // return;
+ // }
+ // else if (eventName.equals(ViewportRanges.MOVE_VIEWPORT))
+ // {
+ // fastPaint = false;
+ // // System.err.println("!!!! fastPaint false from MOVE_VIEWPORT");
+ // repaint();
+ // return;
+ // }
+ //
+ // if (eventName.equals(ViewportRanges.STARTRES)
+ // || eventName.equals(ViewportRanges.STARTRESANDSEQ))
+ // {
+ // // Make sure we're not trying to draw a panel
+ // // larger than the visible window
+ // if (eventName.equals(ViewportRanges.STARTRES))
+ // {
+ // scrollX = (int) evt.getNewValue() - (int) evt.getOldValue();
+ // }
+ // else
+ // {
+ // scrollX = ((int[]) evt.getNewValue())[0]
+ // - ((int[]) evt.getOldValue())[0];
+ // }
+ // ViewportRanges vpRanges = av.getRanges();
+ //
+ // int range = vpRanges.getEndRes() - vpRanges.getStartRes() + 1;
+ // if (scrollX > range)
+ // {
+ // scrollX = range;
+ // }
+ // else if (scrollX < -range)
+ // {
+ // scrollX = -range;
+ // }
+ // }
// Both scrolling and resizing change viewport ranges: scrolling changes
// both start and end points, but resize only changes end values.
// Here we only want to fastpaint on a scroll, with resize using a normal
// paint, so scroll events are identified as changes to the horizontal or
// vertical start value.
- if (eventName.equals(ViewportRanges.STARTRES))
- {
- if (av.getWrapAlignment())
- {
- fastPaintWrapped(scrollX);
- }
- else
- {
- fastPaint(scrollX, 0);
- }
- }
- else if (eventName.equals(ViewportRanges.STARTSEQ))
- {
- // scroll
- fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
- }
- else if (eventName.equals(ViewportRanges.STARTRESANDSEQ))
- {
- if (av.getWrapAlignment())
- {
- fastPaintWrapped(scrollX);
- }
- else
- {
- fastPaint(scrollX, 0);
- }
- }
- else if (eventName.equals(ViewportRanges.STARTSEQ))
- {
- // scroll
- fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
- }
- else if (eventName.equals(ViewportRanges.STARTRESANDSEQ))
- {
- if (av.getWrapAlignment())
- {
- fastPaintWrapped(scrollX);
- }
- }
+ // BH 2019.07.27 was:
+ // if (eventName.equals(ViewportRanges.STARTRES))
+ // {
+ // if (av.getWrapAlignment())
+ // {
+ // fastPaintWrapped(scrollX);
+ // }
+ // else
+ // {
+ // fastPaint(scrollX, 0);
+ // }
+ // }
+ // else if (eventName.equals(ViewportRanges.STARTSEQ))
+ // {
+ // // scroll
+ // fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
+ // }
+ // else if (eventName.equals(ViewportRanges.STARTRESANDSEQ))
+ // {
+ // if (av.getWrapAlignment())
+ // {
+ // fastPaintWrapped(scrollX);
+ // }
+ // else
+ // {
+ // fastPaint(scrollX, 0);
+ // }
+ // }
+ //
+ // BH oops!
+ //
+ // else if (eventName.equals(ViewportRanges.STARTSEQ))
+ // {
+ // // scroll
+ // fastPaint(0, (int) evt.getNewValue() - (int) evt.getOldValue());
+ // }
+ // else if (eventName.equals(ViewportRanges.STARTRESANDSEQ))
+ // {
+ // if (av.getWrapAlignment())
+ // {
+ // fastPaintWrapped(scrollX);
+ // }
+ // }
}
/**
return labelWidthWest;
}
- /**
- * Ensure that a full paint is done next, for whatever reason. This was
- * necessary for JavaScript; apparently in Java the timing is just right on
- * multiple threads (EventQueue-0, Consensus, Conservation) that we can get
- * away with one fast paint before the others, but this ensures that in the
- * end we get a full paint. Problem arose in relation to copy/paste, where the
- * paste was not finalized with a full paint.
- *
- * @author hansonr 2019.04.17
- */
- public void clearFastPaint()
- {
- fastPaint = false;
- }
}
git://source.jalview.org / jalview.git / blobdiff