raffraichissement affiche regionsRésolu

Question

Bonjour la communauté,
Je travaille sur un programme sous vc++ 6. Il est question de régions.
L’idée est la suivante :
J’ai un bitmap « fond » avec des zones transparentes, cela constitue hRgnTemp[0]
Dans les parties transparentes, j’ai encore d’autres régions (bitmaps) qui viennent s’incruster et interagir avec le clavier. hRgnTemp[1].
hRgnTemp[1] doit réagir à VK_UP ou VK_DOWN.
hRgnTemp[3], une 3eme région fixe

Mon problème est le suivant :
Lorsque j’appuie par exemple sur la flèche vers le haut, la région correspondante est mise à jour, c’est correcte. Si je reviens avec la touche flèche vers le bas, les images correspondantes se chargent, mais celles qui précèdent ne s’effacent pas : les régions se superposent !
Je ne vois pas l'erreur, ou ce qui manque, et bien sûr j'ai tort puisque cela ne fonctionne pas!
Mille Merci pour toute aide.
Une partie du code:

static int Direction = 5; //pour le choix de l'image
static long FAR PASCAL WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam );
static void ReleaseAll(HDC hDCMem, HGDIOBJ hOld, HWND hWnd);
long FAR PASCAL WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
    static HRGN hRgnClip ;
    HRGN        hRgnTemp[3] ;
    int         i ;
    static HBITMAP s_hBmpFond;
    static HBITMAP s_hBmpOrigine, s_hBmpUp1, s_hBmpUp2, s_hBmpUp3, s_hBmpUp4;
    static HBITMAP s_hBmpDown21, s_hBmpDown22, s_hBmpDown23, s_hBmpDown24;
    static BITMAP s_bm;
    static int Direction = 5;
    
    switch( message )
    {
    case WM_CREATE :
{
    int cxTitle, cyTitle;
    DWORD dwStyle;
    // On charge le fond : On recupere les dims de l'img et on cree une region
    s_hBmpFond = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_FOND));
    GetObject(s_hBmpFond, sizeof(s_bm), (LPSTR)&s_bm);
    cxTitle = GetSystemMetrics(SM_CXFRAME) + 1;
    cyTitle = GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFIXEDFRAME) + 1;

// chargement des images
    s_hBmpOrigine = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_NUM_1));
    GetObject(s_hBmpOrigine, sizeof(s_bm), (LPSTR)&s_bm);

    s_hBmpUp1 = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_NUM_11));
    GetObject(s_hBmpUp1, sizeof(s_bm), (LPSTR)&s_bm);

    s_hBmpUp2 = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_NUM_12));
    GetObject(s_hBmpUp2, sizeof(s_bm), (LPSTR)&s_bm);

    s_hBmpUp3 = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_NUM_13));
    GetObject(s_hBmpUp3, sizeof(s_bm), (LPSTR)&s_bm);

    s_hBmpUp4 = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_NUM_14));
    GetObject(s_hBmpUp4, sizeof(s_bm), (LPSTR)&s_bm);

    s_hBmpDown21 = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_NUM_21));
    GetObject(s_hBmpDown21, sizeof(s_bm), (LPSTR)&s_bm);

    s_hBmpDown22 = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_NUM_22));
    GetObject(s_hBmpDown22, sizeof(s_bm), (LPSTR)&s_bm);

    s_hBmpDown23 = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_NUM_23));
    GetObject(s_hBmpDown23, sizeof(s_bm), (LPSTR)&s_bm);

    s_hBmpDown24 = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_NUM_24));
    GetObject(s_hBmpDown24, sizeof(s_bm), (LPSTR)&s_bm);

    s_hBmImgFixe = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_RADIO_0));
    GetObject(s_hBmImgFixe, sizeof(s_bm), (LPSTR)&s_bm);

    hRgnTemp[0] = BitmapToRegion (s_hBmpFond); // region0 == fond, ne bouge pas
    // region1 change en fct de la touche UP/DOWN
    if (Direction 0){hRgnTemp[1] BitmapToRegion (s_hBmpDown24);}
    else if (Direction 1){hRgnTemp[1] BitmapToRegion (s_hBmpDown24);}
    else if (Direction 2){hRgnTemp[1] BitmapToRegion (s_hBmpDown23);}
    else if (Direction 3){hRgnTemp[1] BitmapToRegion (s_hBmpDown22);}
    else if (Direction 4){hRgnTemp[1] BitmapToRegion (s_hBmpDown21);}
    else if (Direction 5){hRgnTemp[1] BitmapToRegion (s_hBmpOrigine);}
    else if (Direction 6){hRgnTemp[1] BitmapToRegion (s_hBmpUp1);}
    else if (Direction 7){hRgnTemp[1] BitmapToRegion (s_hBmpUp2);}
    else if (Direction 8){hRgnTemp[1] BitmapToRegion (s_hBmpUp3);}
    else if (Direction 9){hRgnTemp[1] BitmapToRegion (s_hBmpUp4);}
    else if (Direction 10){hRgnTemp[1] BitmapToRegion (s_hBmpUp4);}
    else{hRgnTemp[1] = BitmapToRegion (s_hBmpUp4);}
    hRgnTemp[2] = BitmapToRegion (s_hBmImgFixe); //region2, ne change pas
    hRgnClip = CreateRectRgn( 0, 0, 0, 0);
    hRgnTemp[3] = CreateRectRgn( 0, 0, 0, 0); // fond XOR hRgnTemp[1] => hRgnTemp[3]
    CombineRgn (hRgnTemp[3],    hRgnTemp[1], hRgnTemp[0], RGN_XOR) ; // hRgnTemp[3] XOR region2 => region cumulée
    CombineRgn (hRgnClip,    hRgnTemp[2], hRgnTemp[3], RGN_XOR) ; 

