Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / wpf / src / Framework / System / Windows / Controls / Primitives / UniformGrid.cs / 1 / UniformGrid.cs
//----------------------------------------------------------------------------
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//
// File: UniformGrid.cs
//
// Description: Implementation of a UniformGrid that evenly distributes
// space among its children
//
// NewsClient is defining this Panel because it wants a
// multi-row, multi-column display of news items in the Pod;
// Grid can be databound, but it does not do auto-indexing,
// meaning that all of the generated items would be laid out
// on top of each other. Rather than subclassing Grid to
// introduce this auto-indexing behavior, it seemed more
// straightforward to construct this straightforward panel.
//
// NOTE: this is grabed from JeffBog's NewsClient under
// windows\wcp\DevTest\Demos\NewsClient\Core and add a FirstColumn property.
//
//---------------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
namespace System.Windows.Controls.Primitives
{
///
/// UniformGrid is used to arrange children in a grid with all equal cell sizes.
///
public class UniformGrid : Panel
{
//--------------------------------------------------------------------
//
// Constructors
//
//-------------------------------------------------------------------
#region Constructors
///
/// Default constructor.
///
public UniformGrid()
: base()
{
}
#endregion Constructors
//--------------------------------------------------------------------
//
// Public Properties
//
//--------------------------------------------------------------------
#region Public Properties
///
/// the start column to arrange children. Leave first 'FirstColumn'
/// cells blank.
///
public int FirstColumn
{
get { return (int)GetValue(FirstColumnProperty); }
set { SetValue(FirstColumnProperty, value); }
}
///
/// FirstColumnProperty
///
public static readonly DependencyProperty FirstColumnProperty =
DependencyProperty.Register(
"FirstColumn",
typeof(int),
typeof(UniformGrid),
new FrameworkPropertyMetadata(
(int)0,
FrameworkPropertyMetadataOptions.AffectsMeasure),
new ValidateValueCallback(ValidateFirstColumn));
private static bool ValidateFirstColumn(object o)
{
return (int)o >= 0;
}
///
/// Specifies the number of columns in the grid
/// A value of 0 indicates that the column count should be dynamically
/// computed based on the number of rows (if specified) and the
/// number of non-collapsed children in the grid
///
public int Columns
{
get { return (int)GetValue(ColumnsProperty); }
set { SetValue(ColumnsProperty, value); }
}
///
/// DependencyProperty for
public static readonly DependencyProperty ColumnsProperty =
DependencyProperty.Register(
"Columns",
typeof(int),
typeof(UniformGrid),
new FrameworkPropertyMetadata(
(int)0,
FrameworkPropertyMetadataOptions.AffectsMeasure),
new ValidateValueCallback(ValidateColumns));
private static bool ValidateColumns(object o)
{
return (int)o >= 0;
}
///
/// Specifies the number of rows in the grid
/// A value of 0 indicates that the row count should be dynamically
/// computed based on the number of columns (if specified) and the
/// number of non-collapsed children in the grid
///
public int Rows
{
get { return (int)GetValue(RowsProperty); }
set { SetValue(RowsProperty, value); }
}
///
/// DependencyProperty for
public static readonly DependencyProperty RowsProperty =
DependencyProperty.Register(
"Rows",
typeof(int),
typeof(UniformGrid),
new FrameworkPropertyMetadata(
(int)0,
FrameworkPropertyMetadataOptions.AffectsMeasure),
new ValidateValueCallback(ValidateRows));
private static bool ValidateRows(object o)
{
return (int)o >= 0;
}
#endregion Public Properties
//-------------------------------------------------------------------
//
// Protected Methods
//
//--------------------------------------------------------------------
#region Protected Methods
///
/// Compute the desired size of this UniformGrid by measuring all of the
/// children with a constraint equal to a cell's portion of the given
/// constraint (e.g. for a 2 x 4 grid, the child constraint would be
/// constraint.Width*0.5 x constraint.Height*0.25). The maximum child
/// width and maximum child height are tracked, and then the desired size
/// is computed by multiplying these maximums by the row and column count
/// (e.g. for a 2 x 4 grid, the desired size for the UniformGrid would be
/// maxChildDesiredWidth*2 x maxChildDesiredHeight*4).
///
/// Constraint
/// Desired size
protected override Size MeasureOverride(Size constraint)
{
UpdateComputedValues();
Size childConstraint = new Size(constraint.Width / _columns, constraint.Height / _rows);
double maxChildDesiredWidth = 0.0;
double maxChildDesiredHeight = 0.0;
// Measure each child, keeping track of maximum desired width and height.
for (int i = 0, count = InternalChildren.Count; i < count; ++i)
{
UIElement child = InternalChildren[i];
// Measure the child.
child.Measure(childConstraint);
Size childDesiredSize = child.DesiredSize;
if (maxChildDesiredWidth < childDesiredSize.Width)
{
maxChildDesiredWidth = childDesiredSize.Width;
}
if (maxChildDesiredHeight < childDesiredSize.Height)
{
maxChildDesiredHeight = childDesiredSize.Height;
}
}
return new Size((maxChildDesiredWidth * _columns),(maxChildDesiredHeight * _rows));
}
///
/// Arrange the children of this UniformGrid by distributing space evenly
/// among all of the children, making each child the size equal to a cell's
/// portion of the given arrangeSize (e.g. for a 2 x 4 grid, the child size
/// would be arrangeSize*0.5 x arrangeSize*0.25)
///
/// Arrange size
protected override Size ArrangeOverride(Size arrangeSize)
{
Rect childBounds = new Rect(0, 0, arrangeSize.Width / _columns, arrangeSize.Height / _rows);
double xStep = childBounds.Width;
double xBound = arrangeSize.Width - 1.0;
childBounds.X += childBounds.Width * FirstColumn;
// Arrange and Position each child to the same cell size
foreach (UIElement child in InternalChildren)
{
child.Arrange(childBounds);
// only advance to the next grid cell if the child was not collapsed
if (child.Visibility != Visibility.Collapsed)
{
childBounds.X += xStep;
if (childBounds.X >= xBound)
{
childBounds.Y += childBounds.Height;
childBounds.X = 0;
}
}
}
return arrangeSize;
}
#endregion Protected Methods
//-----------------------------------------------------
//
// Private Methods
//
//-----------------------------------------------------
#region Private Methods
///
/// If either Rows or Columns are set to 0, then dynamically compute these
/// values based on the actual number of non-collapsed children.
///
/// In the case when both Rows and Columns are set to 0, then make Rows
/// and Columns be equal, thus laying out in a square grid.
///
private void UpdateComputedValues()
{
_columns = Columns;
_rows = Rows;
//parameter checking.
if (FirstColumn >= _columns)
{
//NOTE: maybe we shall throw here. But this is somewhat out of
//the MCC itself. We need a whole new panel spec.
FirstColumn = 0;
}
if ((_rows == 0) || (_columns == 0))
{
int nonCollapsedCount = 0;
// First compute the actual # of non-collapsed children to be laid out
for (int i = 0, count = InternalChildren.Count; i < count; ++i)
{
UIElement child = InternalChildren[i];
if (child.Visibility != Visibility.Collapsed)
{
nonCollapsedCount++;
}
}
// to ensure that we have at leat one row & column, make sure
// that nonCollapsedCount is at least 1
if (nonCollapsedCount == 0)
{
nonCollapsedCount = 1;
}
if (_rows == 0)
{
if (_columns > 0)
{
// take FirstColumn into account, because it should really affect the result
_rows = (nonCollapsedCount + FirstColumn + (_columns - 1)) / _columns;
}
else
{
// both rows and columns are unset -- lay out in a square
_rows = (int)Math.Sqrt(nonCollapsedCount);
if ((_rows * _rows) < nonCollapsedCount)
{
_rows++;
}
_columns = _rows;
}
}
else if (_columns == 0)
{
// guaranteed that _rows is not 0, because we're in the else clause of the check for _rows == 0
_columns = (nonCollapsedCount + (_rows - 1)) / _rows;
}
}
}
#endregion Private Properties
private int _rows;
private int _columns;
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//
// File: UniformGrid.cs
//
// Description: Implementation of a UniformGrid that evenly distributes
// space among its children
//
// NewsClient is defining this Panel because it wants a
// multi-row, multi-column display of news items in the Pod;
// Grid can be databound, but it does not do auto-indexing,
// meaning that all of the generated items would be laid out
// on top of each other. Rather than subclassing Grid to
// introduce this auto-indexing behavior, it seemed more
// straightforward to construct this straightforward panel.
//
// NOTE: this is grabed from JeffBog's NewsClient under
// windows\wcp\DevTest\Demos\NewsClient\Core and add a FirstColumn property.
//
//---------------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
namespace System.Windows.Controls.Primitives
{
///
/// UniformGrid is used to arrange children in a grid with all equal cell sizes.
///
public class UniformGrid : Panel
{
//--------------------------------------------------------------------
//
// Constructors
//
//-------------------------------------------------------------------
#region Constructors
///
/// Default constructor.
///
public UniformGrid()
: base()
{
}
#endregion Constructors
//--------------------------------------------------------------------
//
// Public Properties
//
//--------------------------------------------------------------------
#region Public Properties
///
/// the start column to arrange children. Leave first 'FirstColumn'
/// cells blank.
///
public int FirstColumn
{
get { return (int)GetValue(FirstColumnProperty); }
set { SetValue(FirstColumnProperty, value); }
}
///
/// FirstColumnProperty
///
public static readonly DependencyProperty FirstColumnProperty =
DependencyProperty.Register(
"FirstColumn",
typeof(int),
typeof(UniformGrid),
new FrameworkPropertyMetadata(
(int)0,
FrameworkPropertyMetadataOptions.AffectsMeasure),
new ValidateValueCallback(ValidateFirstColumn));
private static bool ValidateFirstColumn(object o)
{
return (int)o >= 0;
}
///
/// Specifies the number of columns in the grid
/// A value of 0 indicates that the column count should be dynamically
/// computed based on the number of rows (if specified) and the
/// number of non-collapsed children in the grid
///
public int Columns
{
get { return (int)GetValue(ColumnsProperty); }
set { SetValue(ColumnsProperty, value); }
}
///
/// DependencyProperty for
public static readonly DependencyProperty ColumnsProperty =
DependencyProperty.Register(
"Columns",
typeof(int),
typeof(UniformGrid),
new FrameworkPropertyMetadata(
(int)0,
FrameworkPropertyMetadataOptions.AffectsMeasure),
new ValidateValueCallback(ValidateColumns));
private static bool ValidateColumns(object o)
{
return (int)o >= 0;
}
///
/// Specifies the number of rows in the grid
/// A value of 0 indicates that the row count should be dynamically
/// computed based on the number of columns (if specified) and the
/// number of non-collapsed children in the grid
///
public int Rows
{
get { return (int)GetValue(RowsProperty); }
set { SetValue(RowsProperty, value); }
}
///
/// DependencyProperty for
public static readonly DependencyProperty RowsProperty =
DependencyProperty.Register(
"Rows",
typeof(int),
typeof(UniformGrid),
new FrameworkPropertyMetadata(
(int)0,
FrameworkPropertyMetadataOptions.AffectsMeasure),
new ValidateValueCallback(ValidateRows));
private static bool ValidateRows(object o)
{
return (int)o >= 0;
}
#endregion Public Properties
//-------------------------------------------------------------------
//
// Protected Methods
//
//--------------------------------------------------------------------
#region Protected Methods
///
/// Compute the desired size of this UniformGrid by measuring all of the
/// children with a constraint equal to a cell's portion of the given
/// constraint (e.g. for a 2 x 4 grid, the child constraint would be
/// constraint.Width*0.5 x constraint.Height*0.25). The maximum child
/// width and maximum child height are tracked, and then the desired size
/// is computed by multiplying these maximums by the row and column count
/// (e.g. for a 2 x 4 grid, the desired size for the UniformGrid would be
/// maxChildDesiredWidth*2 x maxChildDesiredHeight*4).
///
/// Constraint
/// Desired size
protected override Size MeasureOverride(Size constraint)
{
UpdateComputedValues();
Size childConstraint = new Size(constraint.Width / _columns, constraint.Height / _rows);
double maxChildDesiredWidth = 0.0;
double maxChildDesiredHeight = 0.0;
// Measure each child, keeping track of maximum desired width and height.
for (int i = 0, count = InternalChildren.Count; i < count; ++i)
{
UIElement child = InternalChildren[i];
// Measure the child.
child.Measure(childConstraint);
Size childDesiredSize = child.DesiredSize;
if (maxChildDesiredWidth < childDesiredSize.Width)
{
maxChildDesiredWidth = childDesiredSize.Width;
}
if (maxChildDesiredHeight < childDesiredSize.Height)
{
maxChildDesiredHeight = childDesiredSize.Height;
}
}
return new Size((maxChildDesiredWidth * _columns),(maxChildDesiredHeight * _rows));
}
///
/// Arrange the children of this UniformGrid by distributing space evenly
/// among all of the children, making each child the size equal to a cell's
/// portion of the given arrangeSize (e.g. for a 2 x 4 grid, the child size
/// would be arrangeSize*0.5 x arrangeSize*0.25)
///
/// Arrange size
protected override Size ArrangeOverride(Size arrangeSize)
{
Rect childBounds = new Rect(0, 0, arrangeSize.Width / _columns, arrangeSize.Height / _rows);
double xStep = childBounds.Width;
double xBound = arrangeSize.Width - 1.0;
childBounds.X += childBounds.Width * FirstColumn;
// Arrange and Position each child to the same cell size
foreach (UIElement child in InternalChildren)
{
child.Arrange(childBounds);
// only advance to the next grid cell if the child was not collapsed
if (child.Visibility != Visibility.Collapsed)
{
childBounds.X += xStep;
if (childBounds.X >= xBound)
{
childBounds.Y += childBounds.Height;
childBounds.X = 0;
}
}
}
return arrangeSize;
}
#endregion Protected Methods
//-----------------------------------------------------
//
// Private Methods
//
//-----------------------------------------------------
#region Private Methods
///
/// If either Rows or Columns are set to 0, then dynamically compute these
/// values based on the actual number of non-collapsed children.
///
/// In the case when both Rows and Columns are set to 0, then make Rows
/// and Columns be equal, thus laying out in a square grid.
///
private void UpdateComputedValues()
{
_columns = Columns;
_rows = Rows;
//parameter checking.
if (FirstColumn >= _columns)
{
//NOTE: maybe we shall throw here. But this is somewhat out of
//the MCC itself. We need a whole new panel spec.
FirstColumn = 0;
}
if ((_rows == 0) || (_columns == 0))
{
int nonCollapsedCount = 0;
// First compute the actual # of non-collapsed children to be laid out
for (int i = 0, count = InternalChildren.Count; i < count; ++i)
{
UIElement child = InternalChildren[i];
if (child.Visibility != Visibility.Collapsed)
{
nonCollapsedCount++;
}
}
// to ensure that we have at leat one row & column, make sure
// that nonCollapsedCount is at least 1
if (nonCollapsedCount == 0)
{
nonCollapsedCount = 1;
}
if (_rows == 0)
{
if (_columns > 0)
{
// take FirstColumn into account, because it should really affect the result
_rows = (nonCollapsedCount + FirstColumn + (_columns - 1)) / _columns;
}
else
{
// both rows and columns are unset -- lay out in a square
_rows = (int)Math.Sqrt(nonCollapsedCount);
if ((_rows * _rows) < nonCollapsedCount)
{
_rows++;
}
_columns = _rows;
}
}
else if (_columns == 0)
{
// guaranteed that _rows is not 0, because we're in the else clause of the check for _rows == 0
_columns = (nonCollapsedCount + (_rows - 1)) / _rows;
}
}
}
#endregion Private Properties
private int _rows;
private int _columns;
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- CodeFieldReferenceExpression.cs
- TreeIterator.cs
- ToolStripLocationCancelEventArgs.cs
- returneventsaver.cs
- StringDictionaryWithComparer.cs
- ColorKeyFrameCollection.cs
- BooleanStorage.cs
- WebEventTraceProvider.cs
- FindResponse.cs
- CodeVariableReferenceExpression.cs
- DataGridViewImageColumn.cs
- UnsignedPublishLicense.cs
- StructuredTypeInfo.cs
- PKCS1MaskGenerationMethod.cs
- LockCookie.cs
- FontSource.cs
- DetailsViewPageEventArgs.cs
- StringDictionary.cs
- LeafCellTreeNode.cs
- xml.cs
- ArgumentOutOfRangeException.cs
- HorizontalAlignConverter.cs
- _NativeSSPI.cs
- XmlSchemaAttributeGroupRef.cs
- LocalizabilityAttribute.cs
- DataGridDesigner.cs
- GridViewRowEventArgs.cs
- AuthorizationRuleCollection.cs
- OdbcException.cs
- Matrix.cs
- PointAnimation.cs
- CompositeKey.cs
- _SslSessionsCache.cs
- DiscreteKeyFrames.cs
- MenuItem.cs
- CharacterMetrics.cs
- SqlExpander.cs
- XmlSchemaType.cs
- EventLogEntry.cs
- XmlSchemaInfo.cs
- InputProviderSite.cs
- SQLBinary.cs
- BoolLiteral.cs
- Calendar.cs
- DBNull.cs
- RegexCompilationInfo.cs
- RepeatBehavior.cs
- Line.cs
- GeneralTransform3DCollection.cs
- SafeCryptoHandles.cs
- ContextStaticAttribute.cs
- ComponentCommands.cs
- PerformanceCountersElement.cs
- RowUpdatedEventArgs.cs
- WeakHashtable.cs
- HTMLTextWriter.cs
- PrePostDescendentsWalker.cs
- TemplatedWizardStep.cs
- BaseInfoTable.cs
- DecimalAnimation.cs
- AuthenticateEventArgs.cs
- DictionaryKeyPropertyAttribute.cs
- DrawingGroup.cs
- TreeNodeBinding.cs
- NonVisualControlAttribute.cs
- UnSafeCharBuffer.cs
- DesignerSerializationManager.cs
- AnimatedTypeHelpers.cs
- GPRECT.cs
- ConnectionManagementElement.cs
- MetadataItemSerializer.cs
- ReaderWriterLockSlim.cs
- HtmlListAdapter.cs
- OracleParameterBinding.cs
- IdentityModelStringsVersion1.cs
- ToolStripItemCollection.cs
- FontSource.cs
- StreamGeometry.cs
- X509AsymmetricSecurityKey.cs
- XamlInt32CollectionSerializer.cs
- MemberAccessException.cs
- MetadataItemEmitter.cs
- MemberPath.cs
- EntityClientCacheEntry.cs
- SqlErrorCollection.cs
- X509CertificateStore.cs
- NetCodeGroup.cs
- WebPartEditorOkVerb.cs
- ClientEventManager.cs
- ComponentResourceKeyConverter.cs
- BitmapEffect.cs
- WriterOutput.cs
- XmlJsonWriter.cs
- ToolStripContentPanelRenderEventArgs.cs
- DataGridCaption.cs
- AssociationEndMember.cs
- ListItemParagraph.cs
- IListConverters.cs
- AppSettingsSection.cs
- SafeArrayRankMismatchException.cs