WinApi Hauptschleife

[Peter (Gast)]

Hallo,
ich habe gerade mit winapi angefangen und möchte mir eine oberfläche 
erstellen. Dazu habe ich ein Beispielprogramm gefunden, welches mir das 
Fenster erstellt

#include <windows.h>
#include <stdio.h>

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   PSTR szCmdLine, int iCmdShow)
{
   static TCHAR const szAppName[] = TEXT("Klassenname");
   HWND         hWnd;
   MSG          msg;
   WNDCLASSEX   wndclassex;

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

   if (!RegisterClassEx(&wndclassex))
   {
      MessageBox(NULL, TEXT("RegisterClassEx fehlgeschlagen!"),
                 szAppName, MB_OK | MB_ICONERROR);
      return -1;
   }

   hWnd = CreateWindowEx(WS_EX_OVERLAPPEDWINDOW, // erweiterter Fensterstil
                  szAppName, // Name der Fensterklasse
                  TEXT("Fenstertitel"), // Fenstertitel
                  WS_OVERLAPPEDWINDOW, // Fensterstil
                  CW_USEDEFAULT, // X-Position des Fensters
                  CW_USEDEFAULT, // Y-Position des Fensters
                  CW_USEDEFAULT, // Fensterbreite
                  CW_USEDEFAULT, // Fensterhöhe
                  NULL, // übergeordnetes Fenster
                  NULL, // Menü
                  hInstance, // Programm-Kopiezähler (Programm-ID)
                  NULL); // zusätzliche Parameter

   ShowWindow(hWnd, iCmdShow);
   UpdateWindow(hWnd);

   for (;;)
   {
      int ret = GetMessage(&msg, NULL, 0, 0);
      if (ret == -1)
         return -1;
      else if (ret == 0)
         break;
      TranslateMessage(&msg);
      DispatchMessage(&msg);
   }

   UnregisterClass(szAppName, hInstance);

   return (int)msg.wParam;
}

Danach kommt die Hauptnachrichtenschleife

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  static HWND hButton;
  static HWND lButton;
  HDC hdc;
  PAINTSTRUCT ps;

  switch (message)
  {
    case WM_PAINT:
    {
      hdc = BeginPaint(hWnd, &ps);
      TextOut(hdc, 0, 0, TEXT("Hello World!"), 12);
      EndPaint(hWnd, &ps);
      return 0;
    }
    case WM_CREATE:
    {
      hButton = CreateWindow(  "button",
                                  "Beenden",
                                  WS_CHILD | WS_VISIBLE,
                                  0, 0, 0, 0,
                                  hWnd,
                                  NULL,
                                  ((LPCREATESTRUCT) lParam) -> hInstance,
                                  NULL);

      lButton = CreateWindow( "button",
                  "Zweiter Button",
                  WS_CHILD | WS_VISIBLE,
                  0, 0, 0, 0,
                  hWnd,
                  NULL,
                  ((LPCREATESTRUCT) lParam) -> hInstance,
                  NULL);
      return 0;
    }
    case WM_SIZE:
    {
      MoveWindow(hButton, LOWORD(lParam) / 2 - 80, HIWORD(lParam) - 30, 160, 22, TRUE);
      MoveWindow(lButton, LOWORD(lParam) / 2, HIWORD(lParam) - 30, 160, 22, TRUE);
      return 0;
    }
    case WM_COMMAND:
    {
      if (lParam == (LPARAM)hButton)
      {
        if (HIWORD(wParam) == BN_CLICKED)
          SendMessage(hWnd, WM_CLOSE, 0, 0);
      }
      else if (lParam == (LPARAM)lButton)
      {
        if (HIWORD(wParam) == BN_CLICKED)
          SendMessage(hWnd, WM_CLOSE, 0, 0);
      }
      return 0;
    }
    case WM_CLOSE:
    {
      DestroyWindow(hWnd);
      break;
    }
    case WM_DESTROY:
    {
      PostQuitMessage(0);
      return 0;
    }
  }
  return DefWindowProc(hWnd, message, wParam, lParam);
}

Dazu habe ich eine Frage, kommen alle Elemente die ich in der Oberfläche 
erstelle in die selbe Callback Funktion (LRESULT CALLBACK WndProc)? Oder 
kann man das noch irgendwie aufteilen? Also pro element eine Funktion 
oder ähnlich?
Momentan habe ich nur zwei Buttons dort drinn. Aber wenn noch mehr 
Elemente (z.B. RadioButton oder Tastatureingabe oder schreibfenster oder 
...) kommen, kann das ja ziemlich unübersichtlich werden.