for (i = 0 ; i < 3 ; i++)
                DeleteObject (hRgnTemp[i]) ;
    InvalidateRgn(hWnd, hRgnClip, TRUE); //maj affichage
    break;
}
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE:
PostQuitMessage(0);
break;
case VK_UP:
break;
case VK_RIGHT:
if (Direction < 10)
{Direction = Direction++;
InvalidateRect(hWnd, NULL, NULL);}
else 
Direction = Direction;  //Direction=10
break;
case VK_LEFT:
if (Direction > 1)
{Direction = Direction--;
InvalidateRect(hWnd, NULL, NULL);}
else
Direction = Direction; //Direction=0
        break;
}

    case WM_PAINT:
{
    HDC hDC, hDCMem; 
    HGDIOBJ hOld;
    PAINTSTRUCT ps;
    	    
    hDC = BeginPaint( hWnd, &ps );
    // Copie de l'image sur l'ecran : Le fait d'avoir defini des regions
    // est maintenant gere par Windows
    hDCMem = CreateCompatibleDC(hDC);
    hOld = SelectObject( hDCMem, s_hBmpFond);	
    BitBlt( hDC, 0, 0, s_bm.bmWidth, s_bm.bmHeight, hDCMem, 0, 0, SRCCOPY );

if (Direction 0){hOld SelectObject( hDCMem, s_hBmpDown24);}
else if (Direction 1){hOld SelectObject( hDCMem, s_hBmpDown24);}
else if (Direction 2){hOld SelectObject( hDCMem, s_hBmpDown23);}
else if (Direction 3){hOld SelectObject( hDCMem, s_hBmpDown22);}
else if (Direction 4){hOld SelectObject( hDCMem, s_hBmpDown21);}
else if (Direction 5){hOld SelectObject( hDCMem, s_hBmpOrigine);}
else if (Direction 6){hOld SelectObject( hDCMem, s_hBmpUp1);}
else if (Direction 7){hOld SelectObject( hDCMem, s_hBmpUp2);}
else if (Direction 8){hOld SelectObject( hDCMem, s_hBmpUp3);}
else if (Direction 9){hOld SelectObject( hDCMem, s_hBmpUp4);}
else if (Direction >10){hOld SelectObject( hDCMem, s_hBmpUp4);}
else{hOld = SelectObject( hDCMem, s_hBmpUp4);}
BitBlt( hDC, 0, 0, s_bm.bmWidth, s_bm.bmHeight, hDCMem, 0, 0, SRCPAINT ); //SRCPAINT
        hOld = SelectObject( hDCMem, s_hBmImgFixe);	
BitBlt( hDC, 0, 0, s_bm.bmWidth, s_bm.bmHeight, hDCMem, 0, 0, SRCPAINT );
SetWindowRgn(hWnd, hRgnClip,TRUE);
    ReleaseAll(hDCMem, hOld, hWnd);
    EndPaint( hWnd, &ps );
    return 0L;
}

    case WM_DESTROY :
{
    PostQuitMessage( 0 );
    return 0L;
}
    }

    return DefWindowProc( hWnd, message, wParam, lParam );
}

