1. /******************************************************************
2.  Grafika komputerowa, środowisko MS Windows - program  przykładowy
3.  *****************************************************************/
4.  
5. #include <windows.h>
6. #include <gdiplus.h>
7. #include <vector>
8. using namespace Gdiplus;
9.  
10. POINT bezier[] = { {750, 400}, {820, 350}, {850, 300}, {820, 250}, {800, 220}, {770, 250}, {750, 280}, {730, 250}, { 700, 220 }, {680, 250}, {650, 300}, {680, 350}, {750,400} };
11. int elScale = 7;
12. bool drag = false;
13. bool dragDraw = false;
14. int vertex = -1;
15. std::vector<Point> krzywa;
16. bool initialized = false;
17. bool closed = false;
18. //deklaracja funkcji obslugi okna
19. LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
20.  
21. //funkcja Main - dla Windows
22.  int WINAPI WinMain(HINSTANCE hInstance,
23.                HINSTANCE hPrevInstance,
24.                LPSTR     lpCmdLine,
25.                int       nCmdShow)
26. {
27.         MSG meldunek;             //innymi slowy "komunikat"
28.         WNDCLASS nasza_klasa; //klasa głównego okna aplikacji
29.         HWND okno;
30.         static char nazwa_klasy[] = "Podstawowa";
31.        
32.         GdiplusStartupInput gdiplusParametry;// parametry GDI+; domyślny konstruktor wypełnia strukturę odpowiednimi wartościami
33.         ULONG_PTR       gdiplusToken;                   // tzw. token GDI+; wartość uzyskiwana przy inicjowaniu i przekazywana do funkcji GdiplusShutdown
34.    
35.         // Inicjujemy GDI+.
36.         GdiplusStartup(&gdiplusToken, &gdiplusParametry, NULL);
37.  
38.         //Definiujemy klase głównego okna aplikacji
39.         //Okreslamy tu wlasciwosci okna, szczegoly wygladu oraz
40.         //adres funkcji przetwarzajacej komunikaty
41.         nasza_klasa.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
42.         nasza_klasa.lpfnWndProc   = WndProc; //adres funkcji realizującej przetwarzanie meldunków
43.         nasza_klasa.cbClsExtra    = 0 ;
44.         nasza_klasa.cbWndExtra    = 0 ;
45.         nasza_klasa.hInstance     = hInstance; //identyfikator procesu przekazany przez MS Windows podczas uruchamiania programu
46.         nasza_klasa.hIcon         = 0;
47.         nasza_klasa.hCursor       = LoadCursor(0, IDC_ARROW);
48.         nasza_klasa.hbrBackground = (HBRUSH) GetStockObject(GRAY_BRUSH);
49.         nasza_klasa.lpszMenuName  = "Menu" ;
50.         nasza_klasa.lpszClassName = nazwa_klasy;
51.  
52.     //teraz rejestrujemy klasę okna głównego
53.     RegisterClass (&nasza_klasa);
54.        
55.         /*tworzymy okno główne
56.         okno będzie miało zmienne rozmiary, listwę z tytułem, menu systemowym
57.         i przyciskami do zwijania do ikony i rozwijania na cały ekran, po utworzeniu
58.         będzie widoczne na ekranie */
59.         okno = CreateWindow(nazwa_klasy, "Grafika komputerowa", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
60.                                                 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL);
61.        
62.        
63.         /* wybór rozmiaru i usytuowania okna pozostawiamy systemowi MS Windows */
64.         ShowWindow (okno, nCmdShow) ;
65.    
66.         //odswiezamy zawartosc okna
67.         UpdateWindow (okno) ;
68.  
69.         // GŁÓWNA PĘTLA PROGRAMU
70.         while (GetMessage(&meldunek, NULL, 0, 0))
71.      /* pobranie komunikatu z kolejki; funkcja GetMessage zwraca FALSE tylko dla
72.          komunikatu WM_QUIT; dla wszystkich pozostałych komunikatów zwraca wartość TRUE */
73.         {
74.                 TranslateMessage(&meldunek); // wstępna obróbka komunikatu
75.                 DispatchMessage(&meldunek);  // przekazanie komunikatu właściwemu adresatowi (czyli funkcji obslugujacej odpowiednie okno)
76.         }
77.  
78.         GdiplusShutdown(gdiplusToken);
79.        
80.         return (int)meldunek.wParam;
81. }
82.  
83. /********************************************************************
84. FUNKCJA OKNA realizujaca przetwarzanie meldunków kierowanych do okna aplikacji*/
85. LRESULT CALLBACK WndProc (HWND okno, UINT kod_meldunku, WPARAM wParam, LPARAM lParam)
86. {
87.         HMENU mPlik, mInfo, mGlowne;
88.        
89. /* PONIŻSZA INSTRUKCJA DEFINIUJE REAKCJE APLIKACJI NA POSZCZEGÓLNE MELDUNKI */
90.         switch (kod_meldunku)
91.         {
92.         case WM_CREATE:  //meldunek wysyłany w momencie tworzenia okna
93.                 mPlik = CreateMenu();
94.                 AppendMenu(mPlik, MF_STRING, 100, "&Zapiszcz...");
95.                 AppendMenu(mPlik, MF_SEPARATOR, 0, "");
96.                 AppendMenu(mPlik, MF_STRING, 101, "&Koniec");
97.                 mInfo = CreateMenu();
98.                 AppendMenu(mInfo, MF_STRING, 200, "&Autor...");
99.                 mGlowne = CreateMenu();
100.                 AppendMenu(mGlowne, MF_POPUP, (UINT_PTR) mPlik, "&Plik");
101.                 AppendMenu(mGlowne, MF_POPUP, (UINT_PTR) mInfo, "&Informacja");
102.                 SetMenu(okno, mGlowne);
103.                 DrawMenuBar(okno);
104.  
105.         case WM_COMMAND: //reakcje na wybór opcji z menu
106.                 switch (wParam)
107.                 {
108.                 case 100: if(MessageBox(okno, "Zapiszczeć?", "Pisk", MB_YESNO) == IDYES)
109.                                         MessageBeep(0);
110.                   break;
111.                 case 101: DestroyWindow(okno); //wysylamy meldunek WM_DESTROY
112.                           break;
113.                 case 200: MessageBox(okno, "Imię i nazwisko:\nNumer indeksu: ", "Autor", MB_OK);
114.                 }
115.                 return 0;
116.        
117.         case WM_LBUTTONDOWN: //reakcja na lewy przycisk myszki
118.                 {
119.                         int x = LOWORD(lParam);
120.                         int y = HIWORD(lParam);
121.  
122.                         for (int i = 0; i < 13; i++)
123.                         {
124.                                
125.                                         if ((x >= bezier[i].x - elScale && x <= bezier[i].x + elScale) && (y >= bezier[i].y - elScale && y <= bezier[i].y + elScale))
126.                                         {
127.                                                 vertex = i;
128.                                                 break;
129.                                         }
130.                                 drag = true;
131.                         }
132.                         return 0;
133.                 }
134.         case WM_RBUTTONDOWN:
135.         {
136.                 closed = false;
137.                 int x = LOWORD(lParam);
138.                 int y = HIWORD(lParam);
139.                 if (!initialized)
140.                 {
141.                         initialized = true;
142.                         krzywa.push_back(Point(x, y));
143.                         krzywa.push_back(Point(x, y));
144.                 }
145.                 else
146.                         krzywa.push_back(Point(x, y));
147.                 dragDraw = true;
148.                 return 0L;
149.         }
150.         case WM_RBUTTONDBLCLK:
151.         {
152.                 closed = true;
153.                 krzywa.pop_back();
154.                 InvalidateRect(okno, NULL, true);
155.                 return 0;
156.         }
157.         case WM_RBUTTONUP:
158.         {
159.                 dragDraw = false;
160.                 InvalidateRect(okno, NULL, true);
161.                 return 0;
162.         }
163.         case WM_LBUTTONUP:
164.         {
165.                 if (drag)
166.                 {
167.                         drag = FALSE;
168.                         vertex = -1;
169.                 }
170.                 return 0L;
171.         }
172.         case WM_MOUSEMOVE:
173.         {
174.                 if (vertex > -1 && drag)
175.                 {
176.                         bezier[vertex].x = LOWORD(lParam);
177.                         bezier[vertex].y = HIWORD(lParam);
178.                         InvalidateRect(okno, NULL, true);
179.                         //UpdateWindow(okno);
180.                 }
181.                 else if (dragDraw)
182.                 {
183.                         krzywa[krzywa.size() - 1].X = LOWORD(lParam);
184.                         krzywa[krzywa.size() - 1].Y = HIWORD(lParam);
185.                         InvalidateRect(okno, NULL, true);
186.                 }
187.                 return 0L;
188.         }
189.         case WM_PAINT:
190.                 {
191.                         PAINTSTRUCT paint;
192.                         HDC kontekst;
193.  
194.                         kontekst = BeginPaint(okno, &paint);
195.                        
196.                         // MIEJSCE NA KOD GDI
197.                         POINT litera1[] = { {200,300},{300,300},{300,250},{250, 250}, {250, 100}, {200,100}, {200, 250,}, {180, 250}, {180, 300}, };
198.                         POINT litera2[] = { {170, 240}, { 300, 190}, { 300, 150}, {170, 200} };
199.                         HBRUSH pedzle[] = { CreateSolidBrush(RGB(68, 138, 252)), CreateSolidBrush(RGB(147, 53, 255)), CreateSolidBrush(RGB(0, 153, 132)),
200.                                 CreateSolidBrush(RGB(2, 70, 109)),CreateSolidBrush(RGB(145, 1, 82)) };
201.                         HPEN pioro = CreatePen(PS_SOLID, 5, RGB(0,0,0));
202.                         SelectObject(kontekst, pioro);
203.                         SelectObject(kontekst, pedzle[2]);
204.                         Pie(kontekst, 0, 0, 450, 450, 0, 0, 225, 450);
205.                         SelectObject(kontekst, pedzle[3]);
206.                         Pie(kontekst, 0, 0, 450, 450, 225, 450, 450, 0);
207.                         SelectObject(kontekst, pedzle[4]);
208.                         Pie(kontekst, 0, 0, 450, 450, 450, 0, 0, 0);
209.  
210.                         //MoveToEx(kontekst, 100, 300, NULL);
211.                         //LineTo(kontekst, 800, 300);
212.                         SelectObject(kontekst, pedzle[1]);
213.                         Polygon(kontekst, litera1, 9);
214.                         SelectObject(kontekst, pedzle[0]);
215.                         Polygon(kontekst, litera2, 4);
216.                        
217.                         PolyBezier(kontekst, bezier, 13);
218.                        
219.                         for (int i = 0; i < 13; i++)
220.                         {
221.                                 Ellipse(kontekst, bezier[i].x - elScale, bezier[i].y - elScale, bezier[i].x + elScale, bezier[i].y + elScale);
222.                         }
223.                
224.                         DeleteObject(pioro);
225.  
226.                         // utworzenie obiektu umożliwiającego rysowanie przy użyciu GDI+
227.                         // (od tego momentu nie można używać funkcji GDI
228.                         Graphics grafika(kontekst);
229.                         Pen fioletowy(Color(145, 1, 82), 3);
230.                         // MIEJSCE NA KOD GDI+
231.                         if (krzywa.size() && !closed)
232.                                 grafika.DrawCurve(&fioletowy, &krzywa[0], krzywa.size());
233.                         else if(krzywa.size() && closed)
234.                                 grafika.DrawClosedCurve(&fioletowy, &krzywa[0], krzywa.size());
235.  
236.                         // utworzenie czcionki i wypisanie tekstu na ekranie
237.                         FontFamily  fontFamily(L"Times New Roman");
238.                         Font        font(&fontFamily, 24, FontStyleRegular, UnitPixel);
239.                         PointF      pointF(100.0f, 400.0f);
240.                         SolidBrush  solidBrush(Color(255, 0, 0, 255));
241.  
242.                         //grafika.DrawString(L"To jest tekst napisany za pomocą GDI+.", -1, &font, pointF, &solidBrush);
243.  
244.                         EndPaint(okno, &paint);
245.  
246.                         return 0;
247.                 }
248.        
249.         case WM_DESTROY: //obowiązkowa obsługa meldunku o zamknięciu okna
250.                 PostQuitMessage (0) ;
251.                 return 0;
252.    
253.         default: //standardowa obsługa pozostałych meldunków
254.                 return DefWindowProc(okno, kod_meldunku, wParam, lParam);
255.         }
256. }
257.