Implementacja rysowania obiektów w oknie programu

Stronę tą wyświetlono już: 985 razy

Wstęp

Do tej pory w programie Rysowanie omawiane były jedynie elementy związane z implementacją graficznego interfejsu użytkownika. Interfejs ten jest oczywiście mocno ograniczony do minimum, ponieważ jedynym moim celem jest pokazanie w przybliżeniu jak można stworzyć podstawy do utworzenia bardziej złożonych programów. Celem naszego programu jest oczywiście rysowanie różnych obiektów, a tymi obiektami są:

  • line - czyli linia;
  • circle - czyli okrąg;
  • rectangle - czyli prostokąt

W powyższym nazewnictwie użyłem nazw angielskich, ponieważ również i w kodzie programu będę takich nazw używał tworząc deklarację klas opisujących te obiekty. I teraz powstaje pewien problem, ponieważ obiekty powinny być rysowane kolejno jeden nad drugim a ja muszę je jakoś przechowywać w jednym kontenerze. Jak to zrobić? Odpowiedź jest prosta, trzeba utworzyć interfejs, czyli klasę abstrakcyjną, po której moje klasy opisujące poszczególne obiekty będą dziedziczyły. Spójrzmy więc łaskawym okiem na poniższą ilustrację.

Diagram pokazujący powiązania klas opisujących obiekty z interfejsem
Rys. 1
Diagram pokazujący powiązania klas opisujących obiekty z interfejsem

Jak widać na powyższym rysunku, klasa i_dr_obj {i - interface (interfejs), dr - draving (rysowanego), obj - object (obiektu)} jest dziedziczona przez wszystkie klasy opisujące obiekty rysowane w programie, czyli: line; circle oraz rectangle. Teraz mogę sobie spokojnie przechowywać moje obiekty w kontenerze wskaźników do interfejsów std::vector<i_dr_obj*>. Oczywiście klasa i_dr_obj musi zawierać funkcje abstrakcyjne i wymuszać obsługę pewnych mechanizmów, które są związane z obsługą wyświetlania i dodawania nowego obiektu do programu.

Dodatkowo wewnątrz programu utworzone zostaną dwie grupy klas:

  • opisujące pióro rysowania przypisane do danego obiektu;
  • opisujące wypełnienie rysowanego obiektu;

Uwzględniając wyżej wymienione klasy schemat zależności zmieni się do postaci pokazanej na poniższym rysunku.

Schemat klas w programie Rysowanie
Rys. 2
Schemat klas w programie Rysowanie.

Jak widać na powyższym schemacie klasy pen i hpen mają luźnie powiązanie z klasą abstrakcyjną i_dr_obj oraz z klasami line, circle oraz rectangle. Luźne powiązanie polega na tym, że klasy pen oraz hpen zostały wykorzystane w następujących metodach oraz konstruktorze wcześniej wymienionych klas:

  • dla klasy abstrakcyjnej i_dr_obj:
    • i_dr_obj(std::vector<hpen> &tPen, std::vector<hbrush> &tBrush, pen &p, brush &b) - konstruktor;
    • virtual std::wstring toString(std::vector<hpen> &tPen, std::vector<hbrush> &tBrush) = 0; - metoda związana z konwersją do tekstu;
    • virtual void Draw(HDC &hdc, std::vector<hpen> &tPen, std::vector<hbrush> &tbrush) = 0; - metoda związana z rysowaniem.
  • dla klas dziedziczących line, circle rectangle:
    • konstruktory poszczególnych klas;
    • virtual std::wstring toString(std::vector<hpen> &tPen, std::vector<hbrush> &tBrush) - metoda związana z konwersją do tekstu;
    • virtual void Draw(HDC &hdc, std::vector<hpen> &tPen, std::vector<hbrush> &tbrush) - metoda związana z rysowaniem.

Kod klas utworzonych na potrzeby programu

Zanim opiszę kod klas, najpierw trzeba do projektu dodać plik drawing_class_def.h w taki sam sposób jak plik winmain.cpp. Oto kod programu, który powinien znaleźć się w tym pliku:

Listing 1
  1. #ifndef DRAWING_CLASS_DEF
  2. #define DRAWING_CLASS_DEF
  4. #include <windows.h>
  5. #include <string>
  7. // ######################### KLASA pen ############################
  9. // Ta klasa będzie opisywała wędzel obramowania obiektów:
  11. // r - składowa czerwona;
  12. // g - składowa zielona;
  13. // b - składowa niebieska;
  15. // width - szerokość pióra;
  17. // ps_style - styl linii pióra
  19. class pen{
  20. protected:
  21. BYTE r; // składowa czerwona koloru pióra
  22. BYTE g; // składowa zielona koloru pióra
  23. BYTE b; // składowa niebieska koloru pióra
  25. int width; // szerokość pióra
  27. public:
  28. enum ps{ // dostępne ustawienia stylu pióra
  29. solid = PS_SOLID, // linia ciągła
  30. dash = PS_DASH, // przerwywana
  31. dot = PS_DOT, // kropkowana
  32. dashdot = PS_DASHDOT, // kreska kropka
  33. dashdotdot = PS_DASHDOTDOT, // kreska kropka kropka
  34. null = PS_NULL, // brak
  35. insideframe = PS_INSIDEFRAME // a to nie wiem
  36. };
  38. protected:
  40. enum ps ps_style; // styl pióra
  42. public:
  44. pen():r(255), g(0), b(0), width(1), ps_style(solid){}; // domyślny konstruktor
  45. pen(BYTE r, BYTE g, BYTE b, int width, enum ps ps_style) : r(r), g(g), b(b), width(width), ps_style(ps_style){}; // konstruktor ustawiający
  46. pen(const pen &p):r(p.r), g(p.g), b(p.b), width(p.width), ps_style(p.ps_style){}; // konstruktor kopiujący
  48. virtual void SetColor(BYTE r, BYTE g, BYTE b){
  49. this->r = r;
  50. this->b = b;
  51. this->g = g;
  52. }
  54. virtual void SetStyle(enum ps style){
  55. ps_style = style;
  56. }
  58. virtual void SetPen(BYTE r, BYTE g, BYTE b, enum ps style){
  59. this->r = r;
  60. this->g = g;
  61. this->b = b;
  63. ps_style = style;
  64. }
  66. bool operator ==(const pen &p) const { // operator porównania
  67. if(!memcmp(this, &p, sizeof(pen))){
  68. return true;
  69. }
  70. return false;
  71. }
  73. std::wstring toString() const { // zamiana na ciąg znaków
  74. std::wstring str;
  76. wchar_t buffor[100];
  77. wsprintf(buffor, L"r %i; g %i; b %i; width %i; style %i", r, g, b, width, (int)ps_style);
  78. str = buffor;
  80. return str;
  81. }
  82. };
  84. // ########################## KLASA hpen ###########################
  86. class hpen : public pen{
  87. HPEN hPen; // uchwyt pędzla
  88. public:
  89. hpen(BYTE r, BYTE g, BYTE b, int width, pen::ps style) : pen(r, g, b, width, style), hPen(CreatePen((int)style, width, RGB(r, g, b))){};
  91. hpen(const pen p) : pen(p), hPen(CreatePen((int)ps_style, width, RGB(r, g, b))){};
  93. hpen(const hpen &hp) : pen(hp), hPen(CreatePen((int)ps_style, width, RGB(r, g, b))){};
  95. hpen() : pen(), hPen(CreatePen((int)ps_style, width, RGB(r, g, b))){};
  97. void SelectPen(HDC &hdc){
  98. SelectObject(hdc, hPen);
  99. }
  101. virtual void SetColor(BYTE r, BYTE g, BYTE b){
  102. this->r = r;
  103. this->b = b;
  104. this->g = g;
  105. DeleteObject(hPen);
  106. hPen = CreatePen((int)ps_style, width, RGB( r, g, b));
  107. }
  109. virtual void SetStyle(enum ps style){
  110. ps_style = style;
  111. DeleteObject(hPen);
  112. hPen = CreatePen((int)ps_style, width, RGB( r, g, b));
  113. }
  115. virtual void SetPen(BYTE r, BYTE g, BYTE b, enum ps style){
  116. this->r = r;
  117. this->g = g;
  118. this->b = b;
  120. ps_style = style;
  121. DeleteObject(hPen);
  122. hPen = CreatePen((int)ps_style, width, RGB( r, g, b));
  123. }
  125. ~hpen(){
  126. DeleteObject(hPen);
  127. }
  128. };
  130. // ############################# KLASA brush #####################################
  132. class brush{
  133. protected:
  134. BYTE r;
  135. BYTE g;
  136. BYTE b;
  137. public:
  138. brush(BYTE r, BYTE g, BYTE b):r(r), g(g), b(b){};
  139. brush(const brush &br) : r(br.r), g(br.g), b(br.b){};
  141. virtual void SetColor(BYTE r, BYTE g, BYTE b){
  142. this->r = r;
  143. this->g = g;
  144. this->b = b;
  145. }
  147. std::wstring toString() const {
  148. std::wstring str;
  150. wchar_t buffor[100];
  151. wsprintf(buffor, L"brush: r %i, g %i, b %i", r, g, b);
  152. str = buffor;
  154. return str;
  155. }
  157. bool operator ==(const brush &br) const {
  158. if(memcmp(this, &br, sizeof(brush))){
  159. return false;
  160. }
  161. return true;
  162. }
  163. };
  165. // ############################# KLASA hbrush ##################################
  167. class hbrush : public brush{
  168. protected:
  169. HBRUSH hBrush; // uchwyt wypełnienia
  170. public:
  171. hbrush(const brush &br) : brush(br), hBrush(CreateSolidBrush(RGB(r, g, b))){};
  172. hbrush(const hbrush &hbr) : brush(hbr), hBrush(CreateSolidBrush(RGB(r, g, b))){};
  174. virtual void SetColor(BYTE r, BYTE g, BYTE b){
  175. this->r = r;
  176. this->g = g;
  177. this->b = b;
  178. DeleteObject(hBrush);
  179. hBrush = CreateSolidBrush(RGB(r, g, b));
  180. }
  182. void SelectBrush(HDC &hdc){
  183. SelectObject(hdc, hBrush);
  184. }
  186. ~hbrush(){
  187. DeleteObject(hBrush);
  188. }
  189. };
  191. // ###################### TYP ENUMEROWANY DLA OPISU TRYBU PRACY PROGRAMU #####################
  193. enum state{
  194. dr_line, // rysowanie linii
  195. dr_circle, // rysowanie okręgu
  196. dr_rect, // rysowanie prostokąta
  197. sel // tryb edycji
  198. };
  200. // ############### DAFINICJA INTERFEJSU KLAS DZIEDZICZĄCYCH ###############
  202. class i_dr_obj{ // i - interface; dr - draving; obj - object (interfejs rysowanego obiektu)
  203. protected:
  204. bool selected;
  205. int pen_index; // index pędzla rysowania
  206. int brush_index; // index wypełnienia rysowania
  207. public:
  208. i_dr_obj(std::vector<hpen> &tPen, std::vector<hbrush> &tBrush, pen &p, brush &b):selected(false), pen_index(-1), brush_index(-1){
  209. for(int i = 0; i < tPen.size(); i++){ // dla każdego elementu kontenera tPen
  210. if((pen)tPen[i] == p){ // sprawdzam, czy nie ma już utworzonego pióra o takich samych parametrach
  211. pen_index = i; // jeżeli jest takie pióro to zapamiętuję jego index
  212. break; // i kończę zabawę z iterowaniem
  213. }
  214. }
  215. if(pen_index == -1){ // jak pen_index jest równe -1 to znaczy, że nie ma w tPen takiego pióra więc
  216. pen_index = tPen.size(); // przypisuję index ostatniego elementu
  217. hpen hp(p); // tworzę nową definicję pióra
  218. tPen.push_back(hp); // dodaję definicję pióra
  219. }
  221. for(int i = 0; i < tBrush.size(); i++){ // dla każdego elementu kontenera tBrush
  222. if((brush)tBrush[i] == b){ // sprawdzam, czy nie ma już utworzonego pędzla o takich samych parametrach
  223. brush_index = i; // jeżeli taki pędzel już istnieje to zapamiętuję jego index
  224. break; // i kończę zabawę z iterowaniem
  225. }
  226. }
  227. if(brush_index == -1){ // jak brush_index jest równy -1 to znaczy, że w tBrush nie ma takiego pędzla
  228. brush_index = tBrush.size(); // więc przypisuję index ostatniego elementu kontenera (który zaraz dodam)
  229. hbrush hbr(b); // tworzę ten element
  230. tBrush.push_back(hbr); // i dodaję go do kontenera
  231. }
  232. };
  234. virtual std::wstring toString(std::vector<hpen> &tPen, std::vector<hbrush> &tBrush) const = 0; // każda definicja klasy musi obsługiwać tę metodę
  236. virtual void Draw(HDC &hdc, std::vector<hpen> &tPen, std::vector<hbrush> &tbrush) const = 0; // każda definicja klasy musi obsługiwać tę metodę
  238. virtual void WmLButtonDown(POINT &mp) = 0;
  239. virtual void WmLButtonUp(POINT &mp) = 0;
  241. bool Selected() const {return selected;}; // określa, czy obiekt został zaznaczony
  242. virtual bool Select(POINT &ps) = 0; // każda definicja klasy musi obługiwać tę metodą
  244. virtual ~i_dr_obj(){};
  245. };
  247. // ######################### DEFINICJA KLASY LINE (LINIA) ########################
  249. class line : public i_dr_obj{
  250. POINT begin;
  251. POINT end;
  252. public:
  253. line(std::vector<hpen> &tPen, std::vector<hbrush> &tBrush, pen &p, brush &b):i_dr_obj(tPen, tBrush, p, b){begin.x = begin.y = end.x = end.y = 0;};
  255. virtual std::wstring toString(std::vector<hpen> &tPen, std::vector<hbrush> &tBrush) const {
  256. std::wstring str;
  258. wchar_t buffor[100];
  259. wsprintf(buffor, L"Line %i %i; %i %i", begin.x, begin.y, end.x, end.y);
  261. str = buffor;
  262. str += tPen[this->pen_index].toString();
  263. str += tBrush[this->brush_index].toString();
  265. return str;
  266. }
  268. virtual void Draw(HDC &hdc, std::vector<hpen> &tPen, std::vector<hbrush> &tBrush) const {
  269. tPen[pen_index].SelectPen(hdc);
  270. tBrush[brush_index].SelectBrush(hdc);
  271. MoveToEx(hdc, begin.x, begin.y, NULL);
  272. LineTo(hdc, end.x, end.y);
  273. }
  275. virtual void WmLButtonDown(POINT &mp){
  276. begin = mp;
  277. end = mp;
  278. }
  280. virtual void WmLButtonUp(POINT &mp){
  281. end = mp;
  282. }
  284. virtual bool Select(POINT &ps){
  285. return false;
  286. }
  287. };
  289. // ######################### DEFINICJA KLASY CIRCLE (OKRĄG) ########################
  291. class circle : public i_dr_obj{
  292. POINT begin;
  293. POINT end;
  294. public:
  295. circle(std::vector<hpen> &tPen, std::vector<hbrush> &tBrush, pen &p, brush &b):i_dr_obj(tPen, tBrush, p, b){begin.x = begin.y = end.x = end.y = 0;};
  297. virtual std::wstring toString(std::vector<hpen> &tPen, std::vector<hbrush> &tBrush) const {
  298. std::wstring str;
  300. wchar_t buffor[100];
  301. wsprintf(buffor, L"Circle %i %i; %i %i", begin.x, begin.y, end.x, end.y);
  303. str = buffor;
  304. str += tPen[this->pen_index].toString();
  305. str += tBrush[this->brush_index].toString();
  307. str += tBrush[this->brush_index].toString();
  309. return str;
  310. }
  312. virtual void Draw(HDC &hdc, std::vector<hpen> &tPen, std::vector<hbrush> &tBrush) const {
  313. tPen[pen_index].SelectPen(hdc);
  314. tBrush[brush_index].SelectBrush(hdc);
  315. Ellipse(hdc, begin.x, begin.y, end.x, end.y);
  316. }
  318. virtual void WmLButtonDown(POINT &mp){
  319. begin = mp;
  320. end = mp;
  321. }
  323. virtual void WmLButtonUp(POINT &mp){
  324. end = mp;
  325. if(abs(begin.x - end.x) < abs(begin.y - end.y)){
  326. end.y = begin.y + abs(begin.x - end.x) * ( begin.y < end.y ? 1 : -1);
  327. }else{
  328. end.x = begin.x + abs(begin.y - end.y) * ( begin.x < end.x ? 1 : -1);
  329. }
  330. }
  332. virtual bool Select(POINT &ps){
  333. return false;
  334. }
  335. };
  337. // ######################### DEFINICJA KLASY RECTANGLE (PROSTOKĄT) ########################
  339. class rectangle : public i_dr_obj{
  340. POINT begin;
  341. POINT end;
  342. public:
  343. rectangle(std::vector<hpen> &tPen, std::vector<hbrush> &tBrush, pen &p, brush &b):i_dr_obj(tPen, tBrush, p, b){begin.x = begin.y = end.x = end.y = 0;};
  345. virtual std::wstring toString(std::vector<hpen> &tPen, std::vector<hbrush> &tBrush) const {
  346. std::wstring str;
  348. wchar_t buffor[100];
  349. wsprintf(buffor, L"Rectangle %i %i; %i %i", begin.x, begin.y, end.x, end.y);
  351. str = buffor;
  353. str += tPen[this->pen_index].toString();
  354. str += tBrush[this->brush_index].toString();
  356. return str;
  357. }
  359. virtual void Draw(HDC &hdc, std::vector<hpen> &tPen, std::vector<hbrush> &tBrush) const {
  360. tPen[pen_index].SelectPen(hdc);
  361. tBrush[brush_index].SelectBrush(hdc);
  362. Rectangle(hdc, begin.x, begin.y, end.x, end.y);
  363. }
  365. virtual void WmLButtonDown(POINT &mp){
  366. begin = mp;
  367. end = mp;
  368. }
  370. virtual void WmLButtonUp(POINT &mp){
  371. end = mp;
  372. }
  374. virtual bool Select(POINT &ps){
  375. return false;
  376. }
  377. };
  379. #endif