J'ai essayé InvalidateRect, InvalidateRgn, mais toujours rien.
évidemment, ce que j'ai réussi, c'est grâce au forum, alors je suis à court d'idées. Si quelqu'un peut m'aider, merci infiniment.

mouloudhab · Accepted Answer

Re-bonjour la communauté,
J'ai finalement réussi à trouver la solution, si j'appuie sur une touche, seule l'image concernée est rafraichie (il n'y a plus l'effet de rémanence).

Dans mon code (dont j'ai récupéré une bonne partie sur le forum, sur la gestion des regions), et que j'ai voulu étendre à mon cas (7 regions au lieu de 3). J'ai arrangé différemment les case WM_...

Dans le code initial, les region étaient créées dans WM_CREATE.
Dans le code modifié, elles sont créées dans WM_PAINT.

Un extrait de mon code (seules quelques regions pour ne pas alourdir la page)
pour le contexte, il s'agit d'une vue intérieur d'une voiture, flêches de direction, lumière + radio.

fonction WinMain:

int PASCAL WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow )
{
    HWND hWnd;
    MSG	msg;
    WNDCLASSEX wndclass;
    
    // Init controls
    InitCommonControls();
    // ... code classique

    // Creation de la fenetre
    hWnd = CreateWindow( 
"REGIONSTEST",
"COUCOU",
WS_POPUP|WS_CLIPCHILDREN,
0,
0,
640,
470,
NULL,
NULL,
hInstance,
NULL );
    
    // Affiche la fenetre
    ShowWindow( hWnd, SW_SHOW );
    UpdateWindow( hWnd );
    
    // Boucle des messages
    while( GetMessage( &msg, NULL, 0, 0 ) )
    {
TranslateMessage( &msg );
DispatchMessage( &msg );
    }
    return msg.wParam;
}

fonction WndProc:

long FAR PASCAL WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
    static UINT s_uTimer, s_uTimerBlink;
    static HBITMAP s_hBmpCockpit, s_hBmpVolant, s_hBmpRadio, s_hBmpTdb, s_hBmpLight, s_hBmpRight;
static int s_Chrono = 0;
    
    switch( message )
    {
    case WM_CREATE :
{
s_TRight = FALSE;
    break;
}

    // Dessin de la fenetre
    case WM_PAINT:
{
    int b;
    int cxTitle, cyTitle;
    DWORD dwStyle;
    
    // On supprime MAX et MIN
    dwStyle = GetWindowLong( hWnd, GWL_STYLE );
    dwStyle &= ~(WS_MINIMIZEBOX | WS_MAXIMIZEBOX);
    SetWindowLong( hWnd, GWL_STYLE , dwStyle );
    
    // On charge le visage : On recupere les dims de l'img
    // et on cree une region elliptique
    s_hBmpCockpit = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_COCKPIT));
    GetObject(s_hBmpCockpit, sizeof(s_bm), (LPSTR)&s_bm);
    cxTitle = GetSystemMetrics(SM_CXFRAME) + 1;
    cyTitle = GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFIXEDFRAME) + 1;

    hRgnCockpit = BitmapToRegion (s_hBmpCockpit); // On transforme l'image en région

s_hBmpTdb = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_TDB));
                //à partir de WM_KEYDOWN, je charge le bon bitmap
                // le sélectionne le volant, la radio et la lumière
