WinAPI - Ecke
Auf dieser Seite stelle ich meine Units vor. Die Units habe ich gemacht, um Ordnung zu halten - damit sp�ter nicht eine F�lle von Funktionen bei mir herumliegt und ich nen Rappel bekomm.


1. Unit Fonts
2. Unit DynDialogs
3. Unit InputBox
4. Unit MemoryDialog
5. Unit Regions
6. Unit AppTerminating
7. Unit ColorButton



Unit Fonts
#ifndef FontsH
#define FontsH
//---------------------------------------------------------------------------
#include <windows.h>
//---------------------------------------------------------------------------

// Definitions of font formats
#define  FF_NORMAL     0
#define  FF_BOLD       2
#define  FF_ITALIC     4
#define  FF_UNDERLINE  8
#define  FF_STRIKEOUT  16
//---------------------------------------------------------------------------

HFONT  BuildFont(LPCTSTR lpszName, INT iSize, WORD wFontFormat);
HFONT  SetFont(HWND hwnd, LPCTSTR lpszName, INT iSize, WORD wFontFormat);
VOID   SetFont(HWND hwnd, HFONT hFont);
//---------------------------------------------------------------------------
#endif
Erkl�rung: Mit Hilfe der Unit Fonts soll man leichter mit Schriftarten umgehen k�nnen. Per BuildFont() kann man schnell ein Font erstellen, w�hrend dies in WinAPI eine Menge an schwer verst�ndlichen Zeilen erfordert. SetFont() erstellt ein Font und weist es dem Fenster im ersten Parameter zu. Die zweite Version von SetFont() ist wohl nicht weiter zu erl�utern.
Beispiel: SetFont(hEdit, TEXT("Times New Roman", 10, FF_BOLD | FF_ITALIC);
Download:
Fonts.ZIP
NACH OBEN




Unit DynDialogs
//---------------------------------------------------------------------------
#ifndef DynDialogsH
#define DynDialogsH
//---------------------------------------------------------------------------
#include <windows.h>
//---------------------------------------------------------------------------

// Definitions of icon representations in ShowMessage()
#define  SM_NONE       0
#define  SM_WARNING    1
#define  SM_INFO       2
#define  SM_ERROR      3
//---------------------------------------------------------------------------

LPWORD DWORD_ALIGN(LPWORD);
LPWORD NON_DWORD_ALIGN(LPWORD);
LPWORD InitDialog(LPVOID lpv, LPCTSTR title, DWORD style, WORD ctrlno,
                  LPCTSTR fontname, WORD fontsize, UINT x, UINT y, UINT cx, UINT cy);
LPWORD CreateDlgControl(LPWORD lpw, LPCTSTR ctrl_class, WORD id, LPCTSTR caption,
                        DWORD style, UINT x, UINT y, UINT cx, UINT cy);
VOID   ShowMessage(HWND hwnd, LPCTSTR lpszMsg, LPCTSTR lpszTitle, WORD wIcon);
VOID   ShowMessage(HWND hwnd, INT val, LPCTSTR lpszTitle, WORD wIcon);
//---------------------------------------------------------------------------
#endif
Erkl�rung: Mit dieser Unit kannst du dynamische Dialoge erstellen. Die Unit "InputBox" enth�lt ein Anwendungsbeispiel. Mit den Funktionen InitDialog() und CreateDlgControl() baut man seinen Dialog auf wie in einem Resource-Skript. Die ShowMessage()-Funktionen sind nur dazu da, um schnell einen String oder einen Integer-Wert per MessageBox auszugeben.
Download:
DynDialogs.ZIP
NACH OBEN




Unit InputBox



//---------------------------------------------------------------------------
#ifndef InputBoxH
#define InputBoxH
//---------------------------------------------------------------------------
#include <windows.h>
//---------------------------------------------------------------------------

// Input-Box-Childs
#define  ID_INPUT     200
#define  ID_INFOTEXT  201
//---------------------------------------------------------------------------

int   InputBox(HWND hwnd, LPCTSTR prompt, LPCTSTR title, LPTSTR buffer, INT buflength);
BOOL  CALLBACK  InputBoxDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam);
//---------------------------------------------------------------------------
#endif
Erkl�rung: Diese Unit ben�tigt die Unit "DynDialogs" und enth�lt nur eine aufrufbare Funktion: InputBox(). Diese Funktion zeigt einen (modalen) Dialog an, wie er z.B. bei einem
JavaScript-Prompt erscheint (siehe Abbildung). Der String, den der User eingibt, wird im Parameter "buffer" gespeichert. Der R�ckgabewert ist abh�ngig von der User-Eingabe. Best�tigt der User seine Eingabe (z.B. durch Klicken auf "OK"), so ist der R�ckgabewert IDOK. Bricht der User die Eingabe ab (z.B. durch Klicken auf "Abbrechen"), so ist der R�ckgabewert IDCANCEL.
Download: InputBox.ZIP
NACH OBEN




