Discussion :

[randriano]

Bonjour, jsuis encore novice sous cet éditeur !

Je parle de tracer une ligne et lorsque l'on maintient toujours le bouton de la souris, la ligne est maintenue. Je pense qu'il suffit de manipuler le message WM_MOUSEMOVE ou WM_LBUTTONDOWN mais je ne sais pas comment redessiner à chaque mouvement et ne pas laisser de trace à l'ancienne place : j'ai essayé d'utiliser des variables pour stocker les positions précédentes puis avant de tracer la nouvelle ligne après move, on trace à la position stockée une ligne blanche mais ça laisse des traces !

Mais je serai si comblé si quelqu'un pourrait m'expliquer le fonctionnement de la ligne dans l'application échantillon de MFC nommé DrawCLI, il s'agit d'une ligne comme sous Word, qu'on peut déplacer, repositionner et redimensionner. Génial non mais comment ?

[stephdim]

Bonsoir,

Il faut utiliser un mode de mixage, une operation XOR lors du tracé.
La technique est de dessiner la ligne avec une logique XOR, c'est à dire, qu'un second dessin de la meme ligne l'effacera (1 XOR 1 = 0)

Pour cela utiliser la fonction SetROP2 du Device Context:

Code :

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

1
2
3
4
5
6
7
8
9
 
pDC->SelectStockObject(BLACK_PEN);     // stylo noir --> a adapter
pDC->SetROP2(R2_NOTXORPEN);            // réglage du mode de mixage
// pour effacer la ligne précédente
pDC->MoveTo(x1,y1);
pDC->LineTo(oldx,oldy);
// pour dessiner la nouvelle ligne
pDC->MoveTo(x1,y1);
pDC->LineTo(newx,newy);

C'est la technique la plus efficace pour dessiner une ligne qui bouge avec la souris.

@+

[randriano]

Bonjour,

J'ai écirt le code suivant avec ton bout de code Stephdim et il ne s'affiche rien, quoi dois-je ajouter pour le rendre opérationnel

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
int oldx,oldy,x1,y1;
 
void CTracerLigneView::OnMouseMove(UINT nFlags, CPoint point) 
{
	CPaintDC pDC(this);
	if ((nFlags & MK_LBUTTON) == MK_LBUTTON){
		pDC.SelectStockObject(BLACK_PEN);     // stylo noir --> a adapter
		pDC.SetROP2(R2_NOTXORPEN);            // réglage du mode de mixage
		// pour effacer la ligne précédente
		pDC.MoveTo(x1,y1);
		pDC.LineTo(oldx,oldy);
		// pour dessiner la nouvelle ligne
		pDC.MoveTo(x1,y1);
		pDC.LineTo(point.x,point.y);
		oldx = point.x;oldy = point.y;
	}
	CView::OnMouseMove(nFlags, point);
}
 
void CTracerLigneView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	x1=point.x;y1=point.y;
	CView::OnLButtonDown(nFlags, point);
}

Entre temps, je comprends la technique du XOR, elle s'applique aussi donc pour le drag d'objet (rectangle, etc.) et bitmap, je veux éviter les trainées qui suivent les drag.

Comment faire aussi des traits comme sous WinWord, un trait déplaçable, qu'on peut déplacer à la fois les 2 extrêmités de la droite ? Le sample de MSDN qui est DrawCLI m'inspire mais il n'y a pas d'explications, donc difficile à comprendre, sauf qu'il y a de l'OLE là dedans.

[stephdim]

Le code est juste sauf que c'est pas CPaintDC qu'il faut utiliser, mais CClientDC.

Avec CPaintDC, le Device Context est préparé (au niveau clippage) pour redessiner des zones préalablement déclarées invalides, ici en l'occurence il n'y en a pas, donc rien n'est dessinable ...

Le bug vient de là

De manière générale: CPaintDC uniquement dans OnPaint !

@+

[stephdim]

Quand on fais un Drag'n'Drop en général, on capture la souris par SetCapture(), de maniere a detecter la souris meme si elle sort de la fenetre. (après on peut faire un AutoScroll, défilement automatique, lorsque la souris est en dehors de la fenetre)

