Windows编程

开发平台：
Visual C++

DIALOGS.C：源码内容
							/*--------------------------------------------------------------------------
  Dialogs.c -- Cursors dialogs
  Description:
      This sample is spread across four files, each named for the role
      the contained functions play.  Each file header contains a brief
      description of its purpose and the routines it contains.
      DIALOGS.C contains those routines used to display and manage
      dialogs.  Those functions are:
         AddEditControls - Dynamically create edit controls for UPDATE
                        dialog
         AddDlgProc      - Manage add row dialog
         CenterDialog    - Center a dialog over its parent window
         DoDialog        - Display a dialog
         MyCreateDialog - Create a modeless dialog
         GetEditControls - Retrieve values from dynamically created
                        edit controls
         IsMsgWaiting    - Check for waiting messages
         AboutDlgProc    - Manage about box
         AbsDlgProc      - Manage absolute row number dialog
         DataDlgProc     - Manage large data display dialog
         FindDlgProc    - Manager dialog to get text string to find in result set
         RelDlgProc      - Manage relative row number dialog
         StmtDlgProc     - Manage SQL statement dialog
         UpdateDlgProc   - Manage update row dialog
         SqlTablesDlgProc- handle SQLTables-type request
         ClassOnCommand - handle a command message
  This code is furnished on an as-is basis as part of the ODBC SDK and is
  intended for example purposes only.
--------------------------------------------------------------------------*/
// Includes ----------------------------------------------------------------
#include "headers.h"
#include    "resource.h"
#include "crsrdemo.h"
const char szCREATE[] = "CREATE TABLE %s (id int NOT NULL, name char(31) NOT NULL, C3 int)";
const char szDROP[]   = "DROP TABLE %s";
const char szINSERT[] = "INSERT INTO %s VALUES (?, '-FakeTable-FakeTable-FakeTable-', NULL)";
const int   xFIRST = 10;
const int   cxSEP  = 6;
const int   cySEP  = 3;
const int   cxNAME = 35;
const int   cyNAME = 8;
const int   cxEDIT = 180;
const int   cyEDIT = 10;
const DWORD dwDLGSTYLE    = DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU;
const DWORD dwSTATICSTYLE = WS_CHILD | WS_VISIBLE | SS_RIGHT;
const DWORD dwEDITSTYLE   = WS_BORDER | WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_AUTOHSCROLL | ES_LEFT;
#define STMTError(x) ODBCError(SQL_NULL_HENV, SQL_NULL_HDBC, lpmtbl->hstmt, (x))
#define  USERDATA GWL_USERDATA
// Types -------------------------------------------------------------------
typedef struct tagMTBL {                  // Make table structure
   SQLHSTMT hstmt;                        //   HSTMT in use
   SDWORD   i;                            //   Rows inserted
} MTBL, FAR *LPMTBL;
// Prototypes --------------------------------------------------------------
void INTFUNC AddEditControls(HWND, LPCHILD);
void INTFUNC CenterDialog(HWND);
BOOL INTFUNC GetEditControls(HWND, LPCHILD);
BOOL INTFUNC IsMsgWaiting(HWND);
BOOL INTFUNC DlgProcFilter(HWND, UINT, WPARAM, LPARAM);
/* AddEditControls ---------------------------------------------------------
   Description: Add one edit control for each updateable bound column to
                the dialog box
                --------------------------------------------------------------------------*/
