Esta documentación está archivada y no tiene mantenimiento.

DataGridBoolColumn (Clase)

Especifica una columna en la que cada celda contiene una casilla de verificación para representar un valor booleano.

Espacio de nombres: System.Windows.Forms
Ensamblado: System.Windows.Forms (en system.windows.forms.dll)

public class DataGridBoolColumn : DataGridColumnStyle
public class DataGridBoolColumn extends DataGridColumnStyle
public class DataGridBoolColumn extends DataGridColumnStyle
No aplicable.

El control DataGridBoolColumn se deriva del control DataGridColumnStyle de la clase abstract. En tiempo de ejecución, el control DataGridBoolColumn contiene casillas de verificación en cada celda que tienen tres estados de forma predeterminada: activado (true), desactivado (false) y Value. Para utilizar las casillas de verificación de dos estados, establezca la propiedad AllowNull en false.

Entre las propiedades que se agregan se incluyen las siguientes: FalseValue, NullValue y TrueValue. Estas propiedades especifican el valor que subyace a cada uno de los estados de la columna.

En el ejemplo de código siguiente se crea un nuevo DataGridBoolColumn y se agrega al GridColumnStylesCollection de un DataGridTableStyle.

using System;
using System.Data;
using System.Windows.Forms;
using System.Drawing;
using System.ComponentModel;

public class MyForm : Form 
{
    private DataTable myTable;
    private DataGrid myGrid = new DataGrid();
    
    public MyForm() : base() 
    {
        try
        {
            InitializeComponent();

            myTable = new DataTable("NamesTable");
            myTable.Columns.Add(new DataColumn("Name"));
            DataColumn column = new DataColumn
                ("id", typeof(System.Int32));
            myTable.Columns.Add(column);
            myTable.Columns.Add(new 
                DataColumn("calculatedField", typeof(bool)));
            DataSet namesDataSet = new DataSet();
            namesDataSet.Tables.Add(myTable);
            myGrid.SetDataBinding(namesDataSet, "NamesTable");
        
            AddTableStyle();
            AddData();
        }
        catch (System.Exception exc)
        {
            Console.WriteLine(exc.ToString());
        }
    }

    
    private void grid_Enter(object sender, EventArgs e) 
    {
        myGrid.CurrentCell = new DataGridCell(2,2);
    }

    private void AddTableStyle()
    {
        // Map a new  TableStyle to the DataTable. Then 
        // add DataGridColumnStyle objects to the collection
        // of column styles with appropriate mappings.
        DataGridTableStyle dgt = new DataGridTableStyle();
        dgt.MappingName = "NamesTable";

        DataGridTextBoxColumn dgtbc = new DataGridTextBoxColumn();
        dgtbc.MappingName = "Name";
        dgtbc.HeaderText= "Name";
        dgt.GridColumnStyles.Add(dgtbc);

        dgtbc = new DataGridTextBoxColumn();
        dgtbc.MappingName = "id";
        dgtbc.HeaderText= "id";
        dgt.GridColumnStyles.Add(dgtbc);

        DataGridBoolColumnInherit db = 
            new DataGridBoolColumnInherit();
        db.HeaderText= "less than 1000 = blue";
        db.Width= 150;
        db.MappingName = "calculatedField";
        dgt.GridColumnStyles.Add(db);

        myGrid.TableStyles.Add(dgt);

        // This expression instructs the grid to change
        // the color of the inherited DataGridBoolColumn
        // according to the value of the id field. If it's
        // less than 1000, the row is blue. Otherwise,
        // the color is yellow.
        db.Expression = "id < 1000";
    }

    private void AddData() 
    {
        // Add data with varying numbers for the id field.
        // If the number is over 1000, the cell will paint
        // yellow. Otherwise, it will be blue.
        DataRow dRow = myTable.NewRow();

        dRow["Name"] = "name 1 ";
        dRow["id"] = 999;
        myTable.Rows.Add(dRow);

        dRow = myTable.NewRow();
        dRow["Name"] = "name 2";
        dRow["id"] = 2300;
        myTable.Rows.Add(dRow);

        dRow = myTable.NewRow();
        dRow["Name"] = "name 3";
        dRow["id"] = 120;
        myTable.Rows.Add(dRow);

        dRow = myTable.NewRow();
        dRow["Name"] = "name 4";
        dRow["id"] = 4023;
        myTable.Rows.Add(dRow);

        dRow = myTable.NewRow();
        dRow["Name"] = "name 5";
        dRow["id"] = 2345;
        myTable.Rows.Add(dRow);

        myTable.AcceptChanges();
    }