if (Direction == 55)
{s_hBmpVolant = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_VOLANTM50));}
else if (Direction == 56)
{s_hBmpVolant = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_VOLANTM40));}
else if (Direction == 57)
{s_hBmpVolant = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_VOLANTM30));}
else if (Direction == 58)
{s_hBmpVolant = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_VOLANTM20));}
else if (Direction == 59)
{s_hBmpVolant = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_VOLANTM10));}
else if (Direction == 60)
{s_hBmpVolant = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_VOLANT0));}
else if (Direction == 61)
{s_hBmpVolant = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_VOLANT10));}
else if (Direction == 62)
{s_hBmpVolant = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_VOLANT20));}
else if (Direction == 63)
{s_hBmpVolant = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_VOLANT30));}
else if (Direction == 64)
{s_hBmpVolant = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_VOLANT40));}
else if (Direction == 65)
{s_hBmpVolant = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_VOLANT50));}

if (Radio%8 == 0)
{s_hBmpRadio = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_RADIOE));}
else if (Radio%8 == 1)
{s_hBmpRadio = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_RADIO1));}
else if (Radio%8 == 2)
{s_hBmpRadio = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_RADIO2));}
else if (Radio%8 == 3)
{s_hBmpRadio = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_RADIO3));}
else if (Radio%8 == 4)
{s_hBmpRadio = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_RADIO4));}
else if (Radio%8 == 5)
{s_hBmpRadio = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_RADIO5));}
else if (Radio%8 == 6)
{s_hBmpRadio = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_RADIO6));}
else if (Radio%8 == 7)
{s_hBmpRadio = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_RADIO7));}

if (Light)
{s_hBmpLight = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_LIGHT));}
else if (!Light)
{s_hBmpLight = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_LIGHTE));}
                // là cela va faire l'objet de mon prochain post.
if(s_TRight)
{s_hBmpRight = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_TRIGHT));}
else if(!s_TRight)
{
s_hBmpRight = LoadBitmap( GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_LIGHTE));
}
                // je transforme les bmp en regions
hRgnTdb = CreateRectRgn( 0, 0, 0, 0);
hRgnLight = CreateRectRgn( 0, 0, 0, 0);
hRgnVolant = CreateRectRgn( 0, 0, 0, 0);
hRgnRadio = CreateRectRgn( 0, 0, 0, 0);
hRgnRight = CreateRectRgn( 0, 0, 0, 0);

hRgnTdb = BitmapToRegion(s_hBmpTdb);
hRgnLight = BitmapToRegion(s_hBmpLight);
        hRgnVolant = BitmapToRegion (s_hBmpVolant);
hRgnRadio = BitmapToRegion (s_hBmpRadio);
hRgnRight = BitmapToRegion (s_hBmpRight);
    

hRgnTemp = CreateRectRgn( 0, 0, 0, 0);
        hrgnDest = CreateRectRgn( 0, 0, 0, 0);
CombineRgn(hRgnTemp, hRgnTdb, hRgnLight, RGN_OR); // Lumière + TDB
CombineRgn(hRgnTemp, hRgnTemp, hRgnCockpit, RGN_OR); // Cockpit + (Lumière + TDB)
        CombineRgn( hRgnTemp, hRgnTemp, hRgnVolant,RGN_OR ); // Volant + précédent
CombineRgn( hrgnDest, hRgnRadio, hRgnTemp,RGN_OR ); // Radio + précédent

CombineRgn( hrgnDest, hrgnDest, hRgnRight, RGN_OR); // cligno + précédent

    //je supprime les regions au fur et à mesure
