4. Suche Tutorials (war: Eine Bitte....)

Suche Tutorials (war: Eine Bitte....)

  • B

    😉 Hallo zusammen!

    Ich ahbe neulich mit C++ angefangen und würde gerne die grundlagen der programmierung mit WinMain erlernen. (Zur Zeit kann ich gut VB, bischen C++)
    Es wäre nett wenn jmd, einen Link oder ein Dokument posten könnte, mit dem ich das wesentliche zur verfügung hätte. Ihc kann mir vorstellen, dass das ganze für hier viel zu lange ist. deswegen wär ein externer link beser als ein kurzer satz..

    Nur so als idee: Ich denke ein Thread, der die Grundinfos enthält sollte der Admin für immer im Forum fixieren um für neueinsteiger das ganze zu vereinfachen, und zugleich das forum zu entlasten.

    ---------------------------------------------------------------------------
    🙄 Bin seit tagen im Web auf der Suche nach ner Page auf der steht, wie man OHNE MFC (etc.) richtige Windows Anwendungen erstellen kann. Ne echte Erleichterung dieses forum zu sehn muss ich sagen..
    Ich denke wenn man schon Programmiert, dann ein wenig mehr independence. Mehr selbstständigkeit...

    das wars auhc schon, MfG BreakerMaker ©

    edit: Bitte einen aussagekräftigen Titel verwenden.

    0
  • W

    Die WinAPI ist gut dokumentiert. Bei Fragen zu einzelnen Funktionen lohnt es sich immer zuerst, in der MSDN nachzuschauen. Einen Link dahin findest du über der Hauptseite zu diesem Forum hier. Wenn du keinen Bock hast, immer im INET rumzuhängen, rate ich dir, die Datei win32hlp.exe auf http://www.cs.virginia.edu/~lcc-win32/ unter Free Downloads runterzuladen.
    Hier ein kleines Beispielprogramm für dich, das ich mit vielen Kommentaren versehen habe:

    // Diese Datei wird immer inkludiert, wenn man mit der WinAPI arbeitet
#include <windows.h>
//---------------------------------------------------------------------------

// Definitionen
#define ID_BUTTON    1
//---------------------------------------------------------------------------

// Globale Variablen
LPCTSTR    g_lpszAppTitle = TEXT("<AppTitle>");
LPCTSTR    g_lpszAppClass = TEXT("<AppWindowClass>");
HINSTANCE  g_hInstance;
HWND       g_hAppWindow, g_hButton;

// Zu den Typen:
// LPCTSTR steht für Long Pointer Constant T(dazu sag ich gleich noch was) String.
// Wenn UNICODE nicht definiert ist (#define UNICODE), dann ist das nichts
// anderes als ein char*. Wenn Unicode definiert ist, dann ein wchar_t*.
// Das Makro TEXT() macht nun char*s zu wchar_t*s oder lässt sie so, je
// nachdem, ob UNICODE nun definiert ist oder nicht.
// HINSTANCE ist ein Handle-Typ. Kümmer dich erstmal nicht drum.
// HWND ist wichtig. Das ist auch ein Handle-Typ, und zwar ein Fenster-Handle-
// Typ. Damit wird jedes Fenster, das in Windows existiert eindeutig gemacht.
// Alle Funktionen in der WinAPI, mit denen man was an einem Fenster machen
// kann, verlangen ein HWND als Parameter.
//---------------------------------------------------------------------------

// Funktions-Prototypen
VOID              RegisterAppWindow();
VOID              Create_GUI_Interface(HWND hwndParent);
LRESULT CALLBACK  AppWndProc(HWND, UINT, WPARAM, LPARAM);
VOID              ShowMessage(LPCTSTR);
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, PSTR, int)
{
   MSG  msg;

   // Die Instanz zu unserem Programm, welche oft benötigt wird
   // bei Verwendung der WinAPI
   g_hInstance = hInstance;

   // Registriere Application Window
   RegisterAppWindow();

   // Erstelle Application Window
   g_hAppWindow = CreateWindow(g_lpszAppClass,// Der Fensterklassen-Name
                               g_lpszAppTitle,// Der Text in der Titelleiste
                               WS_VISIBLE|WS_MINIMIZEBOX|WS_SYSMENU,// Der Fenster-Stil
                               100, 100, 300, 300,// Die Fenster-Abmessungen
                               NULL,// Kein Mutterfenster
                               NULL,// Kein Menu
                               g_hInstance,// Die Programminstanz
                               NULL);// Keine Extra-Daten

   // Message Loop
   // Diese wartet auf eingehende Nachrichten an das Fenster und verteilt diese
   // auf die WindowProcs, also an die Nachrichten-verarbeitenden Funktionen zu
   // jedem Fenster. Hier gibt es nur eine solche, nämlich AppWndProc.
   // Ist die Message-ID WM_QUIT, dann gibt GetMessage() FALSE zurück
   while( GetMessage(&msg, NULL, 0, 0) )
   {
      TranslateMessage(&msg);// Übersetzt die Eingaben (erstmal nicht so wichtig)
      DispatchMessage(&msg);// Verteilt die Messages an die WindowProcs
   }

   return msg.wParam ;
}
//---------------------------------------------------------------------------

