rectangle de selection sur pictureBox

**salihovic** · 01/02/2008, 12h31

salut
j'aime dessiner un rectangle de selection sur un PictureBox situé dans un panel
et j'aime que la selection ne dépasse pas le picture box donc la méthode drowreversibleFrame ne marche pas(sinon avec modification)
et par la suite je veut que ce rectangle soi persistant jusqu'a le prochain click

(et bien sure ne disparet pas si une forme vient audessus de celle ci)
merci pour l'aide
désolé si je pose la meme question deux fois mais l'autre solution ne marche pas

**Chubyone** · 01/02/2008, 12h36

Salut,

Hum,

- Je ne vois pas de question(s) (technique(s))...
- Tu "aimes" et tu "veuX" : ben si tu veux

Mais je te ponderais pas un code entier gratos, et je ne ferais pas ton job...
- Pitié, en plus de l'orthographe, tu massacres même la grammaire.. (j'ai rien compris si tu préfères..)
- Si c'est la même question, pourquoi un second post?

**salihovic** · 01/02/2008, 12h56

le second post c'est pour dire que la première solution est insuffisante
et pour bien éclaircir les choses.
deuxièmment j'ai dis dans l'ancien post que j'ai réussi a faire la selection(rectangle de selection qui parche très bien)
mais le problème que la méthode drawreversibleframe utilisé dessine sur l'écran et elle n'est pas délimité par la zone du pic en plus si je passe une autre forme au dessu le rectangle de selection disparait

voici mon code:

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
 
namespace test
{
    public partial class panelli : Panel
    {
        public panelli()
        {
            InitializeComponent();
        }
      public  bool go = false;
        private bool _selecting = false;
        private Point _selectionStartPoint = Point.Empty;
        private Point _selectionEndPoint = Point.Empty;
        private Rectangle _selectionRect = Rectangle.Empty;
 
        private const FrameStyle SELECTION_STYLE = FrameStyle.Dashed;// FrameStyle.Thick;
 
        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);
 
            if (e.Button == MouseButtons.Left)
            {
                this._selecting = true;
                this._selectionStartPoint = this.PointToScreen(new Point(e.X, e.Y));
                this._selectionEndPoint = Point.Empty;
                this._selectionRect = Rectangle.Empty;
            }
        }
 
        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);
 
            if (this._selecting && go)
            {
                // efface le rectangle de sléection précédent
                ControlPaint.DrawReversibleFrame(this._selectionRect, this.BackColor, SELECTION_STYLE);
 
                // calcul du nouveau rectangle
                this._selectionEndPoint = this.PointToScreen(new Point(e.X, e.Y));
                this._selectionRect = new Rectangle(
                    this._selectionStartPoint.X,
                    this._selectionStartPoint.Y,
                    this._selectionEndPoint.X - this._selectionStartPoint.X,
                    this._selectionEndPoint.Y - this._selectionStartPoint.Y
                    );
 
                // dessin du nouveau rectangle
                ControlPaint.DrawReversibleFrame(this._selectionRect, this.BackColor, SELECTION_STYLE);
            }
        }
 
        protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);
 
            if (this._selecting)
            {
                // efface le rectangle de sélection
                ControlPaint.DrawReversibleFrame(this._selectionRect, Color.BlueViolet, SELECTION_STYLE);
            }
 
            this._selecting = false;
            go = false;
        }
 
 
 
    }
}

l'adresse du post : http://www.developpez.net/forums/sho...32#post2891332
si qualqun a une réponse merci

**SirJulio** · 01/02/2008, 14h35

Salut

ici, tu ne dessines ta selection qu'une seule fois, si la form se refraichit, il ne se dessinera plus. Il faut overrider la methode OnPaint, et si il y a une selection (bool ou test sur la selection contre Rectangle.Empty, comme tu veux), tu redessines cette selection.

**Chubyone** · 01/02/2008, 15h24

Envoyé par SirJulio

tu redessines cette selection.

Tu peux aussi mettre en cache l'image peinte avec la sélection, et tu ne redessines que le rectangle nécessaire (+ de mémoire, mais + rapide)

**salihovic** · 01/02/2008, 20h55

oui je c que pour rendre le rectangle de selecion persistant il faut overrider la méthode onPaint mais mon grand problème c'est quand la selection passe sur des autres controls aussi la selection dépasse le cadre(le pictureBox)
est ce qu'il y a une manière simple pour éviter ça???
ou il faut écrire le code par la main???
c-a-d : il faut faire un override de onPaint oû on écrit g.drawRectangle()
puis dans les autres méthodes onmouse move et down et up on manipule les positions en limitant la zone(si la souris sorte de la zone de pictureBox on la fait rentrer)
je pense que c la seule solution mais j'ai cru que par la classe control paint c plus simple il suffit de donner les rectangles de selection et c tt
mais pour l'autre méthode il faut bien calculer et quand le rectangle s'inverse!!!

si quelqun peut m'aider par un simple code

**salihovic** · 01/02/2008, 20h56

j'ai trouvé ce code mais je sait pas il n'a pas marché chez moi

peut etre j'ai mal écrit

Code :

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

1
2
3
4
5
6
7
8
 
protected override void OnPaint(PaintEventArgs e)
{
   Graphics g = e.Graphics;
   Rectangle inner = selectionRectangle;
   inner.Inflate(-2, -2);
   ControlPaint.DrawSelectionFrame(g, true, selectionRectangle, inner, Color.Black);
}

et pour les onmouse down et on mouse move le calcul des position du rect