void INTFUNC AddEditControls(HWND hDlg, LPCHILD lpChild)
{
#define DLGX(x)   (((x) * LOWORD(dwBaseUnits)) / 4)
#define DLGY(y)   (((y) * HIWORD(dwBaseUnits)) / 8)
   HWND  hWnd;
   HFONT hfont;
   RECT  rc;
   LPCOL lpcol;
   char  sz[cbMAXSQL];
   char  szFmt[cbSTRLEN];
   DWORD dwBaseUnits;
   UINT  idName, idEdit;
   int      xName, yName;
   int      cxName, cyName;
   int      xEdit, yEdit;
   int      cxEdit, cyEdit;
   int      i;
   HDC   hdc;
   SIZE  size;
   // Determine basic characteristics and start position in dialog
   hfont = (HFONT)SendDlgItemMessage(hDlg, IDC_STATIC1,
                                     WM_GETFONT, 0, 0L);
   dwBaseUnits = GetDialogBaseUnits();
   cxName = DLGX(cxNAME);
   cyName = DLGY(cyNAME);
   cxEdit = DLGX(cxEDIT);
   cyEdit = DLGY(cyEDIT);
   LoadString(g_hinst, IDS_COLNAME, szFmt, sizeof(szFmt));
   // Calculate the size of the largest name label
   hdc = GetDC(NULL);
   if( hdc ) {
      for( i = 0, lpcol = lpChild->lpcol; i < lpChild->ccol; i++, lpcol++ )
         if( IsUpdateable(lpcol->fSqlType) ) {
            wsprintf(sz, szFmt, lpcol->szName);
            GetTextExtentPoint(hdc, sz, lstrlen(sz), &size);
            if( size.cx > cxName )
               cxName = size.cx;
         }
      ReleaseDC(NULL, hdc);
   }
   GetWindowRect(GetDlgItem(hDlg, IDOK), &rc);
   xName = DLGX(xFIRST);
   yName = (4 * DLGY(cySEP)) + (DLGY(cySEP) / 2) + (2 * (rc.bottom - rc.top));
   xEdit = xName + cxName + DLGX(cxSEP);
   idName = stc1;
   idEdit = edt1;
   // For each bound, updateable column, create and add an edit control
   for (i=0, lpcol=lpChild->lpcol; i < lpChild->ccol; i++, lpcol++) {
      if (IsUpdateable(lpcol->fSqlType)) {
         // Create control label
         wsprintf(sz, szFmt, lpcol->szName);
         hWnd = CreateWindow(szSTATICCLASS, sz, dwSTATICSTYLE,
                             xName, yName, cxName, cyName, hDlg,
                             (HMENU)idName, g_hinst, NULL);
         FORWARD_WM_SETFONT(hWnd, hfont, 0, SendMessage);
         // Create (and intialize) edit control
         yEdit = yName - ((cyEDIT - cyNAME) / 2);
         GetCurrentValue(sz, lpcol, lpChild);
         hWnd = CreateWindow(szEDITCLASS, sz, dwEDITSTYLE,
                             xEdit, yEdit, cxEdit, cyEdit, hDlg,
                             (HMENU)idEdit, g_hinst, NULL);
         FORWARD_WM_SETFONT(hWnd, hfont, 0, SendMessage);
         // Limit number of characters user can type to column display size
         Edit_LimitText(hWnd, lpcol->cbc-1);
         yName += cyEdit + DLGY(cySEP);
         idName++;
         idEdit++;
      }
   }
   // Grow dialog so that all controls are visible
   GetClientRect(hDlg, &rc);
   rc.top    = 0;
   rc.bottom = yName + DLGY(cySEP);
   rc.left   = 0;
   rc.right  = (2 * DLGX(xFIRST)) + DLGX(cxNAME) + DLGX(cxEDIT) + DLGX(cxSEP);
   AdjustWindowRect(&rc, dwDLGSTYLE, FALSE);
   MoveWindow(hDlg, 0, 0, rc.right - rc.left, rc.bottom - rc.top, TRUE);
   // Place OK and Cancel buttons appropriately
   GetClientRect(hDlg, &rc);
   {  RECT  rcButton;
      int      x, y;
      GetWindowRect(GetDlgItem(hDlg, IDOK), &rcButton);
      x = rc.right - DLGX(cxSEP) - (rcButton.right - rcButton.left);
      y = DLGY(cySEP);
      MoveWindow(GetDlgItem(hDlg, IDOK),
                 x, y,
                 rcButton.right - rcButton.left,
                 rcButton.bottom - rcButton.top,
                 TRUE);
      y += rcButton.bottom - rcButton.top + (DLGY(cySEP) / 2);
      GetWindowRect(GetDlgItem(hDlg, IDCANCEL), &rcButton);
      MoveWindow(GetDlgItem(hDlg, IDCANCEL),
                 x, y,
                 rcButton.right - rcButton.left,
                 rcButton.bottom - rcButton.top,
                 TRUE);
   }
   return;
}
/* CenterDialog ------------------------------------------------------------
   Description: Center dialog over its owning parent window
                If the entire dialog does not fit on the desktop,
                ensure upper left corner is always visible
                --------------------------------------------------------------------------*/
void INTFUNC CenterDialog(HWND hDlg)
{
   RECT  rcDlg, rcScr, rcParent;
   int      cx, cy;
   GetWindowRect(hDlg, &rcDlg);
   cx = rcDlg.right  - rcDlg.left;
   cy = rcDlg.bottom - rcDlg.top;
   GetWindowRect(GetParent(hDlg), &rcParent);
   rcDlg.top    = rcParent.top +
      (((rcParent.bottom - rcParent.top) - cy) >> 1);
   rcDlg.left   = rcParent.left +
      (((rcParent.right - rcParent.left) - cx) >> 1);
   rcDlg.bottom = rcDlg.top  + cy;
   rcDlg.right  = rcDlg.left + cx;
   GetWindowRect(GetDesktopWindow(), &rcScr);
   if (rcDlg.bottom > rcScr.bottom) {
      rcDlg.bottom = rcScr.bottom;
      rcDlg.top    = rcDlg.bottom - cy;
   }
   if (rcDlg.right  > rcScr.right) {
      rcDlg.right = rcScr.right;
      rcDlg.left  = rcDlg.right - cx;
   }
   if (rcDlg.left < 0) rcDlg.left = 0;
   if (rcDlg.top  < 0) rcDlg.top  = 0;
   MoveWindow(hDlg, rcDlg.left, rcDlg.top, cx, cy, FALSE);
   return;
}
/* DoDialog ----------------------------------------------------------------
   Description: Launch a dialog passing child window variables
   --------------------------------------------------------------------------*/
int INTFUNC DoDialog(HWND    hWndParent,
                     int     nDlgResNum,
                     DLGPROC lpDlgProc)
{
   HWND  hWnd;
   LPCHILD  lpChild;
   int      nRC;
   hWnd    = FORWARD_WM_MDIGETACTIVE(g_hwndClient, SendMessage);
   lpChild = (hWnd
              ? (LPCHILD)GetWindowLong(hWnd, 0)
              : NULL);
   nRC = DialogBoxParam(g_hinst,
                        MAKEINTRESOURCE(nDlgResNum),
                        hWndParent,
                        lpDlgProc,
                        (LONG)lpChild);
   return nRC;
}
/* MyCreateDialog ------------------------------------------------------------
   Description: Launch a  modeless dialog passing child window variables
--------------------------------------------------------------------------*/
HWND INTFUNC MyCreateDialog(HWND    hWndParent,
                            int     nDlgResNum,
                            DLGPROC lpDlgProc)
{
   HWND  hWnd, hWndRet;
   LPCHILD  lpChild;
   hWnd    = FORWARD_WM_MDIGETACTIVE(g_hwndClient, SendMessage);
   lpChild = (hWnd
              ? (LPCHILD)GetWindowLong(hWnd, 0)
              : NULL);
   hWndRet = CreateDialogParam(g_hinst,
                               MAKEINTRESOURCE(nDlgResNum),
                               hWndParent,
                               lpDlgProc,
                               (LPARAM)lpChild);
   return hWndRet;
}
/* GetEditControls ---------------------------------------------------------
   Description: Get values from edit controls and move to row-set buffers
   --------------------------------------------------------------------------*/
