U_WINDOW.H

gehe zur Dokumentation dieser Datei

//#############################################################################
//                                                                           //
// U_WINDOW.H                                                                //
//                                                                           //
// Subsystem : Fenster-Templates: modale und modeless Dialog; MDI-Fenster    //
// Benutzung durch andere Subsysteme erforderlich: JA                        //
// Implementation: U_WINDOW.CPP                                              //
//---------------------------------------------------------------------------//
// Autor(en): Thomas Kullmann, Günther Reinecker                             //
// Quelle:    verschoben aus SWINTRAC.H                                      //
// Stand:     10.04.2002                                                     //
//                                                                           //
//#############################################################################

#ifndef __WINDOW_H
#define __WINDOW_H

#include "utils\u_values.h"
#include "utils\u_lists.h"
#include <winuser.h> // für die unten definierten Konstanten, RegisterHotKey und UnregisterHotKey
#include <vector> // für std::vector

// die defines entstammen der WINUSER.H

// modifier-Keycodes für WM_SETHOTKEY
#define  HOTKEYF_SHIFT    0x01
#define  HOTKEYF_CONTROL  0x02
#define  HOTKEYF_ALT      0x04
#define  HOTKEYF_EXT      0x08

// die folgenden Konstanten entsprechen dem Parameter <aCode> wenn Dlg_OnCommand eintritt
const UINT ONENTER= 256; // Steuerelement hat den Eingabefokus bekommt
const UINT ONEXIT= 512;  //                                    verloren

const DWORD MainWindow_Style= WS_CLIPCHILDREN | WS_OVERLAPPED | WS_CAPTION | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SYSMENU;
const DWORD ClientWindow_Style= WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL | WS_HSCROLL;

#define    MBINFO              (MB_OK | MB_ICONINFORMATION)
#define    MBASK               (MB_YESNO | MB_ICONEXCLAMATION)
#define    MBFAILURE           (MB_OK | MB_ICONSTOP)
#define    MBSTOP              (MB_OK | MB_ICONSTOP)

//#############################################################################
// globale Konstanten
//#############################################################################

// VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39)
const char VK_0= '0';
const char VK_1= '1';
const char VK_2= '2';
const char VK_3= '3';
const char VK_4= '4';
const char VK_5= '5';
const char VK_6= '6';
const char VK_7= '7';
const char VK_8= '8';
const char VK_9= '9';

// VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A)
const char VK_A= 'A';
const char VK_B= 'B';
const char VK_C= 'C';
const char VK_D= 'D';
const char VK_E= 'E';
const char VK_F= 'F';
const char VK_G= 'G';
const char VK_H= 'H';
const char VK_I= 'I';
const char VK_J= 'J';
const char VK_K= 'K';
const char VK_L= 'L';
const char VK_M= 'M';
const char VK_N= 'N';
const char VK_O= 'O';
const char VK_P= 'P';
const char VK_Q= 'Q';
const char VK_R= 'R';
const char VK_S= 'S';
const char VK_T= 'T';
const char VK_U= 'U';
const char VK_V= 'V';
const char VK_W= 'W';
const char VK_X= 'X';
const char VK_Y= 'Y';
const char VK_Z= 'Z';

//#############################################################################
// global
//#############################################################################

// ACHTUNG: So kann NUR MAX. EINE Tastenkombination registriert werden!
//          Diese Art Tastenkombination funktioniert auch unter Win16.
// FUNKTION
//   registiert die angegeben Tastenkombination; Wenn bereits eine solche Tastenkombination registriert ist, wird diese überschrieben.
//   Was passiert, wenn die so registrierte Tastenkombination gedrückt wird?
//   - ist das Fenster inaktiv, wird es aktiviert
//   - SONST wird Botschaft WM_SYSCOMMAND mit wParam==SC_HOTKEY ans Fenster gesendet
// Signatur: SetHotKey ( in aWnd, in aKey, in aShift, in aCtrl, in aAlt, in aExtended )
//   - der erste Parameter ist das Handle des Fensters, das die Tastenkombinationen empfangen möchte
//   - der zweite Parameter entspricht einer "normalen" Taste (dafür sollten die VK_-Konstanten verwendet werden!)
//   - Parameter drei bis sechs bezeichnen, welche Systemtasten für die Tastenkombination zu drücken sind
// ==> TRUE <--> Tastenkombination erfolgreich registriert
// Bsp.: SetActivateHotKey ( wndHandle, VK_P, FALSE, TRUE, TRUE, FALSE ); // registriert Ctrl+Alt+'P' für das Fenster <wndHandle>
BOOL _CURVECLASS WINAPI SetActivateHotKey ( HWND, const char, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE );

//#############################################################################
// THotKey
//#############################################################################