**SirJulio** · 01/02/2008, 21h56

Envoyé par salihovic

oui je c que pour rendre le rectangle de selecion persistant il faut overrider la méthode onPaint mais mon grand problème c'est quand la selection passe sur des autres controls aussi la selection dépasse le cadre(le pictureBox)
est ce qu'il y a une manière simple pour éviter ça???
ou il faut écrire le code par la main???
c-a-d : il faut faire un override de onPaint oû on écrit g.drawRectangle()
puis dans les autres méthodes onmouse move et down et up on manipule les positions en limitant la zone(si la souris sorte de la zone de pictureBox on la fait rentrer)
je pense que c la seule solution mais j'ai cru que par la classe control paint c plus simple il suffit de donner les rectangles de selection et c tt
mais pour l'autre méthode il faut bien calculer et quand le rectangle s'inverse!!!

si quelqun peut m'aider par un simple code

Bah tu viens de te donner la solution.

Tu redessines chaque ton rectangle dans le paint (ou toute la partie selectionné, comme propose Chubyone).

Pour la sortie de control, c'est pas bien compliqué, juste un peu long à ecrire, mais tu as compris le truc (pour note ne bloque pas la souris, rien de plus horripilant qu'une appli qui s'amuse avec ta souris) tu arretes d'aggrandir le rectangle si la souris sort.

Bref, la solution tu l'as (t'as fait 80% du job). "y plus ka !"

**salihovic** · 02/02/2008, 09h26

bon j'ai ecrit un petit code mais il contient des erreurs

j'ai un soucis avec la méthode onpaint car quand je fait l'override le controle que j'ai ecrit tromble

aussi j'ai pas bien fait pour dessiner le rectangle inversé

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
65
66
67
68
69
70
71
72
73
74
75
76
77
 
public partial class selectionrect : PictureBox
    {
        public selectionrect()
        {
            InitializeComponent();
            //this.SetStyle(ControlStyles.UserPaint |
            //              ControlStyles.AllPaintingInWmPaint |
            //              ControlStyles.OptimizedDoubleBuffer, true);
        }
        public String position = null;
        private Point _poitdepart=Point.Empty;
        private Point _poitarrive=Point.Empty;
        private Rectangle rect=Rectangle.Empty;
        Point inter = Point.Empty;
        private bool selct = false;
        private Pen pen = new Pen(Color.Yellow);
        protected override void OnMouseDown(MouseEventArgs e)
        {
            //base.OnMouseDown(e);
            if (e.Button == MouseButtons.Left)
            {
                selct = true;
                _poitdepart = new Point(e.X, e.Y);
               _poitarrive=Point.Empty;
                 rect=Rectangle.Empty;
                 inter.X = _poitdepart.X;
                 inter.Y = _poitdepart.Y;
            }
        }
        protected override void OnMouseMove(MouseEventArgs e)
        {
            //base.OnMouseMove(e);
            if (selct)
            {
                _poitarrive = new Point(e.X, e.Y);
                position = _poitarrive.ToString();
                // _poitdepart;
                //voir si le poit d'arrivé est positif sinon inverser
                //pour que le rectangle soit bien dessiné ;)
                if (_poitarrive.X<=inter.X || _poitarrive.Y <=inter.Y)
                {
                    //permuter pour que le rect n'as pas de paramètres négatifs ;)
                    _poitdepart.X = e.X;
                    _poitdepart.Y = e.Y;
                    _poitarrive.X = inter.X;
                    _poitarrive.Y = inter.Y;
                }
 
                //maintenat calcul du rectangle ;)
                rect = new Rectangle(_poitdepart.X, _poitdepart.Y, _poitarrive.X - _poitdepart.X, _poitarrive.Y - _poitdepart.Y);
            }
        }
        protected override void OnMouseUp(MouseEventArgs e)
        {
            //base.OnMouseUp(e);
            //on finit le dessin par désactiver le dessin des rectangles ;)
            selct = false;
            //MessageBox.Show(_poitdepart.ToString()+"\n"+_poitarrive.ToString()+"\n"+rect.ToString());
        }
        protected override void OnPaint(PaintEventArgs pe)
        {
            base.OnPaint(pe);
            //if (selct)
            {
                //on dessine un rectangle avec les coordonnées du rectangel de selection ;)
                Graphics g = pe.Graphics;
                g.DrawRectangle(pen, rect);
                g.DrawString("position" + position, new Font(FontFamily.GenericSerif, 12), Brushes.Red, new PointF(0, 0));
                g.DrawString("arrive" + _poitarrive.ToString(), new Font(FontFamily.GenericSerif, 12), Brushes.Red, new PointF(0, 20));
                g.DrawString("depart" + _poitdepart.ToString(), new Font(FontFamily.GenericSerif, 12), Brushes.Red, new PointF(0, 40));
                g.DrawString("inter" + inter.ToString(), new Font(FontFamily.GenericSerif, 12), Brushes.Red, new PointF(0, 60));
                g.DrawString("rectangle" + rect.ToString(), new Font(FontFamily.GenericSerif, 12), Brushes.Red, new PointF(0, 80));
                this.Invalidate();
            }
        }
    }

**SirJulio** · 02/02/2008, 11h18

Tromble ? =p

Bah vi, c'est normal, si tu appelles Invalidate() dans un Paint, ca va boucler puisque ton control est en permanence invalidé et redessiné. Bref, enleves le Invalidate(), tu n'en as pas besoin puisque tu viens de dessiner.