home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Internet Business Development Kit / PRODUCT_CD.iso / sqlsvr / odbcsdk / samples / admndemo / dialogs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-07  |  17.6 KB  |  536 lines
  1. //*---------------------------------------------------------------------------------
  2. //|  ODBC System Administrator
  3. //|
  4. //|  This code is furnished on an as-is basis as part of the ODBC SDK and is
  5. //|  intended for example purposes only.
  6. //|
  7. //|    Title:    DIALOGS.C
  8. //|        This module contains the dialog procs which are used to display
  9. //|            catalog function arguements and display the results.  Note that
  10. //|            the best way to determine the size of the arguements would be
  11. //|            to use SQLGetInfo, however, due to ease of coding, the values
  12. //|            have been hard-coded to constants.
  13. //*---------------------------------------------------------------------------------
  14. #include <windows.h>
  15. #include "admndemo.h"
  16. #include "dialogs.h"
  17. #include "sql.h"
  18. #include "sqlext.h"
  19. #include "execute.h"
  20. #include "info.h"
  21. #include "results.h"
  22. #include "strings.h"
  23.  
  24. VSZFile;
  25. #define CHKNULL(str)  (*str ? str : NULL)
  26.  
  27.  
  28. //*---------------------------------------------------------------------------------
  29. //|    Local function prototypes
  30. //*---------------------------------------------------------------------------------
  31. BOOL ShowCatalogResults(CHILDINFO FAR * ci, LPSTR szTitle);
  32. BOOL EXTFUN CatalogWndProc(HWND hDlg, unsigned msg, WORD wParam, LONG lParam);
  33.  
  34.  
  35. //*---------------------------------------------------------------------------------
  36. //|    Global variables
  37. //*---------------------------------------------------------------------------------
  38. extern char OutStr[MAXBUFF];
  39.  
  40.  
  41. //
  42. // The following set of defines and host vars are used to create a common
  43. //    dialog handler for each of the catalog function dialogs.  This makes 
  44. // the code size smaller while still handling each catalog functions
  45. //    parameters.  It also allows for sharing of values from one function
  46. //    to another.
  47. //
  48. #define CAT_LAST             256
  49. #define CAT_QUALIFIER        1
  50. #define CAT_TABLE                2
  51. #define CAT_OWNER                4
  52. #define CAT_TYPE                8
  53. #define CAT_COLUMN          16
  54. #define CAT_QUALIFIER2      32
  55. #define CAT_OWNER2          64
  56. #define CAT_TABLE2         128
  57. #define CAT_PROCS             256        
  58. char szQualifierVal[MAX_QUALIFIER];
  59. char szTableVal[MAX_NAME];
  60. char szOwnerVal[MAX_OWNER];
  61. char szTypeVal[MAX_NAME];
  62. char szColumnVal[MAX_NAME];
  63. char szQualifierVal2[MAX_QUALIFIER];
  64. char szOwnerVal2[MAX_OWNER];
  65. char szTableVal2[MAX_NAME];
  66. char szProcsVal[MAX_NAME];
  67.  
  68. struct {
  69.     int            mMask;                                // Bit mask value
  70.     int            id;                                    // Edit control id
  71.     LPSTR            szStr;                                // Buffer location
  72.     int            cbMax;                                // Maximum size
  73.     } CatalogVals[] = {
  74. // mMask                        id                                szStr                            cbMax
  75. // -------------------    ---------------------    -----------------------    ------------------------
  76.     CAT_QUALIFIER,            IDE_QUALIFIER,                (LPSTR)szQualifierVal,    MAX_QUALIFIER,
  77.     CAT_TABLE,                IDE_TABLE,                    (LPSTR)szTableVal,        MAX_NAME,
  78.     CAT_OWNER,                IDE_OWNER,                    (LPSTR)szOwnerVal,        MAX_OWNER,
  79.     CAT_TYPE,                IDE_TYPE,                    (LPSTR)szTypeVal,            MAX_NAME,
  80.     CAT_COLUMN,                IDE_COLUMN,                    (LPSTR)szColumnVal,        MAX_NAME,
  81.     CAT_QUALIFIER2,        IDE_QUALIFIER2,            (LPSTR)szQualifierVal2,    MAX_QUALIFIER,
  82.     CAT_OWNER2,                IDE_OWNER2,                    (LPSTR)szOwnerVal2,        MAX_OWNER,
  83.     CAT_TABLE2,                IDE_TABLE2,                    (LPSTR)szTableVal2,        MAX_NAME,
  84.     CAT_PROCS,                IDE_PROCEDURE,                (LPSTR)szProcsVal,        MAX_NAME,
  85.     };
  86.  
  87. dCSEG(char) szTablesTitle[]                    =    "Tables";
  88. dCSEG(char) szColumnsTitle[]                    =    "Columns";
  89. dCSEG(char)    szStatistics[]                        =    "Statistics";
  90. dCSEG(char)    szPrimaryKeys[]                    =    "Primary Keys";
  91. dCSEG(char)    szForeignKeys[]                    =    "Foreign Keys";
  92. dCSEG(char)    szTablePrivs[]                        =    "Table Privileges";
  93. dCSEG(char) szColumnPrivs[]                    =    "Column Privileges";
  94. dCSEG(char) szSpecialCols[]                    =    "Special Columns";
  95. dCSEG(char) szProcsTitle[]                        =    "Procedures";
  96. dCSEG(char) szProcCols[]                        =    "Procedure Columns";
  97. dCSEG(char)    szCOLON[]                            =    ":";
  98.  
  99.  
  100. struct {
  101.     int                    idMenu;                            // Menu identifier
  102.     int                    iDialogName;                    // ID of dialog
  103. //    DLGWNDPROC             dlgProc;                            // Dialog procedure
  104.     LPSTR                    szDlgTitle;                        // Title of the dialog
  105.     UINT                    mask;                                // Mask for this dialog
  106.     } Dialogs[] = {
  107. // idMenu                        iDialogName                        szDlgTitle                    mask
  108. //    ---------------------    ------------------            -----------------------    -------------------------------------------------
  109.     IDM_TABLES,                    IDD_SQLTABLES,                    (LPSTR)szTablesTitle,    CAT_QUALIFIER | CAT_OWNER | CAT_TABLE | CAT_TYPE,
  110.     IDM_COLUMNS,                IDD_SQLCOLUMNS,                (LPSTR)szColumnsTitle,    CAT_QUALIFIER | CAT_OWNER | CAT_TABLE | CAT_COLUMN,
  111.     IDM_STATISTICS,            IDD_SQLSTATISTICS,            (LPSTR)szStatistics,      CAT_QUALIFIER | CAT_OWNER | CAT_TABLE,
  112.     IDM_PRIMARY_KEYS,            IDD_SQLPRIMARYKEYS,            (LPSTR)szPrimaryKeys,    CAT_QUALIFIER | CAT_OWNER | CAT_TABLE,
  113.     IDM_FOREIGN_KEYS,            IDD_SQLFOREIGNKEYS,            (LPSTR)szForeignKeys,    CAT_QUALIFIER | CAT_OWNER | CAT_TABLE | CAT_QUALIFIER2 | CAT_OWNER2 | CAT_TABLE2,
  114.     IDM_TABLE_PRIVS,            IDD_SQLTABLEPRIVILEGES,        (LPSTR)szTablePrivs,        CAT_QUALIFIER | CAT_OWNER | CAT_TABLE,
  115.     IDM_COLUMN_PRIVS,            IDD_SQLCOLUMNPRIVILEGES,    (LPSTR)szColumnPrivs,    CAT_QUALIFIER | CAT_OWNER | CAT_TABLE | CAT_COLUMN,
  116.     IDM_SPECIAL_COLUMNS,        IDD_SQLSPECIALCOLUMNS,        (LPSTR)szSpecialCols,    CAT_QUALIFIER | CAT_OWNER | CAT_TABLE,
  117.     IDM_PROCEDURES,            IDD_SQLPROCEDURES,            (LPSTR)szProcsTitle,        CAT_QUALIFIER | CAT_OWNER | CAT_PROCS,
  118.     IDM_PROC_COLUMNS,            IDD_SQLPROCEDURECOLUMNS,    (LPSTR)szProcCols,        CAT_QUALIFIER | CAT_OWNER | CAT_PROCS | CAT_COLUMN,
  119.     };
  120.  
  121. //
  122. // This structure is used to control the catalog fucntions
  123. //
  124. typedef struct tagCATALOGINFO {
  125.     HINSTANCE            hInst;                    // Instance handle for this app
  126.     CHILDINFO FAR *    ci;                        // Child info
  127.     int                    id;                        // Dialog id to indicate function
  128.     LPSTR                    szDlgTitle;                // Title for the dialog
  129.     UINT                    mask;                        // Dialog control mask
  130. // For SQLStatistics
  131.     UWORD                    fUnique;
  132.     UWORD                    fAccuracy;
  133. // For SQLSpecialColumns
  134.     UWORD                    fColType;
  135.     UWORD                    fScope;
  136.     UWORD                    fNullable;
  137.     } CATALOGINFO;
  138.  
  139. //
  140. // A prototype for radio button controls
  141. //
  142. typedef struct tagIDXINFO {
  143.     int                    idxVal;
  144.     int                    fType;
  145.     } IDXINFO;
  146.     
  147. //
  148. //    For SQLStatistics, fUnqiue parameter    
  149. //
  150. struct {
  151.     int                    idxVal;                            // Dialog item number
  152.     int                    fType;                            // SQL constant equivalent
  153.     } StatsfUnique[] = {
  154. //    idxVal                                fType
  155. //    --------------------------        ---------------------------------
  156.     IDX_INDEX_UNIQUE,                    SQL_INDEX_UNIQUE,
  157.     IDX_INDEX_ALL,                        SQL_INDEX_ALL,
  158.     };
  159.  
  160. //
  161. //    For SQLStatistics, fAccuracy parameter    
  162. //
  163. struct {
  164.     int                    idxVal;                            // Dialog item number
  165.     int                    fType;                            // SQL constant equivalent
  166.     } StatsfAccuracy[] = {
  167. //    idxVal                                fType
  168. //    --------------------------        ---------------------------------
  169.     IDX_ENSURE,                            SQL_ENSURE,
  170.     IDX_QUICK,                            SQL_QUICK,
  171.     };
  172.  
  173. //
  174. //    For SQLSpecialColumns, fColType parameter    
  175. //
  176. struct {
  177.     int                    idxVal;                            // Dialog item number
  178.     int                    fType;                            // SQL constant equivalent
  179.     } SpecColsfColType[] = {
  180. //    idxVal                                fType
  181. //    --------------------------        ---------------------------------
  182.     IDX_BEST_ROWID,                    SQL_BEST_ROWID,
  183.     IDX_ROWVER,                            SQL_ROWVER,
  184.     };
  185.  
  186. //
  187. //    For SQLSpecialColumns, fNullable parameter    
  188. //
  189. struct {
  190.     int                    idxVal;                            // Dialog item number
  191.     int                    fType;                            // SQL constant equivalent
  192.     } SpecColsfNullable[] = {
  193. //    idxVal                                fType
  194. //    --------------------------        ---------------------------------
  195.     IDX_NO_NULLS,                        SQL_NO_NULLS,
  196.     IDX_NULLABLE,                        SQL_NULLABLE,
  197.     };
  198.  
  199. //
  200. //    For SQLSpecialColumns, fScope parameter    
  201. //
  202. struct {
  203.     int                    idxVal;                            // Dialog item number
  204.     int                    fType;                            // SQL constant equivalent
  205.     } SpecColsfScope[] = {
  206. //    idxVal                                fType
  207. //    --------------------------        ---------------------------------
  208.     IDX_SCOPE_CURROW,                    SQL_SCOPE_CURROW,
  209.     IDX_SCOPE_TRANSACTION,            SQL_SCOPE_TRANSACTION,
  210.     IDX_SCOPE_SESSION,                SQL_SCOPE_SESSION,
  211.     };
  212.  
  213.  
  214.  
  215.  
  216. //*---------------------------------------------------------------------------------
  217. //| GetRadioValue:
  218. //|    This function will examine a group of radio buttons based on the control
  219. //|    structure and see which is checked.  When found, that value is returned.
  220. //| Parms:
  221. //|    hDlg                Window handle of dialog with control
  222. //|    stct                Radio control structure
  223. //|    cbNum                How many items in control structure
  224. //| Returns:              
  225. //|    The value for the item checked
  226. //*---------------------------------------------------------------------------------
  227. int GetRadioValue(HWND hDlg, IDXINFO FAR * stct, int cbNum)
  228. { 
  229.     int     dex;                                                               
  230.     for(dex=0;  dex<cbNum;  dex++)                                  
  231.         if(IsDlgButtonChecked(hDlg, stct[dex].idxVal))
  232.             return(stct[dex].fType); 
  233.     return 0;
  234. }
  235.  
  236.  
  237. //*---------------------------------------------------------------------------------
  238. //| ShowCatalogResults:
  239. //|    This function will display the results set returned by a catalog
  240. //|    function.
  241. //| Parms:
  242. //|    in            ci                            CHILDINFO information
  243. //|    in            szTitle                    Title for the results set
  244. //| Returns:              
  245. //|    Nothing.
  246. //*---------------------------------------------------------------------------------
  247. BOOL ShowCatalogResults(CHILDINFO FAR * ci, LPSTR szTitle)
  248. {
  249.     RESULTSSET FAR *     rs;
  250.     int                    cbCols;
  251.  
  252.     if(!(cbCols = GetNumResultsCols(ci->hstmt)))
  253.         return TRUE;
  254.     if(cbCols == 0) {
  255.         szWrite(ci->hwndOut, GetidsString(idsNoDataFound, OutStr, sizeof(OutStr)));
  256.         return TRUE;
  257.         }
  258.     rs = GetConnectWindowResultsNode(ci);
  259.     if(!CreateResultsSet(rs, ci->hwndClient, ci->hInst,
  260.                 cbCols, szTitle))
  261.         return TRUE;
  262.     SetMetaDataFromSql(ci->hwndOut, ci->hstmt, rs, cbCols);
  263.     if(!CreateResultsWindow(ci, rs))
  264.         return TRUE;
  265.     FetchAllRecordsToResults(ci->hwndOut, ci->hstmt, rs, cbCols, TRUE);
  266.     SQLFreeStmt(ci->hstmt, SQL_CLOSE);
  267.     
  268.     return FALSE;
  269. }
  270.  
  271.  
  272. //*---------------------------------------------------------------------------------
  273. //| DoList:
  274. //|    This function will display a selection dialog for the catalog functions
  275. //|    then process the request.
  276. //| Parms:
  277. //|    in            ci                            CHILDINFO information
  278. //|    in            idMenuSelection        Menu value
  279. //| Returns:              
  280. //|    Nothing.
  281. //*---------------------------------------------------------------------------------
  282. void DoList(CHILDINFO FAR * ci, int idMenuSelection)
  283. {
  284.     static BOOL                    fInit;                // Have we called before
  285.     CATALOGINFO                    cati;
  286.     CATALOGINFO FAR *            lpcati=&cati;
  287.     DLGPROC                      dlgproc;
  288.     int                            dex;
  289.     HWND                            fHwnd=GetFocus();
  290.  
  291.     // Clean up all buffers on first catalog function
  292.     if(!fInit) {
  293.         for(dex=0;  dex<NumItems(CatalogVals);  dex++)
  294.             memset(CatalogVals[dex].szStr, 0, CatalogVals[dex].cbMax);
  295.         fInit = TRUE;
  296.         }
  297.  
  298.     // Find the dialog
  299.     for(dex=0;  dex<NumItems(Dialogs) &&
  300.                     Dialogs[dex].idMenu != idMenuSelection;  dex++);
  301.  
  302.     // Collect information for the dialog proc
  303.     cati.hInst = ci->hInst;
  304.     cati.id = idMenuSelection;
  305.     cati.ci = ci;
  306.     cati.szDlgTitle = Dialogs[dex].szDlgTitle;
  307.     cati.mask = Dialogs[dex].mask;
  308.  
  309.     // Display the dialog
  310.     dlgproc = MakeProcInstance(CatalogWndProc, cati.hInst);
  311.     if(-1 == DialogBoxParam(cati.hInst, 
  312.             MAKEINTRESOURCE(Dialogs[dex].iDialogName),
  313.             ci->hwnd, 
  314.             dlgproc, (LPARAM)(CATALOGINFO FAR *)lpcati))
  315.         MessageBox(NULL, "Could not open dialog box.",
  316.             "DoList", MB_ICONEXCLAMATION);
  317.     FreeProcInstance((FARPROC) dlgproc);
  318.     
  319.     if(fHwnd)
  320.         SetFocus(fHwnd);
  321. }
  322.  
  323.  
  324.  
  325. //*---------------------------------------------------------------------------------
  326. //| DoCatalogFunction:
  327. //|    The caller should have prepared all the information we need, so we will
  328. //|    simply invoke the function they want to run.
  329. //|    
  330. //| Parms:
  331. //|    cati        CATALOGINFO
  332. //| Returns:              
  333. //|    Nothing
  334. //*---------------------------------------------------------------------------------
  335. void DoCatalogFunction(CATALOGINFO FAR * cati)
  336. {
  337.     char                        szTitle[MAXBUFF];
  338.     RETCODE                    retcode;
  339.     CHILDINFO FAR *        ci=cati->ci;
  340.     
  341.     SQLFreeStmt(ci->hstmt, SQL_CLOSE);
  342.  
  343.     switch(cati->id) {                    
  344.         case IDM_TABLES:
  345.             if (!*szTableVal &&
  346.                 ((!*szOwnerVal && strcmp(szQualifierVal, "%") == 0)||
  347.                 (!*szQualifierVal && strcmp(szOwnerVal, "%") == 0)))
  348.                 retcode = SQLTables(ci->hstmt,
  349.                             szQualifierVal, SQL_NTS,
  350.                             szOwnerVal, SQL_NTS,
  351.                             szTableVal, SQL_NTS,
  352.                             szTypeVal, SQL_NTS);
  353.             else
  354.                 retcode = SQLTables(ci->hstmt, 
  355.                                     CHKNULL(szQualifierVal), SQL_NTS,
  356.                                     CHKNULL(szOwnerVal), SQL_NTS,
  357.                                     CHKNULL(szTableVal), SQL_NTS,
  358.                                     CHKNULL(szTypeVal), SQL_NTS);
  359.             break;
  360.  
  361.         case IDM_COLUMNS:
  362.                 retcode = SQLColumns(ci->hstmt,
  363.                             CHKNULL(szQualifierVal), SQL_NTS,
  364.                             CHKNULL(szOwnerVal), SQL_NTS,
  365.                             CHKNULL(szTableVal), SQL_NTS,
  366.                             CHKNULL(szColumnVal), SQL_NTS);
  367.             break;
  368.             
  369.         case IDM_STATISTICS:
  370.                 retcode = SQLStatistics(ci->hstmt,
  371.                             CHKNULL(szQualifierVal), SQL_NTS,
  372.                             CHKNULL(szOwnerVal), SQL_NTS,
  373.                             CHKNULL(szTableVal), SQL_NTS,
  374.                             cati->fUnique,
  375.                             cati->fAccuracy);
  376.             break;
  377.             
  378.         case IDM_PRIMARY_KEYS:
  379.                 retcode = SQLPrimaryKeys(ci->hstmt,
  380.                             CHKNULL(szQualifierVal), SQL_NTS,
  381.                             CHKNULL(szOwnerVal), SQL_NTS,
  382.                             CHKNULL(szTableVal), SQL_NTS);
  383.             break;
  384.             
  385.         case IDM_FOREIGN_KEYS:
  386.                 retcode = SQLForeignKeys(ci->hstmt,
  387.                             CHKNULL(szQualifierVal), SQL_NTS,
  388.                             CHKNULL(szOwnerVal), SQL_NTS,
  389.                             CHKNULL(szTableVal), SQL_NTS,
  390.                             CHKNULL(szQualifierVal2), SQL_NTS,
  391.                             CHKNULL(szOwnerVal2), SQL_NTS,
  392.                             CHKNULL(szTableVal2), SQL_NTS);
  393.             break;
  394.             
  395.         case IDM_TABLE_PRIVS:
  396.                 retcode = SQLTablePrivileges(ci->hstmt,
  397.                             CHKNULL(szQualifierVal), SQL_NTS,
  398.                             CHKNULL(szOwnerVal), SQL_NTS,
  399.                             CHKNULL(szTableVal), SQL_NTS);
  400.             break;
  401.             
  402.         case IDM_COLUMN_PRIVS:
  403.                 retcode = SQLColumnPrivileges(ci->hstmt,
  404.                             CHKNULL(szQualifierVal), SQL_NTS,
  405.                             CHKNULL(szOwnerVal), SQL_NTS,
  406.                             CHKNULL(szTableVal), SQL_NTS,
  407.                             CHKNULL(szColumnVal), SQL_NTS);
  408.             break;
  409.             
  410.         case IDM_SPECIAL_COLUMNS:
  411.                 retcode = SQLSpecialColumns(ci->hstmt,
  412.                             cati->fColType,
  413.                             CHKNULL(szQualifierVal), SQL_NTS,
  414.                             CHKNULL(szOwnerVal), SQL_NTS,
  415.                             CHKNULL(szTableVal), SQL_NTS,
  416.                             cati->fScope,     
  417.                             cati->fNullable);
  418.             break;
  419.             
  420.         case IDM_PROCEDURES:
  421.                 retcode = SQLProcedures(ci->hstmt,
  422.                             CHKNULL(szQualifierVal), SQL_NTS,
  423.                             CHKNULL(szOwnerVal), SQL_NTS,
  424.                             CHKNULL(szProcsVal), SQL_NTS);
  425.             break;
  426.             
  427.         case IDM_PROC_COLUMNS:
  428.                 retcode = SQLProcedureColumns(ci->hstmt,
  429.                             CHKNULL(szQualifierVal), SQL_NTS,
  430.                             CHKNULL(szOwnerVal), SQL_NTS,
  431.                             CHKNULL(szProcsVal), SQL_NTS,
  432.                             CHKNULL(szColumnVal), SQL_NTS);
  433.             break;
  434.         
  435.         default:
  436.             break;
  437.         }
  438.         
  439.     if(retcode != SQL_SUCCESS) {
  440.         PrintErrors(ci);
  441.         return;
  442.         }
  443.  
  444.     lstrcpy((LPSTR)szTitle, (LPSTR)ci->szClientTitle);
  445.     lstrcat((LPSTR)szTitle, (LPSTR)szCOLON);
  446.     lstrcat((LPSTR)szTitle, (LPSTR)cati->szDlgTitle);
  447.     if(ShowCatalogResults(ci, (LPSTR)szTitle))
  448.         return;
  449. }
  450.  
  451.  
  452. //*------------------------------------------------------------------------
  453. //| CatalogWndProc:
  454. //|    This windows procedure handles all of the catalog function messages.
  455. //|    Many things such as setting/getting text values are table driven.
  456. //|    This reduces overall code size significantly.
  457. //| Parms:
  458. //|    in            Standard window parms
  459. //| Returns:              
  460. //|    Depends on message
  461. //*------------------------------------------------------------------------
  462. BOOL EXTFUN CatalogWndProc(HWND hDlg, unsigned msg, WORD wParam, LONG lParam)
  463. {
  464.     static CATALOGINFO FAR *     cati;
  465.     int                                dex;
  466.  
  467.     switch(msg) {
  468.         case WM_INITDIALOG:
  469.             cati = (CATALOGINFO FAR *)lParam;
  470.             CenterDialog(hDlg);
  471.             
  472.             // Set all default values for edit controls
  473.             for(dex=0;  dex<NumItems(CatalogVals);  dex++) 
  474.                 if(cati->mask & CatalogVals[dex].mMask) {
  475.                     SetWindowText(GetDlgItem(hDlg, CatalogVals[dex].id),
  476.                                     CatalogVals[dex].szStr);
  477.                     SendMessage(GetDlgItem(hDlg, CatalogVals[dex].id), EM_LIMITTEXT,
  478.                                     CatalogVals[dex].cbMax, 0L);
  479.                     }
  480.             // Special case for dialogs with options
  481.             if(cati->id == IDM_STATISTICS) {
  482.                 CheckRadioButton(hDlg, IDX_INDEX_UNIQUE, IDX_INDEX_ALL, IDX_INDEX_UNIQUE);
  483.                 CheckRadioButton(hDlg, IDX_ENSURE, IDX_QUICK, IDX_ENSURE);
  484.                 }
  485.             else if(cati->id == IDM_SPECIAL_COLUMNS) {
  486.                 CheckRadioButton(hDlg, IDX_BEST_ROWID, IDX_ROWVER, IDX_BEST_ROWID);
  487.                 CheckRadioButton(hDlg, IDX_NO_NULLS, IDX_NULLABLE, IDX_NO_NULLS);
  488.                 CheckRadioButton(hDlg, IDX_SCOPE_CURROW, IDX_SCOPE_SESSION, IDX_SCOPE_CURROW);
  489.                 }
  490.                     
  491.             return TRUE;        
  492.  
  493.  
  494.         case WM_COMMAND:
  495.             switch(GET_WM_COMMAND_ID(wParam, lParam)) {
  496.                 case IDOK:
  497.                     {
  498.                     Busy(TRUE);
  499.                     for(dex=0;  dex<NumItems(CatalogVals);  dex++) 
  500.                         if(cati->mask & CatalogVals[dex].mMask)
  501.                             GetText(GetDlgItem(hDlg, CatalogVals[dex].id),
  502.                                     CatalogVals[dex].szStr);
  503.                     // Special case for dialogs with options
  504.                     if(cati->id == IDM_STATISTICS) {
  505.                         cati->fUnique = GetRadioValue(hDlg, (IDXINFO FAR *)StatsfUnique, NumItems(StatsfUnique));
  506.                         cati->fAccuracy = GetRadioValue(hDlg, (IDXINFO FAR *)StatsfAccuracy, NumItems(StatsfAccuracy));
  507.                         }
  508.                     else if(cati->id == IDM_SPECIAL_COLUMNS) {
  509.                         cati->fColType = GetRadioValue(hDlg, (IDXINFO FAR *)SpecColsfColType,
  510.                                         NumItems(SpecColsfColType));
  511.                         cati->fScope = GetRadioValue(hDlg, (IDXINFO FAR *)SpecColsfScope,
  512.                                         NumItems(SpecColsfScope));
  513.                         cati->fNullable = GetRadioValue(hDlg, (IDXINFO FAR *)SpecColsfNullable,
  514.                                         NumItems(SpecColsfNullable));
  515.                         }
  516.                     DoCatalogFunction(cati);
  517.  
  518.                     Busy(FALSE);
  519.                     EndDialog(hDlg, IDOK);
  520.                     }
  521.                     return TRUE;
  522.             
  523.             case IDCANCEL:
  524.                    SendMessage(hDlg, WM_CLOSE, 0, 0L);
  525.                    EndDialog(hDlg, IDCANCEL);
  526.                     return TRUE;
  527.                 }
  528.             return TRUE;
  529.  
  530.         default:
  531.             return FALSE;
  532.         }
  533.     return FALSE;
  534. }
  535.  
  536.