[marais (Gast)]

Ich weiss ja nicht, wie komplex Deine Oberfläche werden soll, aber für 
alles, was über zwei Knöpfe hinausgeht, würde ich nicht winapi 
verwenden. Es ist natürlich sinnvoll, das Beispielprogramm zu verstehen, 
um zu wissen, wie die Hauptnachrichtenschleife in Windows-Programmen 
funktioniert. Für den eigentlichen Job würde ich aber ein Framework 
verwenden. Das nimmt Dir viel Arbeit ab und kapselt viele Details (wie 
eben auch die Nachrichtenschleife).

Ich mache das mit MFC, einfach weil ich das vor 20 Jahren gelernt habe 
und Portabilität auf andere Plattformen normalerweise kein Thema ist. 
Ich trenne allerdings strikt GUI-Code und den eigentlichen Arbeitscode, 
um eben doch portieren zu können, falls erforderlich.


Zu den möglichen Frameworks hat jeder seine Meinung. Konsens ist wohl, 
dass ein Neueinsteiger heute nicht mehr mit MFC anfangen sollte, sondern 
eher Qt lernen sollte. Für kleinere Projekte gibt es einfachere 
Alternativen. Du sagst auch nicht, ob Du einen Compiler kaufen kannst 
(MFC gibt's soweit ich weiss nur in der kommerziellen Version von Visual 
Studio, Qt ist umsonst) oder ob alles umsonst sein muss.


Dann gibt's noch die Frage, ob Du Dich auf C# und .net einlassen 
möchtest (und damit an Microsoft-Technologie gebunden bist) - dann 
stehen andere Alternativen offen. Für mich musste ich diese Frage mit 
Nein beantworten, aber jeder Jeck iss anders.


Und falls Du wirklich nur zwei Knöpfe und ein Eingabefeld brauchst: 
Mach's mit winapi, Du lernst auf jeden Fall was dabei.

[Rufus Τ. F. (rufus)]

Wenn Du tatsächlich den sehr steinigen Weg gehen möchtest, 
Windows-GUI-Anwendungen mit der Win32-API zu schreiben, kann ich Dir nur 
die Lektüre eines Buches nahelegen:

Charles Petzold "Windows-Programmierung: Das Entwicklerhandbuch zur 
WIN32-API".

ISBN 3860631888

(das ist zwar fast zwanzig Jahre alt, aber die API für 
GUI-Programmierung und die dahinterstehenden Konzepte haben sich seitdem 
nicht geändert)

Üblicherweise empfehle ich keine übersetzten Bücher, hier aber stammt 
die Übersetzung von Arne Schäpers, der bereits das deutsche Handbuch von 
Borlands Turbo-C 2.0 geschrieben hatte, und das war exzellent.

Das englischsprachige Original des Petzold ("Programming Windows®, Fifth 
Edition") findest Du unter der ISBN 157231995X.

Beide Bücher sind natürlich nur noch antiquarisch erhältlich.

--

Ich verdiene seit über einem Vierteljahrhundert meinen Lebensunterhalt 
unter anderem mit der Windows-Programmierung, und ich bin sehr froh, 
GUI-Anwendungen nicht auf diese Art und Weise schreiben zu müssen. Das 
habe ich in den ersten paar Jahren (beginnend mit Windows 3.0) gemacht, 
und es ist sicherlich gutes Grundlagenwissen, das einem hilft, zu 
verstehen, warum eine bestimmte C++-Klassenbibliothek auf eine bestimmte 
Art und Weise aufgebaut ist --- aber nicht jedes Grundlagenwissen, das 
in einem Computer steckt, muss man unbedingt haben, wenn man einfach nur 
Programme dafür schreiben will.

Windows-GUI-Anwendungen würde ich mit einer C++-Klassenbibliothek 
schreiben, und da das Thema "Portabilität" nicht komplett uninteressant 
ist, würde ich eine auf mehreren Plattformen verfügbare Bibliothek 
wählen. Die "Platzhirsche" sind hier QT und wxwidgets.

Ich selbst arbeite überwiegend mit der nicht portierbaren MFC; die zu 
lernen rate ich nicht. Daß ich sie nutze, ist historisch bedingt; als 
ich damit anfing, gab es keine Alternativen. Als "Exit-Strategie" sehe 
ich in diesem Fall wxwidgets, weil einige strukturelle Konzepte der MFC 
ähneln und von daher der Umdenkaufwand nicht so groß ist, wie er es bei 
QT wäre.