DeleteObject(hRgnTdb);
DeleteObject(hRgnLight);
DeleteObject(hRgnCockpit);
DeleteObject(hRgnVolant);
DeleteObject(hRgnRadio);
DeleteObject(hRgnRight);
DeleteObject(hRgnTemp);

    // Soit au final :
    b = SetWindowRgn( hWnd, hrgnDest, TRUE );

    HDC hDC, hDCMem; 
    HGDIOBJ hOld;
    PAINTSTRUCT ps;
    hDC = BeginPaint( hWnd, &ps );
    
    // on empile les regions les unes sur les autres avec BitBlt
    hDCMem = CreateCompatibleDC(hDC);
    hOld = SelectObject( hDCMem, s_hBmpCockpit );	    
    BitBlt( hDC, 0, 0, s_bm.bmWidth, s_bm.bmHeight, hDCMem, 0, 0, SRCCOPY );

    hOld = SelectObject( hDCMem, s_hBmpTdb );	    
    BitBlt( hDC, 0, 0, s_bm.bmWidth, s_bm.bmHeight, hDCMem, 0, 0, SRCPAINT );

    hOld = SelectObject( hDCMem, s_hBmpLight );	    
    BitBlt( hDC, 0, 0, s_bm.bmWidth, s_bm.bmHeight, hDCMem, 0, 0, SRCPAINT );

    hOld = SelectObject( hDCMem, s_hBmpVolant );
    BitBlt( hDC, 0, 0, s_bm.bmWidth, s_bm.bmHeight, hDCMem, 0, 0, SRCPAINT );

    hOld = SelectObject( hDCMem, s_hBmpRadio );
    BitBlt( hDC, 0, 0, s_bm.bmWidth, s_bm.bmHeight, hDCMem, 0, 0, SRCPAINT );

    hOld = SelectObject( hDCMem, s_hBmpRight );
    BitBlt( hDC, 0, 0, s_bm.bmWidth, s_bm.bmHeight, hDCMem, 0, 0, SRCPAINT );

    SelectObject( hDCMem, hOld );
    ReleaseDC( hWnd, hDCMem );
    
    EndPaint( hWnd, &ps );
    return 0L;
}

case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE: //je quitte l'appli
PostQuitMessage(0);
break;
case VK_RIGHT:  //tourne à droite
if (Direction >60){
s_uTimer = SetTimer( hWnd, ID_TIMER_RIGHT, 1000, NULL );
}
Direction++;
if (Direction >= 65)
Direction = 65;
break;
case VK_LEFT:  //tourne à gauche
if (Direction < 59){
s_uTimerBlink = SetTimer( hWnd, ID_TIMER_LEFT, 1000, NULL );
}
Direction--;
if (Direction <= 55)
Direction = 55;
break;
case (0x52):
Radio++;
break;
case (0x4C):  // lumière
Light = !Light;
break;
case (0x45):  // radio off
Radio = 0;
break;
}
InvalidateRect(hWnd, NULL, TRUE);	

    // Gestion des clignotants 
    case WM_TIMER:
{
switch (wParam)
{
case ID_TIMER_RIGHT:
s_TRight = !s_TRight;
InvalidateRect(hWnd, NULL, TRUE);
return 0;

case ID_TIMER_LEFT:
s_TLeft = !s_TLeft;
InvalidateRect(hWnd, NULL, TRUE);
return 0;
}
    break;
}

    case WM_DESTROY :
{
    // Restons propres
    KillTimer( hWnd, s_uTimer );
KillTimer(hWnd, s_uTimerBlink);
    // Fin
    PostQuitMessage( 0 );
    return 0L;
}
    }
    return DefWindowProc( hWnd, message, wParam, lParam );
}

Cela fonctionne maitenant, du moins pour ce qui concerne le rafraichissement des images.
Je clôture ce sujet, et je vais en ouvrir un autre sur la gestion des Timers, enfin pas tout à fait (mes images se succèdent bien, et puis HOP, ma fenêtre passe en REDUIT, c'est PÔ pratique!).

Merci mille fois à tous ceux qui ont pris la peine de penser à mon problème, et à ceux qui m'ont proposé leurs aides!

yann_lo_san · Answer

Salut,

As tu essayé ceci ?

// efface la région au BeginPaint
::InvalidateRgn(
    hWnd,  
    hRgnClip,    
    TRUE /*BOOL bErase*/ ); 

// Force Redraw
::RedrawWindow(  
  hWnd,
  NULL,
  hRgnClip, // je ne suis pas sur de cette région par rapport à tn code
  RDW_INVALIDATE | RDW_UPDATENOW);

bye...

ToutEnMasm · Answer

Mauvaise gestion de l'évènement paint.
Il ne faut faire que de l'affichage içi,BitBlt est suffisant.Mettre les autres fonctions ailleurs pour gagner du temps à l'affichage

Pour l'évènement touche,il faut rajouter:
RedrawWindow,hwnd,rect,Hrgn,RDW_INTERNALPAINT

Cela force l'évènement paint et tout est changer.

mouloudhab · Answer

Bonjour à tous,
et Merci à yann_lo_san et ToutEnMasm.

J'ai essayé les deux idées. Je suis d'accord avec TouEnMasm concernant l'évènement WM_PAINT, il est chargé. Il faudra que je mette mes boucles if en dehors, dans une fonction autre, et ne laisser que BitBlt (je ne sais pas si en terme d'exécution j'y gagnerais quelque chose!)

pour l'évènement touche, je génère bien l'évènement PAINT avec le InvalidateRect(hWnd, NULL, TRUE); avec TRUE cela efface toute l'image dés que je change de touche (ex: 2x RIGHT, puis LEFT°, et avec FALSE, ça garde toute les régions (au début non!: si je fais uniquement RIGHT, c'est ok).

