Ajouter des contrôles sur plusieurs cellule d'un Datagridview

**bobosh** · 22/03/2010, 22h10

Bonjour,

J'ai un planning par semaine, sur lequelle j'aimerais ajouter tout les rendez-vous que je pourrais avoir.

Mais je ne sais pas quel contrôle utiliser pour ajouter ce rendez-vous.

En effet, j'aimerais que ce rendez vous puisse s'étendre sur un ou plusieurs cellules d'une colonne.

Merci d'avance.

**Graffito** · 23/03/2010, 00h45

Malheureusement, ni le DataGridView ni le ListView ne permettent de fusionner des cellulles.

Reste, la solution de faire "comme si" grace à l'event CellPainting du DataGridView. Voir : http://social.msdn.microsoft.com/For...0-50f5f00878d3

**bobosh** · 28/03/2010, 19h32

Je ne vois pas du tout comment utiliser cet évènement.

J'aimerais juste pouvoir à la manière d'outlook ajouter des rendez vous sur ce planning.

CellPainting permet d'ajouter un rendez vous sur le datagrid, sur plusieurs lignes ?

J'ai trouvez plusieurs planning qui faisait cela sur http://www.codeproject.com mais ceux ci n'utilise pas cellpainting.

**Graffito** · 28/03/2010, 20h22

CellPainting permet d'ajouter un rendez vous sur le datagrid, sur plusieurs lignes ?

CellPainting permet de tracer le contenu des cellules de sonchoix.

Supposons que la Cellule[n,2] et Cellule[n,3] soient fusionnées.
Quand on sera sur le paint de Cellule[n,2], comme on peut tracer au-dela des "Bounds" fournie par l'event, on tracera la cellule fusionnée sur des "Bounds" étendues à droite sur la Cellule{n,3].
Quand on sera sur le paint de Cellule[n,3], on tracera la même chose sur des "Bounds" étendues à gauche.

**bobosh** · 28/03/2010, 20h46

je ne suis pas sur de tout saisir.

Aurais tu un lien vers de la doc ou autre.

J'ai regardé sur mdsn et d'après ce que je comprends cela permet de personnaliser les cellules mais il n'y a pas plus de doc que ça.

Je joints une image montrat ce que je veux faire.

Merci encore de tes réponses

**Graffito** · 28/03/2010, 21h26

Pour écrire dans et en dehors de la cellule:

e.CellBounds définit le rectangle correspondant à la cellule,
e.graphics permet de faire des tracés à la main comme dans le BitMap d'une PictureBox (voir quelques fonctions de tracé dans le code ci-dessous). Ces tracés peuvent déborder sur d'autres cellules.
e.value indique le contenu texte standard de la cellule.
e.ColumnIndex && e.RowIndex et devraient te permettre de déterminer suivant l'heure et le jour ce qu'il faut tracer.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
      Rectangle newRect = new Rectangle(e.CellBounds.X + 1,
            e.CellBounds.Y + 1, e.CellBounds.Width - 4,
            e.CellBounds.Height - 4);
 
        using (
            Brush gridBrush = new SolidBrush(this.dataGridView1.GridColor),
            backColorBrush = new SolidBrush(e.CellStyle.BackColor))
        {
            using (Pen gridLinePen = new Pen(gridBrush))
            {
                // Erase the cell.
                e.Graphics.FillRectangle(backColorBrush, e.CellBounds);
 
                // Draw the grid lines (only the right and bottom lines;
                // DataGridView takes care of the others).
                e.Graphics.DrawLine(gridLinePen, e.CellBounds.Left,
                    e.CellBounds.Bottom - 1, e.CellBounds.Right - 1,
                    e.CellBounds.Bottom - 1);
                e.Graphics.DrawLine(gridLinePen, e.CellBounds.Right - 1,
                    e.CellBounds.Top, e.CellBounds.Right - 1,
                    e.CellBounds.Bottom);
 
                // Draw the inset highlight box.
                e.Graphics.DrawRectangle(Pens.Blue, newRect);
 
                // Draw the text content of the cell, ignoring alignment.
                if (e.Value != null)
                {
                    e.Graphics.DrawString((String)e.Value, e.CellStyle.Font,
                        Brushes.Crimson, e.CellBounds.X + 2,
                        e.CellBounds.Y + 2, StringFormat.GenericDefault);
                }
                e.Handled = true;
            }
        }

**bobosh** · 29/03/2010, 10h01

je te remercie,

je trouve ça déjà plus clair.

Si tu avais quelques liens la dessus ça m'éviterais de venir vous déranger tout le temps avec mes questions.

J'ai cherché mais j'ai pas grand chose d'interressant

**bobosh** · 30/03/2010, 18h26

J'ai ajouté un évènement sur cellpainting de la façcon suivante

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
 
 this.CellPainting += new DataGridViewCellPaintingEventHandler(Calendrier_CellPainting);
 
        }

