GDI

GDI - API Win32 - Programmation

Marsh Posté le 24-10-2010 à 12:05:03    

Bonjour,
 
Une bonne âme pourrait elle m'aider ? Je ne comprends pas pourquoi mon code ne marche pas alors que j'ai essayé de suivre les préconisations de la MSDN et de différents forums. Un truc m'échappe...
 
Pour l'instant, je veux juste écrire un code simple, pour le complexifier par la suite.
 
Je définis en global :

Code :
  1. #define tailleX 800
  2. #define tailleY 600
  3. DWORD tableau[tailleX * tailleY];


 
J'éxécute en premier dans la winmain :

Code :
  1. for (int i=0;i<tailleX*tailleY;i++) tableau[i]=0x00FF00FF;


 
Et enfin, j'intercepte le message WM_PAINT. Je transforme tableau en hBitmap, puis je le redimensionne pour la fenêtre

Code :
  1. PAINTSTRUCT ps;
  2. HDC hdc=BeginPaint(hWnd, &ps);
  3. RECT tailleFenetre;
  4. BITMAPINFO bi;
  6. bi.bmiHeader.biBitCount=32;
  7. bi.bmiHeader.biClrImportant=0;
  8. bi.bmiHeader.biClrUsed=0;
  9. bi.bmiHeader.biCompression=BI_RGB;
  10. bi.bmiHeader.biHeight=tailleY;
  11. bi.bmiHeader.biWidth=tailleX;
  12. bi.bmiHeader.biPlanes=1;
  13. bi.bmiHeader.biSize=sizeof(bi.bmiHeader);
  14. bi.bmiHeader.biSizeImage=0;
  15. bi.bmiHeader.biXPelsPerMeter=0;
  16. bi.bmiHeader.biYPelsPerMeter=0;
  18. GetClientRect(hWnd, &tailleFenetre);
  19. SetStretchBltMode(hdc, HALFTONE);
  21. HDC hMemDC= CreateCompatibleDC(hdc);
  22. SetStretchBltMode(hMemDC, HALFTONE);
  23. HBITMAP hBitmap= CreateDIBitmap(hMemDC, &bi.bmiHeader,CBM_INIT,tableau,&bi,DIB_RGB_COLORS);
  24. SelectObject(hMemDC, hBitmap);
  25. StretchBlt(hdc, 0, 0, tailleFenetre.right, tailleFenetre.bottom, hMemDC, 0, 0, tailleX, tailleY, SRCCOPY);
  26. DeleteObject(hBitmap);
  27. DeleteDC(hMemDC);
  29. EndPaint(hWnd, &ps);
  30. break;


 
 
J'ai passé 4 heures sur les forums et à reprendre chaque paramétrage un par un pour essayer de comprendre. J'ai essayé d'intercepter les erreurs (aucun appel à une fonction ne renvoie d'erreur). Je m'attends à avoir la zone centrale de ma fenêtre toute violette (0x00ff00ff) et je me retrouve avec une fenêtre toute noire.  
 
 
Code complet :

