Lire en anglais

Partager via


DataGridBoolColumn Classe

Définition

Spécifie une colonne dans laquelle chaque cellule contient une case à cocher représentant une valeur Boolean.

public class DataGridBoolColumn : System.Windows.Forms.DataGridColumnStyle
Héritage

Exemples

L’exemple de code suivant crée d’abord un nouveau DataGridBoolColumn et l’ajoute GridColumnStylesCollection au d’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);
    }
}

Remarques

dérive DataGridBoolColumn de la abstract classe DataGridColumnStyle. Au moment de l’exécution, contient DataGridBoolColumn case activée zones dans chaque cellule qui ont trois états par défaut : coché (true), décoché (false) et Value. Pour utiliser des zones de case activée à deux états, définissez la propriété sur AllowNullfalse.

Les propriétés ajoutées à la classe incluent FalseValue, NullValueet TrueValue. Ces propriétés spécifient la valeur sous-jacente de chacun des états de la colonne.

Constructeurs

DataGridBoolColumn()

Initialise une nouvelle instance de la classe DataGridBoolColumn.

DataGridBoolColumn(PropertyDescriptor)

Initialise une nouvelle instance de la classe DataGridBoolColumn avec le PropertyDescriptor spécifié.

DataGridBoolColumn(PropertyDescriptor, Boolean)

Initialise une nouvelle instance de la classe avec le DataGridBoolColumn spécifié PropertyDescriptoret en spécifiant si le style de colonne est une colonne par défaut.

Propriétés

Alignment

Obtient ou définit l'alignement du texte dans une colonne.

(Hérité de DataGridColumnStyle)
AllowNull

Obtient ou définit une valeur indiquant si des valeurs null sont autorisées.

CanRaiseEvents

Obtient une valeur qui indique si le composant peut déclencher un événement.

(Hérité de Component)
Container

Obtient le IContainer qui contient la Component.

(Hérité de Component)
DataGridTableStyle

Obtient le DataGridTableStyle pour la colonne.

(Hérité de DataGridColumnStyle)
DesignMode

Obtient une valeur qui indique si Component est actuellement en mode design.

(Hérité de Component)
Events

Obtient la liste des gestionnaires d'événements attachés à ce Component.

(Hérité de Component)
FalseValue

Obtient ou définit la valeur réelle utilisée pour affecter la valeur false à la colonne.

FontHeight

Obtient la hauteur de la police de la colonne.

(Hérité de DataGridColumnStyle)
HeaderAccessibleObject

Obtient le AccessibleObject pour la colonne.

(Hérité de DataGridColumnStyle)
HeaderText

Obtient ou définit le texte de l'en-tête de colonne.

(Hérité de DataGridColumnStyle)
MappingName

Obtient ou définit le nom des données membres avec lesquelles le style de colonne est mis en correspondance.

(Hérité de DataGridColumnStyle)
NullText

Obtient ou définit le texte affiché quand la colonne contient null.

(Hérité de DataGridColumnStyle)
NullValue

Obtient ou définit la valeur réelle utilisée pour affecter la valeur Value à la colonne.

PropertyDescriptor

Obtient ou définit PropertyDescriptor qui détermine les attributs des données affichées par DataGridColumnStyle.

(Hérité de DataGridColumnStyle)
ReadOnly

Obtient ou définit une valeur indiquant si les données dans la colonne peuvent être modifiées.

(Hérité de DataGridColumnStyle)
Site

Obtient ou définit le ISite de Component.

(Hérité de Component)
TrueValue

Obtient ou définit la valeur réelle utilisée pour affecter la valeur true à la colonne.

Width

Obtient ou définit la largeur de la colonne.

(Hérité de DataGridColumnStyle)

Méthodes

Abort(Int32)

Lance une demande d'interruption d'une procédure de modification.

BeginUpdate()

Suspend la peinture de la colonne jusqu'à ce que la méthode EndUpdate() soit appelée.

(Hérité de DataGridColumnStyle)
CheckValidDataSource(CurrencyManager)

Lève une exception si la DataGrid ne possède pas une source de données valide, ou si cette colonne n'est pas mappée avec une propriété valide dans la source de données.

(Hérité de DataGridColumnStyle)
ColumnStartedEditing(Control)

Indique à DataGrid que l'utilisateur a commencé la modification de la colonne.

(Hérité de DataGridColumnStyle)
Commit(CurrencyManager, Int32)

Lance une demande de fin d'une procédure de modification.

ConcedeFocus()

Notifie une colonne qu'elle doit abandonner le focus vers le contrôle qu'elle héberge.

CreateHeaderAccessibleObject()

Obtient le AccessibleObject pour la colonne.

(Hérité de DataGridColumnStyle)
CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.

(Hérité de MarshalByRefObject)
Dispose()

Libère toutes les ressources utilisées par Component.

(Hérité de Component)
Dispose(Boolean)

Libère les ressources non managées utilisées par Component et libère éventuellement les ressources managées.

