public void layoutContainer(Container target) {
int barwidth = 0;
int i;
for (i = 1; i < target.getComponentCount(); i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getPreferredSize();
if (d.width > barwidth) barwidth = d.width;
}
}
Insets insets = target.insets();
int targetw = target.size().width - insets.left - insets.right;
int cw = targetw - barwidth;
int targeth = target.size().height - (insets.top + insets.bottom);
target.getComponent(0).move(insets.left, insets.top);
target.getComponent(0).resize(cw, targeth);
cw += insets.left;
int h = insets.top;
for (i = 1; i < target.getComponentCount(); i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getPreferredSize();
if (m instanceof DecentScrollbar || m instanceof TextComponent) d.width = barwidth;
if (m instanceof Choice && d.width > barwidth) d.width = barwidth;
if (m instanceof Label) {
h += d.height / 5;
d.width = barwidth;
}
m.move(cw, h);
m.resize(d.width, d.height);
h += d.height;
}
}
}
public Dimension preferredLayoutSize(Container parent) {
Insets insets = parent.getInsets();
Dimension maxSize = new Dimension(insets.left + insets.right, insets.top + insets.bottom);
for (int i = 0; i < parent.getComponentCount(); i++) {
Dimension ps = parent.getComponent(i).getPreferredSize();
maxSize.width += ps.width - (i < parent.getComponentCount() - 1 ? overlap : 0);
maxSize.height = Math.max(maxSize.height, insets.top + ps.height + insets.bottom);
}
return maxSize;
}
public void layoutContainer(Container target) {
Insets insets = target.getInsets();
int ncomponents = target.getComponentCount();
int top = 0;
int left = insets.left;
Dimension tps = target.getPreferredSize();
Dimension targetSize = target.getSize();
Component comp;
Dimension ps;
if (horizontalOrientation == Orientation.CENTER)
left = left + (targetSize.width / 2) - (tps.width / 2);
if (horizontalOrientation == Orientation.RIGHT) left = left + targetSize.width - tps.width;
for (int i = 0; i < ncomponents; i++) {
comp = target.getComponent(i);
if (comp.isVisible()) {
ps = comp.getPreferredSize();
if (verticalOrientation == Orientation.CENTER)
top = (targetSize.height / 2) - (ps.height / 2);
else if (verticalOrientation == Orientation.TOP) top = insets.top;
else if (verticalOrientation == Orientation.BOTTOM)
top = targetSize.height - ps.height - insets.bottom;
comp.setBounds(left, top, ps.width, ps.height);
left += ps.width + gap;
}
}
}
@Override
public Dimension preferredLayoutSize(final Container parent) {
synchronized (parent.getTreeLock()) {
final Insets in = parent.getInsets();
final int nr = parent.getComponentCount();
int maxW = 0;
int maxH = 0;
for (int i = 0; i < cols; ++i) {
posX[i] = maxW;
final int w = maxW;
int h = 0;
for (int j = 0; j < rows; ++j) {
final int n = j * cols + i;
if (n >= nr) break;
final Component c = parent.getComponent(n);
final Dimension d = c.getPreferredSize();
if (maxW < w + d.width) maxW = w + d.width;
if (posY[j] < h) posY[j] = h;
else h = posY[j];
h += d.height;
}
if (maxH < h) maxH = h;
}
width = in.left + maxW + (cols - 1) * insetX + in.right;
height = in.top + maxH + (rows - 1) * insetY + in.bottom;
return new Dimension(width, height);
}
}
private final void printComp(final Component comp, final int deep) {
final Rectangle rect = comp.getBounds();
if (L.isInWorkshop) {
System.out.println(
comp.getClass().getName()
+ deep
+ ", x : "
+ rect.x
+ ", y : "
+ rect.y
+ ", w : "
+ rect.width
+ ", h : "
+ rect.height);
}
if (comp instanceof Container) {
final Container container = (Container) comp;
final int count = container.getComponentCount();
for (int i = 0; i < count; i++) {
printComp(container.getComponent(i), deep + 1);
}
} else if (comp instanceof JScrollPane) {
if (L.isInWorkshop) {
System.out.println("------This is JScrollPane-----");
}
printComp(((JScrollPane) comp).getViewport().getView(), deep);
}
}
/**
* Dumps the component constraints to the console.
*
* @param container the layout container to inspect
*/
public static void dumpConstraints(Container container) {
System.out.println("COMPONENT CONSTRAINTS");
if (!(container.getLayout() instanceof FormLayout)) {
System.out.println("The container's layout is not a FormLayout.");
return;
}
FormLayout layout = (FormLayout) container.getLayout();
int childCount = container.getComponentCount();
for (int i = 0; i < childCount; i++) {
Component child = container.getComponent(i);
CellConstraints cc = layout.getConstraints(child);
String ccString = cc == null ? "no constraints" : cc.toShortString(layout);
System.out.print(ccString);
System.out.print("; ");
String childType = child.getClass().getName();
System.out.print(childType);
if (child instanceof JLabel) {
JLabel label = (JLabel) child;
System.out.print(" \"" + label.getText() + "\"");
}
if (child.getName() != null) {
System.out.print("; name=");
System.out.print(child.getName());
}
System.out.println();
}
System.out.println();
}
private void setSizes(Container parent) {
int nComps = parent.getComponentCount();
Dimension d = null;
// Reset preferred/minimum width and height.
preferredWidth = 0;
preferredHeight = 0;
minWidth = 0;
minHeight = 0;
for (int i = 0; i < nComps; i++) {
Component c = parent.getComponent(i);
if (c.isVisible()) {
d = c.getPreferredSize();
if (i > 0) {
preferredWidth += d.width / 2;
preferredHeight += vgap;
} else {
preferredWidth = d.width;
}
preferredHeight += d.height;
minWidth = Math.max(c.getMinimumSize().width, minWidth);
minHeight = preferredHeight;
}
}
}
/*--------------------------------------------------------------------------*/
public Dimension preferredLayoutSize(Container target) {
synchronized (target.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
int nmembers = target.getComponentCount();
boolean firstVisibleComponent = true;
for (int i = 0; i < nmembers; i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getPreferredSize();
dim.height = Math.max(dim.height, d.height);
if (firstVisibleComponent) {
firstVisibleComponent = false;
} else {
dim.width += hgap;
}
dim.width += d.width;
}
}
Insets insets = target.getInsets();
dim.width += insets.left + insets.right + hgap * 2;
dim.height += insets.top + insets.bottom + vgap * 2;
return (dim);
}
}
public Dimension minimumLayoutSize(Container target) {
Dimension dim = new Dimension(0, 0);
int nmembers = target.getComponentCount();
for (int i = 0; i < nmembers; i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getMinimumSize();
if (fVerticalLayout) {
dim.width = Math.max(dim.width, d.width);
if (i > 0) {
dim.height += fGap;
}
dim.height += d.height;
} else {
dim.height = Math.max(dim.height, d.height);
if (i > 0) {
dim.width += fGap;
}
dim.width += d.width;
}
}
}
Insets insets = target.getInsets();
dim.width += insets.left + insets.right;
dim.width += 2 * fBorder.x;
dim.height += insets.top + insets.bottom;
dim.height += 2 * fBorder.y;
return dim;
}
/**
* Lays out the container in the specified container.
*
* @param parent the component which needs to be laid out
*/
public void layoutContainer(Container parent) {
synchronized (parent.getTreeLock()) {
Insets insets = parent.getInsets();
int ncomponents = parent.getComponentCount();
if (ncomponents == 0) {
return;
}
// Total parent dimensions
Dimension size = parent.getSize();
int totalW = size.width - (insets.left + insets.right);
int totalH = size.height - (insets.top + insets.bottom);
// Cell dimensions, including padding
int totalCellW = totalW / gridSize.width;
int totalCellH = totalH / gridSize.height;
// Cell dimensions, without padding
int cellW = (totalW - ((gridSize.width + 1) * hgap)) / gridSize.width;
int cellH = (totalH - ((gridSize.height + 1) * vgap)) / gridSize.height;
for (int i = 0; i < ncomponents; i++) {
Component c = parent.getComponent(i);
Rectangle rect = (Rectangle) compTable.get(c);
if (rect != null) {
int x = insets.left + (totalCellW * rect.x) + hgap;
int y = insets.top + (totalCellH * rect.y) + vgap;
int w = (cellW * rect.width) - hgap;
int h = (cellH * rect.height) - vgap;
c.setBounds(x, y, w, h);
}
}
}
}
/**
* Called to change the visibility of the outline.
*
* @param value true if visible.
*/
public void setVisible(final boolean value) {
if (value != isVisible()) {
super.setVisible(value);
Container parent = getParent();
if ((parent != null) && (parent.getComponentCount() == 1)) {
parent.setVisible(value);
}
invalidate();
try {
for (; parent != null; parent = parent.getParent()) {
try {
parent.getClass().getMethod("resetToPreferredSizes", null).invoke(parent, null);
visibleArgs[0] = new Integer(value ? 10 : 0);
parent.getClass().getMethod("setDividerSize", visibleParms).invoke(parent, visibleArgs);
break;
} catch (final Throwable ignored) {
}
}
} catch (final Throwable ignored) {
}
djvuBean.recursiveRevalidate();
}
}
public void layoutContainer(Container parent) {
synchronized (parent.getTreeLock()) {
DiagramView diagramView = (DiagramView) parent;
DesignView designView = diagramView.getDesignView();
double k = designView.getCorrectedZoom();
FBounds bounds = diagramView.getContentSize();
int offsetX = (int) Math.round((diagramView.getWidth() - bounds.width * k) / 2.0);
int offsetY = (int) Math.round((diagramView.getHeight() - bounds.height * k) / 2.0);
diagramView.setOffsets(offsetX, offsetY);
if (parent.getComponentCount() > 0) {
repositionDecorations(parent);
}
// Component component = parent.getComponent(0);
// if (!(component instanceof NavigationTools)) {
// return;
// }
// component.setBounds(0, 0, parent.getWidth(), parent.getHeight());
}
}
/**
* Sets the font for a component and all components contained within it.
*
* @param c the parent component of the component subtree to set
* @param font the font to set
*/
public static void setFont(Component c, Font font) {
c.setFont(font);
if (c instanceof Container) {
Container con = (Container) c;
for (int i = 0; i < con.getComponentCount(); ++i) setFont(con.getComponent(i), font);
}
}
@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 void setSizes(Container parent) {
if (sizesSet) return;
int n = parent.getComponentCount();
preferredWidth = 0;
preferredHeight = 0;
minWidth = 0;
minHeight = 0;
maxComponentWidth = 0;
maxComponentHeight = 0;
// compute the maximum component widths and heights
// and set the preferred size to the sum of the component sizes.
for (int i = 0; i < n; i++) {
Component c = parent.getComponent(i);
if (c.isVisible()) {
Dimension d = c.getPreferredSize();
maxComponentWidth = Math.max(maxComponentWidth, d.width);
maxComponentHeight = Math.max(maxComponentHeight, d.height);
preferredWidth += d.width;
preferredHeight += d.height;
}
}
minWidth = preferredWidth / 2;
minHeight = preferredHeight / 2;
sizesSet = true;
}
/**
* Calculates the preferred size dimensions for the specified panel given the components in the
* specified parent container.
*
* @param target The component to be laid out.
* @return A size deemed suitable for laying out the container.
* @see #minimumLayoutSize
*/
public Dimension preferredLayoutSize(Container target) {
int count;
Component component;
Dimension dimension;
Insets insets;
Dimension ret;
synchronized (target.getTreeLock()) {
// get the the total height and maximum width component
ret = new Dimension(0, 0);
count = target.getComponentCount();
for (int i = 0; i < count; i++) {
component = target.getComponent(i);
if (component.isVisible()) {
dimension = component.getPreferredSize();
ret.width = Math.max(ret.width, dimension.width);
ret.height += dimension.height;
}
}
insets = target.getInsets();
ret.width += insets.left + insets.right;
ret.height += insets.top + insets.bottom;
}
return (ret);
}
/**
* Checks the component and all children to ensure that everything is pure Swing. We can only draw
* lightweights.
*
* <p>We'll also set PopupMenus to heavyweight and fix JViewport blitting.
*/
protected void verifyHierarchy(Component comp) {
JPopupMenu.setDefaultLightWeightPopupEnabled(false);
if (comp instanceof JComponent) {
((JComponent) comp).setDoubleBuffered(false);
}
if (!(comp instanceof JComponent)) {
Logger.getLogger(GLG2DCanvas.class.getName())
.warning(
"Drawable component and children should be pure Swing: "
+ comp
+ " does not inherit JComponent");
}
if (comp instanceof JViewport) {
((JViewport) comp).setScrollMode(JViewport.SIMPLE_SCROLL_MODE);
}
if (comp instanceof Container) {
Container cont = (Container) comp;
for (int i = 0; i < cont.getComponentCount(); i++) {
verifyHierarchy(cont.getComponent(i));
}
}
}
private boolean is(boolean first) {
Container parent = getParent();
if (parent == null) return false;
int max = first ? Integer.MAX_VALUE : 0;
ToolWindowAnchor anchor = getAnchor();
Component c = null;
int count = parent.getComponentCount();
for (int i = 0; i < count; i++) {
Component component = parent.getComponent(i);
if (!component.isVisible()) continue;
Rectangle r = component.getBounds();
if (anchor == ToolWindowAnchor.LEFT || anchor == ToolWindowAnchor.RIGHT) {
if (first && (max > r.y) || (!first && max < r.y)) {
max = r.y;
c = component;
}
} else {
if (first && (max > r.x) || (!first && max < r.x)) {
max = r.x;
c = component;
}
}
}
return c == this;
}
private void setSizes(Container parent) {
int nComps = parent.getComponentCount();
this.preferredWidth = 0;
this.preferredHeight = 0;
this.minWidth = 0;
this.minHeight = 0;
for (int i = 0; i < nComps; i++) {
Component c = parent.getComponent(i);
if (c.isVisible()) {
Dimension d = c.getPreferredSize();
if (this.maxCompWidth < d.width) {
this.maxCompWidth = d.width;
}
if (this.maxCompHeight < d.height) {
this.maxCompHeight = d.height;
}
this.preferredWidth += d.width;
this.preferredHeight += d.height;
}
}
this.preferredWidth /= 2;
this.preferredHeight /= 2;
this.minWidth = this.preferredWidth;
this.minHeight = this.preferredHeight;
}
public Dimension preferredLayoutSize(Container target) {
Insets insets = target.getInsets();
Dimension compMax = new Dimension(0, 0);
int maxheight = target.getBounds().height - (insets.top + insets.bottom + vgap * 2);
int nmembers = target.getComponentCount();
int visiblecount = 0;
for (int i = 0; i < nmembers; i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
++visiblecount;
Dimension d = m.getPreferredSize();
compMax.width = Math.max(compMax.width, d.width);
compMax.height = Math.max(compMax.height, d.height);
}
}
if (visiblecount > 0) {
int nrows = Math.max(1, (maxheight + compMax.height / 4) / compMax.height);
int ncols = (visiblecount + nrows - 1) / nrows;
compMax.height = compMax.height * nrows + vgap * (nrows - 1);
compMax.width = compMax.width * ncols + hgap * (ncols - 1);
}
compMax.height += insets.top + insets.bottom + vgap * 2;
compMax.width += insets.left + insets.right + hgap * 2;
return compMax;
}
/**
* Replace the current contents of the frame's content pane.
*
* @param panel JPanel of the new contents of the content pane.
*/
public void replace(JPanel panel) {
// Removes everything from the content pane.
for (int i = 0; i < pane.getComponentCount(); i++) {
pane.remove(i);
}
pane.add(panel);
}
/**
* Sets the foreground and background color for a component and all components contained within
* it.
*
* @param c the parent component of the component subtree to set
* @param back the background color to set
* @param fore the foreground color to set
*/
public static void setColor(Component c, Color back, Color fore) {
c.setBackground(back);
c.setForeground(fore);
if (c instanceof Container) {
Container con = (Container) c;
for (int i = 0; i < con.getComponentCount(); ++i) setColor(con.getComponent(i), back, fore);
}
}
private void wireDragAndDrop(Component comp) {
comp.setDropTarget(new DropTarget(this, new JitterbugDropHandler()));
if (comp instanceof Container) {
Container cont = (Container) comp;
for (int i = 0; i < cont.getComponentCount(); i++) {
wireDragAndDrop(cont.getComponent(i));
}
}
}
public static final Component getChildAtLine(
Container container, Point point, boolean horizontal) {
if (horizontal) {
for (int i = 0; i < container.getComponentCount(); i++) {
Component component = container.getComponent(i);
if (point.x >= component.getX() && point.x < component.getX() + component.getWidth())
return component;
}
} else {
for (int i = 0; i < container.getComponentCount(); i++) {
Component component = container.getComponent(i);
if (point.y >= component.getY() && point.y < component.getY() + component.getHeight())
return component;
}
}
return null;
}
public static void setAllOpaque(Container container, boolean opaque) {
if (container instanceof JComponent) {
((JComponent) container).setOpaque(opaque);
for (int i = 0; i < container.getComponentCount(); i++) {
Component component = container.getComponent(i);
if (component instanceof Container) setAllOpaque((Container) component, opaque);
}
}
}
public static void recursiveSetBackground(Component comp, Color color) {
if (comp instanceof JToolBar || comp instanceof JButton) return;
comp.setBackground(color);
if (comp instanceof Container) {
Container cc = (Container) comp;
for (int i = 0; i < cc.getComponentCount(); i++)
recursiveSetBackground(cc.getComponent(i), color);
}
}
protected void setBorderToRollover(Component c) {
if (c instanceof AbstractButton) {
super.setBorderToRollover(c);
} else if (c instanceof Container) {
Container cont = (Container) c;
for (int i = 0; i < cont.getComponentCount(); i++)
super.setBorderToRollover(cont.getComponent(i));
}
}
/**
* <code>PlanWorks</code> - constructor
*
* @param constantMenus - <code>JMenu[]</code> -
*/
public PlanWorks(JMenu[] constantMenus) {
super(name, constantMenus);
projectMenu.setEnabled(false);
currentProjectName = "";
currentProject = null;
viewManager = null;
sequenceDirChooser = new DirectoryChooser();
createDirectoryChooser();
// Closes from title bar
addWindowListener(
new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
if (isMaxScreen) {
Rectangle maxRectangle =
GraphicsEnvironment.getLocalGraphicsEnvironment().getMaximumWindowBounds();
this.setSize((int) maxRectangle.getWidth(), (int) maxRectangle.getHeight());
this.setLocation(0, 0);
} else {
this.setSize(DESKTOP_FRAME_WIDTH, DESKTOP_FRAME_HEIGHT);
this.setLocation(FRAME_X_LOCATION, FRAME_Y_LOCATION);
}
Container contentPane = getContentPane();
for (int i = 0, n = contentPane.getComponentCount(); i < n; i++) {
// System.err.println( "i " + i + " " +
// contentPane.getComponent( i).getClass().getName());
if (contentPane.getComponent(i) instanceof MDIDesktopPane) {
((MDIDesktopPane) contentPane.getComponent(i))
.setBackground(ViewConstants.VIEW_BACKGROUND_COLOR);
break;
}
}
supportedViewNames = Utilities.sortStringKeySet(viewClassNameMap);
this.setVisible(true);
if (usingSplash) {
this.toBack();
}
setProjectMenuEnabled(CREATE_MENU_ITEM, true);
setProjectMenuEnabled(ADDSEQ_MENU_ITEM, false);
setProjectMenuEnabled(DELSEQ_MENU_ITEM, false);
if ((PwProject.listProjects() != null) && (PwProject.listProjects().size() > 0)) {
setProjectMenuEnabled(OPEN_MENU_ITEM, true);
setProjectMenuEnabled(DELETE_MENU_ITEM, true);
} else {
setProjectMenuEnabled(OPEN_MENU_ITEM, false);
setProjectMenuEnabled(DELETE_MENU_ITEM, false);
}
projectMenu.setEnabled(true);
windowBuilt = true;
if (usingSplash) {
this.toFront();
}
} // end constructor
public void layoutContainer(Container parent) {
Dimension ourSize = preferredLayoutSize(parent),
// Does the following do something useful?
// And shouldn't we cater to real instead of maximum sizes?
// This way, if a VerticallyLaidout component had a particular size forced upon it,
// wouldn't we neglect to scale down to using minimum sizes so long as its maximum
// size was bigger than our preferred? all: [Davis]
maxSize = parent.getMaximumSize(),
size = parent.getSize();
Insets isets = parent.getInsets();
Dimension compSize;
int n = parent.getComponentCount();
int y;
boolean usingPreferredSize = true;
if (ourSize.width > maxSize.width || ourSize.height > maxSize.height) {
ourSize = minimumLayoutSize(parent);
usingPreferredSize = false;
}
switch (verticalAlignment) {
case TOP:
y = isets.top;
break;
case BOTTOM:
y = (size.height - ourSize.height);
break;
default: // assume MIDDLE
y = (size.height - ourSize.height) / 2 + isets.top;
break;
}
for (int i = 0; i < n; i++) {
Component c = parent.getComponent(i);
compSize = usingPreferredSize ? c.getPreferredSize() : c.getMinimumSize();
switch (horizontalAlignment) {
case LEFT:
c.setBounds(isets.left, y, compSize.width, compSize.height);
break;
case RIGHT:
c.setBounds(
ourSize.width - isets.right - compSize.width + isets.left,
y,
compSize.width,
compSize.height);
break;
default: // assume CENTER
c.setBounds(
(ourSize.width - isets.left - isets.right - compSize.width + isets.left) / 2,
y,
compSize.width,
compSize.height);
}
y += compSize.height + vgap;
}
}
@Override
public Dimension preferredLayoutSize(final Container parent) {
Dimension result = new Dimension();
for (int i = 0; i < parent.getComponentCount(); i++) {
final Dimension prefSize = parent.getComponent(i).getPreferredSize();
result.width += prefSize.width;
result.height = Math.max(prefSize.height, result.height);
}
return result;
}
