Return to open.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / cdtest

Annotation of mstools/samples/cdtest/open.c, revision 1.1

1.1     ! root        1: /************************************************************************
        !             2: 
        !             3:   File: open.c
        !             4: 
        !             5:   Purpose:
        !             6: 
        !             7:     This file contains the routines to control the CDTEST.EXE "Open" dialog
        !             8:     box.  The "Open" dialog box allows the user to enter values into an
        !             9:     OPENFILENAME structure and then create GetOpenFileName() dialog boxes
        !            10:     on the fly.
        !            11: 
        !            12:   Functions:
        !            13: 
        !            14:     DoOpenDialog()                   -- starts off the main dialog for "open"
        !            15: 
        !            16:     OpenFunc()                       -- Callback function for main dialog
        !            17: 
        !            18:     InitOpenStruct()                 -- Fills initial OPENFILENAME structure.
        !            19: 
        !            20:     FillOpenDlg()                    -- Fills the dialog with the values from
        !            21:                                         the OPENFILENAME structure.
        !            22: 
        !            23:     GetOpenDlg()                     -- Retrieves the users entries from the
        !            24:                                         main dialog and puts them in the
        !            25:                                         OPENFILENAME structure.
        !            26: 
        !            27:     InitFilterString()               -- Creates filter string
        !            28: 
        !            29:     InitCustFiltString()             -- Creates custom filter string
        !            30: 
        !            31:     InterpretCustomFilterString()    -- Parses custom filter string returned
        !            32:                                         from GetOpenFileName()
        !            33: 
        !            34:     GetCorrectResourceHandle()       -- Loads custom templates from file
        !            35:                                         as resource handles
        !            36: 
        !            37:     OpenSaveHookProc()               -- The hook function that will be
        !            38:                                         called if GetOpen/Save is called
        !            39:                                         with the OFN_ENABLEHOOK flag set.
        !            40: 
        !            41:     MultiThreadOpenSave()            -- Creates two Open/Save dialogs that
        !            42:                                         the user can simultaneously access
        !            43: 
        !            44:     OpenSaveThread1Proc()            -- The starting address of thread 1
        !            45: 
        !            46:     OpenSaveThread2Proc()            -- The starting address of thread 2
        !            47: 
        !            48:     DoOpenSaveStuff()                -- Does the actuall calling of
        !            49:                                         GetOpen/SaveFileName()
        !            50: 
        !            51:     OpenMultiThreadEnableButtons()   -- Enables and disables buttons in
        !            52:                                         main dialog.  Needed when multi-
        !            53:                                         threading.
        !            54: 
        !            55: ************************************************************************/
        !            56: 
        !            57: #include <windows.h>
        !            58: #include <commdlg.h>
        !            59: #include <stdlib.h>
        !            60: #include <winnls.h>
        !            61: #include "cdtest.h"
        !            62: #include "open.h"
        !            63: #include "save.h"
        !            64: #include "dlgs.h"     //include file that contains all #defines for the
        !            65:                       //commdlg dialog templates.
        !            66: 
        !            67: 
        !            68: /* All functions defined in this file + 1 external function
        !            69:    and one external variable */
        !            70: 
        !            71: extern UINT uMode ;                               //see cdtest.c
        !            72: extern LONG MyAtol(LPTSTR, BOOL, LPBOOL) ;
        !            73: void InterpretCustomFilterString(void) ;
        !            74: HANDLE GetCorrectResourceHandle(void) ;
        !            75: void DoOpenSaveStuff(LPOPENFILENAME) ;
        !            76: UINT APIENTRY OpenSaveHookProc(HWND hwnd, UINT msg, UINT wParam, LONG lParam) ;
        !            77: DWORD OpenSaveThread1Proc(LPDWORD) ;
        !            78: DWORD OpenSaveThread2Proc(LPDWORD) ;
        !            79: void MultiThreadOpenSave(void) ;
        !            80: void OpenMultiThreadEnableButtons(BOOL, HWND) ;
        !            81: 
        !            82: 
        !            83: /* All global variables defined in this file */
        !            84: 
        !            85: HWND hwndMainDialog ;   //global handle for open dialog.
        !            86: 
        !            87: HANDLE hRes ;           //handles to the resource and dialog for
        !            88: HANDLE hDialog ;        //ofn_enabletemplatehandle
        !            89: 
        !            90: HBRUSH hBrushDlg ;
        !            91: HBRUSH hBrushEdit ;     //brush handles for new colors done with hook proc
        !            92: HBRUSH hBrushButton ;
        !            93: 
        !            94: HANDLE hOpenSaveThread1, hOpenSaveThread2 ;   //variables for the
        !            95: DWORD dwThreadID1, dwThreadID2 ;              //multithreading part
        !            96: DWORD dwThreadParm1, dwThreadParm2 ;
        !            97: OPENFILENAME ofnThread1, ofnThread2 ;
        !            98: int nOpenDialogCount ;
        !            99: 
        !           100: 
        !           101: 
        !           102: 
        !           103: 
        !           104: /************************************************************************
        !           105: 
        !           106:   Function: DoOpenDialog(HWND)
        !           107: 
        !           108:   Purpose: To create the GetOpenFileName() and GetSaveFileName()
        !           109:            creation dialog.
        !           110: 
        !           111:   Returns: Nothing.
        !           112: 
        !           113:   Comments:
        !           114: 
        !           115:     GetOpenFileName() and GetSaveFileName() are similiar enough so that
        !           116:     the same dialog can be used to edit their creation structure elements,
        !           117:     so a global variable "bDoOpenDlg" keeps track of which one to create
        !           118:     when the user clicks the OK or Multithread buttons...
        !           119: 
        !           120: ************************************************************************/
        !           121: 
        !           122: 
        !           123: void DoOpenDialog(HWND hwnd)
        !           124: {
        !           125: 
        !           126:   bDoOpenDlg = TRUE ;
        !           127: 
        !           128: 
        !           129:   DialogBox(hInst, MAKEINTRESOURCE(ID_OPENDIALOG), hwnd, OpenFunc) ;
        !           130: 
        !           131: }
        !           132: 
        !           133: 
        !           134: 
        !           135: 
        !           136: 
        !           137: 
        !           138: /************************************************************************
        !           139: 
        !           140: 
        !           141:   Function: OpenFunc(HWND, UINT, UINT, LONG)
        !           142: 
        !           143:   Purpose:
        !           144: 
        !           145:     This is the callback function for the dialog box containing the
        !           146:     GetOpenFileName() and the GetSaveFileName() creation options.
        !           147: 
        !           148:     This function will handle the messages for this dialog and create
        !           149:     either a GetOpenFileName() dialog or a GetSaveFileName() dialog
        !           150:     depending on the state of the bDoOpenDlg variable.
        !           151: 
        !           152:   Returns: TRUE or FALSE depending on the situation.
        !           153: 
        !           154:   Comments:
        !           155: 
        !           156: 
        !           157: ************************************************************************/
        !           158: 
        !           159: 
        !           160: BOOL APIENTRY OpenFunc(HWND hwnd, UINT msg, UINT wParam, LONG lParam)
        !           161: {
        !           162:   switch (msg)
        !           163:   {
        !           164: 
        !           165:     case WM_INITDIALOG:
        !           166: 
        !           167:       if (bDoOpenDlg)
        !           168:         SetWindowText(hwnd, TEXT("GetOpenFileName()")) ;
        !           169:       else
        !           170:         SetWindowText(hwnd, TEXT("GetSaveFileName()")) ;
        !           171: 
        !           172: 
        !           173:       /* initialize the OPENFILENAME structure members */
        !           174: 
        !           175:       InitOpenStruct(hwnd, &ofn) ;
        !           176: 
        !           177: 
        !           178:       /* Fill these values into the creation dialog */
        !           179: 
        !           180:       FillOpenDlg(hwnd, &ofn) ;
        !           181: 
        !           182: 
        !           183:       /* There are three separate OPENFILENAME structures.  One for
        !           184:          the main Open/Save dialog and one for each multithreaded dialog.
        !           185:          Set them equal to begin with */
        !           186: 
        !           187:       *(&ofnThread1) = *(&ofnThread2) = *(&ofn) ;
        !           188: 
        !           189:       hwndMainDialog = hwnd ;
        !           190: 
        !           191:       SetFocus(GetDlgItem(hwnd, ID_STRUCTSIZEO)) ;
        !           192: 
        !           193:       break ;
        !           194: 
        !           195: 
        !           196: 
        !           197:     case UMSG_DECREMENTDLGCOUNT:  //user defined message indicating
        !           198:                                   //the closure of a multithreaded dialog
        !           199: 
        !           200:       /* When we are multithreading, there is nothing to prevent the
        !           201:          user from interacting with the creation dialog once the first
        !           202:          GetOpen(Save) file name dialog has returned.  So, in order
        !           203:          to prevent the Multithread" button from being pressed again
        !           204:          before the previous two multithreaded dialogs have been canceled,
        !           205:          disable the controls until we get a message from each thread
        !           206:          that the dialog has ended */
        !           207: 
        !           208: 
        !           209:       nOpenDialogCount-- ;
        !           210: 
        !           211:       if (nOpenDialogCount == 0)
        !           212:         OpenMultiThreadEnableButtons(TRUE, hwnd) ;
        !           213: 
        !           214:       break ;
        !           215: 
        !           216: 
        !           217:     case WM_COMMAND:
        !           218:     {
        !           219:       switch (LOWORD(wParam))
        !           220:       {
        !           221: 
        !           222:         case IDOK:
        !           223:           GetOpenDlg(hwnd, &ofn) ;          //get the user's input
        !           224:           DoOpenSaveStuff(&ofn) ;           //do the dialog
        !           225:           break ;
        !           226: 
        !           227: 
        !           228:         case IDCANCEL:
        !           229:           EndDialog(hwnd, FALSE) ;
        !           230:           break ;
        !           231: 
        !           232: 
        !           233:         case ID_RESETOPEN:
        !           234: 
        !           235:           SendDlgItemMessage(hwnd, ID_FILTERO, CB_RESETCONTENT,
        !           236:             (WPARAM) 0, (LPARAM) 0) ;
        !           237: 
        !           238:           InitOpenStruct(hwnd, &ofn) ;
        !           239: 
        !           240:           FillOpenDlg(hwnd, &ofn) ;
        !           241: 
        !           242:           SendDlgItemMessage(hwnd, ID_NULLSTRUCTO, BM_SETCHECK, (WPARAM)0, (LPARAM)0) ;
        !           243:           SendDlgItemMessage(hwnd, ID_USEHINSTO, BM_SETCHECK, (WPARAM)0, (LPARAM)0) ;
        !           244: 
        !           245:           *(&ofnThread1) = *(&ofnThread2) = *(&ofn) ;
        !           246: 
        !           247:           SetFocus(GetDlgItem(hwnd, ID_STRUCTSIZEO)) ;
        !           248: 
        !           249:           break ;
        !           250: 
        !           251: 
        !           252:         case ID_ADD1O:
        !           253: 
        !           254:           GetDlgItemText(hwnd, ID_FILTERO, szTemp, 100) ;
        !           255: 
        !           256:           if (*szTemp)
        !           257:           {
        !           258:             SendDlgItemMessage(hwnd, ID_FILTERO, CB_ADDSTRING, (WPARAM) 0,
        !           259:                               (LPARAM) (LPTSTR) szTemp) ;
        !           260:             SetWindowText(GetDlgItem(hwnd, ID_FILTERO), TEXT("")) ;
        !           261:           }
        !           262:           break ;
        !           263: 
        !           264: 
        !           265:         case ID_ADD2O:
        !           266: 
        !           267:           GetDlgItemText(hwnd, ID_CUSTFILTO, szTemp, 100) ;
        !           268: 
        !           269:           if (*szTemp)
        !           270:           {
        !           271:             SendDlgItemMessage(hwnd, ID_CUSTFILTO, CB_ADDSTRING, (WPARAM) 0,
        !           272:                               (LPARAM) (LPTSTR) szTemp) ;
        !           273:             SetWindowText(GetDlgItem(hwnd, ID_CUSTFILTO), TEXT("")) ;
        !           274:           }
        !           275:           break ;
        !           276: 
        !           277: 
        !           278:         case ID_CLEAR1O:
        !           279:           SendDlgItemMessage(hwnd, ID_FILTERO, CB_RESETCONTENT,
        !           280:                              (WPARAM) 0, (LPARAM) 0) ;
        !           281:           break ;
        !           282: 
        !           283:         case ID_CLEAR2O:
        !           284:           SendDlgItemMessage(hwnd, ID_CUSTFILTO, CB_RESETCONTENT,
        !           285:                              (WPARAM) 0, (LPARAM) 0) ;
        !           286:           break ;
        !           287: 
        !           288:         case ID_MULTIOPEN:
        !           289: 
        !           290:         /* First, disable the OK, Cancel, and MultiThread buttons */
        !           291: 
        !           292:           OpenMultiThreadEnableButtons(FALSE, hwnd) ;
        !           293: 
        !           294: 
        !           295:         /* Then multithread the dialogs */
        !           296: 
        !           297:           nOpenDialogCount = 2 ;
        !           298: 
        !           299:           MultiThreadOpenSave() ;
        !           300: 
        !           301:           break ;
        !           302: 
        !           303: 
        !           304:         default:   //end WM_COMMAND case
        !           305:           break ;
        !           306:       }
        !           307:     }
        !           308: 
        !           309:     default:
        !           310: 
        !           311:       /* If the help button is pressed in the GetOpen/SaveFileName()
        !           312:          dialogs, it will send a message Registered with RegisterWindowMessage()
        !           313:          to the parent window.  The message nHelpMessage was registered
        !           314:          at application startup */
        !           315: 
        !           316:       if (msg == nHelpMessage)
        !           317:         MessageBox(GetForegroundWindow(),
        !           318:                    TEXT("Hello from the help button"),
        !           319:                    TEXT("Open Help Button"), MB_OK | MB_APPLMODAL) ;
        !           320: 
        !           321:       break ;
        !           322: 
        !           323:   }
        !           324: 
        !           325:   return FALSE ;
        !           326: }
        !           327: 
        !           328: 
        !           329: 
        !           330: 
        !           331: 
        !           332: 
        !           333: 
        !           334: /************************************************************************
        !           335: 
        !           336: 
        !           337:   Function: InitOpenStruct(HWND, LPOPENFILENAME)
        !           338: 
        !           339:   Purpose:
        !           340: 
        !           341:     Initializes the OPENFILENAME structure.  The structure is referenced
        !           342:     via a pointer passed in as the second parameter so that we can pass
        !           343:     any of the three OPENFILENAME structures into this function and
        !           344:     Initialize them.
        !           345: 
        !           346:   Returns: Nothing.
        !           347: 
        !           348:   Comments:
        !           349: 
        !           350:     The szFilterInits and szCustFiltInits arrays are initialized to
        !           351:     contain some default strings.  Eventually the strings in
        !           352:     these arrays must be arranged one after the other with a null
        !           353:     character between them and two null characters at the end:
        !           354: 
        !           355:     "Text files\0*.txt\0All files\0*.*\0\0"
        !           356: 
        !           357: ************************************************************************/
        !           358: 
        !           359: 
        !           360: void InitOpenStruct(HWND hwnd, LPOPENFILENAME po)
        !           361: {
        !           362:    int i = 0 ;
        !           363:    szFileName[0] = 0 ;
        !           364:    szFileTitle[0] = 0 ;
        !           365: 
        !           366:    dwFlags = OFN_READONLY | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_SHOWHELP  ;
        !           367: 
        !           368:    if (bDoOpenDlg)
        !           369:      lstrcpy(szDlgTitle, TEXT("Open Dialog Title")) ;
        !           370:    else
        !           371:      lstrcpy(szDlgTitle, TEXT("Save Dialog Title")) ;
        !           372: 
        !           373:    lstrcpy(szDefExt, TEXT("rat")) ;
        !           374:    lstrcpy(szInitialDir, TEXT("c:\\")) ;
        !           375:    lstrcpy(szTempName, TEXT("opentemp1")) ;
        !           376: 
        !           377:    lstrcpy(&szFilterInits[0][0], TEXT("All Files (*.*)")) ;
        !           378:    lstrcpy(&szFilterInits[1][0], TEXT("*.*")) ;
        !           379:    lstrcpy(&szFilterInits[2][0], TEXT("Fat Files (*.fat)")) ;
        !           380:    lstrcpy(&szFilterInits[3][0], TEXT("*.fat")) ;
        !           381:    szFilterInits[4][0] = (TCHAR) 0 ;
        !           382: 
        !           383:    lstrcpy(&szCustFiltInits[0][0], TEXT("Last Filter Used")) ;
        !           384:    lstrcpy(&szCustFiltInits[1][0], TEXT("*.lst")) ;
        !           385:    szCustFiltInits[2][0] = (TCHAR) 0 ;
        !           386: 
        !           387: 
        !           388:    /*
        !           389: 
        !           390:       These two functions will create "strings" in the applications
        !           391:       data area that are in the form
        !           392: 
        !           393:       "Filter Description"\0
        !           394:       "Filter"\0
        !           395:       "Filter Description"\0
        !           396:       "Filter"\0
        !           397:       ..
        !           398:       ..
        !           399:       \0\0
        !           400: 
        !           401:       The filters must be in this form in order that the common dialogs
        !           402:       interpret it correctly...
        !           403:    */
        !           404: 
        !           405:    InitFilterString() ;
        !           406: 
        !           407:    InitCustFilterString() ;
        !           408: 
        !           409:    po->lStructSize          = sizeof(OPENFILENAME) ;
        !           410:    po->hwndOwner            = hwnd ;
        !           411:    po->hInstance            = hInst ;
        !           412:    (LPTSTR) po->lpstrFilter = lpszFilterString ;
        !           413:    po->lpstrCustomFilter    = lpszCustFilterString ;
        !           414:    po->nMaxCustFilter       = MAXCUSTFILTER ;
        !           415:    po->nFilterIndex         = 1L ;
        !           416:    po->lpstrFile            = szFileName ;
        !           417:    po->nMaxFile             = FILENAMESIZE ;
        !           418:    po->lpstrFileTitle       = szFileTitle ;
        !           419:    po->nMaxFileTitle        = FILETITLESIZE ;
        !           420:    po->lpstrInitialDir      = szInitialDir ;
        !           421:    (LPTSTR) po->lpstrTitle  = szDlgTitle ;
        !           422:    po->Flags                = dwFlags ;
        !           423:    po->nFileOffset          = 0 ;
        !           424:    po->nFileExtension       = 0 ;
        !           425:    (LPTSTR) po->lpstrDefExt = szDefExt;
        !           426:    po->lCustData            = 0L ;
        !           427:    po->lpfnHook             = OpenSaveHookProc ;
        !           428:    (LPTSTR) po->lpTemplateName  = szTempName ;
        !           429: 
        !           430:    return ;
        !           431: }
        !           432: 
        !           433: 
        !           434: 
        !           435: 
        !           436: 
        !           437: 
        !           438: 
        !           439: /************************************************************************
        !           440: 
        !           441: 
        !           442:   Function: FillOpenDlg(HWND, LPOPENFILENAME)
        !           443: 
        !           444:   Purpose:
        !           445: 
        !           446:     - This function will fill in the edit boxes that correspond to each
        !           447:       of the fields in the OPENFILENAME structure.  The user can accept
        !           448:       these values to create the common dialog or edit them.
        !           449: 
        !           450:   Returns: Nothing.
        !           451: 
        !           452:   Comments:
        !           453: 
        !           454:       The contents of the strings "szShortFilter" and "szLongFilter"
        !           455:       determine how a WORD or a DWORD value is represented in the edit boxes
        !           456: 
        !           457: ************************************************************************/
        !           458: 
        !           459: void FillOpenDlg(HWND hwnd, LPOPENFILENAME po)
        !           460: {
        !           461:    int i = 0 ;
        !           462: 
        !           463:    wsprintf(szTemp, szShortFilter, (int) po->lStructSize) ;
        !           464:    SetDlgItemText(hwnd, ID_STRUCTSIZEO, szTemp) ;
        !           465: 
        !           466:    wsprintf(szTemp, szLongFilter, (LONG) po->hwndOwner) ;
        !           467:    SetDlgItemText(hwnd, ID_HWNDOWNERO, szTemp) ;
        !           468: 
        !           469:    wsprintf(szTemp, szLongFilter, (LONG) po->hInstance) ;
        !           470:    SetDlgItemText(hwnd, ID_HINSTANCEO, szTemp) ;
        !           471: 
        !           472: 
        !           473:    SendDlgItemMessage(hwnd, ID_FILTERO, CB_RESETCONTENT,
        !           474:                       (WPARAM) 0, (LPARAM) 0) ;
        !           475: 
        !           476:    while (szFilterInits[i][0] != (TCHAR) 0)
        !           477:    {
        !           478:       SendDlgItemMessage(hwnd, ID_FILTERO, CB_ADDSTRING, (WPARAM) 0,
        !           479:                         (LPARAM) (LPTSTR) &szFilterInits[i][0]) ;
        !           480:       i++ ;
        !           481:    }
        !           482: 
        !           483:    SendDlgItemMessage(hwnd, ID_FILTERO, CB_SETCURSEL,
        !           484:                      (WPARAM) 0, (LPARAM) 0 ) ;
        !           485: 
        !           486: 
        !           487: 
        !           488:    SendDlgItemMessage(hwnd, ID_CUSTFILTO, CB_RESETCONTENT,
        !           489:                       (WPARAM) 0, (LPARAM) 0) ;
        !           490: 
        !           491:    for (i=0; i<2; i++)
        !           492:      SendDlgItemMessage(hwnd, ID_CUSTFILTO, CB_ADDSTRING, (WPARAM) 0,
        !           493:                         (LPARAM) (LPTSTR) &szCustFiltInits[i][0]) ;
        !           494: 
        !           495:    SendDlgItemMessage(hwnd, ID_CUSTFILTO, CB_SETCURSEL,
        !           496:                      (WPARAM) 0, (LPARAM) 0) ;
        !           497: 
        !           498: 
        !           499:    wsprintf(szTemp, szShortFilter, (int) po->nMaxCustFilter) ;
        !           500:    SetDlgItemText(hwnd, ID_MAXCUSTFILTO, szTemp) ;
        !           501: 
        !           502:    wsprintf(szTemp, szShortFilter, (int) po->nFilterIndex) ;
        !           503:    SetDlgItemText(hwnd, ID_FILTINDEXO, szTemp) ;
        !           504: 
        !           505:    SetDlgItemText(hwnd, ID_SZFILEO, po->lpstrFile) ;
        !           506: 
        !           507:    wsprintf(szTemp, szShortFilter, (int) po->nMaxFile) ;
        !           508:    SetDlgItemText(hwnd, ID_MAXSZFILEO, szTemp) ;
        !           509: 
        !           510:    SetDlgItemText(hwnd, ID_SZFILETITLEO, po->lpstrFileTitle) ;
        !           511: 
        !           512:    wsprintf(szTemp, szShortFilter, (int) po->nMaxFileTitle) ;
        !           513:    SetDlgItemText(hwnd, ID_MAXSZFILETITLEO, szTemp) ;
        !           514: 
        !           515:    SetDlgItemText(hwnd, ID_SZINITDIRO, po->lpstrInitialDir) ;
        !           516: 
        !           517:    SetDlgItemText(hwnd, ID_SZTITLEO, po->lpstrTitle) ;
        !           518: 
        !           519:    wsprintf(szTemp, szLongFilter, po->Flags) ;
        !           520:    SetDlgItemText(hwnd, ID_FLAGSO, szTemp) ;
        !           521: 
        !           522:    wsprintf(szTemp, szShortFilter, po->nFileOffset) ;
        !           523:    SetDlgItemText(hwnd, ID_FILEOFFO, szTemp) ;
        !           524: 
        !           525:    wsprintf(szTemp, szShortFilter, po->nFileExtension) ;
        !           526:    SetDlgItemText(hwnd, ID_FILEEXTO, szTemp) ;
        !           527: 
        !           528:    SetDlgItemText(hwnd, ID_SZDEFEXTO, po->lpstrDefExt) ;
        !           529: 
        !           530:    wsprintf(szTemp, szLongFilter, po->lCustData) ;
        !           531:    SetDlgItemText(hwnd, ID_CUSTDATAO, szTemp) ;
        !           532: 
        !           533:    wsprintf(szTemp, szLongFilter, po->lpfnHook) ;
        !           534:    SetDlgItemText(hwnd, ID_HOOKO, szTemp) ;
        !           535: 
        !           536:    SetDlgItemText(hwnd, ID_TEMPLATEO, po->lpTemplateName) ;
        !           537: 
        !           538:    return ;
        !           539: }
        !           540: 
        !           541: 
        !           542: 
        !           543: 
        !           544: 
        !           545: 
        !           546: 
        !           547: 
        !           548: /************************************************************************
        !           549: 
        !           550: 
        !           551:   Function: GetOpenDlg(HWND, LPOPENFILENAME)
        !           552: 
        !           553: 
        !           554:   Purpose:
        !           555: 
        !           556:       This function will retrieve the contents of each edit box corresponding
        !           557:       with each field in the OPENFILENAME structure, and fill in the
        !           558:       OPENFILENAME structure with these values.
        !           559: 
        !           560:   Returns: Nothing.
        !           561: 
        !           562:   Comments:
        !           563: 
        !           564:     if (uMode == IDM_HEXMODE), then the numbers should be interpreted as
        !           565:     hexidecimal and the MyAtol() function is called with its "bHex"
        !           566:     parameter set to true.
        !           567: 
        !           568: ************************************************************************/
        !           569: 
        !           570: void GetOpenDlg(HWND hwnd, LPOPENFILENAME po)
        !           571: {
        !           572:    int i ;
        !           573:    BOOL b ;
        !           574:    TCHAR szNum[20] ;
        !           575: 
        !           576:    GetDlgItemText(hwnd, ID_STRUCTSIZEO, szNum, 20) ;
        !           577:    po->lStructSize = MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
        !           578: 
        !           579:    GetDlgItemText(hwnd, ID_HWNDOWNERO, szNum, 20) ;
        !           580:    po->hwndOwner = (HWND) MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
        !           581: 
        !           582:    GetDlgItemText(hwnd, ID_HINSTANCEO, szNum, 20) ;
        !           583:    po->hInstance = (HANDLE) MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
        !           584: 
        !           585: 
        !           586:    /* these are just strings, no conversion necessary */
        !           587: 
        !           588:    i = 0 ;
        !           589:    while (SendDlgItemMessage(hwnd, ID_FILTERO, CB_GETLBTEXT, (WPARAM) i,
        !           590:                           (LPARAM) (LPTSTR) szFilterInits[i]) != CB_ERR)
        !           591:    { i++ ; }
        !           592: 
        !           593: 
        !           594:    /* create the filter string */
        !           595: 
        !           596:    InitFilterString() ;
        !           597: 
        !           598: 
        !           599:    i = 0 ;
        !           600: 
        !           601:    while (SendDlgItemMessage(hwnd, ID_CUSTFILTO, CB_GETLBTEXT, (WPARAM) i,
        !           602:                         (LPARAM) (LPTSTR) szCustFiltInits[i]) != CB_ERR)
        !           603:    { i++ ; }
        !           604: 
        !           605: 
        !           606:    InitCustFilterString() ;
        !           607: 
        !           608: 
        !           609:    GetDlgItemText(hwnd, ID_MAXCUSTFILTO, szNum, 20) ;
        !           610:    po->nMaxCustFilter = MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
        !           611: 
        !           612:    GetDlgItemText(hwnd, ID_FILTINDEXO, szNum, 20) ;
        !           613:    po->nFilterIndex = MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
        !           614: 
        !           615:    GetDlgItemText(hwnd, ID_SZFILEO, po->lpstrFile, MAXBUF) ;
        !           616: 
        !           617:    GetDlgItemText(hwnd, ID_MAXSZFILEO, szNum, 20) ;
        !           618:    po->nMaxFile = MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
        !           619: 
        !           620:    GetDlgItemText(hwnd, ID_SZFILETITLEO, po->lpstrFileTitle, MAXBUF) ;
        !           621: 
        !           622:    GetDlgItemText(hwnd, ID_MAXSZFILETITLEO, szNum, MAXBUF) ;
        !           623:    po->nMaxFileTitle = MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
        !           624: 
        !           625:    GetDlgItemText(hwnd, ID_SZINITDIRO, (LPTSTR) po->lpstrInitialDir, MAXBUF) ;
        !           626: 
        !           627:    GetDlgItemText(hwnd, ID_SZTITLEO, (LPTSTR) po->lpstrTitle, MAXBUF) ;
        !           628: 
        !           629:    GetDlgItemText(hwnd, ID_FLAGSO, szNum, 20) ;
        !           630:    po->Flags = MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
        !           631: 
        !           632:    GetDlgItemText(hwnd, ID_FILEOFFO, szNum, 20) ;
        !           633:    po->nFileOffset = (WORD) MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
        !           634: 
        !           635:    GetDlgItemText(hwnd, ID_FILEEXTO, szNum, 20) ;
        !           636:    po->nFileExtension = (WORD) MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
        !           637: 
        !           638:    GetDlgItemText(hwnd, ID_SZDEFEXTO, (LPTSTR) po->lpstrDefExt, DEFEXTSIZE) ;
        !           639: 
        !           640:    GetDlgItemText(hwnd, ID_CUSTDATAO, szNum, 20) ;
        !           641:    po->lCustData = MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
        !           642: 
        !           643:    GetDlgItemText(hwnd, ID_HOOKO, szNum, 20) ;
        !           644:    po->lpfnHook = (LPOFNHOOKPROC) MyAtol(szNum, uMode==IDM_HEXMODE, &b) ;
        !           645: 
        !           646:    GetDlgItemText(hwnd, ID_TEMPLATEO, (LPTSTR) po->lpTemplateName, TEMPNAMESIZE) ;
        !           647: 
        !           648: 
        !           649:    /*  if we are supposed to use a preloaded resource handle, load it and put it in
        !           650:        OPENFILENAME.hInstance... */
        !           651: 
        !           652:    if (IsDlgButtonChecked(hwnd, ID_USEHINSTO) == 1)
        !           653:      po->hInstance = GetCorrectResourceHandle() ;
        !           654: 
        !           655:    return ;
        !           656: }
        !           657: 
        !           658: 
        !           659: 
        !           660: 
        !           661: 
        !           662: 
        !           663: 
        !           664: /************************************************************************
        !           665: 
        !           666: 
        !           667:   Function: InitFilterString(void)
        !           668: 
        !           669: 
        !           670:   Purpose:
        !           671: 
        !           672:     This function will create a "string" in memory in the form that the
        !           673:     GetOpenFileName() function will expect for the filters it fills into
        !           674:     the "List Files of Type" combo box.
        !           675: 
        !           676:   Returns: Nothing.
        !           677: 
        !           678:   Comments:
        !           679: 
        !           680:     The szFilterInits and szCustFiltInits arrays are initialized to
        !           681:     contain some default strings.  Eventually the strings in
        !           682:     these arrays must be arranged one after the other with a null
        !           683:     character between them and two null characters at the end:
        !           684: 
        !           685:     "Text files\0*.txt\0All files\0*.*\0\0"
        !           686: 
        !           687: ************************************************************************/
        !           688: 
        !           689: 
        !           690: void InitFilterString(void)
        !           691: {
        !           692:   int i ;
        !           693:   int nInc = 0 ;
        !           694:   LPTSTR lpStr = szFilterString ;
        !           695: 
        !           696: 
        !           697:   /* First, zero out this memory just for the sake of sanity */
        !           698: 
        !           699:   for (i=0; i<MAXBUF; i++)
        !           700:     szFilterString[i] = 0 ;
        !           701: 
        !           702: 
        !           703:   /* Now, for each string in the szFilterInits array, concatenate it to
        !           704:      the last one right after the last one's null terminator */
        !           705: 
        !           706:   i = 0 ;
        !           707: 
        !           708:   while (szFilterInits[i][0] != (TCHAR) 0)
        !           709:   {
        !           710:     lstrcpy(lpStr, &szFilterInits[i][0]) ;
        !           711:     nInc+=lstrlen(&szFilterInits[i][0]) + 1 ;   //1 past null term...
        !           712:     lpStr = &szFilterString[nInc] ;
        !           713:     i++ ;
        !           714:   }
        !           715: 
        !           716:   szFilterString[nInc] = (TCHAR) 0 ;  //double terminator
        !           717: 
        !           718: 
        !           719:   /* Set the lpszFilterString to point to the memory we just filled in
        !           720:      with the filters because lpszFilterString is what is in
        !           721:      OPENFILENAME->lpstrFilter */
        !           722: 
        !           723:   lpszFilterString = szFilterString ;
        !           724: 
        !           725:   return ;
        !           726: }
        !           727: 
        !           728: 
        !           729: 
        !           730: 
        !           731: 
        !           732: 
        !           733: 
        !           734: 
        !           735: 
        !           736: /************************************************************************
        !           737: 
        !           738: 
        !           739:   Function: InitCustFiltString(void)
        !           740: 
        !           741: 
        !           742:   Purpose:
        !           743: 
        !           744:     This function will create a "string" in memory in the form that the
        !           745:     GetOpenFileName() function will expect for a custom filter.
        !           746: 
        !           747:   Returns: Nothing.
        !           748: 
        !           749:   Comments:
        !           750: 
        !           751:     The szFilterInits and szCustFiltInits arrays are initialized to
        !           752:     contain some default strings.  Eventually the strings in
        !           753:     these arrays must be arranged one after the other with a null
        !           754:     character between them and two null characters at the end:
        !           755: 
        !           756:     "Text files\0*.txt\0All files\0*.*\0\0"
        !           757: 
        !           758:     This program initializes these strings, but they do not need to be
        !           759:     initialized.  The GetOpenFileName() functiion will write a filter
        !           760:     into this memory area if the user types a new filter into the
        !           761:     "FileName" box and returns by clicking the OK button (indicating that
        !           762:     a file matching that filter was found).
        !           763: 
        !           764: ************************************************************************/
        !           765: 
        !           766: 
        !           767: void InitCustFilterString(void)
        !           768: {
        !           769:   int i ;
        !           770:   LPTSTR lpStr = szCustFilterString ;
        !           771:   int nInc = 0 ;
        !           772: 
        !           773:   for (i=0; i<MAXBUF; i++)
        !           774:     szCustFilterString[i] = 0 ;
        !           775: 
        !           776:   i = 0 ;
        !           777: 
        !           778:   for(i=0; i<2; i++)  //only two for the custom filter
        !           779:   {
        !           780:     lstrcpy(lpStr, &szCustFiltInits[i][0]) ;
        !           781:     nInc+=lstrlen(&szCustFiltInits[i][0]) + 1 ;
        !           782:     lpStr = &szCustFilterString[nInc] ;
        !           783:   }
        !           784: 
        !           785:   szCustFilterString[nInc] = (TCHAR) 0 ;
        !           786: 
        !           787:   lpszCustFilterString = szCustFilterString ;
        !           788: 
        !           789:   return ;
        !           790: }
        !           791: 
        !           792: 
        !           793: 
        !           794: 
        !           795: 
        !           796: 
        !           797: 
        !           798: 
        !           799: 
        !           800: /************************************************************************
        !           801: 
        !           802:   Function: InterpretCustomFilterString(void)
        !           803: 
        !           804: 
        !           805:   Purpose:
        !           806: 
        !           807:     This function will parse the memory that is being used for the
        !           808:     custom filter string.  If the user returned TRUE after entering
        !           809:     their own filter, the new filter will be here and so we need to
        !           810:     add it to our custom filter init array...
        !           811: 
        !           812:   Returns: Nothing.
        !           813: 
        !           814:   Comments:
        !           815: 
        !           816: ************************************************************************/
        !           817: 
        !           818: void InterpretCustomFilterString(void)
        !           819: {
        !           820:   LPTSTR pNext ;
        !           821: 
        !           822:   int nCount = lstrlen(ofn.lpstrCustomFilter) ;
        !           823: 
        !           824:   pNext = ofn.lpstrCustomFilter + nCount + 1 ;  //one past the NULL
        !           825: 
        !           826: 
        !           827:   /* add it to the filter inits array */
        !           828: 
        !           829:   lstrcpy(&szCustFiltInits[0][0], ofn.lpstrCustomFilter) ;
        !           830:   lstrcpy(&szCustFiltInits[1][0], pNext) ;
        !           831: 
        !           832: }
        !           833: 
        !           834: 
        !           835: 
        !           836: 
        !           837: 
        !           838: 
        !           839: 
        !           840: 
        !           841: 
        !           842: /************************************************************************
        !           843: 
        !           844:   Function: GetCorrectResourceHandle(void)
        !           845: 
        !           846:   Purpose:
        !           847: 
        !           848:     This function will use FindResource() to find the correct custom
        !           849:     template resource, use LoadResource() to get a handle to it.
        !           850: 
        !           851:   Returns: A handle to a custom template resource.
        !           852: 
        !           853:   Comments:
        !           854: 
        !           855:     The names for the custom template for GetOpenFileName() are
        !           856: 
        !           857:       "opentemp1" -- normal
        !           858:       "opentemp2" -- contains a multi-select list box for the file names
        !           859: 
        !           860:     If the user has marked the "Preloaded Template" box and specified
        !           861:     OFN_ENABLETEMPLATEHANDLE in the "Flags" edit box, this handle
        !           862:     will be used to create the GetOpenFileName() dialog box.
        !           863: 
        !           864: ************************************************************************/
        !           865: 
        !           866: 
        !           867: HANDLE GetCorrectResourceHandle(void)
        !           868: {
        !           869:   if (ofn.Flags & OFN_ALLOWMULTISELECT)
        !           870:   {
        !           871:      hRes = FindResource(hInst, TEXT("opentemp2"), RT_DIALOG) ;
        !           872:      hDialog = LoadResource(hInst, hRes) ;
        !           873:   }
        !           874: 
        !           875:   else
        !           876:   {
        !           877:      hRes = FindResource(hInst, TEXT("opentemp1"), RT_DIALOG) ;
        !           878:      hDialog = LoadResource(hInst, hRes) ;
        !           879:   }
        !           880: 
        !           881:   return hDialog ;
        !           882: }
        !           883: 
        !           884: 
        !           885: 
        !           886: 
        !           887: 
        !           888: 
        !           889: 
        !           890: /************************************************************************
        !           891: 
        !           892:   Function: OpenSaveHookProc(HWND, UINT, UINT, LONG) ;
        !           893: 
        !           894:   Purpose:
        !           895: 
        !           896:     This function is the hook function for the GetOpenFileName() function.
        !           897:     If GetOpenFileName() is called with the OFN_ENABLEHOOK flag, this
        !           898:     function will be called before the normal GetOpenFileName() dialog
        !           899:     function is called.
        !           900: 
        !           901:   Returns: FALSE to pass the message on to the normal GetOpenFileName()
        !           902:            logic, TRUE to discard the message.
        !           903: 
        !           904:   Comments:
        !           905: 
        !           906:     To enable this function in this program, enter the value for
        !           907:     OFN_ENABLEHOOK in the "Flags" edit box.
        !           908: 
        !           909: ************************************************************************/
        !           910: 
        !           911: 
        !           912: UINT APIENTRY OpenSaveHookProc(HWND hwnd, UINT msg, UINT wParam, LONG lParam)
        !           913: {
        !           914:   LPOPENFILENAME pOfn ;
        !           915:   TCHAR szMsg[50] ;
        !           916: 
        !           917:   switch(msg)
        !           918:   {
        !           919:     case WM_INITDIALOG:
        !           920: 
        !           921:       pOfn = (LPOPENFILENAME) lParam ;
        !           922: 
        !           923: 
        !           924:       /* During initialization, if there is a hook proc, the getopen()
        !           925:          code will send pointer to the OPENFILENAME strucure in the
        !           926:          lParam.  To demonstrate this, pop up a message box if this
        !           927:          structure has a non zero value in the lCustData structure member */
        !           928: 
        !           929: 
        !           930:       if (pOfn->lCustData != 0L)
        !           931:       {
        !           932:         wsprintf(szMsg, TEXT("OPENFILENAME->lCustData is: %ld"), pOfn->lCustData) ;
        !           933: 
        !           934:         MessageBox(hwnd, szMsg, TEXT("lCustData Sent!"), MB_OK) ;
        !           935:       }
        !           936: 
        !           937:       SetWindowText(hwnd, TEXT("Open Hook Proc Dialog")) ;
        !           938: 
        !           939:       break ;
        !           940: 
        !           941: 
        !           942:     /* use the WM_CTLCOLOR* messages to change the color of the Open
        !           943:        dialog */
        !           944: 
        !           945:     case WM_CTLCOLORDLG:
        !           946: 
        !           947:         if (!hBrushDlg)
        !           948:             hBrushDlg = GetStockObject(LTGRAY_BRUSH) ;
        !           949: 
        !           950:         return (UINT) hBrushDlg ;
        !           951: 
        !           952:         break ;
        !           953: 
        !           954: 
        !           955:     case WM_CTLCOLORBTN:
        !           956: 
        !           957:         SetBkMode((HDC) wParam, TRANSPARENT) ;   //sets background color
        !           958:                                                  //for push and check box
        !           959:                                                  //buttons...
        !           960: 
        !           961:         if (!hBrushButton)
        !           962:             hBrushButton = GetStockObject(LTGRAY_BRUSH) ;
        !           963: 
        !           964:         return (UINT) hBrushButton ;
        !           965: 
        !           966:         break ;
        !           967: 
        !           968: 
        !           969:     case WM_CTLCOLORSTATIC:
        !           970: 
        !           971:         SetTextColor((HDC) wParam, RGB(0x00, 0xff, 0x00)) ;  //green
        !           972:         SetBkMode((HDC) wParam, TRANSPARENT) ;               //transparent text
        !           973: 
        !           974:         if (!hBrushDlg)
        !           975:             hBrushDlg = GetStockObject(LTGRAY_BRUSH) ;
        !           976: 
        !           977:         return (UINT) hBrushDlg ;
        !           978: 
        !           979:         break ;
        !           980: 
        !           981: 
        !           982:     case WM_COMMAND:
        !           983:         switch (LOWORD(wParam))
        !           984:         {
        !           985:           case chx1:
        !           986:             MessageBox(hwnd, TEXT("Read-Only button clicked..."),
        !           987:                        TEXT("Open"), MB_OK | MB_APPLMODAL) ;
        !           988:             break ;
        !           989: 
        !           990:           case ID_FILEPREVIEW:
        !           991:             MessageBox(hwnd, TEXT("File Preview Button Clicked"),
        !           992:                        TEXT("Open"), MB_OK | MB_APPLMODAL) ;
        !           993:             break ;
        !           994: 
        !           995:           default: break ;
        !           996:         }
        !           997:         break ;
        !           998: 
        !           999:     default:
        !          1000: 
        !          1001:       if (msg == nOpenShareVMsg)
        !          1002:       {
        !          1003:         MessageBox(hwnd, TEXT("The SHAREVSTRING message is here!"),
        !          1004:                          TEXT("Open"),
        !          1005:                          MB_ICONEXCLAMATION | MB_OK | MB_APPLMODAL) ;
        !          1006: 
        !          1007:         return OFN_SHAREWARN ;
        !          1008:       }
        !          1009:       break ;
        !          1010:   }
        !          1011: 
        !          1012:   return FALSE ;   //send msg to the common dialog code
        !          1013: }
        !          1014: 
        !          1015: 
        !          1016: 
        !          1017: 
        !          1018: 
        !          1019: 
        !          1020: 
        !          1021: 
        !          1022: 
        !          1023: /************************************************************************
        !          1024: 
        !          1025:   Function: MultiThreadOpenSave(void)
        !          1026: 
        !          1027:   Purpose:
        !          1028: 
        !          1029:     This function will start two threads and then return.  The two
        !          1030:     threads will create GetOpenFileName() dialogs, and the user
        !          1031:     can interact with two Open dialogs at once.
        !          1032: 
        !          1033:   Returns: Nothing.
        !          1034: 
        !          1035:   Comments:
        !          1036: 
        !          1037:     This will create two Open dialogs, but they will be created in the
        !          1038:     same location on the screen.  The only way to change that would be
        !          1039:     to call the function with a hookproc and move one of the windows.
        !          1040: 
        !          1041:     But that would mean that if the user did not enter OFN_ENABLEHOOK
        !          1042:     in the "Flags" edit box, we would be no better off than before.  So,
        !          1043:     in order to see both dialogs, you just have to move the top one out
        !          1044:     of the way a little.
        !          1045: 
        !          1046:     Multithreading note:
        !          1047: 
        !          1048:     This function will return before the common dialog functions return.
        !          1049:     Therefore, do not pass any parameters to this function that will be
        !          1050:     referenced by the common dialogs because as soon as this function
        !          1051:     ends those parameters will be gone.
        !          1052: 
        !          1053: ************************************************************************/
        !          1054: 
        !          1055: void MultiThreadOpenSave(void)
        !          1056: {
        !          1057: 
        !          1058:   if (!(hOpenSaveThread1 = CreateThread((LPSECURITY_ATTRIBUTES) NULL, 0,
        !          1059:                                         (LPTHREAD_START_ROUTINE) OpenSaveThread1Proc,
        !          1060:                                         &dwThreadParm1, CREATE_SUSPENDED, &dwThreadID1)))
        !          1061: 
        !          1062:   {
        !          1063:     MessageBox(GetForegroundWindow(), TEXT("Cannot create thread 1"), NULL, MB_OK | MB_ICONEXCLAMATION) ;
        !          1064:     OpenMultiThreadEnableButtons(TRUE, hwndMainDialog) ;
        !          1065:     nOpenDialogCount = 0 ;
        !          1066:     return ;
        !          1067:   }
        !          1068: 
        !          1069: 
        !          1070: 
        !          1071:   if (!(hOpenSaveThread2 = CreateThread((LPSECURITY_ATTRIBUTES) NULL, 0,
        !          1072:                                         (LPTHREAD_START_ROUTINE) OpenSaveThread2Proc,
        !          1073:                                         &dwThreadParm2, CREATE_SUSPENDED, &dwThreadID2)))
        !          1074:   {
        !          1075:     MessageBox(GetForegroundWindow(), TEXT("Cannot create thread 2"), NULL, MB_OK | MB_ICONEXCLAMATION) ;
        !          1076:     OpenMultiThreadEnableButtons(TRUE, hwndMainDialog) ;
        !          1077:     nOpenDialogCount = 0 ;
        !          1078:     return ;
        !          1079:   }
        !          1080: 
        !          1081: 
        !          1082:   ResumeThread(hOpenSaveThread1) ;
        !          1083:   ResumeThread(hOpenSaveThread2) ;
        !          1084: 
        !          1085: }
        !          1086: 
        !          1087: 
        !          1088: 
        !          1089: 
        !          1090: 
        !          1091: 
        !          1092: 
        !          1093: /************************************************************************
        !          1094: 
        !          1095:   Function: OpenSaveThreadProc1(LPDWORD)
        !          1096: 
        !          1097:   Purpose:
        !          1098: 
        !          1099:     This is the address where the first thread starts executing.
        !          1100: 
        !          1101:   Returns: Any DWORD value.
        !          1102: 
        !          1103:   Comments:
        !          1104: 
        !          1105: ************************************************************************/
        !          1106: 
        !          1107: 
        !          1108: DWORD OpenSaveThread1Proc(LPDWORD pDw)
        !          1109: {
        !          1110: 
        !          1111:   /* Get the user's input */
        !          1112: 
        !          1113:   GetOpenDlg(hwndMainDialog, &ofnThread1) ;
        !          1114: 
        !          1115: 
        !          1116:   /* Do the dialog */
        !          1117: 
        !          1118:   DoOpenSaveStuff(&ofnThread1) ;
        !          1119: 
        !          1120: 
        !          1121:   /* send a message to the parent telling it to decrement the dialog count.
        !          1122:      When the dialog count reaches zero, all the buttons are enabled again. */
        !          1123: 
        !          1124:   SendMessage(hwndMainDialog, UMSG_DECREMENTDLGCOUNT, 0, 0L) ;
        !          1125: 
        !          1126:   return 0L ;
        !          1127: }
        !          1128: 
        !          1129: 
        !          1130: 
        !          1131: 
        !          1132: 
        !          1133: 
        !          1134: 
        !          1135: /************************************************************************
        !          1136: 
        !          1137:   Function: OpenSaveThreadProc2(LPDWORD)
        !          1138: 
        !          1139:   Purpose:
        !          1140: 
        !          1141:     This is the address where the second thread starts executing.
        !          1142: 
        !          1143:   Returns: Any DWORD value.
        !          1144: 
        !          1145:   Comments:
        !          1146: 
        !          1147: ************************************************************************/
        !          1148: 
        !          1149: DWORD OpenSaveThread2Proc(LPDWORD pDw)
        !          1150: {
        !          1151:   GetOpenDlg(hwndMainDialog, &ofnThread2) ;
        !          1152: 
        !          1153:   DoOpenSaveStuff(&ofnThread2) ;
        !          1154: 
        !          1155:   SendMessage(hwndMainDialog, UMSG_DECREMENTDLGCOUNT, 0, 0L) ;
        !          1156: 
        !          1157:   return 0L ;
        !          1158: }
        !          1159: 
        !          1160: 
        !          1161: 
        !          1162: 
        !          1163: 
        !          1164: 
        !          1165: 
        !          1166: /************************************************************************
        !          1167: 
        !          1168:   Function: DoOpenSaveStuff(LPOPENFILENAME)
        !          1169: 
        !          1170:   Purpose:
        !          1171: 
        !          1172:     This is the function that actually calls GetOpenFileName() or
        !          1173:     GetSaveFileName().  It receives a pointer to the structure to
        !          1174:     use as its only parameter.
        !          1175: 
        !          1176:   Returns: Nothing.
        !          1177: 
        !          1178:   Comments:
        !          1179: 
        !          1180: ************************************************************************/
        !          1181: 
        !          1182: void DoOpenSaveStuff(LPOPENFILENAME po)
        !          1183: {
        !          1184:   BOOL bRet = TRUE ;
        !          1185: 
        !          1186: 
        !          1187:   /* If bOpenDlg is TRUE, do GetOpenFileName(), else do GetSave().
        !          1188:      If the "NULL Structure" button is checked, send in a NULL pointer
        !          1189:      to the function */
        !          1190: 
        !          1191:   if (bDoOpenDlg)
        !          1192:   {
        !          1193:     if (IsDlgButtonChecked(hwndMainDialog, ID_NULLSTRUCTO) == 1)
        !          1194:       bRet = GetOpenFileName((LPOPENFILENAME) NULL) ;
        !          1195:     else
        !          1196:       bRet = GetOpenFileName(po) ;
        !          1197:   }
        !          1198: 
        !          1199:   else
        !          1200:   {
        !          1201:     if (IsDlgButtonChecked(hwndMainDialog, ID_NULLSTRUCTO))
        !          1202:       bRet = GetSaveFileName((LPOPENFILENAME) NULL) ;
        !          1203:     else
        !          1204:       bRet = GetSaveFileName(po) ;
        !          1205:   }
        !          1206: 
        !          1207: 
        !          1208:   /* Record the results */
        !          1209: 
        !          1210:   wsprintf(szTemp, szLongFilter, CommDlgExtendedError()) ;
        !          1211:   SetDlgItemText(hwndMainDialog, ID_ERRORO, szTemp) ;
        !          1212: 
        !          1213:   wsprintf(szTemp, szShortFilter, (int) bRet) ;
        !          1214:   SetDlgItemText(hwndMainDialog, ID_RETURNO, szTemp) ;
        !          1215: 
        !          1216:   InterpretCustomFilterString() ;
        !          1217: 
        !          1218:   FillOpenDlg(hwndMainDialog, po) ;
        !          1219: 
        !          1220:   if (hDialog)
        !          1221:   {
        !          1222:     FreeResource(hDialog) ;    //free ofn.hInstance
        !          1223:     hDialog = (HANDLE) 0 ;
        !          1224:     hRes = (HANDLE) 0 ;
        !          1225:   }
        !          1226: }
        !          1227: 
        !          1228: 
        !          1229: 
        !          1230: 
        !          1231: 
        !          1232: 
        !          1233: 
        !          1234: /************************************************************************
        !          1235: 
        !          1236:   Function: OpenMultiThreadEnableButtons(BOOL, HWND)
        !          1237: 
        !          1238:   Purpose:
        !          1239: 
        !          1240:     Enable or disable the buttons that might affect the state of the
        !          1241:     OPENFILENAME structures.  This is necessary because during a
        !          1242:     multithreading session, these buttons may be accessible even though
        !          1243:     there are Open dialogs still working and we don't want to change
        !          1244:     the OPENFILENAME structure out from under them.
        !          1245: 
        !          1246: 
        !          1247:   Returns: Nothing.
        !          1248: 
        !          1249:   Comments:
        !          1250: 
        !          1251: ************************************************************************/
        !          1252: 
        !          1253: void OpenMultiThreadEnableButtons(BOOL bEnable, HWND hwnd)
        !          1254: {
        !          1255:   EnableWindow(GetDlgItem(hwnd, IDOK), bEnable) ;
        !          1256:   EnableWindow(GetDlgItem(hwnd, IDCANCEL), bEnable) ;
        !          1257:   EnableWindow(GetDlgItem(hwnd, ID_RESETOPEN), bEnable) ;
        !          1258:   EnableWindow(GetDlgItem(hwnd, ID_MULTIOPEN), bEnable) ;
        !          1259: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.