/** Enlarge the canvas if the user enlarges the window. */
void resizeCanvas(int width, int height) {
ImageWindow win = imp.getWindow();
// IJ.log("resizeCanvas: "+srcRect+" "+imageWidth+" "+imageHeight+" "+width+" "+height+"
// "+dstWidth+" "+dstHeight+" "+win.maxBounds);
if (!maxBoundsReset
&& (width > dstWidth || height > dstHeight)
&& win != null
&& win.maxBounds != null
&& width != win.maxBounds.width - 10) {
if (resetMaxBoundsCount != 0)
resetMaxBounds(); // Works around problem that prevented window from being larger than
// maximized size
resetMaxBoundsCount++;
}
if (IJ.altKeyDown()) {
fitToWindow();
return;
}
if (srcRect.width < imageWidth || srcRect.height < imageHeight) {
if (width > imageWidth * magnification) width = (int) (imageWidth * magnification);
if (height > imageHeight * magnification) height = (int) (imageHeight * magnification);
setDrawingSize(width, height);
srcRect.width = (int) (dstWidth / magnification);
srcRect.height = (int) (dstHeight / magnification);
if ((srcRect.x + srcRect.width) > imageWidth) srcRect.x = imageWidth - srcRect.width;
if ((srcRect.y + srcRect.height) > imageHeight) srcRect.y = imageHeight - srcRect.height;
repaint();
}
// IJ.log("resizeCanvas2: "+srcRect+" "+dstWidth+" "+dstHeight+" "+width+" "+height);
}
/**
* Zooms out by making the source rectangle (srcRect) larger and centering it on (x,y). If we
* can't make it larger, then make the window smaller.
*/
public void zoomOut(int x, int y) {
if (magnification <= 0.03125) return;
double oldMag = magnification;
double newMag = getLowerZoomLevel(magnification);
double srcRatio = (double) srcRect.width / srcRect.height;
double imageRatio = (double) imageWidth / imageHeight;
double initialMag = imp.getWindow().getInitialMagnification();
if (Math.abs(srcRatio - imageRatio) > 0.05) {
double scale = oldMag / newMag;
int newSrcWidth = (int) Math.round(srcRect.width * scale);
int newSrcHeight = (int) Math.round(srcRect.height * scale);
if (newSrcWidth > imageWidth) newSrcWidth = imageWidth;
if (newSrcHeight > imageHeight) newSrcHeight = imageHeight;
int newSrcX = srcRect.x - (newSrcWidth - srcRect.width) / 2;
int newSrcY = srcRect.y - (newSrcHeight - srcRect.height) / 2;
if (newSrcX < 0) newSrcX = 0;
if (newSrcY < 0) newSrcY = 0;
srcRect = new Rectangle(newSrcX, newSrcY, newSrcWidth, newSrcHeight);
// IJ.log(newMag+" "+srcRect+" "+dstWidth+" "+dstHeight);
int newDstWidth = (int) (srcRect.width * newMag);
int newDstHeight = (int) (srcRect.height * newMag);
setMagnification(newMag);
setMaxBounds();
// IJ.log(newDstWidth+" "+dstWidth+" "+newDstHeight+" "+dstHeight);
if (newDstWidth < dstWidth || newDstHeight < dstHeight) {
// IJ.log("pack");
setDrawingSize(newDstWidth, newDstHeight);
imp.getWindow().pack();
} else repaint();
return;
}
if (imageWidth * newMag > dstWidth) {
int w = (int) Math.round(dstWidth / newMag);
if (w * newMag < dstWidth) w++;
int h = (int) Math.round(dstHeight / newMag);
if (h * newMag < dstHeight) h++;
x = offScreenX(x);
y = offScreenY(y);
Rectangle r = new Rectangle(x - w / 2, y - h / 2, w, h);
if (r.x < 0) r.x = 0;
if (r.y < 0) r.y = 0;
if (r.x + w > imageWidth) r.x = imageWidth - w;
if (r.y + h > imageHeight) r.y = imageHeight - h;
srcRect = r;
} else {
srcRect = new Rectangle(0, 0, imageWidth, imageHeight);
setDrawingSize((int) (imageWidth * newMag), (int) (imageHeight * newMag));
// setDrawingSize(dstWidth/2, dstHeight/2);
imp.getWindow().pack();
}
// IJ.write(newMag + " " + srcRect.x+" "+srcRect.y+" "+srcRect.width+" "+srcRect.height+"
// "+dstWidth + " " + dstHeight);
setMagnification(newMag);
// IJ.write(srcRect.x + " " + srcRect.width + " " + dstWidth);
setMaxBounds();
repaint();
}
/**
* With segmented selections, ignore first mouse up and finalize when user double-clicks,
* control-clicks or clicks in start box.
*/
protected void handleMouseUp(int sx, int sy) {
if (state == MOVING) {
state = NORMAL;
return;
}
if (state == MOVING_HANDLE) {
cachedMask = null; // mask is no longer valid
state = NORMAL;
updateClipRect();
oldX = x;
oldY = y;
oldWidth = width;
oldHeight = height;
return;
}
if (state != CONSTRUCTING) return;
if (IJ.spaceBarDown()) // is user scrolling image?
return;
boolean samePoint = false;
if (xpf != null)
samePoint = (xpf[nPoints - 2] == xpf[nPoints - 1] && ypf[nPoints - 2] == ypf[nPoints - 1]);
else samePoint = (xp[nPoints - 2] == xp[nPoints - 1] && yp[nPoints - 2] == yp[nPoints - 1]);
Rectangle biggerStartBox =
new Rectangle(ic.screenXD(startXD) - 5, ic.screenYD(startYD) - 5, 10, 10);
if (nPoints > 2
&& (biggerStartBox.contains(sx, sy)
|| (ic.offScreenXD(sx) == startXD && ic.offScreenYD(sy) == startYD)
|| (samePoint && (System.currentTimeMillis() - mouseUpTime) <= 500))) {
nPoints--;
addOffset();
finishPolygon();
return;
} else if (!samePoint) {
mouseUpTime = System.currentTimeMillis();
if (type == ANGLE && nPoints == 3) {
addOffset();
finishPolygon();
return;
}
// add point to polygon
if (xpf != null) {
xpf[nPoints] = xpf[nPoints - 1];
ypf[nPoints] = ypf[nPoints - 1];
nPoints++;
if (nPoints == xpf.length) enlargeArrays();
} else {
xp[nPoints] = xp[nPoints - 1];
yp[nPoints] = yp[nPoints - 1];
nPoints++;
if (nPoints == xp.length) enlargeArrays();
}
// if (lineWidth>1) fitSpline();
}
}
protected void scroll(int sx, int sy) {
int ox = xSrcStart + (int) (sx / magnification); // convert to offscreen coordinates
int oy = ySrcStart + (int) (sy / magnification);
// IJ.log("scroll: "+ox+" "+oy+" "+xMouseStart+" "+yMouseStart);
int newx = xSrcStart + (xMouseStart - ox);
int newy = ySrcStart + (yMouseStart - oy);
if (newx < 0) newx = 0;
if (newy < 0) newy = 0;
if ((newx + srcRect.width) > imageWidth) newx = imageWidth - srcRect.width;
if ((newy + srcRect.height) > imageHeight) newy = imageHeight - srcRect.height;
srcRect.x = newx;
srcRect.y = newy;
// IJ.log(sx+" "+sy+" "+newx+" "+newy+" "+srcRect);
imp.draw();
Thread.yield();
}
void adjustSourceRect(double newMag, int x, int y) {
// IJ.log("adjustSourceRect1: "+newMag+" "+dstWidth+" "+dstHeight);
int w = (int) Math.round(dstWidth / newMag);
if (w * newMag < dstWidth) w++;
int h = (int) Math.round(dstHeight / newMag);
if (h * newMag < dstHeight) h++;
x = offScreenX(x);
y = offScreenY(y);
Rectangle r = new Rectangle(x - w / 2, y - h / 2, w, h);
if (r.x < 0) r.x = 0;
if (r.y < 0) r.y = 0;
if (r.x + w > imageWidth) r.x = imageWidth - w;
if (r.y + h > imageHeight) r.y = imageHeight - h;
srcRect = r;
setMagnification(newMag);
// IJ.log("adjustSourceRect2: "+srcRect+" "+dstWidth+" "+dstHeight);
}
void enlargeCanvas() {
imp.unlock();
if (imp.getStackSize() == 1) Undo.setup(Undo.COMPOUND_FILTER, imp);
IJ.run("Select All");
IJ.run("Rotate...", "angle=" + angle);
Roi roi = imp.getRoi();
Rectangle r = roi.getBounds();
if (r.width < imp.getWidth()) r.width = imp.getWidth();
if (r.height < imp.getHeight()) r.height = imp.getHeight();
IJ.showStatus("Rotate: Enlarging...");
IJ.run(
"Canvas Size...",
"width="
+ r.width
+ " height="
+ r.height
+ " position=Center "
+ (fillWithBackground ? "" : "zero"));
IJ.showStatus("Rotating...");
}
protected Dimension canEnlarge(int newWidth, int newHeight) {
// if ((flags&Event.CTRL_MASK)!=0 || IJ.controlKeyDown()) return null;
ImageWindow win = imp.getWindow();
if (win == null) return null;
Rectangle r1 = win.getBounds();
Insets insets = win.getInsets();
Point loc = getLocation();
if (loc.x > insets.left + 5 || loc.y > insets.top + 5) {
r1.width = newWidth + insets.left + insets.right + 10;
r1.height = newHeight + insets.top + insets.bottom + 10;
if (win instanceof StackWindow) r1.height += 20;
} else {
r1.width = r1.width - dstWidth + newWidth + 10;
r1.height = r1.height - dstHeight + newHeight + 10;
}
Rectangle max = win.getMaxWindow(r1.x, r1.y);
boolean fitsHorizontally = r1.x + r1.width < max.x + max.width;
boolean fitsVertically = r1.y + r1.height < max.y + max.height;
if (fitsHorizontally && fitsVertically) return new Dimension(newWidth, newHeight);
else if (fitsVertically && newHeight < dstWidth) return new Dimension(dstWidth, newHeight);
else if (fitsHorizontally && newWidth < dstHeight) return new Dimension(newWidth, dstHeight);
else return null;
}
public void mousePressed(MouseEvent e) {
// super.mousePressed(e);
ImageProcessor ip = imp.getProcessor();
ip.setLineWidth(1);
if (Toolbar.getToolId() == Toolbar.DROPPER) IJ.setTool(Toolbar.RECTANGLE);
Rectangle flipperRect = new Rectangle(86, 268, 18, 18);
Rectangle resetRect = new Rectangle(86, 294, 18, 18);
Rectangle foreground1Rect = new Rectangle(9, 266, 45, 10);
Rectangle foreground2Rect = new Rectangle(9, 276, 23, 25);
Rectangle background1Rect = new Rectangle(33, 302, 45, 10);
Rectangle background2Rect = new Rectangle(56, 277, 23, 25);
int x = offScreenX(e.getX());
int y = offScreenY(e.getY());
long difference = System.currentTimeMillis() - mouseDownTime;
boolean doubleClick = (difference <= 250);
mouseDownTime = System.currentTimeMillis();
if (flipperRect.contains(x, y)) {
Color c = Toolbar.getBackgroundColor();
Toolbar.setBackgroundColor(Toolbar.getForegroundColor());
Toolbar.setForegroundColor(c);
} else if (resetRect.contains(x, y)) {
Toolbar.setForegroundColor(new Color(0x000000));
Toolbar.setBackgroundColor(new Color(0xffffff));
} else if ((background1Rect.contains(x, y)) || (background2Rect.contains(x, y))) {
background = true;
if (doubleClick) editColor();
((ColorGenerator) ip).refreshForeground();
((ColorGenerator) ip).refreshBackground();
} else if ((foreground1Rect.contains(x, y)) || (foreground2Rect.contains(x, y))) {
background = false;
if (doubleClick) editColor();
((ColorGenerator) ip).refreshBackground();
((ColorGenerator) ip).refreshForeground();
} else {
// IJ.log(" " + difference + " " + doubleClick);
if (doubleClick) editColor();
else {
setDrawingColor(offScreenX(e.getX()), offScreenY(e.getY()), background);
}
}
if (ip instanceof ColorGenerator) {
if (background) {
((ColorGenerator) ip).refreshForeground();
((ColorGenerator) ip).refreshBackground();
} else {
((ColorGenerator) ip).refreshBackground();
((ColorGenerator) ip).refreshForeground();
}
}
}