home *** CD-ROM | disk | FTP | other *** search
/ Black Box 4 / BlackBox.cdr / w3_prog / zap.arj / Z1.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-12  |  16.1 KB  |  553 lines
  1. /***********************************************************************
  2. * Zap                                                                  *
  3. * ===                                                                  *
  4. *                                                                      *
  5. * Windows 3 Text Editor                                                *
  6. *                                                                      *
  7. * This programme uses the Windows edit control as an editting engine,  *
  8. * and hence is limited to 32K - 1 characters.  The edit control is     *
  9. * sub-classed to provide additional functionality.                     *
  10. *                                                                      *
  11. * Main module                                                          *
  12. *   int  PASCAL WinMain(HANDLE, HANDLE, LPSTR, int);                   *
  13. *   BOOL InitApplication(HANDLE);                                      *
  14. *   BOOL InitInstance(HANDLE, int);                                    *
  15. *   long FAR PASCAL MainWndProc(HWND, unsigned, WORD, LONG);           *
  16. *   BOOL FAR PASCAL AboutProc(HWND, unsigned, WORD, LONG);             *
  17. *   void Comment(char *);                                              *
  18. *                                                                      *
  19. * This programme was developed using Microsoft C6.0 and the Microsoft  *
  20. * SDK, however any ANSI C could be used if suitable libraries and the  *
  21. * Windows header are available.                                        *
  22. ***********************************************************************/
  23.  
  24. #include <windows.h>
  25. #include <commdlg.h>
  26. #include <string.h>
  27. #include "zap.h"
  28. #include "zapdlg.h"
  29.  
  30.  
  31. /***********************************************************************
  32. * Global variables                                                     *
  33. ***********************************************************************/
  34.  
  35. /*** System variables */
  36.  
  37. HANDLE hInst;
  38. HWND   hMainWnd;
  39.  
  40. /*** Edit windows */
  41.  
  42. EDIT_WND EditWnd[MAX_FILES];
  43. int NumFiles, CurrentFile;
  44.  
  45. /*** Pointer to sub-classing function */
  46.  
  47. FARPROC lpNewEditWndProc;
  48.  
  49. /*** Buffer for manipulating window contents */
  50.  
  51. HANDLE hTransBuf;
  52. LPSTR  TransBuf;
  53.  
  54. /*** Dialog box variables */
  55.  
  56. OPENFILENAME OpenFileInfo;
  57. char FilterSpec[128] = "All Files  (*.*)\0*.*\0"
  58.                        "Text Files (*.TXT)\0*.TXT\0"
  59.                        "C programs (*.C)\0*.C\0";
  60.  
  61. char FileName[MAX_DOS_NAME], FileTitle[MAX_DOS_NAME];
  62.  
  63. /*** Miscellaneous variables */
  64.  
  65. int  CharWd, CharDp;
  66.  
  67. char WorkStr[WORK_STR_LEN];
  68.  
  69.  
  70. /***********************************************************************
  71. * Entry point from Windows                                             *
  72. ***********************************************************************/
  73.  
  74. int PASCAL WinMain(HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow )
  75. { WORD i, j;
  76.   HDC hDC;
  77.   MSG msg;
  78.  
  79. /*** Initialise application */
  80.  
  81.   if (!hPrevInstance)
  82.   { if (!InitApplication(hInstance))
  83.     { Comment("System error: Cannot register window class");
  84.       return(FALSE);
  85.     }
  86.   }
  87.  
  88.   if (!InitInstance(hInstance, nCmdShow)) return(FALSE);
  89.  
  90. /*** If a file name was given open it */
  91.  
  92.   if (lpszCmdLine[0] != '\0')
  93.   { for (i = 0; lpszCmdLine[i] == ' '; i++);
  94.     for (j = 0; lpszCmdLine[i] != ' ' && lpszCmdLine[i] != '\0'; j++, i++)
  95.       FileName[j] = lpszCmdLine[i];
  96.     FileName[j] = '\0';
  97.  
  98.     if ((j = _lopen(FileName, OF_READ)) == -1)
  99.     { sprintf(WorkStr, "Cannot open file \"%s\"", FileName);
  100.       Comment(WorkStr);
  101.     }
  102.     else
  103.     { if ((i = _lread(j, TransBuf, TRANS_BUF_SIZE - 1)) == TRANS_BUF_SIZE - 1)
  104.         Comment("Warning: file is too big and has been truncated");
  105.       TransBuf[i] = '\0';
  106.  
  107.       _lclose(j);
  108.  
  109.       SetWindowText(EditWnd[0].hwnd, TransBuf);
  110.       strcpy(EditWnd[0].name, FileName);
  111.  
  112.       hDC = GetDC(hMainWnd);
  113.       RedrawStatusBar(hDC, 0);
  114.       ReleaseDC(hMainWnd, hDC);
  115.     }
  116.   }
  117.  
  118. /*** Enter message loop */
  119.  
  120.   while (GetMessage(&msg, NULL, NULL, NULL))
  121.   { TranslateMessage(&msg);
  122.     DispatchMessage(&msg);
  123.   }
  124.  
  125.   return (msg.wParam);
  126. }
  127.  
  128.  
  129. /***********************************************************************
  130. * Application initialisation routine                                   *
  131. * Creates window class for application                                 *
  132. ***********************************************************************/
  133.  
  134. BOOL InitApplication(HANDLE hInstance)
  135. { WNDCLASS  wc;
  136.  
  137.   wc.style         = CS_OWNDC;
  138.   wc.lpfnWndProc   = MainWndProc;
  139.   wc.cbClsExtra    = 0;
  140.   wc.cbWndExtra    = 0;
  141.   wc.hInstance     = hInstance;
  142.   wc.hIcon         = LoadIcon(hInstance, "ZapIcon");
  143.   wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
  144.   wc.hbrBackground = GetStockObject(WHITE_BRUSH);
  145.   wc.lpszMenuName  = "ZapMenu";
  146.   wc.lpszClassName = "ZapWClass";
  147.  
  148.   return (RegisterClass(&wc));
  149. } 
  150.  
  151.  
  152. /****************************************************************************
  153. * Instance initialisation routine
  154. ****************************************************************************/
  155.  
  156. BOOL InitInstance(HANDLE hInstance, int nCmdShow)
  157. { int i;
  158.   HDC hDC;
  159.   RECT wrect;
  160.   TEXTMETRIC tm;
  161.  
  162.   hInst = hInstance;
  163.  
  164. /*** Allocate the file transfer buffer */
  165.  
  166.   if (!(hTransBuf = GlobalAlloc(GMEM_MOVEABLE, TRANS_BUF_SIZE)))
  167.   { Comment("System error: Insufficient memory for buffers");
  168.     return(FALSE);
  169.   }
  170.  
  171.   if (!(TransBuf = GlobalLock(hTransBuf)))
  172.   { Comment("System error: Insufficient memory to lock buffers");
  173.     return(FALSE);
  174.   }
  175.  
  176. /*** Create instance for the subclassing procedure */
  177.  
  178.   lpNewEditWndProc = MakeProcInstance((FARPROC)NewEditWndProc, hInst);
  179.  
  180. /*** Create window and get context */
  181.  
  182.   hMainWnd = CreateWindow("ZapWClass",
  183.                           "Zap",
  184.                           WS_OVERLAPPEDWINDOW,
  185.                           CW_USEDEFAULT,
  186.                           CW_USEDEFAULT,
  187.                           CW_USEDEFAULT,
  188.                           CW_USEDEFAULT,
  189.                           NULL,
  190.                           NULL,
  191.                           hInstance,
  192.                           NULL);
  193.   if (!hMainWnd) return (FALSE);
  194.  
  195. /*** Create the edit control */
  196.  
  197.   NumFiles = 0;
  198.  
  199.   if (!CreateEditWindow())
  200.   { DestroyWindow(hMainWnd);
  201.     return(FALSE);
  202.   }
  203.  
  204. /*** Resize main window and centre it on screen */
  205.  
  206.   hDC = GetDC(hMainWnd);
  207.  
  208.   SelectObject(hDC, GetStockObject(ANSI_FIXED_FONT));
  209.   GetTextMetrics(hDC, &tm);
  210.   CharWd = tm.tmAveCharWidth;
  211.   CharDp = tm.tmHeight;
  212.  
  213.   GetWindowRect(hMainWnd, &wrect);
  214.   srand(wrect.left);
  215.  
  216.   wrect.right  = CharWd*INITIAL_WIDTH
  217.                          + 2*GetSystemMetrics(SM_CXFRAME);
  218.  
  219.   wrect.bottom = CharDp*INITIAL_DEPTH
  220.                          + 2*GetSystemMetrics(SM_CYFRAME)
  221.                          +   GetSystemMetrics(SM_CYCAPTION)
  222.                          +   GetSystemMetrics(SM_CYMENU);
  223.  
  224.   wrect.left = rand() % (GetDeviceCaps(hDC, HORZRES) - wrect.right);
  225.   wrect.top  = rand() % (GetDeviceCaps(hDC, VERTRES) - wrect.bottom);
  226.   MoveWindow(hMainWnd, wrect.left, wrect.top, wrect.right, wrect.bottom, FALSE);
  227.  
  228.   ReleaseDC(hMainWnd, hDC);
  229.  
  230. /*** File dialog box info structure */
  231.  
  232.   OpenFileInfo.lStructSize       = sizeof(OPENFILENAME);
  233.   OpenFileInfo.hwndOwner         = hMainWnd;
  234.   OpenFileInfo.lpstrFilter       = FilterSpec;
  235.   OpenFileInfo.lpstrCustomFilter = NULL;
  236.   OpenFileInfo.nMaxCustFilter    = 0;
  237.   OpenFileInfo.nFilterIndex      = 1;
  238.   OpenFileInfo.lpstrFile         = FileName;
  239.   OpenFileInfo.nMaxFile          = MAX_DOS_NAME;
  240.   OpenFileInfo.lpstrInitialDir   = NULL;
  241.   OpenFileInfo.lpstrFileTitle    = FileTitle;
  242.   OpenFileInfo.nMaxFileTitle     = MAX_DOS_NAME;
  243.   OpenFileInfo.lpstrTitle        = NULL;
  244.   OpenFileInfo.lpstrDefExt       = "TXT";
  245.   OpenFileInfo.Flags             = 0;
  246.  
  247. /*** Display window and return*/
  248.  
  249.   ShowWindow(hMainWnd, nCmdShow);
  250.   UpdateWindow(hMainWnd);
  251.  
  252.   return(TRUE);
  253. }
  254.  
  255.  
  256. /***********************************************************************
  257. * Message handler for main window                                      *
  258. ***********************************************************************/
  259.  
  260. long FAR PASCAL MainWndProc(HWND hWnd, unsigned message, WORD wParam, LONG lParam)
  261. { int i;
  262.   FARPROC lp_proc;
  263.   HDC hDC;
  264.   PAINTSTRUCT ps;
  265.  
  266.   switch (message)
  267.   { case WM_COMMAND:
  268.       switch (wParam)
  269.       {
  270.  
  271. /*** Create a new file */
  272.  
  273.         case IDM_FILE_NEW:
  274.           if (SendMessage(CurWnd, EM_GETMODIFY, 0, 0L))
  275.           { sprintf(WorkStr, "Save %s", EditWnd[CurrentFile].name);
  276.             i = MessageBox(GetFocus(), WorkStr, "Zap", MB_YESNOCANCEL | MB_ICONQUESTION);
  277.             if (i == IDCANCEL)
  278.               break;
  279.             if (i == IDYES)
  280.               SaveFile(CurrentFile, TRUE);
  281.           }
  282.  
  283.           SetWindowText(CurWnd, "");
  284.           SendMessage(CurWnd, EM_SETMODIFY, 0, 0L);
  285.           strcpy(EditWnd[CurrentFile].name, UNTITLED);
  286.  
  287.           hDC = GetDC(hMainWnd);
  288.           RedrawStatusBar(hDC, CurrentFile);
  289.           ReleaseDC(hMainWnd, hDC);
  290.  
  291.           break;
  292.  
  293. /*** Open a file */
  294.  
  295.         case IDM_FILE_OPEN:
  296.           if (SendMessage(CurWnd, EM_GETMODIFY, 0, 0L))
  297.           { sprintf(WorkStr, "Save %s", EditWnd[CurrentFile].name);
  298.             i = MessageBox(GetFocus(), WorkStr, "Zap", MB_YESNOCANCEL | MB_ICONQUESTION);
  299.             if (i == IDCANCEL)
  300.               break;
  301.             if (i == IDYES)
  302.               SaveFile(CurrentFile, TRUE);
  303.           }
  304.  
  305.           ReadFile(CurrentFile, TRUE);
  306.           SendMessage(CurWnd, EM_SETMODIFY, 0, 0L);
  307.  
  308.           hDC = GetDC(hMainWnd);
  309.           RedrawStatusBar(hDC, CurrentFile);
  310.           ReleaseDC(hMainWnd, hDC);
  311.  
  312.           break;
  313.  
  314. /*** Save the file using the current name */
  315.  
  316.         case IDM_FILE_SAVE:
  317.           SaveFile(CurrentFile, TRUE);
  318.           SendMessage(CurWnd, EM_SETMODIFY, 0, 0L);
  319.           break;
  320.  
  321. /*** Save the file supplying a name */
  322.  
  323.         case IDM_FILE_SAVEAS:
  324.           SaveFile(CurrentFile, FALSE);
  325.           SendMessage(CurWnd, EM_SETMODIFY, 0, 0L);
  326.           break;
  327.  
  328. /*** Insert the contents of a file */
  329.  
  330.         case IDM_FILE_INSERT:
  331.           ReadFile(CurrentFile, FALSE);
  332.           SendMessage(CurWnd, EM_SETMODIFY, 1, 0L);
  333.           break;
  334.  
  335. /*** Print a file */
  336.  
  337.         case IDM_FILE_PRINT:
  338.           PrintFile(CurrentFile);
  339.           break;
  340.  
  341. /*** Exit */
  342.  
  343.         case IDM_FILE_EXIT:
  344.           for (i = 0; i < NumFiles; i++)
  345.           { if (SendMessage(EditWnd[i].hwnd, EM_GETMODIFY, 0, 0L))
  346.             { sprintf(WorkStr, "Save %s", EditWnd[i].name);
  347.               i = MessageBox(GetFocus(), WorkStr, "Zap", MB_YESNOCANCEL | MB_ICONQUESTION);
  348.               if (i == IDCANCEL)
  349.                 return(0L);
  350.               if (i == IDYES)
  351.                 SaveFile(CurrentFile, TRUE);
  352.             }
  353.           }
  354.  
  355.           DestroyWindow(hMainWnd);
  356.           break;
  357.  
  358. /*** Traditional about box */
  359.  
  360.         case IDM_FILE_ABOUT:
  361.           lp_proc = MakeProcInstance(AboutProc, hInst);
  362.           DialogBox(hInst, "AboutBox", hWnd, lp_proc);
  363.           FreeProcInstance(lp_proc);
  364.           break;
  365.  
  366. /*** The edit commands are mostly passed straight on to the controls */
  367.  
  368.         case IDM_EDIT_UNDO:
  369.           CallWindowProc(CurWndProc, CurWnd, EM_UNDO, 0, 0L);
  370.           break;
  371.  
  372.         case IDM_EDIT_CUT:
  373.           CallWindowProc(CurWndProc, CurWnd, WM_CUT, 0, 0L);
  374.           break;
  375.  
  376.         case IDM_EDIT_COPY:
  377.           CallWindowProc(CurWndProc, CurWnd, WM_COPY, 0, 0L);
  378.           break;
  379.  
  380.         case IDM_EDIT_PASTE:
  381.           CallWindowProc(CurWndProc, CurWnd, WM_PASTE, 0, 0L);
  382.           break;
  383.  
  384.         case IDM_EDIT_CLEAR:
  385.           CallWindowProc(CurWndProc, CurWnd, WM_CLEAR, 0, 0L);
  386.           break;
  387.  
  388.         case IDM_EDIT_SELECTALL:
  389.           CallWindowProc(CurWndProc, CurWnd, EM_SETSEL, 0, MAKELONG(0, 0X7FFF));
  390.           break;
  391.  
  392. /*** Search file for string */
  393.  
  394.         case IDM_EDIT_SEARCH:
  395.           lp_proc = MakeProcInstance(SearchProc, hInst);
  396.           DialogBox(hInst, "SearchBox", hWnd, lp_proc);
  397.           FreeProcInstance(lp_proc);
  398.           break;
  399.  
  400. /*** Replace string in file */
  401.  
  402.         case IDM_EDIT_REPLACE:
  403.           lp_proc = MakeProcInstance(ReplaceProc, hInst);
  404.           DialogBox(hInst, "ReplaceBox", hWnd, lp_proc);
  405.           FreeProcInstance(lp_proc);
  406.           break;
  407.  
  408. /*** Open a new window */
  409.  
  410.         case IDM_WINDOW_OPEN:
  411.           if (CreateEditWindow())
  412.           { ReadFile(CurrentFile, TRUE);
  413.             SendMessage(CurWnd, EM_SETMODIFY, 0, 0L);
  414.             RearrangeEditWindows();
  415.           }
  416.           break;
  417.  
  418. /*** Close a window */
  419.  
  420.         case IDM_WINDOW_CLOSE:
  421.           if (NumFiles == 1)
  422.           { PostMessage(hWnd, WM_COMMAND, IDM_FILE_EXIT, 0L);
  423.             break;
  424.           }
  425.  
  426.           if (SendMessage(CurWnd, EM_GETMODIFY, 0, 0L))
  427.           { sprintf(WorkStr, "Save %s", EditWnd[CurrentFile].name);
  428.             i = MessageBox(GetFocus(), WorkStr, "Zap", MB_YESNOCANCEL | MB_ICONQUESTION);
  429.             if (i == IDCANCEL)
  430.               break;
  431.             if (i == IDYES)
  432.               SaveFile(CurrentFile, TRUE);
  433.           }
  434.  
  435.           DestroyWindow(CurWnd);
  436.           GlobalFree(EditWnd[CurrentFile].ds);
  437.           for (i = CurrentFile + 1; i < NumFiles; i++)
  438.             EditWnd[i-1] = EditWnd[i];
  439.           NumFiles--;
  440.  
  441.           if (CurrentFile == NumFiles) CurrentFile--;
  442.           RearrangeEditWindows();
  443.           SetFocus(CurWnd);
  444.           break;
  445.  
  446. /*** Finally check for messages from edit controls */
  447.  
  448.         default:
  449.           for (i = 0; i < NumFiles; i++)
  450.           { if (wParam == IDC_EDIT + i)
  451.             { switch (HIWORD(lParam))
  452.               { case EN_ERRSPACE:
  453.                   sprintf(WorkStr, "%s is too big for Zap; file has been truncated", EditWnd[i].name);
  454.                   Comment(WorkStr);
  455.                   break;
  456.  
  457.                 case EN_SETFOCUS:
  458.                   CurrentFile = i;
  459.                   break;
  460.               }
  461.             }
  462.           }
  463.           break;
  464.       }
  465.       break;
  466.  
  467. /*** The only painting needed is the status bars */
  468.  
  469.     case WM_PAINT:
  470.       hDC = BeginPaint(hWnd, &ps);
  471.       for (i = 0; i < NumFiles; i++) RedrawStatusBar(hDC, i);
  472.       EndPaint(hWnd, &ps);
  473.       break;
  474.  
  475. /*** Adjust window size down to nearest whole number of characters */
  476.  
  477.     case WM_SIZE:
  478.       if (IsWindowVisible(hWnd))
  479.         RearrangeEditWindows();
  480.       break;
  481.  
  482. /*** Pass the focus on to the current edit window */
  483.  
  484.     case WM_SETFOCUS:
  485.       SetFocus(CurWnd);
  486.       break;
  487.  
  488. /*** On closure check all files are saved */
  489.  
  490.     case WM_CLOSE:
  491.       for (i = 0; i < NumFiles; i++)
  492.       { if (SendMessage(EditWnd[i].hwnd, EM_GETMODIFY, 0, 0L))
  493.         { sprintf(WorkStr, "Save %s", EditWnd[i].name);
  494.           i = MessageBox(GetFocus(), WorkStr, "Zap", MB_YESNOCANCEL | MB_ICONQUESTION);
  495.           if (i == IDCANCEL)
  496.             return(0L);;
  497.           if (i == IDYES)
  498.             SaveFile(CurrentFile, TRUE);
  499.         }
  500.       }
  501.       return DefWindowProc( hWnd, message, wParam, lParam );
  502.  
  503. /*** If window destroyed quit */
  504.  
  505.     case WM_DESTROY:
  506.       PostQuitMessage(0);
  507.       break;
  508.  
  509. /*** Default action */
  510.  
  511.     default:
  512.       return DefWindowProc( hWnd, message, wParam, lParam );
  513.   }
  514.  
  515.   return(0L);
  516. }
  517.  
  518.  
  519. /***********************************************************************
  520. * Message handler for About dialog box                                 *
  521. ***********************************************************************/
  522.  
  523. BOOL FAR PASCAL AboutProc(HWND hDlg, unsigned message, WORD wParam, LONG lParam)
  524. {
  525.   switch (message)
  526.   { case WM_INITDIALOG:
  527.       return (TRUE);
  528.  
  529.     case WM_COMMAND:
  530.       if (wParam == IDOK)
  531.       { EndDialog(hDlg, TRUE);
  532.         return (TRUE);
  533.       }
  534.       break;
  535.   }
  536.  
  537.   return (FALSE);
  538. }
  539.  
  540.  
  541. /***********************************************************************
  542. * Message routine                                                      *
  543. ***********************************************************************/
  544.  
  545. void Comment(char *str)
  546. {
  547.   MessageBox(GetFocus(),
  548.              str,
  549.              "Zap",
  550.              MB_ICONEXCLAMATION | MB_OK);
  551. }
  552.  
  553.