/// <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; } } }
/// <summary> /// Flips to the component that was added to this layout with the /// specified <code>name</code>, using <code>addLayoutComponent</code>. /// If no such component exists, then nothing happens. </summary> /// <param name="parent"> the parent container in which to do the layout </param> /// <param name="name"> the component name </param> /// <seealso cref= java.awt.CardLayout#addLayoutComponent(java.awt.Component, java.lang.Object) </seealso> public virtual void Show(Container parent, String name) { lock (parent.TreeLock) { CheckLayout(parent); Component next = null; int ncomponents = Vector.Count; for (int i = 0; i < ncomponents; i++) { Card card = (Card)Vector[i]; if (card.Name.Equals(name)) { next = card.Comp; CurrentCard = i; break; } } if ((next != null) && !next.Visible) { ncomponents = parent.ComponentCount; for (int i = 0; i < ncomponents; i++) { Component comp = parent.GetComponent(i); if (comp.Visible) { comp.Visible = false; break; } } next.Visible = true; parent.Validate(); } } }
/// <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)); } }
internal virtual void ShowDefaultComponent(Container parent) { if (parent.ComponentCount > 0) { CurrentCard = 0; parent.GetComponent(0).Visible = true; parent.Validate(); } }
/// <summary> /// Flips to the previous card of the specified container. If the /// currently visible card is the first one, this method flips to the /// last card in the layout. </summary> /// <param name="parent"> the parent container in which to do the layout </param> /// <seealso cref= java.awt.CardLayout#next </seealso> public virtual void Previous(Container parent) { lock (parent.TreeLock) { CheckLayout(parent); int ncomponents = parent.ComponentCount; for (int i = 0; i < ncomponents; i++) { Component comp = parent.GetComponent(i); if (comp.Visible) { comp.Visible = false; CurrentCard = ((i > 0) ? i - 1 : ncomponents - 1); comp = parent.GetComponent(CurrentCard); comp.Visible = true; parent.Validate(); return; } } ShowDefaultComponent(parent); } }
/// <summary> /// Flips to the last card of the container. </summary> /// <param name="parent"> the parent container in which to do the layout </param> /// <seealso cref= java.awt.CardLayout#first </seealso> public virtual void Last(Container parent) { lock (parent.TreeLock) { CheckLayout(parent); int ncomponents = parent.ComponentCount; for (int i = 0; i < ncomponents; i++) { Component comp = parent.GetComponent(i); if (comp.Visible) { comp.Visible = false; break; } } if (ncomponents > 0) { CurrentCard = ncomponents - 1; parent.GetComponent(CurrentCard).Visible = true; parent.Validate(); } } }
/// <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> /// 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> /// 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); } }
/// <summary> /// Centers the elements in the specified row, if there is any slack. </summary> /// <param name="target"> the component which needs to be moved </param> /// <param name="x"> the x coordinate </param> /// <param name="y"> the y coordinate </param> /// <param name="width"> the width dimensions </param> /// <param name="height"> the height dimensions </param> /// <param name="rowStart"> the beginning of the row </param> /// <param name="rowEnd"> the the ending of the row </param> /// <param name="useBaseline"> Whether or not to align on baseline. </param> /// <param name="ascent"> Ascent for the components. This is only valid if /// useBaseline is true. </param> /// <param name="descent"> Ascent for the components. This is only valid if /// useBaseline is true. </param> /// <returns> actual row height </returns> private int MoveComponents(Container target, int x, int y, int width, int height, int rowStart, int rowEnd, bool ltr, bool useBaseline, int[] ascent, int[] descent) { switch (NewAlign) { case LEFT: x += ltr ? 0 : width; break; case CENTER: x += width / 2; break; case RIGHT: x += ltr ? width : 0; break; case LEADING: break; case TRAILING: x += width; break; } int maxAscent = 0; int nonbaselineHeight = 0; int baselineOffset = 0; if (useBaseline) { int maxDescent = 0; for (int i = rowStart; i < rowEnd; i++) { Component m = target.GetComponent(i); if (m.Visible_Renamed) { if (ascent[i] >= 0) { maxAscent = System.Math.Max(maxAscent, ascent[i]); maxDescent = System.Math.Max(maxDescent, descent[i]); } else { nonbaselineHeight = System.Math.Max(m.Height, nonbaselineHeight); } } } height = System.Math.Max(maxAscent + maxDescent, nonbaselineHeight); baselineOffset = (height - maxAscent - maxDescent) / 2; } for (int i = rowStart; i < rowEnd; i++) { Component m = target.GetComponent(i); if (m.Visible) { int cy; if (useBaseline && ascent[i] >= 0) { cy = y + baselineOffset + maxAscent - ascent[i]; } else { cy = y + (height - m.Height_Renamed) / 2; } if (ltr) { m.SetLocation(x, cy); } else { m.SetLocation(target.Width_Renamed - x - m.Width_Renamed, cy); } x += m.Width_Renamed + Hgap_Renamed; } } return(height); }