et J'ai ensuite ajouté cette méthode dans ma classe calendrier qui dériver d'un datagridview :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
        void Calendrier_CellPainting(object sender, DataGridViewCellPaintingEventArgs e)
{
// Retrieve the client location of the mouse pointer.
            Point cursorPosition =
                this.PointToClient(Cursor.Position);
 
            // If the mouse pointer is over the current cell, draw a custom border.
            if (e.CellBounds.Contains(cursorPosition))
            {
 
                Rectangle newRect = new Rectangle(e.CellBounds.X + 1,
                    e.CellBounds.Y + 1, e.CellBounds.Width - 4,
                    e.CellBounds.Height + 20);
 
                e.Graphics.DrawRectangle(Pens.Red, newRect);
            }
        }

Si j'ai bien compris, Cellpainting est l'événement qui est appelé lors de la génération du datagridview.

Cela permet donc d'ajouter une nouvelle méthode lorsque le datagridview est dessiné ?

Quelle est la différence avec la surcharge de la méthode OnCellPainting ?

Le morceau de code ajouté ne créé un cadre rouge a l'intérieur de la cellule seulement au moment du clic et disparaît ensuite.

Comment faire pour qu'il soit permanant ?

Et si je déborde sur une autre cellule, celui ci passe sous la cellule.
Comment faire pour qu'il passe au dessus ?

cellBounds est la cellule actuelle en train d'être repaint?

Mais clipBounds correspond à quoi ?

J'ai pour clipbounds :

Rectangle qui représente la zone de DataGridView qui doit être repeinte.

Cela ne correspond pas déjà à cellbounds ?

merci

**Graffito** · 30/03/2010, 22h11

Tester la position curseur pour repeindre est à éviter formellement.
Par contre, tu devrais tester si e.State==DataGridViewElementStates.Selected pour mettre un fond de couleur différente.

De plus, pour fusionner 2 cellules A et B, il faut peindre le dessin de "A+B", lorsqu'on peint "A" ET lorsqu'on peint "B".

**bobosh** · 31/03/2010, 20h16

j'ai fais un test.

Je paint la cellule A et je lui donne la taille de 2 cellules en hauteur de la manière suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
 
 
if (e.RowIndex == 1)
            {
                if (e.ColumnIndex == 1)
                {
                    e.PaintBackground(e.ClipBounds, true);
                    Rectangle r = e.CellBounds;
                    Rectangle r1 = this.GetCellDisplayRectangle(2, 1, true);
                    r.Width -= 1;
                    r.Height += r1.Height - 1;
                    using (SolidBrush brBk = new SolidBrush(Color.FromArgb(50,0,0,255)))
                    using (SolidBrush brFr = new SolidBrush(e.CellStyle.ForeColor))
                    {
                        e.Graphics.FillRectangle(brBk, r);
                        StringFormat sf = new StringFormat();
                        sf.Alignment = StringAlignment.Center;
                        sf.LineAlignment = StringAlignment.Center;
                        e.Graphics.DrawString("cell merged", e.CellStyle.Font, brFr, r, sf);
                    }
                    e.Handled = true;
                }
 
            }

La cellule devrait donc deborder sur la cellule du dessous, mais elle passe en dessous.

Je doit donc redéfinir la cellule se trouvant en dessous de la première.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
 
// else if (e.RowIndex == 2)
            //{
             //   if (e.ColumnIndex == 1)
               // {
                 //   using (Pen p = new Pen(this.GridColor))
                    //{
                        //e.Graphics.DrawLine(p, e.CellBounds.Left, e.CellBounds.Bottom - 1,
                          //  e.CellBounds.Right, e.CellBounds.Bottom - 1);
                       // e.Graphics.DrawLine(p, e.CellBounds.Right - 1, e.CellBounds.Top,
                         //   e.CellBounds.Right - 1, e.CellBounds.Bottom);
                    //}
                    //e.Handled = true;
                //}
           // }

Ce qui fonctionne.

Cependant, je ne comprends pas pourquoi je dois redéfinir cette seconde cellule pour que la première ne passe pas en dessous.

De plus, lorsque j'ajoute un e.handled = true pour la seconde cellule, la première ne passe plus en dessous. Pourquoi ?

Et lorsque je fais ceci, je n'ai plus la bordure du bas et de droite de la celllule du dessous. Je ne comprends pas pourquoi non plus.

**Graffito** · 31/03/2010, 22h50

Tu dois considérer que les cellules se peignent dans un ordre aléatoire qui peut dépendre de l'indice de la CurrentRow, du fait que des cellules deviennent visible, du mouvement sur les scrollbar, ...

C'est pourquoi "il faut peindre le dessin de "A+B", lorsqu'on peint "A" ET lorsqu'on peint "B".

Pour les bordures, cela peut être un effet de bord : vérifie si en peignant "A+B" tu ne débordes pas sur une bordure.

Pour éviter un problème d'ordre de tracé entre l'intérieur des cellules et celui des bordures, tu pourrais être contraint d'utiliser un DGV sans bordure et les dessiner à la main dans le CellPainting.

**bobosh** · 01/04/2010, 19h40

Merci encore de tes réponses.

Je ne pense pas que ce soit un effet de bord pour les bordures des cellules.

J'ai utilisé une couleur transparente pour dessiner mon rectangle, et ainsi je vois la bordure qui sépare les deux cellule initales mais pas les bordures de la secondes cellule.