// ACHTUNG: Diese Art Tastenkombination sind erst ab Win32 verfügbar - in Win16 deshalb leer implementiert.
//          Dafür können hiervon "nahezu" beliebig viele Tastenkombinationen registriert werden.
// FUNKTION
//   registriert die angegebene Tastenkombination
//   Wenn die Tastenkombination gedrückt wird (AUCH WENN DAS FENSTER INAKTIV IST !!!), wird eine WM_HOTKEY-Botschaft ausgelöst, die den Keycode in lParam trägt;
//   Beim verarbeiten der Botschaft, kann man mit IsEqual( lParam ) ermittelt, ob es sich um diese Tastenkombination handelt.
//   Wenn man <m_Cmd> auf von -1 verschiedene Werte setzt und das Fensterhandle von einem (von TBasicWindow abgeleiteten) Objekt
//   besteht, wird (NUR wenn das Fenster aktiviert ist) anstatt der WM_HOTKEY-Botschaft ein Kommando (mit <m_Cmd> als Id) ausgelöst.
// Signatur: THotKey ( in aWindow, in aKey, in aShift, in aCtrl, in aAlt, in aWin )
//   - der erste Parameter ist das Handle des Fensters, das die Tastenkombinationen empfangen möchte
//   - der zweite Parameter entspricht einer "normalen" Taste (dafür sollten die VK_-Konstanten verwendet werden!)
//   - Parameter drei bis sechs bezeichnen, welche Systemtasten für die Tastenkombination zu drücken sind - der letzte Parameter entspricht der Windows-Taste
// ==> TRUE <--> Tastenkombination erfolgreich registriert
// Bsp. THotKey ( wndHandle, VK_P, FALSE, TRUE, TRUE, FALSE ); // registriert Ctrl+Alt+'P' für das Fenster <wndHandle>
class THotKey
{
        //-----------------------------------------------------------------------------
        // Konstruktor-Destruktor
private:
        THotKey( THotKey& ) {} // kein Copy-Konstruktor
        THotKey &operator= ( const THotKey& )
        {
                return *this;
        } // und auch kein Zuweisungsoperator

public:
        THotKey ( HWND, const char, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE );
        virtual ~THotKey ( void );

        //-----------------------------------------------------------------------------
        // Accessormethode(n)
public:
        BOOL IsEqual ( LPARAM ) const;
        BOOL IsRegistered ( void ) const;

        //-----------------------------------------------------------------------------
        // STATIC
public:
        static UINT CalcModifier ( const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE ); // berechnet den Modifer-Code
        static LPARAM CalcKeyCode ( const char, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE ); // berechnet den Key-Code

        //-----------------------------------------------------------------------------
        // ATTRIBUTE
public:
        int m_Cmd;         // wenn die Tastenkombination gedrückt wird, löst TBasicWindow ein Kommando mit <m_Cmd> aus; bei <m_Cmd>==-1 wird eine WM_HOTKEY-Botschaft ausgelöst (siehe Beschreibung von THotKey)

private:
        HWND m_Window;     // Fenster, das die WM_HOTKEY-Botschaft erhalten soll, wenn die Tastenkombination gedrückt wurde
        ATOM m_Atom;       // eindeutiger Bezeichner; 0 wenn keiner mehr verfügbar
        BOOL m_Registered; // Tastenkombination registriert?

        LPARAM m_KeyCode;  // KeyCode der (im Konstruktor übergebenen) Tastenkombination
};

//#############################################################################
// TBasicWindow
//#############################################################################

class _CURVECLASS TBasicWindow
{
        //-----------------------------------------------------------------------------
        // Konstruktor-Destruktor
private:
        TBasicWindow ( TBasicWindow& ) {} // kein Copy-Konstruktor
        TBasicWindow &operator= ( const TBasicWindow& )
        {
                return *this;
        } // und auch kein Zuweisungsoperator

public:
        TBasicWindow ( HINSTANCE );
        virtual ~TBasicWindow ( void );

        //-----------------------------------------------------------------------------
        // Accessormethode(n)
public:
        HWND GetHandle ( void ) const
        {
                return m_Window;
        };

        HINSTANCE GetInstance() const 
        {
                return m_Instance;
        };

        //-----------------------------------------------------------------------------
        // StringTable-Einträge laden
public:
        // Signatur: LoadString( in aResId )
        // sucht den StringTable-Eintrag <aStrTbleId>, ermittelt die Größe, reserviert entsprechend dynamischen Speicher 
        // und gibt den String zurück - der Aufrufer muss den Speicher freigeben!!!
        // wird der Eintrag nicht gefunden, wird "" zurückgegeben***
        // ***In der DEBUG-Version wird zusätzlich eine TraceErr-Fehlermeldung ausgegeben!
        char *LoadString(const int) const;

        // Signatur: LoadString( in aResId, out aValid )
        // WIEVOR, <aValid> gibt zusätzlich an, ob der Eintrag gefunden wurde
        char *LoadString ( const int, BOOL & ) const;

        //-----------------------------------------------------------------------------
        // Fenster-Titel ermitteln
private:
        // Signatur: GetWindowText( in aWindow )
        // ermittelt den Titel des Fensters mit Handle <aWindow>, ermittelt die Größe, reserviert entsprechend dynamischen Speicher 
        // und gibt den String zurück - der Aufrufer muss den Speicher freigeben!!!
        // wird der Eintrag nicht gefunden, wird "ohne Titel" zurückgegeben***
        static char *GetWindowTxt ( HWND );

        // WIEVOR, für <m_Window>
        char *GetWindowTxt();