    private void InitializeComponent() 
    {
        this.Size = new Size(500, 500);
        myGrid.Size = new Size(350, 250);
        myGrid.TabStop = true;
        myGrid.TabIndex = 1;
      
        this.StartPosition = FormStartPosition.CenterScreen;
        this.Controls.Add(myGrid);
      }
    [STAThread]
    public static void Main() 
    {
        Application.Run(new MyForm());
    }
}

public class DataGridBoolColumnInherit : DataGridBoolColumn 
{
    private SolidBrush trueBrush = Brushes.Blue as SolidBrush;
    private SolidBrush falseBrush = Brushes.Yellow as SolidBrush;
    private DataColumn expressionColumn = null;
    private static int count = 0;

    public Color FalseColor 
    {
        get 
        {
            return falseBrush.Color;
        }
        set 
        {
            falseBrush = new SolidBrush(value);
            Invalidate();
        }
    }

    public Color TrueColor 
    {
        get 
        {
            return trueBrush.Color;
        }
        set 
        {
            trueBrush = new SolidBrush(value);
            Invalidate();
        }
    }

    public DataGridBoolColumnInherit() : base () 
    {
        count ++;
    }


    // This will work only with a DataSet or DataTable.
    // The code is not compatible with IBindingList implementations.
    public string Expression 
    {
        get 
        {
            return this.expressionColumn == null ? String.Empty : 
                this.expressionColumn.Expression;
        }
        set 
        {
            if (expressionColumn == null)
                AddExpressionColumn(value);
            else 
                expressionColumn.Expression = value;
            if (expressionColumn != null && 
                expressionColumn.Expression.Equals(value))
                return;
            Invalidate();
        }
    }

    private void AddExpressionColumn(string value) 
    {
        // Get the grid's data source. First check for a null 
        // table or data grid.
        if (this.DataGridTableStyle == null || 
            this.DataGridTableStyle.DataGrid == null)
            return;

        DataGrid myGrid = this.DataGridTableStyle.DataGrid;
        DataView myDataView = ((CurrencyManager) 
            myGrid.BindingContext[myGrid.DataSource, 
            myGrid.DataMember]).List 
            as DataView;

        // This works only with System.Data.DataTable.
        if (myDataView == null)
            return;

        // If the user already added a column with the name 
        // then exit. Otherwise, add the column and set the 
        // expression to the value passed to this function.
        DataColumn col = myDataView.Table.Columns["__Computed__Column__"];
        if (col != null)
            return;
        col = new DataColumn("__Computed__Column__" + count.ToString());

        myDataView.Table.Columns.Add(col);
        col.Expression = value;
        expressionColumn = col;
    }

    // override the OnPaint method to paint the cell based on the expression.
    protected override void Paint(Graphics g, Rectangle bounds,
        CurrencyManager source, int rowNum,
        Brush backBrush, Brush foreBrush,
        bool alignToRight) 
    {
        bool trueExpression = false;
        bool hasExpression = false;
        DataRowView drv = source.List[rowNum] as DataRowView;

        hasExpression = this.expressionColumn != null && 
            this.expressionColumn.Expression != null && 
            !this.expressionColumn.Expression.Equals(String.Empty);

        Console.WriteLine(string.Format("hasExpressionValue {0}",hasExpression));
        // Get the value from the expression column.
        // For simplicity, we assume a True/False value for the 
        // expression column.
        if (hasExpression) 
        {
            object expr = drv.Row[expressionColumn.ColumnName];
            trueExpression = expr.Equals("True");
        }

        // Let the DataGridBoolColumn do the painting.
        if (!hasExpression)
            base.Paint(g, bounds, source, rowNum, 
                backBrush, foreBrush, alignToRight);

        // Paint using the expression color for true or false, as calculated.
        if (trueExpression)
            base.Paint(g, bounds, source, rowNum, 
                trueBrush, foreBrush, alignToRight);
        else
            base.Paint(g, bounds, source, rowNum, 
                falseBrush, foreBrush, alignToRight);
    }
}

import System.*;
import System.Data.*;
import System.Windows.Forms.*;
import System.Drawing.*;
import System.ComponentModel.*;