BOOL INTFUNC GetEditControls(HWND hDlg, LPCHILD lpChild)
{
   LPCOL lpcol;
   char  sz[cbMAXSQL];
   UINT  idEdit;
   BOOL  fChangeMade;
   int      i;
   fChangeMade = FALSE;
   idEdit      = edt1;
   // For each bound, updateable column, retrieve the value
   for (i=0, lpcol=lpChild->lpcol; i < lpChild->ccol; i++, lpcol++) {
      if (IsUpdateable(lpcol->fSqlType)) {
         // Get the control value
         SendDlgItemMessage(hDlg, idEdit, WM_GETTEXT,
                            (WPARAM)sizeof(sz), (LPARAM)((LPSTR)sz));
         // Move into row-set buffer
         if (SetCurrentValue(sz, lpcol, lpChild) && !fChangeMade)
            fChangeMade = TRUE;
         idEdit++;
      }
   }
   return fChangeMade;
}
/* IsMsgWaiting ------------------------------------------------------------
   Description: Return TRUE if the Cancel button has been pressed
   --------------------------------------------------------------------------*/
BOOL INTFUNC IsMsgWaiting(HWND hWnd)
{
   MSG   msg;
   UNREF_PARAM (hWnd);
   // Check all waiting messages
   while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
      // Process message
      TranslateMessage(&msg);
      DispatchMessage(&msg);
      // Return TRUE if the Cancel button was pressed
      if ((msg.message == WM_COMMAND
           && GET_WM_COMMAND_ID(msg.wParam, msg.lParam) == IDCANCEL)
          || msg.message == WMU_CANCEL)
         return TRUE;
   }
   return FALSE;
}
/* OptionsDlgProc ----------------------------------------------------------
   Description: handle options dialog
----------------------------------------------------------------------------*/
BOOL EXPFUNC OptionsDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
   switch (msg) {
     case WM_INITDIALOG:
      CenterDialog(hDlg);
      SetWindowLong(hDlg, USERDATA, (LONG)lParam);
      InitializeDialogControls(hDlg, (LPCHILD) lParam);
      return TRUE;
     case WM_COMMAND:
      (void) HANDLE_WM_COMMAND(hDlg,wParam,lParam,ClassOnCommand);
      break;
      // New option dialog selected
     case WMU_NEWOPTION:
      {
         LPCHILD  lpChild = (LPCHILD) GetWindowLong(hDlg, USERDATA);
         if (g_hwndChildDialog)
            DestroyWindow(g_hwndChildDialog);
         g_hwndChildDialog = MyCreateDialog(hDlg,
                                            (int) lParam,
                                            ChildOptDlgProc);
         SetFocus(GetDlgItem(hDlg, IDC_OPTIONLIST));
         break;
      }
      // Set title of option area
     case WMU_SETSUBTEXT:
      {
         char  szBuffer[1000];
         ListBox_GetText(GetDlgItem(hDlg, wParam),
                         ListBox_GetCurSel(GetDlgItem(hDlg,wParam)),
                         szBuffer);
         Static_SetText( GetDlgItem(hDlg, IDC_OPTIONAREA_TITLE),
                        szBuffer);
         break;
      }
   }
   return DlgProcFilter(hDlg, msg, wParam, lParam);
}
/* ChildOptDlgProc --------------------------------------------------------
   Description: handle generic dialog
----------------------------------------------------------------------------*/
BOOL EXPFUNC ChildOptDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
   switch (msg) {
     case WM_INITDIALOG:
      SetWindowLong(hDlg, USERDATA, (LONG)lParam);
      InitializeDialogControls(hDlg, (LPCHILD) lParam);
      // Align the window to a hidden static in the parent
      (void) AlignToControl(hDlg, GetParent(hDlg), IDC_OPTION_WINPOS);
      return TRUE;
     case WM_COMMAND:
      return (BOOL)HANDLE_WM_COMMAND(hDlg,wParam,lParam,ClassOnCommand);
   }
   return DlgProcFilter(hDlg, msg, wParam, lParam);
}
/* AboutDlgProc ------------------------------------------------------------
   Description: Display about box
   --------------------------------------------------------------------------*/
BOOL EXPFUNC AboutDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
   UNREF_PARAM (lParam);
   switch (msg) {
     case WM_INITDIALOG:
      CenterDialog(hDlg);
      return TRUE;
     case WM_COMMAND:
      if (GET_WM_COMMAND_ID(wParam, lParam) == IDOK
          || GET_WM_COMMAND_ID(wParam, lParam) == IDCANCEL) {
         EndDialog(hDlg, GET_WM_COMMAND_ID(wParam, lParam));
         return TRUE;
      }
      break;
   }
   return DlgProcFilter(hDlg, msg, wParam, lParam);
}
/* AbsDlgProc --------------------------------------------------------------
   Description: Get absolute row number to fetch
   --------------------------------------------------------------------------*/
BOOL EXPFUNC AbsDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
   LPCHILD  lpChild;
   char  sz[11];
   char  *EndPtr;
   SDWORD   arow;
   lpChild = (LPCHILD)GetWindowLong(hDlg, USERDATA);
   switch (msg) {
     case WM_INITDIALOG:
      CenterDialog(hDlg);
      lpChild = (LPCHILD)lParam;
      SetWindowLong(hDlg, USERDATA, (LONG)lpChild);
      wsprintf(sz, "%ld", lpChild->arow);
      SetWindowText(GetDlgItem(hDlg, IDC_EDIT1), sz);
      SendDlgItemMessage(hDlg, IDC_EDIT1,
                         EM_LIMITTEXT, sizeof(sz)-1, 0L);
      return TRUE;
     case WM_COMMAND:
      switch (GET_WM_COMMAND_ID(wParam, lParam)) {
        case IDOK:
         GetWindowText(GetDlgItem(hDlg, IDC_EDIT1), sz, sizeof(sz));
         arow = strtol((char*) sz, &EndPtr, 10);
         for (; *EndPtr &&
              ISWHITE(*EndPtr); EndPtr = AnsiNext(EndPtr));
         // the number inputed is within '0' to '9' or + or -
         if (*EndPtr != '') {
            MessageBox(hDlg,
                       "Invalid absolute row number",
                       NULL,
                       MB_ICONSTOP);
            return TRUE;
         }
         lpChild->arow = arow;
        case IDCANCEL:
         EndDialog(hDlg, GET_WM_COMMAND_ID(wParam, lParam));
         return TRUE;
      }
      break;
   }
   return DlgProcFilter(hDlg, msg, wParam, lParam);
}
/* DataDlgProc -------------------------------------------------------------
   Description: Display large data value (retrieved via SQLGetData)
   --------------------------------------------------------------------------*/
BOOL EXPFUNC DataDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
   switch (msg) {
     case WM_INITDIALOG: {
        LPBIGCOL  lpbc;
        char      sz[cbSTRLEN];
        char      szNum[cbSTRLEN];
        char      szFmt[cbSTRLEN];
        CenterDialog(hDlg);
        lpbc = (LPBIGCOL)lParam;
        if (lpbc->cb == SQL_NULL_DATA) {
           lstrcpy(lpbc->lpsz, g_szNull);
           lpbc->cb = 0;
           _ltoa(0, szNum, 10);
        }
        else if (lpbc->cb == SQL_NO_TOTAL)
           lstrcpy(szNum, g_szUnknown);
        else
           _ltoa(lpbc->cb, szNum, 10);
        LoadString(g_hinst, IDS_DATADLG, szFmt, sizeof(szFmt));
        wsprintf(sz, szFmt, lpbc->szName, szNum);
        SetWindowText(GetDlgItem(hDlg, IDC_TEXT1), sz);
        SetWindowText(GetDlgItem(hDlg, IDC_EDIT1), lpbc->lpsz);
        return TRUE;
     }
     case WM_COMMAND:
      switch (GET_WM_COMMAND_ID(wParam, lParam)) {
        case IDOK:
        case IDCANCEL:
         EndDialog(hDlg, GET_WM_COMMAND_ID(wParam, lParam));
         return TRUE;
      }
      break;
   }
   return DlgProcFilter(hDlg, msg, wParam, lParam);
}
/* RelDlgProc --------------------------------------------------------------
   Description: Get relative row offset to fetch
   --------------------------------------------------------------------------*/
BOOL EXPFUNC RelDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
   LPCHILD  lpChild;
   char  sz[7];
   lpChild = (LPCHILD)GetWindowLong(hDlg, USERDATA);
   switch (msg) {
     case WM_INITDIALOG:
      CenterDialog(hDlg);
      lpChild = (LPCHILD)lParam;
      SetWindowLong(hDlg, USERDATA, (LONG)lpChild);
      wsprintf(sz, "%ld", lpChild->rrow);
      SetWindowText(GetDlgItem(hDlg, IDC_EDIT1), sz);
      SendDlgItemMessage(hDlg, IDC_EDIT1,
                         EM_LIMITTEXT, sizeof(sz)-1, 0L);
      return TRUE;
     case WM_COMMAND:
      switch (GET_WM_COMMAND_ID(wParam, lParam)) {
        case IDOK: {
           SDWORD rrow;
           char   *EndPtr;
           GetWindowText(GetDlgItem(hDlg, IDC_EDIT1), sz, sizeof(sz));
           rrow = strtol((char*) sz, &EndPtr, 10);
           for (; *EndPtr &&
                ISWHITE(*EndPtr); EndPtr = AnsiNext(EndPtr));
           // the number inputed is within '0' to '9' or + or -
           if (*EndPtr != '' || rrow < -100000 || rrow > 100000) {
              MessageBox(hDlg,
                         "Step amount must be between -100,000 and 100,000",
                         NULL,
                         MB_ICONSTOP);
              return TRUE;
           }
           lpChild->rrow = rrow;
        }
        case IDCANCEL:
         EndDialog(hDlg, GET_WM_COMMAND_ID(wParam, lParam));
         return TRUE;
      }
      break;
   }
   return DlgProcFilter(hDlg, msg, wParam, lParam);
}
/* StmtDlgProc -------------------------------------------------------------
   Description: Get SQL statement to execute
   --------------------------------------------------------------------------*/
BOOL EXPFUNC StmtDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
   LPCHILD  lpChild;
   lpChild = (LPCHILD)GetWindowLong(hDlg, USERDATA);
   switch (msg) {
     case WM_INITDIALOG:
      CenterDialog(hDlg);
      lpChild = (LPCHILD)lParam;
      SetWindowLong(hDlg, USERDATA, (LONG)lpChild);
      SetWindowText(GetDlgItem(hDlg, IDC_EDIT1), lpChild->sql);
      SendDlgItemMessage(hDlg, IDC_EDIT1, EM_LIMITTEXT, cbMAXSQL-1, 0L);
      return TRUE;
     case WM_COMMAND:
      switch (GET_WM_COMMAND_ID(wParam, lParam)) {
        case IDOK:
         GetWindowText(GetDlgItem(hDlg, IDC_EDIT1),
                       lpChild->sql, cbMAXSQL);
         lpChild->dwOperation = OPER_SELECT;
        case IDCANCEL:
         EndDialog(hDlg, wParam);
         return TRUE;
      }
      break;
   }
   return DlgProcFilter(hDlg, msg, wParam, lParam);
}
/* UpdateDlgProc -----------------------------------------------------------
   Description: Get new values with which to update the current row
   --------------------------------------------------------------------------*/
BOOL EXPFUNC UpdateDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
   LPCHILD  lpChild;
   lpChild = (LPCHILD)GetWindowLong(hDlg, USERDATA);
   switch (msg) {
      // Build dialog dynamically, adding appropriate edit controls
     case WM_INITDIALOG:
      lpChild = (LPCHILD)lParam;
      SetWindowLong(hDlg, USERDATA, (LONG)lpChild);
      AddEditControls(hDlg, lpChild);
      SendDlgItemMessage(hDlg,edt1,EM_SETSEL,GET_EM_SETSEL_MPS(0, -1));
      CenterDialog(hDlg);
      SetFocus(GetDlgItem(hDlg, edt1));
      return FALSE;
      // Close dialog updating row-set buffer (if OK) with new values
     case WM_COMMAND:
      switch (GET_WM_COMMAND_ID(wParam, lParam)) {
        case IDOK:
         if (!GetEditControls(hDlg, lpChild))
            GET_WM_COMMAND_ID(wParam, lParam) = IDCANCEL;
        case IDCANCEL:
         EndDialog(hDlg, GET_WM_COMMAND_ID(wParam, lParam));
         return TRUE;
      }
      break;
   }
   return DlgProcFilter(hDlg, msg, wParam, lParam);
}
/* FindDlgProc -------------------------------------------------------------
   Description: Get text string to find in result set
   --------------------------------------------------------------------------*/
BOOL EXPFUNC FindDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
   LPCHILD  lpChild;
   lpChild = (LPCHILD)GetWindowLong(hDlg, USERDATA);
   switch (msg) {
     case WM_INITDIALOG:
      CenterDialog(hDlg);
      lpChild = (LPCHILD)lParam;
      SetWindowLong(hDlg, USERDATA, (LONG)lpChild);
      SetWindowText(GetDlgItem(hDlg, IDC_EDIT1), lpChild->sql);
      SendDlgItemMessage(hDlg, IDC_EDIT1, EM_LIMITTEXT, cbMAXSQL-1, 0L);
      return TRUE;
     case WM_COMMAND:
      switch (GET_WM_COMMAND_ID(wParam, lParam)) {
        case IDOK:
         GetWindowText(GetDlgItem(hDlg, IDC_EDIT1),
                       lpChild->sql, cbMAXSQL);
        case IDCANCEL:
         EndDialog(hDlg, wParam);
         return TRUE;
      }
      break;
   }
   return DlgProcFilter(hDlg, msg, wParam, lParam);
}
/*---------------------------------------------------------------------------
** SQLTablesDlgProc -- get information for SQLTables and similar functions
----------------------------------------------------------------------------*/
BOOL EXPFUNC SQLTablesDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
   LPCHILD  lpChild;
   lpChild = (LPCHILD)GetWindowLong(hDlg, USERDATA);
   switch (msg) {
     case WM_INITDIALOG:
      CenterDialog(hDlg);
      lpChild = (LPCHILD)lParam;
      SetWindowLong(hDlg, USERDATA, (LONG)lpChild);
      // Set the default button
      if (!(lpChild->dwGuiFlags & GUIF_TABLES_RADIO)) {
         lpChild->dwOperation = IDC_TABLE_RAD_TABLE;
         lpChild->dwRadioButton = IDC_TABLE_RAD_TABLE;
      }
      // Set the dialog up
      ControlValue(  lpChild,
                   hDlg,
                   GetDlgItem(hDlg,lpChild->dwRadioButton),
                   lpChild->dwRadioButton,
                   ACT_INIT);
      ControlValue(  lpChild,
                   hDlg,
                   GetDlgItem(hDlg,lpChild->dwRadioButton),
                   lpChild->dwRadioButton,
                   ACT_TRIGGER);
      ControlValue(  lpChild,
                   hDlg,
                   GetDlgItem(hDlg,IDC_TABLEINFO_QUALIFIER),
                   IDC_TABLEINFO_QUALIFIER,
                   ACT_INIT);
      ControlValue(  lpChild,
                   hDlg,
                   GetDlgItem(hDlg,IDC_TABLEINFO_NAME),
                   IDC_TABLEINFO_NAME,
                   ACT_INIT);
      ControlValue(  lpChild,
                   hDlg,
                   GetDlgItem(hDlg,IDC_TABLEINFO_OWNER),
                   IDC_TABLEINFO_OWNER,
                   ACT_INIT);
      ControlValue(  lpChild,
                   hDlg,
                   GetDlgItem(hDlg,IDC_TABLEINFO_TYPE),
                   IDC_TABLEINFO_TYPE,
                   ACT_INIT);
      ControlValue(  lpChild,
                   hDlg,
                   GetDlgItem(hDlg,IDC_TABLEINFO_COLNAME),
                   IDC_TABLEINFO_COLNAME,
                   ACT_INIT);
      return TRUE;
     case WM_COMMAND:
      return (BOOL)HANDLE_WM_COMMAND(hDlg, wParam, lParam, ClassOnCommand);
      break;
   }
   return DlgProcFilter(hDlg, msg, wParam, lParam);
}
/*---ClassCommand---------------------------------------------------------
   Filters commands for dialogs.   Forwards those messages that we think
   are interesting to a handler that processes the events.
---------------------------------------------------------------------------*/
VOID INTFUNC ClassOnCommand(HWND hWnd, int iId, HWND hWndCtl, UINT uNotify)
{
   LPCHILD  lpChild;
   lpChild = (LPCHILD)GetWindowLong(hWnd,USERDATA);
   if (!(lpChild))
      return;
   switch (uNotify) {
     case   BN_CLICKED:       // button control selected
     case   EN_UPDATE:        // edit box has been updated
     case   LBN_SELCHANGE:       // listbox has gotten a message
      ControlValue(lpChild, hWnd, hWndCtl, iId, ACT_TRIGGER);
      break;
   }
}
/*
 ** ControlValue -- Initialize a control's value from the child's state, or
 **               set the child's state from the control.   All control-
 **               specific logic should go here.
 **
 ** Parameters:
 **      lpChild  -- child state
 **      hDlg  --  id of the active dialog
 **      hCtl  --  control's window
 **      iId      --  control's id
 **      iAction  -- Action to take -- ACT_INIT or ACT_TRIGGER
 **
 ** No return value
 */
VOID INTFUNC ControlValue (LPCHILD     lpChild,
                           HWND     hDlg,
                           HWND     hCtl,
                           int         iId,
                           int         iAction)
{
   int      iLbSelection;
   DWORD dwListData;
   BOOL  fTemp;
   UCHAR szBuffer[MAXNAME];
   const DIALOG_PAIR dpOptList[] = {
      {"Binding",          IDD_BIND_OPTIONS},
      {"General options",     IDD_GENERAL_OPTIONS},
      {"Scrolling Options",   IDD_SCROLLING_OPTIONS},
      {"Concurrency Options", IDD_CONCURRENCY_OPTIONS}};
   switch (iId) {
     case   IDOK:                   // generic OK
     case   IDCANCEL:                  // generic CANCEL
      if (iAction == ACT_TRIGGER) {
         if (g_hwndChildDialog) {
            g_hwndChildDialog = NULL;
         }
         EndDialog(hDlg, iId);
      }
      break;
     case IDC_RADIO_BINDROW:
     case IDC_RADIO_BINDCOL:
      if (SetOrGetCheck(hCtl, iAction, (iId == lpChild->fBindByRow))) {
         lpChild->fBindByRow = iId;
      }
      break;
     case IDC_RADIO_READONLY:
      if (SetOrGetCheck(hCtl, iAction,
                        (lpChild->fConcurrency == SQL_CONCUR_READ_ONLY))) {
         lpChild->fConcurrency = SQL_CONCUR_READ_ONLY;
      }
      break;
     case IDC_RADIO_LOCKING:
      if (SetOrGetCheck(hCtl, iAction,
                        (lpChild->fConcurrency == SQL_CONCUR_LOCK))) {
         lpChild->fConcurrency = SQL_CONCUR_LOCK;
      }
      break;
     case IDC_RADIO_OPTIMISTIC:
      if (SetOrGetCheck(hCtl, iAction,
                        (lpChild->fConcurrency == SQL_CONCUR_ROWVER))) {
         lpChild->fConcurrency = SQL_CONCUR_ROWVER;
      }
      break;
     case IDC_RADIO_OPTIMVALUE:
      if (SetOrGetCheck(hCtl, iAction,
                        (lpChild->fConcurrency == SQL_CONCUR_VALUES))) {
         lpChild->fConcurrency = SQL_CONCUR_VALUES;
      }
      break;
     case IDC_RADIO_FORWARD:
      if (SetOrGetCheck(hCtl, iAction,
                        (lpChild->crowKeyset == SQL_CURSOR_FORWARD_ONLY))) {
         lpChild->crowKeyset = SQL_CURSOR_FORWARD_ONLY;
      }
      break;
     case IDC_RADIO_SNAPSHOT:
      if (SetOrGetCheck(hCtl, iAction,
                        (lpChild->crowKeyset == SQL_CURSOR_STATIC))) {
         lpChild->crowKeyset = SQL_CURSOR_STATIC;
      }
      break;
     case IDC_RADIO_KEYSET:
      if (SetOrGetCheck(hCtl, iAction,
                        (lpChild->crowKeyset == SQL_CURSOR_KEYSET_DRIVEN))) {
         lpChild->crowKeyset = SQL_CURSOR_KEYSET_DRIVEN;
      }
      break;
     case IDC_RADIO_DYNAMIC:
      if (SetOrGetCheck(hCtl, iAction,
                        (lpChild->crowKeyset == SQL_CURSOR_DYNAMIC))) {
         lpChild->crowKeyset = SQL_CURSOR_DYNAMIC;
      }
      break;
     case IDC_CHECK_BINDALL:
      fTemp = SetOrGetCheck(hCtl,iAction, (lpChild->fBindAll));
      lpChild->fBindAll = fTemp;
      Edit_Enable(GetDlgItem(hDlg,IDC_EDIT_BIND), !(fTemp));
      Static_Enable(GetDlgItem(hDlg, IDC_STATIC_NBIND), !(fTemp));
      break;
     case IDC_EDIT_BIND:
      if (lpChild->fBind)
         wsprintf((LPSTR)szBuffer,"%s", lpChild->szBind);
      else  wsprintf((LPSTR)szBuffer,"%u", lpChild->cBind);
      SetOrGetEditArray(hCtl, szBuffer, iAction);
      if (iAction == ACT_TRIGGER) {
         lpChild->fBind = TRUE;
         strncpy(lpChild->szBind, szBuffer, cbINTLEN);
         lpChild->szBind[cbINTLEN-1] = '';
      }
      break;
     case IDC_EDIT_ROWSETSIZE:
      if (lpChild->fRowset)
         wsprintf((LPSTR)szBuffer,"%s", lpChild->szRowset);
      else wsprintf((LPSTR)szBuffer,"%u", lpChild->crowRowset);
      SetOrGetEditArray(hCtl, szBuffer, iAction);
      if (iAction == ACT_TRIGGER) {
         lpChild->fRowset = TRUE;
         strncpy(lpChild->szRowset, szBuffer, cbINTLEN);
         lpChild->szRowset[cbINTLEN-1] = '';
      }
      break;
     case IDC_MAXCOL:
      if (lpChild->fMaxBind)
         wsprintf((LPSTR)szBuffer, "%s", lpChild->szMaxBind);
      else wsprintf((LPSTR)szBuffer, "%ld", lpChild->crowMaxBind);
      SetOrGetEditArray(hCtl, szBuffer, iAction);
      if (iAction == ACT_TRIGGER) {
         lpChild->fMaxBind = TRUE;
         strncpy(lpChild->szMaxBind, szBuffer, cbINTLEN);
         lpChild->szMaxBind[cbINTLEN-1] = '';
      }
      break;
     case IDC_TABLE_RAD_STATISTICS:       // TABLEINFO->STATSTICS
     case IDC_TABLE_RAD_COLUMN:           // TABLEINFO->COLUMNS
     case IDC_TABLE_RAD_PRIV:          // TABLEINFO->PRIVILEGES
     case IDC_TABLE_RAD_PROC:          // TABLEINFO->PROCEDURES
     case IDC_TABLE_RAD_TABLE:            // TABLEINFO->TABLES
      // Initialize the button, or set iAction to its value
      // Hide any fields not related to the button, show fields related
      if( SetOrGetCheck(hCtl, iAction,
                        (iId == (int)lpChild->dwRadioButton)) )
         lpChild->dwOperation = (UWORD) iId;
      if (iAction == ACT_TRIGGER) {
         lpChild->dwGuiFlags |= GUIF_TABLES_RADIO;
         lpChild->dwRadioButton = iId;
         (void) SetHiddenFields(hDlg, iId);
      }
      break;
     case IDC_CHECK_FETCH:
      if (SetOrGetCheck(hCtl, iAction, (int)IS_ALLWFETCH(lpChild)))
         lpChild->dwGuiFlags |= GUIF_ALWAYSFETCH;
      else
         lpChild->dwGuiFlags &= ~GUIF_ALWAYSFETCH;
      break;
     case IDC_CHECK_ASYNC:
      lpChild->fAsync = SetOrGetCheck(hCtl,iAction,lpChild->fAsync);
      break;
     case IDC_TABLEINFO_QUALIFIER:        // TABLEINFO->QUALIFIER
      SetOrGetEditArray(hCtl, lpChild->szQualifier, iAction);
      break;
     case IDC_TABLEINFO_NAME:          // TABLEINFO->NAME
      SetOrGetEditArray(hCtl, lpChild->szTable, iAction);
      break;
     case IDC_TABLEINFO_OWNER:            // TABLEINFO->OWNER
      SetOrGetEditArray(hCtl, lpChild->szUser, iAction);
      break;
     case IDC_TABLEINFO_TYPE:          // TABLEINFO->TYPE
      SetOrGetEditArray(hCtl, lpChild->szType, iAction);
      break;
     case IDC_TABLEINFO_COLNAME:          // TABLEINFO->COLUMN NAME
      SetOrGetEditArray(hCtl, lpChild->szColName, iAction);
      break;
     case IDC_OPTIONLIST:              // OPTIONS->options
      {
         if (iAction == ACT_INIT) {
            InitializeListBox(hDlg,
                              IDC_OPTIONLIST,
                              &dpOptList[0],
                              sizeof(dpOptList) / sizeof(DIALOG_PAIR),
                              IDD_GENERAL_OPTIONS);
         }
         // Get the title and data for the currently-selected list box
         iLbSelection = ListBox_GetCurSel(hCtl);
         dwListData   = ListBox_GetItemData(hCtl, iLbSelection);
         SendMessage(hDlg,WMU_NEWOPTION, iLbSelection,(LPARAM)dwListData);
         SendMessage(hDlg,WMU_SETSUBTEXT,iId, 0);
         break;
      }
   }
}
/*
** SetOrGetCheck      -- set a value based upon a button action, or set a
**                 check button if the action is equal to a value
**                 Also used for radios
**
** Parameters:
**    hCtl     -- control handle
**    iAction     -- ACT_INIT or ACT_TRIGGER
**    bEqual      -- Initialization -- should value be set?
**
** Returns:
**    TRUE if checkbox is now set
*/
INLINE BOOL SetOrGetCheck(
                          HWND   hCtl,
                          int    iAction,
                          BOOL   bEqual)
{
   if (iAction == ACT_INIT) {
      Button_SetCheck(hCtl, bEqual);
      return bEqual;
   }
   if (iAction == ACT_TRIGGER) {
      Button_SetCheck(hCtl, Button_GetCheck(hCtl));
      return Button_GetCheck(hCtl);
   }
   return FALSE;
}
/*
** SetOrGetEditArray -- set the value of an array from an edit control, or
**                set the edit control from the array  (inline)
**
** Parameters:
**    hCtl  -- control
**    lpStr -- string
**    iAction  -- ACT_INIT or ACT_TRIGGER
**
** Notes:   Assumes lpStr is MAXNAME bytes long
*/
INLINE VOID SetOrGetEditArray(
                              HWND  hCtl,
                              UCHAR FAR *lpStr,
                              int      iAction)
{
   if (iAction == ACT_INIT)
      Edit_SetText(hCtl, (LPSTR)lpStr);
   else
      if (iAction == ACT_TRIGGER)
         Edit_GetText(hCtl, (LPSTR)lpStr, MAXNAME - 1);
}
/*
** SetHiddenFields -- show or hide hidden fields in a dialog box, depending
**               upon the action taken.
**
** Parameters:
**    hDlg  -- dialog we are dealing with
**    iAct  -- action
**
*/
BOOL    INTFUNC SetHiddenFields(
                                HWND   hWnd,
                                int    iAct)
{
   HWND  hTTag, hCol;
   HWND  hType, hCTag;
   // Get handles for all of the windows we want to deal with
   hTTag = GetDlgItem(hWnd, IDC_TYPETAG);
   hCol  = GetDlgItem(hWnd, IDC_COLTAG);
   hType = GetDlgItem(hWnd, IDC_TABLEINFO_TYPE);
   hCTag = GetDlgItem(hWnd, IDC_TABLEINFO_COLNAME);
   if (hType) {
      Edit_Enable(hType, (iAct == IDC_TABLE_RAD_TABLE)  ? 1 : 0);
      ShowWindow(hType,  (iAct == IDC_TABLE_RAD_TABLE)  ? SW_SHOW : SW_HIDE);
      ShowWindow(hTTag,  (iAct == IDC_TABLE_RAD_TABLE)  ? SW_SHOW : SW_HIDE);
      Edit_Enable(hCTag, (iAct == IDC_TABLE_RAD_COLUMN) ? 1 : 0);
      ShowWindow(hCol,   (iAct == IDC_TABLE_RAD_COLUMN) ? SW_SHOW : SW_HIDE);
      ShowWindow(hCTag,  (iAct == IDC_TABLE_RAD_COLUMN) ? SW_SHOW : SW_HIDE);
      return TRUE;
   }
   return FALSE;
}
/*
 **   InitializeListBox -- initialize a listbox from a DIALOG_PAIR
 **                     structure.
 **
 **  Parameters:
 **      hWnd     --  window the list box lives in
 **      lbId     --  resource id of the list box
 **      dpOptList   --  pointer to option list structure
 **      iEntries --  number of entries in the list box
 **      iDefId      --  default to select
 **
 **
 **  Returns:  FALSE
 **
 */
BOOL INTFUNC InitializeListBox(
   HWND                    hWnd,
   int                     lbId,
   const DIALOG_PAIR FAR   *dpOptList  ,
   int                     iEntries,
   int                     iDefId)
{
   int            iDlg, iIndex;
   HWND        hOptionBox;
   LPSTR       szDefaultTitle;
   hOptionBox  =  GetDlgItem(hWnd, lbId);
   for (iDlg = 0; iDlg < iEntries; iDlg++) {
      iIndex = ListBox_AddString(hOptionBox,
                                 dpOptList[iDlg].szDlgPairTitle);
      ListBox_SetItemData(hOptionBox,
                          iIndex,
                          dpOptList[iDlg].iDlgPairDlgId);
      if (iDefId == dpOptList[iDlg].iDlgPairDlgId) {
         szDefaultTitle = dpOptList[iDlg].szDlgPairTitle;
      }
   }
   ListBox_SetCurSel(hOptionBox,
                     ListBox_FindStringExact(hOptionBox, 0, szDefaultTitle));
   return FALSE;
}
/*
** InitializeDialogControls   -- Initialize all of the controls in a dialog
**                      from the lpchild structure.   Callback function.
**
** Parameters:
**    hDlg     -- dialog handle
**    lpChild     -- state structure
**
*/
VOID INTFUNC InitializeDialogControls(
                                      HWND   hDlg,
                                      LPCHILD   lpChild)
{
   FARPROC     ControlInstance = MakeProcInstance((FARPROC)InitControlCallback,
                                                  g_hinst);
   EnumChildWindows(hDlg, (WNDENUMPROC)ControlInstance, (LPARAM)lpChild);
   FreeProcInstance(ControlInstance);
}
/*
** InitControlCallback  -- callback function for initializing controls
**
** Parameters:
**    hwndChild   -- child window handle
**    lParam      -- lparam (lpChild from EnumChildProc
*/
BOOL CALLBACK InitControlCallback(
                                  HWND hwndChild,
                                  LPARAM  lParam)
{
   int      iControl= GetDlgCtrlID(hwndChild);
   if (iControl) {
      ControlValue((LPCHILD) lParam,
                   GetParent(hwndChild),
                   hwndChild,
                   iControl,
                   ACT_INIT);
   }
   return TRUE;
}
BOOL INTFUNC DlgProcFilter(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
   switch (msg) {
     case WM_SETTEXT:
     case WM_NCPAINT:
     case WM_NCACTIVATE:
      SetWindowLong(hDlg, DWL_MSGRESULT,0L);
      return TRUE;
   }
   return FALSE;
}
/*
** AlignToControl -- align a window to a control in a dialog
**
** Parameters:
**    hWnd  -- window to align
**    hParent -- parent dialog
**    iCtlId   -- control Id
**
** Returns: BOOL that moveWindow returns
*/
BOOL INTFUNC AlignToControl(
                            HWND hWnd,
                            HWND hParent,
                            int     iCtlId)
{
   HWND  hwndDrawArea;
   RECT  rcDrawArea, rcChildWnd;
   POINT ptPoint;
   hwndDrawArea = GetDlgItem(hParent, iCtlId);
   GetWindowRect(hwndDrawArea, &rcDrawArea);
   GetWindowRect(hWnd, &rcChildWnd);
   ptPoint.x = rcDrawArea.left;
   ptPoint.y = rcDrawArea.top;
   ScreenToClient(hWnd, &ptPoint);
   return (MoveWindow(  hWnd,
                      ptPoint.x,
                      ptPoint.y,
                      rcChildWnd.right- rcChildWnd.left,
                      rcChildWnd.bottom - rcChildWnd.top,
                      FALSE));
}

						