C# ColumnDefinition类代码示例

        public void write_column_for_widths()
        {
            var column = new ColumnDefinition<ColumnDefTarget, string>(FieldType.column, x => x.Name);
            column.Width(100, 80, 120);

            writeColumn(column).ShouldContain("width: 100, minWidth: 80, maxWidth: 120");
        }

        public void override_id()
        {
            var column = new ColumnDefinition<ColumnDefTarget, string>(x => x.Name);
            column.Id("else");

            writeColumn(column).ShouldEqual("{name: \"Name\", field: \"Name\", id: \"else\", sortable: true}");
        }

        public DataGridLengthEditorGrid()
        {
            this.ColumnDefinitions.Add(new ColumnDefinition());
            ColumnDefinition columnDefinition = new ColumnDefinition();
            columnDefinition.Width = GridLength.Auto;
            this.ColumnDefinitions.Add(columnDefinition);

            _textBox = new TextBox();
            Binding binding = new Binding("Text");
            binding.Mode = BindingMode.TwoWay;
            _textBox.SetBinding(TextBox.TextProperty, binding);
            _textBox.KeyDown += new KeyEventHandler(TextBox_KeyDown);
            _textBox.DataContext = this;
            this.Children.Add(_textBox);

            _comboBox = new ComboBox();
            _comboBox.SetValue(Grid.ColumnProperty, 1);
            // Unfortunately, there's no built in way to tell the ComboBox to be as wide as the widest item
            _comboBox.MinWidth = 95; 
            _comboBox.SelectionChanged += new SelectionChangedEventHandler(ComboBox_SelectionChanged);
            DataGridLengthUnitType[] items = 
            {
                DataGridLengthUnitType.Auto,
                DataGridLengthUnitType.Pixel,
                DataGridLengthUnitType.SizeToCells,
                DataGridLengthUnitType.SizeToHeader
            };
            _comboBox.ItemsSource = items;
            this.Children.Add(_comboBox);
        }

 public override bool Equals(ColumnDefinition other)
 {
     if (!base.Equals(other)) return false;
     var otherInteger = (IntegerColumnDefinition)other;
     if (IdentitySeed != otherInteger.IdentitySeed) return false;
     return true;
 }

        public void override_title()
        {
            var column = new ColumnDefinition<ColumnDefTarget, string>(x => x.Name);
            column.Title("else");

            writeColumn(column).ShouldContain("name: \"else\"");
        }

            /**
             * The constructor
             */
            public VerticalLayout()
            {
                mGrid = new System.Windows.Controls.Grid();

                mColDef = new ColumnDefinition();
                mSpacerUp = new RowDefinition();
                mSpacerDown = new RowDefinition();

                mSpacerRight = new ColumnDefinition();
                mSpacerLeft = new ColumnDefinition();

                mColDef.Width = new System.Windows.GridLength(1, System.Windows.GridUnitType.Star);

                mSpacerUp.Height = new System.Windows.GridLength(0);
                mSpacerDown.Height = new System.Windows.GridLength(0);
                mSpacerRight.Width = new System.Windows.GridLength(0);
                mSpacerLeft.Width = new System.Windows.GridLength(0);

                mGrid.RowDefinitions.Add(mSpacerUp);
                mGrid.RowDefinitions.Add(mSpacerDown);

                mGrid.ColumnDefinitions.Add(mSpacerLeft);
                mGrid.ColumnDefinitions.Add(mColDef);
                mGrid.ColumnDefinitions.Add(mSpacerRight);

                this.fillSpaceVerticalyEnabled = false;
                this.fillSpaceHorizontalyEnabled = false;

                mView = mGrid;
                #if DEBUG
                mGrid.ShowGridLines = true;
                #endif
            }

    public static void AddPages(TabControl tabControl, string tabName, bool maxSize, params Page[] pages)
    {
        Grid grid = new Grid();
        grid.Width = double.NaN;
        grid.Height = double.NaN;
        grid.Margin = new Thickness(0);
        grid.VerticalAlignment = VerticalAlignment.Top;

        if (maxSize)
        {
            grid.HorizontalAlignment = HorizontalAlignment.Stretch;
            grid.VerticalAlignment = VerticalAlignment.Stretch;
        }

        int index = 0;
        foreach (var item in pages)
        {
            ColumnDefinition col = new ColumnDefinition();
            col.Width = GridLength.Auto;
            grid.ColumnDefinitions.Add(col);
            SetPageToGrid(item, grid, 0, index);
            index++;
        }

        TabItem tabItem = new TabItem();
        tabItem.Header = tabName;
        tabItem.Content = grid;
        tabControl.Items.Add(tabItem);
    }

		public void SharedSizeGroup ()
		{
			ColumnDefinition c = new ColumnDefinition ();
			Assert.IsNull (c.SharedSizeGroup, "1");
			try {
				c.SharedSizeGroup = string.Empty;
				Assert.Fail ("2");
			} catch (ArgumentException) {
			}
			try {
				c.SharedSizeGroup = " ";
				Assert.Fail ("3");
			} catch (ArgumentException) {
			}
			try {
				c.SharedSizeGroup = ".";
				Assert.Fail ("4");
			} catch (ArgumentException) {
			}
			try {
				c.SharedSizeGroup = "1";
				Assert.Fail ("5");
			} catch (ArgumentException) {
			}
			c.SharedSizeGroup = "_";
			c.SharedSizeGroup = "A";
			c.SharedSizeGroup = "A1";
			c.SharedSizeGroup = null;
			Assert.IsNotNull (DefinitionBase.SharedSizeGroupProperty.ValidateValueCallback, "6");
		}

 public ColumnOrderSet(ColumnDefinition column, ListSortDirection order)
     : this()
 {
     column.ThrowIfNull("column");
     this.Column = column;
     this.Direction = order;
 }

 public override bool Equals(ColumnDefinition other)
 {
     if (!base.Equals(other)) return false;
     var otherSize = (VariableSizeColumnDefinition)other;
     if (IsMaximumSize && otherSize.IsMaximumSize) return true;
     if (Size != otherSize.Size) return false;
     return true;
 }

        public void will_not_write_a_null_property_because_that_wigs_out_at_runtime()
        {
            var column = new ColumnDefinition<ColumnDefTarget, string>(x => x.Name, theProjection);
            column.Property("something", null);

            // just wanna see it not blow up
            writeColumn(column);
        }

 public FixedLengthTokenizer(ColumnDefinition[] columns)
 {
     if (columns == null)
     {
         throw new ArgumentNullException("columns");
     }
     Columns = columns;
 }

 public override bool Equals(ColumnDefinition other)
 {
     if (!base.Equals(other)) return false;
     var otherDecimal = (DecimalColumnDefinition)other;
     if (Precision != otherDecimal.Precision) return false;
     if (Scale != otherDecimal.Scale) return false;
     return true;
 }

        /// <summary>
        /// Add a new column to the table.
        /// </summary>
        /// <param name="columndef">The column definition.</param>
        /// <returns>The table the column was added to.</returns>
        public override Table CreateColumn(ColumnDefinition columndef)
        {
            this.Tracer.TraceInfo("adding column {0} of type {1}", columndef.Name, columndef.Type);
            columndef.CreateColumn(this.TableCursor);

            // The meta-data has changed. Reload it.
            this.LoadMetaData();
            return this;
        }

 private string GetFormattedColumnLine(ColumnDefinition column)
 {
     return string.Format(
         "[{0}] {1}{2}{3}",
         column.Name,
         GetFormattedDataType(column),
         GetFormattedIdentity(column),
         GetFormattedNullable(column));
 }