Code :
  1. #include "stdafx.h"
  2. #include "Projet test.h"
  4. #define MAX_LOADSTRING 100
  5. #define tailleX 800
  6. #define tailleY 600
  9. // Variables globales :
  10. HINSTANCE hInst;        // instance actuelle
  11. TCHAR szTitle[MAX_LOADSTRING];     // Le texte de la barre de titre
  12. TCHAR szWindowClass[MAX_LOADSTRING];   // le nom de la classe de fenêtre principale
  14. DWORD tableau[tailleX * tailleY];
  17. // Pré-déclarations des fonctions incluses dans ce module de code :
  18. ATOM    MyRegisterClass(HINSTANCE hInstance);
  19. BOOL    InitInstance(HINSTANCE, int);
  20. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
  21. INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);
  23. int APIENTRY _tWinMain(HINSTANCE hInstance,
  24.                      HINSTANCE hPrevInstance,
  25.                      LPTSTR    lpCmdLine,
  26.                      int       nCmdShow)
  27. {
  28. UNREFERENCED_PARAMETER(hPrevInstance);
  29. UNREFERENCED_PARAMETER(lpCmdLine);
  31. for (int i=0;i<tailleX*tailleY;i++) tableau[i]=0x00FF00FF;
  32. MSG msg;
  33. HACCEL hAccelTable;
  35. // Initialise les chaînes globales
  36. LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
  37. LoadString(hInstance, IDC_PROJETTEST, szWindowClass, MAX_LOADSTRING);
  38. MyRegisterClass(hInstance);
  40. // Effectue l'initialisation de l'application :
  41. if (!InitInstance (hInstance, nCmdShow))
  42. {
  43.  return FALSE;
  44. }
  46. hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_PROJETTEST));
  48. // Boucle de messages principale :
  49. while (GetMessage(&msg, NULL, 0, 0))
  50. {
  51.  if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
  52.  {
  53.   TranslateMessage(&msg);
  54.   DispatchMessage(&msg);
  55.  }
  56. }
  58. return (int) msg.wParam;
  59. }
  63. //
  64. //  FONCTION : MyRegisterClass()
  65. //
  66. //  BUT : inscrit la classe de fenêtre.
  67. //
  68. //  COMMENTAIRES :
  69. //
  70. //    Cette fonction et son utilisation sont nécessaires uniquement si vous souhaitez que ce code
  71. //    soit compatible avec les systèmes Win32 avant la fonction 'RegisterClassEx'
  72. //    qui a été ajoutée à Windows 95. Il est important d'appeler cette fonction
  73. //    afin que l'application dispose des petites icônes correctes qui lui sont
  74. //    associées.
  75. //
  76. ATOM MyRegisterClass(HINSTANCE hInstance)
  77. {
  78. WNDCLASSEX wcex;
  80. wcex.cbSize = sizeof(WNDCLASSEX);
  82. wcex.style   = CS_HREDRAW | CS_VREDRAW;
  83. wcex.lpfnWndProc = WndProc;
  84. wcex.cbClsExtra  = 0;
  85. wcex.cbWndExtra  = 0;
  86. wcex.hInstance  = hInstance;
  87. wcex.hIcon   = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_PROJETTEST));
  88. wcex.hCursor  = LoadCursor(NULL, IDC_ARROW);
  89. wcex.hbrBackground = 0;
  90. wcex.lpszMenuName = MAKEINTRESOURCE(IDC_PROJETTEST);
  91. wcex.lpszClassName = szWindowClass;
  92. wcex.hIconSm  = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
  94. return RegisterClassEx(&wcex);
  95. }
  97. //
  98. //   FONCTION : InitInstance(HINSTANCE, int)
  99. //
  100. //   BUT : enregistre le handle de l'instance et crée une fenêtre principale
  101. //
  102. //   COMMENTAIRES :
  103. //
  104. //        Dans cette fonction, nous enregistrons le handle de l'instance dans une variable globale, puis
  105. //        créons et affichons la fenêtre principale du programme.
  106. //
  107. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
  108. {
  109.    HWND hWnd;
  111.    hInst = hInstance; // Stocke le handle d'instance dans la variable globale
  113.    hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
  114.       CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
  116.    if (!hWnd)
  117.    {
  118.       return FALSE;
  119.    }
  121.    ShowWindow(hWnd, nCmdShow);
  122.    UpdateWindow(hWnd);
  124.    return TRUE;
  125. }
  127. //
  128. //  FONCTION : WndProc(HWND, UINT, WPARAM, LPARAM)
  129. //
  130. //  BUT :  traite les messages pour la fenêtre principale.
  131. //
  132. //  WM_COMMAND - traite le menu de l'application
  133. //  WM_PAINT - dessine la fenêtre principale
  134. //  WM_DESTROY - génère un message d'arrêt et retourne
  135. //
  136. //
  137. LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  138. {
  140. switch (message)
  141. {
  142. case WM_COMMAND:
  143.         int wmId, wmEvent;
  145.  wmId    = LOWORD(wParam);
  146.  wmEvent = HIWORD(wParam);
  147.  // Analyse les sélections de menu :
  148.  switch (wmId)
  149.  {
  150.  case IDM_ABOUT:
  151.   DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
  152.   break;
  153.  case IDM_EXIT:
  154.   DestroyWindow(hWnd);
  155.   break;
  156.  default:
  157.   return DefWindowProc(hWnd, message, wParam, lParam);
  158.  }
  159.  break;
  160. case WM_PAINT:
  161.          {
  162.          PAINTSTRUCT ps;
  163.          HDC hdc=BeginPaint(hWnd, &ps);
  164.          RECT tailleFenetre;
  165.          BITMAPINFO bi;
  167.   bi.bmiHeader.biBitCount=32;
  168.   bi.bmiHeader.biClrImportant=0;
  169.   bi.bmiHeader.biClrUsed=0;
  170.   bi.bmiHeader.biCompression=BI_RGB;
  171.   bi.bmiHeader.biHeight=tailleY;
  172.   bi.bmiHeader.biWidth=tailleX;
  173.   bi.bmiHeader.biPlanes=1;
  174.   bi.bmiHeader.biSize=sizeof(bi.bmiHeader);
  175.   bi.bmiHeader.biSizeImage=0;
  176.   bi.bmiHeader.biXPelsPerMeter=0;
  177.   bi.bmiHeader.biYPelsPerMeter=0;
  179.             GetClientRect(hWnd, &tailleFenetre);
  180.   SetStretchBltMode(hdc, HALFTONE);
  182.             HDC hMemDC= CreateCompatibleDC(hdc);
  183.   SetStretchBltMode(hMemDC, HALFTONE);
  184.   HBITMAP hBitmap= CreateDIBitmap(hMemDC, &bi.bmiHeader,CBM_INIT,tableau,&bi,DIB_RGB_COLORS);
  187.   //HBITMAP hBitmap=CreateCompatibleBitmap(hMemDC, tailleX, tailleY);
  188.   SelectObject(hMemDC, hBitmap);
  189.   SetDIBits(hMemDC, hBitmap, 0, tailleY, tableau, &bi, DIB_RGB_COLORS);
  191.   StretchBlt(hdc, 0, 0, tailleFenetre.right, tailleFenetre.bottom, hMemDC, 0, 0, 15, 15, SRCCOPY);//tailleX, tailleY, SRCCOPY);
  192.             DeleteObject(hBitmap);
  193.             DeleteDC(hMemDC);
  195.   /*
  196.   SetStretchBltMode(hdc, HALFTONE);
  197.   SetBrushOrgEx(hdc, 0, 0, 0);
  198.          
  199.   StretchDIBits(
  200.            hdc,
  201.            0, 0, 640, 480, //tailleFenetre.right, tailleFenetre.bottom,
  202.            0, 0, tailleX, tailleY,
  203.            tableau,
  204.            &bi,
  205.            0,
  206.            0
  207.          );
  208.   */
  209.          EndPaint(hWnd, &ps);
  210.          break;
  211.         }
  213. case WM_DESTROY:
  214.  PostQuitMessage(0);
  215.  break;
  216. default:
  217.  return DefWindowProc(hWnd, message, wParam, lParam);
  218. }
  219. return 0;
  220. }
  222. // Gestionnaire de messages pour la boîte de dialogue À propos de.
  223. INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  224. {
  225. UNREFERENCED_PARAMETER(lParam);
  226. switch (message)
  227. {
  228. case WM_INITDIALOG:
  229.  return (INT_PTR)TRUE;
  231. case WM_COMMAND:
  232.  if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
  233.  {
  234.   EndDialog(hDlg, LOWORD(wParam));
  235.   return (INT_PTR)TRUE;
  236.  }
  237.  break;
  238. }
  239. return (INT_PTR)FALSE;
  240. }