public class MyForm extends Form
{
    private DataTable myTable;
    private DataGrid myGrid = new DataGrid();

    public MyForm()
    {
        try {
            InitializeComponent();
            myTable = new DataTable("NamesTable");
            myTable.get_Columns().Add(new DataColumn("Name"));

            DataColumn column = 
                new DataColumn("id", System.Int32.class.ToType());

            myTable.get_Columns().Add(column);
            myTable.get_Columns().Add(new DataColumn("calculatedField", 
                boolean.class.ToType()));

            DataSet namesDataSet = new DataSet();

            namesDataSet.get_Tables().Add(myTable);
            myGrid.SetDataBinding(namesDataSet, "NamesTable");
            AddTableStyle();
            AddData();
        }
        catch(System.Exception exc) {
            Console.WriteLine(exc.ToString());
        }
    } //MyForm

    private void gridEnter(Object sender, EventArgs e)
    {
        myGrid.set_CurrentCell(new DataGridCell(2, 2));
    } //gridEnter

    private void AddTableStyle()
    {
        // Map a new  TableStyle to the DataTable. Then 
        // add DataGridColumnStyle objects to the collection
        // of column styles with appropriate mappings.
        DataGridTableStyle dgt = new DataGridTableStyle();

        dgt.set_MappingName("NamesTable");

        DataGridTextBoxColumn dgtbc = new DataGridTextBoxColumn();

        dgtbc.set_MappingName("Name");
        dgtbc.set_HeaderText("Name");
        dgt.get_GridColumnStyles().Add(dgtbc);
        dgtbc = new DataGridTextBoxColumn();
        dgtbc.set_MappingName("id");
        dgtbc.set_HeaderText("id");
        dgt.get_GridColumnStyles().Add(dgtbc);

        DataGridBoolColumnInherit db = new DataGridBoolColumnInherit();

        db.set_HeaderText("less than 1000 = blue");
        db.set_Width(150);
        db.set_MappingName("calculatedField");
        dgt.get_GridColumnStyles().Add(db);
        myGrid.get_TableStyles().Add(dgt);

        // This expression instructs the grid to change
        // the color of the inherited DataGridBoolColumn
        // according to the value of the id field. If it's
        // less than 1000, the row is blue. Otherwise,
        // the color is yellow.
        db.set_Expression("id < 1000");
    } //AddTableStyle

    private void AddData()
    {
        // Add data with varying numbers for the id field.
        // If the number is over 1000, the cell will paint
        // yellow. Otherwise, it will be blue.
        DataRow dRow = myTable.NewRow();

        dRow.set_Item("Name", "name 1 ");
        dRow.set_Item("id", (Int32)999);
        myTable.get_Rows().Add(dRow);
        dRow = myTable.NewRow();
        dRow.set_Item("Name", "name 2");
        dRow.set_Item("id", (Int32)2300);
        myTable.get_Rows().Add(dRow);
        dRow = myTable.NewRow();
        dRow.set_Item("Name", "name 3");
        dRow.set_Item("id", (Int32)120);
        myTable.get_Rows().Add(dRow);
        dRow = myTable.NewRow();
        dRow.set_Item("Name", "name 4");
        dRow.set_Item("id", (Int32)4023);
        myTable.get_Rows().Add(dRow);
        dRow = myTable.NewRow();
        dRow.set_Item("Name", "name 5");
        dRow.set_Item("id", (Int32)2345);
        myTable.get_Rows().Add(dRow);
        myTable.AcceptChanges();
    } //AddData

    private void InitializeComponent()
    {
        this.set_Size(new Size(500, 500));
        myGrid.set_Size(new Size(350, 250));
        myGrid.set_TabStop(true);
        myGrid.set_TabIndex(1);
        this.set_StartPosition(FormStartPosition.CenterScreen);
        this.get_Controls().Add(myGrid);
    } //InitializeComponent

    /** @attribute STAThread()
     */
    public static void main(String[] args)
    {
        Application.Run(new MyForm());
    } //main
} //MyForm

public class DataGridBoolColumnInherit extends DataGridBoolColumn
{
    private SolidBrush trueBrush = (SolidBrush)Brushes.get_Blue();
    private SolidBrush falseBrush = (SolidBrush)Brushes.get_Yellow();
    private DataColumn expressionColumn = null;
    private static int count = 0;