        //-----------------------------------------------------------------------------
        // Meldungsfenster anzeigen
public:
        // zeigt eine MessageBox
        // der erste Parameter ist der Text, der zweite der Titel des Fensters, der dritte Parameter die Art der Meldung
        // die Parameter können entweder direkt als Zeichenkette (LPCSTR) oder 
        // als Ressourcen-ID auf einen StringTable-Eintrag angegeben werden. 
        //   Wird der Text-Eintrag nicht gefunden, eine Fehlermeldung ohne Text.***
        //   Fehlt der Titel, wird <_MSGTITLE> verwendet.***
        // ***In der DEBUG-Version wird zusätzlich eine TraceErr-Fehlermeldung ausgegeben!
        int MessageBox(LPCSTR,    LPCSTR= "", UINT= 0) const;
        int MessageBox(const int, LPCSTR= "", UINT= 0) const;
        int MessageBox(LPCSTR,    const int,  UINT= 0) const;
        int MessageBox(const int, const int,  UINT= 0) const;

        //-----------------------------------------------------------------------------
        // EREIGNISSE
protected:
        // wenn OnEvent in einer abgeleiteten Klasse überschrieben wird und die Botschaft
        // nicht verarbeitet werden konnte, sollte diese Methode aufgerufen werden, um die restlichen Windows-Botschaften zu verarbeiten
        // Rückgabewert bestimmt, ob Botschaft verarbeitet wurde
        virtual LRESULT OnEvent ( HWND, UINT, WPARAM, LPARAM )
        {
                return FALSE;
        };

        //-----------------------------------------------------------------------------
        // Liste der registrierten Fenster; Zuordnung HWND <--> Fensterobjekt
protected:
        // registriert dieses Objekt, indem es in eine Liste eingetragen wird
        void RegisterWindow ( HWND ); // muss nicht durch das Objekt selbst aufgerufen werden, siehe s_WaitingWindow

        // löscht die Registrierung dieses Objekts; Botschaften werden dann nicht mehr an dieses Objekt weitergeleitet
        void UnregisterWindow ( void ); // sollte NUR aufgerufen werden wenn das Fenster nicht mehr angezeigt wird

        // ==> Fensterhandle in registriertes Objekt "umwandeln"
        static TBasicWindow *Handle2Object ( HWND );

        // STATIC
protected:
        // hier kommen die Botschaften ALLER Fenster an, die dann ans jeweilige Fensterobjekt weitergeleitet wird
        static LRESULT CALLBACK EventHandler ( HWND, UINT, WPARAM, LPARAM );
        //WIEVOR, zuletzlich gibt der letzte Parameter an, ob die Botschaft korrekt weitergeleitet werden konnte
        static LRESULT CALLBACK EventHandlerEx ( HWND, UINT, WPARAM, LPARAM, BOOL& );

        //-----------------------------------------------------------------------------
        // ATTRIBUTE
protected:
        HWND m_Window;  // Handle des registierten Fensters ODER 0
        HINSTANCE m_Instance;

        // STATIC
protected:
        // kurz bevor man ein Fenster zum ersten Mal angezeigt - z.B. mit Methode DialogBoxParam() - muss man s_WaitingWindow= this setzen
        // sobald die nächste Botschaft für ein nicht registriertes Fenster empfangen wird, wird das Fenster in s_WaitingWindow automatisch registriert und aus dem Wartezustand genommen, s_WaitingWindow= 0
        static TBasicWindow *s_WaitingWindow; // Verknüpfung zum angemeldeten Fenster

private:
        static TIndList s_WindowList; // Liste der geöffneten Fenster

        //-----------------------------------------------------------------------------
        // Tastenkombinationen
public:   // Diese Funktionen dürfen erst aufgerufen werden, wenn das Fenster bereits ein Handle besitzt !!!
        // siehe ::SetHotKey
        BOOL SetActivateHotKey ( const char, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE );

        //nur ab Win32 verfügbar, sonst leer implementiert
        // siehe THotKey
        // Wenn man <m_Cmd> JEDOCH auf einen von -1 verschiedenen Wert setzt, löst TBasicWindow ein Kommando mit <m_Cmd> aus (NUR wenn das Fenster aktiviert ist);
        // SONST wird eine WM_HOTKEY-Botschaft ausgelöst und man kann mit IsHotKey( lParam, const char, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE ) ermittelt werden, welche Tastenkombination eingetreten ist
        // ==> TRUE <--> Tastenkombination wurde registriert
        BOOL AddHotKey ( const char, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE );

        // liest die Tastenkombinationen aus der Accelerator-Ressource (die mit LoadAccelerators() geladen und im Parameter angegeben wird)
        // Wenn eine der geladenen Tastenkombinationen gedrückt wird, wird das (in den Ressourcen für diese Tastenkombination angegebene) Kommando ausgelöst; bei <m_Cmd> == -1 wird eine WM_HOTKEY-Botschaft
        // ausgelöst und man kann mit IsHotKey( lParam, const char, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE ) ermittelt werden, welche Tastenkombination eingetreten ist.
        // ==> Anzahl der geladenen Tastenkombinationen (d.h. nicht, dass die Tastenkombinationen registriert werden konnten)
        UINT LoadHotKeys ( HACCEL );

