private void checkSizes() { Dimension vsz = scroll_pane.getViewport().getViewSize(); Dimension csz = draw_area.getSize(); Dimension nsz = new Dimension((int) (vsz.width * x_scale), (int) (vsz.height * y_scale)); boolean chng = false; if (nsz.width > csz.width) { if (vsz.width >= csz.width) { csz.width = vsz.width; chng = true; x_scale = 1; } } else if (nsz.width < csz.width) { if (x_scale == 1) { csz.width = vsz.width; chng = true; } } if (nsz.height > csz.height) { if (vsz.height >= csz.height) { csz.height = vsz.height; chng = true; y_scale = 1; } } else if (nsz.height < csz.height) { if (y_scale == 1) { csz.height = vsz.height; chng = true; } } if (chng) draw_area.setSize(csz); }
public void processCellResized( RadContainer container, final boolean isRow, final int cell, final int newSize) { int cellCount = isRow ? container.getGridRowCount() : container.getGridColumnCount(); if (container.getParent().isXY() && cell == cellCount - 1) { processRootContainerResize(container, isRow, newSize); } else { for (RadComponent component : container.getComponents()) { GridConstraints c = component.getConstraints(); if (c.getCell(isRow) == cell && c.getSpan(isRow) == 1) { Dimension preferredSize = new Dimension(c.myPreferredSize); if (isRow) { preferredSize.height = newSize; if (preferredSize.width == -1) { preferredSize.width = component.getDelegee().getPreferredSize().width; } } else { preferredSize.width = newSize; if (preferredSize.height == -1) { preferredSize.height = component.getDelegee().getPreferredSize().height; } } PreferredSizeProperty.getInstance(container.getProject()) .setValueEx(component, preferredSize); } } } }
/** * Calculates the maximum size dimensions for the specified panal given the components in the * specified parent container. */ public Dimension maximumLayoutSize(Container target) { synchronized (target.getTreeLock()) { Dimension dim = new Dimension(0, 0); int size = actions.size(); if ((grip != null) && grip.isVisible()) { Dimension d = grip.getPreferredSize(); dim.width += d.width; dim.width += hgap; } Component last = null; for (int i = 0; i < size; i++) { Component comp = (Component) actions.elementAt(i); if (comp.isVisible()) { Dimension d = comp.getPreferredSize(); dim.width += d.width; dim.height = Math.max(dim.height, d.height); dim.width += hgap; last = comp; } } if (last != null) { Dimension prefSize = last.getPreferredSize(); Dimension maxSize = last.getMaximumSize(); if (prefSize != maxSize) { dim.width = dim.width - prefSize.width + maxSize.width; dim.height = Math.max(dim.height, maxSize.height); } } Insets insets = target.getInsets(); dim.width += insets.left + insets.right; dim.height += insets.top + insets.bottom; return dim; } }
@Override public void updateMinimumSize() { final Dimension min; if (getTarget().isMinimumSizeSet()) { min = getTarget().getMinimumSize(); min.width = Math.max(min.width, MINIMUM_WIDTH); min.height = Math.max(min.height, MINIMUM_HEIGHT); } else { min = new Dimension(MINIMUM_WIDTH, MINIMUM_HEIGHT); } final int maxW, maxH; if (graphicsConfig instanceof TextureSizeConstraining) { maxW = ((TextureSizeConstraining) graphicsConfig).getMaxTextureWidth(); maxH = ((TextureSizeConstraining) graphicsConfig).getMaxTextureHeight(); } else { maxW = maxH = Integer.MAX_VALUE; } final Dimension max; if (getTarget().isMaximumSizeSet()) { max = getTarget().getMaximumSize(); max.width = Math.min(max.width, maxW); max.height = Math.min(max.height, maxH); } else { max = new Dimension(maxW, maxH); } platformWindow.setSizeConstraints(min.width, min.height, max.width, max.height); }
public void paint(Graphics g) { MetalBumps usedBumps; if (splitPane.hasFocus()) { usedBumps = focusBumps; g.setColor(primaryControlColor); } else { usedBumps = bumps; g.setColor(controlColor); } Rectangle clip = g.getClipBounds(); Insets insets = getInsets(); g.fillRect(clip.x, clip.y, clip.width, clip.height); Dimension size = getSize(); size.width -= inset * 2; size.height -= inset * 2; int drawX = inset; int drawY = inset; if (insets != null) { size.width -= (insets.left + insets.right); size.height -= (insets.top + insets.bottom); drawX += insets.left; drawY += insets.top; } usedBumps.setBumpArea(size); usedBumps.paintIcon(this, g, drawX, drawY); super.paint(g); }
@Override public void layoutContainer(final Container parent) { final int componentCount = parent.getComponentCount(); if (componentCount == 0) return; final EditorEx history = myHistoryViewer; final EditorEx editor = componentCount == 2 ? myConsoleEditor : null; if (editor == null) { parent.getComponent(0).setBounds(parent.getBounds()); return; } final Dimension panelSize = parent.getSize(); if (panelSize.getHeight() <= 0) return; final Dimension historySize = history.getContentSize(); final Dimension editorSize = editor.getContentSize(); final Dimension newEditorSize = new Dimension(); // deal with width final int width = Math.max(editorSize.width, historySize.width); newEditorSize.width = width + editor.getScrollPane().getHorizontalScrollBar().getHeight(); history.getSoftWrapModel().forceAdditionalColumnsUsage(); editor .getSettings() .setAdditionalColumnsCount( 2 + (width - editorSize.width) / EditorUtil.getSpaceWidth(Font.PLAIN, editor)); history .getSettings() .setAdditionalColumnsCount( 2 + (width - historySize.width) / EditorUtil.getSpaceWidth(Font.PLAIN, history)); // deal with height if (historySize.width == 0) historySize.height = 0; final int minHistorySize = historySize.height > 0 ? 2 * history.getLineHeight() + (myShowSeparatorLine ? SEPARATOR_THICKNESS : 0) : 0; final int minEditorSize = editor.isViewer() ? 0 : editor.getLineHeight(); final int editorPreferred = editor.isViewer() ? 0 : Math.max(minEditorSize, editorSize.height); final int historyPreferred = Math.max(minHistorySize, historySize.height); if (panelSize.height < minEditorSize) { newEditorSize.height = panelSize.height; } else if (panelSize.height < editorPreferred) { newEditorSize.height = panelSize.height - minHistorySize; } else if (panelSize.height < editorPreferred + historyPreferred) { newEditorSize.height = editorPreferred; } else { newEditorSize.height = editorPreferred == 0 ? 0 : panelSize.height - historyPreferred; } final Dimension newHistorySize = new Dimension(width, panelSize.height - newEditorSize.height); // apply editor .getComponent() .setBounds(0, newHistorySize.height, panelSize.width, newEditorSize.height); myForceScrollToEnd.compareAndSet(false, shouldScrollHistoryToEnd()); history.getComponent().setBounds(0, 0, panelSize.width, newHistorySize.height); }
public Dimension getAvailableSize() { Dimension availableSize = getSize(); if (!cc.opts.fullScreen) { Insets vpInsets = VncViewer.insets; availableSize.width -= vpInsets.left + vpInsets.right; availableSize.height -= vpInsets.top + vpInsets.bottom; } if (tb.isVisible()) availableSize.height -= tb.getHeight(); if (availableSize.width < 0) availableSize.width = 0; if (availableSize.height < 0) availableSize.height = 0; return availableSize; }
protected Dimension getThumbSize() { Dimension size = super.getThumbSize(); if ((getThumbHorIcon() != null) && (getThumbVerIcon() != null)) { if (slider.getOrientation() == JSlider.HORIZONTAL) { size.width = getThumbHorIcon().getIconWidth(); size.height = getThumbHorIcon().getIconHeight(); } else { size.width = getThumbVerIcon().getIconWidth(); size.height = getThumbVerIcon().getIconHeight(); } } return size; }
public void reshape(int x, int y, int w, int h) { if (inEditMode) { defLoc.x = x; defLoc.y = y; defDim.width = w; defDim.height = h; } curLoc.x = x; curLoc.y = y; curDim.width = w; curDim.height = h; super.reshape(x, y, w, h); }
public Dimension getPreferredSize(JComponent c) { Dimension size = super.getPreferredSize(c); if (comboBox.getGraphics() != null) { FontMetrics fm = Utilities.getFontMetrics(comboBox, comboBox.getGraphics(), comboBox.getFont()); size.height = fm.getHeight() + 2; if (UIManager.getLookAndFeel() instanceof BaseLookAndFeel) { BaseLookAndFeel laf = (BaseLookAndFeel) UIManager.getLookAndFeel(); size.height = Math.max(size.height, laf.getIconFactory().getDownArrowIcon().getIconHeight() + 2); } } return new Dimension(size.width + 2, size.height + 2); }
public RoundButton(String label) { super(label); // These statements enlarge the button so that it // becomes a circle rather than an oval. Dimension size = getPreferredSize(); size.width = size.height = Math.max(size.width, size.height); setPreferredSize(size); // This call causes the JButton not to paint // the background. // This allows us to paint a round background. setContentAreaFilled(false); }
/** Description of the Method */ public void init() { // super.init(); size = new Dimension(570, 570); contentPane = (JPanel) this.getContentPane(); contentPane.setLayout(borderLayout1); Dimension d = messagePanel.getSize(); d.height += 20; messagePanel.setPreferredSize(d); contentPane.add(messagePanel, BorderLayout.SOUTH); contentPane.setOpaque(true); userPanel.setLayout(new GridBagLayout()); GridBagConstraints gbc = new GridBagConstraints(); gbc.anchor = GridBagConstraints.WEST; gbc.insets = new Insets(2, 2, 2, 2); messagePanel.setLayout(borderLayout5); contentPane.setOpaque(true); contentPane.setBackground(Color.white); this.setSize(size); messagePanel.add(labelMessage, BorderLayout.NORTH); // Logg.logg("MhClient: Före XttTree-skapande", 6); this.mhTable = new MhTable(root, false, this.labelMessage); // Logg.logg("MhClient: mhTable-skapande klart", 6); this.contentPane.add(this.mhTable.splitPane, BorderLayout.CENTER); }
private void setHeaderComponent(JComponent c) { boolean doRevalidate = false; if (myHeaderComponent != null) { myHeaderPanel.remove(myHeaderComponent); myHeaderPanel.add(myCaption, BorderLayout.NORTH); myHeaderComponent = null; doRevalidate = true; } if (c != null) { myHeaderPanel.remove(myCaption); myHeaderPanel.add(c, BorderLayout.NORTH); myHeaderComponent = c; final Dimension size = myContent.getSize(); if (size.height < c.getPreferredSize().height * 2) { size.height += c.getPreferredSize().height; setSize(size); } doRevalidate = true; } if (doRevalidate) myContent.revalidate(); }
@Override public Dimension getPreferredSize() { final Dimension size = super.getPreferredSize(); size.width += (myMoreRec.width + myDownIconInsets.left + myDownIconInsets.right); size.height += (myDownIconInsets.top + myDownIconInsets.bottom); return size; }
/** * The critical part of the animation of this <code>JCollapsiblePane</code> relies on the * calculation of its preferred size. During the animation, its preferred size (specially its * height) will change, when expanding, from 0 to the preferred size of the content pane, and the * reverse when collapsing. * * @return this component preferred size */ public Dimension getPreferredSize() { /* * The preferred size is calculated based on the current position of the * component in its animation sequence. If the Component is expanded, then * the preferred size will be the preferred size of the top component plus * the preferred size of the embedded content container. <p>However, if the * scroll up is in any state of animation, the height component of the * preferred size will be the current height of the component (as contained * in the currentHeight variable) */ Dimension dim; if (!isAnimated()) { if (getContentPane().isVisible()) { dim = getContentPane().getPreferredSize(); } else { dim = super.getPreferredSize(); } } else { dim = new Dimension(getContentPane().getPreferredSize()); if (!getContentPane().isVisible() && currentHeight != -1) { dim.height = currentHeight; } } return dim; }
void jButtonWeights_actionPerformed(ActionEvent e) { NumberGeneratorDialog dlg = new NumberGeneratorDialog( (Frame) null, "Weights", "Weight of synaptic connections", mySynProps.getWeightsGenerator(), true); // Center the window Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); Dimension frameSize = dlg.getSize(); if (frameSize.height > screenSize.height) { frameSize.height = screenSize.height; } if (frameSize.width > screenSize.width) { frameSize.width = screenSize.width; } dlg.setLocation( (screenSize.width - frameSize.width) / 2, (screenSize.height - frameSize.height) / 2); dlg.setVisible(true); jTextFieldWeights.setText(mySynProps.getWeightsGenerator().toShortString()); // mySynProps.setWeightsGenerator(dlg.getFinalNumGen()); }
/* * This method is called every time: * - to make sure the viewport is returned to its default position * - to remove the horizontal scrollbar when it is not wanted */ private void checkHorizontalScrollBar(BasicComboPopup popup) { // Reset the viewport to the left JViewport viewport = scrollPane.getViewport(); Point p = viewport.getViewPosition(); p.x = 0; viewport.setViewPosition(p); // Remove the scrollbar so it is never painted if (!scrollBarRequired) { scrollPane.setHorizontalScrollBar(null); return; } // Make sure a horizontal scrollbar exists in the scrollpane JScrollBar horizontal = scrollPane.getHorizontalScrollBar(); if (horizontal == null) { horizontal = new JScrollBar(JScrollBar.HORIZONTAL); scrollPane.setHorizontalScrollBar(horizontal); scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED); } // Potentially increase height of scroll pane to display the scrollbar if (horizontalScrollBarWillBeVisible(popup, scrollPane)) { Dimension scrollPaneSize = scrollPane.getPreferredSize(); scrollPaneSize.height += horizontal.getPreferredSize().height; scrollPane.setPreferredSize(scrollPaneSize); scrollPane.setMaximumSize(scrollPaneSize); scrollPane.revalidate(); } }
/** * Returns the preferred size of the viewport for a view component. For example the preferredSize * of a JList component is the size required to acommodate all of the cells in its list however * the value of preferredScrollableViewportSize is the size required for * JList.getVisibleRowCount() rows. A component without any properties that would effect the * viewport size should just return getPreferredSize() here. * * @return The preferredSize of a JViewport whose view is this Scrollable. * @see JViewport#getPreferredSize */ public Dimension getPreferredScrollableViewportSize() { Dimension size = getPreferredSize(); Dimension retval = new Dimension(); retval.width = size.width > 600 ? 600 : size.width; retval.height = size.height > 400 ? 400 : size.height; return retval; }
@Override public Dimension getMinimumSize(JComponent c) { AbstractButton b = (AbstractButton) c; String style = (String) c.getClientProperty("Quaqua.Button.style"); if (style == null) { style = "push"; } if (style.equals("help")) { return getPreferredSize(c); } Dimension d = super.getMinimumSize(c); if (isFixedHeight(c)) { Dimension p = getPreferredSize(c); if (d != null && p != null) { d.height = Math.max(d.height, p.height); } } if (!QuaquaUtilities.isSmallSizeVariant(c) && style.equals("push") // && b.getIcon() == null && b.getText() != null) { if (d != null) { d.width = Math.max(d.width, UIManager.getInt("Button.minimumWidth")); } } return d; }
/** * Randomly picks the location of a new window, such that it fits completely on the screen. * * @param desktopPane the desktop pane that the frame is being added to. * @param frame the JInternalFrame which is being added. * @param desiredSize the desired dimensions of the frame. */ private static void setGoodBounds( JInternalFrame frame, JDesktopPane desktopPane, Dimension desiredSize) { RandomUtil randomUtil = RandomUtil.getInstance(); Dimension desktopSize = desktopPane.getSize(); Dimension d = new Dimension(desiredSize); int tx = desktopSize.width - d.width; int ty = desktopSize.height - d.height; if (tx < 0) { tx = 0; d.width = desktopSize.width; } else { tx = (int) (randomUtil.nextDouble() * tx); } if (ty < 0) { ty = 0; d.height = desktopSize.height; } else { ty = (int) (randomUtil.nextDouble() * ty); } frame.setBounds(tx, ty, d.width, d.height); }
public Dimension minimumLayoutSize(Container parent) { Dimension dim = new Dimension(); Insets insets = getInsets(); dim.width = insets.left + insets.right; dim.height = insets.top + insets.bottom; Dimension centerPref = center.getMinimumSize(); dim.width += centerPref.width; dim.height += centerPref.height; Dimension rightPref = right.getMinimumSize(); dim.width += rightPref.width; Dimension bottomPref = bottom.getMinimumSize(); dim.height += bottomPref.height; return dim; }
public Dimension getBorderSize() { if (cc.opts.fullScreen) return new Dimension(0, 0); Insets vpInsets = VncViewer.insets; Dimension borderSize = new Dimension(vpInsets.left + vpInsets.right, vpInsets.top + vpInsets.bottom); if (cc.showToolbar) borderSize.height += 22; return borderSize; }
public Dimension getPreferredSize(JComponent c) { Dimension size; Insets border = progressBar.getInsets(); FontMetrics fontSizer = progressBar.getFontMetrics(progressBar.getFont()); if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) { size = new Dimension(getPreferredInnerHorizontal()); // Ensure that the progress string will fit if (progressBar.isStringPainted()) { // I'm doing this for completeness. String progString = progressBar.getString(); int stringWidth = SwingUtilities2.stringWidth(progressBar, fontSizer, progString); if (stringWidth > size.width) { size.width = stringWidth; } // This uses both Height and Descent to be sure that // there is more than enough room in the progress bar // for everything. // This does have a strange dependency on // getStringPlacememnt() in a funny way. int stringHeight = fontSizer.getHeight() + fontSizer.getDescent(); if (stringHeight > size.height) { size.height = stringHeight; } } } else { size = new Dimension(getPreferredInnerVertical()); // Ensure that the progress string will fit. if (progressBar.isStringPainted()) { String progString = progressBar.getString(); int stringHeight = fontSizer.getHeight() + fontSizer.getDescent(); if (stringHeight > size.width) { size.width = stringHeight; } // This is also for completeness. int stringWidth = SwingUtilities2.stringWidth(progressBar, fontSizer, progString); if (stringWidth > size.height) { size.height = stringWidth; } } } size.width += border.left + border.right; size.height += border.top + border.bottom; return size; }
/** * Returns the preferred size of this component. * * @return the preferred size of this component */ public Dimension getPreferredSize() { Dimension preferredSize = new Dimension(); int preferredHeight; if (treeNode instanceof ContactNode) { UIContact contact = ((ContactNode) treeNode).getContactDescriptor(); preferredHeight = contact.getPreferredHeight(); if (preferredHeight > 0) preferredSize.height = preferredHeight; else if (contact instanceof ShowMoreContact) preferredSize.height = 20; else if (isSelected && treeContactList.isContactButtonsVisible()) preferredSize.height = 70; else preferredSize.height = 35; } else if (treeNode instanceof GroupNode) { UIGroup group = ((GroupNode) treeNode).getGroupDescriptor(); preferredHeight = group.getPreferredHeight(); if (isSelected && customActionButtonsUIGroup != null && !customActionButtonsUIGroup.isEmpty()) preferredSize.height = 70; else if (preferredHeight > 0) preferredSize.height = preferredHeight; else preferredSize.height = 20; } return preferredSize; }
/** The minumum size is the size of the display area plus insets plus the button. */ public Dimension getMinimumSize(JComponent c) { if (!isMinimumSizeDirty) { return new Dimension(cachedMinimumSize); } Dimension size = getDisplaySize(); Insets insets = getInsets(); size.height += insets.top + insets.bottom; if (comboBox.isEditable()) { Insets editorBorderInsets = UIManager.getInsets("ComboBox.editorBorderInsets"); size.width += editorBorderInsets.left + editorBorderInsets.right; // size.height += editorBorderInsets.top + editorBorderInsets.bottom; // The combo editor benefits from extra space for the caret. // To make editable and non-editable equally wide, // we always add 1 pixel. size.width += 1; } else if (arrowButton != null) { Insets arrowButtonInsets = arrowButton.getInsets(); size.width += arrowButtonInsets.left; } int buttonWidth = getEditableButtonWidth(); size.width += insets.left + insets.right + buttonWidth; // Honor corrections made in #paintCurrentValue ListCellRenderer renderer = comboBox.getRenderer(); if (renderer instanceof JComponent) { JComponent component = (JComponent) renderer; Insets rendererInsets = component.getInsets(); Insets editorInsets = UIManager.getInsets("ComboBox.editorInsets"); int offsetLeft = Math.max(0, editorInsets.left - rendererInsets.left); int offsetRight = Math.max(0, editorInsets.right - rendererInsets.right); // int offsetTop = Math.max(0, editorInsets.top - rendererInsets.top); // int offsetBottom = Math.max(0, editorInsets.bottom - rendererInsets.bottom); size.width += offsetLeft + offsetRight; // size.height += offsetTop + offsetBottom; } // The height is oriented on the JTextField height Dimension textFieldSize = PHANTOM.getMinimumSize(); size.height = Math.max(textFieldSize.height, size.height); cachedMinimumSize.setSize(size.width, size.height); isMinimumSizeDirty = false; return new Dimension(size); }
protected void checkMinimumSize() { Dimension d = getDrawingSize(); if (fViewSize.height < d.height || fViewSize.width < d.width) { fViewSize.height = d.height + SCROLL_OFFSET; fViewSize.width = d.width + SCROLL_OFFSET; setSize(fViewSize); } }
public Dimension preferredLayoutSize(Container parent) { Dimension dim = new Dimension(); Dimension captionSize = caption.getPreferredSize(); dim.width = captionSize.width; for (int i = 0; i < pages.length; i++) { Dimension _dim = pages[i].getPreferredSize(); dim.width = Math.max(_dim.width, dim.width); dim.height = Math.max(_dim.height, dim.height); } dim.width += PADDING * 2; dim.height += PADDING * 2; dim.height += nextButton.getPreferredSize().height; dim.height += captionSize.height; return dim; }
private void toggleViewState(final Component component, final boolean visible) { final Dimension size = getSize(); size.height += component.getSize().height * (visible ? -1 : 1); component.setVisible(!visible); setMinimumSize(size); if ((getExtendedState() & Frame.MAXIMIZED_BOTH) != Frame.MAXIMIZED_BOTH) { pack(); } }
public void reshape(int x, int y, int w, int h) { if (inEditMode) { defLoc.x = x; defLoc.y = y; defDim.width = w; defDim.height = h; } curLoc.x = x; curLoc.y = y; curDim.width = w; curDim.height = h; if (!inEditMode) { if ((h != nHeight) || (h < rHeight)) { adjustFont(w, h); } } super.reshape(x, y, w, h); }
public Dimension getMaximumSize(JComponent c) { Dimension pref = getPreferredSize(progressBar); if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) { pref.width = Short.MAX_VALUE; } else { pref.height = Short.MAX_VALUE; } return pref; }