(Hérité de Component)
Edit(CurrencyManager, Int32, Rectangle, Boolean)

Prépare une cellule pour modification.

(Hérité de DataGridColumnStyle)
Edit(CurrencyManager, Int32, Rectangle, Boolean, String)

Prépare la cellule pour modification en utilisant le CurrencyManager, le numéro de ligne et les paramètres de Rectangle spécifiés.

(Hérité de DataGridColumnStyle)
Edit(CurrencyManager, Int32, Rectangle, Boolean, String, Boolean)

Prépare la cellule pour modifier une valeur.

EndUpdate()

Reprend la peinture des colonnes suspendues en appelant la méthode BeginUpdate().

(Hérité de DataGridColumnStyle)
EnterNullValue()

Entre un Value dans la colonne.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetColumnValueAtRow(CurrencyManager, Int32)

Obtient la valeur au niveau de la ligne spécifiée.

GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetLifetimeService()
Obsolète.

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
GetMinimumHeight()

Obtient la hauteur d'une cellule dans une colonne.

GetPreferredHeight(Graphics, Object)

Obtient la hauteur utilisée lors du redimensionnement des colonnes.

GetPreferredSize(Graphics, Object)

Obtient la largeur et la hauteur optimale d'une cellule en fonction d'une valeur spécifique à contenir.

GetService(Type)

Retourne un objet qui représente un service fourni par Component ou par son Container.

(Hérité de Component)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
InitializeLifetimeService()
Obsolète.

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
Invalidate()

Redessine la colonne et provoque l'envoi d'un message de peinture au contrôle.

(Hérité de DataGridColumnStyle)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.

(Hérité de MarshalByRefObject)
Paint(Graphics, Rectangle, CurrencyManager, Int32)

Dessine DataGridBoolColumn avec Graphics, Rectangle et le numéro de ligne donnés.

Paint(Graphics, Rectangle, CurrencyManager, Int32, Boolean)

Peint DataGridBoolColumn avec les Graphics, Rectangle, le numéro de ligne et les paramètres d'alignement donnés.

Paint(Graphics, Rectangle, CurrencyManager, Int32, Brush, Brush, Boolean)

Peint DataGridBoolColumn avec les Graphics, Rectangle, le numéro de ligne, Brush et Color donnés.

ReleaseHostedControl()

Autorise la colonne à libérer des ressources lorsque le contrôle qu'elle héberge n'est pas nécessaire.

(Hérité de DataGridColumnStyle)
ResetHeaderText()

Rétablit la valeur par défaut HeaderText de la propriété, null.

(Hérité de DataGridColumnStyle)
SetColumnValueAtRow(CurrencyManager, Int32, Object)

Définit la valeur d'une ligne spécifiée.

SetDataGrid(DataGrid)

Définit le contrôle DataGrid auquel la colonne appartient.

(Hérité de DataGridColumnStyle)
SetDataGridInColumn(DataGrid)

Définit le DataGrid pour la colonne.

(Hérité de DataGridColumnStyle)
ToString()

Retourne un String contenant le nom du Component, s’il en existe un. Cette méthode ne doit pas être remplacée.

(Hérité de Component)
UpdateUI(CurrencyManager, Int32, String)

Met à jour la valeur d'une ligne spécifiée avec le texte indiqué.

(Hérité de DataGridColumnStyle)

Événements

AlignmentChanged

Se produit quand la valeur de la propriété Alignment change.

(Hérité de DataGridColumnStyle)
AllowNullChanged

Se produit lorsque la propriété AllowNull est modifiée.

Disposed

Se produit lorsque le composant est supprimé par un appel à la méthode Dispose().

(Hérité de Component)
FalseValueChanged

Se produit lorsque la propriété FalseValue est modifiée.

FontChanged

Se produit lorsque la police de la colonne change.

(Hérité de DataGridColumnStyle)
HeaderTextChanged

Se produit quand la valeur de la propriété HeaderText change.

(Hérité de DataGridColumnStyle)
MappingNameChanged

Se produit quand la valeur MappingName est modifiée.

(Hérité de DataGridColumnStyle)
NullTextChanged

Se produit quand la valeur NullText est modifiée.

(Hérité de DataGridColumnStyle)
PropertyDescriptorChanged

Se produit quand la valeur de la propriété PropertyDescriptor change.

(Hérité de DataGridColumnStyle)
ReadOnlyChanged

Se produit quand la valeur de la propriété ReadOnly change.

(Hérité de DataGridColumnStyle)
TrueValueChanged

Se produit lorsque la propriété TrueValue a été modifiée.

WidthChanged

Se produit quand la valeur de la propriété Width change.

(Hérité de DataGridColumnStyle)

Implémentations d’interfaces explicites

IDataGridColumnStyleEditingNotificationService.ColumnStartedEditing(Control)

Indique au contrôle DataGrid que l'utilisateur a commencé la modification de la colonne.

(Hérité de DataGridColumnStyle)

S’applique à

Produit Versions
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
Windows Desktop 3.0

Voir aussi