Turbo Toolbox/Turbo_Toolbox.iso/dtx9302/dynamix/dynamix.cpp

C/C++ Source or Header | 1992-12-12 | 8.3 KB | 303 lines

/* ************************************ **
 * Name: dynamix.cpp
 *       Beispiel für dynamische (zur
 *       laufzeit erzeugte) Dialogboxen.
 *       Zum compilieren des Beispieles:
 *       1. anlegen eines neuen Projektes
 *          mit c++ Lauzeitsupport und
 *          windows 3.1 exe template
 *       2. hinzufügen der folgenden files
 *          - dynamix.def
 *          - pre.cpp
 *          - dynamix.cpp
 *          - dynamix.rc
 *          Dabei sollte pre.cpp "to top
 *          of list" angegeben werden.
 *       3. ändern der compileroptionen
 *          auf "large model"; weiterhin
 *          "use precompiled headers"
 *          anwählen und als zu verwenden-
 *          des headerfile "afxcoll.h"
 *          angeben.
 * Update:  12-Dec-1992 tw
/* ************************************ */

#include <afxwin.h>    // mfc
#include <afxcoll.h>   // mfc collections

#include "dialog.h"    // dialog
#include "dynamix.h"   // klassen

// **************[ Anwendung ]************

// Die instanzierung dieser Klasse startet
// die gesamte Anwendung
theApp theApp;

// ///////////////////////////////////////
// Name:    theApp::InitInstance()
//       Initialisieren der Instance. dazu
//       wird einfach nur ein neues Window
//       ( in diesem Fall eine dialogbox)
//       erzeugt.
// Update:  12-Dec-1992    tw
// ///////////////////////////////////////
BOOL
theApp::InitInstance()
{
   // dialogbox allozieren
   m_pMainWnd = new MainWindow();

   // dlg. anzeigen
   m_pMainWnd->ShowWindow( m_nCmdShow );
   m_pMainWnd->UpdateWindow();

   return TRUE;
}

// ***************[ MainWindow ]**********

// ///////////////////////////////////////
// Message Map des Hauptwindows
// abgefangen werden nur 2 Messages,
// die WM_CLOSE meldung des Controlmenus
// sowie die Button Pressed meldung
// ///////////////////////////////////////

BEGIN_MESSAGE_MAP( MainWindow , CDialog )
 ON_WM_CLOSE()
 ON_BN_CLICKED(IDB_PRESSHERE,OnBtnClicked)
END_MESSAGE_MAP()

// ///////////////////////////////////////
// Name: OnBtnClicked
//       Die Funktion wird aufgerufen,
//       wenn der "Hier drücken" button
//       auf dem Dialog gedrückt wird.
// ///////////////////////////////////////
void
MainWindow::OnBtnClicked( void )
{
   // Instanzieren einer dynamischen
   // Dialogbox.
   XDynamicDialogBox dlg( this );

   // Initialparameter der Dialogbox
   // setzen.
   dlg.DefineBox(
      WS_CAPTION |   // captionbar
      WS_SYSMENU |    // systemmenu
      WS_VISIBLE |   // sichtbar !
      WS_POPUP,
      1,              // X position
      1,              // Y position
      200,            // Breite
      200,            // Höhe
      "",            // Menuname
      "",            // Klasse
      "Dynamix !"    // Caption
      );

   // Ein Button hinzufügen
   dlg.AddItem(     // Neues Kontrol
      5,            // x Position
      5,            // y Position
      60,           // Länge
      25,           // Breite
      IDOK,         // Control-ID
      WS_TABSTOP |  // hat TABstop
      BS_PUSHBUTTON,// Button style
      "Button",     // Klasse
      "OK",         // Caption-Text
      0,            // zusatzdata
      NULL          // zeiger auf data
      );

   // Weitere items ..
   dlg.AddItem( 5,35,60,25, 100,
      WS_TABSTOP | ES_AUTOHSCROLL,
      "Edit", "Initialtext", 0, NULL );

   // Bearbeitung der dynamischen Box
   // starten
   dlg.DoModal();
}

/* *******[ dynamische box ]**************

/* ************************************ **
 * XDynamicDialogBox::DefineBox
 *    Initialparameter der dynamischen Box
 *
 * Update: 23-Nov-1992 tw
** ************************************ */
void
XDynamicDialogBox::DefineBox(
   LONG Style,          // WindowStyle
   int x,               // X-Position
   int y,               // Y-Position
   int cx,              // Breite
   int cy,              // Höhe
   LPSTR szMenuName,    // Menuname
   LPSTR szClassName,   // Klassenname
   LPSTR szCaptionText  // Captiontext
   )
{
   LPDLGTEMPLATE     lpDlg;
   LPSTR          lpText;

   // Anzahl byte, die für Menuname,
   // Klassenname und Caption benötigt
   // werden ermitteln.

   int nMenuNameBytes=strlen(
                         szMenuName
                         )
                         + 1;
   int nClassNameBytes=strlen(
                         szClassName
                         )
                         + 1;
   int nCaptionTextBytes=strlen(
                           szCaptionText
                           )
                           + 1;

   // Anzahl Byte insgesamt ermitteln
   m_nBytes = sizeof(DLGTEMPLATE) +
                 nMenuNameBytes +
                 nClassNameBytes +
                 nCaptionTextBytes;

   // Anzahl Controlelemente auf 0
   m_nItems = 0;

   // Speicher fuer Dialogbox holen
   m_hMem = GlobalAlloc( GHND, m_nBytes);

   // Wenn nicht genug speicher da ist,
   // wird eine Exception geworfen. Auf
   // diese Weise kann die aufrufende
   // Funktion einen try-catch frame auf-
   // bauen, um dem user die Möglichkeit
   // zu geben, vielleicht eine andere
   // Anwendung zu terminieren.
   if (m_hMem == NULL)
   {
      AfxThrowMemoryException();
   }

   // Falls speicher da ist, locken
   lpDlg = (LPDLGTEMPLATE) GlobalLock(
                              m_hMem
                              );

   // Parameter der Dialogbox im template
   // ablegen
   lpDlg->Style = Style;   // Art
   lpDlg->nItems = 0;      // Anzahl items
   lpDlg->x = x;           // X-Position
   lpDlg->y = y;           // Y-Position
   lpDlg->width = cx;      // Breite
   lpDlg->height = cy;     // Höhe

   // Zeiger auf Speicherbereich für
   // den Menutext ermitteln und Text
   // hineinkopieren
   lpText = ((LPSTR) lpDlg) +
               sizeof( DLGTEMPLATE );
   memcpy( lpText,        // Ziel
           szMenuName,    // Text
           nMenuNameBytes // Anzahl byte
           );

   // Zeiger auf Speicher für KlassenNamen
   // und CaptionText genauso behandeln
   lpText += nMenuNameBytes;
   memcpy( lpText, szClassName,
           nClassNameBytes);

   lpText += nClassNameBytes;
   memcpy( lpText, szCaptionText,
           nCaptionTextBytes);

   // Speicher wieder unlocken
   GlobalUnlock( m_hMem );
}

/* ************************************ **
 * Name: XDynamicDialogBox::AddItem
 *       Kontrollelement auf der Dialog-
 *       box einfügen.
 * Update:  12-Dec-1992 tw
** ************************************ */
void
XDynamicDialogBox::AddItem(
   int x,           // X-Position
   int y,           // Y-Position
   int cx,          // Breite
   int cy,          // Höhe
   int nID,         // Kontrol-ID
   long Style,      // Item-Style
   LPSTR szClass,   // klasse
   LPSTR szText,    // Windowtext
   BYTE DataBytes,  // Additional bytes
   LPBYTE pData     // ptr. auf add. data
   )
{
   LPDLGTEMPLATE lpDlg;
   LPDLGITEMTEMPLATE lpItem;
   LPSTR lpText;

   int nOldBytes = m_nBytes;
   int nClassBytes = strlen(szClass) + 1;
   int nTextBytes = strlen(szText) + 1;

   // Neue benötigte Speichergröße
   // ermitteln, bisher allozierten Block
   // erweitern, und neuen Bereich locken

   m_nBytes += sizeof(DLGITEMTEMPLATE) +
                  nClassBytes +
                  nTextBytes +
                  sizeof(BYTE) +
                  DataBytes;
   m_hMem = GlobalReAlloc(m_hMem,
                          m_nBytes,
                          GHND);
   if (m_hMem == NULL)
   {
      AfxThrowMemoryException();
   }

   // Kontrollelementzähler erhöhen
   m_nItems++;
   lpDlg = (LPDLGTEMPLATE) GlobalLock(
                              m_hMem);

   // Parameter im Speicherblock
   // eintragen
   lpDlg->nItems = m_nItems;
   lpItem = (LPDLGITEMTEMPLATE) ((
               (LPSTR) lpDlg) +nOldBytes);
   lpItem->x = x;
   lpItem->y = y;
   lpItem->width = cx;
   lpItem->height = cy;
   lpItem->ID = nID;
   lpItem->Style = Style | WS_CHILD |
                           WS_VISIBLE;

   lpText = ((LPSTR) lpItem )+
               sizeof(DLGITEMTEMPLATE);
   memcpy(lpText, szClass, nClassBytes);
   lpText += nClassBytes;
   memcpy(lpText, szText, nTextBytes);
   lpText += nTextBytes;
   *lpText = DataBytes;
   lpText += sizeof(BYTE);
   memcpy(lpText, pData, DataBytes);

   GlobalUnlock(m_hMem);
}