Si on redessine bien la meme ligne (les memes coordonnées d'extremité) il n'y a pas de trainée qui reste ...
Je procède tjrs comme ça j'ai aucun soucis.

Pour déplacer ta ligne, il faut déjà détecté un clic sur cette ligne.
Après la fonction DragDetect() de l'API Windows peut t'aider.

Après c'est le meme principe, mais on deplace les deux extrémités en meme temps.

@+

[randriano]

Bonjour,

Et si on travaille dans OnPaint, comment tirer bénéfice des messages MouseMove et LButtonDown . En fait, avant d'utiliser CPaintDC, j'ai utilisé CClientDC, même si c'est pas approprié, ça ne trace rien au moins je crois il doit y avoir des gribouillis dans le View de l'application SDI.

Concernant les lignes comme dans WinWord, je vais m'informer sur cette méthode DragDetect(). Merci stephdim !
Je suis toujours partant pour des explications sur la ligne dans le sample DrawCLI

[stephdim]

Pourquoi CClientDC n'est il pas approprié ???

CClientDC te retourne un 'Device Context' de toute la zone "dessinable" de la fenetre. CPaintDC te retourne un 'Device Context' sur la region invalide de la fenetre.

Si tu utilises CPaintDC, et les fonctions Invalidate(), tu vas avoir un gros probleme de 'flicker' (clignotement lors de l'affichage)

Je te mets ci dessous a titre d'exemple un bout de code que j'avais realisé pour faire un 'RubberBand' (un rectangle étirable pour sélectionner une zone)

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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
 
void OnLButtonDown(UINT nFlags,CPoint point)
{
  CRect rect;
  if (TrackRubberBand(rect,point))
  {
    if (!rect.IsRectEmpty())
    {
       rect.right++;
       rect.bottom++;
 
       // ici rect est le rectangle sélectionné
 
    }
  }
}
 
// gestion du rectangle de sélection
bool TrackRubberBand(LPRECT pRect,CPoint refpt)
{
  bool result=false;
 
  if (GetCapture()==NULL)
  {
    CPen pen;
    if (pen.CreatePen(PS_DOT,0,RGB(0,0,0)))
    {
      UpdateWindow();                             // mise à jour de l'affichage
 
      AfxLockTempMaps();
 
      SetCapture();                               // capture de la souris
 
      CRect oldrect;                              // rectangle de l'ancienne sélection
      bool visible=false;                         // drapeau 'rectangle visible'
 
      while (GetCapture()==this)
      {
        MSG msg;
        VERIFY(GetMessage(&msg,NULL,0,0));
 
        switch (msg.message)
        {
          case WM_MOUSEMOVE:
          {
            CRect newrect;                        // rectangle de la nouvelle sélection
 
            if (!CalcRubberBand(newrect,refpt,msg.lParam))
              StartAutoScroll();                  // démarrage du défilement automatique
            else
              StopAutoScroll();                   // arret du défilement automatique
 
            if (!newrect.IsRectEmpty())
            {
              newrect.right++;
              newrect.bottom++;
 
              if (visible)
              {
                if (DrawRubberBand(&pen,oldrect,newrect))
                  oldrect=newrect;
              }
              else
              {
                visible=DrawRubberBand(&pen,newrect);
                if (visible)
                  oldrect=newrect;
              }
            }
            else
            {
              if (visible)
              {
                if (!DrawRubberBand(&pen,oldrect))
                {
                  Invalidate();
                  UpdateWindow();
                }
 
                visible=false;
              }
            }
 
            continue;
          }
          case WM_LBUTTONUP:
          {
            if (visible)
              if (!DrawRubberBand(&pen,oldrect))  // effacement du rectangle de sélection
                Invalidate();
 
            CalcRubberBand(pRect,refpt,msg.lParam);   // calcul du rectangle de sélection
 
            result=true;
 
            break;
          }
          case WM_KEYDOWN:
          {
            if (msg.wParam==VK_ESCAPE)
              break;
 
            continue;
          }
          case WM_TIMER:
          {
            if (msg.wParam==ID_AUTOSCROLL_TIMER)
            {
              if (visible)
                if (!DrawRubberBand(&pen,oldrect))
                  Invalidate();
 
              LONG oldx=m_XOrigin;
              LONG oldy=m_YOrigin;
 
              DispatchMessage(&msg);
 
              UpdateWindow();
 
              refpt.x+=m_XOrigin-oldx;
              refpt.y+=m_YOrigin-oldy;
 
              CPoint newpt;
              GetCursorPos(&newpt);
              ScreenToClient(&newpt);
 
              CalcRubberBand(oldrect,refpt,newpt);
 
              if (!oldrect.IsRectEmpty())
              {
                oldrect.right++;
                oldrect.bottom++;
 
                visible=DrawRubberBand(&pen,oldrect);
              }
              else
                visible=false;
            }
            else
              DispatchMessage(&msg);
 
            continue;
          }
          default:
          {
            if (  (msg.message<WM_MOUSEFIRST  ||  msg.message>WM_MOUSELAST) &&
                  (msg.message<WM_KEYFIRST    ||  msg.message>WM_KEYFIRST)  )
            {
              DispatchMessage(&msg);
            }
 
            continue;
          }
        }
 
        ReleaseCapture();                         // libération de la souris
        break;
      }
 
      StopAutoScroll();                         // arret du défilement automatique
      AfxUnlockTempMaps(FALSE);
    }
  }
 
  return result;
}
 
// calcul du rectangle de sélection
bool CalcRubberBand(LPRECT pRect,CPoint refpt,CPoint newpt)
{
  CRect rect;
  GetClientRect(rect);
 
  bool inside=true;
 
  if (newpt.x<0)
  {
    newpt.x=0;
    inside=false;
  }
  else
    if (newpt.x>=rect.right)
    {
      newpt.x=rect.right-1;
      inside=false;
    }
 
  if (newpt.y<0)
  {
    newpt.y=0;
    inside=false;
  }
  else
    if (newpt.y>=rect.bottom)
    {
      newpt.y=rect.bottom-1;
      inside=false;
    }
 
  if (refpt.x<newpt.x)
  {
    pRect->left=refpt.x;
    pRect->right=newpt.x;
  }
  else
  {
    pRect->left=newpt.x;
    pRect->right=refpt.x;
  }
 
  if (refpt.y<newpt.y)
  {
    pRect->top=refpt.y;
    pRect->bottom=newpt.y;
  }
  else
  {
    pRect->top=newpt.y;
    pRect->bottom=refpt.y;
  }
 
  return inside;
}
 
// dessin du rectangle de sélection
bool DrawRubberBand(CPen *pPen,LPCRECT pRect1,LPCRECT pRect2 = /*NULL*/ )
{
  CDC *pDC=GetDC();                             // 'Device Context' de la fenetre
  if (pDC==NULL)
    return false;                               // erreur
 
  CPen *pOldPen=pDC->SelectObject(pPen);        // sélection du stylo
  CGdiObject *pOldBrush=pDC->SelectStockObject(HOLLOW_BRUSH);   // sélection de la brosse
  int ROP=pDC->SetROP2(R2_NOTXORPEN);           // sélection du mode de mixage
 
  pDC->Rectangle(pRect1);
 
  if (pRect2!=NULL)
    pDC->Rectangle(pRect2);
 
  pDC->SetROP2(ROP);                            // restitution de l'ancien mode de mixage
  pDC->SelectObject(pOldBrush);                 // restitution de l'ancienne brosse
  pDC->SelectObject(pOldPen);                   // restitution de l'ancien stylo
 
  ReleaseDC(pDC);                               // libération du 'Device Context'
 
  return true;                                  // succès
}

Comme tu peux le voir, il y a du code
Mais aucun probleme d'affichage, et aucun conflit avec WM_PAINT.

A s'inspirer, et a adapter

@+

[randriano]

Bonjour,

Pour le code que tu as posté Stephdim ! ça marche très bien et je vais m'inspirer sur !
A propos de la technique du mode de mixage, on utilise toujours pDC->SelectStockObject(BLACK_PEN); c-à-d un stylo noir mais comment faire pour d'autres couleurs !

Merci bcp pour l'entraide Stephdim !

[stephdim]

Bonjour,

Pour créer un nouveau stylo regarde la classe CPen des MFC et sa fonction CreatePen --> voir dans MSDN
Le mieux serait de créer ton stylo perso avant d'entrer dans la boucle, et placer un pointeur du stylo en parametre a la fonction DrawLine()

Tous type de stylo (fin/epais, pointilles, couleurs ...) fonctionne avec cette methode

@+

[randriano]

Ok ! Je crois que mon thread est résolu. Merci à tous ceux qui de près ou de loin répondus à cette discussion.