        // prüft, ob die angegebene Tastenkombinationen gedrückt wurde
        // ==> TRUE <--> der KeyCode in lParam entspricht der (in den rechtlichen Parametern übergebenen) Tastenkombination
        BOOL IsHotKey ( LPARAM, const char, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE, const BOOL= FALSE );

//hp std::vector müsste als __declspec(dllexport) definiert sein - nicht möglich, da vorkompilierte Bibliothek
#pragma warning( push )
#pragma warning( disable : 4251 )
        // Liste der Win32-Tastenkombinationen für dieses Fenster
        std::vector<THotKey*> m_HotKeys;
#pragma warning( pop )
};

//#############################################################################
// TBasicDialog
//#############################################################################

enum ECheckState { csUnknown= 0, csChecked, csUnchecked, csIndeterminate };

class _CURVECLASS TBasicDialog : public TBasicWindow
{
        //-----------------------------------------------------------------------------
        // Konstruktor-Destruktor
public:
        // der erste Parameter ist die Ressourcenbezeichnung zu anzuzeigenden Dialogfensters
        // der letzte Parameter gibt die Instanz an, aus welcher die Ressource zu laden ist
        TBasicDialog ( const char* , HINSTANCE );
        virtual ~TBasicDialog ( void );

        //-----------------------------------------------------------------------------
        // Accessormethode(n)
public:
        const char *GetResName ( void ) const
        {
                return m_ResName;
        };

        //-----------------------------------------------------------------------------
        // Verwaltung des Inhalts von Steuerelementen
public:
        // Signatur: CtrlGetText( in aResId, out aReturn, in aMaxChars )
        // liest den Inhalt eines Steuerelements mit RessourcenId <aResId> in <aReturn> (bei mehr als <aMaxChars> wird der Rest abgeschnitten)
        // ==> wieviele Zeichen wurden in <aReturn> gespeichert; 0 bei Fehlern
        UINT CtrlGetText ( const int, char*, const int ) const;

        // Signatur: CtrlSetText( in aResId, in aString )
        // trägt <aString> in das Steuerelement (mit RessourcenId <aResId>) ein
        // ==> TRUE <--> Wert erfolgreich eingetragen
        BOOL CtrlSetText ( const int, LPCSTR ) const;

        // Signatur: CtrlSetText( in aResId, in aStrTbleId )
        // sucht den StringTable-Eintrag <aStrTbleId> und trägt ihn in das Steuerelement (mit RessourcenId <aResId>) ein
        // ist der Eintrag nicht vorhanden, wird kein Text ("") eingetragen***
        // ***In der DEBUG-Version wird zusätzlich eine TraceErr-Fehlermeldung ausgegeben!
        // ==> TRUE <--> Eintrag gefunden und erfolgreich eingetragen
        BOOL CtrlSetText ( const int, const int ) const;

public:
        // Signatur: CtrlGetLong( in aResId, out aValid )
        // ==> der Long-Wert aus dem Steuerelement (mit RessourcenId <aResId>)
        // Hat der gelesene Wert Nachkommastellen, werden diese verworfen.(ABRUNDEN).
        // Gibt es kein solches Steuerelement oder steht dort kein Long-Wert, wird eine Fehlermeldung ausgegeben; im letzen Parameter wird FALSE zurückgeben - der Rückgabewert ist 0.
        // ACHTUNG: Im Gegensatz zur Konvertierung mittels atof(...) wird "1a234" nicht als
        //          Long-Wert akzeptiert! Dies ist demnach ein Fehlerfall.
        LONG CtrlGetLong ( const int, BOOL& ) const;

        // Signatur: CtrlGetLong( in aResId, in aMin, in aMax, out aValid )
        // ==> WIEVOR, der zurückzugebene Wert wird jedoch zusätzlich ins Intervall [<aMin>..<aMax>] eingepasst.
        LONG CtrlGetLong ( const int, const LONG, const LONG, BOOL& ) const;

        // Signatur: CtrlSetLong( in aResId, in aLong )
        // trägt <aLong> in das Steuerelement (mit RessourcenId <aResId>) ein
        // ==> TRUE <--> Wert erfolgreich eingetragen
        BOOL CtrlSetLong ( const int, const LONG ) const;

public:
        // Signatur: CtrlGetDouble( in aResId, in aDigits, in aDecimal, out aValid )
        // ==> der Double-Wert aus dem Steuerelement (mit RessourcenId <aResId>)
        // Hat der gelesene Wert mehr als <aDigits> Nachkommastellen, werden nachfolgendene verworfen.(ABRUNDEN); Kommazeichen ist <aDecimal>.
        // Gibt es kein solches Steuerelement oder steht dort kein Double-Wert, wird eine Fehlermeldung ausgegeben; im letzen Parameter wird FALSE zurückgeben - der Rückgabewert ist 0.0.
        // ACHTUNG: Im Gegensatz zur Konvertierung mittels atof(...) wird "1a234" nicht als
        //          Double-Wert akzeptiert! Dies ist demnach ein Fehlerfall.
        double CtrlGetDouble ( const int, const UINT, const char, BOOL& ) const;

