Uruchom Code::Blocks, wybierz opcję Create a new project, a następnie w okienku dialogowym New from template wybierz Win32 GUI Project. Resztę zrób standardowo, jak dla aplikacji konsoli. Usuń z edytora program szablonowy i na jego miejsce wstaw poniższy kod:

// Koło Informatyczne I LO w Tarnowie
// (C)2013 mgr Jerzy Wałaszek
// Prosty program dla Windows
// PRG_004
//-----------------------------------

#include <windows.h>

int main()
{
   MessageBox(0, "Witaj w świecie okienkowym\nI-LO w Tarnowie", "Pierwszy program dla MS-Windows", MB_OK | MB_ICONINFORMATION);
   ExitProcess(0);
}

Wybierz z menu opcję Project → Properties. W okienku dialogowym Project/target options wybierz zakładkę Build targets. W sekcji Selected build target options zmień typ na GUI application. Zatwierdź okienko dialogowe klikając na przycisk OK. Zmiana ta spowoduje, że nie będzie tworzone okno konsoli.

Skompiluj i uruchom program. Jeśli wszystko jest OK, to na ekranie pojawi się następujące okienko:

W systemie Windows program musi współpracować ze środowiskiem graficznym. Dlatego programowanie MS-Windows wymaga dobrej znajomości sposobu pracy systemu oraz setek funkcji systemowych (tzw. API – Aplication Program Interface : Interfejs Programowy Aplikacji), za pomocą których komunikujemy się z różnymi składnikami systemu.

W pierwszym programie wykorzystujemy dwie procedury systemowe, które wykonają za nas "czarną robotę". Ich deklaracje są umieszczone w pliku nagłówkowym windows.h, który bezwarunkowo musi być dołączony do aplikacji tworzonych dla środowiska MS-Windows.

Już w tak prostym programie występuje kilka pojęć, które musimy dobrze poznać, aby efektywnie programować okienka:

Proces

  ExitProcess(0);

Uchwyt / dojście

Funkcja MessageBox()

int MessageBox
(
    HWND hWnd,
    LPCTSTR lpText,
    LPCTSTR lpCaption,
    UINT uType
);

Chociaż MessageBox() służy głównie do powiadamiania użytkownika o jakiś zdarzeniach powstałych w trakcie pracy programu (najczęściej są to komunikaty błędów), to poniżej mamy przykładową grę w odgadywanie liczb od 0 do 15 wykorzystującą tą funkcję. Zasady są bardzo proste – użytkownik wymyśla sobie liczbę od 0 do 15, a następnie odpowiada na pytania komputera. Komputer odgadnie liczbę po 4 pytaniach.

// Koło Informatyczne I LO w Tarnowie
// (C)2013 mgr Jerzy Wałaszek
// Prosta gra dla Windows
// PRG_005
//-----------------------------------

#include <windows.h>
#include <sstream>
#include <ctime>

using namespace std;

int main()
{
  char tytul[] = "ZGADYWANKA (C)2013 I-LO w Tarnowie";
  int i,j;

  MessageBox(0, "Wymyśl liczbę z zakresu od 0 do 15 i kliknij OK", tytul, MB_OK | MB_ICONINFORMATION);

// generujemy tablicę masek bitowych

  int maski[] = {1,2,4,8};

  srand((unsigned)time(NULL));

  for(i = 0; i < 50; i++)
  {
    int x = rand() % 4;
    int y = rand() % 4;
    int z = maski[x]; maski[x] = maski[y]; maski[y] = z;
  }

// zadajemy 4 pytania, w każdym umieszczamy liczby zawierające
// bit z bieżącej maski. Odpowiedź TAK powoduje dodanie maski do
// zgadywanej liczby

  int liczba = 0;

  for(i = 0; i < 4; i++)
  {
    ostringstream sout;

    sout << "Pytanie nr " << i + 1
         << "\n\nCzy twoja liczba jest jedną z liczb : \n\n";

    for(j = 1; j < 16; j++) if(j & maski[i]) sout << j << " ";

    if(MessageBox(0, sout.str().c_str(), tytul, MB_YESNO | MB_ICONQUESTION) == IDYES)
      liczba += maski[i];
  }

// Wyświetlamy wynik

  ostringstream sout;

  sout << "Twoją liczbą jest liczba " << liczba;
  MessageBox(0, sout.str().c_str(), tytul, MB_OK | MB_ICONINFORMATION);

// Koniec

  ExitProcess(0);
}

Efekt uruchomienia programu

 

Objaśnienia

  int maski[] = {1,2,4,8};
   
  srand((unsigned)time(NULL));
  for(int i = 0; i < 50; i++)
  {
    int x = rand() % 4;
    int y = rand() % 4;
    int z = maski[x];
    maski[x] = maski[y];
    maski[y] = z;    
  }

   int liczba = 0;

   for(int i = 0; i < 4; i++)
  {
    ostringstream sout;

    sout << "Pytanie nr " << i + 1
         << "\n\nCzy twoja liczba jest jedną z liczb : \n\n";

    for(int j = 1; j < 16; j++)
      if(j & maski[i]) sout << j << " ";
    
    if(MessageBox(0, sout.str().c_str(), tytul,
        MB_YESNO | MB_ICONQUESTION) == IDYES) liczba += maski[i];
  }

  ostringstream sout;

  sout << "Twoją liczbą jest liczba : " << liczba;
  MessageBox(0, sout.str().c_str(), tytul,
    MB_OK | MB_ICONINFORMATION);

  ExitProcess(0);
}