Unit MemoryDialog




//---------------------------------------------------------------------------
#ifndef MemoryDialogH
#define MemoryDialogH
//---------------------------------------------------------------------------

// Definitions of dialog control IDs
#define  ID_GROUP          10
#define  ID_STATIC_FROM    11
#define  ID_STATIC_TO      12
#define  ID_EDIT_FROM      13
#define  ID_EDIT_TO        14
#define  ID_BUTTON_SHOW    15
#define  ID_BUTTON_SAVE    16
#define  ID_EDIT_MEMORY    17
//---------------------------------------------------------------------------

LRESULT ShowMemory(HWND hwnd, BYTE* addr_from, BYTE* addr_to);
BOOL    TestValues(DWORD dwFrom, DWORD dwTo);
DWORD   HexToInt(unsigned char* buf, INT digits);
VOID    DisplayMemory(HWND hDlg, DWORD dwFrom, DWORD dwTo);
CHAR*   FillLines(DWORD dwFrom, DWORD dwTo);
VOID    SaveToFile(HWND hDlg, DWORD dwFrom, DWORD dwTo);

BOOL  CALLBACK  ShowMemDlgProc(HWND hwnd, UINT uiMsg, WPARAM wParam, LPARAM lParam);
//---------------------------------------------------------------------------
#endif
Erkl�rung: Diese Unit ben�tigt die Units "DynDialogs" und "Fonts", und auch in ihr ist nur eine Funktion f�r den Programmierer von Bedeutung: ShowMemory(). Diese Funktion zeigt einen (modalen) Dialog an. Dieser "visualisiert" den Speicherblock, der durch den zweiten und den dritten Parameter definiert ist. Der zweite Parameter zeigt auf die Startadresse, der dritte auf die Endadresse des anzuzeigenden Blocks. Die einzelnen Bytes im Block werden hexadezimal angezeigt (siehe Abbildung) wie in einem HexEditor. Ich denke, dieser Dialog ist f�r jeden Windows-Programmierer ein n�tzliches Tool.
Beispiel:
CHAR lpszString[30] = "Dies ist eine Zeichenkette";
ShowMemory(hwnd, (BYTE*)lpszString, (BYTE*)&lpszString[29]);

Download:
MemoryDialog.ZIP
NACH OBEN




Unit Regions
#ifndef RegionsH
#define RegionsH
//---------------------------------------------------------------------------
#define  LR_FROMRESOURCE   1
#define  LR_FROMFILE       2
//---------------------------------------------------------------------------

typedef VOID CALLBACK (*PROGRESSCALLBACK)(float pc);

//---------------------------------------------------------------------------

RECT     Rect(LONG, LONG, LONG, LONG);
BOOL     IsBitInByte(BYTE p, UINT no);
HBITMAP  CreateMask(HBITMAP hBmpSrc, COLORREF clTransparent);
HRGN     GetLastRgnPart(UINT rect_counter, RGNDATA* lpRgnData);
HRGN     BitmapToRegion(HBITMAP hBmp, COLORREF clTransparent, PROGRESSCALLBACK prgcall);
BOOL     SaveRegion(HRGN hRgn, LPCTSTR lpszFileName);
BOOL     LoadRegion(HINSTANCE hInstance, HRGN& hRgn, WORD wFlags, LPCTSTR lpszName);
BOOL     CopyRegion(HRGN& hRgnDest, HRGN hRgnSrc);
//---------------------------------------------------------------------------
#endif
Erkl�rung: Diese Unit behandelt Regions. Die wichtigen Funktionen sind hier BitmapToRegion(), SaveRegion(), LoadRegion() und CopyRegion(). BitmapToRegion() wandelt eine Bitmap unter Angabe einer transparenten Farbe in eine Region um. Die Funktion generiert zunächst per CreateMask() eine monochrome Maske der Bitmap, um diese dann durchzuscannen. Da die Region per ExtCreateRegion() erstellt wird, ist BitmapToRegion() besonders schnell. Mit SaveRegion() l�sst sich eine Region bin�r in ein File speichern. Per LoadRegion() kann man eine Region entweder aus einem solchen File oder aus einer Resource laden. CopyRegion() schlie�lich dupliziert eine Region.
Download:
Regions.ZIP
Bemerkung: Der RegionBuilder arbeitet mit dieser Unit. Mit diesem Tool kannst du aus verschiedenen Grafikformaten (BMP, JPG, JPEG, GIF, ICO) Regions erstellen, ausprobieren und abspeichern. Linke eine so abgespeicherte Region per Resource in dein Programm und lade sie mit LoadRegion().
NACH OBEN