    /** @property 
     */
    public Color get_FalseColor()
    {
        return falseBrush.get_Color();
    } //get_FalseColor

    /** @property 
     */
    public void set_FalseColor(Color value)
    {
        falseBrush = new SolidBrush(value);
        Invalidate();
    } //set_FalseColor

    /** @property 
     */
    public Color get_TrueColor()
    {
        return trueBrush.get_Color();
    } //get_TrueColor

    /** @property 
     */
    public void set_TrueColor(Color value)
    {
        trueBrush = new SolidBrush(value);
        Invalidate();
    } //set_TrueColor

    public DataGridBoolColumnInherit()
    {
        super();
        count++;
    } //DataGridBoolColumnInherit

    // This will work only with a DataSet or DataTable.
    // The code is not compatible with IBindingList implementations.
    /** @property 
     */
    public String get_Expression()
    {
        return (this.expressionColumn == null) 
            ? String.Empty : this.expressionColumn.get_Expression();
    } //get_Expression

    /** @property 
     */
    public void set_Expression(String value)
    {
        if(expressionColumn == null) {
            AddExpressionColumn(value);
        }
        else {
            expressionColumn.set_Expression(value);
        }

        if(expressionColumn != null 
            && expressionColumn.get_Expression().Equals(value)) {
            return;
        }
        Invalidate();
    } //set_Expression

    private void AddExpressionColumn(String value)
    {
        // Get the grid's data source. First check for a null 
        // table or data grid.
        if(this.get_DataGridTableStyle() == null 
            || this.get_DataGridTableStyle().get_DataGrid() == null) {
            return;
        }

        DataGrid myGrid = this.get_DataGridTableStyle().get_DataGrid();
        DataView myDataView = (DataView)(((CurrencyManager)(myGrid.
            get_BindingContext().get_Item(myGrid.get_DataSource(), 
            myGrid.get_DataMember()))).get_List());

        // This works only with System.Data.DataTable.
        if(myDataView == null) {
            return;
        }

        // If the user already added a column with the name 
        // then exit. Otherwise, add the column and set the 
        // expression to the value passed to this function.
        DataColumn col = myDataView.get_Table().get_Columns().
            get_Item("__Computed__Column__");

        if(col != null) {
            return;
        }
        col = new DataColumn("__Computed__Column__" 
            + System.Convert.ToString(count));

        myDataView.get_Table().get_Columns().Add(col);
        col.set_Expression(value);
        expressionColumn = col;
    } //AddExpressionColumn

    // override the OnPaint method to paint the cell based on the expression.
    protected void Paint(Graphics g, Rectangle bounds, CurrencyManager source, 
        int rowNum, Brush backBrush, Brush foreBrush, boolean alignToRight)
    {
        boolean trueExpression = false;
        boolean hasExpression = false;
        DataRowView drv = (DataRowView)source.get_List().get_Item(rowNum);

        hasExpression = this.expressionColumn != null 
            && this.expressionColumn.get_Expression() != null 
            && !(this.expressionColumn.get_Expression().Equals(String.Empty));
        
        Console.WriteLine(String.Format("hasExpressionValue {0}", 
            System.Convert.ToString(hasExpression)));

        // Get the value from the expression column.
        // For simplicity, we assume a True/False value for the 
        // expression column.
        if(hasExpression) {
            Object expr = 
                drv.get_Row().get_Item(expressionColumn.get_ColumnName());
            trueExpression = expr.Equals("True");
        }

        // Let the DataGridBoolColumn do the painting.
        if(!(hasExpression)) {
            super.Paint(g, bounds, source, rowNum, backBrush, foreBrush, 
                alignToRight);
        }

        // Paint using the expression color for true or false, as calculated.
        if(trueExpression) {
            super.Paint(g, bounds, source, rowNum, trueBrush, foreBrush, 
                alignToRight);
        }
        else {
            super.Paint(g, bounds, source, rowNum, falseBrush, foreBrush, 
                alignToRight);
        }
    } //Paint
} //DataGridBoolColumnInherit

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Windows 98, Windows 2000 Service Pack 4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter

Microsoft .NET Framework 3.0 es compatible con Windows Vista, Microsoft Windows XP SP2 y Windows Server 2003 SP1.

.NET Framework

Compatible con: 3.0, 2.0, 1.1, 1.0
Mostrar: