home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Moscow ML 1.42 / ANSIshellƒ / os_mac.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-26  |  77.1 KB  |  2,758 lines  |  [TEXT/R*ch]
  1. /* os_mac.c
  2.  * 12Sep92  e  adapted from the file of the same name in the Gambit Project
  3.  * Macintosh specific stuff (for THINK C 7 or CodeWarrior 4 compiler).
  4.  * portions Copyright © 1992-1994 Marc Feeley and Douglas H. Currie, Jr.
  5.  */
  6.  
  7. #ifdef THINK_C
  8. #include <MacHeaders>
  9. #else
  10. #ifdef __MWERKS__
  11. #else
  12. "Unknown compiler!"
  13. #endif
  14. #endif
  15.  
  16. #include "os_mac.h"
  17. #include <stdio.h>
  18. #include <string.h>
  19. #include <stdlib.h>
  20. #include <errno.h>
  21. #include <signal.h>
  22. #ifdef THINK_C
  23. #include <ansi_e.h>
  24. #else
  25. Boolean XlateRETURN = 0;
  26. #endif
  27.  
  28. /*---------------------------------------------------------------------------*/
  29.  
  30. #include <Files.h>
  31. #include <Gestalt.h>
  32. #include <AppleEvents.h>
  33. #include <AERegistry.h>
  34.  
  35. static void init_ae();
  36.  
  37. #if ( CREATOR == 'Moml' )
  38. char *image_name = 0; // May97 e
  39. FSSpec appFSS;
  40. #endif
  41. static Boolean been_there_done_that = false;
  42. char      gReceivedAE = 0;
  43. Boolean   gMadeAppFSS = false;
  44. Boolean        gDoQuit = false;
  45. Boolean        gHasAppleEvents = false;
  46. Boolean        gPrintPage = false;
  47. Boolean        gHasStdFile = false;
  48. Boolean   gCursRgnOK = false;
  49. Boolean   gInBackground = false;
  50. Boolean   gLowMemory = false;
  51. Boolean   gSpareBool;
  52.  
  53. // Boolean     gHasWNE = true;
  54. // Boolean     gHasHWPriv = true;
  55.  
  56. static Handle rainy_day_fund;
  57. #define kRamReserve 65536
  58. #define kRamSlop    16384
  59.  
  60. Ptr empty_buffer;
  61.  
  62. #include "os_mac_eventchk.h"
  63. long next_eventchk_ticks;
  64.  
  65. /*---------------------------------------------------------------------------*/
  66.  
  67. TextStyle prefStylNormal =
  68. { monaco, 0, 0, FontSize, { 65536, 65536, 65536 } /* RGBColor Black */ };
  69. TextStyle prefStylHilite =
  70. { monaco, 0, 0, FontSize, { 65536, 65536, 65536 } /* RGBColor Black */ };
  71.  
  72. short prefTabs = dfltTabs;
  73. short prefWrap = dfltWrap;
  74. short prefAutoInd = dfltAutoInd;
  75.  
  76. short current_menus;
  77.  
  78. MenuHandle menus[7];
  79.  
  80. Cursor watch_cursor;
  81. Cursor gc_cursor;
  82. Cursor ibeam_cursor;
  83. Cursor *current_cursor;
  84.  
  85. unsigned char *find_string, *replace_string;
  86.  
  87. Boolean find_ci   = FALSE;
  88. Boolean find_wrap = FALSE;
  89.  
  90. static Boolean smKeyBdP;
  91. static Boolean showPosnP;
  92.  
  93. short interaction_id = 0;
  94. short interrupted = 0;
  95.  
  96. static struct {
  97.   WindowPtr wptr;
  98.   ControlHandle vscroll;
  99.   ControlHandle hscroll;
  100.   TeHANDLE hTE;
  101.   short bold_input;
  102.   short height;
  103.   short dirty;
  104.   short out_len;
  105.   long pos, len;
  106.   char *buf;
  107.   Handle out_buf;
  108.   long needs_inval_ticks;
  109.   char  in_use;
  110.   char  is_file; // 0: console, 1: new,  2: fss good
  111.   FSSpec fss;
  112. } wind_table[MAX_NB_WINDOWS];
  113.  
  114. #define WINDOW_OWNS_FILE_P( id, fss ) \
  115.  (wind_table[id].in_use != 0 && \
  116.   wind_table[id].is_file == 2 && \
  117.   wind_table[id].fss.vRefNum == fss->vRefNum && \
  118.   wind_table[id].fss.parID == fss->parID && \
  119.   (compare_p_to_p( wind_table[id].fss.name, fss->name ) == 0))
  120.  
  121. RgnHandle gCursorRgn;
  122.  
  123. long gWaitTicksBG = 20; /* in ticks, should be 6..60 */
  124. long gWaitTicksFG =  1; /* in ticks, should be 1..15 */
  125.  
  126. /* */
  127.  
  128. static void setup_cursors()
  129. { CursHandle hCurs;
  130.   hCurs = GetCursor(watchCursor);
  131.   watch_cursor = **hCurs;
  132.   /* 28Jan93  e
  133.   hCurs = GetCursor(gc_cursorID);
  134.   gc_cursor = **hCurs;
  135.   */
  136.   hCurs = GetCursor(iBeamCursor);
  137.   ibeam_cursor = **hCurs;
  138.  
  139.   current_cursor = &watch_cursor;
  140. }
  141.  
  142. static void ParamText1( Str255 text )
  143. {
  144.     ParamText( text, "\p", "\p", "\p" );
  145. }
  146.  
  147. /* *** preferences saved to disk *** */
  148.  
  149. static OSErr findPrefFolder( short *foundVRefNum, long *foundDirID )
  150. {    
  151.   *foundVRefNum = 0;
  152.   *foundDirID = 0;
  153.   /* MacTraps2 has FindFolder() glue */
  154.   return FindFolder( kOnSystemDisk, kPreferencesFolderType, kCreateFolder,
  155.                        foundVRefNum, foundDirID );
  156. }
  157.  
  158. struct prefs
  159. { short version;
  160.   short tabs;
  161.   short wrap;
  162.   Boolean find_ci;
  163.   Boolean find_wrap;
  164.   Boolean spare0;        /* smKeyBdP in Gambit */
  165.   Boolean showPosnP;
  166.   short spare2;
  167.   short spare3;
  168.   short autoInd;
  169.   TextStyle stylNormal;
  170.   TextStyle stylHilite;
  171.   unsigned char fontnmNormal[64];
  172.   unsigned char fontnmHilite[64];
  173. };
  174.  
  175. void savePrefs( ConstStr255Param fn )
  176. {
  177.     short rRef;
  178.       OSErr err;
  179.     struct prefs **hRes;
  180.     struct prefs  *pRes;
  181.     short foundVRefNum;
  182.     long  foundDirID;
  183.     Str255 fontnmNormal, fontnmHilite;
  184.     
  185.     err = findPrefFolder( &foundVRefNum, &foundDirID );
  186.     if( err != noErr ) return;
  187.     
  188.     if( ( rRef = HOpenResFile( foundVRefNum, foundDirID, fn, fsRdWrPerm ) ) < 0)
  189.     {    HCreateResFile( foundVRefNum, foundDirID, fn );
  190.         { HFileInfo pb;
  191.           pb.ioCompletion = (void *)0;
  192.           pb.ioNamePtr = (StringPtr )fn;
  193.           pb.ioVRefNum = foundVRefNum;
  194.           pb.ioFDirIndex = 0;
  195.           pb.ioDirID = foundDirID;
  196.           err = PBHGetFInfoSync( (HParmBlkPtr )&pb );
  197.           pb.ioCompletion = (void *)0;
  198.           pb.ioNamePtr = (StringPtr )fn;
  199.           pb.ioVRefNum = foundVRefNum;
  200.           pb.ioFDirIndex = 0;
  201.           pb.ioDirID = foundDirID;
  202.           pb.ioFlFndrInfo.fdCreator = CREATOR;
  203.           pb.ioFlFndrInfo.fdType    = 'gamP';
  204.           if( err == noErr )
  205.             PBHSetFInfoSync( (HParmBlkPtr )&pb );
  206.         }
  207.         rRef = HOpenResFile( foundVRefNum, foundDirID, fn, fsRdWrPerm );
  208.     }
  209.     if( rRef < 0 )
  210.         return;
  211.     hRes = (struct prefs **)GetResource('ePrf', 357);
  212.     if(    hRes == 0 || rRef != HomeResFile( (Handle )hRes ) )
  213.     {    hRes = (struct prefs **)NewHandle( sizeof( struct prefs ) );
  214.         if( hRes == 0 )
  215.         {    CloseResFile( rRef );
  216.             return;
  217.         }
  218.         AddResource( (Handle )hRes, (ResType )'ePrf', 357, (ConstStr255Param)"\p" );
  219.         if( LMGetResErr() != noErr )
  220.         {    DisposeHandle( (Handle )hRes );
  221.             CloseResFile( rRef );
  222.             return;
  223.         }
  224.     }
  225.     pRes = *hRes;
  226.     (*pRes).version    = 1;
  227.     (*pRes).tabs       = prefTabs;
  228.     (*pRes).wrap       = prefWrap;
  229.     (*pRes).find_ci    = find_ci;
  230.     (*pRes).find_wrap  = find_wrap;
  231.     (*pRes).spare0     = 0;
  232.     (*pRes).showPosnP  = showPosnP;
  233.     (*pRes).spare2     = 0;
  234.     (*pRes).spare3     = 0;
  235.     (*pRes).autoInd    = prefAutoInd;
  236.     (*pRes).stylNormal = prefStylNormal;
  237.     (*pRes).stylHilite = prefStylHilite;
  238.     GetFontName( prefStylNormal.tsFont, fontnmNormal );
  239.     if( fontnmNormal[0] > 63 ) fontnmNormal[0] = 63;
  240.     p_to_p( fontnmNormal, (**hRes).fontnmNormal );
  241.     GetFontName( prefStylHilite.tsFont, fontnmHilite );
  242.     if( fontnmHilite[0] > 63 ) fontnmHilite[0] = 63;
  243.     p_to_p( fontnmHilite, (**hRes).fontnmHilite );
  244.     
  245.     ChangedResource( (Handle )hRes );
  246.     CloseResFile( rRef );
  247. }
  248.  
  249. static void readPrefs( ConstStr255Param fn )
  250. {
  251.     short rRef;
  252.       OSErr err;
  253.     struct prefs **hRes;
  254.     struct prefs  *pRes;
  255.     short foundVRefNum;
  256.     long  foundDirID;
  257.  
  258.     err = findPrefFolder( &foundVRefNum, &foundDirID );
  259.     if( err != noErr ) return;
  260.     
  261.     rRef = HOpenResFile( foundVRefNum, foundDirID, fn, fsRdWrPerm );
  262.     /* don't test rRef here since resource may come from elsewhere, e.g., from appl. */
  263.     hRes = (struct prefs **)GetResource('ePrf', 357);
  264.     if(    hRes != 0 )
  265.     {    pRes = *hRes;
  266.         if( (*pRes).version == 1 )
  267.         {    prefTabs   = (*pRes).tabs;
  268.             prefWrap   = (*pRes).wrap;
  269.             find_ci    = (*pRes).find_ci;
  270.             find_wrap  = (*pRes).find_wrap;
  271.             prefAutoInd = (*pRes).autoInd;
  272.             showPosnP  = (*pRes).showPosnP;
  273.             prefStylNormal = (*pRes).stylNormal;
  274.             prefStylHilite = (*pRes).stylHilite;
  275.             GetFNum( (**hRes).fontnmNormal, &prefStylNormal.tsFont );
  276.             if( prefStylNormal.tsFont < 0 ) prefStylNormal.tsFont = 0;
  277.             GetFNum( (**hRes).fontnmHilite, &prefStylHilite.tsFont );
  278.             if( prefStylHilite.tsFont < 0 ) prefStylHilite.tsFont = 0;
  279.         }
  280.     }
  281.     if( rRef >= 0 ) CloseResFile( rRef );
  282. }
  283.  
  284. /* *** */
  285.  
  286. #define fustItem 3
  287. static short itemtowindid[MAX_NB_WINDOWS];
  288. static short windidtodigit[MAX_NB_WINDOWS];
  289. static short qWindItems = 0;
  290.  
  291. #if GENERATINGPOWERPC
  292. #pragma options align=mac68k
  293. #endif
  294.  
  295. typedef struct { short nbmenus6, right, dummy; struct { MenuHandle mh; short left; } menu[100]; } menu_list;
  296.  
  297. #if GENERATINGPOWERPC
  298. #pragma options align=reset
  299. #endif
  300.  
  301. static short cmd_key_exists( char c )
  302. {
  303.   menu_list **ml = (menu_list **)LMGetMenuList();
  304.   short n = (*ml)->nbmenus6/6;
  305.   short i, j, m, cmd;
  306.   for (i=0; i<n; i++)
  307.   { MenuHandle mh = (*ml)->menu[i].mh;
  308.     m = CountMItems( mh );
  309.     for (j=1; j <= m; j++)
  310.     {
  311.       GetItemCmd( mh, j, &cmd );
  312.       if (cmd == c) return 1;
  313.     }
  314.   }
  315.   return 0;
  316. }
  317.  
  318. static void addWindMenuItem( short id )
  319. {    short d, i, j;
  320.     Str255 title, key = "\p / ";
  321.     WindowPtr wind = wind_table[id].wptr;
  322.     if (qWindItems >= MAX_NB_WINDOWS) return;
  323.     for (d=1; d<10; d++) if (!cmd_key_exists('0'+d)) break;
  324.     if (d < 10) key[3] = '0'+d; else key[2] = ' ';
  325.     windidtodigit[id] = d;
  326.     for (i=0; i < qWindItems; i++)
  327.       if (windidtodigit[itemtowindid[i]] > d) break;
  328.     for (j=qWindItems; j > i; j--) // was: qWindItems-1 -- 1997Jul26 e
  329.       itemtowindid[j] = itemtowindid[j-1];
  330.     itemtowindid[i] = id;
  331.     GetWTitle( wind, title );
  332.     InsertMenuItem( menus[windowsM], key, i+fustItem-1 );
  333.     SetMenuItemText( menus[windowsM], i+fustItem, title );
  334.     qWindItems++;
  335. }
  336.  
  337. static void delWindMenuItem( short id )
  338. {    register short i;
  339.     for(i = 0; i < qWindItems; i++)
  340.     {    if( id == itemtowindid[i] )
  341.         {    DeleteMenuItem( menus[windowsM], i+fustItem );
  342.             for( i++; i < qWindItems; i++ )
  343.                 itemtowindid[i-1] = itemtowindid[i];
  344.             qWindItems--;
  345.             break;
  346.         }
  347.     }
  348. }
  349.  
  350. static void eSmudgeWindow( register short w )
  351. {    register short i;
  352.     if( ! wind_table[w].dirty )
  353.     {    wind_table[w].dirty = 1;
  354.         for( i = 0; i < qWindItems; i++ )
  355.         {    if( w == itemtowindid[i] )
  356.             {    SetItemMark( menus[windowsM], i+fustItem, '◊');
  357.                 break;
  358.             }
  359.         }
  360.     }
  361. }
  362.  
  363. static void eUnSmudgeWindow( register short w, TeHANDLE hTE )
  364. {    register short i;
  365.     (**hTE).dirty = 0;
  366.     if( wind_table[w].dirty )
  367.     {    wind_table[w].dirty = 0;
  368.         for( i = 0; i < qWindItems; i++ )
  369.         {    if( w == itemtowindid[i] )
  370.             {    SetItemMark( menus[windowsM], i+fustItem, 0);
  371.                 break;
  372.             }
  373.         }
  374.     }
  375. }
  376.  
  377. static void eMaybeSmudgeWindow( short w, TeHANDLE hTE )
  378. {
  379.     if( (**hTE).dirty )
  380.         eSmudgeWindow( w );
  381.     else
  382.         eUnSmudgeWindow( w, hTE );    /* for Undo */
  383. }
  384.  
  385. void select_and_show( WindowPtr wptr )
  386. {
  387.   SelectWindow( wptr );
  388.   ShowWindow( wptr );
  389. }
  390.  
  391. /* ************* */
  392.  
  393. static void wind_begin(void)
  394. { short i;
  395.   long result;
  396.   for (i=0; i<MAX_NB_WINDOWS; i++) wind_table[i].in_use = 0;
  397.   InitGraf( &qd.thePort );
  398.   InitFonts();
  399.   FlushEvents( everyEvent, 0 );
  400.   InitWindows();
  401.   InitMenus();
  402.   TEInit();
  403.   eTeInit();
  404.   InitDialogs( 0L );
  405.   InitCursor();
  406.  
  407.   prefStylHilite.tsFace = bold+condense;
  408.  
  409.   menus[appleM] = GetMenu( appleID );
  410.   AppendResMenu( menus[appleM], 'DRVR' );
  411.   menus[fileM]    = GetMenu( fileID );
  412.   menus[editM]    = GetMenu( editID );
  413.   menus[findM]    = GetMenu( findID );
  414.   menus[commandM] = GetMenu( commandID );
  415.   menus[windowsM] = GetMenu( windowsID );
  416.  
  417.   ClearMenuBar();
  418.   for ( (i=appleM); (i<=windowsM); i++ ) InsertMenu(menus[i], 0);
  419.   DrawMenuBar();
  420.   current_menus = 0;
  421.  
  422.   setup_cursors();
  423.  
  424.   find_string =    (unsigned char *)NewPtr( 256 );
  425.   replace_string = (unsigned char *)NewPtr( 256 );
  426.   if( find_string == NULL || replace_string == NULL )
  427.   {    SysBeep(10);
  428.       os_quit();
  429.   }
  430.   find_string[0] = '\0';
  431.   replace_string[0] = '\0';
  432.  
  433.   gCursorRgn = NewRgn();
  434.   SetRectRgn(gCursorRgn, -32768, -32768, 32766, 32766);
  435.   
  436.   empty_buffer = NewPtr( 4 );
  437.   *empty_buffer = 0;
  438.  
  439.   // gHasWNE = TrapExists(_WaitNextEvent);
  440.   // gHasHWPriv = TrapExists(_HWPriv);
  441.   
  442.   gHasStdFile = (Gestalt(gestaltStandardFileAttr, &result) ? false
  443.                   : (result & (1 << gestaltStandardFile58)) != 0);
  444.  
  445.   readPrefs( PREFS_FILENAME );
  446.  
  447.   XlateRETURN = XlateRETURNp;
  448.  
  449.   init_ae();
  450. }
  451.  
  452. static void wind_close( short id )
  453. { TeHANDLE hTE = wind_table[id].hTE;
  454.   if (id == interaction_id)
  455.   { HideWindow( wind_table[id].wptr );
  456.     eTeSetSelect( hTE, 0, eTeTextLength( hTE ));
  457.     eTeDelete( hTE );
  458.   }
  459.   else if (wind_table[id].in_use)
  460.   { wind_table[id].in_use = 0;
  461.     HideWindow( wind_table[id].wptr );
  462.     eTeDispose( hTE );
  463.     delWindMenuItem( id );
  464.     DisposeControl( wind_table[id].vscroll );
  465.     DisposeControl( wind_table[id].hscroll );
  466.     DisposeWindow( wind_table[id].wptr );
  467.     if (wind_table[id].buf != NULL)
  468.     { DisposePtr( wind_table[id].buf ); wind_table[id].buf = NULL; }
  469.     if( wind_table[id].out_buf != NULL )
  470.     { DisposeHandle( wind_table[id].out_buf ); wind_table[id].out_buf = NULL; }
  471.   }
  472. }
  473.  
  474. static void wind_end(void)
  475. { short id;
  476.   for (id=MAX_NB_WINDOWS-1; id>=0; id--) wind_close( id );
  477.   eTePutScrap();
  478. }
  479.  
  480. static pascal click_scroll();
  481.  
  482. static short wind_open( unsigned char *wname, short visible, short goaway, short bold_input )
  483. { Rect viewRect, vScrollRect, bounds;
  484.   short width = 80 /*(screenBits.bounds.right-SBarWidth-2*Border-11)/FontW*/;
  485.   short height;
  486.   short id;
  487.  
  488.   for (id=0; id<MAX_NB_WINDOWS; id++) if (!wind_table[id].in_use) break;
  489.   if (id == MAX_NB_WINDOWS) return -1;
  490.  
  491.   height = (qd.screenBits.bounds.bottom-Border-48-SBarWidth)/FontH - id;
  492.  
  493.   bounds.left   = 3 + id*5;
  494.   bounds.right  = bounds.left + width*FontW + SBarWidth + Border;
  495.   bounds.top    = 41 + id*(FontH+3);
  496.   bounds.bottom = bounds.top + height*FontH + SBarWidth + Border;
  497.  
  498.   wind_table[id].wptr = (WindowPtr )
  499.     NewWindow( NULL, &bounds, wname, visible, documentProc, (WindowPtr)-1L, goaway, 0L );
  500.   if (wind_table[id].wptr == NULL) return -1;
  501.  
  502.   SetPort( wind_table[id].wptr );
  503.   TextFont( prefStylNormal.tsFont );
  504.   TextSize( prefStylNormal.tsSize );
  505.  
  506.   vScrollRect = (*wind_table[id].wptr).portRect;
  507.   vScrollRect.left = vScrollRect.right-SBarWidth;
  508.   vScrollRect.right += 1;
  509.   vScrollRect.bottom -= SBarWidth-1;
  510.   vScrollRect.top -= 1;
  511.  
  512.   wind_table[id].vscroll =
  513.     NewControl( wind_table[id].wptr, &vScrollRect, "\p", 1, 0, 0, 0,
  514.                 scrollBarProc, 0L);
  515.  
  516.   if (wind_table[id].vscroll != NULL)
  517.   { static FontInfo fInfo;
  518.  
  519.     vScrollRect = (*wind_table[id].wptr).portRect;
  520.     vScrollRect.top = vScrollRect.bottom-SBarWidth;
  521.     vScrollRect.bottom += 1;
  522.     vScrollRect.left += (vScrollRect.right-vScrollRect.left)>>1;
  523.     vScrollRect.right -= SBarWidth-1;
  524.     wind_table[id].hscroll =
  525.       NewControl( wind_table[id].wptr, &vScrollRect, "\p", 1, 0, 0, 0,
  526.                 scrollBarProc, 0L);
  527.     if (wind_table[id].hscroll != NULL)
  528.     {
  529.  
  530.       viewRect = (*wind_table[id].wptr).portRect;
  531.       viewRect.top    += Border;
  532.       viewRect.left   += Border;
  533.       viewRect.bottom -= SBarWidth;
  534.       viewRect.right  -= SBarWidth;
  535.  
  536.       wind_table[id].hTE = eTeNew( wind_table[id].wptr, viewRect, prefTabs, prefWrap,
  537.                                       prefAutoInd, wind_table[id].hscroll, wind_table[id].vscroll );
  538.  
  539.       if (wind_table[id].hTE != NULL)
  540.       {
  541.         eTeSetStyles( wind_table[id].hTE, &prefStylNormal, &prefStylHilite );
  542.         wind_table[id].height     = height;
  543.         wind_table[id].bold_input = bold_input;
  544.         wind_table[id].dirty      = 0;
  545.         wind_table[id].pos        = 0;
  546.         wind_table[id].len        = 0;
  547.         wind_table[id].buf        = NULL;
  548.         wind_table[id].out_buf    = NULL;
  549.         wind_table[id].out_len    = 0;
  550.         wind_table[id].is_file    = 0;
  551.         wind_table[id].fss.name[0]= 0;
  552.         wind_table[id].in_use     = 1;
  553.         addWindMenuItem( id );
  554.         return id;
  555.       }
  556.       DisposeControl( wind_table[id].hscroll );
  557.     }
  558.     DisposeControl( wind_table[id].vscroll );
  559.   }
  560.   DisposeWindow( wind_table[id].wptr );
  561.   return -1;
  562. }
  563.  
  564. static short discard_changes( short id )
  565. { Str255 title;
  566.   GetWTitle( wind_table[id].wptr, title );
  567.   ParamText( "\pDiscard changes to \"", title, "\p\"?", "\p" );
  568.   SysBeep( 10 );
  569.   switch (CautionAlert( ok_cancel_alertID, 0L ))
  570.   { case 3: return 1;
  571.     default: return 0;
  572.   }
  573. }
  574.  
  575. static short mem_full = 0;
  576. static short supress_mem_full_dialog = 0;
  577.  
  578. static pascal long mem_full_err( long size )
  579. {
  580.   #pragma unused (size)
  581.   if (mem_full)
  582.   { SetGrowZone( NULL );
  583.       ParamText1( "\pOut of memory.  The application will exit." );
  584.     SysBeep( 10 );
  585.     StopAlert( ok_alertID, 0L );
  586.     ExitToShell();
  587.   }
  588.   mem_full = 1;
  589.   if ( ! supress_mem_full_dialog )
  590.   { ParamText1( "\pOut of memory." );
  591.     SysBeep( 10 );
  592.     StopAlert( ok_alertID, 0L );
  593.   }
  594.   return 0;
  595. }
  596.  
  597. static void already_open_err( Str255 name )
  598. { ParamText( "\p\"", name, "\p\"", "\pis already open.  Close it first." );
  599.   SysBeep( 10 );
  600.   StopAlert( ok_alertID, 0L );
  601. }
  602.  
  603. static void path_too_long_err( Str255 name )
  604. { ParamText( "\pPath to file \"", name, "\p\" is too long.", "\p" );
  605.   SysBeep( 10 );
  606.   StopAlert( ok_alertID, 0L );
  607. }
  608.  
  609. static void wind_err(void)
  610. { ParamText1( "\pCan't open window" );
  611.   SysBeep( 10 );
  612.   StopAlert( ok_alertID, 0L );
  613. }
  614.  
  615. void io_err( short io )
  616. { unsigned char errnostr[16];
  617.   switch (io)
  618.   { case wrPermErr    : ParamText1( "\pCan't write file!" ); break;
  619.     case dupFNErr     : ParamText1( "\pDuplicate file name!" ); break;
  620.     case fBsyErr      : ParamText1( "\pFile is busy!" ); break;
  621.     case vLckdErr     : ParamText1( "\pVolume is locked!" ); break;
  622.     case fLckdErr     : ParamText1( "\pFile is locked!" ); break;
  623.     case fnfErr       : ParamText1( "\pFile not found!" ); break;
  624.     case bdNamErr     : ParamText1( "\pBad filename!" ); break;
  625.     case ioErr        : ParamText1( "\pIO transfer error!" ); break;
  626.     case dskFulErr    : ParamText1( "\pDisk full!" ); break;
  627.     case dirFulErr    : ParamText1( "\pDirectory full!" ); break;
  628.     case mFulErr      : ParamText1( "\pFile is too large for memory!" ); break;
  629.                         
  630.     case -4101          : ParamText1( "\pNo printer selected. Use the Chooser." ); break;
  631.     default           : NumToString( io, errnostr );
  632.                         ParamText( "\pIO Error! Mac error number: ", errnostr, "\p", "\p" );
  633.                         break;
  634.   }
  635.   SysBeep( 10 );
  636.   StopAlert( ok_alertID, 0L );
  637. }
  638.  
  639. static void te_limit_err(void)
  640. { ParamText1( "\pFile unopened due to size limit on buffer (32000 lines)." );
  641.   SysBeep( 10 );
  642.   StopAlert( ok_alertID, 0L );
  643. }
  644.  
  645. static short check_TEWrite( char *ptr, long len, eTeHandle hTE, short bold )
  646. {    eTeWrite( hTE, ptr, len, bold );
  647.     if (mem_full) { mem_full = 0; return 1; }
  648.     return 0;
  649. }
  650.  
  651. short check_TEInsert( char *ptr, long len, eTeHandle hTE, short bold )
  652. {    eTeInsert( hTE, ptr, len, bold );
  653.     if (mem_full) { mem_full = 0; return 1; }
  654.     return 0;
  655. }
  656.  
  657. static short check_TECut( eTeHandle hTE )
  658. { eTeCut( hTE );
  659.   if (mem_full) { mem_full = 0; return 1; }
  660.   return 0;
  661. }
  662.  
  663. static short check_TECopy( eTeHandle hTE )
  664. { eTeCopy( hTE );
  665.   if (mem_full) { mem_full = 0; return 1; }
  666.   return 0;
  667. }
  668.  
  669. static short check_TEPaste( eTeHandle hTE, short bold )
  670. {     eTePaste( hTE, bold );
  671.     if (mem_full) { mem_full = 0; return 1; }
  672.     return 0;
  673. }
  674.  
  675. static short check_TEKey( char c, eTeHandle hTE, short bold, EventRecord *event )
  676. {    eTeKey( hTE, c, (event->message & keyCodeMask) >> 8, event->modifiers, bold );
  677.     if (mem_full) { mem_full = 0; return 1; }
  678.     return 0;
  679. }
  680.  
  681. short getfullpath( 
  682.     short vRefNum,
  683.     long dirID,
  684.     Str255 fName,
  685.     char *Path,
  686.     short MaxLength,
  687.     short warn )
  688. {
  689.   char *p, *q;
  690.   long len;
  691.   CInfoPBRec block;
  692.   Str255 directoryName;
  693.  
  694.   p = &Path[MaxLength];
  695.   *--p = '\0';
  696.  
  697.   len = (unsigned char)fName[0];
  698.   p -= len;
  699.   if (p < Path) goto too_long;
  700.   BlockMove( &fName[1], p, len );
  701.  
  702.   block.dirInfo.ioNamePtr = directoryName;
  703.   block.dirInfo.ioDrParID = dirID;
  704.  
  705.   do
  706.   { block.dirInfo.ioVRefNum = vRefNum;
  707.     block.dirInfo.ioFDirIndex = -1;
  708.     block.dirInfo.ioDrDirID = block.dirInfo.ioDrParID;
  709.  
  710.     if (PBGetCatInfoSync( &block ) != noErr) return 0;
  711.     *--p = ':';
  712.     len = (unsigned char)directoryName[0];
  713.     p -= len;
  714.     if (p < Path) goto too_long;
  715.     BlockMove( &directoryName[1], p, len );
  716.   } while ( block.dirInfo.ioDrDirID != fsRtDirID );
  717.  
  718.   q = Path;
  719.   while (*p != '\0') *q++ = *p++;
  720.   *q = '\0';
  721.  
  722.   return (short )( q - Path );
  723.  
  724.   too_long:
  725.   if (warn) path_too_long_err( fName );
  726.   return 0;
  727. }
  728.  
  729. Point SFGwhere = { 90, 82 };
  730. Point SFPwhere = { 106, 104 };
  731.  
  732. short get_file(
  733.     FSSpec *fss,
  734.     short nbtypes,
  735.     SFTypeList ftypes
  736.    )
  737. {
  738.   StandardFileReply reply;
  739.  
  740.   eTePutScrap();
  741.   if (nbtypes == 0) nbtypes = -1;
  742.   if(gHasStdFile)
  743.   {
  744.     StandardGetFile( 0L, nbtypes, ftypes, &reply );
  745.     *fss = reply.sfFile;
  746.   }
  747.   else
  748.   {
  749.     SFReply reply2;
  750.     long procID;
  751.     SFGetFile( SFGwhere, "\p", 0L, nbtypes, ftypes, 0L, &reply2 );
  752.     if( (reply.sfGood = reply2.good) != 0 )
  753.     {
  754.       GetWDInfo( reply2.vRefNum, &fss->vRefNum, &fss->parID, &procID );
  755.       p_to_p( reply2.fName, fss->name );
  756.     }
  757.   }
  758.   eTeGetScrap();
  759.   return reply.sfGood;
  760. }
  761.  
  762. short put_file(
  763.     FSSpec *fss,
  764.     Str255 prompt,
  765.     Str255 deflt
  766.    )
  767. {
  768.   StandardFileReply reply;
  769.  
  770.   eTePutScrap();
  771.   if(gHasStdFile)
  772.   {
  773.     StandardPutFile( prompt, deflt, &reply );
  774.     *fss = reply.sfFile;
  775.   }
  776.   else
  777.   {
  778.     SFReply reply2;
  779.     long procID;
  780.     SFPutFile( SFPwhere, prompt, deflt, 0L, &reply2 );
  781.     if( (reply.sfGood = reply2.good) != 0 )
  782.     {
  783.       GetWDInfo( reply2.vRefNum, &fss->vRefNum, &fss->parID, &procID );
  784.       p_to_p( reply2.fName, fss->name );
  785.     }
  786.   }
  787.   eTeGetScrap();
  788.   return reply.sfGood;
  789. }
  790.  
  791. static short wptr_to_id( WindowPtr w )
  792. { short id;
  793.   for (id=0; id<MAX_NB_WINDOWS; id++)
  794.     if ((wind_table[id].in_use) && (wind_table[id].wptr == (WindowPtr )w)) return id;
  795.   return -1;
  796. }
  797.  
  798. static void setup_view( short id )
  799. { WindowPtr w = wind_table[id].wptr;
  800.   TeHANDLE hTE = wind_table[id].hTE;
  801.   Rect view = w->portRect;
  802.   view.top    += Border;
  803.   view.left   += Border;
  804.   view.bottom -= SBarWidth;
  805.   view.right  -= SBarWidth;
  806.   eTeNewView( hTE, &view );
  807. }
  808.  
  809. static void really_inval_msgrect( short w )
  810. { GrafPtr port = wind_table[w].wptr;
  811.   Rect r = port->portRect;
  812.   r.right -= (( r.right - r.left ) >> 1 ) + SBarWidth + 1;
  813.   r.top = r.bottom - SBarWidth + 1;
  814.   SetPort( port );
  815.   InvalRect( &r );
  816. }
  817. static void inval_msgrect( short w )
  818. { if ( showPosnP ) wind_table[w].needs_inval_ticks = TickCount();
  819. }
  820.  
  821. #if LiveScrollP
  822. // live scrolling -- 960716 e
  823. static ControlActionUPP vSBarThumbActionProcUPP;
  824. static ControlActionUPP hSBarThumbActionProcUPP;
  825. static ControlHandle globalScroller;
  826. static Rect globalScrollCtlRect;
  827. static eTeHandle globalScrollhTE;
  828. static short globalScrollCntlCode;
  829. static short globalScrollMin;
  830. static short globalScrollMax;
  831. static short globalScrollSize;
  832. static void vSBarThumbActionProc( void )
  833. {
  834.   EventRecord event;
  835.   short cntlVal;
  836.   OSEventAvail(0L, &event); // a NULL event with the global mouse location
  837.   if(    event.where.h > globalScrollCtlRect.left
  838.       && event.where.h < globalScrollCtlRect.right
  839.       // && event.where.v > globalScrollCtlRect.top - 24
  840.       // && event.where.v < globalScrollCtlRect.bottom + 24
  841.     )
  842.   { // in the scrollbar...
  843.     cntlVal = ((event.where.v - globalScrollCtlRect.top) * globalScrollSize)
  844.                 / (globalScrollCtlRect.bottom - globalScrollCtlRect.top);
  845.     if( cntlVal < globalScrollMin ) cntlVal = globalScrollMin;
  846.     if( cntlVal > globalScrollMax ) cntlVal = globalScrollMax;
  847.     if( cntlVal != globalScrollCntlCode )
  848.     {
  849.       SetPort( (**globalScrollhTE).macPort );
  850.       ClipRect( &(**globalScrollhTE).macPort->portRect );
  851.       SetControlValue( globalScroller, cntlVal );
  852.       eTeScroll( globalScrollhTE, 0, cntlVal - globalScrollCntlCode, TRUE );
  853.       globalScrollCntlCode = cntlVal;
  854.       // leave the window clipped to exclude the scrollbar
  855.       //  so TrackControl's drawing is obscured
  856.     }
  857.   }
  858. }
  859. static void hSBarThumbActionProc( void )
  860. {
  861.   EventRecord event;
  862.   short cntlVal;
  863.   OSEventAvail(0L, &event); // a NULL event with the global mouse location
  864.   if(    event.where.v > globalScrollCtlRect.top
  865.       && event.where.v < globalScrollCtlRect.bottom
  866.       // && event.where.h > globalScrollCtlRect.left - 24
  867.       // && event.where.h < globalScrollCtlRect.right + 24
  868.     )
  869.   { // in the scrollbar...
  870.     cntlVal = ((event.where.h - globalScrollCtlRect.left) * globalScrollSize)
  871.                 / (globalScrollCtlRect.right - globalScrollCtlRect.left);
  872.     if( cntlVal < globalScrollMin ) cntlVal = globalScrollMin;
  873.     if( cntlVal > globalScrollMax ) cntlVal = globalScrollMax;
  874.     if( cntlVal != globalScrollCntlCode )
  875.     {
  876.       SetPort( (**globalScrollhTE).macPort );
  877.       ClipRect( &(**globalScrollhTE).macPort->portRect );
  878.       SetControlValue( globalScroller, cntlVal );
  879.       eTeScroll( globalScrollhTE, cntlVal - globalScrollCntlCode, 0, TRUE );
  880.       globalScrollCntlCode = cntlVal;
  881.       // leave the window clipped to exclude the scrollbar
  882.       //  so TrackControl's drawing is obscured
  883.     }
  884.   }
  885. }
  886. static ControlActionUPP init_live_scroll( eTeHandle hTE, ControlHandle theControl )
  887. {
  888.   globalScrollhTE = hTE;
  889.   globalScroller = theControl;
  890.   globalScrollCntlCode = GetControlValue( theControl );
  891.   globalScrollCtlRect = (**theControl).contrlRect;
  892.   LocalToGlobal( (Point *)&(globalScrollCtlRect.top) );      /* topLeft  */
  893.   LocalToGlobal( (Point *)&(globalScrollCtlRect.bottom) );   /* botRight */
  894.   globalScrollMin = GetControlMinimum( theControl );
  895.   globalScrollMax = GetControlMaximum( theControl );
  896.   globalScrollSize = globalScrollMax - globalScrollMin + 1;
  897.   if( (**theControl).contrlRect.left < (**theControl).contrlRect.top ) 
  898.   { // horizontal
  899.     globalScrollCtlRect.left += 24; // arrows
  900.     globalScrollCtlRect.right -= 24;
  901.     globalScrollCtlRect.top -= 2; // mouse slop
  902.     globalScrollCtlRect.bottom += 2;
  903.     if( hSBarThumbActionProcUPP == NULL )
  904.       // no!: hSBarThumbActionProcUPP = NewControlActionProc(hSBarThumbActionProc);
  905.       hSBarThumbActionProcUPP = 
  906.        (ControlActionUPP) NewRoutineDescriptor((ProcPtr)(hSBarThumbActionProc),
  907.                                    kPascalStackBased, GetCurrentArchitecture());
  908.     return hSBarThumbActionProcUPP;
  909.   }
  910.   else
  911.   { // vertical
  912.     globalScrollCtlRect.top += 24; // arrows
  913.     globalScrollCtlRect.bottom -= 24;
  914.     globalScrollCtlRect.left -= 2; // mouse slop
  915.     globalScrollCtlRect.right += 2;
  916.     if( vSBarThumbActionProcUPP == NULL )
  917.       // no!: vSBarThumbActionProcUPP = NewControlActionProc(vSBarThumbActionProc);
  918.       vSBarThumbActionProcUPP = 
  919.        (ControlActionUPP) NewRoutineDescriptor((ProcPtr)(vSBarThumbActionProc),
  920.                                    kPascalStackBased, GetCurrentArchitecture());
  921.     return vSBarThumbActionProcUPP;
  922.   }
  923. }
  924. #endif // LiveScrollP
  925.  
  926. static void content( short id, EventRecord *event )
  927. { WindowPtr w = wind_table[id].wptr;
  928.   eTeHandle hTE = wind_table[id].hTE;
  929.   short cntlCode;
  930.   ControlHandle theControl;
  931.   ChPos oldCaret;
  932.  
  933.   SetPort( w );
  934.   ClipRect( &w->portRect );
  935.   GlobalToLocal( &event->where );
  936.   if ((cntlCode = FindControl( event->where, w, &theControl )) == 0 )
  937.   { if (PtInRect( event->where, &(**hTE).viewRect ))
  938.     { oldCaret = (**hTE).caretChPos;
  939.       eTeClick( hTE, event->where, event->modifiers, event->when );
  940.       if ( *(long *)&oldCaret != *(long *)&(**hTE).caretChPos ) inval_msgrect( id );
  941.     }
  942.   }
  943.   else if (cntlCode == kControlIndicatorPart) // inThumb
  944.   {
  945. #if LiveScrollP
  946.     TrackControl( theControl, event->where, init_live_scroll( hTE, theControl ) );
  947.     SetControlValue( theControl, globalScrollCntlCode );
  948. #else
  949.     cntlCode = GetControlValue( theControl );
  950.     TrackControl( theControl, event->where, 0L );
  951.     if ( ( cntlCode = GetControlValue( theControl ) - cntlCode ) != 0 )
  952.         if( (**theControl).contrlRect.left < (**theControl).contrlRect.top )
  953.             eTeScroll( hTE, cntlCode, 0, TRUE );
  954.         else
  955.             eTeScroll( hTE, 0, cntlCode, TRUE );
  956. #endif
  957.   }
  958.   else
  959.     TrackControl( theControl, event->where, (void *)-1L );
  960. }
  961.  
  962. static void update_window( short w )
  963. { GrafPtr port = wind_table[w].wptr;
  964.   Rect r = port->portRect;
  965.   Str255 tStr;
  966.   eTeHandle hTE;
  967.   r.right -= (( r.right - r.left ) >> 1 ) + SBarWidth + 1;
  968.   r.top = r.bottom - SBarWidth;
  969.   SetPort( port );
  970.   ClipRect( &port->portRect );
  971.   BeginUpdate( port );
  972.   EraseRect( &port->portRect );
  973.   DrawControls( port );
  974.   DrawGrowIcon( port );
  975.   EraseRect( &r );
  976.   MoveTo( r.left, r.top );
  977.   LineTo( r.right, r.top );
  978. #ifdef USE_eTe_debug
  979.   NumToString( eTeTextLength( wind_table[w].hTE ), tStr);
  980.   MoveTo( r.left + 4, r.bottom - 4 );
  981.   ClipRect( &r );
  982.   DrawString( (ConstStr255Param )tStr );
  983. #else
  984.   if ( showPosnP )
  985.   { hTE = wind_table[w].hTE;
  986.     MoveTo( r.left + 4, r.bottom - 4 );
  987.     ClipRect( &r );
  988.     NumToString( (long )(**hTE).caretChPos.v+1, tStr);
  989.     DrawString( (ConstStr255Param )tStr );
  990.     DrawString( "\p:" );
  991.     NumToString( (long )(**hTE).caretChPos.h, tStr);
  992.     DrawString( (ConstStr255Param )tStr );
  993.   }
  994. #endif
  995.   eTeUpdate( wind_table[w].hTE );
  996.   EndUpdate( port );
  997. }
  998.  
  999. static void grow_window( short id, Point p )
  1000. { WindowPtr w = wind_table[id].wptr;
  1001.   long result;
  1002.   Rect r;
  1003.   
  1004.   SetPort( w );
  1005.  
  1006.   /* 16Sep92  e  increase min size for H scroll bar
  1007.   SetRect(&r, 80, 80, screenBits.bounds.right, screenBits.bounds.bottom); */
  1008.   /* 13Oct92  e  per: bernard@sigi.cs.colorado.edu
  1009.   SetRect(&r, 150, 80, screenBits.bounds.right, screenBits.bounds.bottom); */
  1010.   r = (**GetGrayRgn()).rgnBBox;
  1011.   r.top = 80;
  1012.   r.left = 150;
  1013.   /*  13Oct92  e  */
  1014.   result = GrowWindow( w, p, &r );
  1015.   if (result == 0) return;
  1016.   SizeWindow( w, LoWord(result), HiWord(result), 1);
  1017.  
  1018.   InvalRect(&w->portRect);
  1019.   setup_view( id );
  1020.   HideControl( wind_table[id].vscroll );
  1021.   MoveControl( wind_table[id].vscroll, w->portRect.right - SBarWidth, w->portRect.top-1);
  1022.   SizeControl( wind_table[id].vscroll, SBarWidth+1, w->portRect.bottom - w->portRect.top-(SBarWidth-2));
  1023.   HideControl( wind_table[id].hscroll );
  1024.   MoveControl( wind_table[id].hscroll,
  1025.                   w->portRect.right-((w->portRect.right-w->portRect.left)>>1),
  1026.                   w->portRect.bottom - SBarWidth);
  1027.   SizeControl( wind_table[id].hscroll,
  1028.                   ((w->portRect.right-w->portRect.left)>>1)-(SBarWidth-1),
  1029.                   SBarWidth+1);
  1030.   ShowControl( wind_table[id].hscroll );
  1031.   ValidRect(&(*wind_table[id].hscroll)->contrlRect );
  1032.   ShowControl( wind_table[id].vscroll );
  1033.   ValidRect(&(*wind_table[id].vscroll)->contrlRect );
  1034.   update_window( id );
  1035.   /* dunno (sometimes appropriate, sometimes not)... eTeShowCaret( wind_table[id].hTE ); */
  1036. }
  1037.  
  1038. static void put_input( short id, char *ptr, long len, short cr, short flush, short freshline )
  1039. { if (wind_table[id].in_use)
  1040.   { long len1;
  1041.     register long len2 = (wind_table[id].len - wind_table[id].pos);
  1042.     register char *buf, *p1, *p2;
  1043.     if ((len2 < 0) || flush) len2 = 0;
  1044.     len1 = ((cr)?1:0) + len2 + (long)len;
  1045.     buf = NewPtr( len1 );
  1046.     if (buf == NULL) { SysBeep(10); return; }
  1047.     p1 = buf;
  1048.     p2 = wind_table[id].buf + wind_table[id].pos;
  1049.     while (len2 > 0) { *p1++ = *p2++; len2--; }
  1050.     p2 = ptr;
  1051.     while (len > 0) { *p1++ = *p2++; len--; }
  1052.     if (cr) *p1++ = '\r';
  1053.     if (wind_table[id].buf != NULL) DisposePtr( wind_table[id].buf );
  1054.     wind_table[id].buf = buf;
  1055.     wind_table[id].pos = 0;
  1056.     wind_table[id].len = len1;
  1057.     if (freshline)
  1058.     { eTeHandle hTE = wind_table[id].hTE;
  1059.       if ( (**hTE).caretChPos.h > 0 )
  1060.         check_TEInsert( "\r", 1L, hTE, 0 );
  1061.       (**hTE).writeChPos = (**hTE).caretChPos;
  1062.       eTeShowCaret( hTE );
  1063.     }
  1064.   }
  1065. }
  1066.  
  1067. void put_input_str (char *text)
  1068. {
  1069.   check_TEInsert( text, strlen(text), wind_table[interaction_id].hTE, 1 );
  1070.   put_input( interaction_id, text, strlen (text), 1, 0, 1 );
  1071. }
  1072.  
  1073. static void handle_interrupt()
  1074. { interrupted = 1;
  1075. }
  1076.  
  1077. static short open_file( short id, short for_output, short txt, short *io )
  1078. { short refnum;
  1079.   short file_existed = 1;
  1080.   OSErr err;
  1081.   
  1082.   if (for_output)
  1083.   {
  1084.     err = FSpCreate( &wind_table[id].fss, CREATOR, txt ? 'TEXT' : 'DATA', smSystemScript );
  1085.     file_existed = (err == dupFNErr);
  1086.     if ((err != noErr) && !file_existed)
  1087.     { *io = err;  return -1; }
  1088.   }
  1089.   err = FSpOpenDF( &wind_table[id].fss, for_output ? fsRdWrPerm : fsRdPerm, &refnum );
  1090.   if (err != noErr)
  1091.   { *io = err;
  1092.     if (for_output && !file_existed)
  1093.       FSpDelete( &wind_table[id].fss );
  1094.     return -1;
  1095.   }
  1096.   *io = for_output ? SetEOF( refnum, 0L ) : noErr;
  1097.   return refnum;
  1098. }
  1099.  
  1100. static short close_file( short refnum, short *io )
  1101. { *io = FSClose( refnum );
  1102.   return (*io != noErr);
  1103. }
  1104.  
  1105. static short read_file( short id, long line, long chr, long sesz )
  1106. { TeHANDLE hTE = wind_table[id].hTE;
  1107.   short refnum;
  1108.   short io, io2;
  1109.   long pos = 0;
  1110.   short beep = 0;
  1111.   long size, count;
  1112.   ChPos chPos;
  1113.   Handle hData;
  1114.   
  1115.   if ( line > 32768 )
  1116.   { te_limit_err();
  1117.     return 0;
  1118.   }
  1119.   chPos.v = (line==0) ? 0 : line-1;
  1120.   chPos.h = (line==0) ? 0 : chr;
  1121.  
  1122.   SelectWindow( wind_table[id].wptr );
  1123.  
  1124.   if (wind_table[id].dirty)
  1125.     if (!discard_changes( id )) return 0;
  1126.  
  1127.   refnum = open_file( id, 0, 1, &io );
  1128.   if (refnum == -1)
  1129.   { io_err( io );
  1130.     return 0;
  1131.   }
  1132.  
  1133.   // eTeSetTextPtr( hTE, empty_buffer, 1L ); why!? 22Jul96 e
  1134.   io = GetEOF(refnum, &size);
  1135.   if( io == noErr )    {
  1136.     if( (hData = NewHandle( size + 1 )) != 0 )
  1137.     {    HLock( hData );
  1138.         count = size;
  1139.         io = FSRead( refnum, &count, *hData );
  1140.         HUnlock( hData );
  1141.         if( ( io != noErr ) || ( count != size ) )
  1142.         {    DisposeHandle( hData );
  1143.             if ( io == noErr ) io = ioErr;
  1144.             /* io_err( io ); will happen */
  1145.             /* added these next lines 7Jul92  e */
  1146.             mem_full = 0;
  1147.               // eTeSetTextPtr( hTE, empty_buffer, 1L ); why!? 22Jul96 e
  1148.         }
  1149.         else
  1150.         {    ((char *)*hData)[size] = '\0';
  1151.             io = eTeSetTextHandleDetabify( hTE, hData, prefTabs );
  1152.             if ( io == noErr )
  1153.             {   count = eTeChPosToOffset( hTE, chPos );
  1154.                 eTeSetSelect( hTE, count, count + sesz );
  1155.                 eTeShowCaret( hTE );
  1156.             }
  1157.             else
  1158.             {    DisposeHandle( hData );
  1159.                 /* io_err( io ); will happen */
  1160.                 /* added these next lines 7Jul92  e */
  1161.                 mem_full = 0;
  1162.                   eTeSetTextPtr( hTE, empty_buffer, 1L ); // ok
  1163.             }
  1164.           }
  1165.       }
  1166.       else
  1167.       { mem_full = 0; io = mFulErr; }
  1168.   }
  1169.  
  1170.   if (close_file( refnum, &io2 ) || ((io != eofErr) && (io != noErr)))
  1171.   { if ((io != eofErr) && (io != noErr)) io_err( io ); else io_err( io2 );
  1172.       // eSmudgeWindow( id ); why!? 22Jul96 e
  1173.       return 0;
  1174.   }
  1175.   /*  why!? 22Jul96 e
  1176.   if (io != noErr)
  1177.       eSmudgeWindow( id );
  1178.   else */
  1179.       eUnSmudgeWindow( id, hTE );
  1180.   return (io == noErr);
  1181. }
  1182.  
  1183. static void write_file( short id )
  1184. { TeHANDLE hTE = wind_table[id].hTE;
  1185.   short refnum;
  1186.   short io, io2;
  1187.   long count;
  1188.  
  1189.   refnum = open_file( id, 1, 1, &io );
  1190.   if (refnum == -1)
  1191.   { io_err( io );
  1192.     return;
  1193.   }
  1194.  
  1195.   count = eTeTextLength( hTE );
  1196.   io = FSWrite( refnum, &count, *((**hTE).hText) );
  1197.   
  1198.   /* FlushVol added 19Apr93  e  */
  1199.   if ( io == noErr )
  1200.   { io = GetVRefNum( refnum, &io2 );
  1201.       if ( io == noErr )
  1202.         io = FlushVol( 0L, io2 );
  1203.   }
  1204.   
  1205.   if (close_file( refnum, &io2 ) || (io != noErr))
  1206.   { if (io != noErr) io_err( io ); else io_err( io2 );
  1207.     return;
  1208.   }
  1209.   
  1210.   FlushVol( 0L, wind_table[id].fss.vRefNum );
  1211.  
  1212.   eUnSmudgeWindow( id, hTE );
  1213. }
  1214.  
  1215. short edit( FSSpec *fss, long line, long chr, long size )
  1216. { short id;
  1217.   Str255 pname;
  1218.   int len = getfullpath( fss->vRefNum, fss->parID, fss->name, (char *)&pname[1], 254, 1 );
  1219.   pname[0] = len;
  1220.   
  1221.   if (len != 0)
  1222.   { for (id=0; id<MAX_NB_WINDOWS; id++)
  1223.       if WINDOW_OWNS_FILE_P( id, fss )
  1224.         break;
  1225.   }
  1226.   else
  1227.     id = MAX_NB_WINDOWS;
  1228.  
  1229.   if (id == MAX_NB_WINDOWS) id = wind_open( pname, FALSE, TRUE, FALSE );
  1230.   if (id < 0)
  1231.     wind_err();
  1232.   else
  1233.   { wind_table[id].fss = *fss;
  1234.     wind_table[id].is_file = 2;
  1235.     supress_mem_full_dialog = 1;
  1236.     if ( read_file( id, line, chr, size ) || wind_table[id].dirty )
  1237.         select_and_show( wind_table[id].wptr );
  1238.     else
  1239.     {
  1240.         wind_close( id );
  1241.         id = -1;
  1242.     }
  1243.     supress_mem_full_dialog = 0;
  1244.   }
  1245.   return id;
  1246. }
  1247.  
  1248. void save_as( short id, FSSpec *fss )
  1249. { short i;
  1250.   Str255 ppath;
  1251.   int len = getfullpath( fss->vRefNum, fss->parID, fss->name, (char *)&ppath[1], 254, 1 );
  1252.   ppath[0] = len;
  1253.  
  1254.   for (i=0; i<MAX_NB_WINDOWS; i++)
  1255.     if WINDOW_OWNS_FILE_P( i, fss )
  1256.     { already_open_err( ppath );
  1257.       return;
  1258.     }
  1259.   wind_table[id].fss = *fss;
  1260.   if (wind_table[id].is_file != 0)
  1261.   { // don't make console into a file
  1262.     wind_table[id].is_file = 2;
  1263.     SetWTitle( wind_table[id].wptr, ppath );
  1264.   }
  1265.   if ( id != interaction_id )
  1266.   { delWindMenuItem( id );
  1267.     addWindMenuItem( id );
  1268.   }
  1269.   write_file( id );
  1270. }
  1271.  
  1272. static void wind_quit(void)
  1273. { short id;
  1274.   for (id=MAX_NB_WINDOWS-1; id>=0; id--)
  1275.   { if (wind_table[id].in_use && wind_table[id].is_file && wind_table[id].dirty)
  1276.     { if (!discard_changes( id )) gDoQuit = 0;
  1277.       else wind_close( id );
  1278.     }
  1279.   }
  1280.   eTePutScrap();
  1281. }
  1282.  
  1283. static void handle_close( short id )
  1284. { if (wind_table[id].is_file)
  1285.   { if ((wind_table[id].dirty) && (!discard_changes( id ))) return;
  1286.     wind_close( id );
  1287.   }
  1288. }
  1289.  
  1290. static char upcase( char c )
  1291. { if( c >= 'a' &&  c <= 'z' ) return c - 0x20;
  1292.   else return c;
  1293. }
  1294.  
  1295. Boolean find_next( short id )
  1296. { TeHANDLE hTE = wind_table[id].hTE;
  1297.   char *txt = *((**hTE).hText);
  1298.   long pos = eTeChPosToOffset( hTE, (**hTE).selActive ? (**hTE).selEnd : (**hTE).caretChPos );
  1299.   register char *start = txt + pos - 1;
  1300.   register short len = (unsigned char)find_string[0];
  1301.   register char *end = txt + eTeTextLength( hTE ) - len;
  1302.   register short i;
  1303.   Boolean again = TRUE;
  1304.   Str255 ci_string;
  1305.   if ( len == 0 ) goto not_found;
  1306.   if( find_ci )
  1307.   { for (i=len; i>0; i--)
  1308.       ci_string[i] = upcase( find_string[i] );
  1309.     /* ci_string[0] = len; -- not used */
  1310.   }
  1311.   find_begin:
  1312.   while (start < end)
  1313.   { if( find_ci )
  1314.     { for (i=len; i>0; i--)
  1315.         if( upcase( start[i] ) != (char )ci_string[i] ) goto next_pos;
  1316.     }
  1317.     else
  1318.     { for (i=len; i>0; i--)
  1319.         if (start[i] != (char )find_string[i]) goto next_pos;
  1320.     }
  1321.     eTeSetSelect( hTE, (long)(start-txt+1), (long)(start-txt+1+len) );
  1322.     return 1;
  1323.     next_pos:
  1324.     start++;
  1325.   }
  1326.   if( find_wrap && again ) 
  1327.   { start = txt;
  1328.     end = start + pos - len;
  1329.     again = FALSE;
  1330.     goto find_begin;
  1331.   }
  1332. not_found:
  1333.   SysBeep(10);
  1334.   return 0;
  1335. }
  1336.  
  1337. void replace_next( short id )
  1338. { TeHANDLE hTE = wind_table[id].hTE;
  1339.   if ( ! (**hTE).selActive )
  1340.     SysBeep(10);
  1341.   else
  1342.   { long len = (unsigned char)replace_string[0];
  1343.     check_TEInsert( ((char *)replace_string)+1, len, hTE, wind_table[id].bold_input );
  1344.     find_next( id );
  1345.     eTeShowCaret( hTE );
  1346.   }
  1347. }
  1348.  
  1349. void replace_all( short id )
  1350. { TeHANDLE hTE = wind_table[id].hTE;
  1351.   long len = (unsigned char)replace_string[0];
  1352.   
  1353.   if ( (**hTE).selActive )
  1354.   { long pos = eTeChPosToOffset( hTE, (**hTE).selStart );
  1355.     eTeSetSelect( hTE, pos, pos );
  1356.   }
  1357.   while ( find_next( id ) )
  1358.     check_TEInsert( ((char *)replace_string)+1, len, hTE, wind_table[id].bold_input );
  1359.   eTeShowCaret( hTE );
  1360. }
  1361.  
  1362. static void find_dialog( short id )
  1363. { DialogPtr dp;
  1364.   short i, s;
  1365.   Handle h;
  1366.   Rect r;
  1367.   eTePutScrap();
  1368.   ParamText( "\pFind:", "\pReplace with:", "\p", "\p" );
  1369.   dp = GetNewDialog( find_dlogID, 0L, (WindowPtr)-1L );
  1370.   if (dp == NULL) return;
  1371.   GetDialogItem( dp, 3, &i, &h, &r );
  1372.   SetDialogItemText( h, find_string );
  1373.   GetDialogItem( dp, 5, &i, &h, &r );
  1374.   SetDialogItemText( h, replace_string );
  1375.   GetDialogItem( dp, 7, &i, &h, &r);
  1376.   SetControlValue( (ControlHandle )h, find_wrap );
  1377.   GetDialogItem( dp, 8, &i, &h, &r);
  1378.   SetControlValue( (ControlHandle )h, find_ci );
  1379.   SelectDialogItemText( dp, 3, 0, find_string[0] );
  1380.   SetCursor( &qd.arrow );
  1381.   do
  1382.   { ModalDialog( 0L, &s );
  1383.     switch( s )
  1384.     { case 1:
  1385.         GetDialogItem( dp, 3, &i, &h, &r );
  1386.         GetDialogItemText( h, find_string );
  1387.         GetDialogItem( dp, 5, &i, &h, &r );
  1388.         GetDialogItemText( h, replace_string );
  1389.         GetDialogItem( dp, 7, &i, &h, &r);
  1390.         find_wrap = GetControlValue( (ControlHandle )h );
  1391.         GetDialogItem( dp, 8, &i, &h, &r);
  1392.         find_ci   = GetControlValue( (ControlHandle )h );
  1393.         break;
  1394.       case 7:
  1395.       case 8:
  1396.         GetDialogItem( dp, s, &i, &h, &r );
  1397.         SetControlValue( (ControlHandle )h, GetControlValue( (ControlHandle )h ) ^ 1 );
  1398.         break;
  1399.     }
  1400.   } while( s != 1 && s != 2 );
  1401.   CloseDialog( dp );
  1402.   if( s == 1 ) find_next( id );
  1403.   eTeGetScrap();
  1404. }
  1405.  
  1406. static void handle_pgsetup( short id )
  1407. { 
  1408.   TeHANDLE hTE = wind_table[id].hTE;
  1409.   SetCursor(&qd.arrow);
  1410.   PageSetupDialog( hTE );
  1411. }
  1412.  
  1413. static void handle_print( short id )
  1414. { 
  1415.   OSErr err;
  1416.   TeHANDLE hTE = wind_table[id].hTE;
  1417.   
  1418.   SetCursor(&qd.arrow);
  1419.   err = noErr;
  1420.   if ( ! (**hTE).hPrint )
  1421.     err = PageSetupDialog( hTE );
  1422.   if( ! err )
  1423.   {    err = eTePrint( hTE, true, true, wind_table[id].fss.name );
  1424.     eTePrint( nil, false, false, nil );
  1425.   }
  1426.   if( err && err != userCanceledErr && err != iPrAbort ) io_err( err );
  1427. }
  1428.  
  1429. static short handle_menu( long result, short id )
  1430. { short theItem, theMenu, m, w;
  1431.   MenuHandle mh;
  1432.   Str255 name;
  1433.  
  1434.   theItem = LoWord( result );
  1435.   theMenu = HiWord( result );
  1436.   if (theMenu == 0) return 1;
  1437.   mh = GetMenuHandle( theMenu );
  1438.   for (m=appleM; m<=windowsM; m++) if (menus[m] == mh) break;
  1439.   switch (m)
  1440.   { case appleM:
  1441.       if (theItem == 1)
  1442.       { eDoDialog(0);    /* about */
  1443.       }
  1444.       else if (theItem == 2)
  1445.         ;
  1446.       else
  1447.       { GetMenuItemText( menus[appleM], theItem, name );
  1448.         OpenDeskAcc( name );
  1449.       }
  1450.       break;
  1451.     case fileM: 
  1452.       switch (theItem)
  1453.       { case newCommand:
  1454.         { short w = wind_open( "\pUntitled", TRUE, TRUE, FALSE );
  1455.           if (w < 0)
  1456.             wind_err();
  1457.           else
  1458.             wind_table[w].is_file = 1;
  1459.           break;
  1460.         }
  1461.         case openCommand:
  1462.         { short i;
  1463.           for (i=0; i<MAX_NB_WINDOWS; i++) if (!wind_table[i].in_use) break;
  1464.           if (i == MAX_NB_WINDOWS)
  1465.             wind_err();
  1466.           else
  1467.           { FSSpec fss;
  1468.             SFTypeList tl;
  1469.               tl[0] = 'TEXT';
  1470.             if (get_file( &fss, 1, tl ))
  1471.               edit( &fss, 0L, 0L, 0L );
  1472.           }
  1473.           break;
  1474.         }
  1475.         case closeCommand:
  1476.           if (id >= 0)
  1477.             handle_close( id );
  1478.           break;
  1479.         case saveCommand:
  1480.           if (id >= 0)
  1481.             if (wind_table[id].is_file == 2 )
  1482.             { write_file( id );
  1483.               break;
  1484.             }
  1485.         case saveasCommand:
  1486.           if (id >= 0)
  1487.           { FSSpec fss;
  1488.             if (put_file( &fss, "\pSave as:", wind_table[id].fss.name ))
  1489.               save_as( id, &fss );
  1490.           }
  1491.           break;
  1492.         case revertCommand:
  1493.           if (id >= 0)
  1494.             read_file( id, 0L, 0L, 0L );
  1495.           break;
  1496.         case pgsetupCommand:
  1497.           if (id >= 0)
  1498.             handle_pgsetup( id );
  1499.           break;
  1500.         case printCommand:
  1501.           if (id >= 0)
  1502.             handle_print( id );
  1503.           break;
  1504.         case quitCommand:
  1505.           gDoQuit = 1;
  1506.           wind_quit();
  1507.           if (gDoQuit) os_quit();
  1508.           break;
  1509.       }
  1510.       break;
  1511.     case editM: 
  1512.       if (id < 0)
  1513.         SystemEdit(theItem-1);
  1514.       else
  1515.       { TeHANDLE hTE = wind_table[id].hTE;
  1516.         switch (theItem)
  1517.         { case undoCommand:
  1518.             eTeUndo( hTE );
  1519.             eMaybeSmudgeWindow( id, hTE );
  1520.             break;
  1521.           case cutCommand:
  1522.             check_TECut( hTE );
  1523.             eMaybeSmudgeWindow( id, hTE );
  1524.             break;
  1525.           case copyCommand:
  1526.             check_TECopy( hTE );
  1527.             break;
  1528.           case pasteCommand:
  1529.             check_TEPaste( hTE, wind_table[id].bold_input );
  1530.             eMaybeSmudgeWindow( id, hTE );
  1531.             break;
  1532.           case clearCommand:
  1533.             eTeDelete( hTE );
  1534.             eMaybeSmudgeWindow( id, hTE );
  1535.             break;
  1536.           case selAllCommand:
  1537.             eTeSetSelect( hTE, 0, eTeTextLength( hTE ));
  1538.             break;
  1539.           case stylesCommand:
  1540.             eStyleDlg( hTE );
  1541.               break;
  1542.           case showPosnCommand:
  1543.               showPosnP ^= 1;
  1544.             CheckItem( menus[editM], showPosnCommand, showPosnP );
  1545.             for (w=0; w<MAX_NB_WINDOWS; w++)
  1546.                 if (wind_table[w].in_use) really_inval_msgrect( w );
  1547.               break;
  1548.           default: ;
  1549.         }
  1550.         eTeShowCaret( hTE );
  1551.       }
  1552.       break;
  1553.     case findM:
  1554.       if (id >= 0)
  1555.       { TeHANDLE hTE = wind_table[id].hTE;
  1556.         switch (theItem)
  1557.         { case findCommand:
  1558.             find_dialog( id );
  1559.             break;
  1560.           case againCommand:
  1561.             find_next( id );
  1562.             break;
  1563.           case replaceCommand:
  1564.             replace_next( id );
  1565.             eMaybeSmudgeWindow( id, hTE );
  1566.             break;
  1567.           case fEnterCommand:
  1568.           { long sel_sta, sel_end, sel_len = 0;
  1569.             if( (**hTE).selActive ) {
  1570.               sel_sta = eTeChPosToOffset( hTE, (**hTE).selStart );
  1571.               sel_end = eTeChPosToOffset( hTE, (**hTE).selEnd );
  1572.               sel_len = sel_end - sel_sta;
  1573.             }
  1574.             if (sel_len > 0)
  1575.             { if( sel_len > 255 ) sel_len = 255;
  1576.               buf_to_p( (unsigned short)sel_len, *((**hTE).hText) + sel_sta, find_string );
  1577.             }
  1578.             else
  1579.               SysBeep( 1 );
  1580.             break;
  1581.           }
  1582.           case replaceAllCommand:
  1583.             replace_all( id );
  1584.             eMaybeSmudgeWindow( id, hTE );
  1585.             break;
  1586.  
  1587. #if ( CREATOR == 'Moml' )
  1588.  
  1589.           case findErrorCommand:        /* thanks: 26Aug93 PSC */
  1590.           { long sel_sta, sel_end, sel_len = 0;
  1591.             if( (**hTE).selActive ) {
  1592.               sel_sta = eTeChPosToOffset( hTE, (**hTE).selStart );
  1593.               sel_end = eTeChPosToOffset( hTE, (**hTE).selEnd );
  1594.               sel_len = sel_end - sel_sta;
  1595.               sel_len = sel_len > 255 ? 255 : sel_len;
  1596.             }
  1597.             if (sel_len > 0)
  1598.             { extern void find_error(char *);
  1599.               char selection[256];
  1600.               strncpy( selection, (char *)*((**hTE).hText) + sel_sta, sel_len );
  1601.               selection[sel_len] = 0;
  1602.               find_error(selection);
  1603.             }
  1604.             else
  1605.               SysBeep( 1 );
  1606.             break;
  1607.           }
  1608. #endif
  1609.  
  1610.         }
  1611.         eTeShowCaret( hTE );
  1612.       }
  1613.       break;
  1614.     case commandM: 
  1615.       switch (theItem)
  1616.       { case interruptCommand:
  1617.           HiliteMenu(0);
  1618.           handle_interrupt();
  1619.           return 0;
  1620.         default:
  1621.           eDoCommand(theItem);
  1622.           break;
  1623.       }
  1624.       break;
  1625.     case windowsM:
  1626.       switch(theItem)
  1627.       { case 1:
  1628.           select_and_show( wind_table[interaction_id].wptr );
  1629.           break;
  1630.         case 2: /* blank line */
  1631.           break;
  1632.         default:
  1633.           theItem -= fustItem;
  1634.           if(theItem < qWindItems)
  1635.             SelectWindow( wind_table[itemtowindid[theItem]].wptr );
  1636.           break;
  1637.       }
  1638.       break;
  1639.    }
  1640.   HiliteMenu(0);
  1641.   return 1;
  1642. }
  1643.  
  1644. static short do_tasks()
  1645. { short w;
  1646.   register short i;
  1647.   short men;
  1648.   EventRecord event;
  1649.   Rect r;
  1650.   RgnHandle rgn;
  1651.   long ticks = LMGetTicks();
  1652.  
  1653.   for (i=0; i<MAX_NB_WINDOWS; i++)
  1654.     if (wind_table[i].in_use)
  1655.     { if (wind_table[i].out_len > 0)
  1656.       { HLock( wind_table[i].out_buf );
  1657.         check_TEWrite( *wind_table[i].out_buf, (long)wind_table[i].out_len, wind_table[i].hTE, 0 );
  1658.         HUnlock( wind_table[i].out_buf );
  1659.         wind_table[i].out_len = 0;
  1660.       }
  1661.       /* display caret position */
  1662.       if ( wind_table[i].needs_inval_ticks != 0
  1663.            && ( wind_table[i].needs_inval_ticks + 15 ) < ticks )
  1664.       { really_inval_msgrect( i );
  1665.         wind_table[i].needs_inval_ticks = 0;
  1666.       }
  1667.     }
  1668.   w = wptr_to_id( FrontWindow() );
  1669.   if ( (!gInBackground) && (w >= 0) )
  1670.   { Cursor *curs;
  1671.     OSEventAvail(0L, &event); /* This returns a NULL event with the global mouse location */
  1672.     if( gCursRgnOK && PtInRgn( event.where, gCursorRgn ) )
  1673.     { /* punt... SetCursor( current_cursor ); */
  1674.     }
  1675.     else
  1676.     { SetPort( (GrafPtr)wind_table[w].wptr );
  1677.       r = (**wind_table[w].hTE).viewRect;
  1678.       LocalToGlobal((Point *)&(r.top));      /* topLeft  */
  1679.       LocalToGlobal((Point *)&(r.bottom));   /* botRight */
  1680.       if (PtInRect( event.where, &r ))
  1681.       { curs = &ibeam_cursor;
  1682.         RectRgn(gCursorRgn, &r);
  1683.       }
  1684.       else
  1685.       { curs = &qd.arrow;
  1686.         SetRectRgn(gCursorRgn, -32768, -32768, 32766, 32766);
  1687.         rgn = NewRgn();
  1688.         RectRgn(rgn, &r);
  1689.         DiffRgn(gCursorRgn, rgn, gCursorRgn);
  1690.         DisposeRgn(rgn);
  1691.       }
  1692.       if (!gCursRgnOK || current_cursor != curs)
  1693.       { current_cursor = curs;
  1694.         SetCursor( current_cursor );
  1695.       }
  1696.       gCursRgnOK = true;
  1697.     }
  1698.     eTeIdle( wind_table[w].hTE );
  1699.     men = (wind_table[w].is_file == 2 ) ? 1 : 0;
  1700.   }
  1701.   else
  1702.   { SetRectRgn(gCursorRgn, -32768, -32768, 32766, 32766);
  1703.     gCursRgnOK = false;
  1704.     SetCursor(&qd.arrow);
  1705.     men = 2;
  1706.   }
  1707.   
  1708.   // 21Jul96 -- rainy day fund
  1709.   if ( rainy_day_fund == NULL )
  1710.   { rainy_day_fund = NewHandle(0);
  1711.     EmptyHandle( rainy_day_fund );
  1712.   }
  1713.   if ( gLowMemory )
  1714.   { supress_mem_full_dialog = 1;
  1715.     ReallocateHandle ( rainy_day_fund, kRamReserve + kRamSlop );
  1716.     if ( *rainy_day_fund != NULL )
  1717.     { SetHandleSize( rainy_day_fund, kRamReserve );
  1718.       HPurge( rainy_day_fund );
  1719.       gLowMemory = false;
  1720.     }
  1721.     else
  1722.     { men = 3;
  1723.       mem_full = 0;
  1724.     }
  1725.     supress_mem_full_dialog = 0;
  1726.   }
  1727.   else if ( *rainy_day_fund == NULL )
  1728.   { supress_mem_full_dialog = 1;
  1729.     ReallocateHandle( rainy_day_fund, kRamReserve );
  1730.     if ( *rainy_day_fund != NULL ) HPurge( rainy_day_fund );
  1731.     else
  1732.     { ParamText1( "\p We're getting low on memory; closing some windows may help." );
  1733.       SysBeep( 10 );
  1734.       CautionAlert( ok_alertID, 0L );
  1735.       gLowMemory = true;
  1736.       men = 3;
  1737.       mem_full = 0;
  1738.     }
  1739.     supress_mem_full_dialog = 0;
  1740.   }
  1741.   else ;
  1742.  
  1743.   if ( (!gInBackground) && (men != current_menus) )
  1744.   { current_menus = men;
  1745.     switch (men)
  1746.     { case 0:
  1747.       case 1:
  1748.         EnableItem( menus[fileM], newCommand );
  1749.         EnableItem( menus[fileM], openCommand );
  1750.         EnableItem( menus[fileM], saveCommand );
  1751.         EnableItem( menus[fileM], saveasCommand );
  1752.         if (men == 0)
  1753.           DisableItem( menus[fileM], revertCommand );
  1754.         else
  1755.           EnableItem( menus[fileM], revertCommand );
  1756.         EnableItem( menus[fileM], pgsetupCommand );
  1757.         EnableItem( menus[fileM], printCommand );
  1758.         EnableItem( menus[editM], selAllCommand );
  1759.         EnableItem( menus[editM], stylesCommand );
  1760.         EnableItem( menus[editM], showPosnCommand );
  1761.         EnableItem( menus[findM], 0 );
  1762.         break;
  1763.       case 2:
  1764.         EnableItem( menus[fileM], newCommand );
  1765.         EnableItem( menus[fileM], openCommand );
  1766.         DisableItem( menus[fileM], saveCommand );
  1767.         DisableItem( menus[fileM], saveasCommand );
  1768.         DisableItem( menus[fileM], revertCommand );
  1769.         DisableItem( menus[fileM], pgsetupCommand );
  1770.         DisableItem( menus[fileM], printCommand );
  1771.         DisableItem( menus[editM], selAllCommand );
  1772.         DisableItem( menus[editM], stylesCommand );
  1773.         DisableItem( menus[editM], showPosnCommand );
  1774.         DisableItem( menus[findM], 0 );
  1775.         break;
  1776.       case 3:
  1777.         DisableItem( menus[fileM], newCommand );
  1778.         DisableItem( menus[fileM], openCommand );
  1779.         EnableItem( menus[fileM], saveCommand );
  1780.         EnableItem( menus[fileM], saveasCommand );
  1781.         DisableItem( menus[fileM], revertCommand );
  1782.         DisableItem( menus[fileM], pgsetupCommand );
  1783.         DisableItem( menus[fileM], printCommand );
  1784.         DisableItem( menus[editM], selAllCommand );
  1785.         DisableItem( menus[editM], stylesCommand );
  1786.         DisableItem( menus[editM], showPosnCommand );
  1787.         DisableItem( menus[findM], 0 );
  1788.         break;
  1789.     }
  1790.     DrawMenuBar();
  1791.   }
  1792.  
  1793.   if ( (!gInBackground) && (w>=0) )
  1794.   { register EvQElPtr q = (EvQElPtr )LMGetEventQueue();
  1795.     for (q = (EvQElPtr)((QHdrPtr )q)->qHead; q != NULL; q = (EvQElPtr)q->qLink)
  1796.       if ((q->evtQWhat == keyDown) && ((char)q->evtQMessage == '.') &&
  1797.           (q->evtQModifiers & cmdKey))
  1798.       { while (GetNextEvent(keyDownMask+keyUpMask+autoKeyMask,&event) &&
  1799.                !((event.what == keyDown) && ((event.message & charCodeMask) == '.') &&
  1800.                  ((event.modifiers & cmdKey) != 0) )) ;
  1801.         handle_interrupt();
  1802.         return 0;
  1803.       }
  1804.   }
  1805.   return 1;
  1806. }
  1807.  
  1808. /* from MacDTS */
  1809. #define kDITop                    0x0050        /* kTopLeft - for positioning the Disk */
  1810. #define kDILeft                    0x0070        /*   Initialization dialogs. */
  1811.  
  1812. void handle_activate( WindowPtr wptr, Boolean activep )
  1813. { GrafPtr port;
  1814.   Rect r;
  1815.   short w = wptr_to_id( wptr );
  1816.   if( w >= 0 )
  1817.   { port = wind_table[w].wptr;
  1818.     r = port->portRect;
  1819.     r.left = r.right - (SBarWidth+1);
  1820.     SetPort( port );
  1821.     InvalRect( &r );
  1822.     r = port->portRect;
  1823.     r.top = r.bottom - (SBarWidth+1);
  1824.     InvalRect( &r );
  1825.     if ( activep )
  1826.     { eTeActivate( wind_table[w].hTE );
  1827.       ShowControl( wind_table[w].vscroll );
  1828.       ShowControl( wind_table[w].hscroll );
  1829.     }
  1830.     else
  1831.     { eTeDeactivate( wind_table[w].hTE );
  1832.       HideControl( wind_table[w].vscroll );
  1833.       HideControl( wind_table[w].hscroll );
  1834.     }
  1835.   }
  1836. }
  1837.  
  1838. static short handle_event( EventRecord *event )
  1839. { short w;
  1840.   WindowPtr event_window;
  1841.  
  1842. #if (CREATOR == 'Caml') || (CREATOR == 'Moml')
  1843. extern int DoGraphEvent(EventRecord *event, WindowPtr window);
  1844. #endif
  1845.  
  1846.   if (IsDialogEvent( event ))
  1847.   { DialogPtr dp;
  1848.     short item;
  1849.     DialogSelect( event, &dp, &item );
  1850.     return 1;
  1851.   }
  1852.   
  1853.   event_window = FrontWindow();
  1854.   
  1855. #if (CREATOR == 'Caml') || (CREATOR == 'Moml')
  1856.   if ( DoGraphEvent( event, event_window ) ) return 1;
  1857. #endif
  1858.  
  1859.   w = wptr_to_id( event_window );
  1860.   { switch (event->what)
  1861.     { case mouseDown:
  1862.         gCursRgnOK = false;
  1863.         switch (FindWindow(event->where,&event_window))
  1864.         { case inDesk: 
  1865.             SysBeep( 10 );
  1866.             break;
  1867.           case inGoAway:
  1868.             if ((w = wptr_to_id( event_window )) >= 0)
  1869.               if (TrackGoAway(event_window,event->where)) handle_close( w );
  1870.             break;
  1871.           case inMenuBar:
  1872.           { TeHANDLE hTE = NULL;
  1873.             if( w >= 0) hTE = wind_table[w].hTE;
  1874.             eTeEditMenuUpdate( hTE, menus[editM] );
  1875.             return handle_menu( MenuSelect(event->where), w );
  1876.           }
  1877.           case inSysWindow:
  1878.             SystemClick(event,event_window);
  1879.             break;
  1880.           case inDrag:
  1881.             if ((w = wptr_to_id( event_window )) >= 0)
  1882.               DragWindow(event_window,event->where,&qd.screenBits.bounds);
  1883.             break;
  1884.           case inGrow:
  1885.             if ((w = wptr_to_id( event_window )) >= 0)
  1886.               grow_window( w, event->where );
  1887.             break;
  1888.           case inContent:
  1889.             if (event_window != FrontWindow())
  1890.               SelectWindow(event_window);
  1891.             else 
  1892.               if ((w = wptr_to_id( event_window )) >= 0)
  1893.                 content( w, event );
  1894.             break;
  1895.           default: ;
  1896.         }
  1897.         gLastMouseDown = *event;
  1898.         break;
  1899.       case mouseUp:
  1900.         gLastMouseUp = *event;
  1901.         break;
  1902.       case keyDown:
  1903.       case autoKey:
  1904.         { unsigned char c = event->message & charCodeMask;
  1905.           TeHANDLE hTE = (w>=0)?wind_table[w].hTE:NULL;
  1906.           if ((event->modifiers & cmdKey) != 0 && c != 3 )
  1907.           { long res;
  1908.             if (c == '=') c = '+'; else if (c == '/') c = '?';
  1909.             if (hTE != NULL) eTeEditMenuUpdate( hTE, menus[editM] );
  1910.             res = MenuKey( c );
  1911.             if( HiWord( res ) != 0 )
  1912.               return handle_menu( res, w );
  1913.             if( (hTE != NULL) && (c >= 0) && (c <= 31) )
  1914.             {    check_TEKey( c, hTE, 0, event );
  1915.                 inval_msgrect( w );
  1916.             }
  1917.             break;
  1918.           }
  1919.           if (hTE == NULL) break;
  1920. #if LISPmodeP
  1921.           if( ( event->modifiers & controlKey ) != 0 )
  1922.           { eEditCommand( hTE, c, event->modifiers, wind_table[w].bold_input );
  1923.               eMaybeSmudgeWindow( w, hTE );
  1924.               inval_msgrect( w );
  1925.           }
  1926. #endif
  1927.           else if( ( c == 127 /* del fwd */ )  || ( c <= 31 ) )
  1928.           { if( ( c == 3 /*enter*/ ) || (( c == '\r' /*cr*/ ) && ((event->modifiers & optionKey) != 0 )))
  1929.             { short id = (wind_table[w].is_file != 0) ? interaction_id : w;
  1930.               long sel_sta;
  1931.               long sel_end;
  1932.               long sel_len;
  1933. #if EndOfInputP
  1934.               if( event->message >> 24 == 0xee) end_of_input = 1;
  1935. #endif
  1936.               if( (**hTE).selActive ) {
  1937.                   sel_sta = eTeChPosToOffset( hTE, (**hTE).selStart );
  1938.                   sel_end = eTeChPosToOffset( hTE, (**hTE).selEnd );
  1939.               }
  1940.               else
  1941.               { extern void eTeGetRun( eRec **hE, long *sta, long *end );
  1942.                 if ( w == interaction_id )
  1943.                 { long writePos;
  1944.                   eTeGetRun( hTE, &sel_sta, &sel_end );
  1945.                   // try to prevent multiple input of the same text
  1946.                   writePos = eTeChPosToOffset( hTE, (**hTE).writeChPos );
  1947.                   if( sel_sta < writePos && writePos <= sel_end )
  1948.                     sel_sta = writePos;
  1949.                 }
  1950.                 else
  1951. #if LISPmodeP
  1952.                 { sel_end = eTeChPosToOffset( hTE, (**hTE).caretChPos );
  1953.                   sel_sta = balance_bwd( wind_table[w].hTE, 0, 1 );
  1954.                   if (sel_sta < 0) sel_sta = sel_end;
  1955.                 }
  1956. #else
  1957.                   sel_end = sel_sta = eTeChPosToOffset( hTE, (**hTE).caretChPos );
  1958. #endif
  1959.               }
  1960.               eTeSetSelect( hTE, sel_end, sel_end );
  1961.               sel_len = sel_end - sel_sta;
  1962.               HLock((**hTE).hText);
  1963. #ifndef EndOfInputP
  1964. #define end_of_input 0
  1965. #endif
  1966.               if (sel_len > 0)
  1967.                 put_input( id, *((**hTE).hText) + sel_sta, sel_len, !end_of_input, 0, 1 );
  1968.               else
  1969.                 put_input( id, NULL, 0, !end_of_input, 0, 1 ); /*  not done yet!?  12Sep92  e  */
  1970.               HUnlock((**hTE).hText);
  1971.             }
  1972.             else if (c == 9) /*tab*/
  1973.             { eTabCommand( hTE, event->modifiers, wind_table[w].bold_input );
  1974.               eMaybeSmudgeWindow( w, hTE );
  1975.               inval_msgrect( w );
  1976.             }
  1977.             else if ( c == '\b' /*bs*/ // don't bs over writeChPos
  1978.                       && (**hTE).writeChPos.v == (**hTE).caretChPos.v
  1979.                       && (**hTE).writeChPos.h == (**hTE).caretChPos.h
  1980.                     )
  1981.             { SysBeep(3); // add a progressive Alert!
  1982.             }
  1983.             else
  1984.             { check_TEKey( c, hTE, wind_table[w].bold_input, event );
  1985.               if ((c == '\r') && (**hTE).autoInd)
  1986.                 eTabCommand( hTE, optionKey, wind_table[w].bold_input );
  1987.               eMaybeSmudgeWindow( w, hTE );
  1988.               inval_msgrect( w );
  1989.               if ( (c=='\r' /*cr*/) || (c=='\b' /*bs*/) ) eTeShowCaret( hTE );
  1990.             }
  1991.           }
  1992.           else
  1993.           { 
  1994. #if LISPmodeP
  1995.               if (!check_TEKey( c, hTE, wind_table[w].bold_input, event ))
  1996.                 if (c == ')')
  1997.                 { long open_paren = balance_bwd( wind_table[w].hTE, 0, 0 );
  1998.                   if (open_paren >= 0)
  1999.                   { long now;
  2000.                     long selstart = eTeChPosToOffset( hTE, (**hTE).caretChPos );
  2001.                     eTeSetSelect( hTE, open_paren, open_paren+1 );
  2002.                     eTeShowCaret( hTE );
  2003.                     now = TickCount();
  2004.                     while ((TickCount()-now)<10) ;
  2005.                     while (!EventAvail(everyEvent,event) && ((TickCount()-now)<30)) ;
  2006.                     eTeSetSelect( hTE, selstart, selstart );
  2007.                   }
  2008.                 }
  2009. #else
  2010.             check_TEKey( c, hTE, wind_table[w].bold_input, event );
  2011. #endif
  2012.             eMaybeSmudgeWindow( w, hTE );
  2013.             inval_msgrect( w );
  2014.             eTeShowCaret( hTE );
  2015.           }
  2016.         }
  2017.         break;
  2018.       case activateEvt:
  2019.         gCursRgnOK = false;
  2020.           handle_activate( (WindowPtr)event->message, ((event->modifiers & activeFlag) != 0) );
  2021.         break;
  2022.       case updateEvt: 
  2023.         if ((w = wptr_to_id( (WindowPtr)event->message )) >= 0)
  2024.         { update_window(w);
  2025.         }
  2026.         else
  2027.         { GrafPtr port = (WindowPtr)event->message;
  2028.           SetPort( port );
  2029.           BeginUpdate( port );
  2030.           EndUpdate( port );
  2031.         }
  2032.         break;
  2033.       case osEvt:
  2034.         if( *(char *)(&event->message) == suspendResumeMessage )
  2035.         { gCursRgnOK = false; /* Suspend/resume is also an activate/deactivate. */
  2036.           gInBackground = !(event->message & resumeFlag);
  2037.           if( gInBackground ) eTePutScrap();
  2038.           else                  eTeGetScrap();
  2039.           handle_activate( FrontWindow(), !gInBackground );
  2040.         }
  2041.         /* punt mouseMovedMessage */
  2042.         break;
  2043.       case diskEvt:
  2044.         gCursRgnOK = false;                     /* It is not a bad idea to at least call */
  2045.         if (HiWord(event->message) != noErr) /* DIBadMount in response to a diskEvt,  */
  2046.         { Point pt;                             /* so that the user can format a floppy. */
  2047.           SetPt( &pt, kDILeft, kDITop );
  2048.           DIBadMount( pt, event->message );
  2049.         }
  2050.         break;
  2051.       case kHighLevelEvent:
  2052.         AEProcessAppleEvent(event);
  2053.         if (gDoQuit) os_quit();
  2054.         break;
  2055.       default: ;
  2056.     }
  2057.   }
  2058.   return 1;
  2059. }
  2060.  
  2061. long os_get_next_event( EventRecord *event )
  2062. { long result = 0;
  2063.   GrafPtr save;
  2064.   GetPort( &save );
  2065.   if (do_tasks())
  2066.   { beg_mf_time();
  2067.     // if (gHasWNE)
  2068.       { result = (long)( gInBackground ? gWaitTicksBG
  2069.                                          : (long )( (gWaitTicksFG > gMaxSleep) ? gMaxSleep
  2070.                                                                                 : gWaitTicksFG) );
  2071.       result = WaitNextEvent( everyEvent, event, result, gCursorRgn );
  2072.     }
  2073.     // else
  2074.     // { SystemTask();
  2075.     //   result = GetNextEvent( everyEvent, event );
  2076.     // }
  2077.     end_mf_time();
  2078.   }
  2079.   SetPort( save );
  2080.   return result;
  2081. }
  2082.  
  2083. long os_handle_event( EventRecord *event )
  2084. { long result;
  2085.   GrafPtr save;
  2086.   GetPort( &save );
  2087.   result = handle_event( event );
  2088.   SetPort( save );
  2089.   return result;
  2090. }
  2091.  
  2092. void os_event_check( void )
  2093. { EventRecord event;
  2094.   os_get_next_event( &event );
  2095.   os_handle_event( &event );
  2096. #if USE_EVENTCHK_TIMER
  2097.   next_eventchk_ticks = 0;
  2098. #else
  2099.   next_eventchk_ticks = LMGetTicks() + TicksBetweenEventChecks;
  2100. #endif
  2101.   if ( interrupted ) { interrupted = 0; raise(SIGINT); }
  2102. }
  2103.  
  2104. void os_quit()
  2105. { 
  2106. #if ANSIquitP
  2107.   exit(0);
  2108. #else
  2109.   wind_end();
  2110. #if USE_EVENTCHK_TIMER
  2111.   cancel_eck_timer();
  2112. #endif
  2113.   ExitToShell();
  2114. #endif
  2115. }
  2116.  
  2117. /* ******* console io ******* */
  2118.  
  2119. static GrowZoneUPP mem_full_errUPP;
  2120.  
  2121. static short main_internal( )
  2122. { short i;
  2123.   MaxApplZone();
  2124.   for (i = 0; i < 10; i++)
  2125.         MoreMasters();
  2126.   /* CouldAlert( ok_alertID ); */
  2127.   mem_full_errUPP = NewGrowZoneProc(mem_full_err);
  2128.   SetGrowZone( mem_full_errUPP );
  2129.  
  2130.   wind_begin();
  2131.  
  2132. #if ANSIquitP
  2133.   atexit(wind_quit);
  2134. #endif
  2135.  
  2136.   SetCursor( current_cursor );
  2137.  
  2138.   ParamText1( "\p" );
  2139.  
  2140. #if USE_EVENTCHK_TIMER
  2141.   init_eck_timer();
  2142. #endif
  2143.  
  2144.   return 0;
  2145. }
  2146.  
  2147. static short console_initialized = 0;
  2148.  
  2149. WindowPeek os_console_new( unsigned char *name )
  2150. { short id;
  2151.   WindowPeek wp;
  2152.   if( !console_initialized )
  2153.   { main_internal();
  2154.     console_initialized = 1;
  2155.   }
  2156.   id = wind_open( name, FALSE, FALSE, TRUE );
  2157.   if( id < 0 ) return (WindowPeek )0;
  2158.   interaction_id = id;
  2159.   delWindMenuItem( interaction_id );
  2160.   wp = (WindowPeek )wind_table[id].wptr;
  2161.   wp->refCon = (long )id;
  2162.   return(wp);
  2163. }
  2164.  
  2165. long os_console_chars_ready(WindowPeek wp)
  2166. {  short id = wp->refCon;
  2167.    return wind_table[id].len - wind_table[id].pos;
  2168. }
  2169.  
  2170. long os_console_read( WindowPeek wp, unsigned char *ptr, long cnt )
  2171. { 
  2172. #if ReadHangsP
  2173.   long result;
  2174.   do
  2175.   { result = os_console_read_nohang( wp, ptr, cnt );
  2176.   } while (result == 0);
  2177.   return result;
  2178. #else
  2179.   return os_console_read_nohang( wp, ptr, cnt );
  2180. #endif
  2181. }
  2182.  
  2183. long os_console_read_nohang( WindowPeek wp, unsigned char *ptr, long cnt )
  2184. { long result = 0;
  2185.   GrafPtr save;
  2186.   GetPort( &save );
  2187.   if( cnt > 0 )
  2188.   { register unsigned char *p1 = ptr;
  2189.     short id = wp->refCon;
  2190.     EventRecord event;
  2191.     do
  2192.     { os_get_next_event( &event );
  2193.       os_handle_event( &event );
  2194.       if( interrupted )
  2195.         goto ocr_done;
  2196.       else
  2197.       { register unsigned char *p2 = (unsigned char *)wind_table[id].buf + wind_table[id].pos;
  2198.         register long len = wind_table[id].len - wind_table[id].pos;
  2199.         register short i = 0;
  2200.         if (len > cnt) len = cnt;
  2201.         cnt = len; /* nohang */
  2202.         while ( i < len )
  2203.         { register unsigned char c = p2[i++];
  2204.           if (c == '\r')
  2205.           {
  2206.             if (XlateRETURN != 0) c = '\n';
  2207.             len = i; /* to exit inner loop */
  2208.             cnt = i; /* to exit outer loop */
  2209.           }
  2210.           *p1++ = c;
  2211.         }
  2212.         wind_table[id].pos += i;
  2213.         cnt -= i;
  2214.         result += i;
  2215.       }
  2216. #if EndOfInputP
  2217.       if( end_of_input )
  2218.       {
  2219.         // end_of_input = 0;
  2220.         goto ocr_done;
  2221.       }
  2222. #endif
  2223.     } while( cnt > 0 );
  2224.   }
  2225. ocr_done:
  2226.   SetPort( save );
  2227.   return result;
  2228. }
  2229.  
  2230. long os_console_write( WindowPeek wp, unsigned char *ptr, long cnt)
  2231. { long result = 0;
  2232.   GrafPtr save;
  2233.   short id = (short )wp->refCon;
  2234.  
  2235.   GetPort( &save );
  2236.  
  2237.   if (!(wp->visible))
  2238.     select_and_show( (WindowPtr )wp );
  2239.  
  2240.   if (XlateRETURN)
  2241.   {
  2242.     register unsigned char *p1 = ptr, *p2 = ptr+cnt;
  2243.     register short len = wind_table[id].out_len;
  2244.     register unsigned char *p3;
  2245.     if( wind_table[id].out_buf == NULL )
  2246.     { wind_table[id].out_buf = NewHandle( OUT_BUF_LEN );
  2247.       if( wind_table[id].out_buf == NULL )
  2248.       { SysBeep(10);
  2249.         return result;
  2250.       }
  2251.     }
  2252.     HLock( wind_table[id].out_buf );
  2253.     p3 = (unsigned char *)*wind_table[id].out_buf;
  2254.  
  2255.     while( p1 < p2 )
  2256.     { register unsigned char c = *p1++;
  2257.       if (c == '\n') { p3[len++] = '\r'; goto output; }
  2258.       p3[len++] = c;
  2259.       if (len == OUT_BUF_LEN)
  2260.       { output:
  2261.         if( check_TEWrite( (char *)p3, (long)len, wind_table[id].hTE, 0 ) ) goto werror;
  2262.         wind_table[id].out_len = 0;
  2263.         len = 0;
  2264.       }
  2265.     }
  2266.     wind_table[id].out_len = len;
  2267.     result = cnt;
  2268. werror:
  2269.     SetPort( save );
  2270.     HUnlock( wind_table[id].out_buf );
  2271.   }
  2272.   else
  2273.   {
  2274.     if( check_TEWrite( (char *)ptr, (long)cnt, wind_table[id].hTE, 0 ) == 0 )
  2275.       result = cnt;
  2276.   }
  2277.   return result;
  2278. }
  2279.  
  2280. long os_console_close( WindowPeek wp )
  2281. { long result = 0;
  2282.   GrafPtr save;
  2283.   short id = (short )wp->refCon;
  2284.   GetPort( &save );
  2285.   if( id < 0 )
  2286.     result = -1;
  2287.   else
  2288.     wind_close( id );
  2289.   SetPort( save );
  2290.   return result;
  2291. }
  2292.  
  2293. /*--------------------------------------------------------------------------*/
  2294.  
  2295. /* Used to check for any unread required parameters. Returns true if we
  2296. ** missed at least one. */
  2297.  
  2298. static Boolean    MissedAnyParameters(AppleEvent *message)
  2299. {
  2300.     OSErr        err;
  2301.     DescType    ignoredActualType;
  2302.     AEKeyword    missedKeyword;
  2303.     Size        ignoredActualSize;
  2304.     EventRecord    event;
  2305.  
  2306.     err = AEGetAttributePtr(    /* SEE IF PARAMETERS ARE ALL USED UP.          */
  2307.         message,                /* AppleEvent to check.                          */
  2308.         keyMissedKeywordAttr,    /* Look for unread parameters.                  */
  2309.         typeWildCard,            /* So we can see what type we missed, if any. */
  2310.         &ignoredActualType,        /* What it would have been if not coerced.      */
  2311.         (Ptr)&missedKeyword,    /* Data area.  (Keyword not handled.)          */
  2312.         sizeof(missedKeyword),    /* Size of data area.                          */
  2313.         &ignoredActualSize        /* Actual data size.                          */
  2314.     );
  2315.  
  2316. /* No error means that we found some unused parameters. */
  2317.  
  2318.     if (err == noErr) {
  2319.         event.message = *(long *) &ignoredActualType;
  2320.         event.where = *(Point *) &missedKeyword;
  2321.         err = errAEEventNotHandled;
  2322.     }
  2323.  
  2324. /* errAEDescNotFound means that there are no more parameters.  If we get
  2325. ** an error code other than that, flag it. */
  2326.  
  2327.     return(err != errAEDescNotFound);
  2328. }
  2329.  
  2330. #if ( CREATOR == 'Moml' )
  2331.  
  2332. static void get_app_name( void )
  2333. {
  2334.   //unsigned char *CurApName = LMGetCurApName();
  2335.   ProcessInfoRec pir;
  2336.   ProcessSerialNumber psn;
  2337.   char      path[512];
  2338.   short     w;
  2339.   
  2340.   psn.highLongOfPSN = 0;
  2341.   psn.lowLongOfPSN = kCurrentProcess;
  2342.   pir.processInfoLength = sizeof(pir);
  2343.   pir.processName = 0;
  2344.   pir.processAppSpec = &appFSS;
  2345.   GetProcessInformation( &psn, &pir );
  2346.   w = getfullpath( appFSS.vRefNum, appFSS.parID, appFSS.name, path, 511, 1 );
  2347.   e_setenv( "PATH_TRANSLATED", path, 0 );
  2348.   if( image_name == NULL && strcmp( ".app", &path[w-4] ) == 0 && w < 510 )
  2349.   { // make image name from app name: foo.app => foo.image
  2350.     strcpy( &path[w-3], "image" );
  2351.     image_name = malloc( w + 3 );
  2352.     if( image_name ) strncpy( image_name, path, w + 3 );
  2353.   }
  2354.     gMadeAppFSS = true;
  2355. }
  2356.  
  2357. #else
  2358. static void get_app_name( void )
  2359. {
  2360. }
  2361. #endif
  2362.  
  2363. static OSErr    OpenDocEventHandler(AppleEvent *message, AppleEvent *reply, short mode)
  2364. {
  2365.   #pragma unused( reply )
  2366.     OSErr        err;
  2367.     OSErr        err2;
  2368.     AEDesc        theDesc;
  2369.     FSSpec        theFSS;
  2370.     short        loop;
  2371.     long        numFilesToOpen;
  2372.     AEKeyword    ignoredKeyWord;
  2373.     DescType    ignoredType;
  2374.     Size        ignoredSize;
  2375.     char path[512];
  2376.     short w;
  2377.     FInfo theFInfo;
  2378.  
  2379.   if( ! gMadeAppFSS ) get_app_name( );
  2380.  
  2381.     theDesc.dataHandle = nil;
  2382.         /* Make sure disposing of the descriptors is okay in all cases.
  2383.         ** This will not be necessary after 7.0b3, since the calls that
  2384.         ** attempt to create the descriptors will nil automatically
  2385.         ** upon failure. */
  2386.  
  2387.     if ( (err = AEGetParamDesc( message, keyDirectObject, typeAEList, &theDesc )) != 0 )
  2388.         return(err);
  2389.  
  2390.     if ( ! MissedAnyParameters( message ) ) {
  2391.  
  2392. /* Got all the parameters we need.  Now, go through the direct object,
  2393. ** see what type it is, and parse it up. */
  2394.  
  2395.         err = AECountItems(&theDesc, &numFilesToOpen);
  2396.         if (!err)
  2397.         {    /* We have numFilesToOpen that need opening, as either a window
  2398.             ** or to be printed.  Go to it... */
  2399.  
  2400.             for (loop = 1; ((loop <= numFilesToOpen) && (!err)); ++loop)
  2401.             {    err = AEGetNthPtr(        /* GET NEXT IN THE LIST...         */
  2402.                     &theDesc,            /* List of file names.             */
  2403.                     loop,                /* Item # in the list.             */
  2404.                     typeFSS,            /* Item is of type FSSpec.         */
  2405.                     &ignoredKeyWord,    /* Returned keyword -- we know.  */
  2406.                     &ignoredType,        /* Returned type -- we know.     */
  2407.                     (Ptr)&theFSS,        /* Where to put the FSSpec info. */
  2408.                     sizeof(theFSS),        /* Size of the FSSpec info.         */
  2409.                     &ignoredSize        /* Actual size -- we know.         */
  2410.                 );
  2411.                 if (err) break;
  2412.  
  2413.                 FSpGetFInfo( &theFSS, &theFInfo );
  2414.                 if ( theFInfo.fdType != 'TEXT' )
  2415.                 { 
  2416. #ifdef PFILmode
  2417.                   if( theFInfo.fdType == 'FILi' ) pfil_ae_load( &theFSS );
  2418.                   else
  2419. #endif
  2420. #if ( CREATOR == 'Moml' )
  2421.                   w = getfullpath( theFSS.vRefNum, theFSS.parID, theFSS.name, path, 511, 1 );
  2422.                   if( !been_there_done_that && theFInfo.fdType == 'BINA' && theFInfo.fdCreator == 'Moml' )
  2423.                   {
  2424.                     been_there_done_that = true;
  2425.                     image_name = malloc( w + 1 );
  2426.                     if( image_name ) strncpy( image_name, path, w + 1 );
  2427.                   }
  2428.                   else
  2429. #elif ( CREATOR == 's48e' )
  2430.                   char *cmnd = "vm -i ";
  2431.                   w = getfullpath( theFSS.vRefNum, theFSS.parID, theFSS.name, path, 511, 1 );
  2432.                   if ( ( theFInfo.fdType == 'BINA' ) && w )
  2433.                   {
  2434.                     check_TEInsert( cmnd, 6, wind_table[interaction_id].hTE, 1 );
  2435.                     check_TEInsert( path, w, wind_table[interaction_id].hTE, 1 );
  2436.                     put_input( interaction_id, cmnd, 6, 0, 0, 1 );
  2437.                     put_input( interaction_id, path, w, 1, 0, 0 );
  2438.                   }
  2439.                   else
  2440. #else
  2441.           #pragma unused( path )
  2442. #endif
  2443.                   SysBeep( 3 );
  2444.                   continue;
  2445.                 }
  2446.                 gPrintPage = mode;
  2447.                     /* Open the window off-screen if we are printing.
  2448.                     ** We use the gPrintPage global to flag this.  Normally, the
  2449.                     ** gPrintPage global is to tell ImageDocument if we are imaging
  2450.                     ** to the window or to paper.  We don't need it for this yet,
  2451.                     ** as we can't image the document until it is opened.  DoNewWindow()
  2452.                     ** uses gPrintPage as a flag to open the window off-screen, but
  2453.                     ** visible, so that PrintMonitor can use the title of the window
  2454.                     ** as the document name that is being printed. */
  2455.                 
  2456.                 if ( 1 ) /* was ( w ); moved getfullpath inside bin case 18Jul96 e */
  2457.                 {    
  2458.                     w = edit( &theFSS, 0L, 0L, 0L );
  2459.  
  2460.                     if ( gPrintPage && w >= 0 )
  2461.                     {
  2462.                         err  = eTePrint( wind_table[w].hTE, (mode == 2), (loop == 1),
  2463.                                          wind_table[w].fss.name );
  2464.                         mode = 1;    /* No interaction mode (mode == 2) only valid
  2465.                                     ** for the first printed document. */
  2466.                         wind_close( w );
  2467.                     }
  2468.                 }
  2469.                 else err = errAEEventNotHandled;     /* file pathname too long */
  2470.             }
  2471.             if (gPrintPage)
  2472.             {    eTePrint( nil, false, false, nil );  /* cleanup */
  2473.                 gPrintPage = 0;                      /* back to normal */
  2474.             }
  2475.         }
  2476.     }
  2477.     err2 = AEDisposeDesc(&theDesc);
  2478.     return(err ? err : err2);
  2479. }
  2480.  
  2481. static Boolean install_aehandler( AEEventClass cl, AEEventID id, ProcPtr p )
  2482. { OSErr    err;
  2483.   AEEventHandlerUPP upp = NewAEEventHandlerProc(p);
  2484.   
  2485.   if ( upp == NULL ) err = memFullErr;
  2486.   else err = AEInstallEventHandler( cl, id, upp, 0L, false );
  2487.   if (err)
  2488.   { io_err(err);
  2489.     return false;
  2490.   }
  2491.   return true;
  2492. }
  2493.  
  2494. static pascal OSErr    DoAEOpenApplication( AppleEvent *message, AppleEvent *reply, long refcon )
  2495. {
  2496.     #pragma unused( message, reply, refcon )
  2497.     get_app_name( );
  2498.     return(noErr);
  2499. }
  2500.  
  2501. static pascal OSErr    DoAEOpenDocuments( AppleEvent *message, AppleEvent *reply, long refcon )
  2502. {
  2503.     #pragma unused( refcon )
  2504.   gCursRgnOK = false;
  2505.     return( OpenDocEventHandler( message, reply, 0 ) ); /* 0 means regular open document */
  2506. }
  2507.  
  2508. #define kTimeOutInTicks (60 * 30)    /* 30 second timeout. */
  2509.  
  2510. static pascal OSErr    DoAEPrintDocuments(AppleEvent *message, AppleEvent *reply, long refcon)
  2511. {
  2512.     #pragma unused( refcon )
  2513.     short                openMode;
  2514.     ProcessSerialNumber    cpsn, fpsn;
  2515.     Boolean                procsSame;
  2516.  
  2517.   gCursRgnOK = false;
  2518.     openMode = 1;
  2519.     if (!AEInteractWithUser(kTimeOutInTicks, nil, nil))
  2520.         ++openMode;
  2521.  
  2522.     GetCurrentProcess(&cpsn);        /* We may have been moved to the front. */
  2523.     GetFrontProcess(&fpsn);
  2524.     SameProcess(&cpsn, &fpsn, &procsSame);
  2525.     gInBackground = !procsSame;
  2526.  
  2527.     return( OpenDocEventHandler( message, reply, openMode ) );
  2528.   /* openMode is either 1 or 2, depending if user interaction is okay. */
  2529. }
  2530.  
  2531. static pascal OSErr    DoAEQuitApplication( AppleEvent *message, AppleEvent *reply, long refcon )
  2532. {
  2533.     #pragma unused( message, reply, refcon )
  2534.   gCursRgnOK = false;
  2535.     gDoQuit = 1;
  2536.     wind_quit();
  2537.     return( gDoQuit ? noErr : errAEEventNotHandled );
  2538. }
  2539.  
  2540. static OSErr DoScriptAsFile( FSSpec *theFSS )
  2541. {
  2542.     OSErr err = noErr;
  2543.     short len;
  2544.     char  path[512];
  2545.     
  2546.     if( (len = getfullpath( theFSS->vRefNum, theFSS->parID, theFSS->name, path, 511, 1 )) != 0 )
  2547.     {
  2548.         put_input( interaction_id, dosc_open_str, dosc_open_str_sz, 0, 0, 1 );
  2549.         put_input( interaction_id, path, len, 0, 0, 0 );
  2550.         put_input( interaction_id, dosc_clos_str, dosc_clos_str_sz, 1, 0, 0 );
  2551.     }
  2552.     else err = errAEEventNotHandled;
  2553.     return err;
  2554. }
  2555.  
  2556. #ifdef DoSCRIPT
  2557. AppleEvent  gAEEvent;
  2558. AppleEvent  gAEReply;
  2559. int         gAESuspn;
  2560. #endif
  2561.  
  2562. static pascal OSErr DoAEDoScript( AppleEvent *theAEEvent, AppleEvent *theAEReply, long *theRefCon)
  2563. {
  2564.     #pragma unused( theRefCon )
  2565.     OSErr        theErr;
  2566.     DescType    typeCode;
  2567.     Size        sizeOfParam, actualSize;
  2568.     char        ourScriptText[256];
  2569.     FSSpec        ourScriptFSpec;
  2570.  
  2571.     /* Get the script to run */ 
  2572.  
  2573.     theErr = AESizeOfParam( theAEEvent, keyDirectObject, &typeCode, &sizeOfParam);
  2574.     if (theErr != noErr)
  2575.     {    /*
  2576.             If we fail here just return the error. We don't need to do any clean up since 
  2577.             we've allocated nothing on the heap yet.  The Apple Event Manager automatically 
  2578.             adds the error number to the reply as keyErrorNumber for non zero handler returns.
  2579.         */
  2580.         return theErr;
  2581.     }
  2582.     else if ((typeCode == typeChar) || (typeCode == typeStyledText) || (typeCode == typeIntlText))
  2583.     {
  2584.         theErr = AEGetParamPtr( theAEEvent, keyDirectObject, typeChar, &typeCode,
  2585.                                  (Ptr)ourScriptText, sizeof(ourScriptText), &actualSize);
  2586.         if (theErr == noErr)
  2587.             if ( MissedAnyParameters( theAEEvent ) )
  2588.                 theErr = errAEEventNotHandled;
  2589.             else
  2590.             { check_TEInsert( ourScriptText, actualSize, wind_table[interaction_id].hTE, 1 );
  2591.               put_input( interaction_id, ourScriptText, actualSize, 1, 0, 1 );
  2592.             }
  2593.     }
  2594.     else if (typeCode == typeAlias)
  2595.     {
  2596.         theErr = AEGetParamPtr( theAEEvent, keyDirectObject, typeFSS, &typeCode,
  2597.                                 (Ptr)&ourScriptFSpec, sizeof(ourScriptFSpec), &actualSize);
  2598.         if ( theErr == noErr )
  2599.             if ( MissedAnyParameters( theAEEvent ) )
  2600.                 theErr = errAEEventNotHandled;
  2601.             else theErr = DoScriptAsFile( &ourScriptFSpec );
  2602.     }
  2603.     else theErr = errAEEventNotHandled;
  2604. #ifdef DoSCRIPT
  2605.     if ( theErr == noErr )
  2606.     {
  2607.     gAEEvent = *theAEEvent;
  2608.     gAEReply = *theAEReply;
  2609.     gAESuspn = 1;
  2610.     gReceivedAE = -1;
  2611.     return AESuspendTheCurrentEvent( theAEEvent );
  2612.     }
  2613. #else
  2614. #pragma unused( theAEEvent, theAEReply, theRefCon )
  2615. #endif
  2616.     return theErr;
  2617. }
  2618.  
  2619. #ifdef DoSCRIPT
  2620. static pascal OSErr DoAEwww2( AppleEvent *theAEEvent, AppleEvent *theAEReply, long *theRefCon)
  2621. {
  2622.   #pragma unused( theAEEvent, theRefCon )
  2623.   OSErr     theErr = noErr;
  2624.   //char      ourScriptText[256];
  2625.  
  2626.   if( gAESuspn )
  2627.   {
  2628.     TeHANDLE hTE = wind_table[interaction_id].hTE;
  2629.     char *txt;
  2630.     int len = eTeTextLength( hTE );
  2631.     HLock( (**hTE).hText );
  2632.     txt = *((**hTE).hText);
  2633.     theErr = AEPutParamPtr( theAEReply, keyDirectObject, typeChar, (Ptr)txt, len);
  2634.     // sprintf( ourScriptText+1, "www2: %d", err );
  2635.     // ourScriptText[0] = strlen(ourScriptText+1);
  2636.     // DebugStr( (unsigned char *)ourScriptText );
  2637.     HUnlock( (**hTE).hText );
  2638.     gAESuspn = 0;
  2639.   }
  2640.   return theErr;
  2641. }
  2642. #endif
  2643.  
  2644. #if 0
  2645. static pascal OSErr DoAEwww( AppleEvent *theAEEvent, AppleEvent *theAEReply, long *theRefCon)
  2646. {
  2647.   OSErr        theErr;
  2648.   DescType    typeCode;
  2649.   Size        sizeOfParam, actualSize;
  2650.   char        ourScriptText[256];
  2651.   FSSpec        ourScriptFSpec;
  2652.  
  2653.   theErr = AEGetParamPtr( theAEEvent, keyDirectObject, typeChar, &typeCode,
  2654.                              (Ptr)ourScriptText, sizeof(ourScriptText), &actualSize);
  2655.   if (theErr == noErr)
  2656.   { check_TEInsert( ourScriptText, actualSize, wind_table[interaction_id].hTE, 1 );
  2657.     put_input( interaction_id, ourScriptText, actualSize, 1, 0, 1 );
  2658.   }
  2659.   gAEEvent = *theAEEvent;
  2660.   gAEReply = *theAEReply;
  2661.   gAESuspn = 1;
  2662.   return AESuspendTheCurrentEvent( theAEEvent );
  2663. }
  2664. #endif
  2665.  
  2666. #ifdef DoSCRIPT
  2667. OSErr finish_AEDoScript( void )
  2668. {
  2669.   if( gAESuspn )
  2670.   {
  2671.     int i;
  2672.     //  char ourScriptText[256];
  2673.   AEEventHandlerUPP upp = NewAEEventHandlerProc(DoAEwww2);
  2674.     OSErr err = AEResumeTheCurrentEvent( &gAEEvent, &gAEReply, upp, 0 );
  2675.     //  sprintf( ourScriptText+1, "www1: %d %x %x %x", err, gAEEvent, gAEReply, upp );
  2676.     //  ourScriptText[0] = strlen(ourScriptText+1);
  2677.     //  DebugStr( (unsigned char *)ourScriptText );
  2678.     if( gAESuspn && err == noErr ) 
  2679.       for( i = 0; gAESuspn && i < 10; i++ ) os_event_check();
  2680.     return err;
  2681.   }
  2682.   return errAEEventNotHandled;
  2683. }
  2684. #endif
  2685.  
  2686.  
  2687. #ifdef PFILmode
  2688.  
  2689. extern int pfil_ae_eval( char *in_buf, int in_siz, char* ou_buf, int ou_siz );
  2690.  
  2691. static pascal OSErr DoAEDoEval( AppleEvent *theAEEvent, AppleEvent *theAEReply, long *theRefCon)
  2692. {
  2693.     OSErr        theErr;
  2694.     DescType    typeCode;
  2695.     Size        sizeOfParam, actualSize;
  2696.     char        inScriptText[256];
  2697.     char        ouScriptText[256];
  2698.     FSSpec        ourScriptFSpec;
  2699.  
  2700.     /* Get the script to run */ 
  2701.  
  2702.     theErr = AESizeOfParam( theAEEvent, keyDirectObject, &typeCode, &sizeOfParam);
  2703.     if (theErr != noErr)
  2704.     {    return theErr;
  2705.     }
  2706.     else if ((typeCode == typeChar) || (typeCode == typeStyledText) || (typeCode == typeIntlText))
  2707.     {
  2708.         theErr = AEGetParamPtr( theAEEvent, keyDirectObject, typeChar, &typeCode,
  2709.                                  (Ptr)inScriptText, sizeof(inScriptText), &actualSize);
  2710.         if (theErr == noErr)
  2711.             if ( MissedAnyParameters( theAEEvent ) )
  2712.                 theErr = errAEEventNotHandled;
  2713.     }
  2714.     else if (typeCode == typeAlias)
  2715.     {
  2716.         theErr = AEGetParamPtr( theAEEvent, keyDirectObject, typeFSS, &typeCode,
  2717.                                 (Ptr)&ourScriptFSpec, sizeof(ourScriptFSpec), &actualSize);
  2718.         if ( theErr == noErr )
  2719.             if ( MissedAnyParameters( theAEEvent ) )
  2720.                 theErr = errAEEventNotHandled;
  2721.             else theErr = errAEEventNotHandled; /* DoScriptAsFile( &ourScriptFSpec ); */
  2722.     }
  2723.     else theErr = errAEEventNotHandled;
  2724.  
  2725.     if ( theErr == noErr )
  2726.     {
  2727.         actualSize = pfil_ae_eval( inScriptText, actualSize,
  2728.                                    ouScriptText, sizeof(ouScriptText) );
  2729.         theErr = AEPutParamPtr( theAEReply, keyDirectObject, typeChar,
  2730.                                  (Ptr)ouScriptText, actualSize);
  2731.     }
  2732.     return theErr;
  2733. }
  2734.  
  2735. #endif
  2736.  
  2737. static void init_ae()
  2738. {
  2739.     long    result;
  2740.  
  2741.     gHasAppleEvents = (Gestalt(gestaltAppleEventsAttr, &result) ? false : result != 0);
  2742.  
  2743.     if (gHasAppleEvents)
  2744.          install_aehandler( kCoreEventClass, kAEOpenApplication, (ProcPtr )DoAEOpenApplication )
  2745.       && install_aehandler( kCoreEventClass, kAEOpenDocuments, (ProcPtr )DoAEOpenDocuments )
  2746.       && install_aehandler( kCoreEventClass, kAEPrintDocuments, (ProcPtr )DoAEPrintDocuments )
  2747.       && install_aehandler( kCoreEventClass, kAEQuitApplication, (ProcPtr )DoAEQuitApplication )
  2748.       && install_aehandler( kAEMiscStandards, kAEDoScript, (ProcPtr )DoAEDoScript )
  2749.       // && install_aehandler( 'WWWΩ', 'sdoc', (ProcPtr )DoAEwww )
  2750. #ifdef PFILmode
  2751.       && install_aehandler( kAEMiscStandards, (OSType )'eval', (ProcPtr )DoAEDoEval )
  2752. #endif
  2753.     ;
  2754. }
  2755.  
  2756. /*--------------------------------------------------------------------------*/
  2757.  
  2758.