home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / d / d020_1_4 / 5.ddi / MULTIPAD / MPFILE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-01  |  15.2 KB  |  478 lines
  1. /***************************************************************************
  2.  *                                                                         *
  3.  *  MODULE    : MpFile.c                                                   *
  4.  *                                                                         *
  5.  *  PURPOSE   : Contains the code for File I/O for Multipad.               *
  6.  *                                                                         *
  7.  *  FUNCTIONS : AlreadyOpen   - Determines if a file is already open.      *
  8.  *                                                                         *
  9.  *              AddFile       - Creates a new MDI window and, if specified,*
  10.  *                loads a file into it.                      *
  11.  *                                                                         *
  12.  *              LoadFile      - Loads a file into a MDI window.            *
  13.  *                                                                         *
  14.  *              ReadFile      - Calls File/Open dialog and appropriately   *
  15.  *                              responds to the user's input.              *
  16.  *                                                                         *
  17.  *              SaveFile      - Saves the contents of a MDI window's edit  *
  18.  *                              control to a file.                         *
  19.  *                                                                         *
  20.  *              SetSaveFrom   - Formats the "Save 'file' to" string.       *
  21.  *                                                                         *
  22.  *              SaveAsDlgProc - Dialog function for the File/SaveAs dialog.*
  23.  *                                                                         *
  24.  *              ChangeFile    - Calls File/SaveAs dialog.                  *
  25.  *                                                                         *
  26.  ***************************************************************************/
  27. #include "multipad.h"
  28.  
  29. VOID NEAR PASCAL GetFileName(PSTR);
  30. int FAR PASCAL DialogBoxParam(HANDLE,LPSTR,HWND,FARPROC,LONG);
  31.  
  32. OFSTRUCT    of;
  33. /****************************************************************************
  34.  *                                                                          *
  35.  *  FUNCTION   : AlreadyOpen(szFile)                                        *
  36.  *                                                                          *
  37.  *  PURPOSE    : Checks to see if the file described by the string pointed  *
  38.  *               to by 'szFile' is already open.                            *
  39.  *                                                                          *
  40.  *  RETURNS    : a handle to the described file's window if that file is    *
  41.  *               already open;  NULL otherwise.                             *
  42.  *                                                                          *
  43.  ****************************************************************************/
  44.  
  45. HWND AlreadyOpen(char *szFile)
  46. {
  47.     int     iDiff;
  48.     HWND    hwndCheck;
  49.     char    szChild[64];
  50.     LPSTR   lpChild, lpFile;
  51.     int     wFileTemp;
  52.  
  53.     /* Open the file with the OF_PARSE flag to obtain the fully qualified
  54.      * pathname in the OFSTRUCT structure.
  55.      */
  56.     wFileTemp = OpenFile ((LPSTR)szFile, (LPOFSTRUCT)&of, OF_PARSE);
  57.     if (! wFileTemp)
  58.     return(NULL);
  59.     _lclose (wFileTemp);
  60.  
  61.     /* Check each MDI child window in Multipad */
  62.     for (   hwndCheck = GetWindow(hwndMDIClient, GW_CHILD);
  63.         hwndCheck;
  64.         hwndCheck = GetWindow(hwndCheck, GW_HWNDNEXT)   ) {
  65.     /* Initialization  for comparison */
  66.     lpChild = szChild;
  67.     lpFile = AnsiUpper((LPSTR) of.szPathName);
  68.     iDiff = 0;
  69.  
  70.     /* Skip icon title windows */
  71.     if (GetWindow(hwndCheck, GW_OWNER))
  72.         continue;
  73.  
  74.     /* Get current child window's name */
  75.     GetWindowText(hwndCheck, lpChild, 64);
  76.  
  77.     /* Compare window name with given name */
  78.     while ((*lpChild) && (*lpFile) && (!iDiff)){
  79.         if (*lpChild++ != *lpFile++)
  80.         iDiff = 1;
  81.     }
  82.  
  83.     /* If the two names matched, the file is already   */
  84.     /* open -- return handle to matching child window. */
  85.     if (!iDiff)
  86.         return(hwndCheck);
  87.     }
  88.     /* No match found -- file is not open -- return NULL handle */
  89.     return(NULL);
  90. }
  91.  
  92. /****************************************************************************
  93.  *                                        *
  94.  *  FUNCTION   : AddFile (lpName)                        *
  95.  *                                        *
  96.  *  PURPOSE    : Creates a new MDI window. If the lpName parameter is not   *
  97.  *         NULL, it loads a file into the window.             *
  98.  *                                        *
  99.  *  RETURNS    : HWND  - A handle to the new window.                *
  100.  *                                        *
  101.  ****************************************************************************/
  102.  
  103. HWND FAR PASCAL AddFile(pName)
  104. char * pName;
  105. {
  106.     HWND hwnd;
  107.  
  108.     char        sz[160];
  109.     MDICREATESTRUCT mcs;
  110.  
  111.     if (!pName) {
  112.     /* The pName parameter is NULL -- load the "Untitled" string from */
  113.     /* STRINGTABLE and set the title field of the MDI CreateStruct.    */
  114.     LoadString (hInst, IDS_UNTITLED, sz, sizeof(sz));
  115.     mcs.szTitle = (LPSTR)sz;
  116.     }
  117.     else
  118.     /* Title the window with the fully qualified pathname obtained by
  119.      * calling OpenFile() with the OF_PARSE flag (in function
  120.      * AlreadyOpen(), which is called before AddFile().
  121.      */
  122.     mcs.szTitle = of.szPathName;
  123.  
  124.     mcs.szClass = szChild;
  125.     mcs.hOwner    = hInst;
  126.  
  127.     /* Use the default size for the window */
  128.     mcs.x = mcs.cx = CW_USEDEFAULT;
  129.     mcs.y = mcs.cy = CW_USEDEFAULT;
  130.  
  131.     /* Set the style DWORD of the window to default */
  132.     mcs.style = styleDefault;
  133.  
  134.     /* tell the MDI Client to create the child */
  135.     hwnd = (WORD)SendMessage (hwndMDIClient,
  136.                   WM_MDICREATE,
  137.                   0,
  138.                   (LONG)(LPMDICREATESTRUCT)&mcs);
  139.  
  140.     /* Did we get a file? Read it into the window */
  141.     if (pName){
  142.     if (!LoadFile(hwnd, pName)){
  143.         /* File couldn't be loaded -- close window */
  144.         SendMessage(hwndMDIClient, WM_MDIDESTROY, (WORD) hwnd, 0L);
  145.     }
  146.     }
  147.  
  148.     return hwnd;
  149. }
  150.  
  151. /****************************************************************************
  152.  *                                        *
  153.  *  FUNCTION   : LoadFile (lpName)                        *
  154.  *                                        *
  155.  *  PURPOSE    : Given the handle to a MDI window and a filename, reads the *
  156.  *         file into the window's edit control child.                 *
  157.  *                                        *
  158.  *  RETURNS    : TRUE  - If file is sucessfully loaded.             *
  159.  *         FALSE - Otherwise.                        *
  160.  *                                        *
  161.  ****************************************************************************/
  162.  
  163. int FAR PASCAL LoadFile (hwnd, pName)
  164. HWND hwnd;
  165. char * pName;
  166. {
  167.     WORD   wLength;
  168.     HANDLE hT;
  169.     LPSTR  lpB;
  170.     HWND   hwndEdit;
  171.     int    fh;
  172.  
  173.     hwndEdit = GetWindowWord (hwnd, GWW_HWNDEDIT);
  174.  
  175.     /* The file has a title, so reset the UNTITLED flag. */
  176.     SetWindowWord(hwnd, GWW_UNTITLED, FALSE);
  177.  
  178.     fh = _lopen (pName, 0);
  179.  
  180.     /* Make sure file has been opened correctly */
  181.     if ( fh < 0 )
  182.     goto error;
  183.  
  184.     /* Find the length of the file */
  185.     wLength = (WORD)_llseek (fh, 0L, 2);
  186.     _llseek (fh, 0L, 0);
  187.  
  188.     /* Attempt to reallocate the edit control's buffer to the file size */
  189.     hT = (HANDLE)SendMessage (hwndEdit, EM_GETHANDLE, 0, 0L);
  190.     if (LocalReAlloc(hT, wLength+1, LHND) == NULL) {
  191.     /* Couldn't reallocate to new size -- error */
  192.     _lclose (fh);
  193.     goto error;
  194.     }
  195.  
  196.     /* read the file into the buffer */
  197.     if (wLength != _lread (fh, (lpB = (LPSTR)LocalLock (hT)), wLength))
  198.     MPError (hwnd, MB_OK|MB_ICONHAND, IDS_CANTREAD, (LPSTR)pName);
  199.  
  200.     /* Zero terminate the edit buffer */
  201.     lpB[wLength] = 0;
  202.     LocalUnlock (hT);
  203.  
  204.     SendMessage (hwndEdit, EM_SETHANDLE, hT, 0L);
  205.     _lclose (fh);
  206.  
  207.     return TRUE;
  208.  
  209. error:
  210.     /* Report the error and quit */
  211.     MPError(hwnd, MB_OK | MB_ICONHAND, IDS_CANTOPEN, (LPSTR)pName);
  212.     return FALSE;
  213. }
  214.  
  215. /****************************************************************************
  216.  *                                                                          *
  217.  *  FUNCTION   : ReadFile(hwnd)                                             *
  218.  *                                                                          *
  219.  *  PURPOSE    : Called in response to a File/Open menu selection. It asks  *
  220.  *               the user for a file name and responds appropriately.       *
  221.  *                                                                          *
  222.  ****************************************************************************/
  223.  
  224. VOID FAR PASCAL ReadFile(HWND hwnd)
  225. {
  226.     char    szFile[128];
  227.     HWND    hwndFile;
  228.  
  229.     GetFileName (szFile);
  230.  
  231.     /* If the result is not the empty string -- take appropriate action */
  232.     if (*szFile) {
  233.     /* Is file already open?? */
  234.     if (hwndFile = AlreadyOpen(szFile)) {
  235.         /* Yes -- bring the file's window to the top */
  236.         BringWindowToTop(hwndFile);
  237.     }
  238.     else {
  239.         /* No -- make a new window and load file into it */
  240.         AddFile(szFile);
  241.     }
  242.     }
  243. }
  244.  
  245. /****************************************************************************
  246.  *                                        *
  247.  *  FUNCTION   : SaveFile (hwnd)                        *
  248.  *                                        *
  249.  *  PURPOSE    : Saves contents of current edit control to disk.        *
  250.  *                                        *
  251.  ****************************************************************************/
  252.  
  253. VOID FAR PASCAL SaveFile( hwnd )
  254.  
  255. HWND hwnd;
  256. {
  257.     HANDLE   hT;
  258.     LPSTR    lpT;
  259.     char     szFile[128];
  260.     WORD     cch;
  261.     int      fh;
  262.     OFSTRUCT of;
  263.     HWND     hwndEdit;
  264.  
  265.     PSTR     pch;
  266.  
  267.     hwndEdit = GetWindowWord ( hwnd, GWW_HWNDEDIT);
  268.     GetWindowText (hwnd, szFile, sizeof(szFile));
  269.  
  270.     /* If there is no extension (control is 'Untitled') add .TXT as extension */
  271.     for (cch = FALSE, lpT = szFile; *lpT; lpT++)
  272.     switch (*lpT){
  273.         case '.':
  274.          cch = TRUE;
  275.          break;
  276.  
  277.         case '\\':
  278.         case ':' :
  279.          cch = FALSE;
  280.          break;
  281.     }
  282.     if (!cch)
  283.     LoadString (hInst, IDS_ADDEXT, lpT, lpT - (LPSTR)szFile);
  284.  
  285.     fh = OpenFile (szFile, &of, OF_WRITE | OF_CREATE);
  286.  
  287.     /* If file could not be opened, quit */
  288.     if (fh < 0){
  289.     MPError (hwnd, MB_OK | MB_ICONHAND, IDS_CANTCREATE, (LPSTR)szFile);
  290.     return;
  291.     }
  292.  
  293.     /* Find out the length of the text in the edit control */
  294.     cch = GetWindowTextLength (hwndEdit);
  295.  
  296.     /* Obtain a handle to the text buffer */
  297.     hT    = (HANDLE)SendMessage (hwndEdit, EM_GETHANDLE, 0, 0L);
  298.     lpT = (LPSTR)LocalLock (hT);
  299.  
  300.     /* Write out the contents of the buffer to the file. */
  301.     if (cch != _lwrite (fh, lpT, cch))
  302.     MPError (hwnd, MB_OK | MB_ICONHAND, IDS_CANTWRITE, (LPSTR)szFile);
  303.  
  304.     /* Clean up */
  305.     LocalUnlock (hT);
  306.     SendMessage (hwndEdit, EM_SETHANDLE, hT, 0L);
  307.  
  308.     _lclose (fh);
  309.  
  310.     return;
  311. }
  312.  
  313. /****************************************************************************
  314.  *                                        *
  315.  *  FUNCTION   : SetSaveFrom ()                         *
  316.  *                                        *
  317.  *  PURPOSE    : Formats the "Save 'file' to .." string.            *
  318.  *                                        *
  319.  ****************************************************************************/
  320.  
  321. VOID NEAR PASCAL SetSaveFrom ( hwnd , psz)
  322. HWND hwnd;
  323. PSTR psz;
  324. {
  325.     char szFmt[32];
  326.     char szText[160];
  327.  
  328.     /* The text string in the .RC file contains the format string... */
  329.     GetDlgItemText( hwnd, IDD_SAVEFROM, szFmt, sizeof(szFmt));
  330.  
  331.     /* NOTE: this (LPSTR) cast MUST be here... wsprintf() is a cdecl
  332.      * (C calling conventions) function with varying args... there is
  333.      * no way for the compiler to know that all strings must be LPSTR's
  334.      * and do the conversion, so we have to be careful about wsprintf()'s.
  335.      */
  336.     wsprintf ( szText, szFmt, (LPSTR)psz);
  337.  
  338.     /* set the text in the static control */
  339.     SetDlgItemText (hwnd, IDD_SAVEFROM, szText);
  340. }
  341.  
  342. /****************************************************************************
  343.  *                                        *
  344.  *  FUNCTION   : SaveAsDlgProc(hwnd, message, wParam, lParam)            *
  345.  *                                        *
  346.  *  PURPOSE    : Dialog function File/SaveAs. It waits for a filename, and  *
  347.  *         then calls SaveFile or cancels the operation.            *
  348.  *                                        *
  349.  ****************************************************************************/
  350.  
  351. BOOL FAR PASCAL SaveAsDlgProc( hwnd, message, wParam, lParam)
  352. HWND hwnd;
  353. WORD message;
  354. WORD wParam;
  355. LONG lParam;
  356. {
  357.     char   sz[64];
  358.     char   *pch;
  359.     BOOL   fExt;
  360.     HWND   hwndSave;
  361.  
  362.     switch (message){
  363.  
  364.     case WM_INITDIALOG:
  365.  
  366.         /* Identify the window whose contents we're saving */
  367.         hwndSave = LOWORD (lParam);
  368.  
  369.         /* Set it's name in the property list */
  370.         SetProp (hwnd, PROP_FILENAME, hwndSave);
  371.  
  372.         GetWindowText (hwndSave, sz, sizeof(sz));
  373.  
  374.         /* Set the save from string... */
  375.         SetSaveFrom (hwnd,sz);
  376.  
  377.         /* Generate a filename complete with extension */
  378.         AnsiUpper (sz);
  379.         for (fExt = FALSE, pch = sz; *pch; pch++)
  380.         if (*pch == '.')
  381.             fExt = TRUE;
  382.         else if (*pch == '\\')
  383.             fExt = FALSE;
  384.         if (!fExt)
  385.         LoadString (hInst, IDS_ADDEXT, (LPSTR)pch, pch - sz);
  386.  
  387.         /* Display the filename in the edit control */
  388.         SetDlgItemText (hwnd, IDD_SAVETO, sz);
  389.  
  390.         /* Select the entire range of text */
  391.         SendDlgItemMessage (hwnd, IDD_SAVETO, EM_SETSEL, 0, MAKELONG (0,100));
  392.  
  393.         DlgDirList (hwnd, "*.*", IDD_DIRS, IDD_PATH, ATTR_DIRS);
  394.  
  395.         /* enable OK butto iff edit control is nonempty */
  396.         if (!*sz)
  397.         EnableWindow (GetDlgItem (hwnd, IDOK), FALSE);
  398.         break;
  399.  
  400.     case WM_COMMAND:
  401.         switch (wParam){
  402.         case IDCANCEL:
  403.             /* Abort operation */
  404.             EndDialog(hwnd,1);
  405.             break;
  406.  
  407.         case IDOK:
  408.            /*  Just change the title of the MDI child. The calling
  409.             *  function of ChangeFile(), which uses the title text
  410.             *  for the filename, will do the actual save.
  411.             */
  412.             hwndSave = GetProp (hwnd, PROP_FILENAME);
  413.             GetDlgItemText (hwnd, IDD_SAVETO, sz, sizeof(sz));
  414.             AnsiUpper ((LPSTR)sz);
  415.             SetWindowText (hwndSave, sz);
  416.             EndDialog (hwnd, 0);
  417.             break;
  418.  
  419.         case IDD_SAVETO:
  420.            /* If the edit control changes, check to see if its empty.
  421.             * enable OK if it contains something
  422.             */
  423.             if (HIWORD (lParam) != EN_CHANGE)
  424.             return FALSE;
  425.             EnableWindow (GetDlgItem (hwnd, IDOK),
  426.             (WORD) SendDlgItemMessage (hwnd,
  427.                            IDD_SAVETO,
  428.                            WM_GETTEXTLENGTH,
  429.                            0,
  430.                            0L));
  431.             break;
  432.  
  433.         case IDD_DIRS:
  434.             if (HIWORD(lParam)==LBN_DBLCLK){
  435.             char szT[64];
  436.  
  437.             DlgDirSelect ( hwnd, szT, IDD_DIRS);
  438.             lstrcat ( szT, "*.*");
  439.             DlgDirList (hwnd, szT, IDD_DIRS, IDD_PATH, ATTR_DIRS);
  440.             break;
  441.             }
  442.             return FALSE;
  443.  
  444.         default:
  445.             return FALSE;
  446.         }
  447.  
  448.     default:
  449.         return FALSE;
  450.     }
  451.     return TRUE;
  452. }
  453.  
  454. /****************************************************************************
  455.  *                                        *
  456.  *  FUNCTION   : ChangeFile (hwnd)                        *
  457.  *                                        *
  458.  *  PURPOSE    : Invokes the File/SaveAs dialog.                *
  459.  *                                        *
  460.  *  RETURNS    : TRUE  - if user selected OK or NO.                *
  461.  *         FALSE - otherwise.                        *
  462.  *                                        *
  463.  ****************************************************************************/
  464.  
  465. BOOL FAR PASCAL ChangeFile (hwnd)
  466. HWND hwnd;
  467. {
  468.     FARPROC lpfn;
  469.     int     i;
  470.  
  471.     lpfn = MakeProcInstance (SaveAsDlgProc, hInst);
  472.     i = DialogBoxParam (hInst, IDD_SAVEAS, hwnd, lpfn, MAKELONG (hwnd, 0));
  473.     FreeProcInstance (lpfn);
  474.     if (!i)
  475.     SetWindowWord (hwnd, GWW_UNTITLED, 0);
  476.     return !i;
  477. }
  478.