Reply

Marsh Posté le 24-10-2010 à 12:05:03   

Reply

Marsh Posté le 25-10-2010 à 14:27:44    

La première chose à corriger est :

bi.bmiHeader.biSizeImage=0;


A la place, il faut écrire :

bi.bmiHeader.biSizeImage = bi.bmiHeader.biWidth * 4 * bi.bmiHeader.biHeight * sizeof(unsigned char);


Je n'ai pas regardé la suite en détail.
 
Edit : J'avais mis "* -1", car d'habitude on met un nombre négatif pour la hauteur pour partir du haut vers le bas, au lieu de l'inverse.


Message édité par olivthill le 25-10-2010 à 14:30:09
Reply

Marsh Posté le 25-10-2010 à 16:25:05    

Haha, GDI et son API de merde. Bon, quand je fais joujou avec les bitmaps, je préfère utiliser des DIBSection, c'est moins casse gueule. En essayant de modifier ton code, je n'ai pas réussi à le faire fonctionner non plus. Mais en utilisant des DIBSection, ça fonctionne sans problème. Suffit de réécrire ton WM_PAINT de la sorte :

Code :
  1. {
  2.     PAINTSTRUCT ps;
  3.     HDC hdc=BeginPaint(hWnd, &ps);
  4.     RECT tailleFenetre;
  5.     BITMAPINFO bi = {};
  6.  
  7.     bi.bmiHeader.biBitCount=32;
  8.     bi.bmiHeader.biCompression=BI_RGB;
  9.     bi.bmiHeader.biHeight=tailleY;
  10.     bi.bmiHeader.biWidth=tailleX;
  11.     bi.bmiHeader.biPlanes=1;
  12.     bi.bmiHeader.biSize=sizeof(bi.bmiHeader);
  13.  
  14.     GetClientRect(hWnd, &tailleFenetre);
  15.     SetStretchBltMode(hdc, HALFTONE);
  16.  
  17.     HDC hMemDC= CreateCompatibleDC(hdc);
  18.     SetStretchBltMode(hMemDC, HALFTONE);
  19.     LPVOID data;
  20.     HBITMAP hBitmap = CreateDIBSection(hMemDC, &bi,DIB_RGB_COLORS,&data,NULL,0);
  21. //    HBITMAP hBitmap = CreateDIBitmap(hMemDC, &bi.bmiHeader,CBM_INIT,tableau,&bi,DIB_RGB_COLORS);
  22.  
  23.     memcpy(data, tableau, sizeof tableau);
  24.     HANDLE old = SelectObject(hMemDC, hBitmap);
  25.  
  26.     StretchBlt(hdc, 0, 0, tailleFenetre.right, tailleFenetre.bottom, hMemDC, 0, 0, tailleX, tailleY, SRCCOPY);
  27.     BitBlt(hdc, 0, 0, tailleX, tailleY, hMemDC, 0, 0, SRCCOPY);
  28.     SelectObject(hMemDC, old);
  29.     DeleteObject(hBitmap);
  30.     DeleteDC(hMemDC);
  31.  
  32.     EndPaint(hWnd, &ps);
  33.     break;
  34. }


 
