Realizzazione di una Finestra con le API Windows
Mer 03 Ott 2007

Introduzione

Message Box

Struttura di una Finestra

Una Semplice Finestra

Inserimento di un Menù

Costruzione di un Dialog Box

Inserimento di una Toolbar

Inserimento di una Statusbar



Inserimento di una Toolbar

La toolbar è una barra orizzontale in cui sono presenti dei bottoni, è considerata una finestra, ed è posizionata nella parte superiore della finestra genitrice.
Per quanto riguarda le icone da inserire nella toolbar vi sono delle icone appartenenti ad un insieme predefinito che è possibile utilizzare, oppure se ne possono definire delle altre utilizzando il resource builder. In questo caso quando si andrà a salvare oltre al file script.rc e al file resource.h sarà prodotto anche il file toolbarX.bmp che sarà una immagine costituita dalla barra di bottoni definita dall'utente con il resource builder.
Il gruppo di icone predefinito è il seguente STD_COPY, STD_PASTE, STD_CUT, STD_PRINT, STD_DELETE, STD_PRINTPRE, STD_FILENEW, STD_PROPERTIES, STD_FILEOPEN, STD_REDOW, STD_FILESAVE, STD_REPLACE, STD_FIND, STD_UNDO, STD_HELP, VIEW_LARGEICONS, VIEW_SORTNAME, VIEW_SMALLICONS, VIEW_SORTSIZE, VIEW_LIST, VIEW_SORTDATE, VIEW_DETAILS, VIEW_SORTTYPE  

Per aggiungere una toolbar ad una finestra la si deve prima creare. Per farlo, dal momento che viene considerata come una finestra, si utilizza la funzione CreateWindowEx

1. handle = CreateWindowEx(0, TOOLBARCLASSNAME, NULL, WS_CHILD | WS_VISIBLE,
2. 0, 0, 0, 0, hwnd, (HMENU)IDC_MAIN_TOOL,
3. GetModuleHandle(NULL), NULL);

Come nome della finestra viene utilizzato il nome predefinito per le toolbar, TOOLBARCLASSNAME, viene poi indicato che la finestra che si sta costruendo sarà una finestra figlia di un'altra finestra (WS_CHILD), e dovrà essere visibile (WS_VISIBLE). La finestra genitrice sarà quella il cui handle è contenuto in hwnd.
La finestra creata per contenere la Toolbar ha come menù la Toolbar stessa. Praticamente si può considerare la finestra creata per contenere la Toolbar come una finestra costituita dal solo menù: la Toolbar ((HMENU)IDC_MAIN_TOOL). Non c’è nessuna istanza, nessuna applicazione associata alla finestra Toolbar, nessuna funzione che si dovrà occupare di processare i comandi inviati alla toolbar (GetModuleHandle(NULL)). È poi necessario per la toolbar inserire la seguente istruzione SendMessage(hTool,TB_BUTTONSTRUCTSIZE,(WPARAM)sizeof(TBBUTTON),0) se non la si inserisse la toolbar non verrebbe visualizzata.
Una volta costruita la toolbar si deve definirla indicando quali icone ne faranno parte. Per comporre la toolbar si utilizzerà la struttura TBADDBITMAP.

Quindi, una volta creata la finestra toolbar si compone la toolbar utilizzando la struttura TBADDBITMAP. Si fissa il membro hInst al valore predefinito HINST_COMMCTRL indicando che si intende aggiungere delle immagini di bottoni predefiniti alla lista di bottoni già presenti nella toolbar. Con nID si fissa il tipo dei bottoni presenti nella toolbar.
Si deve quindi informare la toolbar che la lista di bottoni che la costituiranno è stata definita nella struttura TBADDBITMAP. Per farlo si invierà un messaggio alla toolbar utilizzando la funzione SendMessage.

Nel codice che segue si fissa la struttura TBADDBITMAP, e si invia un messaggio, il messaggio TB_ADDBITMAP, alla toolbar.

1. TBADDBITMAP tbab;
2.  
3. tbab.hInst = HINST_COMMCTRL;
4. tbab.nID = IDB_STD_SMALL_COLOR;
5. SendMessage(handle, TB_ADDBITMAP, 0, (LPARAM)&tbab);

La toolbar sarà costituita da una barra di bottoni, si dovrà quindi utilizzare una struttura adeguata per memorizzare i dati relativi ad ogni bottone. A tale scopo si utilizza un'array. Un'array di tipo TBBUTTON.


Per ogni elemento (per ogni bottone) della toolbar si deve fissare un elemento dell'array. Nel codice che segue si definiranno tre bottoni della toolbar

1. ZeroMemory(tbb, sizeof(tbb));
2. tbb[0].iBitmap = STD_FILENEW;
3. tbb[0].fsState = TBSTATE_ENABLED;
4. tbb[0].fsStyle = TBSTYLE_BUTTON;
5. tbb[0].idCommand = ID_FILE_NEW;
6.  
7. tbb[1].iBitmap = STD_FILEOPEN;
8. tbb[1].fsState = TBSTATE_ENABLED;
9. tbb[1].fsStyle = TBSTYLE_BUTTON;
10. tbb[1].idCommand = ID_FILE_OPEN;
11.  
12. tbb[2].iBitmap = STD_FILESAVE;
13. tbb[2].fsState = TBSTATE_ENABLED;
14. tbb[2].fsStyle = TBSTYLE_BUTTON;
15. tbb[2].idCommand = ID_FILE_SAVEAS;

Con il membro iBitmap si indicherà il tipo di bottone, in questo caso si sono utilizzati dei bottoni predefiniti. Con il membro fsState si indica che il bottone è abilitato. Con il membro fsStyle si indica che va creato un bottone standard. Con il membro idCommand si indica l'identificatore del bottone che verrà inviato alla funzione che processerà il comando.
Una volta definito l'array dei bottoni bisogna renderlo noto alla toolbar, per farlo si invia un messaggio, il messaggio TB_ADDBUTTONS, alla toolbar tramite la funzione SendMessage.

1. SendMessage(handle, TB_ADDBUTTONS, sizeof(tbb)/sizeof(TBBUTTON), (LPARAM)&tbb);

Il codice per la creazione della toolbar sarà posizionato nella funzione WndProc in corrispondenza del messaggio WM_CREATE inviato quando la finestra è stata creata, ma non è ancora visibile. Inoltre è necessario chiamare InitCommonControls() prima della creazione della finestra, altrimenti la toolbar non verrà visualizzata.
Si deve inoltre inserire del codice per gestire il ridimensionamento della finestra. Quando la finestra viene ridimensionata o massimizzata si deve di conseguenza modificare anche la toolbar. Se così non fosse si avrebbe una situazione come quella descritta dalla figura seguente

Figura 12. Finestra con toolbar non ridimensionata.

in cui la finestra è stata ridimensionata dall'utente ma la dimensione della toolbar è rimasta invariata. In questo modo si ottiene questo effetto non certo gradevole.
Per evitare questo effetto si deve inserire del codice per gestire il ridimensionamento della toolbar in corrispondenza ad un ridimensionamento della finestra. Quando la finestra viene ridimensionata viene inviato un messaggio WM_SIZE alla funzione WinMain che viene inviato alla funzione WndProc per essere processato. è nella funzione WndProc che dovrà essere inserito il codice in questione.
Il programma completo è il seguente

1. #include <windows.h>
2. #include <commctrl.h>
3. #include "resource.h"
4.  
5. #define ID_TOOLBAR 212
6. #define ID_FILE_NEW 300
7. #define ID_FILE_OPEN 301
8. #define ID_FILE_SAVEAS 302
9.  
10. LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
11. {
12. switch(msg)
13. {
14. case WM_CREATE:
15. {
16. HWND hTool;
17. TBBUTTON tbb[3];
18. TBADDBITMAP tbab;
19.  
20. HWND hStatus;
21. int statwidths[] = {100, -1};
22.  
23. // Create Toolbar
24. hTool = CreateWindowEx(0, TOOLBARCLASSNAME, NULL,
25. WS_CHILD | WS_VISIBLE, 0, 0, 0, 0, hwnd, (HMENU)IDC_MAIN_TOOL,
26. GetModuleHandle(NULL), NULL);
27. if(hTool == NULL)
28. MessageBox(hwnd, "Could not create tool bar.", "Error",
29. MB_OK | MB_ICONERROR);
30. SendMessage(hTool, TB_BUTTONSTRUCTSIZE, (WPARAM)sizeof(TBBUTTON), 0);
31. tbab.hInst = HINST_COMMCTRL;
32. tbab.nID = IDB_STD_SMALL_COLOR;
33. SendMessage(hTool, TB_ADDBITMAP, 0, (LPARAM)&tbab);
34.  
35. ZeroMemory(tbb, sizeof(tbb));
36. tbb[0].iBitmap = STD_FILENEW;
37. tbb[0].fsState = TBSTATE_ENABLED;
38. tbb[0].fsStyle = TBSTYLE_BUTTON;
39. tbb[0].idCommand = ID_FILE_NEW;
40.  
41. tbb[1].iBitmap = STD_FILEOPEN;
42. tbb[1].fsState = TBSTATE_ENABLED;
43. tbb[1].fsStyle = TBSTYLE_BUTTON;
44. tbb[1].idCommand = ID_FILE_OPEN;
45.  
46. tbb[2].iBitmap = STD_FILESAVE;
47. tbb[2].fsState = TBSTATE_ENABLED;
48. tbb[2].fsStyle = TBSTYLE_BUTTON;
49. tbb[2].idCommand = ID_FILE_SAVEAS;
50.  
51. SendMessage(hTool, TB_ADDBUTTONS, sizeof(tbb)/sizeof(TBBUTTON), (LPARAM)&tbb);
52.  
53. }
54. break;
55.  
56. case WM_SIZE:
57. {
58. HWND hTool;
59. RECT rcTool;
60. int iToolHeight;
62. // Calculate remaining height and size edit
63. GetClientRect(hwnd, &rcClient);
64. iEditHeight = rcClient.bottom - iToolHeight - iStatusHeight;
65. hEdit = GetDlgItem(hwnd, IDC_MAIN_EDIT);
66. SetWindowPos(hEdit, NULL, 0, iToolHeight, rcClient.right,iEditHeight, SWP_NOZORDER);
67. }
68. break;
69.  
70. case WM_CLOSE:
71. DestroyWindow(hwnd);
72. break;
73.  
74. case WM_DESTROY:
75. PostQuitMessage(0);
76. break;
77.  
78. case WM_COMMAND:
79. switch(LOWORD(wParam))
80. {
81. case ID_FILE_SAVE:
82. break;
83.  
84. case ID_FILE_OPEN:
85. break;
86.  
87. case ID_FILE_SAVEAS:
88. break;
89. }
90. break;
91.  
92. default:return DefWindowProc(hwnd, msg, wParam, lParam);
93. }
94. return 0;
95. }
96.  
97. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine,
98. int nCmdShow)
99. {
100. WNDCLASSEX wc;
101. HWND handle;
102. MSG message;
103.  
104. InitCommonControls();
105.  
106. wc.cbSize = sizeof(WNDCLASSEX);
107. wc.style = 0;
108. wc.lpfnWndProc = WndProc;
109. wc.cbClsExtra = 0;
110. wc.cbWndExtra = 0;
111. wc.hInstance = hInstance;
112. wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
113. wc.hCursor = LoadCursor(NULL, IDC_ARROW);
114. wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
115. wc.lpszMenuName = MAKEINTRESOURCE(IDR_MAINMENU);
116. wc.lpszClassName = "wintoolbar";
117. wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
118.  
119. if(!RegisterClassEx(&wc))
120. {
121. MessageBox(NULL, "Registrazione della Finestra Fallita!", "Errore!",
122. MB_ICONEXCLAMATION | MB_OK);
123. return 0;
124. }
125.  
126. handle = CreateWindowEx(
127. 0,
128. "wintoolbar",
129. "Esempio Toolbar e Statusbar",
130. WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
131. CW_USEDEFAULT, CW_USEDEFAULT, 480, 320,
132. NULL, NULL, hInstance, NULL);
133.  
134. if(handle == NULL)
135. {
136. MessageBox(NULL, "Creazione della Finestra Fallita!", "Errore!",
137. MB_ICONEXCLAMATION | MB_OK);
138. return 0;
139. }
140.  
141. ShowWindow(handle, nCmdShow);
142. UpdateWindow(handle);
143.  
144. while(GetMessage(&message, NULL, 0, 0) > 0)
145. {
146. TranslateMessage(&message);
147. DispatchMessage(&message);
148. }
149. return message.wParam;
150. }

Affinché il programma funzioni però è necessario utilizzare la libreria comctl32.lib. In visual C++ sotto il menù Project->settings e poi nel tab link si deve inserire la libreria comctl32.lib.
La finestra risultante è la seguente

Figura 13. Finestra con menù e toolbar.

Inserimento di una Statusbar

La statusbar è una barra orizzontale posizionata nella parte inferiore della finestra. È possibile dividerla in più parti (sezioni), e in ciascuna parte si potrà inserire del testo o delle immagini, è considerata a sua volta una finestra. È utilizzata principalmente per visualizzare informazioni.
Per aggiungere una statusbar alla finestra si procede come per la toolbar, la statusbar viene considerata come una finestra e il menù di questa finestra è la statusbar stessa. Quindi per creare la toolbar si utilizzerà la funzione CreateWindowEx esattamente come per la toolbar

1. handle = CreateWindowEx(0, STATUSCLASSNAME, NULL,
2. WS_CHILD | WS_VISIBLE | SBARS_SIZEGRIP, 0, 0, 0, 0,
3. hwnd, (HMENU)STATUSBAR, GetModuleHandle(NULL), NULL);

Come nome della finestra viene utilizzato il nome predefinito per le statusbar, STATUSCLASSNAME, viene poi indicato che la finestra che si sta costruendo sarà una finestra figlia di un'altra finestra (WS_CHILD), dovrà essere visibile (WS_VISIBLE), e la statusbar deve includere una sizing grip alla sua estremità di destra (SBARS_SIZEGRIP). La finestra genitrice sarà quella il cui handle è contenuto in hwnd. La finestra creata per contenere la statusbar ha come menù la statusbar stessa ((HMENU)STATUSBAR). Non c’è nessuna istanza, nessuna applicazione associata alla finestra statusbar, nessuna funzione che si dovrà occupare di processare i comandi inviati alla statusbar (GetModuleHandle(NULL)).
Con la CreateWindowEx si è semplicemente creata la statusbar, per dividerla in sezioni si deve inviare un messaggio, il messaggio SB_SETPARTS, alla statusbar tramite la funzione SendMessage

1. SendMessage(handle, SB_SETPARTS, sizeof(statwidths)/sizeof(int),
2. (LPARAM)statwidths);

Una volta suddivisa la statusbar si devono inserire i vari testi nelle varie sezioni. Per inserire un testo in una sezione si dovrà inviare un messaggio, il messaggio SB_SETTEXT, alla statusbar

1. SendMessage(handle, SB_SETTEXT, 0, (LPARAM)"Esempio Status Bar");

Nell'esempio che segue si è creata una statusbar con tre sezioni,

1. int statwidths[] = {100, 200, -1};
2.  
3. SendMessage(handle, SB_SETTEXT, 0, (LPARAM)"Esempio Status Bar");
4. SendMessage(handle, SB_SETTEXT, 1, (LPARAM)"Seconda Sezione");
5. SendMessage(handle, SB_SETTEXT, 2, (LPARAM)"Terza, ed Ultima Sezione");

Il codice (esclusa la funzione WinMain che è identica a quella del programma relativo alla toolbar) che produce la statusbar è il seguente

1. #include <windows.h>
2. #include <commctrl.h>
3. #include "resource.h"
4.  
5. #define STATUSBAR 213
6.  
7. LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
8. {
9. switch(msg)
10. {
11. case WM_CREATE:
12. {
13. HWND hStatus;
14. int statwidths[] = {100, 200, -1};
15.  
16. // Create Status bar
17. hStatus = CreateWindowEx(0, STATUSCLASSNAME, NULL,
18. WS_CHILD | WS_VISIBLE | SBARS_SIZEGRIP, 0, 0, 0, 0,
19. hwnd, (HMENU)STATUSBAR, GetModuleHandle(NULL), NULL);
20. if(hTool == NULL)
21. MessageBox(hwnd, "Could not create tool bar.", "Error",
22. MB_OK | MB_ICONERROR);
23.  
24. SendMessage(hStatus, SB_SETPARTS, sizeof(statwidths)/sizeof(int),
25. (LPARAM)statwidths);
26. SendMessage(handle, SB_SETTEXT, 0, (LPARAM)"Prima Sezione");
27. SendMessage(handle, SB_SETTEXT, 1, (LPARAM)"Seconda Sezione");
28. SendMessage(handle, SB_SETTEXT, 2, (LPARAM)"Terza,
29. ed Ultima Sezione");
30. }
31. break;
32.  
33. case WM_SIZE:
34. {
35. HWND hStatus;
36. RECT rcStatus;
37. int iStatusHeight;
38.  
39. // Size status bar and get height
40. hStatus = GetDlgItem(hwnd, STATUSBAR);
41. SendMessage(hStatus, WM_SIZE, 0, 0);
42. GetWindowRect(hStatus, &rcStatus);
43. iStatusHeight = rcStatus.bottom - rcStatus.top;
44. }
45. break;
46.  
47. case WM_CLOSE: DestroyWindow(hwnd); break;
48.  
49. case WM_DESTROY: PostQuitMessage(0); break;
50.  
51. case WM_COMMAND:
52. switch(LOWORD(wParam))
53. {
54. case ID_FILE_SAVE:
55. break;
56.  
57. case ID_FILE_OPEN:
58. break;
59.  
60. case ID_FILE_SAVEAS:
61. break;
62. }
63. break;
64.  
65. default:return DefWindowProc(hwnd, msg, wParam, lParam);
66. }
67. return 0;
68. }

La finestra risultante sarà la seguente

Figura 14. Finestra con menù e statusbar.