// Koło Informatyczne I LO w Tarnowie
// (C)2013 mgr Jerzy Wałaszek
// Proste okienko w Windows
// PRG_006
//-----------------------------------

#include <windows.h>

// Tutaj umieszczamy nazwę klasy, wg której powstanie nasze okno
// Jest to zmienna globalna.
//--------------------------------------------------------------

char ClassName[ ] = "SimpleWinClass";

// Procedura obsługująca wiadomości dla okna, wywoływana przez
// MS-Windows przy okazji różnych zdarzeń, które należy obsłużyć
//--------------------------------------------------------------

LRESULT CALLBACK WndProc(HWND h, UINT uMsg , WPARAM wP, LPARAM lP)
{
  if(uMsg == WM_DESTROY)           // Jeśli wiadomość dotyczy zamknięcia okna,
  {
    PostQuitMessage(0); return 0;  // to je zamykamy i kończymy funkcję
  }
  else return DefWindowProc(h,uMsg,wP,lP); // Inaczej każemy systemowi obsłużyć tę wiadomość
}

// W Windows główna funkcja, od której uruchamiany jest program,
// nazywa się WinMain zamiast main.
//--------------------------------------------------------------

int WINAPI WinMain (HINSTANCE hinst, HINSTANCE hprevinst, LPSTR cmdLine, int cmdShow)
{
  WNDCLASSEX wc;  // struktura klasy okna
  MSG        ms;  // przechowuje wiadomości aplikacji
  HWND       h;   // Uchwyt naszego okna


  // Ustawiamy kolejne pola struktury klasy okna

  wc.cbSize        = sizeof(WNDCLASSEX);
  wc.style         = CS_HREDRAW | CS_VREDRAW;
  wc.lpfnWndProc   = WndProc;
  wc.cbClsExtra    = wc.cbWndExtra = 0;
  wc.hInstance     = hinst;
  wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
  wc.lpszMenuName  = NULL;
  wc.lpszClassName = ClassName;
  wc.hIcon         = wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
  wc.hCursor       = LoadCursor(NULL, IDC_ARROW);

  // Rejestrujemy klasę okna w Windows. Jeśli się to nie uda, kończymy program

  if(!RegisterClassEx(&wc)) return 0;

  // Gdy klasa jest zarejestrowana, tworzymy na jej podstawie okno

  h = CreateWindowEx(0,                      // dodatkowe style okna, 0 oznacza ich brak
                     ClassName,              // adres tablicy char z nazwą klasy
                     "Nasze pierwsze okno",  // adres łańcucha z napisem tytułowym okna
                     WS_OVERLAPPEDWINDOW,    // styl okna
                     CW_USEDEFAULT,          // współrzędna X lewego górnego narożnika okna
                     CW_USEDEFAULT,          // współrzędna Y lewego górnego narożnika okna
                     300,                    // szerokość okna w pikselach, również może być CW_USEDEFAULT
                     200,                    // wysokość okna w pikselach, również może być CW_USEDEFAULT
                     0,                      // uchwyt nadrzędnego okna, jeśli istnieje
                     0,                      // uchwyt menu, jeśli istnieje
                     hinst,                  // uchwyt programu, który korzysta z okna
                     0                       // adres dodatkowych danych
                     );

  // Utworzone okno wyświetlamy na ekranie

  ShowWindow(h, cmdShow);

  // Uaktualniamy treść okna

  UpdateWindow(h);

  // Rozpoczynamy pętlę obsługi wiadomości napływających do naszego okna.

  while(GetMessage(&ms, NULL, 0, 0))  // Czekamy na wiadomość
  {
    TranslateMessage(&ms);            // Przekształcamy wiadomość
    DispatchMessage(&ms);             // Wysyłamy ją do procedury okna
  }

  // zwracamy wartość umieszczoną w polu wParam ostatniej wiadomości

  return ms.wParam;
}

Po skompilowaniu i uruchomieniu ukaże się okienko aplikacji:

Powyższy program wyjaśnia powód nie rozpoczynania nauki programowania od systemu Windows. Jednakże warto dokładnie przeczytać podane tutaj informacje, ponieważ opisane funkcje i struktury występują praktycznie w każdym programie okienkowym. Z drugiej strony nie musimy się wszystkiego dokładnie uczyć na pamięć. Wystarczy, iż wiemy ogólnie, gdzie znaleźć odpowiednie wyjaśnienia i do czego służą opisane funkcje i struktury danych.

Zadaniem naszego programu jest utworzenie jednego prostego, pustego okna aplikacji, które będzie posiadało typowe zachowania okienkowe (na przykład możliwość przesuwania po ekranie, skalowania, sprowadzania na pasek zadań, itp.). W tym celu musimy wykonać następujące kroki:

1. Zainicjować pola specjalnej struktury danych, zwanej strukturą klasy okna.
2. Wykorzystać strukturę klasy okna do rejestracji tej klasy w systemie MS-Windows. Gdy klasa zostanie zarejestrowana, struktura klasy okna nie będzie już potrzebna i można ją wykorzystać do rejestracji innej klasy okna. Klasa okna definiuje parametry okienka – jego wygląd, kolory, menu itp.
3. Po rejestracji należy utworzyć okno na podstawie klasy.
4. Utworzone okno należy wyświetlić na ekranie i odświeżyć.
5. Następnie w pętli należy sprawdzać wiadomości nadchodzące od Windows i wysyłać je do specjalnej procedury, zwanej procedurą okna, w której zostaną obsłużone. Pętla jest wykonywana dotąd, aż skończą się wiadomości dla naszego programu – wszystkie utworzone przezeń okna zostaną zamknięte. Wtedy kończymy funkcję WinMain.

Struktura klasy okna

Do rejestracji klasy okna wykorzystywana jest struktura typu WNDCLASSEX, która posiada następującą deklarację:

typedef struct
{
    UINT      cbSize;
    UINT      style;
    WNDPROC   lpfnWndProc;
    int       cbClsExtra;
    int       cbWndExtra;
    HINSTANCE hInstance;
    HICON     hIcon;
    HCURSOR   hCursor;
    HBRUSH    hbrBackground;
    LPCTSTR   lpszMenuName;
    LPCTSTR   lpszClassName;
    HICON     hIconSm;
} WNDCLASSEX, *PWNDCLASSEX;

W definicji pól tej struktury występuje wiele nowych typów danych, zdefiniowanych specjalnie na potrzeby systemu MS-Windows.

UINT	– 32-bitowa liczba całkowita bez znaku, odpowiednik C++ to unsigned int.
WNDPROC	– adres procedury okna, czyli procedury obsługującej napływające dla niego wiadomości.
HINSTANCE	– uchwyt programu
HICON	– uchwyt ikony
HCURSOR	– uchwyt kursora
HBRUSH	– uchwyt pędzla.
LPCTSTR	– długi wskaźnik tablicy znaków zakończonych kodem 0

Poszczególne pola struktury WNDCLASSEX posiadają następujące przeznaczenia:

cbSize	–	określa rozmiar w bajtach struktury WNDCLASSEX. Rozmiar ten otrzymamy z sizeof(WNDCLASSEX).
style	–	określa style okna, które mogą być dowolną kombinacją (za pomocą operatora | ) stałych: CS_BYTEALIGNCLIENT  –  Wyrównuje obszar roboczy okna do granicy bajtu w kierunku x. Styl ten wpływa na szerokość okna oraz jego położenie poziome na ekranie monitora. CS_BYTEALIGNWINDOW  –  Wyrównuje okno do granicy bajtu w kierunku x. Styl ten wpływa na szerokość okna oraz jego położenie poziome na ekranie monitora. CS_CLASSDC  –  Przydziela jeden wspólny kontekst graficzny dla wszystkich okien w tej klasie. Ponieważ klasy okien są zależne od procesów, to możliwe jest utworzenie okien tej samej klasy przez wiele wątków danej aplikacji. Możliwe również jest jednoczesna próba użycia w wątkach tego samego kontekstu graficznego. Gdy tak się stanie, system zezwoli tylko jednemu wątkowi na ukończenie jego operacji graficznych. CS_DBLCLKS  –  Wysyła wiadomość o podwójnym kliknięciu myszką do procedury okna, gdy kursor myszki znajduje się w obszarze okna zbudowanego na podstawie tej klasy. CS_DROPSHADOW  –  W Windows XP: umożliwia rzucanie cienia przez okno. Efekt ten jest stosowany zwykle przez małe okna, które na krótko pojawiają się na ekranie – np. okna podpowiedzi lub menu, aby stworzyć wrażenie trójwymiarowości. CS_GLOBALCLASS  –  Określa, iż dana klasa okien jest globalną klasą aplikacji. CS_HREDRAW  –  Przerysowuje całe okno przy zmianie szerokości obszaru roboczego użytkownika. CS_NOCLOSE  –  Wyłącza przycisk zamykania okna na pasku tytułowym. CS_OWNDC  –  Przydziela oddzielny kontekst graficzny dla każdego okna w tej klasie. CS_PARENTDC  –  Ustawia prostokąt obcinania okna potomnego do prostokąta obcinania okna nadrzędnego. Dzięki temu okno potomne może rysować po swoim oknie nadrzędnym. CS_SAVEBITS  –  Zachowuje w postaci bitmapy część obrazu ekranu zakrytego przez okno tej klasy. Gdy okno zostanie usunięte, system wykorzysta zapamiętany obraz do przywrócenia ekranu. Styl ten jest użyteczny dla małych okienek (menu, okna dialogowe, itp.), które są wyświetlane przez krótki okres czasu, a następnie usuwane. Styl ten zwiększa czas wymagany na wyświetlenie okna, ponieważ system musi najpierw przydzielić pamięć na obrazek. CS_VREDRAW  –  Przerysowuje całe okno przy zmianie wysokości obszaru roboczego.
lpfnWndProc	–	adres procedury okna, która przetwarza i obsługuje wiadomości systemowe napływające dla okna utworzonego na podstawie tej klasy.
cbClsExtra	–	określa liczbę bajtów, którą należy dodatkowo zarezerwować za strukturą klasy okna. System inicjuje te bajty na zero.
cbWndExtra	–	określa liczbę dodatkowych bajtów, które należy zarezerwować za egzemplarzem okna. System inicjuje te bajty na zero.
hInstance	–	uchwyt programu zawierającego procedurę okna dla tej klasy.
hIcon	–	uchwyt ikony klasy. Musi to być uchwyt do zasobu ikon. Jeśli będzie zawierać NULL, to system udostępni standardową ikonę.
hCursor	–	uchwyt kursora klasy. Musi to być uchwyt do zasobu kursora. Jeśli będzie zawierać NULL, to aplikacja musi osobiście ustawić kształt kursora w momencie, gdy kursor myszki pojawia się ponad okienkiem aplikacji.
hbrBackground	–	uchwyt pędzla tła klasy. Pole to może być uchwytem do fizycznego pędzla stosowanego do malowania tła lub może być wartością koloru. Stałe koloru wymienione są poniżej. Jeśli stosujemy stałą koloru, to należy dokonać rzutowania typu (HBRUSH): COLOR_ACTIVEBORDER  – kolor aktywnej ramki okna COLOR_ACTIVECAPTION  – kolor aktywnego tytułu okna COLOR_APPWORKSPACE  – kolor obszaru roboczego aplikacji COLOR_BACKGROUND  – kolor tła COLOR_BTNFACE  – kolor przycisków COLOR_BTNSHADOW  – kolor cienia przycisków COLOR_BTNTEXT  – kolor tekstu przycisków COLOR_CAPTIONTEXT  – kolor tekstu tytułu okna COLOR_GRAYTEXT  – kolor zablokowanego tekstu COLOR_HIGHLIGHT  – kolor wyróżnienia COLOR_HIGHLIGHTTEXT  – kolor wyróżnionego tekstu COLOR_INACTIVEBORDER  – kolor nieaktywnej ramki COLOR_INACTIVECAPTION  – kolor nieaktywnego tytułu COLOR_MENU  – kolor menu COLOR_MENUTEXT  – kolor tekstu menu COLOR_SCROLLBAR  – kolor paska przewijania COLOR_WINDOW  – kolor okna COLOR_WINDOWFRAME  – kolor ramki okna Jeśli pole to zawiera wartość NULL, to aplikacja musi samodzielnie zamalowywać tło okna przy każdym żądaniu malowania obszaru roboczego.
lpszMenuName	–	wskaźnik nazwy menu klasy. Jeśli pole zawiera NULL, to okna zbudowane na podstawie tej klasy nie będą posiadały żadnego menu.
lpszClassName	–	wskaźnik nazwy klasy.
hIconSm	–	wskaźnik małej ikony związanej z klasą okna. Jeśli pole zawiera NULL, system przeszuka zasoby ikon określone przez pole hIcon i tam dobierze odpowiednią ikonę.

Rejestracja nowej klasy okna

Gdy struktura WNDCLASSEX zostanie wypełniona odpowiednimi danymi, używamy jej do rejestracji klasy za pomocą funkcji:

ATOM RegisterClassEx
(
    CONST WNDCLASSEX *lpwcx
);

lpwcx

–

wskaźnik powyżej opisanej struktury WNDCLASSEX.

Jeśli wywołanie funkcji się powiedzie, to zwracana jest specjalna wartość identyfikująca jednoznacznie rejestrowaną klasę. W przeciwnym razie zwracane jest 0, co właśnie sprawdza nasz program.

Tworzenie okna

Gdy klasa okna zostanie zarejestrowana w systemie Windows, można na jej podstawie tworzyć okna robocze aplikacji. Do tego celu wykorzystujemy funkcję:

HWND CreateWindowEx
(      
    DWORD     dwExStyle,
    LPCTSTR   lpClassName,
    LPCTSTR   lpWindowName,
    DWORD     dwStyle,
    int       x,
    int       y,
    int       nWidth,
    int       nHeight,
    HWND      hWndParent,
    HMENU     hMenu,
    HINSTANCE hInstance,
    LPVOID    lpParam
);

dwExStyle	–	określa rozszerzone style okna dla tworzonego okna. Ponieważ w tym programie nie wykorzystujemy tego parametru, a jest on dosyć rozbudowany, opiszemy go, gdy stanie się potrzebny.
lpClassName	–	wskaźnik tablicy znaków zakończonych kodem 0, zawierających nazwę klasy.
lpWindowName	–	wskaźnik tekstu będącego tytułem okna.
dwStyle	–	określa styl tworzonego okna. Parametr może być dowolną kombinacją następujących styli: WS_BORDER  –  tworzy okno z cienką linią ramki WS_CAPTION  –  tworzy okno z paskiem tytułowym WS_CHILD  –  tworzy okno podrzędne. Okno zawierające ten styl nie może posiadać paska menu. Również ten styl nie może występować razem ze stylem WS_POPUP. WS_CHILDWINDOW  –  to samo co WS_CHILD. WS_CLIPCHILDREN  –  z operacji graficznych okna będą wyłączone obszary przykryte przez okna potomne. WS_CLIPSIBLINGS  –  powoduje wyłączenie z operacji graficznych dla okien potomnych obszarów zakrytych przez inne okna potomne. Jeśli ten styl nie jest ustawiony, to okna potomne mogą rysować po przykrywającym je obszarze innego okna potomnego. WS_DISABLED  –  tworzy okno, które jest początkowo zablokowane. Zablokowane okno nie może odczytywać danych od użytkownika. WS_DLGFRAME  –  tworzy okno posiadające krawędź w stylu typowym dla okienek dialogowych.  WS_GROUP  –  określa pierwszą kontrolkę w grupie kontrolek. WS_HSCROLL  –  tworzy okno z poziomym paskiem przewijania. WS_ICONIC  –  tworzy okno, które początkowo jest zminimalizowane do ikony. To samo co WS_MINIMIZE. WS_MAXIMIZE  –  tworzy okno pierwotnie zmaksymalizowane WS_MAXIMIZEBOX  –  tworzy okno z przyciskiem maksymalizacji. WS_MINIMIZE  –  tworzy okno, które początkowo jest zminimalizowane do ikony. To samo co WS_ICONIC. WS_MINIMIZEBOX  –  tworzy okno z przyciskiem minimalizacji. WS_OVERLAPPED  –  tworzy okno, które może być przykrywane innymi oknami. Okno takie posiada pasek tytułowy oraz brzeg. WS_OVERLAPPEDWINDOW  –  tworzy okno zakrywalne z ustawionymi stylami WS_OVERLAPPED, WS_CAPTION, WS_SYSMENU, WS_THICKFRAME, WS_MINIMIZEBOX, oraz WS_MAXIMIZEBOX. WS_POPUP  –  tworzy wyskakujące okno. WS_POPUPWINDOW  –  tworzy okno wyskakujące z ustawionymi stylami WS_BORDER, WS_POPUP i WS_SYSMENU. WS_SIZEBOX  –  tworzy okno z brzegiem zawierającym ikonę skalowania. WS_SYSMENU  –  tworzy okno z przyciskiem menu systemowego na pasku tytułowym. Styl WS_CAPTION również musi być dołączony. WS_TABSTOP  –  Określa kontrolkę otrzymującą skupienie przy naciśnięciu klawisza TAB, Naciskanie klawisza TAB zmienia skupienie klawiatury na następną kontrolkę z ustawionym stylem WS_TABSTOP. WS_THICKFRAME  –  tworzy okienko ze skalowalnym brzegiem – to samo co WS_SIZEBOX. WS_TILED  –  to samo co WS_OVERLAPPED WS_TILEDWINDOW  –  to samo co WS_OVERLAPPEDWINDOW WS_VISIBLE  –  tworzy okno pierwotnie widoczne. Styl ten można włączać i wyłączać wykorzystując funkcje API ShowWindow lub SetWindowPos. WS_VSCROLL  –  tworzy okno z pionowym paskiem przewijania.
x,y	–	określają początkową pozycję okna na ekranie. Współrzędne x i y odnoszą się do lewego górnego narożnika okna. W obu przypadkach można zastosować stałą CW_USEDEFAULT.
nWidth, nHeight	–	szerokość i wysokość okna.
hWndParent	–	jeśli tworzone okno jest własnością innego okna, to tutaj umieszczamy uchwyt właściciela
hMenu	–	uchwyt menu okna. Jeśli okno nie posiada menu, wpisujemy tutaj NULL.
hInstance	–	uchwyt programu, z którym jest skojarzone to okno
lpParam	–	wskaźnik wartości do przekazania do okna poprzez pole lpCreateParams struktury CREATESTRUCT, która jest wskazywana przez parametr lParam wiadomości WM_CREATE. Wiadomość jest wysyłana do tworzonego okna przez tą funkcję zanim zakończy ona swoje działanie.

Funkcja zwraca uchwyt do utworzonego okna. Uchwyt ten należy zapamiętać w osobnej zmiennej, ponieważ korzystają z niego funkcje obsługujące okno.

Pokazywanie okna na ekranie

Po utworzeniu okna pokazujemy je na ekranie za pomocą funkcji:

BOOL ShowWindow
(      
    HWND hWnd,
    int  nCmdShow
);

hWnd	–	uchwyt okna
nCmdShow	–	określa sposób wyświetlenia okna. Przy pierwszym wywołaniu okna aplikacji parametr ten powinien przyjąć wartość otrzymaną przez funkcję WinMain w parametrze  cmdShow. W kolejnych wywołaniach można stosować poniższe stałe: SW_FORCEMINIMIZE  –  minimalizuje okno. Tą opcję zwykle stosujemy przy minimalizowaniu okna z innego wątku. SW_HIDE  –  ukrywa to okno i aktywizuje kolejne okienko na pulpicie SW_MAXIMIZE  –  maksymalizuje okno SW_MINIMIZE  –  minimalizuje okno i aktywuje następne okno ze sterty ekranu SW_RESTORE  –  aktywuje i wyświetla okno. SW_SHOW  –  aktywuje okno i wyświetla je w bieżących rozmiarach i na bieżącej pozycji. SW_SHOWDEFAULT  –  ustawia stan pokazywania okna na podstawie wartości SW_... określonej w strukturze STARTUPINFO, przekazanej do funkcji CreateProcess przez program, który uruchomił tą aplikację. SW_SHOWMAXIMIZED  –  aktywuje okno i wyświetla je jako zmaksymalizowane SW_SHOWMINIMIZED  –  aktywuje okno i wyświetla je jako zminimalizowane SW_SHOWMINNOACTIVE  –  wyświetla okno jako zminimalizowane. Różni się od SW_SHOWMINIMIZED tym, iż okno nie jest aktywowane SW_SHOWNA  –  wyświetla okno w bieżących rozmiarach i na bieżącej pozycji. Nie aktywuje okna. SW_SHOWNOACTIVATE  –  wyświetla okno w jego ostatnich rozmiarach i na jego ostatniej pozycji. Nie aktywuje okna. SW_SHOWNORMAL  –  aktywuje i wyświetla okno. Tą stałą aplikacja powinna wybrać przy pierwszym wyświetleniu okna.

Uaktualnienie obszaru roboczego okna

Wyświetlone na ekranie okno zwykle uaktualniamy za pomocą funkcji:

BOOL UpdateWindow
(
    HWND hWnd
);

Funkcja powoduje odświeżenie obszaru roboczego (client area) określonego okna przez wysłanie do niego wiadomości WM_PAINT. Wiadomość jest obsługiwana w procedurze okna.

Pobieranie wiadomości z kolejki

Gdy w systemie Windows pojawi się zdarzenie związane z naszym oknem, zostaje do niego wysłana odpowiednia wiadomość. System magazynuje wiadomości dla różnych okien na specjalnej kolejce. Do pobierania wiadomości wykorzystujemy funkcję:

BOOL GetMessage
(      
    LPMSG lpMsg,
    HWND  hWnd,
    UINT  wMsgFilterMin,
    UINT  wMsgFilterMax
);

lpMsg	–	wskaźnik struktury MSG, w której zostanie umieszczona wiadomość z kolejki wiadomości danego wątku. Struktura MSG jest następująca: typedef struct { HWND hwnd; UINT message; WPARAM wParam; LPARAM lParam; DWORD time; POINT pt; } MSG, *PMSG; hwnd  –  uchwyt okna, którego procedura otrzyma wiadomość. Jeśli wiadomość odnosi się do wątku, to pole zawiera NULL. message  –  określa identyfikator wiadomości. wParam  –  dodatkowa informacja związana z wiadomością – pole 16 bitowe lParam  –  dodatkowa informacja związana z wiadomością – pole 32 bitowe time  –  określa czas wysłania wiadomości pt  –  określa pozycję kursora we współrzędnych ekranu w czasie wysłania wiadomości.
hWnd	–	uchwyt okna, dla którego wiadomości należy pobrać. Okno musi należeć do bieżącego wątku. Jeśli hWnd zawiera NULL, to funkcja GetMessage pobierze wiadomości dla wszystkich okien należących do bieżącego wątku.
wMsgFilterMin	–	określa najniższą wartość wiadomości do pobrania.
wMsgFilterMax	–	określa największą wartość wiadomości do pobrania. Jeśli oba parametry mają wartość 0, to GetMessage pobiera wszystkie wiadomości. Parametry te stosuje się zwykle do filtrowania wiadomości pochodzących od klawiatury i myszy.

Funkcja zwraca wartość 0 po odebraniu wiadomości WM_QUIT. W pozostałych przypadkach wartość jest niezerowa.

Przekształcanie wiadomości klawiatury

Naciśnięcie lub zwolnienie dowolnego klawisza powoduje wysłanie wiadomości o tzw. klawiszach wirtualnych. Wiadomości te umożliwiają przetwarzanie dosłownie wszystkich klawiszy. Jeśli w naszym oknie interesują nas jedynie klawisze znakowe (czyli takie, które produkują litery, cyfry i znaki), to możemy przetłumaczyć wiadomości klawiszy wirtualnych na klawisze znakowe za pomocą funkcji:

BOOL TranslateMessage(const MSG *lpMsg);

Rozsyłanie wiadomości do okna

Pobraną z kolejki wiadomość rozsyłamy do odpowiedniego okna za pomocą funkcji:

Wiadomość trafia do procedury okna. Wartość zwrotna jest wartością zwróconą przez procedurę okna. Najczęściej się ją ignoruje.

Analiza programu

char ClassName[ ] = "SimpleWinClass";

LRESULT CALLBACK WndProc
  (
  HWND h,    // uchwyt okna
  UINT uMsg, // kod wiadomości
  WPARAM wP, // parametr 16-bitowy
  LPARAM lP  // parametr 32-bitowy
  )
{
  if(uMsg == WM_DESTROY)
  {
    PostQuitMessage(0); return 0;
  }
  else return DefWindowProc(h,uMsg,wP,lP);
}

  int WINAPI WinMain
    (
    HINSTANCE hinst,     // uchwyt aplikacji
    HINSTANCE hprevinst, // obecnie prawie zawsze NULL
    LPSTR     cmdLine,   // wskaźnik wiersza poleceń
                         // uruchamiającego ten program
    int       cmdShow)   // określa początkowy sposób
                         // wyświetlania okna
{

  WNDCLASSEX wc;  // struktura klasy okna
  MSG        ms;  // przechowuje wiadomości aplikacji
  HWND       h;   // Uchwyt naszego okna

  wc.cbSize        = sizeof(WNDCLASSEX);
  wc.style         = CS_HREDRAW | CS_VREDRAW;
  wc.lpfnWndProc   = WndProc;
  wc.cbClsExtra    = wc.cbWndExtra = 0;
  wc.hInstance     = hinst;
  wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
  wc.lpszMenuName  = NULL;
  wc.lpszClassName = ClassName;
  wc.hIcon         = wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
  wc.hCursor       = LoadCursor(NULL, IDC_ARROW);

    if(!RegisterClassEx(&wc)) return 0;

    h = CreateWindowEx(0, ClassName, "Nasze pierwsze okno",
          WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
          300, 200, 0, 0, hinst, 0);

    ShowWindow(h, cmdShow);

    UpdateWindow(h);

    while(GetMessage(&ms, NULL, 0, 0))
    {
        TranslateMessage(&ms);
        DispatchMessage(&ms);
    }

    return ms.wParam;
}

W programie wymień funkcję WndProc() na poniższą:

LRESULT CALLBACK WndProc(HWND h, UINT uMsg , WPARAM wP, LPARAM lP)
{
  switch(uMsg)
  {
    case WM_DESTROY :

      PostQuitMessage(0);
      break;

    // W procedurze okna obsługujemy wiadomość WM_PAINT, która jest wysyłana przy konieczności
    // przerysowania obszaru roboczego okna.

    case WM_PAINT :

      HDC         hdc;  // uchwyt kontekstu graficznego
      PAINTSTRUCT pps;  // struktura parametrów rysowania
      RECT        r;    // prostokąt obejmujący obszar roboczy okna

      hdc = BeginPaint(h, &pps);
      GetClientRect(h, &r);
      DrawText(hdc, "Witaj w świecie MS-Windows",-1, &r, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
      EndPaint(h, &pps);
      break;

    default:

      return DefWindowProc(h, uMsg, wP, lP);
  }
  return 0;
}

Skompiluj i uruchom program. Otrzymasz następujące okno:

Program w systemie Windows nie może sobie tak po prostu coś narysować na ekranie. Ekran jest zasobem współdzielonym, zatem korzystanie z niego musi się odbywać wg ściśle określonych zasad. Okienko, po którym chcemy rysować może znajdować się w różnych stanach (np. może być zminimalizowane lub częściowo przykryte innym oknem itp.). Dlatego przy operacjach graficznych należy bezwzględnie wykorzystywać funkcje jądra graficznego GDI (ang. Graphic Device Interface – interfejs grafiki).

Jeśli chcemy coś narysować na obszarze roboczym okienka (ang. client area), najpierw musimy poprosić system Windows o udostępnienie dla tego obszaru uchwytu odpowiedniego kontekstu graficznego (ang. DC – device context).  Uchwyt kontekstu graficznego identyfikuje pewną wewnętrzną strukturę danych w systemie Windows, w której są umieszczone różne parametry graficzne. Uchwyt DC można otrzymać na kilka sposobów. W naszym programie wykorzystujemy do tego celu funkcję:

HDC BeginPaint
(
    HWND hwnd,
    LPPAINTSTRUCT lpPaint
);

typedef struct tagPAINTSTRUCT
{ 
  HDC  hdc; 
  BOOL fErase; 
  RECT rcPaint; 
  BOOL fRestore; 
  BOOL fIncUpdate; 
  BYTE rgbReserved[32]; 
} PAINTSTRUCT, *PPAINTSTRUCT; 

Po pobraniu uchwytu kontekstu graficznego ustalamy obszar rysowania. W naszym programie nie bawimy się w szczegóły i pobieramy do struktury RECT współrzędne całego obszaru roboczego okna przy pomocy funkcji GetClientRect. W rzeczywistości w PAINTSTRUC.rcPaint system Windows umieszcza prostokąt obejmujący ten fragment obszaru roboczego okna, który uległ zmianie (np. przesunięto zakrywające go inne okno) i powinien zostać przerysowany (taki prostokąt nosi nazwę nieaktualnego – ang. invalid rectangle). Wykorzystanie tej informacji jest czasami dużo efektywniejsze od przerysowywania całego obszaru roboczego okna, lecz również i trudniejsze, gdyż musimy odpowiednio przeliczać położenia wszystkich obiektów graficznych.

Do wyrysowania tekstu na obszarze roboczym wykorzystujemy funkcję:

int DrawText
(
    HDC hdc,
    LPCTSTR lpString,
    int nCount,
    LPRECT lpRect,
    UINT uFormat
);

typedef struct _RECT
{ 
    LONG left;
    LONG top; 
    LONG right; 
    LONG bottom; 
} RECT, * PRECT; 

Przed zakończeniem obsługi wiadomości WM_PAINT musimy zwolnić uchwyt kontekstu graficznego. W tym celu wywołujemy funkcję EndPaint().

W tym miejscu możesz wypróbować różne funkcje graficzne API Win32.

Rysowanie punktów

COLORREF SetPixel
(
    HDC hdc,
    int X,
    int Y,
    COLORREF crColor
);

LRESULT CALLBACK WndProc(HWND h, UINT uMsg , WPARAM wP, LPARAM lP)
{
  switch(uMsg)
  {
    case WM_DESTROY :

      PostQuitMessage(0);
      break;

    // W procedurze okna obsługujemy wiadomość WM_PAINT, która jest wysyłana przy konieczności
    // przerysowania obszaru roboczego okna.

    case WM_PAINT :

      HDC         hdc;  // uchwyt kontekstu graficznego
      PAINTSTRUCT pps;  // struktura parametrów rysowania
      RECT        r;    // prostokąt obejmujący obszar roboczy okna
      int cw,ch;

      hdc = BeginPaint(h, &pps);
      GetClientRect(h, &r);

      cw = r.right - r.left;  // szerokość obszaru klienta
      ch = r.bottom - r.top;  // wysokość obszaru klienta

      for(int y = 0; y < ch; y++)
        for(int x = 0; x < cw; x++)
        {
          COLORREF c = RGB(255-255*x/cw,(255-255*y/ch)/2,255*y/ch);
          SetPixel(hdc,x,y,c);
        }

      EndPaint(h, &pps);
      break;

    default:

      return DefWindowProc(h, uMsg, wP, lP);
  }
  return 0;
}

Rysowanie Linii

WINGDIAPI BOOL WINAPI MoveToEx
(
    HDC hdc,
    int X,
    int Y,
    LPPOINT lpPoint
);

typedef struct tagPOINT
{
    LONG x;
    LONG y;
} POINT;

WINGDIAPI BOOL WINAPI LineTo
(
    HDC hdc,
    int X,
    int Y
);

HPEN CreatePen
( 
    int fnPenStyle, 
    int nWidth, 
    COLORREF crColor
);

HGDIOBJ SelectObject
(
    HDC hdc, 
    HGDIOBJ hgdiobj
); 

BOOL DeleteObject
(
    HGDIOBJ hObject
); 

LRESULT CALLBACK WndProc(HWND h, UINT uMsg , WPARAM wP, LPARAM lP)
{
  switch(uMsg)
  {
    case WM_DESTROY :

      PostQuitMessage(0);
      break;

    // W procedurze okna obsługujemy wiadomość WM_PAINT, która jest wysyłana przy konieczności
    // przerysowania obszaru roboczego okna.

    case WM_PAINT :

      HDC         hdc;  // uchwyt kontekstu graficznego
      PAINTSTRUCT pps;  // struktura parametrów rysowania
      RECT        r;    // prostokąt obejmujący obszar roboczy okna
      HGDIOBJ previous;
      int cw,ch,x,y;
 
      hdc = BeginPaint(h, &pps);
      GetClientRect(h, &r);

      previous = SelectObject(hdc,CreatePen(PS_SOLID,0,0)); // tworzymy nowe pióro i wybieramy je

      cw = r.right - r.left - 1;  // szerokość obszaru klienta
      ch = r.bottom - r.top - 1;  // wysokość obszaru klienta

      for(int i = 0; i < 30; i++)
      {
        DeleteObject(SelectObject(hdc,CreatePen(PS_SOLID,0,RGB(255 * i / 30, 0, 255 - 255 * i / 30))));
        x = i * cw / 30;
        y = i * ch / 30;

        MoveToEx(hdc,0,y,NULL);
        LineTo(hdc,x,ch);

        MoveToEx(hdc,0,ch-y,NULL);
        LineTo(hdc,x,0);

        MoveToEx(hdc,cw,y,NULL);
        LineTo(hdc,cw-x,ch);

        MoveToEx(hdc,cw,ch-y,NULL);
        LineTo(hdc,cw-x,0);
      }

      DeleteObject(SelectObject(hdc,previous)); // usuwamy pióro

      EndPaint(h, &pps);
      break;

    default:

      return DefWindowProc(h, uMsg, wP, lP);
  }
  return 0;
}

Osobnym problemem jest tworzenie aplikacji przenośnych na inne platformy. Jeśli napiszesz program dla Windows, to jego przeróbka dla systemu Linux może być dosyć kosztowna czasowo. Z tego powodu opracowano różne dodatkowe biblioteki, które pozwalają tworzyć aplikacje niezależne od systemu operacyjnego komputera (oczywiście do pewnego stopnia niezależne). Istnieje tutaj kilka możliwości, np.:

• Windows / Linux – biblioteka SDL. Pozwala ona tworzyć programy graficzne, jednakże nie zawiera elementów środowiska graficznego, takich jak przyciski, listy, pola wyboru, itp. Mimo to jest idealna do pisania gier, które i tak posiadają zwykle własny interfejs użytkownika.
• Windows – Borland C++ Builder : Linux – Kylix 3. Kłopoty z zainstalowaniem Kylixa pod najnowszymi systemami Linuxa. Poza tym Kylix już nie jest rozwijany od kilku lat.
• Windows / Linux – Lazarus. Jest to środowisko RAD pozwalające programować w języku Pascal. Projekt jest wciąż rozwijany. Umożliwia tworzenie aplikacji okienkowych na bazie komponentów, podobnie jak w Borland C++ Builder, ale wymaga nauki języka Pascal, co samo w sobie wadą nie jest.
• Windows / Linux / MacOS – wxWidgets. Jest to biblioteka obiektowa, która pozwala na tworzenie aplikacji okienkowych w języku C++ w trzech wymienionych systemach operacyjnych. Na następnych zajęciach zajmiemy się instalacją tej biblioteki oraz nieco w niej poprogramujemy, aby zdobyć podstawy.

I Liceum Ogólnokształcące    im. Kazimierza Brodzińskiego w Tarnowie ©2024 mgr Jerzy Wałaszek

Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl

W artykułach serwisu są używane cookies. Jeśli nie chcesz ich otrzymywać,
zablokuj je w swojej przeglądarce.
Informacje dodatkowe