        // Signatur: CtrlGetDouble( in aResId, in aMin, in aMax, in aDigits, in aDecimal, out aValid )
        // ==> WIEVOR, der zurückzugebene Wert wird jedoch zusätzlich ins Intervall [<aMin>..<aMax>] eingepasst.
        double CtrlGetDouble ( const int, const double, const double, const UINT, const char, BOOL& ) const;

        // Signatur: CtrlSetDouble( in aResId, in aDouble, in aDigits, in aDecimal )
        // trägt <aDouble> in das Steuerelement (mit RessourcenId <aResId>) ein
        // Nach der zu schreibende Wert mehr als <aDigits> Nachkommastellen, werden nachfolgende verworfen.(ABRUNDEN); Kommazeichen ist <aDecimal>.
        // ==> TRUE <--> Wert erfolgreich eingetragen
        BOOL CtrlSetDouble ( const int, const double, const UINT, const char ) const;

public:
        // Signatur: CtrlGetFloat( in aResId, in aDigits, in aDecimal, out aValid )
        // ==> der Float-Wert aus dem Steuerelement (mit RessourcenId <aResId>)
        // Hat der gelesene Wert mehr als <aDigits> Nachkommastellen, werden nachfolgendene verworfen.(ABRUNDEN); Kommazeichen ist <aDecimal>.
        // Gibt es kein solches Steuerelement oder steht dort kein Float-Wert, wird eine Fehlermeldung ausgegeben; im letzen Parameter wird FALSE zurückgeben - der Rückgabewert ist 0.0.
        // ACHTUNG: Im Gegensatz zur Konvertierung mittels atof(...) wird "1a234" nicht als
        //          Float-Wert akzeptiert! Dies ist demnach ein Fehlerfall.
        float CtrlGetFloat ( const int, const UINT, const char, BOOL& ) const;

        // Signatur: CtrlGetFloat( in aResId, in aMin, in aMax, in aDigits, in aDecimal, out aValid )
        // ==> WIEVOR, der zurückzugebene Wert wird jedoch zusätzlich ins Intervall [<aMin>..<aMax>] eingepasst.
        float CtrlGetFloat ( const int, const float, const float, const UINT, const char, BOOL& ) const;

        // Signatur: CtrlSetFloat( in aResId, in aFloat, in aDigits, in aDecimal )
        // trägt <aFloat> in das Steuerelement (mit RessourcenId <aResId>) ein
        // Nach der zu schreibende Wert mehr als <aDigits> Nachkommastellen, werden nachfolgende verworfen.(ABRUNDEN); Kommazeichen ist <aDecimal>.
        // ==> TRUE <--> Wert erfolgreich eingetragen
        BOOL CtrlSetFloat ( const int, const float, const UINT, const char ) const;

// Kombinationsfenster (ComboBox)
public:
        // Signatur: CtrlAddString( in aResId, in aString )
        // fügt <aString> als neues, letztes Element in das Kombinationsfenster (mit RessourcenId <aResId>) ein
        // ==> Index des eingefügten Eintrags oder CB_ERR (==-1) 
        int CtrlAddString( const int, LPCSTR ) const;
        
        // Signatur: CtrlAddString( in aResId, in aStrTbleId )
        // sucht den StringTable-Eintrag <aStrTbleId> und trägt ihn in das Steuerelement (mit RessourcenId <aResId>) ein
        // ist der Eintrag nicht vorhanden, wird nichts eingetragen***
        // ***In der DEBUG-Version wird zusätzlich eine TraceErr-Fehlermeldung ausgegeben!
        // ==> Index des eingefügten Eintrags oder CB_ERR (==-1) 
        int CtrlAddString( const int, const int ) const;

        // Signatur: CtrlDelString( in aResId, in aString )
        // versucht <aString> im Kombinationsfenster (mit RessourcenId <aResId>) zu löschen
        // ==> Anzahl der verbleibenden Einträge; ggf. CB_ERR (==-1) 
        int CtrlDelString( const int, LPCSTR ) const;

        // Signatur: CtrlDelString( in aResId, in aStrTbleId )
        // versucht den StringTable-Eintrag <aStrTbleId> im Kombinationsfenster (mit RessourcenId <aResId>) zu löschen
        // ist der Eintrag nicht vorhanden, wird nichts gelöscht***
        // ***In der DEBUG-Version wird zusätzlich eine TraceErr-Fehlermeldung ausgegeben!
        // ==> Anzahl der verbleibenden Einträge; ggf. CB_ERR (==-1) 
        int CtrlDelString( const int, const int ) const;

        // Signatur: CtrlGetCount( in aResId )
        // ==> Anzahl der Einträge im Kombinationsfenster (mit RessourcenId <aResId>); ggf. CB_ERR (==-1) 
        int CtrlGetCount( const int ) const;

        // Signatur: CtrlFindString( in aResId, in aText, in aStartIdx )
        // sucht <aText> im Kombinationsfenster (mit RessourcenId <aResId>)**** und gibt den Index des Eintrages zurück; ggf. CB_ERR (==-1)
        // ****Die Suche wird nach dem Index <aStartIdx> begonnen. Am Ende der Liste wird von vorn beginnen, bis als letztes <aStartIdx> erreicht wird. -1 durchsucht die gesamte Liste.
        // ==> Index des gefundenen Eintrags; ggf. CB_ERR (==-1) 
        int CtrlFindString( const int, LPCSTR, const int= -1 ) const;

        // Signatur: CtrlFindString( in aResId, in aStrTbleId, in aStartIdx )
        // sucht den StringTable-Eintrag <aStrTbleId> im Kombinationsfenster (mit RessourcenId <aResId>)**** und gibt den Index des Eintrages zurück; ggf. CB_ERR (==-1)
        // wird der Eintrag nicht in der StringTable gefunden, wird CB_ERR (==-1) zurückgegeben***
        // ***In der DEBUG-Version wird zusätzlich eine TraceErr-Fehlermeldung ausgegeben!
        // ****Die Suche wird nach dem Index <aStartIdx> begonnen. Am Ende der Liste wird von vorn beginnen, bis als letztes <aStartIdx> erreicht wird. -1 durchsucht die gesamte Liste.
        // ==> Index des gefundenen Eintrags; ggf. CB_ERR (==-1) 
        int CtrlFindString( const int, const int, const int= -1 ) const;

        // Signatur: CtrlGetSel( in aResId )
        // ==> Index des aktuell ausgewählten Eintrags des Kombinationsfensters (mit RessourcenId <aResId>); ggf. CB_ERR (==-1) 
        int CtrlGetSel( const int ) const;

        // Signatur: CtrlGetSelString( in aResId )
        // ermittelt die Größe, reserviert entsprechend dynamischen Speicher und gibt den aktuell ausgewählten Eintrags des Kombinationsfensters (mit RessourcenId <aResId>) zurück - der Aufrufer muss der Speicher freigeben!!!
        // wird der Eintrag nicht gefunden, wird "" zurückgegeben
        // ==> aktuell ausgewählter Eintrag
        char *CtrlGetSelString( const int ) const;

        // Signatur: CtrlSetSel( in aResId, in aIdx )
        // wählt den Eintrag an Index <aIdx> im Kombinationsfensters (mit RessourcenId <aResId>) aus
        // ==> Index des ausgewählten Eintrags; CB_ERR (==-1) wenn das Kombinationsfenster <aResId> nicht gefunden wurde
        int CtrlSetSel( const int, const int ) const;

        // Signatur: CtrlSetSelString( in aResId, in aString )
        // versucht <aString> im Kombinationsfenster (mit RessourcenId <aResId>)**** auszuwählen
        // ****Die Suche wird nach dem Index <aStartIdx> begonnen. Am Ende der Liste wird von vorn beginnen, bis als letztes <aStartIdx> erreicht wird. -1 durchsucht die gesamte Liste.
        // ==> Index des aktuell ausgewählten Eintrags; CB_ERR (==-1) wenn das Kombinationsfenster <aResId> nicht gefunden wurde
        int CtrlSetSelString( const int, LPCSTR, const int= -1 ) const;

        // Signatur: CtrlSelString( in aResId, in aStrTbleId )
        // sucht den StringTable-Eintrag <aStrTbleId>**** und versucht ihn im Kombinationsfenster (mit RessourcenId <aResId>) auszuwählen
        // ist der Eintrag nicht vorhanden, bleibt die aktuelle Auswahl erhalten***
        // ***In der DEBUG-Version wird zusätzlich eine TraceErr-Fehlermeldung ausgegeben!
        // ****Die Suche wird nach dem Index <aStartIdx> begonnen. Am Ende der Liste wird von vorn beginnen, bis als letztes <aStartIdx> erreicht wird. -1 durchsucht die gesamte Liste.
        // ==> Index des aktuell ausgewählten Eintrags; CB_ERR (==-1) wenn das Kombinationsfenster <aResId> nicht gefunden wurde
        int CtrlSetSelString( const int, const int, const int= -1 ) const;

// Allgemein
public:
        // Signatur: Ctrl( in aResId )
        // ==> Handle des Steuerelements (mit RessourcenId <aResId>); 0 im Fehlerfall
        HWND Ctrl ( const int ) const;

        // Signatur: CtrlHasFocus( in aResId )
        // ==> TRUE <--> das angegebene Steuerelement ist fokussiert
        BOOL CtrlHasFocus ( const int ) const;

        // Signatur: CtrlSetFocus( in aResId )
        // fokussiert das Steuerelement (mit RessourcenId <aResId>)
        // ==> TRUE <--> Steuerelement erfolgreich fokussiert
        BOOL CtrlSetFocus ( const int ) const;

        // Signatur: CtrlIsEnabled( in aResId )
        // ==> TRUE <--> das angegebene Steuerelemet ist freigegeben
        BOOL CtrlIsEnabled ( const int ) const;

        // Signatur: CtrlSetEnabled( in aResId, in aEnable )
        // gibt das Steuerelement (mit RessourcenId <aResId>) frei oder sperrt es (ausgrauen funktioniert unter VC)
        // ==> TRUE <--> Steuerelement war vor dieser Aktion gesperrt
        BOOL CtrlSetEnabled ( const int, const BOOL ) const;

// Kontrollkästchen (CheckBox), Optionsfeld (RadioButton)
public:
        // Signatur: CtrlIsChecked( in aResId )
        // ==> TRUE <--> das Steuerelement ist ausgewählt (BST_CHECKED)
        BOOL CtrlIsChecked ( const int ) const;

        // Signatur: CtrlSetChecked( in aResId, in aChecked )
        // wählt das Steuerelement (mit RessourceId <aResId>) aus (<aChecked>==TRUE) oder hebt die Auswahl auf (SONST)
        // ==>
        BOOL CtrlSetChecked ( const int, const BOOL ) const;

        // Signatur: CtrlGetState( in aResId )
        // ermittelt den Zustand des Steuerelements
        // ==> csChecked / BST_CHECKED             <--> Steuerelement ist ausgewählt
        //     csUnchecked / BST_UNCHECKED         <-->                   nicht ausgewählt
        //     csIndeterminate / BST_INDETERMINATE <-->                   weder ausgewählt noch nicht ausgewählt (grayed)
        //     csUnknown / 0                       <-->                   nicht vorhanden
        UINT CtrlGetState ( const int ) const;
        ECheckState CtrlGetCheckState ( const int ) const;

        // Signatur: CtrlSetState( in aResId, in aCheckState )
        // ändert den Zustand des Steuerelements (mit RessourcenId <aResId>); für mögliche Optionen siehe CtrGetState
        // ==> neuer Zustand des Steuerelements; siehe CtrlGetState
        UINT CtrlSetState ( const int, const UINT ) const;
        ECheckState CtrlSetCheckState ( const int, const ECheckState ) const;

        //-----------------------------------------------------------------------------
        // EREIGNISSE
protected:
        virtual LRESULT OnEvent ( HWND, UINT, WPARAM, LPARAM );

        // Standardereignisse
        virtual void Dlg_OnCommand ( HWND, int, HWND, UINT )
        {};

        virtual BOOL Dlg_OnInit ( HWND, HWND, LPARAM )
        {
                return TRUE;
        };

        virtual void Dlg_OnHScrollBar ( HWND, HWND, UINT, int )
        {};

        virtual void Dlg_OnVScrollBar ( HWND, HWND, UINT, int )
        {};

        virtual void Dlg_OnTimer ( HWND, UINT )
        {};

        // klier 24.08.02
        virtual BOOL Dlg_OnSysCommand ( HWND, int, LPARAM )
        {
                return FALSE;
        };

        // Mausereignisse (Klier)
        virtual void Dlg_OnLButtonUp ( HWND, int, int, UINT )
        {};

        virtual void Dlg_OnLButtonDown ( HWND, UINT, int, int, UINT )
        {};

        virtual void Dlg_OnRButtonDown ( HWND, UINT, int, int, UINT )
        {};

        virtual void Dlg_OnMouseMove ( HWND, int, int, UINT )
        {};

        //Datum: 27.07.2002 virtual void  Dlg_OnMouseActivate ( HWND, int, HWND, UINT ) {};
        virtual int Dlg_OnMouseActivate ( HWND, HWND, UINT, UINT )
        {
                return 1;
        };

        // Rest (Klier)

        //10.07.2003 klier
        // Auf Änderungen an TabCtrl und ListView kann reagiert werden!
        virtual void Dlg_OnNotify ( HWND, int, UINT, UINT )
        {};

        virtual void Dlg_OnDestroy ( HWND )
        {};

        virtual void Dlg_OnSetFocus ( HWND, HWND )
        {};

        //Datum: 27.07.2002 virtual void  Dlg_OnKillFocus ( HWND, HWND ) {};

        // Tastatur
        virtual BOOL Dlg_OnChar ( HWND, WPARAM, LPARAM );

        //Datum: 27.07.2002 virtual void  Paint           ( void ) {};

        //-----------------------------------------------------------------------------
        // EREIGNISSE zum Schließen des Fensters
protected:
        virtual BOOL CanClose ( void )
        {
                return TRUE;
        };

        virtual void Interrupt ( void )
        {};

        virtual void LeaveDialog ( void )
        {};

        //-----------------------------------------------------------------------------
        // ATTRIBUTE
private:
        char *m_ResName;  // Name der anzuzeigenden Ressource
};

//#############################################################################
// TModalDlg
//#############################################################################

class _CURVECLASS TModalDlg : public TBasicDialog
{
        //-----------------------------------------------------------------------------
        // Konstruktor-Destruktor
public:
        TModalDlg ( const char*, HINSTANCE hInstance);
        virtual ~TModalDlg ( void );

        //-----------------------------------------------------------------------------
        // Dialog anzeigen
public:
        int ExecuteDialog ( HWND );

        //-----------------------------------------------------------------------------
        // EREIGNISSE
protected:
        // wenn Dlg_OnCommand in einer abgeleitete Klasse überschrieben wird und die Botschaft
        // nicht verarbeitet werden konnte, sollte diese Methode aufgerufen werden; sonst kann der Dialog nicht beendet werden
        virtual void Dlg_OnCommand ( HWND, int, HWND, UINT );

        //-----------------------------------------------------------------------------
        // ATTRIBUTE
protected:
        FARPROC m_Handler;
};

//#############################################################################
// TModelessDlg
//#############################################################################

class _CURVECLASS TModelessDlg : public TBasicDialog
{
        //-----------------------------------------------------------------------------
        // Konstruktor-Destruktor
public:
        // Neben dem Namen der Ressource des anzuzeigenden Dialogfensters muss auch die Adresse auf die Variable übergeben werden, wo dieses Dialogfenster gespeichert ist.
        // Wenn das Fenster geschlossen wird, wird diese Variable 0 gesetzt. Sonst müsste das Hauptprogramm beim Beenden auch alle modeless Dialogobjekte freigeben.
        TModelessDlg ( const char*, TModelessDlg** , HINSTANCE);
        virtual ~TModelessDlg ( void );

        //-----------------------------------------------------------------------------
        // Dialog anzeigen
public:
        BOOL Initialize ( HINSTANCE, HWND );

        //-----------------------------------------------------------------------------
        // EREIGNISSE
protected:
        // wenn Dlg_OnCommand in einer abgeleitete Klasse überschrieben wird und die Botschaft
        // nicht verarbeitet werden konnte, sollte diese Methode aufgerufen werden, um das Beendigungsverhalten zu impl.
        virtual void Dlg_OnCommand ( HWND, int, HWND, UINT );

        //-----------------------------------------------------------------------------
        // ATTRIBUTE
protected:
        DLGPROC m_Handler;
        TModelessDlg **m_Reference;
};

//#############################################################################
// TBasicMDIWindow
//#############################################################################

class _CURVECLASS TBasicMDIWindow : public TBasicWindow
{
        //-----------------------------------------------------------------------------
        // Konstruktor-Destruktor
public:
        TBasicMDIWindow ( HINSTANCE );
        virtual ~TBasicMDIWindow ( void );

        //-----------------------------------------------------------------------------
        // Dialog anzeigen
public:
        // Fenster erzeugen und anzeigen
        LRESULT Show ( HWND, const int= -1, const int= -1, const int= -1, const int= -1 );

        //-----------------------------------------------------------------------------
        // Start-/ Beendigungsverhalten und Aussehen des Fensters
protected:
        // Fenster öffnen/ schließen erlaubt?
        virtual BOOL CanOpen ( void )
        {
                return TRUE;
        }
        virtual BOOL CanClose ( void )
        {
                return TRUE;
        }

        // Hintergrundfarbe für den Clientbereich
        virtual HBRUSH GetBkColor ( void ) const
        {
                return HBRUSH(COLOR_WINDOW + 1);
        }

        // Icon für die Titelleiste
        virtual HICON GetIcon ( void ) const
        {
                return 0;
        }

        // welchen Mauszeiger?
        virtual HCURSOR GetCursor( void ) const
        {
                return LoadCursor( NULL, IDC_ARROW );
        };

        // Kontextmenü
        virtual HMENU GetMenu ( HWND ) const
        {
                return 0;
        }

        virtual LPCSTR ClassName ( void )
        {
                return "GR+JF";
        };

        // m_Title anzeigen
        virtual BOOL SetTitle ( void );

        //-----------------------------------------------------------------------------
        // EREIGNISSE
protected:
        // wenn OnEvent in einer abgeleitete Klasse überschrieben wird und die Botschaft
        // nicht verarbeitet werden konnte, sollte diese Methode aufgerufen werden, um das Beendigungsverhalten zu impl.
        virtual LRESULT OnEvent ( HWND, UINT, WPARAM, LPARAM );

        // Tastatur
        virtual void OnHotKey ( LPARAM );
        virtual void OnKeyDown ( WPARAM, LPARAM ) {};
        virtual void OnKeyUp ( WPARAM, LPARAM ) {};

        // Maus
        virtual void OnLButtonDown ( WPARAM, LPARAM ) {}
        virtual void OnLButtonUp ( WPARAM, LPARAM )     {}
        virtual void OnRButtonDown ( WPARAM, LPARAM ) {}
        virtual void OnMouseMove ( WPARAM, LPARAM )     {}

        // Kommandos
        virtual LRESULT OnCommand( WPARAM, LPARAM )
        {
                return 0;
        }
        virtual void OnCreate( void ) {}
        virtual void OnNotCreated( void ) {}

        // Zeichnen
        virtual void OnPaint ( void ); // WM_PAINT
        virtual void DoPaint( HDC, PAINTSTRUCT* ) {} // auf HDC zeichnen

        // (Kontext-)Menü
        virtual void OnPopupMenuInit ( WPARAM, LPARAM ) {}
        virtual void OnMenuSelect ( WPARAM, LPARAM ) {}

        // Sonstiges
        virtual void OnFocus ( void ) {}
        virtual void OnSize ( WPARAM, LPARAM ) {}
        virtual void OnTimer ( WPARAM, LPARAM ) {}
        virtual void OnRenderFormat ( WPARAM, LPARAM ) {}
        virtual void OnRenderAllFormats ( WPARAM, LPARAM ) {}   

        //-----------------------------------------------------------------------------
        //ATTRIBUT(E)
protected:
        char m_Title[256]; // Beschriftung der Titelleiste

private:
        bool m_Showing;    // Show bereits aufgerufen

        //-----------------------------------------------------------------------------
        //STATIC
private:
        static LRESULT CALLBACK EventHandler ( HWND, UINT, WPARAM, LPARAM );
};

#endif //#ifndef __WINDOW_H

//#############################################################################
// LASTLINE
//#############################################################################

---