private Window updateMaskAndAlpha(Window window) {
if (window == null) return window;
final WindowManagerEx wndManager = getWndManager();
if (wndManager == null) return window;
if (!wndManager.isAlphaModeEnabled(window)) return window;
if (myAlpha != myLastAlpha) {
wndManager.setAlphaModeRatio(window, myAlpha);
myLastAlpha = myAlpha;
}
if (myMaskProvider != null) {
final Dimension size = window.getSize();
Shape mask = myMaskProvider.getMask(size);
wndManager.setWindowMask(window, mask);
}
WindowManagerEx.WindowShadowMode mode =
myShadowed
? WindowManagerEx.WindowShadowMode.NORMAL
: WindowManagerEx.WindowShadowMode.DISABLED;
WindowManagerEx.getInstanceEx().setWindowShadow(window, mode);
return window;
}
/*
* Places the Window object at the center of the screen
*/
public static void centerWindow(Window win) {
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension dlgSize = win.getSize();
win.setLocation(
(screenSize.width - dlgSize.width) / 2, (screenSize.height - dlgSize.height) / 2);
}
@Override
public Dimension getSize() {
if (myPopup != null) {
final Window popupWindow = SwingUtilities.windowForComponent(myContent);
return popupWindow.getSize();
} else {
return myForcedSize;
}
}
/**
* Method description
*
* @param window
*/
public static void centerWindow(Window window) {
Dimension dimension = window.getSize();
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
int x = (screenSize.width - dimension.width) / 2;
int y = (screenSize.height - dimension.height) / 2;
window.setLocation(x, y);
window.requestFocus();
}
private void setSizeAndDimensions(
@NotNull JTable table,
@NotNull JBPopup popup,
@NotNull RelativePoint popupPosition,
@NotNull List<UsageNode> data) {
JComponent content = popup.getContent();
Window window = SwingUtilities.windowForComponent(content);
Dimension d = window.getSize();
int width = calcMaxWidth(table);
width = (int) Math.max(d.getWidth(), width);
Dimension headerSize = ((AbstractPopup) popup).getHeaderPreferredSize();
width = Math.max((int) headerSize.getWidth(), width);
width = Math.max(myWidth, width);
if (myWidth == -1) myWidth = width;
int newWidth = Math.max(width, d.width + width - myWidth);
myWidth = newWidth;
int rowsToShow = Math.min(30, data.size());
Dimension dimension = new Dimension(newWidth, table.getRowHeight() * rowsToShow);
Rectangle rectangle = fitToScreen(dimension, popupPosition, table);
dimension = rectangle.getSize();
Point location = window.getLocation();
if (!location.equals(rectangle.getLocation())) {
window.setLocation(rectangle.getLocation());
}
if (!data.isEmpty()) {
TableScrollingUtil.ensureSelectionExists(table);
}
table.setSize(dimension);
// table.setPreferredSize(dimension);
// table.setMaximumSize(dimension);
// table.setPreferredScrollableViewportSize(dimension);
Dimension footerSize = ((AbstractPopup) popup).getFooterPreferredSize();
int newHeight =
(int) (dimension.height + headerSize.getHeight() + footerSize.getHeight())
+ 4 /* invisible borders, margins etc*/;
Dimension newDim = new Dimension(dimension.width, newHeight);
window.setSize(newDim);
window.setMinimumSize(newDim);
window.setMaximumSize(newDim);
window.validate();
window.repaint();
table.revalidate();
table.repaint();
}
void saveWindowLocations() {
Window win = WindowManager.getWindow("B&C");
if (win != null) Prefs.saveLocation(ContrastAdjuster.LOC_KEY, win.getLocation());
win = WindowManager.getWindow("Threshold");
if (win != null) Prefs.saveLocation(ThresholdAdjuster.LOC_KEY, win.getLocation());
win = WindowManager.getWindow("Results");
if (win != null) {
Prefs.saveLocation(TextWindow.LOC_KEY, win.getLocation());
Dimension d = win.getSize();
Prefs.set(TextWindow.WIDTH_KEY, d.width);
Prefs.set(TextWindow.HEIGHT_KEY, d.height);
}
win = WindowManager.getWindow("Log");
if (win != null) {
Prefs.saveLocation(TextWindow.LOG_LOC_KEY, win.getLocation());
Dimension d = win.getSize();
Prefs.set(TextWindow.LOG_WIDTH_KEY, d.width);
Prefs.set(TextWindow.LOG_HEIGHT_KEY, d.height);
}
win = WindowManager.getWindow("ROI Manager");
if (win != null) Prefs.saveLocation(RoiManager.LOC_KEY, win.getLocation());
}
/**
* Called by {@link DefaultWindowManager} when iterating through all windows to decide their size
* and position. If you override {@link DefaultWindowManager} to add your own logic to how windows
* are placed on the screen, you can override this method and selectively choose which window to
* interfere with. Note that the two key properties that are read by the GUI system after
* preparing all windows are the position and decorated size. Your custom implementation should
* set these two fields directly on the window. You can infer the decorated size from the content
* size by using the window decoration renderer that is attached to the window manager.
*
* @param screenSize Size of the terminal that is available to draw on
* @param window Window to prepare decorated size and position for
*/
protected void prepareWindow(TerminalSize screenSize, Window window) {
WindowDecorationRenderer decorationRenderer = getWindowDecorationRenderer(window);
TerminalSize contentAreaSize;
if (window.getHints().contains(Window.Hint.FIXED_SIZE)) {
contentAreaSize = window.getSize();
} else {
contentAreaSize = window.getPreferredSize();
}
TerminalSize size = decorationRenderer.getDecoratedSize(window, contentAreaSize);
TerminalPosition position = window.getPosition();
if (window.getHints().contains(Window.Hint.FULL_SCREEN)) {
position = TerminalPosition.TOP_LEFT_CORNER;
size = screenSize;
} else if (window.getHints().contains(Window.Hint.EXPANDED)) {
position = TerminalPosition.OFFSET_1x1;
size =
screenSize.withRelative(
-Math.min(4, screenSize.getColumns()), -Math.min(3, screenSize.getRows()));
if (!size.equals(window.getDecoratedSize())) {
window.invalidate();
}
} else if (window.getHints().contains(Window.Hint.FIT_TERMINAL_WINDOW)
|| window.getHints().contains(Window.Hint.CENTERED)) {
// If the window is too big for the terminal, move it up towards 0x0 and if that's not enough
// then shrink
// it instead
while (position.getRow() > 0 && position.getRow() + size.getRows() > screenSize.getRows()) {
position = position.withRelativeRow(-1);
}
while (position.getColumn() > 0
&& position.getColumn() + size.getColumns() > screenSize.getColumns()) {
position = position.withRelativeColumn(-1);
}
if (position.getRow() + size.getRows() > screenSize.getRows()) {
size = size.withRows(screenSize.getRows() - position.getRow());
}
if (position.getColumn() + size.getColumns() > screenSize.getColumns()) {
size = size.withColumns(screenSize.getColumns() - position.getColumn());
}
if (window.getHints().contains(Window.Hint.CENTERED)) {
int left = (lastKnownScreenSize.getColumns() - size.getColumns()) / 2;
int top = (lastKnownScreenSize.getRows() - size.getRows()) / 2;
position = new TerminalPosition(left, top);
}
}
window.setPosition(position);
window.setDecoratedSize(size);
}
public void setUiVisible(final boolean visible) {
if (myPopup != null) {
if (visible) {
myPopup.show();
final Window window = getPopupWindow();
if (window != null && myRestoreWindowSize != null) {
window.setSize(myRestoreWindowSize);
myRestoreWindowSize = null;
}
} else {
final Window window = getPopupWindow();
if (window != null) {
myRestoreWindowSize = window.getSize();
window.setVisible(true);
}
}
}
}
/**
* Saves the window state to the given properties map.
*
* @param aNamespace the namespace to use for the window state;
* @param aProperties the properties to fill;
* @param aWindow the window to save the state for.
*/
public static void saveWindowState(final Preferences aProperties, final Window aWindow) {
// Special case: for FileDialog/JFileChooser we also store the properties...
saveFileDialogState(aProperties, aWindow);
final Point location = aWindow.getLocation();
aProperties.put("winXpos", Integer.toString(location.x));
aProperties.put("winYpos", Integer.toString(location.y));
if (isNonResizableWindow(aWindow)) {
// In case the window cannot be resized, don't restore its width &
// height...
return;
}
final Dimension dims = aWindow.getSize();
aProperties.put("winWidth", Integer.toString(dims.width));
aProperties.put("winHeight", Integer.toString(dims.height));
}
public Canvas(Window window) {
this.window = window;
setIgnoreRepaint(true);
setSize(window.getSize());
setBackground(Color.BLACK);
setBounds(0, 0, getWidth(), getHeight());
window.add(this, BorderLayout.CENTER);
addKeyListener(InputHandler.SINGLETON);
addMouseListener(InputHandler.SINGLETON);
addMouseMotionListener(InputHandler.SINGLETON);
addMouseWheelListener(InputHandler.SINGLETON);
addFocusListener(InputHandler.SINGLETON);
vi = createVolatileImage(getWidth(), getHeight());
createBufferStrategy(3);
strategy = getBufferStrategy();
updateOffscreen();
}
/** Centre a Window on the screen */
public static void centre(Window w) {
Dimension us = w.getSize(), them = Toolkit.getDefaultToolkit().getScreenSize();
int newX = (them.width - us.width) / 2;
int newY = (them.height - us.height) / 2;
w.setLocation(newX, newY);
}
public static void center(Window w) {
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension windowSize = w.getSize();
w.setLocation(
(screenSize.width - windowSize.width) / 2, (screenSize.height - windowSize.height) / 2);
}