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));
 }

 public override void AddColumn(ColumnDefinition columnDef)
 {
     using (var transaction = new Transaction(connection.session))
      using (var table = new Microsoft.Isam.Esent.Interop.Table(connection.session, connection.dbid, name, OpenTableGrbit.None)) {
          var tableCreator = new EseTableCreator(connection);
          tableCreator.AddColumn(table, columnDef);
          transaction.Commit(CommitTransactionGrbit.None);
      }
      RefreshTableInfo();
 }

 private static string Extended(ColumnDefinition column)
 {
     var sizeColumn = column as VariableSizeColumnDefinition;
     if (sizeColumn != null) return string.Format(", {0} = {1}", nameof(sizeColumn.Size), sizeColumn.Size);
     var integerColumn = column as IntegerColumnDefinition;
     if (integerColumn != null && integerColumn.IdentitySeed.HasValue) return string.Format(", {0} = {1}", nameof(integerColumn.IdentitySeed), integerColumn.IdentitySeed);
     var decimalColumn = column as DecimalColumnDefinition;
     if (decimalColumn != null) return string.Format(", {0} = {1}, {2} = {3}", nameof(decimalColumn.Precision), decimalColumn.Precision, nameof(decimalColumn.Scale), decimalColumn.Scale);
     return null;
 }

        public void ProcessColumnDefinition(ColumnDefinition ColumnDef)
        {
            _smells.ProcessTsqlFragment(ColumnDef.DataType);
            foreach (var Constraint in ColumnDef.Constraints)
            {

                _smells.ProcessTsqlFragment(Constraint);
            }
           
        }

        public static void CreateTable(DataManagement.Configuration config, string tablePrefix = "")
        {
            var columns = new ColumnDefinition[]
            {
                new ColumnDefinition("Variable", DataType.LargeText),
                new ColumnDefinition("Value", DataType.LargeText),
                new ColumnDefinition("Timestamp", DataType.DateTime)
            };

            Table.Create(config, tablePrefix + Names.Variables, columns, primaryKey);
        }

        public override void Visit(ColumnDefinition col)
        {
            String s = "<COL id='" + col.ColumnIdentifier.Value + "'";
            SqlDataTypeReference dt = (SqlDataTypeReference)col.DataType;

            s = s + " type='" + dt.SqlDataTypeOption + "'></COL>";
            sw.WriteLine(s);

            col.Accept(new NullVisitor());

        }