/// <summary>
/// Lays out the specified container using this card layout.
/// <para>
/// Each component in the <code>parent</code> container is reshaped
/// to be the size of the container, minus space for surrounding
/// insets, horizontal gaps, and vertical gaps.
///
/// </para>
/// </summary>
/// <param name="parent"> the parent container in which to do the layout </param>
/// <seealso cref= java.awt.Container#doLayout </seealso>
public virtual void LayoutContainer(Container parent)
{
lock (parent.TreeLock)
{
Insets insets = parent.Insets;
int ncomponents = parent.ComponentCount;
Component comp = null;
bool currentFound = false;
for (int i = 0; i < ncomponents; i++)
{
comp = parent.GetComponent(i);
comp.SetBounds(Hgap_Renamed + insets.Left, Vgap_Renamed + insets.Top, parent.Width_Renamed - (Hgap_Renamed * 2 + insets.Left + insets.Right), parent.Height_Renamed - (Vgap_Renamed * 2 + insets.Top + insets.Bottom));
if (comp.Visible)
{
currentFound = true;
}
}
if (!currentFound && ncomponents > 0)
{
parent.GetComponent(0).Visible = true;
}
}
}
public InsetsTextField(Insets insets)
{
base.\u002Ector();
InsetsTextField insetsTextField = this;
this.setInsets(insets);
((JComponent) this).setEnabled(false);
}
/// <summary>
/// Returns a string representing the state of this
/// <code>ScrollPane</code>. This
/// method is intended to be used only for debugging purposes, and the
/// content and format of the returned string may vary between
/// implementations. The returned string may be empty but may not be
/// <code>null</code>.
/// </summary>
/// <returns> the parameter string of this scroll pane </returns>
public override String ParamString()
{
String sdpStr;
switch (ScrollbarDisplayPolicy_Renamed)
{
case SCROLLBARS_AS_NEEDED:
sdpStr = "as-needed";
break;
case SCROLLBARS_ALWAYS:
sdpStr = "always";
break;
case SCROLLBARS_NEVER:
sdpStr = "never";
break;
default:
sdpStr = "invalid display policy";
break;
}
Point p = (ComponentCount > 0)? ScrollPosition : new Point(0, 0);
Insets i = Insets;
return(base.ParamString() + ",ScrollPosition=(" + p.x + "," + p.y + ")" + ",Insets=(" + i.Top + "," + i.Left + "," + i.Bottom + "," + i.Right + ")" + ",ScrollbarDisplayPolicy=" + sdpStr + ",wheelScrollingEnabled=" + WheelScrollingEnabled);
}
/// <summary>
/// Calculates the minimum size for the specified panel. </summary>
/// <param name="parent"> the parent container in which to do the layout </param>
/// <returns> the minimum dimensions required to lay out the
/// subcomponents of the specified container </returns>
/// <seealso cref= java.awt.Container#doLayout </seealso>
/// <seealso cref= java.awt.CardLayout#preferredLayoutSize </seealso>
public virtual Dimension MinimumLayoutSize(Container parent)
{
lock (parent.TreeLock)
{
Insets insets = parent.Insets;
int ncomponents = parent.ComponentCount;
int w = 0;
int h = 0;
for (int i = 0; i < ncomponents; i++)
{
Component comp = parent.GetComponent(i);
Dimension d = comp.MinimumSize;
if (d.Width_Renamed > w)
{
w = d.Width_Renamed;
}
if (d.Height_Renamed > h)
{
h = d.Height_Renamed;
}
}
return(new Dimension(insets.Left + insets.Right + w + Hgap_Renamed * 2, insets.Top + insets.Bottom + h + Vgap_Renamed * 2));
}
}
/// <summary>
/// Determines the minimum size of the container argument using this
/// grid layout.
/// <para>
/// The minimum width of a grid layout is the largest minimum width
/// of all of the components in the container times the number of columns,
/// plus the horizontal padding times the number of columns minus one,
/// plus the left and right insets of the target container.
/// </para>
/// <para>
/// The minimum height of a grid layout is the largest minimum height
/// of all of the components in the container times the number of rows,
/// plus the vertical padding times the number of rows minus one, plus
/// the top and bottom insets of the target container.
///
/// </para>
/// </summary>
/// <param name="parent"> the container in which to do the layout </param>
/// <returns> the minimum dimensions needed to lay out the
/// subcomponents of the specified container </returns>
/// <seealso cref= java.awt.GridLayout#preferredLayoutSize </seealso>
/// <seealso cref= java.awt.Container#doLayout </seealso>
public virtual Dimension MinimumLayoutSize(Container parent)
{
lock (parent.TreeLock)
{
Insets insets = parent.Insets;
int ncomponents = parent.ComponentCount;
int nrows = Rows_Renamed;
int ncols = Cols;
if (nrows > 0)
{
ncols = (ncomponents + nrows - 1) / nrows;
}
else
{
nrows = (ncomponents + ncols - 1) / ncols;
}
int w = 0;
int h = 0;
for (int i = 0; i < ncomponents; i++)
{
Component comp = parent.GetComponent(i);
Dimension d = comp.MinimumSize;
if (w < d.Width_Renamed)
{
w = d.Width_Renamed;
}
if (h < d.Height_Renamed)
{
h = d.Height_Renamed;
}
}
return(new Dimension(insets.Left + insets.Right + ncols * w + (ncols - 1) * Hgap_Renamed, insets.Top + insets.Bottom + nrows * h + (nrows - 1) * Vgap_Renamed));
}
}
void IMyForm.Show () {
awt.Insets insets = this.getInsets ();
base.setSize (_s.Width + insets.left + insets.right,
_s.Width + insets.top + insets.bottom);
this.show ();
//save the image
//ImageIO.write((java.awt.image.RenderedImage)_image, "png", new java.io.File("test.java.png"));
}
/// <summary>
/// Checks whether two insets objects are equal. Two instances
/// of <code>Insets</code> are equal if the four integer values
/// of the fields <code>top</code>, <code>left</code>,
/// <code>bottom</code>, and <code>right</code> are all equal. </summary>
/// <returns> <code>true</code> if the two insets are equal;
/// otherwise <code>false</code>.
/// @since JDK1.1 </returns>
public override bool Equals(Object obj)
{
if (obj is Insets)
{
Insets insets = (Insets)obj;
return((Top == insets.Top) && (Left == insets.Left) && (Bottom == insets.Bottom) && (Right == insets.Right));
}
return(false);
}
/// <summary>
/// Creates a <code>GridBagConstraints</code> object with
/// all of its fields set to the passed-in arguments.
///
/// Note: Because the use of this constructor hinders readability
/// of source code, this constructor should only be used by
/// automatic source code generation tools.
/// </summary>
/// <param name="gridx"> The initial gridx value. </param>
/// <param name="gridy"> The initial gridy value. </param>
/// <param name="gridwidth"> The initial gridwidth value. </param>
/// <param name="gridheight"> The initial gridheight value. </param>
/// <param name="weightx"> The initial weightx value. </param>
/// <param name="weighty"> The initial weighty value. </param>
/// <param name="anchor"> The initial anchor value. </param>
/// <param name="fill"> The initial fill value. </param>
/// <param name="insets"> The initial insets value. </param>
/// <param name="ipadx"> The initial ipadx value. </param>
/// <param name="ipady"> The initial ipady value.
/// </param>
/// <seealso cref= java.awt.GridBagConstraints#gridx </seealso>
/// <seealso cref= java.awt.GridBagConstraints#gridy </seealso>
/// <seealso cref= java.awt.GridBagConstraints#gridwidth </seealso>
/// <seealso cref= java.awt.GridBagConstraints#gridheight </seealso>
/// <seealso cref= java.awt.GridBagConstraints#weightx </seealso>
/// <seealso cref= java.awt.GridBagConstraints#weighty </seealso>
/// <seealso cref= java.awt.GridBagConstraints#anchor </seealso>
/// <seealso cref= java.awt.GridBagConstraints#fill </seealso>
/// <seealso cref= java.awt.GridBagConstraints#insets </seealso>
/// <seealso cref= java.awt.GridBagConstraints#ipadx </seealso>
/// <seealso cref= java.awt.GridBagConstraints#ipady
///
/// @since 1.2 </seealso>
public GridBagConstraints(int gridx, int gridy, int gridwidth, int gridheight, double weightx, double weighty, int anchor, int fill, Insets insets, int ipadx, int ipady)
{
this.Gridx = gridx;
this.Gridy = gridy;
this.Gridwidth = gridwidth;
this.Gridheight = gridheight;
this.Fill = fill;
this.Ipadx = ipadx;
this.Ipady = ipady;
this.Insets = insets;
this.Anchor = anchor;
this.Weightx = weightx;
this.Weighty = weighty;
}
/// <summary>
/// Returns the minimum dimensions needed to layout the <i>visible</i>
/// components contained in the specified target container. </summary>
/// <param name="target"> the container that needs to be laid out </param>
/// <returns> the minimum dimensions to lay out the
/// subcomponents of the specified container </returns>
/// <seealso cref= #preferredLayoutSize </seealso>
/// <seealso cref= java.awt.Container </seealso>
/// <seealso cref= java.awt.Container#doLayout </seealso>
public virtual Dimension MinimumLayoutSize(Container target)
{
lock (target.TreeLock)
{
bool useBaseline = AlignOnBaseline;
Dimension dim = new Dimension(0, 0);
int nmembers = target.ComponentCount;
int maxAscent = 0;
int maxDescent = 0;
bool firstVisibleComponent = true;
for (int i = 0; i < nmembers; i++)
{
Component m = target.GetComponent(i);
if (m.Visible_Renamed)
{
Dimension d = m.MinimumSize;
dim.Height_Renamed = System.Math.Max(dim.Height_Renamed, d.Height_Renamed);
if (firstVisibleComponent)
{
firstVisibleComponent = false;
}
else
{
dim.Width_Renamed += Hgap_Renamed;
}
dim.Width_Renamed += d.Width_Renamed;
if (useBaseline)
{
int baseline = m.GetBaseline(d.Width_Renamed, d.Height_Renamed);
if (baseline >= 0)
{
maxAscent = System.Math.Max(maxAscent, baseline);
maxDescent = System.Math.Max(maxDescent, dim.Height_Renamed - baseline);
}
}
}
}
if (useBaseline)
{
dim.Height_Renamed = System.Math.Max(maxAscent + maxDescent, dim.Height_Renamed);
}
Insets insets = target.Insets;
dim.Width_Renamed += insets.Left + insets.Right + Hgap_Renamed * 2;
dim.Height_Renamed += insets.Top + insets.Bottom + Vgap_Renamed * 2;
return(dim);
}
}
/// <summary>
/// Creates a <code>GridBagConstraint</code> object with
/// all of its fields set to their default value.
/// </summary>
public GridBagConstraints()
{
Gridx = RELATIVE;
Gridy = RELATIVE;
Gridwidth = 1;
Gridheight = 1;
Weightx = 0;
Weighty = 0;
Anchor = CENTER;
Fill = NONE;
Insets = new Insets(0, 0, 0, 0);
Ipadx = 0;
Ipady = 0;
}
/// <summary>
/// Determines the preferred size of the <code>target</code>
/// container using this layout manager, based on the components
/// in the container.
/// <para>
/// Most applications do not call this method directly. This method
/// is called when a container calls its <code>getPreferredSize</code>
/// method.
/// </para>
/// </summary>
/// <param name="target"> the container in which to do the layout. </param>
/// <returns> the preferred dimensions to lay out the subcomponents
/// of the specified container. </returns>
/// <seealso cref= java.awt.Container </seealso>
/// <seealso cref= java.awt.BorderLayout#minimumLayoutSize </seealso>
/// <seealso cref= java.awt.Container#getPreferredSize() </seealso>
public virtual Dimension PreferredLayoutSize(Container target)
{
lock (target.TreeLock)
{
Dimension dim = new Dimension(0, 0);
bool ltr = target.ComponentOrientation.LeftToRight;
Component c = null;
if ((c = GetChild(EAST, ltr)) != null)
{
Dimension d = c.PreferredSize;
dim.Width_Renamed += d.Width_Renamed + Hgap_Renamed;
dim.Height_Renamed = System.Math.Max(d.Height_Renamed, dim.Height_Renamed);
}
if ((c = GetChild(WEST, ltr)) != null)
{
Dimension d = c.PreferredSize;
dim.Width_Renamed += d.Width_Renamed + Hgap_Renamed;
dim.Height_Renamed = System.Math.Max(d.Height_Renamed, dim.Height_Renamed);
}
if ((c = GetChild(CENTER, ltr)) != null)
{
Dimension d = c.PreferredSize;
dim.Width_Renamed += d.Width_Renamed;
dim.Height_Renamed = System.Math.Max(d.Height_Renamed, dim.Height_Renamed);
}
if ((c = GetChild(NORTH, ltr)) != null)
{
Dimension d = c.PreferredSize;
dim.Width_Renamed = System.Math.Max(d.Width_Renamed, dim.Width_Renamed);
dim.Height_Renamed += d.Height_Renamed + Vgap_Renamed;
}
if ((c = GetChild(SOUTH, ltr)) != null)
{
Dimension d = c.PreferredSize;
dim.Width_Renamed = System.Math.Max(d.Width_Renamed, dim.Width_Renamed);
dim.Height_Renamed += d.Height_Renamed + Vgap_Renamed;
}
Insets insets = target.Insets;
dim.Width_Renamed += insets.Left + insets.Right;
dim.Height_Renamed += insets.Top + insets.Bottom;
return(dim);
}
}
/// <summary>
/// Lays out the container argument using this border layout.
/// <para>
/// This method actually reshapes the components in the specified
/// container in order to satisfy the constraints of this
/// <code>BorderLayout</code> object. The <code>NORTH</code>
/// and <code>SOUTH</code> components, if any, are placed at
/// the top and bottom of the container, respectively. The
/// <code>WEST</code> and <code>EAST</code> components are
/// then placed on the left and right, respectively. Finally,
/// the <code>CENTER</code> object is placed in any remaining
/// space in the middle.
/// </para>
/// <para>
/// Most applications do not call this method directly. This method
/// is called when a container calls its <code>doLayout</code> method.
/// </para>
/// </summary>
/// <param name="target"> the container in which to do the layout. </param>
/// <seealso cref= java.awt.Container </seealso>
/// <seealso cref= java.awt.Container#doLayout() </seealso>
public virtual void LayoutContainer(Container target)
{
lock (target.TreeLock)
{
Insets insets = target.Insets;
int top = insets.Top;
int bottom = target.Height_Renamed - insets.Bottom;
int left = insets.Left;
int right = target.Width_Renamed - insets.Right;
bool ltr = target.ComponentOrientation.LeftToRight;
Component c = null;
if ((c = GetChild(NORTH, ltr)) != null)
{
c.SetSize(right - left, c.Height_Renamed);
Dimension d = c.PreferredSize;
c.SetBounds(left, top, right - left, d.Height_Renamed);
top += d.Height_Renamed + Vgap_Renamed;
}
if ((c = GetChild(SOUTH, ltr)) != null)
{
c.SetSize(right - left, c.Height_Renamed);
Dimension d = c.PreferredSize;
c.SetBounds(left, bottom - d.Height_Renamed, right - left, d.Height_Renamed);
bottom -= d.Height_Renamed + Vgap_Renamed;
}
if ((c = GetChild(EAST, ltr)) != null)
{
c.SetSize(c.Width_Renamed, bottom - top);
Dimension d = c.PreferredSize;
c.SetBounds(right - d.Width_Renamed, top, d.Width_Renamed, bottom - top);
right -= d.Width_Renamed + Hgap_Renamed;
}
if ((c = GetChild(WEST, ltr)) != null)
{
c.SetSize(c.Width_Renamed, bottom - top);
Dimension d = c.PreferredSize;
c.SetBounds(left, top, d.Width_Renamed, bottom - top);
left += d.Width_Renamed + Hgap_Renamed;
}
if ((c = GetChild(CENTER, ltr)) != null)
{
c.SetBounds(left, top, right - left, bottom - top);
}
}
}
public InsetsChooserPanel(Insets current)
{
base.\u002Ector();
InsetsChooserPanel insetsChooserPanel = this;
current = current != null ? current : new Insets(0, 0, 0, 0);
JTextField.__\u003Cclinit\u003E();
this.topValueEditor = new JTextField((Document) new IntegerDocument(), new StringBuffer().append("").append((int) current.top).toString(), 0);
JTextField.__\u003Cclinit\u003E();
this.leftValueEditor = new JTextField((Document) new IntegerDocument(), new StringBuffer().append("").append((int) current.left).toString(), 0);
JTextField.__\u003Cclinit\u003E();
this.bottomValueEditor = new JTextField((Document) new IntegerDocument(), new StringBuffer().append("").append((int) current.bottom).toString(), 0);
JTextField.__\u003Cclinit\u003E();
this.rightValueEditor = new JTextField((Document) new IntegerDocument(), new StringBuffer().append("").append((int) current.right).toString(), 0);
JPanel.__\u003Cclinit\u003E();
JPanel jpanel1 = new JPanel((LayoutManager) new GridBagLayout());
((JComponent) jpanel1).setBorder((Border) new TitledBorder(InsetsChooserPanel.localizationResources.getString("Insets")));
JPanel jpanel2 = jpanel1;
JLabel.__\u003Cclinit\u003E();
JLabel jlabel1 = new JLabel(InsetsChooserPanel.localizationResources.getString("Top"));
GridBagConstraints gridBagConstraints1 = new GridBagConstraints(1, 0, 3, 1, 0.0, 0.0, 10, 0, new Insets(0, 0, 0, 0), 0, 0);
((Container) jpanel2).add((Component) jlabel1, (object) gridBagConstraints1);
((Container) jpanel1).add((Component) new JLabel(" "), (object) new GridBagConstraints(1, 1, 1, 1, 0.0, 0.0, 10, 1, new Insets(0, 12, 0, 12), 8, 0));
((Container) jpanel1).add((Component) this.topValueEditor, (object) new GridBagConstraints(2, 1, 1, 1, 0.0, 0.0, 10, 2, new Insets(0, 0, 0, 0), 0, 0));
((Container) jpanel1).add((Component) new JLabel(" "), (object) new GridBagConstraints(3, 1, 1, 1, 0.0, 0.0, 10, 1, new Insets(0, 12, 0, 11), 8, 0));
JPanel jpanel3 = jpanel1;
JLabel.__\u003Cclinit\u003E();
JLabel jlabel2 = new JLabel(InsetsChooserPanel.localizationResources.getString("Left"));
GridBagConstraints gridBagConstraints2 = new GridBagConstraints(0, 2, 1, 1, 0.0, 0.0, 10, 1, new Insets(0, 4, 0, 4), 0, 0);
((Container) jpanel3).add((Component) jlabel2, (object) gridBagConstraints2);
((Container) jpanel1).add((Component) this.leftValueEditor, (object) new GridBagConstraints(1, 2, 1, 1, 0.0, 0.0, 10, 1, new Insets(0, 0, 0, 0), 0, 0));
((Container) jpanel1).add((Component) new JLabel(" "), (object) new GridBagConstraints(2, 2, 1, 1, 0.0, 0.0, 10, 0, new Insets(0, 12, 0, 12), 8, 0));
((Container) jpanel1).add((Component) this.rightValueEditor, (object) new GridBagConstraints(3, 2, 1, 1, 0.0, 0.0, 10, 2, new Insets(0, 0, 0, 0), 0, 0));
JPanel jpanel4 = jpanel1;
JLabel.__\u003Cclinit\u003E();
JLabel jlabel3 = new JLabel(InsetsChooserPanel.localizationResources.getString("Right"));
GridBagConstraints gridBagConstraints3 = new GridBagConstraints(4, 2, 1, 1, 0.0, 0.0, 10, 0, new Insets(0, 4, 0, 4), 0, 0);
((Container) jpanel4).add((Component) jlabel3, (object) gridBagConstraints3);
((Container) jpanel1).add((Component) this.bottomValueEditor, (object) new GridBagConstraints(2, 3, 1, 1, 0.0, 0.0, 10, 2, new Insets(0, 0, 0, 0), 0, 0));
JPanel jpanel5 = jpanel1;
JLabel.__\u003Cclinit\u003E();
JLabel jlabel4 = new JLabel(InsetsChooserPanel.localizationResources.getString("Bottom"));
GridBagConstraints gridBagConstraints4 = new GridBagConstraints(1, 4, 3, 1, 0.0, 0.0, 10, 0, new Insets(0, 0, 0, 0), 0, 0);
((Container) jpanel5).add((Component) jlabel4, (object) gridBagConstraints4);
((Container) this).setLayout((LayoutManager) new BorderLayout());
((Container) this).add((Component) jpanel1, (object) "Center");
}
/// <summary>
/// Prints the component in this scroll pane. </summary>
/// <param name="g"> the specified Graphics window </param>
/// <seealso cref= Component#print </seealso>
/// <seealso cref= Component#printAll </seealso>
public override void PrintComponents(Graphics g)
{
if (ComponentCount == 0)
{
return;
}
Component c = GetComponent(0);
Point p = c.Location;
Dimension vs = ViewportSize;
Insets i = Insets;
Graphics cg = g.Create();
try
{
cg.ClipRect(i.Left, i.Top, vs.Width_Renamed, vs.Height_Renamed);
cg.Translate(p.x, p.y);
c.PrintAll(cg);
}
finally
{
cg.Dispose();
}
}
public override void paint(java.awt.Graphics g)
{
base.paint(g);
awt.Insets insets = this.getInsets();
g.drawImage(_image, insets.left, insets.top, null);
}
/// <summary>
/// Lays out the specified container using this layout.
/// <para>
/// This method reshapes the components in the specified target
/// container in order to satisfy the constraints of the
/// <code>GridLayout</code> object.
/// </para>
/// <para>
/// The grid layout manager determines the size of individual
/// components by dividing the free space in the container into
/// equal-sized portions according to the number of rows and columns
/// in the layout. The container's free space equals the container's
/// size minus any insets and any specified horizontal or vertical
/// gap. All components in a grid layout are given the same size.
///
/// </para>
/// </summary>
/// <param name="parent"> the container in which to do the layout </param>
/// <seealso cref= java.awt.Container </seealso>
/// <seealso cref= java.awt.Container#doLayout </seealso>
public virtual void LayoutContainer(Container parent)
{
lock (parent.TreeLock)
{
Insets insets = parent.Insets;
int ncomponents = parent.ComponentCount;
int nrows = Rows_Renamed;
int ncols = Cols;
bool ltr = parent.ComponentOrientation.LeftToRight;
if (ncomponents == 0)
{
return;
}
if (nrows > 0)
{
ncols = (ncomponents + nrows - 1) / nrows;
}
else
{
nrows = (ncomponents + ncols - 1) / ncols;
}
// 4370316. To position components in the center we should:
// 1. get an amount of extra space within Container
// 2. incorporate half of that value to the left/top position
// Note that we use trancating division for widthOnComponent
// The reminder goes to extraWidthAvailable
int totalGapsWidth = (ncols - 1) * Hgap_Renamed;
int widthWOInsets = parent.Width_Renamed - (insets.Left + insets.Right);
int widthOnComponent = (widthWOInsets - totalGapsWidth) / ncols;
int extraWidthAvailable = (widthWOInsets - (widthOnComponent * ncols + totalGapsWidth)) / 2;
int totalGapsHeight = (nrows - 1) * Vgap_Renamed;
int heightWOInsets = parent.Height_Renamed - (insets.Top + insets.Bottom);
int heightOnComponent = (heightWOInsets - totalGapsHeight) / nrows;
int extraHeightAvailable = (heightWOInsets - (heightOnComponent * nrows + totalGapsHeight)) / 2;
if (ltr)
{
for (int c = 0, x = insets.Left + extraWidthAvailable; c < ncols; c++, x += widthOnComponent + Hgap_Renamed)
{
for (int r = 0, y = insets.Top + extraHeightAvailable; r < nrows; r++, y += heightOnComponent + Vgap_Renamed)
{
int i = r * ncols + c;
if (i < ncomponents)
{
parent.GetComponent(i).SetBounds(x, y, widthOnComponent, heightOnComponent);
}
}
}
}
else
{
for (int c = 0, x = (parent.Width_Renamed - insets.Right - widthOnComponent) - extraWidthAvailable; c < ncols; c++, x -= widthOnComponent + Hgap_Renamed)
{
for (int r = 0, y = insets.Top + extraHeightAvailable; r < nrows; r++, y += heightOnComponent + Vgap_Renamed)
{
int i = r * ncols + c;
if (i < ncomponents)
{
parent.GetComponent(i).SetBounds(x, y, widthOnComponent, heightOnComponent);
}
}
}
}
}
}
/// <summary>
/// Sets margin space between the text component's border
/// and its text.
/// </summary>
public void setMargin(Insets @m)
{
}
/// <summary>
/// Determine the size to allocate the child component.
/// If the viewport area is bigger than the preferred size
/// of the child then the child is allocated enough
/// to fill the viewport, otherwise the child is given
/// it's preferred size.
/// </summary>
internal virtual Dimension CalculateChildSize()
{
//
// calculate the view size, accounting for border but not scrollbars
// - don't use right/bottom insets since they vary depending
// on whether or not scrollbars were displayed on last resize
//
Dimension size = Size;
Insets insets = Insets;
int viewWidth = size.Width_Renamed - insets.Left * 2;
int viewHeight = size.Height_Renamed - insets.Top * 2;
//
// determine whether or not horz or vert scrollbars will be displayed
//
bool vbarOn;
bool hbarOn;
Component child = GetComponent(0);
Dimension childSize = new Dimension(child.PreferredSize);
if (ScrollbarDisplayPolicy_Renamed == SCROLLBARS_AS_NEEDED)
{
vbarOn = childSize.Height_Renamed > viewHeight;
hbarOn = childSize.Width_Renamed > viewWidth;
}
else if (ScrollbarDisplayPolicy_Renamed == SCROLLBARS_ALWAYS)
{
vbarOn = hbarOn = true;
} // SCROLLBARS_NEVER
else
{
vbarOn = hbarOn = false;
}
//
// adjust predicted view size to account for scrollbars
//
int vbarWidth = VScrollbarWidth;
int hbarHeight = HScrollbarHeight;
if (vbarOn)
{
viewWidth -= vbarWidth;
}
if (hbarOn)
{
viewHeight -= hbarHeight;
}
//
// if child is smaller than view, size it up
//
if (childSize.Width_Renamed < viewWidth)
{
childSize.Width_Renamed = viewWidth;
}
if (childSize.Height_Renamed < viewHeight)
{
childSize.Height_Renamed = viewHeight;
}
return(childSize);
}
/// <summary>
/// Returns an <code>Insets</code> object containing this
/// <code>JViewport</code>s inset values.
/// </summary>
public Insets getInsets(Insets @insets)
{
return default(Insets);
}
public virtual void setInsets(Insets insets)
{
((JTextComponent) this).setText(this.formatInsetsString(insets));
}
/// <summary>
/// Lays out the container. This method lets each
/// <i>visible</i> component take
/// its preferred size by reshaping the components in the
/// target container in order to satisfy the alignment of
/// this <code>FlowLayout</code> object.
/// </summary>
/// <param name="target"> the specified component being laid out </param>
/// <seealso cref= Container </seealso>
/// <seealso cref= java.awt.Container#doLayout </seealso>
public virtual void LayoutContainer(Container target)
{
lock (target.TreeLock)
{
Insets insets = target.Insets;
int maxwidth = target.Width_Renamed - (insets.Left + insets.Right + Hgap_Renamed * 2);
int nmembers = target.ComponentCount;
int x = 0, y = insets.Top + Vgap_Renamed;
int rowh = 0, start = 0;
bool ltr = target.ComponentOrientation.LeftToRight;
bool useBaseline = AlignOnBaseline;
int[] ascent = null;
int[] descent = null;
if (useBaseline)
{
ascent = new int[nmembers];
descent = new int[nmembers];
}
for (int i = 0; i < nmembers; i++)
{
Component m = target.GetComponent(i);
if (m.Visible)
{
Dimension d = m.PreferredSize;
m.SetSize(d.Width_Renamed, d.Height_Renamed);
if (useBaseline)
{
int baseline = m.GetBaseline(d.Width_Renamed, d.Height_Renamed);
if (baseline >= 0)
{
ascent[i] = baseline;
descent[i] = d.Height_Renamed - baseline;
}
else
{
ascent[i] = -1;
}
}
if ((x == 0) || ((x + d.Width_Renamed) <= maxwidth))
{
if (x > 0)
{
x += Hgap_Renamed;
}
x += d.Width_Renamed;
rowh = System.Math.Max(rowh, d.Height_Renamed);
}
else
{
rowh = MoveComponents(target, insets.Left + Hgap_Renamed, y, maxwidth - x, rowh, start, i, ltr, useBaseline, ascent, descent);
x = d.Width_Renamed;
y += Vgap_Renamed + rowh;
rowh = d.Height_Renamed;
start = i;
}
}
}
MoveComponents(target, insets.Left + Hgap_Renamed, y, maxwidth - x, rowh, start, nmembers, ltr, useBaseline, ascent, descent);
}
}
public virtual string formatInsetsString(Insets insets)
{
insets = insets != null ? insets : new Insets(0, 0, 0, 0);
return new StringBuffer().append(InsetsTextField.localizationResources.getString("T")).append((int) insets.top).append(", ").append(InsetsTextField.localizationResources.getString("L")).append((int) insets.left).append(", ").append(InsetsTextField.localizationResources.getString("B")).append((int) insets.bottom).append(", ").append(InsetsTextField.localizationResources.getString("R")).append((int) insets.right).toString();
}