Kod główny programu

W pliku winmain.cpp trzeba załączyć wcześniej utworzony plik drawing_class_def.h dopisując następującą linijkę kodu:

Listing 2
  1. #include "drawing_class_def.h"

na samym początku kodu. Teraz cała funkcja procedury okna potomnego rysowania WndDrawingProc będzie wyglądała następująco:

Listing 3
  1. // ################################### Procedura okna dokumentu #####################################
  3. LRESULT CALLBACK WndDrawingProc(HWND hWndDraw, UINT msg, WPARAM wParam, LPARAM lParam){
  4. static POINT mousepos; // współrzędne kursora w oknie
  5. static i_dr_obj* obj; // wskaźnik na interfejs dodawanego obiektu
  6. static std::vector<i_dr_obj*> tObj; // tablica interfejsów obiektów rysowanych
  7. static enum state st; // tryb rysowania lub edycji
  8. static std::vector<hpen> tPen; // tablica wykorzystywanych pędzli
  9. static std::vector<hbrush> tBrush; // tablica wykorzystywanych wypełnień
  11. switch(msg){
  12. case WM_CREATE:
  13. {
  14. obj = NULL;
  15. }
  16. break;
  17. case WM_PAINT:
  18. {
  19. PAINTSTRUCT ps;
  20. HDC hdc = BeginPaint(hWndDraw, &ps);
  22. SetBkMode(hdc, TRANSPARENT);
  24. for(std::vector<i_dr_obj*>::iterator i = tObj.begin(); i < tObj.end(); i++){
  25. (*i)->Draw(hdc, tPen, tBrush); // rysowanie dodanych obiektów
  26. }
  28. if(obj){
  29. obj->Draw(hdc, tPen, tBrush); // rysowanie dodawanego obiektu
  30. }
  32. EndPaint(hWndDraw, &ps);
  33. }
  34. break;
  35. case WM_LBUTTONDOWN:
  36. {
  37. SetCapture(hWndDraw);
  38. switch(st){
  39. case dr_line: // tworzę obiekt typu line
  40. {
  41. obj = new line(tPen, tBrush, pen(255,0,0,1,pen::ps::solid), brush(0,0,150));
  42. obj->WmLButtonDown(mousepos);
  43. }
  44. break;
  45. case dr_circle: // tworzę obiekt typu circle
  46. {
  47. obj = new circle(tPen, tBrush, pen(0,255,0,1,pen::ps::solid), brush(0,150,0));
  48. obj->WmLButtonDown(mousepos);
  49. }
  50. break;
  51. case dr_rect: // tworzę obiekt typu rectangle
  52. {
  53. obj = new rectangle(tPen, tBrush, pen(0, 150, 255, 1, pen::ps::solid), brush(150,0,200));
  54. obj->WmLButtonDown(mousepos);
  55. }
  56. break;
  57. case sel: // trzyb zaznaczania (nie obsłużony jeszcze)
  58. {
  59. }
  60. break;
  61. }
  62. }
  63. break;
  64. case WM_LBUTTONUP:
  65. {
  66. switch(st){
  67. case dr_line: // dodawanie obiektu do kontenera
  68. {
  69. if(obj){
  70. obj->WmLButtonUp(mousepos);
  71. tObj.push_back(obj);
  72. }
  73. }
  74. break;
  75. case dr_circle: // dodawanie obiektu do kontenera
  76. {
  77. if(obj){
  78. obj->WmLButtonUp(mousepos);
  79. tObj.push_back(obj);
  80. }
  81. }
  82. break;
  83. case dr_rect: // dodawanie obiektu do kontenera
  84. {
  85. if(obj){
  86. obj->WmLButtonUp(mousepos);
  87. tObj.push_back(obj);
  88. }
  89. }
  90. break;
  91. case sel: // tryb edycji (nie obsłużony)
  92. {
  93. }
  94. break;
  95. }
  96. obj = NULL;
  97. ReleaseCapture();
  98. }
  99. break;
  100. case WM_MOUSEMOVE:
  101. {
  102. mousepos.x = LOWORD(lParam); // pobieranie współrzędnej x
  103. mousepos.y = HIWORD(lParam); // pobieranie współrzędnej y
  104. wchar_t buffor[100]; // bufor do konwersji na tekst
  105. wsprintf(buffor, L"X = %i",mousepos.x); // konwersja na tekst współrzędnej x
  106. SendMessage(statusbar, SB_SETTEXT, 0, (LPARAM)buffor); // ustawienie tekstu pierwszej pozycji paska kontrolki statusbar
  107. wsprintf(buffor, L"Y = %i",mousepos.y); // konwersja na tekst współrzędnej y
  108. SendMessage(statusbar, SB_SETTEXT, 1, (LPARAM)buffor); // ustawienie tekstu drugiej pozycji paska kontrolki statusbar
  110. if(wParam & MK_LBUTTON && obj){
  111. obj->WmLButtonUp(mousepos); // zmiana obiektu, podczas ruchu mychy
  112. InvalidateRect(hWndDraw, NULL, true); // odświerzanie okna w celu odrysowania nowych ustawień obiektu
  113. }
  114. }
  115. break;
  116. case WM_COMMAND:
  117. {
  118. if((HWND)lParam == toolbar){
  119. switch(LOWORD(wParam)){
  120. case ID_LINE: // komunikat przychodzący od przycisku toolbar-a o identyfikatorze ID_LINE
  121. {
  122. st = dr_line;
  123. SendMessage(statusbar, SB_SETTEXT, 2, (LPARAM)L"Rysowanie linii"); // ustawienie tekstu w ostatnim polu statusbar-u
  124. }
  125. break;
  126. case ID_CIRCLE: // to samo co poprzednio, tylko dla ID_CIRCLE
  127. {
  128. st = dr_circle;
  129. SendMessage(statusbar, SB_SETTEXT, 2, (LPARAM)L"Rysowanie okręgu"); // ustawienie tekstu w ostatnim polu statusbar-u
  130. }
  131. break;
  132. case ID_RECTANGLE: // to samo co poprzednio, tylko dla ID_RECTANGLE
  133. {
  134. st = dr_rect;
  135. SendMessage(statusbar, SB_SETTEXT, 2, (LPARAM)L"Rysowanie prostokąta"); // ustawienie tekstu w ostatnim polu statusbar-u
  136. }
  137. break;
  138. case ID_SELECT: // to samo co poprzednio, tylko dla ID_SELECT
  139. {
  140. st = sel;
  141. SendMessage(statusbar, SB_SETTEXT, 2, (LPARAM)L"Rysowanie edycja"); // ustawienie tekstu w ostatnim polu statusbar-u
  142. }
  143. break;
  144. }
  145. }
  146. }
  147. break;
  148. case WM_DESTROY: // tutaj sprzątanko się rozpoczyna
  149. {
  150. for(std::vector<i_dr_obj*>::iterator i = tObj.begin(); i < tObj.end(); i++){
  151. delete *i; // usuwanie obiektów
  152. }
  153. // czyszczenie kontenerów
  154. tObj.clear();
  155. tPen.clear();
  156. tBrush.clear();
  157. }
  158. break;
  159. }
  160. return DefWindowProc(hWndDraw, msg, wParam, lParam);
  161. }

W tej chwili program już rysuje poszczególne obiekty, ale jeszcze nie ma możliwości zaznaczania i zmiany ustawień obiektów. Poniżej zamieszczam screen programu.

Rysujący program Rysowanie
Rys. 3
Widok programu Rysowanie, który jak widać już rysuje.
Tematy powiązane

Komentarze