VOID RegisterAppWindow()
{
   // Jedes Fenster ist von einer bestimmten Klasse
   // Jede neue Fensterklasse muss registriert werden
   WNDCLASSEX wndclass;
   wndclass.cbSize        = sizeof(WNDCLASSEX);
   wndclass.style         = 0;
   wndclass.lpfnWndProc   = AppWndProc;// Die Funktion, die Nachrichten an das Fenster bearbeitet
   wndclass.cbClsExtra    = 0;
   wndclass.cbWndExtra    = 0;
   wndclass.hInstance     = g_hInstance;// Die Programm-Instanz
   wndclass.hIcon         = LoadIcon(NULL, IDI_APPLICATION);// Ein Icon für das Fenster
   wndclass.hCursor       = LoadCursor(NULL, IDC_ARROW);// Ein Cursor für das Fenster
   wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);// Ein Brush (Pinsel) für das Fenster
   wndclass.lpszMenuName  = NULL;// Kein Menu
   wndclass.lpszClassName = g_lpszAppClass;// Der Klassenname (hier: "<AppWindowClass>")
   wndclass.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);// Noch ein Icon (klein)

   RegisterClassEx(&wndclass);
}
//---------------------------------------------------------------------------

VOID Create_GUI_Interface(HWND hwndParent)
{
   // Create button
   g_hButton = CreateWindow(TEXT("BUTTON"),// Die Fensterklasse ("BUTTON" wurde schon registriert von Windows)
                            TEXT("OK"),// Der Text auf dem Button
                            WS_VISIBLE|WS_CHILD|BS_DEFPUSHBUTTON,// Der Fenster-Stil
                            205, 230, 75, 23,// Die Fenster-Koordinaten (left, top, width, height)
                            hwndParent,// Das Mutterfenster
                            (HMENU)ID_BUTTON,// Die ID (oben definiert)
                            g_hInstance,// Wieder die Programm-Instanz
                            NULL);
   // Dem Button eine ordentliche Schriftart geben
   SendMessage(g_hButton, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), MAKELPARAM(TRUE, 0));
}
//---------------------------------------------------------------------------

// Diese Funktion wird gaaaanz oft aufgerufen, da sie alle Messages verarbeitet,
// die an das Fenster verschickt werden. Jede Message hat eine ID, die sie
// identifiziert. Diese ist in uiMsg gespeichert. In wParam und lParam werden
// zusätzliche Informationen über die Message gespeichert.
LRESULT CALLBACK AppWndProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
   switch(uiMsg)
   {
      // WM_CREATE ist die erste Message an das Fenster nach dem Erstellen.
      // Sie wird schon gesendet, wenn CreateWindow() noch garnichts zurück-
      // gegeben hat.
      case WM_CREATE:
         Create_GUI_Interface(hwnd);
         return 0;

      // WM_COMMAND wird gesendet, wenn ein Control (z.B. ein Button) eine
      // Standard-Nachricht bekommen hat. Das Control schickt die Message
      // dann weiter an das Parent-Window mit einer sogenannten Notification-
      // Message-ID, die im oberen WORD von wParam gespeichert ist.
      case WM_COMMAND:
         switch( LOWORD(wParam) )// In LOWORD(wParam) steht die Control-ID
         {
            case ID_BUTTON:// Wenn die Control-ID ID_BUTTON ist...
               if( HIWORD(wParam) == BN_CLICKED )// Wenn die Notification-Mesage-ID BN_CLICKED ist
               {
                  ShowMessage("Das Programm wird jetzt beendet");// Eine Message ausgeben
                  SendMessage(hwnd, WM_CLOSE, 0, 0);// Das Programm beenden
               }
               break;
         }
         return 0;

      // WM_DESTROY wird an das Fenster gesendet, wenn es zerstört werden soll
      case WM_DESTROY:
         PostQuitMessage(0);// Beendet das Programm (sendet WM_QUIT an das Fenster)
         return 0;
   }

   // Wenn die Message nicht von dieser WindowProc verarbeitet wird, wird sie
   // an die DefWindowProc weitergeleitet, die die Message standardmäßig verar-
   // beitet. Zum Beispiel wird auf WM_CLOSE mit einer Sendung von WM_DESTROY
   // an das Fenster geantwortet. Fängst du oben WM_CLOSE ab und return'st 0,
   // so wird das Programm nicht beendet. Probier's mal...
   return DefWindowProc(hwnd, uiMsg, wParam, lParam);
}
//---------------------------------------------------------------------------

VOID ShowMessage(LPCTSTR str)
{
   MessageBox(g_hAppWindow, str, g_lpszAppTitle,  MB_OK|MB_ICONINFORMATION);
}
//---------------------------------------------------------------------------
    0
  • F

    Also mit Google solltest du da eigentlich eine ganze Menge finden - C bzw. C++ solltest du aber schon ordentlich können

    - http://www.win-api.de/
    - http://www.germandevnet.de/tutorials/cpp-winapi/
    - http://www.winapi.net
    - http://www.henkessoft.de/api1.htm
    - http://www.henkessoft.de/WinAPI_7_GDI.htm

    0
  • B

    Vielen dank.. ich denke das wird mir weiterhelfen.

    0
  • W

    Ich hoffe, denn ich habe mir viel Mühe gegeben!

    0
  • ?

    🤡 🤡 🤡 🤡 🤡 🤡 🤡

    0
Anmelden zum Antworten