Une petite optimisation serait d'allouer le DIBSection avant la boucle d'événement, et d'initialiser le bitmap renvoyé plutôt que d'utiliser une table statique.

Message cité 1 fois
Reply

Marsh Posté le 25-10-2010 à 19:57:42    

@olivthill
Ce champ peut rester à 0. Je cite la MSDN :

Citation :

biSizeImage The size, in bytes, of the image. This may be set to zero for BI_RGB bitmaps.


J'ai essayé, au cas où, de modifier ce champ mais cela n'améliore pas le résultat.
 
@tpierron
Je vais pas me prendre la tête et utiliser les DIBSection, et je vais même utiliser l'amélioration que tu me proposes. N'empêche que sur le principe mon code de départ ne me parait pas si foireux que ça.
Je dis pas que c'est simple de faire une interface graphique qui puisse adapter à tous les matériels, mais le GDI c'est une belle merde.
 
Merci les amis !

Reply

Marsh Posté le 26-10-2010 à 12:32:39    

Pour infos, voici ma version qui marche, créée en modifiant un peu la version initiale :

Code :
  1. #include <windows.h>
  3. #define MAX_LOADSTRING 100
  4. #define tailleX 800
  5. #define tailleY 600
  6. // Variables globales :
  7. HINSTANCE hInst;        // instance actuelle
  8. // TCHAR szTitle[MAX_LOADSTRING];     // Le texte de la barre de titre
  9. char szTitle[MAX_LOADSTRING];     // Le texte de la barre de titre
  10. // TCHAR szWindowClass[MAX_LOADSTRING];   // le nom de la classe de fenêtre principale
  11. char szWindowClass[MAX_LOADSTRING];   // le nom de la classe de fenêtre principale
  12. DWORD tableau[tailleX * tailleY];
  14. // Pré-déclarations des fonctions incluses dans ce module de code :
  15. ATOM    MyRegisterClass(HINSTANCE hInstance);
  16. BOOL    InitInstance(HINSTANCE, int);
  17. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
  18. INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);
  19. int APIENTRY WinMain(HINSTANCE hInstance,
  20.                      HINSTANCE hPrevInstance,
  21.                      LPTSTR    lpCmdLine,
  22.                      int       nCmdShow)
  23. {
  24. UNREFERENCED_PARAMETER(hPrevInstance);
  25. UNREFERENCED_PARAMETER(lpCmdLine);
  26. for (int i=0;i<tailleX*tailleY;i++) tableau[i]=(DWORD)(0x00FF00FF);
  27. MSG msg;
  28. HACCEL hAccelTable;
  29. // Initialise les chaînes globales
  30. //  ***  LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
  31. strcpy(szTitle, "Test GDI" );
  32. //  *** LoadString(hInstance, IDC_PROJETTEST, szWindowClass, MAX_LOADSTRING);
  33. strcpy(szWindowClass, "Test GDI" );
  34. MyRegisterClass(hInstance);
  35. // Effectue l'initialisation de l'application :
  36. if (!InitInstance (hInstance, nCmdShow))
  37. {
  38. return FALSE;
  39. }
  40. // *** hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_PROJETTEST));
  41. // Boucle de messages principale :
  42. while (GetMessage(&msg, NULL, 0, 0))
  43. {
  44. if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
  45. {
  46.  TranslateMessage(&msg);
  47.  DispatchMessage(&msg);
  48. }
  49. }
  50. return (int) msg.wParam;
  51. }
  52. //
  53. //  FONCTION : MyRegisterClass()
  54. //
  55. //  BUT : inscrit la classe de fenêtre.
  56. //
  57. //  COMMENTAIRES :
  58. //
  59. //    Cette fonction et son utilisation sont nécessaires uniquement si vous souhaitez que ce code
  60. //    soit compatible avec les systèmes Win32 avant la fonction 'RegisterClassEx'
  61. //    qui a été ajoutée à Windows 95. Il est important d'appeler cette fonction
  62. //    afin que l'application dispose des petites icônes correctes qui lui sont
  63. //    associées.
  64. //
  65. ATOM MyRegisterClass(HINSTANCE hInstance)
  66. {
  67.      int i;
  68. WNDCLASSEX wcex;
  69. wcex.cbSize = sizeof(WNDCLASSEX);
  70. wcex.style   = CS_HREDRAW | CS_VREDRAW;
  71. wcex.lpfnWndProc = WndProc;
  72. wcex.cbClsExtra  = 0;
  73. wcex.cbWndExtra  = 0;
  74. wcex.hInstance  = hInstance;
  75. // *** wcex.hIcon   = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_PROJETTEST));
  76. wcex.hIcon   = '\0';
  77. wcex.hCursor  = LoadCursor(NULL, IDC_ARROW);
  78. wcex.hbrBackground = (HBRUSH) COLOR_BACKGROUND;;
  79. // *** wcex.lpszMenuName = MAKEINTRESOURCE(IDC_PROJETTEST);
  80. wcex.lpszMenuName = '\0';
  81. wcex.lpszClassName = szWindowClass;
  82. // *** wcex.hIconSm  = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
  83. // i = RegisterClassEx(&wcex);
  84. return RegisterClassEx(&wcex);
  85. }
  86. //
  87. //   FONCTION : InitInstance(HINSTANCE, int)
  88. //
  89. //   BUT : enregistre le handle de l'instance et crée une fenêtre principale
  90. //
  91. //   COMMENTAIRES :
  92. //
  93. //        Dans cette fonction, nous enregistrons le handle de l'instance dans une variable globale, puis
  94. //        créons et affichons la fenêtre principale du programme.
  95. //
  96. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
  97. {
  98.    HWND hWnd;
  99.    hInst = hInstance; // Stocke le handle d'instance dans la variable globale
  100. //   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
  101. //      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
  102.    hWnd = CreateWindowEx(WS_EX_TOOLWINDOW,szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
  103.       CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
  104.    if (!hWnd)
  105.    {
  106.       return FALSE;
  107.    }
  108.    ShowWindow(hWnd, nCmdShow);
  109.    UpdateWindow(hWnd);
  110.    return TRUE;
  111. }
  112. //
  113. //  FONCTION : WndProc(HWND, UINT, WPARAM, LPARAM)
  114. //
  115. //  BUT :  traite les messages pour la fenêtre principale.
  116. //
  117. //  WM_COMMAND - traite le menu de l'application
  118. //  WM_PAINT - dessine la fenêtre principale
  119. //  WM_DESTROY - génère un message d'arrêt et retourne
  120. //
  121. //
  122. LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  123. {
  124. switch (message)
  125. {
  126. case WM_COMMAND:
  127.         int wmId, wmEvent;
  128. wmId    = LOWORD(wParam);
  129. wmEvent = HIWORD(wParam);
  130. // Analyse les sélections de menu :
  131. switch (wmId)
  132. {
  133. #define IDM_ABOUT 101
  134. case 101:
  135. // ***  DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
  136.  break;
  137. #define IDM_EXIT 999
  138. case IDM_EXIT:
  139.  DestroyWindow(hWnd);
  140.  break;
  141. default:
  142.  return DefWindowProc(hWnd, message, wParam, lParam);
  143. }
  144. break;
  145. case WM_PAINT:
  146.          {
  147.          PAINTSTRUCT ps;
  148.          HDC hdc=BeginPaint(hWnd, &ps);
  149.          RECT tailleFenetre;
  150.     BITMAPINFO bi;
  151. bi.bmiHeader.biBitCount=32;
  152.  bi.bmiHeader.biClrImportant=0;
  153.  bi.bmiHeader.biClrUsed=0;
  154.  bi.bmiHeader.biCompression=BI_RGB;
  155.  bi.bmiHeader.biHeight= -tailleY;
  156.  bi.bmiHeader.biWidth=tailleX;
  157.  bi.bmiHeader.biPlanes=1;
  158.  bi.bmiHeader.biSize=sizeof(bi.bmiHeader);
  159. //  bi.bmiHeader.biSizeImage=0;
  160.     bi.bmiHeader.biSizeImage = bi.bmiHeader.biWidth * 4 * bi.bmiHeader.biHeight * sizeof(unsigned char);
  161.  bi.bmiHeader.biXPelsPerMeter=0;
  162.  bi.bmiHeader.biYPelsPerMeter=0;
  163.             GetClientRect(hWnd, &tailleFenetre);
  164. //  SetStretchBltMode(hdc, HALFTONE);
  165.     HDC hMemDC = GetDC(hWnd);
  166. //  SetStretchBltMode(hMemDC, HALFTONE);
  167.  HBITMAP hBitmap= CreateDIBitmap(hMemDC, &bi.bmiHeader,CBM_INIT,tableau,&bi,DIB_RGB_COLORS);
  168.     ReleaseDC(hWnd, hMemDC);
  169.     hMemDC = CreateCompatibleDC(hdc);
  170.  HBITMAP hbmpold = (HBITMAP)SelectObject(hMemDC, hBitmap);
  171. //    BitBlt(hdc, 0, 0,   // dest
  172. //           (int)tailleX, (int)tailleY,
  173. //                hMemDC,        // src
  174. //                0, 0, SRCCOPY);
  175.  StretchBlt(hdc, 0, 0, tailleFenetre.right, tailleFenetre.bottom, hMemDC, 0, 0, tailleX, tailleY, SRCCOPY);
  176.     SelectObject(hMemDC, hbmpold);
  177.     DeleteDC(hMemDC);
  178. //  HBITMAP hBitmap=CreateCompatibleBitmap(hMemDC, tailleX, tailleY);
  179. // SetDIBits(hMemDC, hBitmap, 0, tailleY, tableau, &bi, DIB_RGB_COLORS);
  180. //            DeleteObject(hBitmap);
  181. /*
  182.  SetStretchBltMode(hdc, HALFTONE);
  183.  SetBrushOrgEx(hdc, 0, 0, 0);
  184.          
  185.  StretchDIBits(
  186.            hdc,
  187.            0, 0, 640, 480, //tailleFenetre.right, tailleFenetre.bottom,
  188.            0, 0, tailleX, tailleY,
  189.            tableau,
  190.            &bi,
  191.            0,
  192.            0
  193.          );
  194.          */
  195.          EndPaint(hWnd, &ps);
  196.          break;
  197.         }
  198. case WM_DESTROY:
  199. PostQuitMessage(0);
  200. break;
  201. default:
  202. return DefWindowProc(hWnd, message, wParam, lParam);
  203. }
  204. return 0;
  205. }
  206. // Gestionnaire de messages pour la boîte de dialogue À propos de.
  207. INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  208. {
  209. UNREFERENCED_PARAMETER(lParam);
  210. switch (message)
  211. {
  212. case WM_INITDIALOG:
  213. return (INT_PTR)TRUE;
  214. case WM_COMMAND:
  215. if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
  216. {
  217.  EndDialog(hDlg, LOWORD(wParam));
  218.  return (INT_PTR)TRUE;
  219. }
  220. break;
  221. }
  222. return (INT_PTR)FALSE;
  223. }

Reply

Marsh Posté le 26-10-2010 à 13:20:57    

tpierron a écrit :

Haha, GDI et son API de merde.

Elle est pas particulièrement merdique quand on passe un peu de temps dedans. Mais elle nécessite un peu d'apprentissage. Faut trouver des infos dans des bouquins un peu anciens comme ceux de Martin Heller (Advanced Win32 Programming, etc), mais je ne sais pas si on les trouve encore hors occase.
A+,

Message cité 1 fois

---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 26-10-2010 à 21:48:29    

gilou a écrit :

Elle est pas particulièrement merdique quand on passe un peu de temps dedans. Mais elle nécessite un peu d'apprentissage. Faut trouver des infos dans des bouquins un peu anciens comme ceux de Martin Heller (Advanced Win32 Programming, etc), mais je ne sais pas si on les trouve encore hors occase.
A+,


 
Sans doute qu'une bonne doc permet de mieux comprendre le fonctionnement de cet API. Ceci dit, j'ai essayé de comprendre pourquoi le code de olivthill marche et pas le mien. En le remodifiant un peu le code suivant marche :  

Code :
  1. PAINTSTRUCT ps;
  2. HDC hdc=BeginPaint(hWnd, &ps);
  3. RECT tailleFenetre;
  4. BITMAPINFO bi; bi.bmiHeader.biBitCount=32; bi.bmiHeader.biClrImportant=0; bi.bmiHeader.biClrUsed=0; bi.bmiHeader.biCompression=BI_RGB;bi.bmiHeader.biHeight= -tailleY; bi.bmiHeader.biWidth=tailleX;  bi.bmiHeader.biPlanes=1;  bi.bmiHeader.biSize=sizeof(bi.bmiHeader);
  5. bi.bmiHeader.biSizeImage=0;  bi.bmiHeader.biXPelsPerMeter=0;  bi.bmiHeader.biYPelsPerMeter=0;
  7. GetClientRect(hWnd, &tailleFenetre);
  8. HBITMAP hBitmap= CreateDIBitmap(hdc, &bi.bmiHeader,CBM_INIT,tableau,&bi,DIB_RGB_COLORS);
  9. hMemDC = CreateCompatibleDC(hdc);
  10. HBITMAP hbmpold = (HBITMAP)SelectObject(hMemDC, hBitmap);
  11. StretchBlt(hdc, 0, 0, tailleFenetre.right, tailleFenetre.bottom, hMemDC, 0, 0, tailleX, tailleY, SRCCOPY);
  12. SelectObject(hMemDC, hbmpold);
  13. DeleteDC(hMemDC);
  14. EndPaint(hWnd, &ps);


 
Ce qui me porte à croire qu'il faut impérativement exécuter le code 'createDIBitmap' avec le Displau device context cible, et pas avec un memory device context. Pour qui ? pour quoi ? ça... mystère.
 
En tous cas merci les gars!

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed