Was ist WinApi

[new1988]

kann mir mal jemand sagen was winapi heißt??
was man damit machen kann ???

sollte man das als c++ programmierer wissen bzw können

im voraus schon thx

[Taelan]

Naja kommt drauf an ob du für Windows Programmieren willst.

WinAPI = Windows Application Programming Interface ? ^^

[Vertexwahn]

WinAPI (Abkürzung für Windows Application Programming Interface) ist eine Schnittstelle, die Windows-Programmierern bereitsteht, um Applikationen für Windows zu erstellen. Die Funktionen der WinAPI können von allen Windows-Programmen aufgerufen werden. Sie befinden sich in DLL-Dateien, wie kernel32.dll, user32.dll und gdi32.dll.

In Programmiersprachen wie zum Beispiel C, C++ oder Delphi wird die API zumeist unbemerkt verwendet. So bieten unter anderem die MFC-Bibliothek und das .NET-Framework eine objektorientierte Alternative zur direkten Nutzung der Windows API. Dennoch basieren viele von Programmen ausgeführte Aktionen, seien es I/O-Operationen, Windows-Dialoge oder Speicherverwaltung auf der Windows-API.

http://de.wikipedia.org/wiki/WinAPI

[Vertexwahn]

Es gibt nen haufen Tutorials und Bücher über WinAPI - such mal danach!!!

[DeltaPi]

Naja, als reiner C++ Programmierer (KONSOLE) nun nicht gerade
aber wenn du in die Windows Programmierung eindringst
ist winapi für dich unverzichtbar!

[Vertexwahn]

winapi für dich unverzichtbar!

willkommen im Zeitalter von Dot Net

Wenn du nur ne schöne GUI willst kannst du auf WinAPI total verzichten. Benutze lieber eine der Zahlreichen GUI Bibliotheken oder .Net

[Vertexwahn]

Hab mal folgendens hier gepostet - vielleicht ist es ja für dich interessant (zeigt wie man einen Fenster mit einen Button erstellt - wird auf den Button geklickt schließt sich das Fenster):

Damit man sich etwas besser zurechtfindet in der Windowswelt möchte ich zuerst auf einige Eigenheiten von Windows eingehen.

Oft begegnet man dem so genannten Handle. Ein Handle ist einfach ein Integer, der ein Objekt bezeichnet und intern von Windows genutzt wird, um zwischen verschiedenen Objekten unterscheiden zu können.

Name Beschreibung
HANDLE Ein generisches Objekt
HCURSOR Ein Cursor
HFILE Eine Datei
HGDIOBJ Ein GDI Objekt
HOBJECT Ein Objekt
HWND Ein Fenster

Als nächstes möchte ich einen Überblick über die häufigsten Datentypen von Windows geben:

Name C++ Äquivalent
BOOL int
TRUE 1
FALSE 0
UINT unsigned int
LONG long
LRESULT long
LPCSTR const char *
LPVOID void *
BYTE unsigned char
WORD unsigned short int
DWORD unsigned long int

Die oben vorgestellten Datentypen sind allesamt einfach als Makro (Define) implementiert.
Wer sich wundert warum Windows versucht einen eignen booleschen Datentyp einzuführen, muss wissen das es zu der Zeit als Windows programmiert wurde noch keinen booleschen Datentyp in C gab.

Ein anderes Wichtiges Element von zentraler Bedeutung ist der Device Context (kurz DC). Ein Device Context repräsentiert eine Sammlung von Grafischen Objekten zusammen mit ihren Attributen und Modis. Einen DC kann mal als Programmeirer nicht direkt manipulieren, sondern es gibt für diesen Zwecken einen Satz von Funktonen.

Normalerweise wird ein Device Context benötigt wenn man Grafik auf einem Fenster darstellen möchte. Dazu holt man sich den Device Context per GetDC() und gibt ihn nach dem Zeichnen wieder mit ReleaseDC frei. Anscheinend ist das ein Schutzmechanismus von Windows, der verhindern soll, das zwei Anwendungen gleichzeitig Versuchen in einem bestimmten Bereich zu zeichnen.

Ein DC kann auch mit CreateCompatibleDC() erzeugt werden. Dieser muss, wenn er nicht mehr gebraucht wird wieder mit DeleteDC freigegeben werden.

Auch auf die Hungarian Notation soll hier hingewissen werden. Hungarian Notation bedeutet nichts anderes als vor jedem Variablennamen ein Zeichen zu setzen (der sogenannte Präfix (prä = vor, fix = fest)), an dem man erkennt um welchen Datentyp es sich handelt. Aber nicht nur Datentypen werden so gekennzeichnet, sondern auch Funktionen, Arrays, Globals, usw. Dadurch soll der Code übersichtlicher werden und einfacher zu verstehen sein.

Dieses Prinzip versuchte Microsoft zu standardisieren indem man erstens festlegte das jede Variable, Zeiger, Klasse usw. einen Präfix erhält und zweitens welcher Datentyp welchen Präfix bekommt. Diesen Standard bezeichnen wir heute als Hungarian Notation.

In folgender Tabelle sind einige der wichtigsten Elemente dieses Standardarts aufgelistet:

Prefix Definiton
b bool
C char
dw DWORD
h Handle
l LONG
lp 32 Bit Zeiger
sz Null terminierter String
lpsz Zeiger auf Null terminierten String
rgb LONG, der einen RGB Wert enthält

Natürlich gibt es viele die sich nicht an diesen Standard halten, aber Microsoft hält sich daran (wie es am Microsoft Platform SDK oder an der MFC zu sehen ist).

Der Programmstart

Jedes Windowsprogramm startet nicht mit der main Funktion sondern mit der WinMain Funktion. Unter MsVC Net 2003 kann man aber ohne Probleme die WinMain Funktion durch die main Funktion ersetzen. Durch Umwege (Compilerspezifische Einstellungen oder Start der Anwendung durch die Konsole) kann dafür sorgen, das eine Anwendung mit WinMain auch eine Konsolenfenster besitzt, das für eventuelle Debug ausgaben genutzt werden kann, was sehr hilfreich sein kann.

Die WinMain Funktion sieht wie folgt aus:
int WinMain (
HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpszCmdLine,
int nCmdShow
);

hInstance ist ein Handle für die Instanz der Anwendung. Man kann die Anwendung (Maschinencode, EXE), als Schablone Klasse betrachten und eine gerade laufende Anwendung dieser Klasse als Objekt, also als Instanz betrachten. Genau das bezeichnet hInstance.

hPrevInstance ist nur aus Gründen der Aufwärtskompatibilität erhalten geblieben und kann ignoriert werden (liefert NULL als Wert).

lpszCmdLine ist schon fast selbsterklärend. Es liefert einfach alle Kommandozeilenangaben als String.

nCmdShow gibt an wie die Anwendung angezeigt werden soll (z. B. versteckt, minimiert, maximiert, usw.).

Die WinMain liefert einen Wert zurück, der beliebig sein darf.

Fenster

Ein Fenster kann mit der Funktion CreateWindow() erzeugt werden. Bevor diese Funktion aber aufgerufen werden kann muss, das Fenster erst noch angemeldet werden mit dem Aufruf der Funktion RegisterClass()

Der Prototyp von RegisterClass() sieht wie folgt aus:
ATOM RegisterClass(CONST WNDCLASS *lpWndClass);

Wie man sieht erwartet diese Funktion einen Zeiger oder besser gesagt die Adresse auf eine Fensterklasse (WNDCLASS).

Die Funktion liefert bei fehlgeschlagenem Aufruf den Wert 0 zurück, ansonsten liefert die Funktion einen Integerzurück, der eine eindeutige Kennung eines Fensters darstellt.

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

Die einzelnen Parameter der Struktur werde ich jetzt nicht mehr so ausführlich beschreiben. Einfach das Plattform SDK zu rate ziehen und dort nachlesen welches Strukturelement welche Bedeutung hat und mit welchen sinnvollen Werten es belegt werden kann. Es ist an dieser Stelle einfach Sinnlos das Plattform SDK einfach zu übersetzen (was ich hier schon oft gemachte habe) und dadurch das ganze noch weiter aufzublähen. Der einzige Paramter über den es Sinn macht etwas zu schreiben ist lpfnWndProc.

lpfnWndProc ist einfach ein Funktionszeiger auf eine Meldeschleife. Windows arbeitet Ereignisgesteuert (event-driven). Das heißt es gibt Ereignisse wie z. B. Mausklicks, Tastatureingabe oder Zeitgesteuerte Ereignisse auf die eine Anwendung reagieren kann.
Die Meldeschleife (Event Handler) erhält vom Betriebssystem Nachrichten (Messages), auf die die Anwendung reagieren kann, aber nicht muss. Beispielsweise wird der Anwendung ein Mausklick gemeldet, wenn auf eines ihrer Fenster geklickt wurde.

Jedes Fenster kann seinen eigenen Event Handler besitzen oder meherer Fenster können gemeinsame einen Event Handler nutzen, je nachdem wie man es wünscht.

Der Event Handler muss die Form

LRESULT CALLBACK WindowProc(HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
);

besitzen.

Der Parameter hwnd enthält den Handle des Fenster von dem die Nachricht erzeugt wurde. uMsg identifiziet die Nachricht. wParam und lParam werden für eventuelle Parmater der Nachricht genutzt.

Sobald eine Fensterklasse angemeldet ist kann sie mit CreateWindow erzeugt werden:

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

Um ein Fenster der vorher erzeugten Fensterklasse zu erzeugen wird einfach als lpWindowName, der vorher gewählte Name der Fensterklasse übergeben.

Windows würde nicht Windows heißen, wenn nicht alles aus Fenstern bestehen würde. Und es ist tatsächlich so – alles ist ein Fenster. Windows besitzt schon vordefinierte Fenster. So kann man beispielsweise als lpWindowName COMBOBOX, BUTTON, EDIT oder LISTBOX angeben und so einen Button auf ein Fenster platzieren.

Vorhin wurde erklärt, das nCmdShow Parameter der WinMain Funktion angibt wie die Anwendung angezeigt werden soll. nCmdShow ist eher als Empfehlung zu betrachten – ignoriert man den Parameter einfach passiert nämlich gar nichts. Mithilfe der Funktion ShowWindow kann man beeinflussen wie ein Fenster angezeigt werden soll:

BOOL ShowWindow(HWND hWnd,
int nCmdShow
);

hWnd bezeichnet das Fensterobjekt und nCmdShow wie das Fenster angezeigt werden soll. Hier übergibt man einfach den nCmdShow Parameter der WinMain Funktion und kann so auf die „Empfehlung“ von Windows eingehen, wenn man das will.

Nachrichten und Ereignisse

In Windows gibt es Nachrichten und Ereignisse. Damit das Programm in der Lage ist diese Nachrichten zu empfangen und an die entsprechenden Event Handler weiterzugeben ist folgender Code notwendig:

MSG msg;
while(GetMessage(&msg, NULL, 0, 0))
{
// translate any accelerator keys
TranslateMessage(&msg);

// send the message to the window proc
DispatchMessage(&msg);
}

Wer wissen will was dahinter steckt wirft am besten wieder einen Blick in das Platform SDK.

Ein Event Handler empfängt eingehende Nachrichten und verarbeitet sie – ein minimaler Event Handler könnte wie folgt aussehen:

LRESULT CALLBACK WindowProc(HWND hwnd,
UINT msg,
WPARAM wparam,
LPARAM lparam)
{
switch(msg)
{
case WM_DESTROY:
PostQuitMessage(0);
return 0;
default: break;
}

return (DefWindowProc(hwnd, msg, wparam, lparam));
}

DefWindowProc ist ein Default Windows Event Handler und verabeitet alle Nachrichten, die man nicht selbst abfängt.

Es gibt einen Haufen von Nachrichten. Ich möchte hier nur mal die Nachricht WM_DEVMODECHANGE erwähnen. Diese wird immer gesendet, wenn der Benutzer Geräteeinsellungen wie Auflösung des Monitors verändert.

Beispielprogramm

Im folgendem er Quelltext des Beispielprogrammes

#define WIN32_LEAN_AND_MEAN // instructs the compiler to not include extraneous MFC overhead
#include <windows.h>

HWND g_hButton;

LRESULT CALLBACK WindowProc(HWND hwnd,
UINT msg,
WPARAM wparam,
LPARAM lparam)
{

switch(msg)
{
case WM_DESTROY:
PostQuitMessage(0);
return 0;
case WM_COMMAND:
{
if (HIWORD(wparam) == BN_CLICKED &&
(HWND) lparam == g_hButton)
{
DestroyWindow(hwnd);
}
return 0;
}
default: break;
}

return (DefWindowProc(hwnd, msg, wparam, lparam));
}

int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdline,
int nCmdShow)
{
WNDCLASSEX winclass;
winclass.cbSize = sizeof(WNDCLASSEX);
winclass.style = CS_VREDRAW | CS_HREDRAW | CS_OWNDC | CS_DBLCLKS;
winclass.lpfnWndProc = WindowProc;
winclass.cbClsExtra = 0; // extra class info space
winclass.cbWndExtra = 0; // extra window info space
winclass.hInstance = hInstance; // assign the application instance
winclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
winclass.hCursor = LoadCursor(NULL, IDC_ARROW);
winclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
winclass.lpszMenuName = NULL; // the name of the menu to attach
winclass.lpszClassName = "WINCLASS1"; // the name of the class itself
winclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

RegisterClassEx(&winclass);

HWND hwnd;
hwnd = CreateWindowEx(NULL,
"WINCLASS1",
"Fenstertitel",
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
0,
0,
400,
400,
NULL, // handle to parent
NULL, // handle to menu
hInstance, // instance of this application
NULL);

if(hwnd==NULL)
return -10;

g_hButton = CreateWindow("BUTTON", "Mein Button", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 100, 100, 100, 100, hwnd, NULL, hInstance, NULL);
CreateWindow("STATIC", "Mein Label", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 10, 10, 100, 100, hwnd, NULL, hInstance, NULL);

//UpdateWindow();

MSG msg;
while(GetMessage(&msg, NULL, 0, 0))
{
// translate any accelerator keys
TranslateMessage(&msg);

// send the message to the window proc
DispatchMessage(&msg);
}

return 0;
}