/**
* This paints the entire plot. It calls the draw methods of all the attached axis and data sets.
* The order of drawing is - Axis first, data legends next, data last.
*
* @params g Graphics state.
*/
public void paint(Graphics g) {
int i;
Graphics lg = g.create();
Rectangle r = bounds();
/* The r.x and r.y returned from bounds is relative to the
** parents space so set them equal to zero.
*/
r.x = 0;
r.y = 0;
if (DefaultBackground == null) DefaultBackground = this.getBackground();
if (DataBackground == null) DataBackground = this.getBackground();
// System.out.println("Graph2D paint method called!");
if (!paintAll) return;
r.x += borderLeft;
r.y += borderTop;
r.width -= borderLeft + borderRight;
r.height -= borderBottom + borderTop;
paintFirst(lg, r);
if (!axis.isEmpty()) r = drawAxis(lg, r);
else {
if (clearAll) {
Color c = g.getColor();
g.setColor(DataBackground);
g.fillRect(r.x, r.y, r.width, r.height);
g.setColor(c);
}
drawFrame(lg, r.x, r.y, r.width, r.height);
}
paintBeforeData(lg, r);
if (!dataset.isEmpty()) {
datarect.x = r.x;
datarect.y = r.y;
datarect.width = r.width;
datarect.height = r.height;
for (i = 0; i < dataset.size(); i++) {
((DataSet) dataset.elementAt(i)).draw_data(lg, r);
}
}
paintLast(lg, r);
lg.dispose();
}
public void zoomIn() {
Dimension asz = this.getSize();
int maxzf = 3;
int coef = 1;
int r;
cmdline =
"/bin/sh get.sh "
+ j2kfilename
+ " "
+ iw
+ " "
+ ih
+ " "
+ rect.x
+ " "
+ rect.y
+ " "
+ rect.width
+ " "
+ rect.height;
Exec.execPrint(cmdline);
rect.x = rect.y = rect.width = rect.height = 0;
img = pgm.open("out.pgm");
iw = img.getWidth(this);
ih = img.getHeight(this);
bi = new BufferedImage(iw, ih, BufferedImage.TYPE_INT_RGB);
big = bi.createGraphics();
selected = 0;
fullRefresh = true;
repaint();
}
/** 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);
}
private void drawMark(Graphics g, Polygon r) {
g.setColor(Color.black);
Rectangle rr = r.getBoundingBox();
rr.x += 3;
rr.y += 3;
rr.height -= 5;
rr.width -= 6;
drawRect(g, rr.x, rr.y, rr.width, rr.height);
}
/**
* Adds the tile to the set, setting the id of the tile only if the current value of id is -1.
*
* @param t the tile to add
* @return int The <b>local</b> id of the tile
*/
public int addTile(Tile t) {
if (t.getId() < 0) t.setId(tiles.size());
if (tileDimensions.width < t.getWidth()) tileDimensions.width = t.getWidth();
if (tileDimensions.height < t.getHeight()) tileDimensions.height = t.getHeight();
tiles.add(t);
t.setTileSet(this);
return t.getId();
}
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 Rectangle getScreenViewableBounds(GraphicsDevice gd) {
Rectangle bounds = new Rectangle(0, 0, 0, 0);
if (gd != null) {
GraphicsConfiguration gc = gd.getDefaultConfiguration();
bounds = gc.getBounds();
Insets insets = Toolkit.getDefaultToolkit().getScreenInsets(gc);
bounds.x += insets.left;
bounds.y += insets.top;
bounds.width -= (insets.left + insets.right);
bounds.height -= (insets.top + insets.bottom);
}
return bounds;
}
/**
* Layout the child Widgets. This may be invoked whenever something has changed (the size of this
* WidgetContainer, the preferred size of one of its children, etc.) that causes the layout to no
* longer be correct. If a child is itself a WidgetContainer, its layoutChildren() method will be
* called in turn.
*/
public void layoutChildren() {
if (minColSize == null) calculateSizes();
Dimension size = getComponent().getSize();
int rowPos[] = calculatePositions(minRowSize, prefRowSize, rowWeight, size.height);
int colPos[] = calculatePositions(minColSize, prefColSize, colWeight, size.width);
Rectangle cell = new Rectangle();
for (int i = 0; i < child.size(); i++) {
ChildInfo info = child.get(i);
LayoutInfo layout = (info.layout == null ? defaultLayout : info.layout);
cell.x = (info.x == 0 ? 0 : colPos[info.x - 1]);
cell.y = (info.y == 0 ? 0 : rowPos[info.y - 1]);
cell.width = colPos[info.x + info.width - 1] - cell.x;
cell.height = rowPos[info.y + info.height - 1] - cell.y;
info.widget.getComponent().setBounds(layout.getWidgetLayout(info.widget, cell));
if (info.widget instanceof WidgetContainer) ((WidgetContainer) info.widget).layoutChildren();
}
}
public void layoutContainer(Container parent) {
Dimension size = parent.getSize();
Dimension captionSize = caption.getPreferredSize();
caption.setBounds(PADDING, PADDING, captionSize.width, captionSize.height);
// make all buttons the same size
Dimension buttonSize = cancelButton.getPreferredSize();
buttonSize.width = Math.max(buttonSize.width, prevButton.getPreferredSize().width);
buttonSize.width = Math.max(buttonSize.width, nextButton.getPreferredSize().width);
// cancel button goes on far left
cancelButton.setBounds(
PADDING, size.height - buttonSize.height - PADDING, buttonSize.width, buttonSize.height);
// prev and next buttons are on the right
prevButton.setBounds(
size.width - buttonSize.width * 2 - 6 - PADDING,
size.height - buttonSize.height - PADDING,
buttonSize.width,
buttonSize.height);
nextButton.setBounds(
size.width - buttonSize.width - PADDING,
size.height - buttonSize.height - PADDING,
buttonSize.width,
buttonSize.height);
// calculate size for current page
Rectangle currentPageBounds = new Rectangle();
currentPageBounds.x = PADDING;
currentPageBounds.y = PADDING * 2 + captionSize.height;
currentPageBounds.width = size.width - currentPageBounds.x - PADDING;
currentPageBounds.height =
size.height - buttonSize.height - currentPageBounds.y - PADDING * 2;
for (int i = 0; i < pages.length; i++) {
Component page = pages[i];
page.setBounds(currentPageBounds);
page.setVisible(i == currentPage);
}
}
private void paintBorder(Graphics g, Rectangle cellRect, int row, int column) {
if (grid.getSpanModel().isCellSpan(row, column)) {
CellSpan span = grid.getSpanModel().getSpanOver(row, column);
row = span.getRow();
column = span.getColumn();
}
// Paint border
javax.swing.border.Border border = grid.getStyleModel().getCellStyle(row, column).getBorder();
Insets borderInsets = border.getBorderInsets(grid);
Rectangle borderRect = new Rectangle(cellRect);
int topOffset = (borderInsets.top >> 1);
int leftOffset = (borderInsets.left >> 1);
int bottomOffset = (borderInsets.bottom / 3) + topOffset;
int rightOffset = (borderInsets.right / 3) + leftOffset;
borderRect.x -= leftOffset;
borderRect.y -= topOffset;
borderRect.width += rightOffset;
borderRect.height += bottomOffset;
border.paintBorder(grid, g, borderRect.x, borderRect.y, borderRect.width, borderRect.height);
}
/**
* Verifies that all required parameters are set. If not, sets them to default values. Verifies
* values of critical parameters, adjust their values when needed.
*
* @throws IllegalArgumentException if params is null
*/
protected void checkParams(XCreateWindowParams params) {
if (params == null) {
throw new IllegalArgumentException("Window creation parameters are null");
}
params.putIfNull(PARENT_WINDOW, Long.valueOf(XToolkit.getDefaultRootWindow()));
params.putIfNull(BOUNDS, new Rectangle(DEF_LOCATION, DEF_LOCATION, MIN_SIZE, MIN_SIZE));
params.putIfNull(DEPTH, Integer.valueOf((int) XlibWrapper.CopyFromParent));
params.putIfNull(VISUAL, Long.valueOf(XlibWrapper.CopyFromParent));
params.putIfNull(VISUAL_CLASS, Integer.valueOf((int) XlibWrapper.InputOnly));
params.putIfNull(VALUE_MASK, Long.valueOf(XlibWrapper.CWEventMask));
Rectangle bounds = (Rectangle) params.get(BOUNDS);
bounds.width = Math.max(MIN_SIZE, bounds.width);
bounds.height = Math.max(MIN_SIZE, bounds.height);
Long eventMaskObj = (Long) params.get(EVENT_MASK);
long eventMask = eventMaskObj != null ? eventMaskObj.longValue() : 0;
// We use our own synthetic grab see XAwtState.getGrabWindow()
// (see X vol. 1, 8.3.3.2)
eventMask |= PropertyChangeMask | OwnerGrabButtonMask;
params.put(EVENT_MASK, Long.valueOf(eventMask));
}
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
int width = getWidth() - rightMargin - leftMargin - 10;
int height = getHeight() - topMargin - bottomMargin;
if (width <= 0 || height <= 0) {
// not enough room to paint anything
return;
}
Color oldColor = g.getColor();
Font oldFont = g.getFont();
Color fg = getForeground();
Color bg = getBackground();
boolean bgIsLight = (bg.getRed() > 200 && bg.getGreen() > 200 && bg.getBlue() > 200);
((Graphics2D) g)
.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
if (smallFont == null) {
smallFont = oldFont.deriveFont(9.0F);
}
r.x = leftMargin - 5;
r.y = topMargin - 8;
r.width = getWidth() - leftMargin - rightMargin;
r.height = getHeight() - topMargin - bottomMargin + 16;
if (border == null) {
// By setting colors here, we avoid recalculating them
// over and over.
border =
new BevelBorder(
BevelBorder.LOWERED,
getBackground().brighter().brighter(),
getBackground().brighter(),
getBackground().darker().darker(),
getBackground().darker());
}
border.paintBorder(this, g, r.x, r.y, r.width, r.height);
// Fill background color
g.setColor(bgColor);
g.fillRect(r.x + 2, r.y + 2, r.width - 4, r.height - 4);
g.setColor(oldColor);
long tMin = Long.MAX_VALUE;
long tMax = Long.MIN_VALUE;
long vMin = Long.MAX_VALUE;
long vMax = 1;
int w = getWidth() - rightMargin - leftMargin - 10;
int h = getHeight() - topMargin - bottomMargin;
if (times.size > 1) {
tMin = Math.min(tMin, times.time(0));
tMax = Math.max(tMax, times.time(times.size - 1));
}
long viewRangeMS;
if (viewRange > 0) {
viewRangeMS = viewRange * MINUTE;
} else {
// Display full time range, but no less than a minute
viewRangeMS = Math.max(tMax - tMin, 1 * MINUTE);
}
// Calculate min/max values
for (Sequence seq : seqs) {
if (seq.size > 0) {
for (int i = 0; i < seq.size; i++) {
if (seq.size == 1 || times.time(i) >= tMax - viewRangeMS) {
long val = seq.value(i);
if (val > Long.MIN_VALUE) {
vMax = Math.max(vMax, val);
vMin = Math.min(vMin, val);
}
}
}
} else {
vMin = 0L;
}
if (unit == Unit.BYTES || !seq.isPlotted) {
// We'll scale only to the first (main) value set.
// TODO: Use a separate property for this.
break;
}
}
// Normalize scale
vMax = normalizeMax(vMax);
if (vMin > 0) {
if (vMax / vMin > 4) {
vMin = 0;
} else {
vMin = normalizeMin(vMin);
}
}
g.setColor(fg);
// Axes
// Draw vertical axis
int x = leftMargin - 18;
int y = topMargin;
FontMetrics fm = g.getFontMetrics();
g.drawLine(x, y, x, y + h);
int n = 5;
if (("" + vMax).startsWith("2")) {
n = 4;
} else if (("" + vMax).startsWith("3")) {
n = 6;
} else if (("" + vMax).startsWith("4")) {
n = 4;
} else if (("" + vMax).startsWith("6")) {
n = 6;
} else if (("" + vMax).startsWith("7")) {
n = 7;
} else if (("" + vMax).startsWith("8")) {
n = 8;
} else if (("" + vMax).startsWith("9")) {
n = 3;
}
// Ticks
ArrayList<Long> tickValues = new ArrayList<Long>();
tickValues.add(vMin);
for (int i = 0; i < n; i++) {
long v = i * vMax / n;
if (v > vMin) {
tickValues.add(v);
}
}
tickValues.add(vMax);
n = tickValues.size();
String[] tickStrings = new String[n];
for (int i = 0; i < n; i++) {
long v = tickValues.get(i);
tickStrings[i] = getSizeString(v, vMax);
}
// Trim trailing decimal zeroes.
if (decimals > 0) {
boolean trimLast = true;
boolean removedDecimalPoint = false;
do {
for (String str : tickStrings) {
if (!(str.endsWith("0") || str.endsWith("."))) {
trimLast = false;
break;
}
}
if (trimLast) {
if (tickStrings[0].endsWith(".")) {
removedDecimalPoint = true;
}
for (int i = 0; i < n; i++) {
String str = tickStrings[i];
tickStrings[i] = str.substring(0, str.length() - 1);
}
}
} while (trimLast && !removedDecimalPoint);
}
// Draw ticks
int lastY = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
long v = tickValues.get(i);
y = topMargin + h - (int) (h * (v - vMin) / (vMax - vMin));
g.drawLine(x - 2, y, x + 2, y);
String s = tickStrings[i];
if (unit == Unit.PERCENT) {
s += "%";
}
int sx = x - 6 - fm.stringWidth(s);
if (y < lastY - 13) {
if (checkLeftMargin(sx)) {
// Wait for next repaint
return;
}
g.drawString(s, sx, y + 4);
}
// Draw horizontal grid line
g.setColor(Color.lightGray);
g.drawLine(r.x + 4, y, r.x + r.width - 4, y);
g.setColor(fg);
lastY = y;
}
// Draw horizontal axis
x = leftMargin;
y = topMargin + h + 15;
g.drawLine(x, y, x + w, y);
long t1 = tMax;
if (t1 <= 0L) {
// No data yet, so draw current time
t1 = System.currentTimeMillis();
}
long tz = timeDF.getTimeZone().getOffset(t1);
long tickInterval = calculateTickInterval(w, 40, viewRangeMS);
if (tickInterval > 3 * HOUR) {
tickInterval = calculateTickInterval(w, 80, viewRangeMS);
}
long t0 = tickInterval - (t1 - viewRangeMS + tz) % tickInterval;
while (t0 < viewRangeMS) {
x = leftMargin + (int) (w * t0 / viewRangeMS);
g.drawLine(x, y - 2, x, y + 2);
long t = t1 - viewRangeMS + t0;
String str = formatClockTime(t);
g.drawString(str, x, y + 16);
// if (tickInterval > (1 * HOUR) && t % (1 * DAY) == 0) {
if ((t + tz) % (1 * DAY) == 0) {
str = formatDate(t);
g.drawString(str, x, y + 27);
}
// Draw vertical grid line
g.setColor(Color.lightGray);
g.drawLine(x, topMargin, x, topMargin + h);
g.setColor(fg);
t0 += tickInterval;
}
// Plot values
int start = 0;
int nValues = 0;
int nLists = seqs.size();
if (nLists > 0) {
nValues = seqs.get(0).size;
}
if (nValues == 0) {
g.setColor(oldColor);
return;
} else {
Sequence seq = seqs.get(0);
// Find starting point
for (int p = 0; p < seq.size; p++) {
if (times.time(p) >= tMax - viewRangeMS) {
start = p;
break;
}
}
}
// Optimization: collapse plot of more than four values per pixel
int pointsPerPixel = (nValues - start) / w;
if (pointsPerPixel < 4) {
pointsPerPixel = 1;
}
// Draw graphs
// Loop backwards over sequences because the first needs to be painted on top
for (int i = nLists - 1; i >= 0; i--) {
int x0 = leftMargin;
int y0 = topMargin + h + 1;
Sequence seq = seqs.get(i);
if (seq.isPlotted && seq.size > 0) {
// Paint twice, with white and with color
for (int pass = 0; pass < 2; pass++) {
g.setColor((pass == 0) ? Color.white : seq.color);
int x1 = -1;
long v1 = -1;
for (int p = start; p < nValues; p += pointsPerPixel) {
// Make sure we get the last value
if (pointsPerPixel > 1 && p >= nValues - pointsPerPixel) {
p = nValues - 1;
}
int x2 = (int) (w * (times.time(p) - (t1 - viewRangeMS)) / viewRangeMS);
long v2 = seq.value(p);
if (v2 >= vMin && v2 <= vMax) {
int y2 = (int) (h * (v2 - vMin) / (vMax - vMin));
if (x1 >= 0 && v1 >= vMin && v1 <= vMax) {
int y1 = (int) (h * (v1 - vMin) / (vMax - vMin));
if (y1 == y2) {
// fillrect is much faster
g.fillRect(x0 + x1, y0 - y1 - pass, x2 - x1, 1);
} else {
Graphics2D g2d = (Graphics2D) g;
Stroke oldStroke = null;
if (seq.transitionStroke != null) {
oldStroke = g2d.getStroke();
g2d.setStroke(seq.transitionStroke);
}
g.drawLine(x0 + x1, y0 - y1 - pass, x0 + x2, y0 - y2 - pass);
if (oldStroke != null) {
g2d.setStroke(oldStroke);
}
}
}
}
x1 = x2;
v1 = v2;
}
}
// Current value
long v = seq.value(seq.size - 1);
if (v >= vMin && v <= vMax) {
if (bgIsLight) {
g.setColor(seq.color);
} else {
g.setColor(fg);
}
x = r.x + r.width + 2;
y = topMargin + h - (int) (h * (v - vMin) / (vMax - vMin));
// a small triangle/arrow
g.fillPolygon(new int[] {x + 2, x + 6, x + 6}, new int[] {y, y + 3, y - 3}, 3);
}
g.setColor(fg);
}
}
int[] valueStringSlots = new int[nLists];
for (int i = 0; i < nLists; i++) valueStringSlots[i] = -1;
for (int i = 0; i < nLists; i++) {
Sequence seq = seqs.get(i);
if (seq.isPlotted && seq.size > 0) {
// Draw current value
// TODO: collapse values if pointsPerPixel >= 4
long v = seq.value(seq.size - 1);
if (v >= vMin && v <= vMax) {
x = r.x + r.width + 2;
y = topMargin + h - (int) (h * (v - vMin) / (vMax - vMin));
int y2 = getValueStringSlot(valueStringSlots, y, 2 * 10, i);
g.setFont(smallFont);
if (bgIsLight) {
g.setColor(seq.color);
} else {
g.setColor(fg);
}
String curValue = getFormattedValue(v, true);
if (unit == Unit.PERCENT) {
curValue += "%";
}
int valWidth = fm.stringWidth(curValue);
String legend = (displayLegend ? seq.name : "");
int legendWidth = fm.stringWidth(legend);
if (checkRightMargin(valWidth) || checkRightMargin(legendWidth)) {
// Wait for next repaint
return;
}
g.drawString(legend, x + 17, Math.min(topMargin + h, y2 + 3 - 10));
g.drawString(curValue, x + 17, Math.min(topMargin + h + 10, y2 + 3));
// Maybe draw a short line to value
if (y2 > y + 3) {
g.drawLine(x + 9, y + 2, x + 14, y2);
} else if (y2 < y - 3) {
g.drawLine(x + 9, y - 2, x + 14, y2);
}
}
g.setFont(oldFont);
g.setColor(fg);
}
}
g.setColor(oldColor);
}
//
// Build installer window
//
public static void showInstallerWindow() {
_installerFrame = new JFrame(Config.getWindowTitle());
Container cont = _installerFrame.getContentPane();
cont.setLayout(new BorderLayout());
// North pane
Box topPane = new Box(BoxLayout.X_AXIS);
JLabel title = new JLabel(Config.getWindowHeading());
Font titleFont = new Font("SansSerif", Font.BOLD, 22);
title.setFont(titleFont);
title.setForeground(Color.black);
// Create Sun logo
URL urlLogo = Main.class.getResource(Config.getWindowLogo());
Image img = Toolkit.getDefaultToolkit().getImage(urlLogo);
MediaTracker md = new MediaTracker(_installerFrame);
md.addImage(img, 0);
try {
md.waitForAll();
} catch (Exception ioe) {
Config.trace(ioe.toString());
}
if (md.isErrorID(0)) Config.trace("Error loading image");
Icon sunLogo = new ImageIcon(img);
JLabel logoLabel = new JLabel(sunLogo);
logoLabel.setOpaque(true);
topPane.add(topPane.createHorizontalStrut(5));
topPane.add(title);
topPane.add(topPane.createHorizontalGlue());
topPane.add(logoLabel);
topPane.add(topPane.createHorizontalStrut(5));
// West Pane
Box westPane = new Box(BoxLayout.X_AXIS);
westPane.add(westPane.createHorizontalStrut(10));
// South Pane
Box bottomPane = new Box(BoxLayout.X_AXIS);
bottomPane.add(bottomPane.createHorizontalGlue());
JButton abortButton = new JButton(Config.getWindowAbortButton());
abortButton.setMnemonic(Config.getWindowAbortMnemonic());
bottomPane.add(abortButton);
bottomPane.add(bottomPane.createHorizontalGlue());
bottomPane.setBorder(BorderFactory.createEmptyBorder(0, 0, 5, 0));
// Center Pane
Box centerPane = new Box(BoxLayout.Y_AXIS);
JLabel hidden = new JLabel(Config.getWindowHiddenLabel());
hidden.setVisible(false);
centerPane.add(hidden);
_stepLabels = new JLabel[5];
for (int i = 0; i < _stepLabels.length; i++) {
_stepLabels[i] = new JLabel(Config.getWindowStep(i));
_stepLabels[i].setEnabled(false);
centerPane.add(_stepLabels[i]);
// install label's length will expand,so set a longer size.
if (i == STEP_INSTALL) {
Dimension dim = new JLabel(Config.getWindowStepWait(STEP_INSTALL)).getPreferredSize();
_stepLabels[i].setPreferredSize(dim);
}
}
hidden = new JLabel(Config.getWindowHiddenLabel());
hidden.setVisible(false);
centerPane.add(hidden);
// Setup box layout
cont.add(topPane, "North");
cont.add(westPane, "West");
cont.add(bottomPane, "South");
cont.add(centerPane, "Center");
_installerFrame.pack();
Dimension dim = _installerFrame.getSize();
// hard code to ensure title is completely visible on Sol/lin.
if (dim.width < 400) {
dim.width = 400;
_installerFrame.setSize(dim);
}
Rectangle size = _installerFrame.getBounds();
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
size.width = Math.min(screenSize.width, size.width);
size.height = Math.min(screenSize.height, size.height);
// Put window at 1/4, 1/4 of screen resoluion
_installerFrame.setBounds(
(screenSize.width - size.width) / 4,
(screenSize.height - size.height) / 4,
size.width,
size.height);
// Setup event listners
_installerFrame.addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent we) {
installFailed("Window closed", null);
}
});
abortButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent ae) {
installFailed("Abort pressed", null);
}
});
// Show window
_installerFrame.show();
}
public static boolean showLicensing() {
if (Config.getLicenseResource() == null) return true;
ClassLoader cl = Main.class.getClassLoader();
URL url = cl.getResource(Config.getLicenseResource());
if (url == null) return true;
String license = null;
try {
URLConnection con = url.openConnection();
int size = con.getContentLength();
byte[] content = new byte[size];
InputStream in = new BufferedInputStream(con.getInputStream());
in.read(content);
license = new String(content);
} catch (IOException ioe) {
Config.trace("Got exception when reading " + Config.getLicenseResource() + ": " + ioe);
return false;
}
// Build dialog
JTextArea ta = new JTextArea(license);
ta.setEditable(false);
final JDialog jd = new JDialog(_installerFrame, true);
Container comp = jd.getContentPane();
jd.setTitle(Config.getLicenseDialogTitle());
comp.setLayout(new BorderLayout(10, 10));
comp.add(new JScrollPane(ta), "Center");
Box box = new Box(BoxLayout.X_AXIS);
box.add(box.createHorizontalStrut(10));
box.add(new JLabel(Config.getLicenseDialogQuestionString()));
box.add(box.createHorizontalGlue());
JButton acceptButton = new JButton(Config.getLicenseDialogAcceptString());
JButton exitButton = new JButton(Config.getLicenseDialogExitString());
box.add(acceptButton);
box.add(box.createHorizontalStrut(10));
box.add(exitButton);
box.add(box.createHorizontalStrut(10));
jd.getRootPane().setDefaultButton(acceptButton);
Box box2 = new Box(BoxLayout.Y_AXIS);
box2.add(box);
box2.add(box2.createVerticalStrut(5));
comp.add(box2, "South");
jd.pack();
final boolean accept[] = new boolean[1];
acceptButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
accept[0] = true;
jd.hide();
jd.dispose();
}
});
exitButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
accept[0] = false;
jd.hide();
jd.dispose();
}
});
// Apply any defaults the user may have, constraining to the size
// of the screen, and default (packed) size.
Rectangle size = new Rectangle(0, 0, 500, 300);
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
size.width = Math.min(screenSize.width, size.width);
size.height = Math.min(screenSize.height, size.height);
// Center the window
jd.setBounds(
(screenSize.width - size.width) / 2,
(screenSize.height - size.height) / 2,
size.width,
size.height);
// Show dialog
jd.show();
return accept[0];
}
public static ActionCallback showAndSelect(
final JTree tree,
int top,
int bottom,
final int row,
final int previous,
boolean addToSelection,
final boolean scroll) {
final TreePath path = tree.getPathForRow(row);
if (path == null) return new ActionCallback.Done();
final int size = tree.getRowCount();
if (size == 0) {
tree.clearSelection();
return new ActionCallback.Done();
}
if (top < 0) {
top = 0;
}
if (bottom >= size) {
bottom = size - 1;
}
if (row >= tree.getRowCount()) return new ActionCallback.Done();
if (!tree.isValid()) {
tree.validate();
}
final Rectangle rowBounds = tree.getRowBounds(row);
if (rowBounds == null) return new ActionCallback.Done();
Rectangle topBounds = tree.getRowBounds(top);
if (topBounds == null) {
topBounds = rowBounds;
}
Rectangle bottomBounds = tree.getRowBounds(bottom);
if (bottomBounds == null) {
bottomBounds = rowBounds;
}
Rectangle bounds = topBounds.union(bottomBounds);
bounds.x = rowBounds.x;
bounds.width = rowBounds.width;
final Rectangle visible = tree.getVisibleRect();
if (visible.contains(bounds)) {
bounds = null;
} else {
final Component comp =
tree.getCellRenderer()
.getTreeCellRendererComponent(
tree, path.getLastPathComponent(), true, true, false, row, false);
if (comp instanceof SimpleColoredComponent) {
final SimpleColoredComponent renderer = ((SimpleColoredComponent) comp);
final Dimension scrollableSize = renderer.computePreferredSize(true);
bounds.width = scrollableSize.width;
}
}
final ActionCallback callback = new ActionCallback();
if (!tree.isRowSelected(row)) {
if (addToSelection) {
tree.getSelectionModel().addSelectionPath(tree.getPathForRow(row));
} else {
tree.setSelectionRow(row);
}
}
if (bounds != null) {
final Range<Integer> range = getExpandControlRange(tree, path);
if (range != null) {
int delta = bounds.x - range.getFrom().intValue();
bounds.x -= delta;
bounds.width -= delta;
}
if (visible.width < bounds.width) {
bounds.width = visible.width;
}
final Rectangle b1 = bounds;
final Runnable runnable =
new Runnable() {
public void run() {
if (scroll) {
tree.scrollRectToVisible(b1);
}
callback.setDone();
}
};
if (ApplicationManager.getApplication().isUnitTestMode()) {
runnable.run();
} else {
SwingUtilities.invokeLater(runnable);
}
} else {
callback.setDone();
}
return callback;
}
@Override
protected void paintText(
Graphics g,
int tabPlacement,
Font font,
FontMetrics metrics,
int tabIndex,
String title,
Rectangle textRect,
boolean isSelected) {
g.setFont(font);
int titleWidth = SwingUtilities.computeStringWidth(metrics, title);
int preferredWidth = 0;
if (isOneActionButtonEnabled()) {
preferredWidth = calculateTabWidth(tabPlacement, tabIndex, metrics) - WIDTHDELTA - 15;
if (isCloseEnabled()) preferredWidth -= BUTTONSIZE;
if (isMaxEnabled()) preferredWidth -= BUTTONSIZE;
} else {
preferredWidth = titleWidth;
}
while (titleWidth > preferredWidth) {
if (title.endsWith("...")) title = title.substring(0, title.indexOf("...") - 1).concat("...");
else title = title.substring(0, title.length() - 4).concat("...");
titleWidth = SwingUtilities.computeStringWidth(metrics, title);
}
textRect.width = titleWidth;
View v = getTextViewForTab(tabIndex);
if (v != null) {
// html
v.paint(g, textRect);
} else {
// plain text
int mnemIndex = tabPane.getDisplayedMnemonicIndexAt(tabIndex);
if (tabPane.isEnabled() && tabPane.isEnabledAt(tabIndex)) {
if (isSelected) g.setColor(TAB_SELECTED_FOREGROUND_COLOR);
else {
if (this.isTabHighlighted(tabIndex)) {
g.setColor(TAB_HIGHLIGHT_FOREGROUND_COLOR);
} else g.setColor(tabPane.getForegroundAt(tabIndex));
}
BasicGraphicsUtils.drawString(
g, title, mnemIndex, textRect.x, textRect.y + metrics.getAscent());
} else { // tab disabled
g.setColor(tabPane.getBackgroundAt(tabIndex).brighter());
BasicGraphicsUtils.drawStringUnderlineCharAt(
g, title, mnemIndex, textRect.x, textRect.y + metrics.getAscent());
g.setColor(tabPane.getBackgroundAt(tabIndex).darker());
BasicGraphicsUtils.drawStringUnderlineCharAt(
g, title, mnemIndex, textRect.x - 1, textRect.y + metrics.getAscent() - 1);
}
}
}
/**
* Draw the Axis. As each axis is drawn and aligned less of the canvas is avaliable to plot the
* data. The returned Rectangle is the canvas area that the data is plotted in.
*/
protected Rectangle drawAxis(Graphics g, Rectangle r) {
Axis a;
int waxis;
Rectangle dr;
int x;
int y;
int width;
int height;
if (square) r = ForceSquare(g, r);
dr = getDataRectangle(g, r);
x = dr.x;
y = dr.y;
width = dr.width;
height = dr.height;
if (clearAll) {
Color c = g.getColor();
g.setColor(DataBackground);
g.fillRect(x, y, width, height);
g.setColor(c);
}
// Draw a frame around the data area (If requested)
if (frame) drawFrame(g, x, y, width, height);
// Now draw the axis in the order specified aligning them with the final
// data area.
for (int i = 0; i < axis.size(); i++) {
a = ((Axis) axis.elementAt(i));
a.data_window = new Dimension(width, height);
switch (a.getAxisPos()) {
case Axis.LEFT:
r.x += a.width;
r.width -= a.width;
a.positionAxis(r.x, r.x, y, y + height);
if (r.x == x) {
a.gridcolor = gridcolor;
a.drawgrid = drawgrid;
a.zerocolor = zerocolor;
a.drawzero = drawzero;
}
a.drawAxis(g);
a.drawgrid = false;
a.drawzero = false;
break;
case Axis.RIGHT:
r.width -= a.width;
a.positionAxis(r.x + r.width, r.x + r.width, y, y + height);
if (r.x + r.width == x + width) {
a.gridcolor = gridcolor;
a.drawgrid = drawgrid;
a.zerocolor = zerocolor;
a.drawzero = drawzero;
}
a.drawAxis(g);
a.drawgrid = false;
a.drawzero = false;
break;
case Axis.TOP:
r.y += a.width;
r.height -= a.width;
a.positionAxis(x, x + width, r.y, r.y);
if (r.y == y) {
a.gridcolor = gridcolor;
a.drawgrid = drawgrid;
a.zerocolor = zerocolor;
a.drawzero = drawzero;
}
a.drawAxis(g);
a.drawgrid = false;
a.drawzero = false;
break;
case Axis.BOTTOM:
r.height -= a.width;
a.positionAxis(x, x + width, r.y + r.height, r.y + r.height);
if (r.y + r.height == y + height) {
a.gridcolor = gridcolor;
a.drawgrid = drawgrid;
a.zerocolor = zerocolor;
a.drawzero = drawzero;
}
a.drawAxis(g);
a.drawgrid = false;
a.drawzero = false;
break;
}
}
return r;
}
public void setRGeom(int x1, int y1, int x2, int y2) {
rect.x = Math.min(x1, x2) - offset.x;
rect.y = Math.min(y1, y2) - offset.y;
rect.width = Math.abs(x2 - x1);
rect.height = Math.abs(y2 - y1);
}
