home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Utilities / TextEditor / source / Main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-30  |  14.9 KB  |  600 lines  |  [TEXT/KAHL]
  1. /* Main.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Stupid Fred's Text Editor                                              */
  5. /*    Written by Thomas R. Lawrence, 1993 - 1994.                            */
  6. /*                                                                           */
  7. /*    This software is Public Domain; it may be used for any purpose         */
  8. /*    whatsoever without restriction.                                        */
  9. /*                                                                           */
  10. /*    This package is distributed in the hope that it will be useful,        */
  11. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  12. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                   */
  13. /*                                                                           */
  14. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  15. /*                                                                           */
  16. /*****************************************************************************/
  17.  
  18. #define Including_Main_c
  19. #include "MiscInfo.h"
  20. #include "Definitions.h"
  21. #include "Debug.h"
  22. #include "Audit.h"
  23.  
  24. #include "Main.h"
  25. #include "Memory.h"
  26. #include "StartupOpen.h"
  27. #include "Files.h"
  28. #include "EventLoop.h"
  29. #include "Alert.h"
  30. #include "WindowStuff.h"
  31. #include "GrowIcon.h"
  32. #include "AboutBox.h"
  33. #include "WindowDispatcher.h"
  34.  
  35.  
  36. MenuType*                    mmAppleMenu;
  37. MenuType*                    mmFileMenu;
  38. MenuType*                    mmEditMenu;
  39. MenuType*                    mmSearchMenu;
  40. MenuType*                    mmWindowsMenu;
  41. MenuType*                    mmFontMenu;
  42. MenuType*                    mmSizeMenu;
  43.  
  44. MenuItemType*            mAboutThisProgram;
  45. MenuItemType*            mNewFile;
  46. MenuItemType*            mOpenFile;
  47. MenuItemType*            mCloseFile;
  48. MenuItemType*            mSaveFile;
  49. MenuItemType*            mSaveAs;
  50. MenuItemType*            mAutoIndent;
  51. MenuItemType*            mSetTabSize;
  52. MenuItemType*            mConvertTabsToSpaces;
  53. MenuItemType*            mMacintoshLineFeeds;
  54. MenuItemType*            mUnixLineFeeds;
  55. MenuItemType*            mMsDosLineFeeds;
  56. MenuItemType*            mQuit;
  57. MenuItemType*            mUndo;
  58. MenuItemType*            mCut;
  59. MenuItemType*            mCopy;
  60. MenuItemType*            mPaste;
  61. MenuItemType*            mClear;
  62. MenuItemType*            mSelectAll;
  63. MenuItemType*            mEnterSelection;
  64. MenuItemType*            mFind;
  65. MenuItemType*            mFindAgain;
  66. MenuItemType*            mReplace;
  67. MenuItemType*            mReplaceAndFindAgain;
  68. MenuItemType*            mPrefixSelection;
  69. MenuItemType*            mBalanceParens;
  70. MenuItemType*            mShiftLeft;
  71. MenuItemType*            mShiftRight;
  72. MenuItemType*            mGotoLine;
  73. MenuItemType*            mShowSelection;
  74. MenuToFont*                mFontItemList;
  75. MenuItemType*            m9Points;
  76. MenuItemType*            m10Points;
  77. MenuItemType*            m12Points;
  78. MenuItemType*            m14Points;
  79. MenuItemType*            m18Points;
  80. MenuItemType*            m24Points;
  81. MenuItemType*            m30Points;
  82. MenuItemType*            m36Points;
  83. MenuItemType*            mOtherPoints;
  84.  
  85.  
  86. MyBoolean                    ItsInTheFontList(MenuItemType* MenuID)
  87.     {
  88.         int                                Scan;
  89.  
  90.         for (Scan = 0; Scan < PtrSize((char*)mFontItemList)
  91.             / sizeof(MenuToFont); Scan += 1)
  92.             {
  93.                 if (mFontItemList[Scan].MenuItemID == MenuID)
  94.                     {
  95.                         return True;
  96.                     }
  97.             }
  98.         return False;
  99.     }
  100.  
  101.  
  102. FontType                    GetFontFromMenuItem(MenuItemType* MenuID)
  103.     {
  104.         int                    Scan;
  105.  
  106.         for (Scan = 0; Scan < PtrSize((char*)mFontItemList)
  107.             / sizeof(MenuToFont); Scan += 1)
  108.             {
  109.                 if (mFontItemList[Scan].MenuItemID == MenuID)
  110.                     {
  111.                         return mFontItemList[Scan].FontID;
  112.                     }
  113.             }
  114.         return 0;
  115.     }
  116.  
  117.  
  118. int                                main(int argc, char* argv[])
  119.     {
  120.         MyBoolean                TryToOpenUntitledDocument;
  121.         MyBoolean                ContinueFlag;
  122.  
  123.  
  124.         APRINT(("+main"));
  125.  
  126.         /* level 0 initialization */
  127.         if (!InitializeScreen())
  128.             {
  129.                 goto InitScreenFailedPoint;
  130.             }
  131.  
  132.         /* level 1 initialization */
  133.         if (!InitializeAlertSubsystem())
  134.             {
  135.                 goto InitAlertFailedPoint;
  136.             }
  137.         if (!InitializeGrowIcon())
  138.             {
  139.                 goto InitGrowFailedPoint;
  140.             }
  141.         if (!InitializeWindowDispatcher())
  142.             {
  143.                 goto InitWindowDispatcherFailed;
  144.             }
  145.  
  146.         /* application initialization */
  147.         if (!InitWindowStuff())
  148.             {
  149.                 goto InitWindowStuffFailed;
  150.             }
  151.  
  152.         mmAppleMenu = MakeAppleMenu();
  153.         if (mmAppleMenu == NIL)
  154.             {
  155.                 goto MakeAppleMenuFailed;
  156.             }
  157.         mAboutThisProgram = MakeNewMenuItem(mmAppleMenu,"About TextEditor...",0);
  158.         if (mAboutThisProgram == NIL)
  159.             {
  160.                 goto MakeFileMenuFailed;
  161.             }
  162.         ShowMenu(mmAppleMenu);
  163.  
  164.         mmFileMenu = MakeNewMenu("File");
  165.         if (mmFileMenu == NIL)
  166.             {
  167.                 goto MakeFileMenuFailed;
  168.             }
  169.         mNewFile = MakeNewMenuItem(mmFileMenu,"New",'N');
  170.         if (mNewFile == NIL)
  171.             {
  172.                 goto MakeEditMenuFailed;
  173.             }
  174.         mOpenFile = MakeNewMenuItem(mmFileMenu,"Open...",'O');
  175.         if (mOpenFile == NIL)
  176.             {
  177.                 goto MakeEditMenuFailed;
  178.             }
  179.         mCloseFile = MakeNewMenuItem(mmFileMenu,"Close",'W');
  180.         if (mCloseFile == NIL)
  181.             {
  182.                 goto MakeEditMenuFailed;
  183.             }
  184.         AppendSeparator(mmFileMenu);
  185.         mSaveFile = MakeNewMenuItem(mmFileMenu,"Save",'S');
  186.         if (mSaveFile == NIL)
  187.             {
  188.                 goto MakeEditMenuFailed;
  189.             }
  190.         mSaveAs = MakeNewMenuItem(mmFileMenu,"Save As...",0);
  191.         if (mSaveAs == NIL)
  192.             {
  193.                 goto MakeEditMenuFailed;
  194.             }
  195.         AppendSeparator(mmFileMenu);
  196.         mAutoIndent = MakeNewMenuItem(mmFileMenu,"Auto Indent",0);
  197.         if (mAutoIndent == NIL)
  198.             {
  199.                 goto MakeEditMenuFailed;
  200.             }
  201.         mSetTabSize = MakeNewMenuItem(mmFileMenu,"Set Tab Size (8)...",'T');
  202.         if (mSetTabSize == NIL)
  203.             {
  204.                 goto MakeEditMenuFailed;
  205.             }
  206.         AppendSeparator(mmFileMenu);
  207.         mConvertTabsToSpaces = MakeNewMenuItem(mmFileMenu,"Convert Tabs To Spaces",0);
  208.         if (mConvertTabsToSpaces == NIL)
  209.             {
  210.                 goto MakeEditMenuFailed;
  211.             }
  212.         AppendSeparator(mmFileMenu);
  213.         mMacintoshLineFeeds = MakeNewMenuItem(mmFileMenu,"Macintosh Line Feeds",0);
  214.         if (mMacintoshLineFeeds == NIL)
  215.             {
  216.                 goto MakeEditMenuFailed;
  217.             }
  218.         mUnixLineFeeds = MakeNewMenuItem(mmFileMenu,"UNIX Line Feeds",0);
  219.         if (mUnixLineFeeds == NIL)
  220.             {
  221.                 goto MakeEditMenuFailed;
  222.             }
  223.         mMsDosLineFeeds = MakeNewMenuItem(mmFileMenu,"MS-DOS Line Feeds",0);
  224.         if (mMsDosLineFeeds == NIL)
  225.             {
  226.                 goto MakeEditMenuFailed;
  227.             }
  228.         AppendSeparator(mmFileMenu);
  229.         mQuit = MakeNewMenuItem(mmFileMenu,"Quit",'Q');
  230.         if (mQuit == NIL)
  231.             {
  232.                 goto MakeEditMenuFailed;
  233.             }
  234.         ShowMenu(mmFileMenu);
  235.  
  236.         mmEditMenu = MakeNewMenu("Edit");
  237.         if (mmEditMenu == NIL)
  238.             {
  239.                 goto MakeEditMenuFailed;
  240.             }
  241.         mUndo = MakeNewMenuItem(mmEditMenu,"Undo",'Z');
  242.         if (mUndo == NIL)
  243.             {
  244.                 goto MakeSearchMenuFailed;
  245.             }
  246.         AppendSeparator(mmEditMenu);
  247.         mCut = MakeNewMenuItem(mmEditMenu,"Cut",'X');
  248.         if (mCut == NIL)
  249.             {
  250.                 goto MakeSearchMenuFailed;
  251.             }
  252.         mCopy = MakeNewMenuItem(mmEditMenu,"Copy",'C');
  253.         if (mCopy == NIL)
  254.             {
  255.                 goto MakeSearchMenuFailed;
  256.             }
  257.         mPaste = MakeNewMenuItem(mmEditMenu,"Paste",'V');
  258.         if (mPaste == NIL)
  259.             {
  260.                 goto MakeSearchMenuFailed;
  261.             }
  262.         mClear = MakeNewMenuItem(mmEditMenu,"Clear",0);
  263.         if (mClear == NIL)
  264.             {
  265.                 goto MakeSearchMenuFailed;
  266.             }
  267.         mSelectAll = MakeNewMenuItem(mmEditMenu,"Select All",'A');
  268.         if (mSelectAll == NIL)
  269.             {
  270.                 goto MakeSearchMenuFailed;
  271.             }
  272.         AppendSeparator(mmEditMenu);
  273.         mPrefixSelection = MakeNewMenuItem(mmEditMenu,"Prefix Selection...",0);
  274.         if (mPrefixSelection == NIL)
  275.             {
  276.                 goto MakeSearchMenuFailed;
  277.             }
  278.         AppendSeparator(mmEditMenu);
  279.         mBalanceParens = MakeNewMenuItem(mmEditMenu,"Balance Parentheses",'B');
  280.         if (mBalanceParens == NIL)
  281.             {
  282.                 goto MakeSearchMenuFailed;
  283.             }
  284.         AppendSeparator(mmEditMenu);
  285.         mShiftLeft = MakeNewMenuItem(mmEditMenu,"Shift Left",'L');
  286.         if (mShiftLeft == NIL)
  287.             {
  288.                 goto MakeSearchMenuFailed;
  289.             }
  290.         mShiftRight = MakeNewMenuItem(mmEditMenu,"Shift Right",'R');
  291.         if (mShiftRight == NIL)
  292.             {
  293.                 goto MakeSearchMenuFailed;
  294.             }
  295.         ShowMenu(mmEditMenu);
  296.  
  297.         mmSearchMenu = MakeNewMenu("Search");
  298.         if (mmSearchMenu == NIL)
  299.             {
  300.                 goto MakeSearchMenuFailed;
  301.             }
  302.         mFind = MakeNewMenuItem(mmSearchMenu,"Find...",'F');
  303.         if (mFind == NIL)
  304.             {
  305.                 goto MakeFontMenuFailed;
  306.             }
  307.         mEnterSelection = MakeNewMenuItem(mmSearchMenu,"Enter Selection",'E');
  308.         if (mEnterSelection == NIL)
  309.             {
  310.                 goto MakeFontMenuFailed;
  311.             }
  312.         mFindAgain = MakeNewMenuItem(mmSearchMenu,"Find Again",'G');
  313.         if (mFindAgain == NIL)
  314.             {
  315.                 goto MakeFontMenuFailed;
  316.             }
  317.         mReplace = MakeNewMenuItem(mmSearchMenu,"Replace",'=');
  318.         if (mReplace == NIL)
  319.             {
  320.                 goto MakeFontMenuFailed;
  321.             }
  322.         mReplaceAndFindAgain = MakeNewMenuItem(mmSearchMenu,"Replace and Find Again",'H');
  323.         if (mReplaceAndFindAgain == NIL)
  324.             {
  325.                 goto MakeFontMenuFailed;
  326.             }
  327.         AppendSeparator(mmSearchMenu);
  328.         mGotoLine = MakeNewMenuItem(mmSearchMenu,"Goto Line...",'J');
  329.         if (mGotoLine == NIL)
  330.             {
  331.                 goto MakeFontMenuFailed;
  332.             }
  333.         AppendSeparator(mmSearchMenu);
  334.         mShowSelection = MakeNewMenuItem(mmSearchMenu,"Show Selection",0);
  335.         if (mShowSelection == NIL)
  336.             {
  337.                 goto MakeFontMenuFailed;
  338.             }
  339.         ShowMenu(mmSearchMenu);
  340.  
  341.         mmFontMenu = MakeNewMenu("Font");
  342.         if (mmFontMenu == NIL)
  343.             {
  344.                 goto MakeFontMenuFailed;
  345.             }
  346.         {
  347.             long                        Scan;
  348.             long                        Limit;
  349.  
  350.             Limit = GetNumAvailableFonts();
  351.             mFontItemList = (MenuToFont*)AllocPtrCanFail(
  352.                 Limit * sizeof(MenuToFont),"FontMenuList");
  353.             if (mFontItemList == NIL)
  354.                 {
  355.                  FontFailure1:
  356.                     goto MakeSizeMenuFailed;
  357.                 }
  358.             for (Scan = 0; Scan < Limit; Scan += 1)
  359.                 {
  360.                     char*                            FontName;
  361.  
  362.                     mFontItemList[Scan].FontID = GetIndexedFont(Scan);
  363.                     FontName = GetNameOfFont(mFontItemList[Scan].FontID);
  364.                     if (FontName == NIL)
  365.                         {
  366.                             long                            Index;
  367.  
  368.                          FontFailure2:
  369.                             for (Index = 0; Index < Scan; Index += 1)
  370.                                 {
  371.                                     KillMenuItem(mFontItemList[Index].MenuItemID);
  372.                                 }
  373.                             ReleasePtr((char*)mFontItemList);
  374.                             goto FontFailure1;
  375.                         }
  376.                     mFontItemList[Scan].MenuItemID = MakeNewMenuItem(mmFontMenu,FontName,0);
  377.                     ReleasePtr(FontName);
  378.                     if (mFontItemList[Scan].MenuItemID == NIL)
  379.                         {
  380.                             goto FontFailure2;
  381.                         }
  382.                 }
  383.         }
  384.         ShowMenu(mmFontMenu);
  385.  
  386.         mmSizeMenu = MakeNewMenu("Size");
  387.         if (mmSizeMenu == NIL)
  388.             {
  389.                 goto MakeSizeMenuFailed;
  390.             }
  391.         m9Points = MakeNewMenuItem(mmSizeMenu,"9 Points",0);
  392.         if (m9Points == NIL)
  393.             {
  394.                 goto MakeWindowsMenuFailed;
  395.             }
  396.         m10Points = MakeNewMenuItem(mmSizeMenu,"10 Points",0);
  397.         if (m10Points == NIL)
  398.             {
  399.                 goto MakeWindowsMenuFailed;
  400.             }
  401.         m12Points = MakeNewMenuItem(mmSizeMenu,"12 Points",0);
  402.         if (m12Points == NIL)
  403.             {
  404.                 goto MakeWindowsMenuFailed;
  405.             }
  406.         m14Points = MakeNewMenuItem(mmSizeMenu,"14 Points",0);
  407.         if (m14Points == NIL)
  408.             {
  409.                 goto MakeWindowsMenuFailed;
  410.             }
  411.         m18Points = MakeNewMenuItem(mmSizeMenu,"18 Points",0);
  412.         if (m18Points == NIL)
  413.             {
  414.                 goto MakeWindowsMenuFailed;
  415.             }
  416.         m24Points = MakeNewMenuItem(mmSizeMenu,"24 Points",0);
  417.         if (m24Points == NIL)
  418.             {
  419.                 goto MakeWindowsMenuFailed;
  420.             }
  421.         m30Points = MakeNewMenuItem(mmSizeMenu,"30 Points",0);
  422.         if (m30Points == NIL)
  423.             {
  424.                 goto MakeWindowsMenuFailed;
  425.             }
  426.         m36Points = MakeNewMenuItem(mmSizeMenu,"36 Points",0);
  427.         if (m36Points == NIL)
  428.             {
  429.                 goto MakeWindowsMenuFailed;
  430.             }
  431.         AppendSeparator(mmSizeMenu);
  432.         mOtherPoints = MakeNewMenuItem(mmSizeMenu,"Other Size (9)...",0);
  433.         if (mOtherPoints == NIL)
  434.             {
  435.                 goto MakeWindowsMenuFailed;
  436.             }
  437.         ShowMenu(mmSizeMenu);
  438.  
  439.         mmWindowsMenu = MakeNewMenu("Windows");
  440.         if (mmWindowsMenu == NIL)
  441.             {
  442.                 goto MakeWindowsMenuFailed;
  443.             }
  444.         ShowMenu(mmWindowsMenu);
  445.  
  446.         PrepareStartupDocuments(argc,argv);
  447.         TryToOpenUntitledDocument = True;
  448.         ContinueFlag = True;
  449.         while (ContinueFlag)
  450.             {
  451.                 OrdType                    XLoc;
  452.                 OrdType                    YLoc;
  453.                 ModifierFlags        Modifiers;
  454.                 FileSpec*                StartupItem;
  455.                 WinType*                Window;
  456.                 MenuItemType*        MenuItem;
  457.                 char                        KeyPress;
  458.                 EventType                TheEvent;
  459.  
  460.                 /* see if there are any startup items to open */
  461.                 if (GetStartupObject(&StartupItem))
  462.                     {
  463.                         /* if it returns True, then we can go ahead */
  464.                         if (StartupItem == NIL)
  465.                             {
  466.                                 /* if we haven't opened an untitled document, and the thing */
  467.                                 /* returned True, except it returned a NIL item, then we */
  468.                                 /* can open an untitled document */
  469.                                 if (TryToOpenUntitledDocument)
  470.                                     {
  471.                                         OpenDocument(NIL);
  472.                                         TryToOpenUntitledDocument = False;
  473.                                     }
  474.                             }
  475.                          else
  476.                             {
  477.                                 /* if it isn't NIL, then open the actual thing */
  478.                                 /* this swallows the startup item record so we don't have */
  479.                                 /* do dispose of it */
  480.                                 OpenDocument(StartupItem);
  481.                                 TryToOpenUntitledDocument = False;
  482.                             }
  483.                     }
  484.                 /* handle an event */
  485.                 TheEvent = GetAnEvent(&XLoc,&YLoc,&Modifiers,&Window,&MenuItem,&KeyPress);
  486.                 switch (TheEvent)
  487.                     {
  488.                         case eMouseUp:
  489.                             break;
  490.                         case eMenuStarting:
  491.                             EnableMenuItem(mAboutThisProgram);
  492.                             EnableMenuItem(mNewFile);
  493.                             EnableMenuItem(mOpenFile);
  494.                             EnableMenuItem(mQuit);
  495.                             DispatchMenuStarting(Window);
  496.                             break;
  497.                         case eMenuCommand:
  498.                             CheckPtrExistence(MenuItem);
  499.                             if (MenuItem == mAboutThisProgram)
  500.                                 {
  501.                                     ShowAboutBox();
  502.                                 }
  503.                             else if (MenuItem == mNewFile)
  504.                                 {
  505.                                     OpenDocument(NIL);
  506.                                 }
  507.                             else if (MenuItem == mOpenFile)
  508.                                 {
  509.                                     FileSpec*                    Where;
  510.                                     unsigned long            FileTypeList[1] = {CODE4BYTES('T','E','X','T')};
  511.  
  512.                                     Where = GetFileStandard(1,FileTypeList);
  513.                                     if (Where != NIL)
  514.                                         {
  515.                                             OpenDocument(Where);
  516.                                         }
  517.                                 }
  518.                             else if (MenuItem == mQuit)
  519.                                 {
  520.                                     SetQuitPending();
  521.                                 }
  522.                             else
  523.                                 {
  524.                                     DispatchProcessMenuCommand(Window,MenuItem);
  525.                                 }
  526.                             break;
  527.                         case eKeyPressed:
  528.                             DispatchDoKeyDown(Window,KeyPress,Modifiers);
  529.                             break;
  530.                         case eMouseDown:
  531.                             DispatchDoMouseDown(Window,XLoc,YLoc,Modifiers);
  532.                             break;
  533.                         case eWindowClosing:
  534.                             DispatchCloseWindow(Window);
  535.                             break;
  536.                         case eWindowResized:
  537.                             DispatchWindowJustResized(Window);
  538.                             break;
  539.                         case eActiveWindowChanged:
  540.                             DispatchActiveWindowJustChanged(Window);
  541.                             break;
  542.                         case eNoEvent:
  543.                         case eCheckCursor:
  544.                             DispatchDoIdle(Window,TheEvent == eCheckCursor,XLoc,YLoc,Modifiers);
  545.                             break;
  546.                         default:
  547.                             EXECUTE(PRERR(AllowResume,"Unimplemented event received"));
  548.                             break;
  549.                     }
  550.                 if (CheckQuitPending())
  551.                     {
  552.                         /* ask "are you sure" here; */
  553.                         if (DoCloseAllQuitPending())
  554.                             {
  555.                                 ContinueFlag = False;
  556.                             }
  557.                          else
  558.                             {
  559.                                 AbortQuitInProgress();
  560.                             }
  561.                     }
  562.             }
  563.         HideAnyAboutBoxes();
  564.         ClearStartupDocuments();
  565.         ReleasePtr((char*)mFontItemList);
  566.  
  567.         /* application cleanup */
  568.         KillMenuAndDeleteItems(mmWindowsMenu);
  569.      MakeWindowsMenuFailed:
  570.         KillMenuAndDeleteItems(mmSizeMenu);
  571.      MakeSizeMenuFailed:
  572.         KillMenuAndDeleteItems(mmFontMenu);
  573.      MakeFontMenuFailed:
  574.         KillMenuAndDeleteItems(mmSearchMenu);
  575.      MakeSearchMenuFailed:
  576.         KillMenuAndDeleteItems(mmEditMenu);
  577.      MakeEditMenuFailed:
  578.         KillMenuAndDeleteItems(mmFileMenu);
  579.      MakeFileMenuFailed:
  580.         KillMenuAndDeleteItems(mmAppleMenu);
  581.      MakeAppleMenuFailed:
  582.         KillWindowStuff();
  583.  
  584.         /* level 1 cleanup */
  585.      InitWindowStuffFailed:
  586.         ShutdownWindowDispatcher();
  587.      InitWindowDispatcherFailed:
  588.         ShutdownGrowIcon();
  589.      InitGrowFailedPoint:
  590.         ShutdownAlertSubsystem();
  591.  
  592.      InitAlertFailedPoint:
  593.         /* level 0 cleanup */
  594.         ShutdownScreen();
  595.  
  596.      InitScreenFailedPoint:
  597.         APRINT(("-main"));
  598.         return 0;
  599.     }
  600.