Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - [C++/Win API] Differenza tra le WindowProcedure
Forum - C/C++ - [C++/Win API] Differenza tra le WindowProcedure

Avatar
Saf (Normal User)
Newbie


Messaggi: 13
Iscritto: 13/07/2010

Segnala al moderatore
Postato alle 20:14
Martedì, 13/07/2010
Ciao a tutti da pochi mesi ho cominciato a studiare il linguaggio C++ applicato alle API di Windows, ho capito che il programma necessita di una WindowProcedure che a seconda dell'evento agisce di conseguenza, però ce ne sono 2 tipi, una Booleana e una di tipo LRESULT.

Finora ho creato un programma che usa la BOOL. La finestra di  dialogo di questo programma la carico da una resource.RC che è stato creato da un editor opportuno, tramite la funzione DialogBoxParam(...);.

Ho provato allora a usare la window procedure di tipo LRESULT senza cambiare altro, ebbene la funzione DialogBoxParam() non funziona più perchè essa necessita di una procedura  booleana (così mi dice il compilatore Dev-C++).
Allora mi è sorto un dubbio: come posso applicare un modello di dialogo al programma se non posso usare la funzione apposita?

Ho notato che quando si usa la LRESULT per creare la finestra si usa la funzione CreateWindow() o CreateWindowEx(), tuttavia in esse non è presente la possibilità di chiamare un modello di dialogo...:(
Inoltre si usa cambiare i parametri della finestra modificando la classe WNDCLASS o una analoga WNDCLASSEX.

Insomma non risco ad applicare il modello alla finestra usando la procedura LRESULT
Spero qualcuno mi faccia capire dove sono le mie lacune...

Saluti..

PM Quote
Avatar
nessuno (Normal User)
Guru^2


Messaggi: 5475
Iscritto: 03/01/2010

Segnala al moderatore
Postato alle 20:58
Martedì, 13/07/2010
Puoi provare ad esprimere i tuoi dubbi con del codice di esempio?

Così si discute delle varie situazioni concretamente.


Ricorda che nessuno è obbligato a risponderti e che nessuno è perfetto ...
PM Quote
Avatar
Saf (Normal User)
Newbie


Messaggi: 13
Iscritto: 13/07/2010

Segnala al moderatore
Postato alle 19:21
Giovedì, 15/07/2010
ok, ma non è facile data la quantità di roba...
Un classico programma senza niente dentro che usa la procedure LRESULT è:

Codice sorgente - presumibilmente C#

  1. #include <windows.h>
  2.  
  3. /*  Declare Windows procedure  */
  4. LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
  5.  
  6. /*  Make the class name into a global variable  */
  7. char szClassName[ ] = "WindowsApp";
  8.  
  9. int WINAPI WinMain (HINSTANCE hThisInstance,HINSTANCE hPrevInstance,
  10.                     LPSTR lpszArgument,int nFunsterStil){
  11.     HWND hwnd;               /* This is the handle for our window */
  12.     MSG messages;            /* Here messages to the application are saved */
  13.     WNDCLASSEX wincl;        /* Data structure for the windowclass */
  14.  
  15.     /* The Window structure */
  16.     wincl.hInstance = hThisInstance;
  17.     wincl.lpszClassName = szClassName;
  18.     wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
  19.     wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
  20.     wincl.cbSize = sizeof (WNDCLASSEX);
  21.  
  22.     /* Use default icon and mouse-pointer */
  23.     wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  24.     wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
  25.     wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
  26.     wincl.lpszMenuName = NULL;                 /* No menu */
  27.     wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
  28.     wincl.cbWndExtra = 0;                      /* structure or the window instance */
  29.     /* Use Windows's default color as the background of the window */
  30.     wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
  31.  
  32.     /* Register the window class, and if it fails quit the program */
  33.     if (!RegisterClassEx (&wincl))
  34.         return 0;
  35.  
  36.     /* The class is registered, let's create the program*/
  37.     hwnd = CreateWindowEx (
  38.            0,                   /* Extended possibilites for variation */
  39.            szClassName,         /* Classname */
  40.            "Windows App",       /* Title Text */
  41.            WS_OVERLAPPEDWINDOW, /* default window */
  42.            CW_USEDEFAULT,       /* Windows decides the position */
  43.            CW_USEDEFAULT,       /* where the window ends up on the screen */
  44.            544,                 /* The programs width */
  45.            375,                 /* and height in pixels */
  46.            HWND_DESKTOP,        /* The window is a child-window to desktop */
  47.            NULL,                /* No menu */
  48.            hThisInstance,       /* Program Instance handler */
  49.            NULL                 /* No Window Creation data */
  50.            );
  51.     /* Make the window visible on the screen */
  52.     ShowWindow (hwnd, nFunsterStil);
  53.  
  54.     /* Run the message loop. It will run until GetMessage() returns 0 */
  55.     while (GetMessage (&messages, NULL, 0, 0)){
  56.         /* Translate virtual-key messages into character messages */
  57.         TranslateMessage(&messages);
  58.         /* Send message to WindowProcedure */
  59.         DispatchMessage(&messages);
  60.     }
  61.     /* The program return-value is 0 - The value that PostQuitMessage() gave */
  62.     return messages.wParam;
  63. }
  64.  
  65. /*  This function is called by the Windows function DispatchMessage()  */
  66. LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
  67.     switch (message) {                 /* handle the messages */
  68.         case WM_DESTROY:
  69.             PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
  70.             break;
  71.         default:                      /* for messages that we don't deal with */
  72.             return DefWindowProc (hwnd, message, wParam, lParam);
  73.     }
  74.  
  75.     return 0;
  76. }


Lo stesso programma nudo e senza comandi particolari con la procedure BOOL può essere uno del tipo:
Codice sorgente - presumibilmente Delphi

  1. #include <windows.h>
  2.  
  3. /*  Declare Windows procedure  */
  4. BOOL CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
  5.  
  6. /* no need to create a windows class for the program  */
  7.  
  8. int WINAPI WinMain (HINSTANCE hThisInstance,HINSTANCE hPrevInstance,
  9.                     LPSTR lpszArgument,int nFunsterStil){
  10.     HWND hwnd;               /* This is the handle for our window */
  11.     MSG messages;            /* Here messages to the application are saved */
  12.  
  13.     /*upload the dialog template from .rc file and show window*/
  14.     DialogBoxParam(0, "nameOfDialog", 0, WindowProcedure, 0);
  15.     ShowWindow (hwnd, nFunsterStil);
  16.  
  17.     /* Run the message loop. It will run until GetMessage() returns 0 */
  18.     while (GetMessage (&messages, NULL, 0, 0)){
  19.         /* Translate virtual-key messages into character messages */
  20.         TranslateMessage(&messages);
  21.         /* Send message to WindowProcedure */
  22.         DispatchMessage(&messages);
  23.     }
  24.     /* The program return-value is 0 - The value that PostQuitMessage() gave */
  25.     return messages.wParam;
  26. }
  27.  
  28. /*  This function is called by the Windows function DispatchMessage()  */
  29. BOOL CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
  30.     switch (message) {                 /* handle the messages */
  31.         case WM_DESTROY:
  32.             PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
  33.             break;
  34.             }
  35.     return 0;
  36. }



Ecco, questo è il programma nudo con le due diverse winProcedure. Come si vede su quello con LRESULT il programma viene disegnato usando la classe WNDCLASS mentre con la procedure BOOL si può facilmente caricare un modello da un file resource.RC.
Tuttavia se uso la LRESULT non posso più usare la funzione DialogBoxParam() per caricare il modello di dialogo, perciò qui mi sono bloccato perchè ho un bellissimo modello di dialogo fatto con un editor che non posso applicare :(
Come posso caricare il modello di dialogo?

PM Quote