Unit AppTerminating
//---------------------------------------------------------------------------
#ifndef AppTerminatingH
#define AppTerminatingH
//---------------------------------------------------------------------------
#include <windows.h>
//---------------------------------------------------------------------------

// Ein paar Definitionen
#define TA_FAILED        0
#define TA_CANNOT_OPEN   1
#define TA_SUCCESS_CLEAN 2

#define KA_FAILED        0
#define KA_CANNOT_OPEN   1
#define KA_SUCCESS_KILL  2
//---------------------------------------------------------------------------

BOOL CALLBACK TerminateAppEnum(HWND hwnd, LPARAM lParam);
WORD TerminateAppByWindowClosing(DWORD pID, DWORD dwTimeout);
WORD KillApp(DWORD pID);
//---------------------------------------------------------------------------
#endif
Erkl�rung: In dieser Unit befinden sich Funktionen, um eine Applikation zu beenden. TerminateAppByWindowClosing() versucht, einen Prozess durch das Schlie�en des Haupt-Fensters zu beenden. Der erste Parameter bezeichnet die ProcessId des Prozesses und der zweite die Dauer in Millisekunden, die maximal gewartet werden soll, ob der Prozess auch wirklich beendet wurde. Diese Funktion ist der Funktion KillApp() vorzuziehen, denn Letztere killt den Prozess, so dass alle DLLs, die mit dem Prozess verkn�pft waren, nicht benachrichtigt werden. Du solltest KillApp() nur dann anwenden, wenn TerminateAppByWindowClosing() nicht TA_SUCCESS_CLEAN zur�ckgibt.
Beispiel: Mit folgendem Code kannst du z.B. einen gerade ge�ffneten Editor-Prozess beenden:
DWORD pID  = 0;
HWND  hEditor = NULL;
WORD  wTA;

hEditor = FindWindow(NULL, "Unbenannt - Editor");
if(!hEditor)
{
   MessageBox(hwnd, "Fenster nicht gefunden", "ERROR", MB_OK);
   return;
}

GetWindowThreadProcessId(hEditor, &pID);
wTA = TerminateAppByWindowClosing(pID, 5000);

if(wTA != TA_SUCCESS_CLEAN)
{
   char* buf1 = "Der Prozess konnte nicht durch blo�es Schlie�en des\n\
Fensters beendet werden. Wollen Sie ihn killen?";
   char* buf2 = "Der Prozess konnte nicht gekillt werden";
   char* buf3 = "Der Prozess konnte nicht ge�ffnet werden";

   if(wTA == TA_CANNOT_OPEN)
      MessageBox(hwnd, buf3, "ERROR", MB_OK|MB_ICONERROR);
   else
   {
      INT resp = MessageBox(hwnd, buf1, "Information", MB_YESNO | MB_ICONINFORMATION);
      if(resp == IDYES)
         if(KillApp(pID) == TA_FAILED)
            MessageBox(hwnd, buf2, "Fehler", MB_OK|MB_ICONERROR);
   }
}

Download:
AppTerminating.ZIP
NACH OBEN




Unit ColorButton
//---------------------------------------------------------------------------
#ifndef ColorButtonH
#define ColorButtonH
//---------------------------------------------------------------------------

VOID              RegisterColorButtonClass(HINSTANCE hInstance);
COLORREF          GetColor(HWND hwnd);
VOID              SetColor(HWND hwnd, COLORREF color);
COLORREF          GetFontColor(HWND hwnd);
VOID              SetFontColor(HWND hwnd, COLORREF color);
//---------------------------------------------------------------------------
#endif
Erkl�rung: "ColorButton" ist eine Fenster-Klasse wie "STATIC", "EDIT", oder "Button". M�chte man sie benutzen, so muss man sie zuerst mit RegisterColorButtonClass() registrieren. Alles andere l�uft wie bei normalen Fensterklassen. Der ColorButton imitiert den normalen Windows9x - Button mit der Ausnahme, dass hier noch die Farbe des Buttons und der Aufschrift ge�ndert werden k�nnen. Der Button kann (noch) keine Grafiken darstellen - nur Text.
Download:
ColorButton.ZIP
NACH OBEN
Hosted by www.Geocities.ws

1