home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / STYLE.ZIP / STY_FILE.C < prev    next >
C/C++ Source or Header  |  1992-03-30  |  23KB  |  730 lines
  1. /*************************************************************************
  2. *
  3. *  File Name   : STY_FILE.C
  4. *
  5. *  Description : This module contains the code for the
  6. *                WM_COMMAND messages posted by the standard
  7. *                File menu.
  8. *
  9. *  Concepts    : Open, close, read, write of files.
  10. *                File selection through the use of the
  11. *                standard file fialog.
  12. *
  13. *  API's       : WinSendMsg
  14. *                WinLoadString
  15. *                WinFileDlg
  16. *                DosOpen
  17. *                DosQueryFileInfo
  18. *                DosClose
  19. *                DosRead
  20. *                DosAllocMem
  21. *                DosFreeMem
  22. *                WinPostMsg
  23. *                DosWrite
  24. *                WinQueryTaskTitle
  25. *                WinLoadString
  26. *                WinSetWindowText
  27. *                WinQueryWindowULong
  28. *
  29. *  Copyright (C) 1992 IBM Corporation
  30. *
  31. *      DISCLAIMER OF WARRANTIES.  The following [enclosed] code is
  32. *      sample code created by IBM Corporation. This sample code is not
  33. *      part of any standard or IBM product and is provided to you solely
  34. *      for  the purpose of assisting you in the development of your
  35. *      applications.  The code is provided "AS IS", without
  36. *      warranty of any kind.  IBM shall not be liable for any damages
  37. *      arising out of your use of the sample code, even if they have been
  38. *      advised of the possibility of such damages.                                                    *
  39. *
  40. ************************************************************************/
  41.  
  42. /*  Include files, macros, defined constants, and externs               */
  43.  
  44. #define INCL_WINFRAMEMGR
  45. #define INCL_WINWINDOWMGR
  46. #define INCL_WINSWITCHLIST
  47. #define INCL_WINMLE
  48. #define INCL_WINSTDFILE
  49.  
  50. #include <os2.h>
  51. #include <string.h>
  52. #include "sty_main.h"
  53. #include "sty_xtrn.h"
  54. #include "sty_help.h"
  55. #include "sty_dlg.h"
  56.  
  57. /*  Global variables                                                    */
  58.  
  59. CHAR szFullPath[CCHMAXPATH] = "";
  60.  
  61. /*********************************************************************
  62.  *  Name: FileNew
  63.  *
  64.  *  Description : Processes the File menu's New item
  65.  *
  66.  *  Concepts : Called whenever New from the File menu is selected.
  67.  *
  68.  *  API's : WinSendMsg
  69.  *
  70.  *  Parameters : mp2 - Message parameter 2
  71.  *
  72.  *  Returns : VOID
  73.  *
  74.  ****************************************************************/
  75. VOID FileNew( MPARAM mp2)
  76. {
  77.    SHORT sMsgBoxResponce;
  78.  
  79.    /* Save file if changed                                              */
  80.    if ((BOOL)WinSendMsg(hwndMLE, MLM_QUERYCHANGED, NULL, NULL))
  81.    {
  82.       sMsgBoxResponce = MessageBox(hwndMLE, IDMSG_FILECHANGED,
  83.            MB_QUERY | MB_YESNOCANCEL, FALSE);
  84.  
  85.       if (sMsgBoxResponce == MBID_CANCEL)   /* if user cancels the New,  */
  86.          return;                           /* then return               */
  87.       else
  88.          if (sMsgBoxResponce == MBID_YES)
  89.             FileSave(NULL);
  90.       /*
  91.        * If sMsgBoxResponce == MBID_NO, continue with New File processing
  92.        */
  93.    }
  94.  
  95.    /*
  96.     * disable redrawing of the MLE so the text doesn't "flash" when
  97.     * the MLE is cleared
  98.     */
  99.    WinSendMsg(hwndMLE, MLM_DISABLEREFRESH, NULL, NULL);
  100.  
  101.    /*
  102.     * Clear the MLE by selecting all of the text and clearing it
  103.     */
  104.    WinSendMsg(hwndMLE, MLM_SETSEL, MPFROMSHORT(NULL),
  105.              (MPARAM)WinSendMsg(hwndMLE, MLM_QUERYTEXTLENGTH, NULL, NULL));
  106.  
  107.    WinSendMsg(hwndMLE, MLM_CLEAR, NULL, NULL);
  108.  
  109.    /*
  110.     * Reset the changed flag
  111.     */
  112.    WinSendMsg(hwndMLE, MLM_SETCHANGED, MPFROMSHORT((BOOL)FALSE), NULL);
  113.  
  114.    /*
  115.     * Enable redrawing of the MLE
  116.     */
  117.    WinSendMsg(hwndMLE, MLM_ENABLEREFRESH, NULL, NULL);
  118.  
  119.    /*
  120.     * Reset file name to NULL and update the main title bar
  121.     */
  122.    szFullPath[0] = 0;
  123.    UpdateTitleText(hwndMainFrame);
  124.  
  125.    /*
  126.     *  This routine currently doesn't use the mp2 parameter but
  127.     *  it is referenced here to prevent an 'Unreferenced Parameter'
  128.     *  warning at compile time.
  129.     */
  130.    mp2;
  131. }   /* En of FileNew()                                                  */
  132.  
  133. /*********************************************************************
  134.  *  Name: FileOpen
  135.  *
  136.  *  Description : Processes the File menu's Open item.
  137.  *
  138.  *  Concepts : Called whenever New from the File menu is
  139.  *             selected.  Calls the standard file open
  140.  *             dialog to get the file name.  The file name
  141.  *             is passed onto DosOpen which returns the
  142.  *             handle to the file.  The file input
  143.  *             procedure is called and then the file
  144.  *             handle is closed.
  145.  *
  146.  *  API's : WinLoadString
  147.  *          WinFileDlg
  148.  *          DosOpen
  149.  *          DosQueryFileInfo
  150.  *          DosClose
  151.  *          DosRead
  152.  *          DosAllocMem
  153.  *          DosFreeMem
  154.  *
  155.  *  Parameters : mp2 - Message parameter 2
  156.  *
  157.  *  Returns : VOID
  158.  *
  159.  ****************************************************************/
  160. VOID FileOpen( MPARAM mp2)
  161. {
  162.    FILEDLG fileDialog;
  163.    HFILE hfile;
  164.    ULONG ulAction;
  165.    FILESTATUS fileStatus;
  166.    PVOID pvBuf;
  167.    CHAR szTitle[MESSAGELEN], szButton[MESSAGELEN];
  168.    IPT iptOffset;                   /* insert position */
  169.  
  170.    fileDialog.cbSize = sizeof(FILEDLG);
  171.  
  172.    if (!WinLoadString(hab, (HMODULE)0, IDS_OPENDLGTITLE, MESSAGELEN, szTitle))
  173.    {
  174.       MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, TRUE);
  175.       return;
  176.    }
  177.  
  178.    if (!WinLoadString(hab,(HMODULE)0, IDS_OPENDLGBUTTON, MESSAGELEN, szButton))
  179.    {
  180.       MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, TRUE);
  181.       return;
  182.    }
  183.  
  184.    fileDialog.pszTitle = szTitle;
  185.    fileDialog.pszOKButton = szButton;
  186.    fileDialog.ulUser = 0;
  187.    fileDialog.fl = FDS_HELPBUTTON | FDS_CENTER | FDS_OPEN_DIALOG;
  188.    fileDialog.pfnDlgProc = (PFNWP)OpenSaveFilterDlgProc;
  189.    fileDialog.lReturn = 0;
  190.    fileDialog.lSRC = 0;
  191.    fileDialog.hMod = (HMODULE)0;
  192.    fileDialog.usDlgId = IDD_FILEOPEN;
  193.    fileDialog.x = 0;
  194.    fileDialog.y = 0;
  195.  
  196.    if (!WinLoadString(hab, (HMODULE)0, IDS_FILEOPENEXT, CCHMAXPATH,
  197.                      fileDialog.szFullFile))
  198.    {
  199.       MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, TRUE);
  200.       return;
  201.    }
  202.  
  203.    fileDialog.pszIType = NULL;
  204.    fileDialog.papszITypeList = NULL;
  205.    fileDialog.pszIDrive = NULL;
  206.    fileDialog.papszIDriveList = NULL;
  207.    fileDialog.sEAType = 0;
  208.    fileDialog.papszFQFilename = NULL;
  209.    fileDialog.ulFQFCount = 0;
  210.  
  211.    /*
  212.     *Call the standard file dialog to get the file
  213.     */
  214.    if (!WinFileDlg(HWND_DESKTOP, hwndMain, (PFILEDLG)&fileDialog))
  215.        return;
  216.  
  217.    /*
  218.     *  Upon sucessful return of a file, open it for reading
  219.     */
  220.  
  221.    if (fileDialog.lReturn == ID_OK)
  222.    {
  223.       if ( DosOpen(fileDialog.szFullFile, &hfile, &ulAction, 0, FILE_NORMAL,
  224.              FILE_OPEN, OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE, NULL))
  225.       {
  226.          MessageBox(hwndMain, IDMSG_CANNOTOPENINPUTFILE, MB_OK | MB_ERROR,
  227.             FALSE);
  228.          return;
  229.       }
  230.       /*
  231.        * Copy file name into file name buffer
  232.        */
  233.       strcpy(szFullPath, fileDialog.szFullFile);
  234.  
  235.       /*
  236.        * Get the length of the file
  237.        */
  238.  
  239.       if (DosQueryFileInfo(hfile, 1, (PVOID)&fileStatus, sizeof(FILESTATUS)))
  240.       {
  241.          MessageBox(hwndMain, IDMSG_CANNOTGETFILEINFO, MB_OK | MB_ERROR,
  242.               FALSE);
  243.          DosClose(hfile);
  244.          return;
  245.       }
  246.       /*
  247.        * Allocate a buffer for the file
  248.        */
  249.       if (DosAllocMem((PPVOID)&pvBuf, (ULONG)fileStatus.cbFileAlloc, fALLOC))
  250.       {
  251.          MessageBox(hwndMain, IDMSG_CANNOTALLOCATEMEMORY, MB_OK | MB_ERROR,
  252.               FALSE);
  253.  
  254.          DosClose(hfile);
  255.          return;
  256.       }
  257.       /*
  258.        * Read in the file
  259.        */
  260.       if (DosRead(hfile, pvBuf, fileStatus.cbFileAlloc, &ulAction))
  261.       {
  262.          MessageBox(hwndMain, IDMSG_CANNOTREADFILE, MB_OK | MB_ERROR,
  263.               FALSE);
  264.  
  265.          DosClose(hfile);
  266.          return;
  267.       }
  268.       /*
  269.        * Set the file into the MLE
  270.        */
  271.       WinSendMsg(hwndMLE, MLM_SETIMPORTEXPORT, MPFROMP((PBYTE)pvBuf),
  272.           MPFROMSHORT(fileStatus.cbFileAlloc));
  273.  
  274.       /*
  275.        * Import to MLE starting at offset 0
  276.        */
  277.  
  278.       iptOffset = 0;
  279.       WinSendMsg(hwndMLE, MLM_IMPORT, MPFROMP(&iptOffset),
  280.           MPFROMSHORT(fileStatus.cbFileAlloc));
  281.  
  282.       /*
  283.        * Reset the changed flag
  284.        */
  285.       WinSendMsg(hwndMLE, MLM_SETCHANGED, MPFROMSHORT((BOOL)FALSE), NULL);
  286.  
  287.       DosFreeMem(pvBuf);
  288.  
  289.       DosClose(hfile);
  290.  
  291.       UpdateTitleText(hwndMainFrame);
  292.    }
  293.    /*
  294.     *  This routine currently doesn't use the mp2 parameter but
  295.     *  it is referenced here to prevent an 'Unreferenced Parameter'
  296.     *  warning at compile time.
  297.     */
  298.    mp2;
  299. }   /* End of FileOpen()                                                */
  300.  
  301.  
  302. /*********************************************************************
  303.  *  Name: FileSave
  304.  *
  305.  *  Description : Processes the File menu's Save item.
  306.  *
  307.  *  Concepts : Gets file name for untitled files, opens file
  308.  *             writes file to disk, closes file.
  309.  *
  310.  *  API's : DosOpen
  311.  *          DosClose
  312.  *
  313.  *  Parameters : mp2 - Message parameter 2
  314.  *
  315.  *  Returns : VOID
  316.  *
  317.  ****************************************************************/
  318. VOID FileSave( MPARAM mp2)
  319. {
  320.    HFILE hfile;
  321.    ULONG ulAction;
  322.    /*
  323.     * If the file currently is untitled, we will need to get a file
  324.     * name from the user before we can open the file.  Getting a
  325.     * file name is normally done during the FileSaveAs operation
  326.     * so we will treat this save as a SaveAs and call FileSaveAs().
  327.     * If the file is titled, then we save the file.
  328.     *
  329.     * NOTE:  This routine will be called by FileSaveAs(), but only
  330.     *  after a valid file name has been obtained.  So, FileSaveAs()
  331.     *  will not be called again from this routine.
  332.     */
  333.    if (szFullPath[0] == 0)
  334.    {
  335.       FileSaveAs(mp2);
  336.       return;
  337.    }
  338.  
  339.    /*
  340.     * Open the file
  341.     */
  342.    if ( DosOpen(szFullPath, &hfile, &ulAction, 0, FILE_NORMAL, FILE_OPEN |
  343.        FILE_CREATE, OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYNONE, NULL))
  344.    {
  345.       MessageBox(hwndMain, IDMSG_CANNOTOPENOUTPUTFILE, MB_OK | MB_ERROR,
  346.            FALSE);
  347.       return;
  348.    }
  349.  
  350.    WriteFileToDisk(hfile);
  351.  
  352.    DosClose(hfile);
  353.    /*
  354.     *  This routine currently doesn't use the mp2 parameter but
  355.     *  it is referenced here to prevent an 'Unreferenced Parameter'
  356.     *  warning at compile time.
  357.     */
  358.    mp2;
  359.  
  360. }   /*  End of FileSave()                                               */
  361.  
  362. /*********************************************************************
  363.  *  Name: FileSaveAs
  364.  *
  365.  *  Description : Processes the File menu's Save As item.
  366.  *
  367.  *  Concepts : Called whenever Save As from the File menu is
  368.  *             selected.
  369.  *
  370.  *  API's : DosOpen
  371.  *          DosClose
  372.  *
  373.  *  Parameters : mp2 - Message parameter 2
  374.  *
  375.  *  Returns : VOID
  376.  *
  377.  ********************************************************************/
  378. VOID FileSaveAs( MPARAM mp2)
  379. {
  380.    HFILE hfile;
  381.    ULONG ulAction;
  382.    SHORT sMsgBoxResponce;
  383.  
  384.    /*
  385.     * Infinite loop until we break out of it
  386.     */
  387.    while(TRUE)
  388.    {
  389.    /*
  390.     * If no file name, then get a file name
  391.     */
  392.      if (!GetFileName())
  393.         return;
  394.    /*
  395.     * See if the file exists.  If it does, then confirm that the
  396.     * user wants to overwrite it.  If he doesn't, then get a new
  397.     * file name
  398.     */
  399.     if ( DosOpen(szFullPath,         /* file name from, GetFileName()    */
  400.                    &hfile,          /* handle of opened file            */
  401.                    &ulAction,
  402.                    0,
  403.                    FILE_NORMAL,
  404.                    FILE_OPEN | FILE_CREATE,
  405.                    OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYNONE,
  406.                    NULL))
  407.      {
  408.         MessageBox(hwndMain, IDMSG_CANNOTOPENOUTPUTFILE, MB_OK | MB_ERROR,
  409.              FALSE);
  410.         return;
  411.      }
  412.      else
  413.         DosClose(hfile);
  414.  
  415.      /*
  416.       * If file exists, ask if we want to overwrite it
  417.       */
  418.      if (ulAction == FILE_EXISTED)
  419.      {
  420.        sMsgBoxResponce = MessageBox(hwndMLE, IDMSG_OVERWRITEFILE, MB_QUERY |
  421.             MB_YESNOCANCEL, FALSE);
  422.  
  423.        if (sMsgBoxResponce == MBID_CANCEL)
  424.           return;
  425.  
  426.         if (sMsgBoxResponce == MBID_YES)
  427.            break;
  428.        /*
  429.         * If user selected no, repeat the sequence
  430.         */
  431.       }
  432.       else
  433.          break;                      /* file didn't exist               */
  434.    }                                 /* while(TRUE)                     */
  435.    UpdateTitleText(hwndMainFrame);
  436.    /*
  437.     * Now that we have a valid file name, save the file.  This is
  438.     * normally done under the File Save function so we can just
  439.     * call the FileSave() function here.  Note that FileSave() will
  440.     * not call FileSaveAs() back since there is a valid file name
  441.     */
  442.     FileSave(mp2);
  443.    /*
  444.     *  This routine currently doesn't use the mp2 parameter but
  445.     *  it is referenced here to prevent an 'Unreferenced Parameter'
  446.     *  warning at compile time.
  447.     */
  448.    mp2;
  449. }       /* End of FileSaveAs()                                          */
  450.  
  451. /****************************************************************
  452.  *  Name: WriteFileToDisk
  453.  *
  454.  *  Description : Writes the current file to the file in szFileName
  455.  *
  456.  *  Concepts : Called from FileSave and FileSaveAs when a file is
  457.  *             to be saved to disk.  Routine uses the file handle
  458.  *             specified and gets the text from the MLE and
  459.  *             writes the text to the file.
  460.  *
  461.  *  API's : WinSendmsg
  462.  *          DosAllocMem
  463.  *          DosWrite
  464.  *          DosFreeMem
  465.  *
  466.  *  Parameters : hfile - handle of file to save
  467.  *
  468.  *  Returns: Void
  469.  *
  470.  ****************************************************************/
  471. VOID WriteFileToDisk( HFILE hfile)
  472. {
  473.    ULONG ulWrite;
  474.    PVOID pvBuf;
  475.    ULONG ulFileLen;
  476.    ULONG ulOffset;             /* offset in buffer                    */
  477.    ULONG cbExport;             /* # of bytes to export from the MLE   */
  478.  
  479.  
  480.    /*
  481.     * Get the length of the file
  482.     */
  483.    ulFileLen = (ULONG)WinSendMsg(hwndMLE, MLM_QUERYTEXTLENGTH, NULL, NULL);
  484.    if (!ulFileLen)
  485.        return;
  486.  
  487.    /*
  488.     * Allocate a buffer for the file
  489.     */
  490.    if (DosAllocMem((PPVOID) &pvBuf, ulFileLen, fALLOC))
  491.    {
  492.       MessageBox(hwndMLE, IDMSG_CANNOTALLOCATEMEMORY, MB_OK | MB_ERROR,
  493.            FALSE);
  494.       return;
  495.    }
  496.  
  497.    /*
  498.     * Get the file from the MLE
  499.     */
  500.    cbExport = ulFileLen;
  501.    WinSendMsg(hwndMLE, MLM_SETIMPORTEXPORT, MPFROMP((PBYTE)pvBuf),
  502.         MPFROMLONG(cbExport));
  503.  
  504.    /*
  505.    * Export MLE starting at offset 0
  506.    */
  507.    ulOffset = 0;
  508.    WinSendMsg(hwndMLE, MLM_EXPORT, MPFROMP(&ulOffset), MPFROMLONG(&cbExport));
  509.  
  510.    /*
  511.     * Write the file
  512.     */
  513.    if (DosWrite(hfile, pvBuf, ulFileLen, &ulWrite))
  514.    {
  515.       MessageBox(hwndMLE, IDMSG_CANNOTWRITETOFILE, MB_OK | MB_ERROR, FALSE);
  516.       return;
  517.    }
  518.  
  519.    /*
  520.     * Reset the changed flag
  521.     */
  522.    WinSendMsg(hwndMLE, MLM_SETCHANGED, MPFROMSHORT((BOOL)FALSE), NULL);
  523.  
  524.    DosFreeMem(pvBuf);
  525. }          /*   End of WriteFileToDisk()                                */
  526.  
  527. /*********************************************************************
  528.  *  Name : GetFileName
  529.  *
  530.  *  Description : Gets the name of the save file.
  531.  *
  532.  *  Concepts : Called when the user is needs to supply a name
  533.  *             for the file to be saved.  Calls the standard
  534.  *             file open dialog to get the file name.
  535.  *
  536.  *  API's : WinLoadString
  537.  *          WinFileDlg
  538.  *
  539.  *  Parameters : None
  540.  *
  541.  *  Returns: Void
  542.  *
  543.  ****************************************************************/
  544. BOOL GetFileName(VOID)
  545. {
  546.     FILEDLG fileDialog;
  547.     CHAR szTitle[MESSAGELEN], szButton[MESSAGELEN];
  548.  
  549.     if (!WinLoadString(hab, (HMODULE)0, IDS_SAVEDLGTITLE, MESSAGELEN, szTitle))
  550.     {
  551.        MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, TRUE);
  552.        return FALSE;
  553.     }
  554.  
  555.     if (!WinLoadString(hab,(HMODULE)0, IDS_SAVEDLGBUTTON, MESSAGELEN, szButton))
  556.     {
  557.        MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, TRUE);
  558.        return FALSE;
  559.     }
  560.  
  561.     fileDialog.cbSize = sizeof(FILEDLG);       /* Size of FILEDLG structure. */
  562.     fileDialog.fl = FDS_HELPBUTTON |   /* FDS_ flags. Alter behavior of dlg. */
  563.                      FDS_CENTER | FDS_SAVEAS_DIALOG | FDS_ENABLEFILELB;
  564.     fileDialog.ulUser = 0;                            /* User defined field. */
  565.     fileDialog.lReturn = 0;            /* Result code from dialog dismissal. */
  566.     fileDialog.lSRC = 0;                              /* System return code. */
  567.     fileDialog.pszTitle = szTitle;        /* String to display in title bar. */
  568.     fileDialog.pszOKButton = szButton;    /* String to display in OK button. */
  569.                                        /* Entry point to custom dialog proc. */
  570.     fileDialog.pfnDlgProc = (PFNWP)OpenSaveFilterDlgProc;
  571.     fileDialog.pszIType = NULL;         /* Pointer to string containing      */
  572.                                         /*   initial EA type filter. Type    */
  573.                                         /*   does not have to exist in list. */
  574.     fileDialog.papszITypeList = NULL;   /* Pointer to table of pointers that */
  575.                                         /*   point to null terminated Type   */
  576.                                         /*   strings. End of table is marked */
  577.                                         /*   by a NULL pointer.              */
  578.     fileDialog.pszIDrive = NULL;          /* Pointer to string containing    */
  579.                                           /*   initial drive. Drive does not */
  580.                                           /*   have to exist in drive list.  */
  581.     fileDialog.papszIDriveList = NULL;  /* Pointer to table of pointers that */
  582.                                         /*   point to null terminated Drive  */
  583.                                         /*   strings. End of table is marked */
  584.                                                        /* by a NULL pointer. */
  585.     fileDialog.hMod = (HMODULE)0;            /* Custom File Dialog template. */
  586.     strcpy(fileDialog.szFullFile, szFullPath); /* Initial or selected fully  */
  587.                                                /*   qualified path and file. */
  588.     fileDialog.papszFQFilename = NULL;  /* Pointer to table of pointers that */
  589.                                         /*   point to null terminated FQFname*/
  590.                                         /*   strings. End of table is marked */
  591.                                         /*   by a NULL pointer.              */
  592.     fileDialog.ulFQFCount = 0;                   /* Number of files selected */
  593.     fileDialog.usDlgId = IDD_FILESAVE;                  /* Custom dialog id. */
  594.     fileDialog.x = 0;                          /* X coordinate of the dialog */
  595.     fileDialog.y = 0;                          /* Y coordinate of the dialog */
  596.     fileDialog.sEAType = 0;                      /* Selected file's EA Type. */
  597.  
  598.  
  599.     /*
  600.      * Get the file
  601.      */
  602.     if (!WinFileDlg(HWND_DESKTOP, hwndMLE, (PFILEDLG)&fileDialog))
  603.         return FALSE;
  604.  
  605.     if (fileDialog.lReturn != ID_OK)
  606.         return FALSE;
  607.  
  608.     /*
  609.      * Copy file name and path returned into buffers
  610.      */
  611.     strcpy(szFullPath, fileDialog.szFullFile);
  612.  
  613.     return TRUE;
  614.  
  615. }   /* End of GetFileName() */
  616.  
  617.  
  618. /*********************************************************************
  619.  *  Name : UpdateTitleText
  620.  *
  621.  *  Description : Updates the text in the main window's title bar
  622.  *                to display the app name, followed by the
  623.  *                separator, followed by the file name
  624.  *
  625.  *  Concepts : Called at init time and when the text file is
  626.  *             changed gets the program name, appends the
  627.  *             separator, and appends the file name.
  628.  *
  629.  *  API's : WinQueryTaskTitle
  630.  *          WinLoadString
  631.  *          WinSetWindowText
  632.  *
  633.  *  Parameters : hwnd - handle of the main window
  634.  *
  635.  *  Returns : Void
  636.  *
  637.  ****************************************************************/
  638. VOID UpdateTitleText(HWND hwnd)
  639. {
  640. /*  CHAR szBuf[MAXNAMEL]; */
  641.     CHAR szBuf[CCHMAXPATH + MAXNAMEL];
  642.     CHAR szSeparator[TITLESEPARATORLEN+1];
  643.     PSZ pszTitle;
  644.  
  645.     WinQueryTaskTitle(0, szBuf, MAXNAMEL);
  646.  
  647.     WinLoadString(hab, (HMODULE)0, IDS_TITLEBARSEPARATOR, TITLESEPARATORLEN,
  648.          szSeparator);
  649.  
  650.     strcat(szBuf, szSeparator);
  651.  
  652.     if (szFullPath[0] == '\0')
  653.        pszTitle = szUntitled;
  654.     else
  655.        pszTitle = szFullPath;
  656.  
  657.     strcat(szBuf, pszTitle);
  658.  
  659.     /***********************************************************************
  660.     * If title is longer that maximum allowable, show the most significant *
  661.     * portion of it (filename end of path).                                *
  662.     ***********************************************************************/
  663.     if (strlen(szBuf) + 1 > MAXNAMEL)
  664.        pszTitle = &szBuf[strlen(szBuf) - MAXNAMEL + 1];
  665.     else
  666.        pszTitle = szBuf;
  667.  
  668.     WinSetWindowText(WinWindowFromID(hwnd,(USHORT) FID_TITLEBAR), pszTitle);
  669.  
  670. }          /*  End of UpdateTitleText()                                      */
  671.  
  672.  
  673. /***********************************************************
  674.  * Name         : OpenSaveFilterProc
  675.  *
  676.  * Description  : Procedure to handle wm_help messages for
  677.  *                the file open/save dialog.
  678.  *
  679.  * Concepts     : This routine handles the WM_HELP messages for
  680.  *                the dialog boxs created with the WinFileDlg
  681.  *                Checks the flags used on the call to determine
  682.  *                the correct help panel to display.
  683.  *
  684.  * API's        : WinQueryWIndowULong
  685.  *                WinSendMessage
  686.  *
  687.  * Parameters   : hwnd - Window handle to which message is addressed
  688.  *                msg - Message type
  689.  *                mp1 - First message parameter
  690.  *                mp2 - Second message parameter
  691.  *
  692.  *  Returns : Dependent upon message sent
  693.  **************************************************************/
  694.  
  695. MRESULT APIENTRY OpenSaveFilterDlgProc(HWND hwnd, USHORT msg,
  696.                                        MPARAM mp1, MPARAM mp2)
  697. {
  698.    if(msg == WM_HELP)
  699.    {
  700.       PFILEDLG pOpenSaveFileDlgStruct;
  701.       /*
  702.        * Get a pointer to the file dialog structure.
  703.        */
  704.       pOpenSaveFileDlgStruct = (PFILEDLG) WinQueryWindowULong(hwnd, QWL_USER);
  705.  
  706.       /*
  707.        * If this is an the File Open dialog, display the file open help
  708.        * panel.
  709.        */
  710.       if (pOpenSaveFileDlgStruct->fl & FDS_OPEN_DIALOG)
  711.       {
  712.          DisplayHelpPanel(PANEL_FILEOPEN);
  713.          return (MRESULT)FALSE ;
  714.       }
  715.  
  716.       /*
  717.        * If this is an the File Save or Save As dialog, display the file
  718.        * Save As help panel.
  719.        */
  720.  
  721.       if (pOpenSaveFileDlgStruct->fl & FDS_SAVEAS_DIALOG)
  722.       {
  723.          DisplayHelpPanel(PANEL_FILESAVEAS);
  724.          return (MRESULT)FALSE ;
  725.       }
  726.    }
  727.    return WinDefFileDlgProc( hwnd, msg, mp1, mp2 );
  728. }                                       /* End of OpenSaveFilterDlgProc  */
  729.  
  730.