De plus, c'est un exemple récupéré du msdn et qui par défaut réfinis les mêmes bordures.

Je pense que cela risque d'être complexe pour pouvoir gérer ajout et suppression d'événement.

**Graffito** · 01/04/2010, 19h56

une couleur transparente

La transparence en winforms dépend de l'ordre dans lequel sont repeints les composants. Donc, hormis quelque situations simples, ça ne marche jamais correctement

**bobosh** · 05/04/2010, 15h19

OK.

J'aurais une autre question par rapport au code.

Je me demander ce qui serait mieux d'un point de vue technique pour ajouter des rendez vous à l'aide de la méthode cellpainting :

- Dessiner des rectangles a partir de la première cellule et modifier la coordonnées Y en fonction de l'heure du rendez vous

- Ou alors dessiner le rectangle à partir de la cellule qui correspond à l'heure ?

Car il ne faut pas oublier que certains rendez vous peuvent se chevaucher au niveau des créneaux horaires ?

Et une toute dernière question :

Je pourrais modifier les rendez-vous à partir de ce planning,

Existe t'il des méthodes permettant de récupérer le contenu de ces rectangles et par hasard peut-on mettre un champs caché permettant par exemple de stocker l'id de l'enregistrements dans la base(à par si tu peux me proposer un meilleur solution ?

**Graffito** · 05/04/2010, 18h11

Existe t'il des méthodes permettant de récupérer le contenu de ces rectangles

Comme on maitrise totalement le rendu avec le CellPaiting, on peut mettre dans la Value des cellules toutes les infos necessaires sous forme de chaine formatée ou en tant qu'objet ou que structure.

**bobosh** · 06/04/2010, 23h31

Je rencontre à nouveau un problème.

J'ajoute donc des rendez-vous sur mon planning(je dessine toujours le rectangle de couleur et les bordures des cellules inférieur comme décrit ci-dessus).

Toutefois, lorsque je modifie la taille de ma fenêtre, les rectangles ou bordures que j'ai dessiner ne s'effacent pas et les dessins se multiplient.

Y aurait-il une solution ?

Merci encore

**Graffito** · 07/04/2010, 09h46

Pas normal ça

Une solution possible serait de gérer l'événement Resize du DataGridView et d'y faire un Refresh() du composant.

**bobosh** · 07/04/2010, 14h06

Le problème reste le même, cette méthode n'a aucun effet...

C'est peut être ma fonction qui génère l'évènement que voici

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
 
        public void AddDayAppointement(DataGridViewCellPaintingEventArgs e, Appointment app)
        {
            double rowDebut = (app.heureDebut - Calendrier.heurDebutJourne) * 2;
            double yRow = rowDebut - Math.Floor(rowDebut);
            rowDebut = Math.Floor(rowDebut);
 
 
            double nbCellHeight = (app.heureFin - app.heureDebut) / 0.5;
            //MessageBox.Show(nbCellHeight.ToString());
            //merge the cell[1,1] and cell[2,1]
            if (e.RowIndex == rowDebut)
            {
                if (e.ColumnIndex == 1)
                {
                    e.PaintBackground(e.ClipBounds, true);
                    Rectangle r = e.CellBounds;
 
                    //Rectangle r2 = e.CellBounds;
 
                    Rectangle r1 = this.GetCellDisplayRectangle(2, 1, true);
 
                    r.Width = r.Width / 2;
                    r.Height = (int)(r1.Height * nbCellHeight - 1);
 
                    //r2.Width = r2.Width / 2;
                    //r2.Height += r1.Height / 2 - 1;
 
                    //r2.Y = (int)(e.CellBounds.Y + e.CellBounds.Height*yRow);
 
                    using (SolidBrush brBk = new SolidBrush(Color.FromArgb(50, 0, 0, 255)))
                    using (SolidBrush brFr = new SolidBrush(e.CellStyle.ForeColor))
                    {
                        SolidBrush br = new SolidBrush(Color.FromArgb(50, 0, 255, 0));
                        e.Graphics.FillRectangle(brBk, r);
 
                        //r2.X = r.X + r.Width;
                        //e.Graphics.FillRectangle(br, r2);
 
                        StringFormat sf = new StringFormat();
                        sf.Alignment = StringAlignment.Center;
                        sf.LineAlignment = StringAlignment.Center;
                        e.Graphics.DrawString("cell merged", e.CellStyle.Font, brFr, r, sf);
                    }
                    e.Handled = true;
                }
 
            }
            else
            {
                if (e.ColumnIndex == 1 && e.RowIndex>0 )
                {
                    using (Pen p = new Pen(this.GridColor))
                    {
                        e.Graphics.DrawLine(p, e.CellBounds.Left, e.CellBounds.Bottom - 1,
                            e.CellBounds.Right, e.CellBounds.Bottom - 1);
                        e.Graphics.DrawLine(p, e.CellBounds.Right - 1, e.CellBounds.Top,
                            e.CellBounds.Right - 1, e.CellBounds.Bottom);
                    }
                    e.Handled = true;
                }
            }
        }

J'appelle cette méthode dans cellpainting.