Si je mets InvalidateRgn(hWnd, hRgnClip, TRUE /*BOOL bErase*/ );
avant BeginPaint, les images se succèdent et ne s'éffacent pas!

Je vais essayer le InvalidateRgn encore, avec la région concernée seule:
c'est à dire: hRgnTemp[1]. Là, si je mets ça en l'état, j'ai un warning, hRgnTemp[1] n'est pas initialisée, et j'ai le même résultat, les régions ne s'éffacent pas!

Encore, merci à tous, mon problème persiste toujours!
si vous avez d'autres idées, je suis preneur.

ToutEnMasm · Answer

Un petit exemple (en assembleur) résolvant le problème.
L'évèvenement timer peut tout simplement être changé en évènement touche.
animation,régions et images.

mouloudhab · Answer

Bonjour,
Merci TouEnMasm.
Je vais regarder l'exemple, et voir ce que je peux en tirer.

Mais en fait, mon problème n'est pas l'évènement "touche"!
Je comprends bien que lorsque j'appuie sur la bonne touche, j'insère:
InvaldateRgn ou InvalidateRect, ce qui doit générer le message WM_PAINT.

Seleument, une fois dans WM_PAINT, mon affichage n'est pas mis à jour, c'est-à-dire: La nouvelle image apparait, et l'ancienne ...aussi!

Pour tout dire, c'est simple, j'ai repris un tableau de bord de voiture, et j'ai isolé le volant. Si j'appuie à droite, le volant tourne à droite.

Si j'appuie à gauche, le volant va à gauche...

Au début, je vais à droite, c'est bon, tout est ok.
Dés que je reviens vers la gauche, les régions se superposent les unes aux autres, et cela, même si je mets InvalidateRgn ou InvalidateRect dans WM_KEYDOWN.

Le principe, je l'ai compris, mais .... c'est tout!
Merci pour toute aide.

ToutEnMasm · Answer

InvalidateRect est la fonction la plus difficile a utiliser qui soit.Seul le systeme sait bien s'en servir.
j'insiste,
RedrawWindow,hwnd,rect,Hrgn,RDW_INTERNALPAINT 
va bien.

mouloudhab · Answer

bonjour,
ok, j'essaie cela ce matin.
Dans WM_KEYDOWN, case etc...je mets à jour ma variable, puis, je termine par RedrawWindow,hwnd,rect,Hrgn,RDW_INTERNALPAINT.

Je l'avais essayé, mais bon, je revérifie. 

J'ai donc mis exactement ceci:
RedrawWindow(hWnd, NULL, hRgnVolant, RDW_INTERNALPAINT); 
dans les différents case, et j'ai l'impression que le WM_PAINT n'est pas généré, pourtant si!

J'ai fait un debug, avec point d'arrêt à l&#8217;intérieur de la boucle else if (Direction==2) dans le WM_PAINT. Le programme y rentre bien et charge les bonnes images, mais c'est curieux, mon affichage n'est pas mis à jour. Et chose curieuse aussi! Mon programme ne sort plus de la boucle de message principale:
while(GetMessage(&msg, NULL,0,0))
{TranslateMessage(&msg);
DispatchMessage(&msg);}

Une explication peut-être? Merci beaucoup, je continue de creuser bien sûr.

racpp · Answer

Salut,
Si tu peux créer un projet contenant le minimum pour reproduire le problème et nous fournir le lien pour le télécharger peut-être qu'on pourra t'aider. Même en relisant le code je n'arrive pas à me représenter l'anomalie.

Raffraichissement affiche regions

9 réponses

Votre réponse

Discussions similaires