home *** CD-ROM | disk | FTP | other *** search
/ Carousel / CAROUSEL.cdr / mactosh / lang / lsc_tran / TransEdit.c < prev    next >
Text File  |  1989-02-18  |  40KB  |  1,747 lines
  1. /*
  2.     TransEdit.c version 2.0 - TransSkel plug-in module supporting an
  3.     arbitrary number of generic edit windows.  Each window may be
  4.     bound to a file.
  5.  
  6.     *** Requires FakeAlert.c for proper linking! ***
  7.     
  8.     TransSkel and TransEdit are public domain, and are written by:
  9.  
  10.             Paul DuBois
  11.             Wisconsin Regional Primate Research Center
  12.             1220 Capitol Court
  13.             Madison, WI  53715-1299  USA
  14.  
  15.     UUCP:    {harvard,rutgers,ucbvax}!uwvax!rhesus!dubois
  16.     ARPA:    dubois@primate.wisc.edu
  17.  
  18.     This version of TransEdit written for LightspeedC.  LightspeedC
  19.     is a trademark of:
  20.             THINK Technologies, Inc
  21.             420 Bedford Street  Suite 350
  22.             Lexington, MA  02173  USA
  23.  
  24.   History
  25.   08/25/86    Genesis.  Beta version.
  26.   09/15/86    Changed to allow arbitrary number of windows.
  27.   11/04/86    Added conditional stuff to allow compilation in
  28.              single- or multiple-window mode.  Changed version to 1.0.
  29.   01/17/87    Changed version number to 1.01.  The window type when a new
  30.               window is created is documentProc+8 now, so that the window
  31.               will have a zoom box on a machine with 128K ROMS.
  32.               Default file name in SaveFile is initialized after
  33.               SyncAllGlobals - fixing bug found by Owen Hartnett.
  34.   01/29/89    Version 2.0.  Converted to work with TransSkel 2.0.  2-byte and
  35.             4-byte integer types are typedef'ed to Integer and Longint to
  36.             ease porting.  Added SystemEdit check to Edit menu handler.
  37. */
  38.  
  39.  
  40. /*
  41.     The following symbol controls the compile mode.  If it is #define'd,
  42.     TransEdit allows only a single edit window, and generates less code.
  43.     If it is #undef'ed, TransEdit allows an arbitrary number of edit
  44.     windows, but generates more code.
  45. */
  46.  
  47. # undef    singleEdit
  48.  
  49.  
  50. # include    "TransEdit.h"
  51. # include    <ControlMgr.h>    /* includes WindowMgr.h, QuickDraw.h, MacTypes.h */
  52. # include    <StdFilePkg.h>
  53. # include    <FileMgr.h>
  54. # include    <ToolBoxUtil.h>
  55.  
  56.  
  57. typedef    int        Integer;    /* compiler 2-byte integer type */
  58. typedef    long    Longint;    /* compiler 4-byte integer type */
  59.  
  60.  
  61. /*
  62.     Edit window types, constants, variables.
  63. */
  64.  
  65.  
  66. # define    enter            3
  67. # define    cr                13
  68. # define    monaco            4
  69. # define    shiftKey        0x0200
  70.  
  71.  
  72. typedef enum            /* Edit menu item numbers */
  73. {
  74.     undo = 1,
  75.     /* --- */
  76.     cut = 3,
  77.     copy,
  78.     paste,
  79.     clear        /* (it's ok if the host doesn't have this item) */
  80. };
  81.  
  82.  
  83. /*
  84.     Default values for edit window text display characteristics
  85.     and event notification procedures
  86. */
  87.  
  88. static Integer    e_font = monaco;    /* default font                 */
  89. static Integer    e_size = 9;            /* default pointsize            */
  90. static Integer    e_wrap = 0;            /* default word wrap (on)       */
  91. static Integer    e_just = teJustLeft;/* default justification        */
  92. static ProcPtr    e_key = nil;        /* default key procedure        */
  93. static ProcPtr    e_activate = nil;    /* default activation procedure */
  94. static ProcPtr    e_close = nil;        /* default close procedure      */
  95.  
  96.  
  97. # ifndef    singleEdit
  98.  
  99. /*
  100.     New(TypeName) returns handle to new object, for any TypeName.
  101.     If there is insufficient memory, the result is nil.
  102. */
  103.  
  104. # define    New(x)    (x **) NewHandle ((Size) sizeof (x))
  105.  
  106.  
  107. /*
  108.     ewList points to a list of structures describing the known edit
  109.     windows.
  110. */
  111.  
  112.  
  113. typedef struct EditInfo
  114. {
  115.     WindowPtr        editWind;    /* the edit window                   */
  116.     Boolean            bound;        /* whether window is bound to file   */
  117.     SFReply            editFile;    /* file it's bound to, if bound true */
  118.     TEHandle        editTE;        /* window text                       */
  119.     Boolean            dirty;        /* whether text modified since save  */
  120.     ControlHandle    scroll;        /* scroll bar                        */
  121.     Integer            visLines;    /* # lines visible in window, max    */
  122.     ProcPtr            eKey;        /* key click notifier                */
  123.     ProcPtr            eActivate;    /* activate event notifier           */
  124.     ProcPtr            eClose;        /* close notifier                    */
  125.     struct EditInfo    **eNext;    /* next information structure        */
  126. } EditInfo, *EIPtr, **EIHandle;
  127.  
  128.  
  129. static EIHandle        ewList = nil;
  130.  
  131. # endif
  132.  
  133.  
  134. /*
  135.     Global variables - most of these are always synced to
  136.     the current window.  Note that not all these are set by
  137.     SyncGlobals, since some are not often needed.  When they
  138.     are all needed, use SyncAllGlobals.
  139. */
  140.  
  141. # ifndef    singleEdit
  142. static EIHandle            editInfo;        /* window's info structure      */
  143. # endif
  144.  
  145. static WindowPtr        editWind = nil;    /* the window                   */
  146. static TEHandle            editTE;            /* window text                  */
  147. static ControlHandle    editScroll;        /* the scroll bar               */
  148. static SFReply            editFile;        /* file information             */
  149. static Integer            visLines;        /* number of lines in window    */
  150. static Boolean            bound;            /* true if window bound to file */
  151. static Boolean            dirty;            /* whether window is dirty      */
  152. static ProcPtr            eKey;            /* key click notifier           */
  153. static ProcPtr            eActivate;        /* activate event notifier      */
  154. static ProcPtr            eClose;            /* close notifier               */
  155.  
  156.  
  157. static Integer    windID = 0;
  158. static Point    dlogWhere = { 70, 100 };    /* GetFile/PutFile location */
  159. static OSType    creator = 'TEDT';            /* default file creator */
  160.  
  161. static RgnHandle    clipRgn;
  162.  
  163.  
  164. /* -------------------------------------------------------------------- */
  165. /*                Miscellaneous Internal (private) Routines                */
  166. /* -------------------------------------------------------------------- */
  167.  
  168.  
  169. /*
  170.     Save and restore the current window's clip region
  171. */
  172.  
  173. static SaveClipRgn ()
  174. {
  175.     clipRgn = NewRgn ();
  176.     GetClip (clipRgn);
  177. }
  178.  
  179.  
  180. static RestoreClipRgn ()
  181. {
  182.     SetClip (clipRgn);
  183.     DisposeRgn (clipRgn);
  184. }
  185.  
  186.  
  187. /*
  188.     Draw grow box in lower right hand corner of window.
  189. */
  190.  
  191.  
  192. static DrawGrowBox ()
  193. {
  194. Rect    r;
  195.  
  196.     SaveClipRgn ();
  197.     r = editWind->portRect;
  198.     r.left = r.right - 15;        /* draw only in corner */
  199.     r.top = r.bottom - 15;
  200.     ClipRect (&r);
  201.     DrawGrowIcon (editWind);
  202.     RestoreClipRgn ();
  203. }
  204.  
  205.  
  206. /* -------------------------------------------------------------------- */
  207. /*            Lowest-level Internal (Private) Edit Window Routines        */
  208. /* -------------------------------------------------------------------- */
  209.  
  210.  
  211. # ifndef    singleEdit
  212.  
  213. /*
  214.     Get edit window info associated with window.
  215.     Return nil if window isn't a known edit window.
  216. */
  217.  
  218. static EIHandle GetEInfo (theWind)
  219. WindowPtr    theWind;
  220. {
  221. register EIHandle    h;
  222.  
  223.     for (h = ewList; h != nil; h = (**h).eNext)
  224.     {
  225.         if ((**h).editWind == theWind)
  226.             return (h);
  227.     }
  228.     return (nil);
  229. }
  230.  
  231. # endif
  232.  
  233.  
  234. # ifdef    singleEdit
  235. # define    SyncAllGlobals    SyncGlobals
  236. # endif
  237.  
  238.  
  239. /*
  240.     Synchronize globals to an edit window and make it the
  241.     current port.  theWind must be a legal edit window, with one
  242.     exception:  if theWind is nil, the variables are synced to the
  243.     port that's already current.  That is safe (and correct) because:
  244.     (i)     nil is only passed by edit window handler procedures,
  245.          which are only attached to edit windows
  246.     (ii) For those handler procs that pass nil, TransSkel either sets
  247.          the port to the window before calling the proc (update, clobber,
  248.          idle procs), or the window is frontmost, and so will be the
  249.          current port anyway (mouse, key procs).
  250.     Hence, using the current port under these circumstances always
  251.     produces a legal edit window.
  252. */
  253.  
  254. static SyncGlobals (theWind)
  255. WindowPtr    theWind;
  256. {
  257.  
  258.     if (theWind == nil)                    /* use current window */
  259.         GetPort (&theWind);
  260.  
  261.     SetPort (theWind);
  262.  
  263. # ifndef    singleEdit
  264.  
  265. /*
  266.     Don't need to set these if singleEdit - they will have been set
  267.     in NewEWindow...
  268. */
  269.  
  270.     editWind = theWind;
  271.     editInfo = GetEInfo (editWind);
  272.     editTE = (**editInfo).editTE;
  273.     editScroll = (**editInfo).scroll;
  274.     visLines = (**editInfo).visLines;
  275.  
  276. # endif
  277.  
  278. }
  279.  
  280.  
  281. # ifndef    singleEdit
  282.  
  283. static SyncAllGlobals (theWind)
  284. WindowPtr    theWind;
  285. {
  286.  
  287.     SyncGlobals (theWind);                /* sync display globals */
  288.     editFile = (**editInfo).editFile;    /* sync file, state, and */
  289.     bound = (**editInfo).bound;            /* procedure globals */
  290.     dirty = (**editInfo).dirty;
  291.     eKey = (**editInfo).eKey;
  292.     eActivate = (**editInfo).eActivate;
  293.     eClose = (**editInfo).eClose;
  294. }
  295.  
  296. # endif
  297.  
  298.  
  299. /*
  300.     Set dirty flag for current window
  301. */
  302.  
  303. static SetDirty (boolVal)
  304. Boolean    boolVal;
  305. {
  306.  
  307. # ifdef    singleEdit
  308.     dirty = boolVal;
  309. # else
  310.     (**editInfo).dirty = boolVal;
  311. # endif
  312. }
  313.  
  314.  
  315. /* -------------------------------------------------------------------- */
  316. /*                    Internal (private) Display Routines                    */
  317. /* -------------------------------------------------------------------- */
  318.  
  319.  
  320. /*
  321.     Calculate the dimensions of the editing rectangle for
  322.     editWind (which must be set properly and is assumed to be
  323.     the current port).  (The viewRect and destRect are the
  324.     same size.)  Assumes the port, text font and text size are all
  325.     set properly.  The viewRect is sized so that an integral
  326.     number of lines can be displayed in it, i.e., so that a
  327.     partial line never shows at the bottom.  If that's not
  328.     done, funny things can happen to the caret.
  329. */
  330.  
  331. static GetEditRect (r)
  332. Rect    *r;
  333. {
  334. FontInfo        f;
  335. register Integer    lineHeight;
  336.  
  337.     GetFontInfo (&f);
  338.     lineHeight = f.ascent + f.descent + f.leading;
  339.     *r = editWind->portRect;
  340.     r->left += 4;
  341.     r->right -= 17;        /* leave room for scroll bar */
  342.     r->top += 2;
  343.     r->bottom = r->top + ((r->bottom - r->top - 2) / lineHeight) * lineHeight;
  344. }
  345.  
  346.  
  347. /*
  348.     Set the edit rect properly.
  349. */
  350.  
  351. static SetEditRect ()
  352. {
  353. Rect    r;
  354.  
  355.     GetEditRect (&r);
  356.     (**editTE).destRect.right = r.right;
  357.     (**editTE).viewRect = r;
  358. }
  359.  
  360.  
  361.  
  362. /*
  363.     Calculate the dimensions of the scroll bar rectangle for
  364.     editWind (which must be set properly).  Make sure that
  365.     the edges overlap the window frame and the grow box.
  366. */
  367.  
  368. static CalcScrollRect (r)
  369. Rect        *r;
  370. {
  371.     *r = editWind->portRect;
  372.     ++r->right;
  373.     --r->top;
  374.     r->left = r->right - 16;
  375.     r->bottom -= 14;
  376. }
  377.  
  378.  
  379. /*
  380.     Return true if the mouse is in the non-scrollbar part of the
  381.     edit window.
  382. */
  383.  
  384. static Boolean PtInText (pt)
  385. Point    pt;
  386. {
  387. Rect    r;
  388.  
  389.     r = editWind->portRect;
  390.     r.right -= 15;
  391.     return (PtInRect (pt, &r));
  392. }
  393.  
  394.  
  395. /*
  396.     Set the cursor appropriately.  If theCursor == iBeamCursor, check
  397.     that it's really in the text area of an edit window (and if not
  398.     set the cursor to an arrow instead).  Otherwise, set the cursor
  399.     to the given type (usually a watch).
  400.  
  401.     If the cursor is supposed to be set to an i-beam, it is assumed
  402.     that the globals are synced, because DoCursor changes them and
  403.     syncs them back.
  404.  
  405.     Pass -1 for theCursor to set the cursor to the arrow.
  406. */
  407.  
  408. static DoCursor (theCursor)
  409. Integer    theCursor;
  410. {
  411. Point    pt;
  412. GrafPtr    savePort;
  413.  
  414.     if (theCursor == iBeamCursor)            /* check whether there's an edit */
  415.     {                                        /* window in front and if so,    */
  416.         theCursor = -1;                        /* whether the cursor's in its   */
  417.         if (IsEWindow (FrontWindow ()))        /* text area                     */
  418.         {
  419.             GetPort (&savePort);
  420.             SyncGlobals (FrontWindow ());
  421.             GetMouse (&pt);
  422.             if (PtInText (pt))
  423.                 theCursor = iBeamCursor;
  424.             SyncGlobals (savePort);
  425.         }
  426.     }
  427.     SetCursor (theCursor == -1 ? &arrow : *GetCursor (theCursor));
  428. }
  429.  
  430.  
  431. /*
  432.     Calculate the number of lines currently scrolled off
  433.     the top.
  434. */
  435.  
  436. static LinesOffTop ()
  437. {
  438. register TEPtr    ePtr;
  439.  
  440.     ePtr = *editTE;
  441.     return (((*ePtr).viewRect.top - (*ePtr).destRect.top)
  442.                 / (*ePtr).lineHeight);
  443. }
  444.  
  445.  
  446. /*
  447.     Return the line number that the caret (or the beginning of
  448.     the currently selected text) is in.  Value returned is in
  449.     the range 0..(**editTE).nLines.  If = (**editTE).nLines, the
  450.     caret is past the last line.  The only special case to watch out
  451.     for is when the caret is at the very end of the text.  If the
  452.     last character is not a carriage return, then the caret is on
  453.     the (nLines-1)th line, not the (nLines)th line.
  454.  
  455.     (This really should do a binary search for speed.)
  456. */
  457.  
  458. static LineWithCaret ()
  459. {
  460. register Integer    i;
  461. register Integer    nLines;
  462. register Integer    teLength;
  463. register Integer    selStart;
  464. register Integer    lineStart;
  465.  
  466.     selStart = (**editTE).selStart;
  467.     nLines = (**editTE).nLines;
  468.     teLength = (**editTE).teLength;
  469.  
  470.     if (selStart == teLength)
  471.     {
  472.         if (teLength != 0 && (*((**editTE).hText))[teLength-1] != cr)
  473.             return (nLines - 1);
  474.         return (nLines);
  475.     }
  476.  
  477.     for (i = 0; /* empty */; ++i)
  478.     {
  479.         if ((lineStart = (**editTE).lineStarts[i]) >= selStart)
  480.         {
  481.             if (lineStart != selStart)
  482.                 --i;
  483.             return (i);
  484.         }
  485.     }
  486. }
  487.  
  488.  
  489. /*
  490.     Return the number of the last displayable line.  That's one
  491.     more than nLines if the text is empty or the last character
  492.     is a carriage return.
  493. */
  494.  
  495. static LastLine ()
  496. {
  497. register Integer    nLines;
  498. register Integer    teLength;
  499.  
  500.     nLines = (**editTE).nLines;
  501.     teLength = (**editTE).teLength;
  502.  
  503.     if (teLength == 0 || (*((**editTE).hText))[teLength-1] == cr)
  504.         nLines++;
  505.     return (nLines);
  506. }
  507.  
  508.  
  509. /*
  510.     Set the maximum value of the scroll bar.  It's set so that if
  511.     there's more text than fits in the window, the bottom line can
  512.     be scrolled up at least a little below the bottom of the window.
  513.  
  514.     The shenanigans with topLines and scrollableLines have to do with
  515.     the case where there may be less text than fills the window, but
  516.     most of it's scrolled off the top.  This can happen when you
  517.     scroll a bunch of stuff up, then delete everything visible in
  518.     the window.
  519. */
  520.  
  521. static SetScrollMax ()
  522. {
  523. register Integer    topLines;
  524. register Integer    scrollableLines;
  525. register Integer    max;
  526.  
  527.     topLines = LinesOffTop ();
  528.     scrollableLines = LastLine () - visLines;
  529.     max = (topLines > scrollableLines ? topLines : scrollableLines);
  530.  
  531.     if (max < 0)
  532.         max = 0;
  533.  
  534.     if (max != GetCtlMax (editScroll))
  535.     {
  536.         SetCtlMax (editScroll, max);
  537.         HiliteControl (editScroll, max > 0 ? 0 : 255);
  538.     }
  539. }
  540.  
  541.  
  542. /*
  543.     Set scroll bar current value (but only if it's different than
  544.     the current value, to avoid needless flashing).
  545. */
  546.  
  547. static SetScrollValue (value)
  548. Integer    value;
  549. {
  550.     if (GetCtlValue (editScroll) != value)
  551.         SetCtlValue (editScroll, value);
  552. }
  553.  
  554.  
  555. /*
  556.     Scroll to the correct position.  lDelta is the
  557.     amount to CHANGE the current scroll setting by.
  558. */
  559.  
  560. static ScrollText (lDelta)
  561. Integer    lDelta;
  562. {
  563. register Integer    topVisLine;
  564. register Integer    newTopVisLine;
  565.  
  566.     topVisLine = LinesOffTop ();
  567.     newTopVisLine = topVisLine + lDelta;
  568.     if (newTopVisLine < 0)                    /* clip to range */
  569.         newTopVisLine = 0;
  570.     if (newTopVisLine > GetCtlMax (editScroll))
  571.         newTopVisLine = GetCtlMax (editScroll);
  572.     SetScrollValue (newTopVisLine);
  573.     TEScroll (0, (topVisLine-newTopVisLine )*(**editTE).lineHeight, editTE);
  574. }
  575.  
  576.  
  577. /*
  578.     Scroll to home position without redrawing.
  579. */
  580.  
  581. static ScrollToHome ()
  582. {
  583. Rect                r;
  584.  
  585.     r = (**editTE).destRect;
  586.     OffsetRect (&r, 0, 2 - r.top);
  587.     (**editTE).destRect = r;
  588. }
  589.  
  590. /*
  591.     ClikLoop proc for autoscrolling text when the mouse is dragged out
  592.     of the text view rectangle.
  593.  
  594.     The clipping region has to be set to include the scroll bar,
  595.     because whenever this proc is called, TE has the region set down
  596.     to the view rectangle - if it's not reset, changes to the scroll
  597.     bar will not show up!
  598. */
  599.  
  600. static pascal Boolean AutoScroll ()
  601. {
  602. Point    p;
  603. Rect    r;
  604.  
  605.     SaveClipRgn ();
  606.     ClipRect (&editWind->portRect);
  607.     GetMouse (&p);
  608.     r = (**editTE).viewRect;
  609.     if (p.v < r.top)
  610.         ScrollText (-1);
  611.     else if (p.v > r.bottom)
  612.         ScrollText (1);
  613.     RestoreClipRgn ();
  614.     return (true);            /* true = 'keep tracking mouse' */
  615. }
  616.  
  617.  
  618. /*
  619.     Filter proc for tracking mousedown in scroll bar.  The code for
  620.     the part originally hit is shoved into the control's reference
  621.     value by Mouse() before this is called.
  622.  
  623.     I suspect odd scrolling may occur for hits in paging regions if
  624.     the window is allowed to size such that less than two lines show.
  625. */
  626.  
  627. static pascal void TrackScroll (theScroll, partCode)
  628. ControlHandle    theScroll;
  629. Integer            partCode;
  630. {
  631. register Integer    lDelta;
  632.  
  633.     if (partCode == GetCRefCon (theScroll))    /* still in same part? */
  634.     {
  635.         switch (partCode)
  636.         {
  637.             case inUpButton: lDelta = -1; break;
  638.             case inDownButton: lDelta = 1; break;
  639.             case inPageUp: lDelta = -(visLines - 1); break;
  640.             case inPageDown: lDelta = visLines - 1; break;
  641.         }
  642.         ScrollText (lDelta);
  643.     }
  644. }
  645.  
  646.  
  647. /*
  648.     Set the scroll bar properly and adjust the text in the
  649.     window so that the line containing the caret is visible.
  650.     If the line with the caret if more than a line outside of
  651.     the viewRect, try to place it in the middle of the window.
  652.  
  653.     Yes, it is necessary to SetScrollMax at the end.
  654. */
  655.  
  656. static AdjustDisplay ()
  657. {
  658. register Integer    caretLine;
  659. register Integer    topVisLine;
  660. register Integer    d;
  661.  
  662.     SetScrollMax ();
  663.     caretLine = LineWithCaret ();
  664.     topVisLine = LinesOffTop ();
  665.     if ((d = caretLine - topVisLine) < 0)
  666.         ScrollText (d == -1 ? -1 : d - visLines / 2);
  667.     else if (( d = caretLine - (topVisLine + visLines - 1)) > 0)
  668.         ScrollText (d == 1 ? 1 : d + visLines / 2);
  669.     else
  670.         SetScrollValue (topVisLine);
  671.     SetScrollMax ();    /* might have changed from scrolling */
  672. }
  673.  
  674.  
  675. /*
  676.     Overhaul the entire display.  This is called for major
  677.     catastrophes, such as resizing the window, or changes to
  678.     the word wrap style.  It makes sure the view and
  679.     destination rectangles are sized properly, and that the bottom
  680.     line of text never scrolls up past the bottom line of the
  681.     window, if there's enough to fill the window, and that the
  682.     scroll bar max and current values are set properly.
  683.  
  684.     Resizing the dest rect just means resetting the right edge
  685.     (the top is NOT reset), since text might be scrolled off the
  686.     top (i.e., destRect.top != 0).
  687.  
  688.     Doesn't redraw the control, though!
  689. */
  690.  
  691. static OverhaulDisplay (showCaret, recalc)
  692. Boolean    showCaret;
  693. Boolean    recalc;
  694. {
  695. Rect            r;
  696.  
  697.     r = (**editTE).viewRect;    /* erase current viewRect */
  698.     EraseRect (&r);
  699.     SetEditRect ();                /* recalculate editing rects */
  700.     if (recalc)
  701.         TECalText (editTE);            /* recalculate line starts */
  702.     visLines = ((**editTE).viewRect.bottom - (**editTE).viewRect.top)
  703.                     / (**editTE).lineHeight;
  704.  
  705. # ifndef    singleEdit
  706.     (**editInfo).visLines = visLines;
  707. # endif
  708.  
  709. /*
  710.     If there is text, but none of it is visible in the window
  711.     (it's all scrolled off the top), pull some down.
  712. */
  713.  
  714.     if (showCaret)
  715.         AdjustDisplay ();
  716.     else
  717.         SetScrollMax ();
  718.     r = (**editTE).viewRect;
  719.     TEUpdate (&r, editTE);
  720. }
  721.  
  722.  
  723. /* ---------------------------------------------------------------- */
  724. /*                        Window Handler Routines                        */
  725. /* ---------------------------------------------------------------- */
  726.  
  727.  
  728. /*
  729.     Handle mouse clicks in window.  The viewRect is never tested
  730.     directly, because if it were, clicks along the top, left and
  731.     bottom edges of the window wouldn't register.
  732. */
  733.  
  734. static Mouse (thePt, t, mods)
  735. Point    thePt;
  736. Longint    t;
  737. Integer    mods;
  738. {
  739. register Integer    thePart;
  740. register Integer    oldCtlValue;
  741.  
  742.     SyncGlobals (nil);        /* sync to current port */
  743.  
  744.     if ((thePart = TestControl (editScroll, thePt)) == inThumb)
  745.     {
  746.         oldCtlValue = GetCtlValue (editScroll);
  747.         if (TrackControl (editScroll, thePt, nil) == inThumb)
  748.             ScrollText (GetCtlValue (editScroll) - oldCtlValue);
  749.     }
  750.     else if (thePart != 0)
  751.     {
  752.         SetCRefCon (editScroll, (Longint) thePart);
  753.         (void) TrackControl (editScroll, thePt, &TrackScroll);
  754.     }
  755.     else if (PtInText (thePt))
  756.     {
  757.         TEClick (thePt, (mods & shiftKey) != 0, editTE);
  758.     }
  759.  
  760.     SetScrollMax ();
  761. }
  762.  
  763.  
  764. /*
  765.     Handle key clicks in window
  766. */
  767.  
  768. static Key (c, mods)
  769. char    c;
  770. Integer    mods;
  771. {
  772.     SyncAllGlobals (nil);        /* sync to current port */
  773.  
  774.     if (c != enter)
  775.         TEKey (c, editTE);
  776.     AdjustDisplay ();
  777.     SetDirty (true);
  778.     if (eKey != nil)    /* report event to the host */
  779.         (*eKey) ();
  780. }
  781.  
  782.  
  783. /*
  784.     When the window comes active, highlight the scroll bar appropriately.
  785.     When the window is deactivated, un-highlight the scroll bar.
  786.     Redraw the grow box in any case.  Set the cursor (DoCursor avoids
  787.     changing it from an ibeam to an arrow back to an ibeam, in the case
  788.     where one edit window is going inactive and another is coming
  789.     active).
  790.  
  791.     Report the event to the host.
  792. */
  793.  
  794. static Activate (active)
  795. Boolean    active;
  796. {
  797.     SyncAllGlobals (nil);        /* sync to current port */
  798.  
  799.     DrawGrowBox ();
  800.     if (active)
  801.     {
  802.         TEActivate (editTE);
  803.         HiliteControl (editScroll, GetCtlMax (editScroll) > 0 ? 0 : 255);
  804.     }
  805.     else
  806.     {
  807.         TEDeactivate (editTE);
  808.         HiliteControl (editScroll, 255);
  809.     }
  810.     DoCursor (iBeamCursor);
  811.     if (eActivate != nil)    /* report event to the host */
  812.         (*eActivate) (active);
  813. }
  814.  
  815.  
  816. /*
  817.     Close box was clicked.  If user specified notify proc, call it.
  818.     Otherwise do default close operation (ask about saving if dirty,
  819.     etc.).
  820. */
  821.  
  822. static Close ()
  823. {
  824.     SyncAllGlobals (nil);        /* sync to current port */
  825.  
  826.     if (eClose != nil)
  827.         (*eClose) ();
  828.     else
  829.         (void) EWindowClose (editWind);
  830. }
  831.  
  832.  
  833. /*
  834.     Update window.  The update event might be in response to a
  835.     window resizing.  If so, move and resize the scroll bar.
  836.     The ValidRect call is done because the HideControl adds the
  837.     control bounds box to the update region - which would generate
  838.     another update event!  Since everything gets redrawn below,
  839.     the ValidRect is used to cancel the update.
  840. */
  841.  
  842. static Update (resized)
  843. Boolean    resized;
  844. {
  845. Rect            r;
  846.  
  847.     SyncGlobals (nil);        /* sync to current port */
  848.  
  849.     r = editWind->portRect;
  850.     EraseRect (&r);
  851.     if (resized)
  852.     {
  853.         HideControl (editScroll);
  854.         r = (**editScroll).contrlRect;
  855.         ValidRect (&r);
  856.         CalcScrollRect (&r);
  857.         SizeControl (editScroll, 16, r.bottom - r.top);
  858.         MoveControl (editScroll, r.left, r.top);
  859.         OverhaulDisplay (false, (**editTE).crOnly >= 0);
  860.         ShowControl (editScroll);
  861.     }
  862.     else
  863.     {
  864.         OverhaulDisplay (false, false);
  865.         DrawControls (editWind);    /* redraw scroll bar */
  866.     }
  867.  
  868.     DrawGrowBox ();
  869. }
  870.  
  871.  
  872. /*
  873.     Remove the edit window from the list, and dispose of it.
  874.     This is called by SkelRmveWind, not directly by user program.
  875.  
  876.     At this point it's too late to back out if any changes have been
  877.     made to the text.
  878.  
  879.     Since the clobber procedure is never called except for real edit
  880.     windows, and since the list must therefore be non-empty, it is
  881.     not necessary to check the legality of the window or that the
  882.     window's in the list.
  883. */
  884.  
  885. static Clobber ()
  886. {
  887. # ifndef    singleEdit
  888. register EIHandle    h, h2;
  889. # endif
  890.  
  891.     SyncGlobals (nil);                    /* sync to current port */
  892.  
  893. # ifndef    singleEdit
  894.  
  895.     if ((**ewList).editWind == editWind)    /* is it the first window in list? */
  896.     {
  897.         h2 = ewList;
  898.         ewList = (**ewList).eNext;
  899.     }
  900.     else
  901.     {
  902.         for (h = ewList; h != nil; h = h2)
  903.         {
  904.             h2 = (**h).eNext;
  905.             if ((**h2).editWind == editWind)    /* found it */
  906.             {
  907.                 (**h).eNext = (**h2).eNext;
  908.                 break;
  909.             }
  910.         }
  911.     }
  912.     DisposHandle (h2);            /* get rid of information structure */
  913.  
  914. # endif
  915.  
  916.     TEDispose (editTE);            /* toss text record */
  917.     DisposeWindow (editWind);    /* disposes of scroll bar, too */
  918.     editWind = nil;
  919.     DoCursor (iBeamCursor);
  920. }
  921.  
  922.  
  923. /*
  924.     Blink the caret and make sure the cursor's an i-beam when it's
  925.     in the non-scrollbar part of the window.
  926. */
  927.  
  928. static Idle ()
  929. {
  930.  
  931.     SyncGlobals (nil);
  932.     TEIdle (editTE);            /* blink that caret! */
  933.     DoCursor (iBeamCursor);
  934. }
  935.  
  936.  
  937. /* ---------------------------------------------------------------- */
  938. /*                        Internal File Routines                        */
  939. /* ---------------------------------------------------------------- */
  940.  
  941.  
  942. static ErrMesg (s)
  943. StringPtr    s;
  944. {
  945.     (void) FakeAlert (s, "\p", "\p", "\p", 1, 1, "\pOK", "\p", "\p");
  946. }
  947.  
  948.  
  949. /*
  950.     Save the contents of the edit window.  If there is no file bound
  951.     to the window, ask for a file name.  If askForFile is true, ask
  952.     for a name even if the window is currently bound to a file.  If
  953.     bindToFile is true, bind the window to the file written to (if
  954.     that's different than the currently bound file), and clear the
  955.     window's dirty flag.
  956.  
  957.     Return true if the file was written without error.  Return false
  958.     if (a) user was asked for name and clicked Cancel (b) there was
  959.     some error writing the file.  In the latter case, the window is
  960.     not bound to any new name given by user.
  961.  
  962.     Always returns false if the window isn't an edit window.  This
  963.     simplifies EWindowSave, EWindowSaveAs, EWindowSaveCopy.  (They
  964.     don't do the test.)
  965. */
  966.  
  967. static Boolean SaveFile (theWind, askForFile, bindToFile)
  968. WindowPtr    theWind;
  969. Boolean        askForFile;
  970. Boolean        bindToFile;
  971. {
  972. Integer    f;
  973. FInfo    fndrInfo;    /* finder info */
  974. SFReply    tmpFile;
  975. Handle    hText;
  976. Longint    count;
  977. OSErr    result;
  978. Boolean    haveNewFile = false;
  979.  
  980.     if (!IsEWindow (theWind))
  981.         return (false);
  982.  
  983.     SyncAllGlobals (theWind);
  984.     tmpFile = editFile;                    /* initialize default name */
  985.     if (bound == false || askForFile)
  986.     {
  987.         SFPutFile (dlogWhere, "\pSave file as:", editFile.fName,
  988.                         nil, &tmpFile);
  989.         if (!tmpFile.good)
  990.             return (false);
  991.         else
  992.         {
  993.             haveNewFile = true;
  994.             if (GetFInfo (tmpFile.fName, tmpFile.vRefNum, &fndrInfo)
  995.                     == noErr) /* exists */
  996.             {
  997.                 if (fndrInfo.fdType != 'TEXT')
  998.                 {
  999.                     ErrMesg ("\pNot a TEXT File");
  1000.                     return (false);
  1001.                 }
  1002.             }
  1003.             else    /* doesn't exist.  create it. */
  1004.             {
  1005.                 if (Create (tmpFile.fName, tmpFile.vRefNum,
  1006.                             creator, 'TEXT') != noErr)
  1007.                 {
  1008.                     ErrMesg ("\pCan't Create");
  1009.                     return (false);
  1010.                 }
  1011.             }
  1012.         }
  1013.     }
  1014.     
  1015.     if (FSOpen (tmpFile.fName, tmpFile.vRefNum, &f) != noErr)
  1016.         ErrMesg ("\pCan't Open");
  1017.     else
  1018.     {
  1019.         DoCursor (watchCursor);
  1020.         (void) SetFPos (f, fsFromStart, 0L);
  1021.         hText = (**editTE).hText;
  1022.         HLock (hText);
  1023.         count = (**editTE).teLength;
  1024.         result = FSWrite (f, &count, *hText);
  1025.         (void) GetFPos (f, &count);
  1026.         (void) SetEOF (f, count);
  1027.         (void) FSClose (f);
  1028.         (void) FlushVol (nil, tmpFile.vRefNum);
  1029.         HUnlock (hText);
  1030.         DoCursor (iBeamCursor);
  1031.         if (result == noErr)
  1032.         {
  1033.             if (bindToFile)
  1034.             {
  1035.                 SetDirty (false);
  1036.                 if (haveNewFile)    /* name different than current */
  1037.                 {
  1038.                     SetWTitle (editWind, tmpFile.fName);
  1039.  
  1040. # ifdef    singleEdit
  1041.                     bound = true;
  1042.                     editFile = tmpFile;
  1043. # else
  1044.                     (**editInfo).bound = true;
  1045.                     (**editInfo).editFile = tmpFile;
  1046. # endif
  1047.  
  1048.                 }
  1049.             }
  1050.             return (true);
  1051.         }
  1052.         ErrMesg ("\pWrite error!");
  1053.     }
  1054.     return (false);
  1055. }
  1056.  
  1057.  
  1058. /*
  1059.     Revert to version of file saved on disk.  Doesn't check whether
  1060.     the window's really bound to a file or not, doesn't ask whether
  1061.     to really revert if the window's dirty, does no redrawing, etc.
  1062.     Just reports whether the file was read in successfully.
  1063. */
  1064.  
  1065. static Boolean Revert ()
  1066. {
  1067. Boolean    result = false;
  1068. Integer    f;
  1069. Longint    len;
  1070. Handle    h;
  1071.  
  1072.     DoCursor (watchCursor);
  1073.     if (FSOpen (editFile.fName, editFile.vRefNum, &f) != noErr)
  1074.         ErrMesg ("\pCouldn't open file");
  1075.     else
  1076.     {
  1077.         (void) GetEOF (f, &len);
  1078.         if (len >= 32000)
  1079.             ErrMesg ("\pFile is too big");
  1080.         else
  1081.         {
  1082.             h = TEGetText (editTE);
  1083.             SetHandleSize (h, len);
  1084.             HLock (h);
  1085.             (void) FSRead (f, &len, *h);
  1086.             HUnlock (h);
  1087.             (**editTE).teLength = len;
  1088.             TESetSelect (0L, 0L, editTE);    /* set caret at start */
  1089.             result = true;
  1090.             SetDirty (false);
  1091.         }
  1092.         (void) FSClose (f);
  1093.     }
  1094.     DoCursor (iBeamCursor);
  1095.     return (result);
  1096. }
  1097.  
  1098.  
  1099. /* ------------------------------------------------------------ */
  1100. /*            Lowest-level Interface (Public) Routines            */
  1101. /* ------------------------------------------------------------ */
  1102.  
  1103.  
  1104. /*
  1105.     Return true/false to indicate whether the window is really an
  1106.     edit window.
  1107. */
  1108.  
  1109. Boolean IsEWindow (theWind)
  1110. WindowPtr    theWind;
  1111. {
  1112. # ifdef    singleEdit
  1113.     return (theWind == editWind && editWind != nil);
  1114. # else
  1115.     return (GetEInfo (theWind) != nil);
  1116. # endif
  1117. }
  1118.  
  1119.  
  1120. /*
  1121.     Return true/false to indicate whether the text associated with
  1122.     the window has been changed since the last save/revert (or since
  1123.     created, if not bound to file).
  1124. */
  1125.  
  1126. Boolean IsEWindowDirty (theWind)
  1127. WindowPtr    theWind;
  1128. {
  1129. # ifndef    singleEdit
  1130. register EIHandle    eInfo;
  1131.     if ((eInfo = GetEInfo (theWind)) != nil)
  1132.         return ((**eInfo).dirty);
  1133. # else
  1134.     if (IsEWindow (theWind))
  1135.         return (dirty);
  1136. # endif
  1137.     return (false);
  1138. }
  1139.  
  1140.  
  1141. /*
  1142.     Return a handle to the TextEdit record associated with the edit
  1143.     window, or nil if it's not an edit window
  1144. */
  1145.  
  1146. TEHandle GetEWindowTE (theWind)
  1147. WindowPtr    theWind;
  1148. {
  1149. # ifndef    singleEdit
  1150. register EIHandle    eInfo;
  1151.     if ((eInfo = GetEInfo (theWind)) != nil)
  1152.         return ((**eInfo).editTE);
  1153. # else
  1154.     if (IsEWindow (theWind))
  1155.         return (editTE);
  1156. # endif
  1157.     return (nil);
  1158. }
  1159.  
  1160.  
  1161. /*
  1162.     Return true/false depending on whether the editor is bound to
  1163.     a file or not, and a copy of the file info in the second
  1164.     argument.  Pass nil for fileInfo if only want the return status.
  1165.     Returns false if it's not an edit window.
  1166. */
  1167.  
  1168. Boolean GetEWindowFile (theWind, fileInfo)
  1169. WindowPtr    theWind;
  1170. SFReply        *fileInfo;
  1171. {
  1172. # ifndef    singleEdit
  1173. register EIHandle    eInfo;
  1174.     if ((eInfo = GetEInfo (theWind)) != nil)
  1175.     {
  1176.         if (fileInfo != nil)
  1177.             *fileInfo = (**eInfo).editFile;
  1178.         return ((**eInfo).bound);
  1179.     }
  1180. # else
  1181.     if (IsEWindow (theWind))
  1182.     {
  1183.         if (fileInfo != nil)
  1184.             *fileInfo = editFile;
  1185.         return (bound);
  1186.     }
  1187. # endif
  1188.     return (false);
  1189. }
  1190.  
  1191.  
  1192. /* ---------------------------------------------------------------- */
  1193. /*                    Interface Display Routines                        */
  1194. /* ---------------------------------------------------------------- */
  1195.  
  1196.  
  1197. /*
  1198.     Install event notification procedures for an edit window.
  1199. */
  1200.  
  1201. SetEWindowProcs (theWind, pKey, pActivate, pClose)
  1202. WindowPtr    theWind;
  1203. ProcPtr        pKey;
  1204. ProcPtr        pActivate;
  1205. ProcPtr        pClose;
  1206. {
  1207. # ifndef    singleEdit
  1208. register EIHandle    eInfo;
  1209. # endif
  1210.  
  1211.     if (theWind == nil)            /* reset window creation defaults */
  1212.     {
  1213.         e_key = pKey;
  1214.         e_activate = pActivate;
  1215.         e_close = pClose;
  1216.         return;
  1217.     }
  1218.  
  1219. # ifndef    singleEdit
  1220.  
  1221.     if ((eInfo = GetEInfo (theWind)) != nil)
  1222.     {
  1223.         (**eInfo).eKey = pKey;
  1224.         (**eInfo).eActivate = pActivate;
  1225.         (**eInfo).eClose = pClose;
  1226.     }
  1227.  
  1228. # else
  1229.  
  1230.     if (IsEWindow (theWind))
  1231.     {
  1232.         eKey = pKey;
  1233.         eActivate = pActivate;
  1234.         eClose = pClose;
  1235.     }
  1236.  
  1237. # endif
  1238.  
  1239. }
  1240.  
  1241.  
  1242. /*
  1243.     Change the text display characteristics of an edit window
  1244.     and redisplay it.
  1245.  
  1246.     Scroll to home position before overhauling, because although
  1247.     the overhaul sets the viewRect to display an integral number
  1248.     of lines, there's no guarantee that the destRect offset will
  1249.     also be integral except at home position.  Clipping is set to
  1250.     an empty rect so the scroll doesn't show.
  1251. */
  1252.  
  1253. SetEWindowStyle (theWind, font, size, wrap, just)
  1254. WindowPtr    theWind;
  1255. Integer        font;
  1256. Integer        size;
  1257. Integer        wrap;
  1258. Integer        just;
  1259. {
  1260. GrafPtr                savePort;
  1261. FontInfo            f;
  1262. register TEHandle    te;
  1263. Rect                r;
  1264. Integer                oldWrap;
  1265.  
  1266.     if (theWind == nil)            /* reset window creation defaults */
  1267.     {
  1268.         e_font = font;
  1269.         e_size = size;
  1270.         e_wrap = wrap;
  1271.         e_just = just;
  1272.         return;
  1273.     }
  1274.  
  1275.     if (IsEWindow (theWind))
  1276.     {
  1277.         GetPort (&savePort);
  1278.         SyncGlobals (theWind);    /* sync and set port */
  1279.         te = editTE;
  1280.         ScrollToHome ();
  1281.  
  1282.         oldWrap = (**te).crOnly;
  1283.         (**te).crOnly = wrap;    /* set word wrap */
  1284.         TESetJust (just, te);    /* set justification */
  1285.  
  1286.         TextFont (font);         /* set the font and point size */
  1287.         TextSize (size);        /* of text record */
  1288.         GetFontInfo (&f);
  1289.         (**te).lineHeight = f.ascent + f.descent + f.leading;
  1290.         (**te).fontAscent = f.ascent;
  1291.         (**te).txFont = font;
  1292.         (**te).txSize = size;
  1293.  
  1294.         OverhaulDisplay (true, (oldWrap >= 0 || wrap >= 0));
  1295.  
  1296.         SetPort (savePort);
  1297.     }
  1298. }
  1299.  
  1300.  
  1301. /*
  1302.     Redo display.  Does not save current port.  This is used by hosts
  1303.     that mess with the text externally to TransEdit.  The arguments
  1304.     determine whether the text is scrolled to show the line with the
  1305.     caret, whether the lineStarts are recalculated, and whether the
  1306.     text should be marked dirty or not.
  1307. */
  1308.  
  1309. EWindowOverhaul (theWind, showCaret, recalc, dirty)
  1310. WindowPtr    theWind;
  1311. Boolean        showCaret;
  1312. Boolean        recalc;
  1313. Boolean        dirty;
  1314. {
  1315.     if (IsEWindow (theWind))
  1316.     {
  1317.         SyncGlobals (theWind);
  1318.         OverhaulDisplay (showCaret, recalc);
  1319.         DrawControls (editWind);
  1320.         SetDirty (dirty);
  1321.     }
  1322. }
  1323.  
  1324.  
  1325. /* ---------------------------------------------------------------- */
  1326. /*                        Menu Interface Routine                        */
  1327. /* ---------------------------------------------------------------- */
  1328.  
  1329.  
  1330. /*
  1331.     Do Edit menu selection.  This is only valid if an edit
  1332.     window is frontmost.
  1333. */
  1334.  
  1335. EWindowEditOp (item)
  1336. Integer    item;
  1337. {
  1338.     if (SystemEdit (item - 1))
  1339.         return;
  1340.  
  1341.     if (!IsEWindow (FrontWindow ()))
  1342.         return;                /* host messed up */
  1343.  
  1344.     SyncGlobals (FrontWindow ());
  1345.  
  1346.     switch (item)
  1347.     {
  1348.  
  1349. /*
  1350.     cut selection, put in TE Scrap, clear clipboard and put
  1351.     TE scrap in it
  1352. */
  1353.         case cut:
  1354.         {
  1355.             TECut (editTE);
  1356.             (void) ZeroScrap ();
  1357.             (void) TEToScrap ();
  1358.             break;
  1359.         }
  1360. /*
  1361.     copy selection to TE Scrap, clear clipboard and put
  1362.     TE scrap in it
  1363. */
  1364.         case copy:
  1365.         {
  1366.             TECopy (editTE);
  1367.             (void) ZeroScrap ();
  1368.             (void) TEToScrap ();
  1369.             break;
  1370.         }
  1371. /*
  1372.     get clipboard into TE scrap, put TE scrap into edit record
  1373. */
  1374.         case paste:
  1375.         {
  1376.             (void) TEFromScrap ();
  1377.             TEPaste (editTE);
  1378.             break;
  1379.         }
  1380. /*
  1381.     delete selection without putting into TE scrap or clipboard
  1382. */
  1383.         case clear:
  1384.         {
  1385.             (void) TEDelete (editTE);
  1386.             break;
  1387.         }
  1388.  
  1389.     }
  1390.     AdjustDisplay ();
  1391.     SetDirty (true);
  1392. }
  1393.  
  1394.  
  1395. /* ---------------------------------------------------------------- */
  1396. /*                        Interface File Routines                        */
  1397. /* ---------------------------------------------------------------- */
  1398.  
  1399.  
  1400. /*
  1401.     Set file creator for any files created by TransEdit
  1402. */
  1403.  
  1404. SetEWindowCreator (creat)
  1405. OSType    creat;
  1406. {
  1407.     creator = creat;
  1408. }
  1409.  
  1410.  
  1411.  
  1412. /*
  1413.     Save the contents of the given window
  1414. */
  1415.  
  1416. Boolean EWindowSave (theWind)
  1417. WindowPtr    theWind;
  1418. {
  1419.     return (SaveFile (theWind,    /* window to save */
  1420.                       false,    /* don't ask for file if have one */
  1421.                       true));    /* bind to new file if one given */
  1422. }
  1423.  
  1424.  
  1425. /*
  1426.     Save the contents of the given window under a new name
  1427.     and bind to that name.
  1428. */
  1429.  
  1430. Boolean EWindowSaveAs (theWind)
  1431. WindowPtr    theWind;
  1432. {
  1433.     return (SaveFile (theWind,    /* window to save */
  1434.                       true,        /* ask for file even if have one */
  1435.                       true));    /* bind to new file if one given */
  1436. }
  1437.  
  1438.  
  1439. /*
  1440.     Save the contents of the given window under a new name, but
  1441.     don't bind to the name.
  1442. */
  1443.  
  1444. Boolean EWindowSaveCopy (theWind)
  1445. WindowPtr    theWind;
  1446. {
  1447.     return (SaveFile (theWind,    /* window to save */
  1448.                       true,        /* ask for file even if have one */
  1449.                       false));    /* don't bind to file */
  1450. }
  1451.  
  1452.  
  1453. /*
  1454.     Close the window.  If it's dirty and is either bound to a file
  1455.     or (if not bound) has some text in it, ask about saving it first,
  1456.     giving user option of saving changes, tossing them, or
  1457.     cancelling altogether.
  1458.  
  1459.     Return true if the file was saved and the window closed, false if
  1460.     user cancelled or there was an error.
  1461. */
  1462.  
  1463. Boolean EWindowClose (theWind)
  1464. WindowPtr    theWind;
  1465. {
  1466.     if (IsEWindow (theWind) == false)
  1467.         return (false);
  1468.  
  1469.     SyncAllGlobals (theWind);
  1470.     if ( (bound || (**editTE).teLength > 0) && dirty)
  1471.     {
  1472.         switch (FakeAlert ("\pSave changes to \"", editFile.fName,
  1473.                 "\p\"?", "\p", 3, 3,
  1474.                 "\pCancel", "\pDiscard", "\pSave"))    /* ask whether to save */
  1475.         {
  1476.  
  1477.             case 1:            /* cancel Close */
  1478.                 return (false);
  1479.  
  1480.             case 2:            /* toss changes */
  1481.                 break;
  1482.  
  1483.             case 3:
  1484.                 if (SaveFile (editWind,    /* window to save */
  1485.                               false,    /* don't ask for name */
  1486.                               false)    /* don't bind to name */
  1487.                         == false)
  1488.                     return (false);    /* cancelled or error - cancel Close */
  1489.                 break;
  1490.         }
  1491.     }
  1492.     SkelRmveWind (editWind);
  1493.     return (true);
  1494. }
  1495.  
  1496.  
  1497. /*
  1498.     Revert to saved version of file on disk.  theWind must be an edit
  1499.     window, and must be bound to a file.  Returns false if one of these
  1500.     conditions is not met, or if they are met but there was an error
  1501.     reading the file.
  1502.  
  1503.     The window need not be dirty, but if it is, the user is asked
  1504.     whether to really revert.
  1505. */
  1506.  
  1507. Boolean EWindowRevert (theWind)
  1508. WindowPtr    theWind;
  1509. {
  1510.     if (!IsEWindow (theWind))
  1511.         return (false);
  1512.     SyncAllGlobals (theWind);
  1513.     if (!bound)
  1514.         return (false);        /* no file to revert to */
  1515.     if (dirty)
  1516.     {
  1517.         if (FakeAlert ("\p\"", editFile.fName,
  1518.                 "\p\" has been changed.  Really revert?",
  1519.                 "\p", 2, 1, "\pCancel", "\pRevert", "\p") == 1)
  1520.             return (false);
  1521.     }
  1522.     if (Revert () == false)
  1523.         return (false);
  1524.     ScrollToHome ();
  1525.     OverhaulDisplay (true, true);
  1526.     DrawControls (editWind);
  1527.     ValidRect (&editWind->portRect);
  1528.     return (true);
  1529. }
  1530.  
  1531.  
  1532. /* ---------------------------------------------------------------- */
  1533. /*            Interface Initialization/Termination Routines            */
  1534. /* ---------------------------------------------------------------- */
  1535.  
  1536.  
  1537. /*
  1538.     Initialize the window and associated data structures.
  1539.     Return window pointer or nil if some sort of error.
  1540.  
  1541.     Preserves the current port.
  1542. */
  1543.  
  1544. WindowPtr NewEWindow (bounds, title, visible, behind,
  1545.                             goAway, refNum, bindToFile)
  1546. Rect        *bounds;
  1547. StringPtr    title;
  1548. Boolean        visible;
  1549. WindowPtr    behind;
  1550. Boolean        goAway;
  1551. Longint        refNum;
  1552. Boolean        bindToFile;
  1553. {
  1554. GrafPtr        savePort;
  1555. Rect        r;
  1556. OSType        type = 'TEXT';
  1557. Str255        s, s2;
  1558. StringPtr    tPtr;
  1559.  
  1560. # ifndef    singleEdit
  1561. register EIHandle    eInfo;
  1562. # endif
  1563.  
  1564. # ifdef    singleEdit
  1565.  
  1566.     if (editWind != nil)    /* allow only one window at a time */
  1567.         return (nil);
  1568.  
  1569. # endif
  1570.  
  1571. /*
  1572.     If supposed to bind to file, ask for name.  Return without doing
  1573.     anything if Cancel button clicked.
  1574. */
  1575.  
  1576.     if (bindToFile)
  1577.     {
  1578.         SFGetFile (dlogWhere, "\p", nil, 1, &type, nil, &editFile);
  1579.         if (!editFile.good)
  1580.             return (nil);
  1581.     }
  1582.     bound = bindToFile;
  1583.  
  1584. /*
  1585.     Create window and install handler.  Set window title:  If window is
  1586.     to be bound to file, use name of file.  Otherwise use any title that
  1587.     was passed in.  If nil was passed, use a default name ("Untitled nnn").
  1588.     Also copy the name into the file info structure even if the window is
  1589.     unbound, because the Save operations expect to find it there as the
  1590.     most likely name to use if the window is untitled.
  1591.  
  1592.     Save and restore port, because it gets reset by the rest of the
  1593.     initialization code.
  1594. */
  1595.  
  1596.     if (bound)
  1597.         tPtr = editFile.fName;
  1598.     else
  1599.     {
  1600.         if (title != nil)
  1601.             tPtr = title;
  1602.         else
  1603.         {
  1604.  
  1605. # ifndef    singleEdit
  1606.             BlockMove ("\pUntitled ", s, 10L);
  1607.             NumToString ((Longint) ++windID, s2);
  1608.             BlockMove (&s2[1], &s[10], (Longint) s2[0]);
  1609.             s[0] += s2[0];
  1610.             tPtr = s;
  1611. # else
  1612.             tPtr = (StringPtr) "\pUntitled";
  1613. # endif
  1614.  
  1615.         }
  1616.         BlockMove (tPtr, editFile.fName, (Longint) (tPtr[0] + 1));
  1617.     }
  1618.  
  1619.     editWind = NewWindow (nil, bounds, tPtr, false, documentProc + 8,
  1620.                                 behind, goAway, refNum);
  1621.  
  1622.     GetPort (&savePort);
  1623.     SkelWindow (editWind,    /* the window */
  1624.                 Mouse,        /* mouse click handler */
  1625.                 Key,        /* key click handler */
  1626.                 Update,        /* window updating procedure */
  1627.                 Activate,    /* window activate/deactivate procedure */
  1628.                 Close,        /* window close procedure */
  1629.                 Clobber,    /* window disposal procedure */
  1630.                 Idle,        /* idle proc */
  1631.                 true);        /* idle only when frontmost */
  1632.  
  1633.  
  1634. /*
  1635.     Build the scroll bar.
  1636. */
  1637.  
  1638.     CalcScrollRect (&r);
  1639.     editScroll = NewControl (editWind, &r, "\p", true, 0, 0, 0,
  1640.                                 scrollBarProc, 0L);
  1641.  
  1642.  
  1643.  
  1644. /*
  1645.     Create the TE record used for text display.  Use default
  1646.     characteristics.
  1647. */
  1648.  
  1649.     GetEditRect (&r);
  1650.     editTE = TENew (&r, &r);
  1651.     SetClikLoop (AutoScroll, editTE);            /* set autoscroll proc */
  1652.  
  1653.  
  1654. # ifndef    singleEdit
  1655.  
  1656. /*
  1657.     Get new information structure, attach to list of known edit
  1658.     windows.
  1659. */
  1660.  
  1661.     eInfo = New (EditInfo);
  1662.     editInfo = eInfo;
  1663.     (**eInfo).eNext = ewList;
  1664.     ewList = eInfo;
  1665.     (**eInfo).editWind = editWind;
  1666.     (**eInfo).scroll = editScroll;
  1667.     (**eInfo).editTE = editTE;
  1668.     (**eInfo).bound = bound;
  1669.     (**eInfo).editFile = editFile;
  1670.  
  1671. # endif
  1672.  
  1673. /*
  1674.     Install default event notification procedures, font characteristics.
  1675. */
  1676.  
  1677.     SetEWindowProcs (editWind, e_key, e_activate, e_close);
  1678.     SetEWindowStyle (editWind, e_font, e_size, e_wrap, e_just);
  1679.     SetDirty (false);
  1680.  
  1681. /*
  1682.     If supposed to read file, do so.  Check the return value of
  1683.     Revert and toss the window if there was an error.
  1684. */
  1685.  
  1686.     if (bindToFile && Revert () == false)
  1687.     {
  1688.         SkelRmveWind (editWind);
  1689.         SetPort (savePort);
  1690.         return (nil);
  1691.     }
  1692.  
  1693. /*
  1694.     Show window if specified as visible, and return a pointer to it.
  1695. */
  1696.  
  1697.     SyncGlobals (editWind);
  1698.     OverhaulDisplay (true, true);
  1699.     if (visible)
  1700.         ShowWindow (editWind);
  1701.     SetPort (savePort);
  1702.     return (editWind);
  1703. }
  1704.  
  1705.  
  1706. /*
  1707.     Look through the list of windows, shutting down all the edit
  1708.     windows.  If any window is dirty, ask user about saving it first.
  1709.     If the user cancels on any such request, ClobberEWindows returns
  1710.     false.  If all edit windows are shut down, return true.  It is
  1711.     then safe for the host to exit.
  1712.  
  1713.     When a window *is* shut down, have to start looking through the
  1714.     window list again, since theWind no longer points anywhere
  1715.     meaningful.
  1716. */
  1717.  
  1718. Boolean ClobberEWindows ()
  1719. {
  1720. WindowPtr    theWind;
  1721.  
  1722.     for (;;)
  1723.     {
  1724.         for (theWind = FrontWindow ();
  1725.                 theWind != nil;
  1726.                     theWind = (WindowPtr) ((WindowPeek) theWind)->nextWindow)
  1727.         {
  1728.             if (IsEWindow (theWind))
  1729.                 break;
  1730.         }
  1731.         if (theWind == nil)
  1732.             return (true);        /* all edit windows are shut down */
  1733.  
  1734.         if (theWind != FrontWindow ())
  1735.         {
  1736.             SelectWindow (theWind);
  1737.             ShowWindow (theWind);
  1738.             EWindowOverhaul (theWind, false, false, IsEWindowDirty (theWind));
  1739.             SetPort (theWind);
  1740.             ValidRect (&theWind->portRect);
  1741.         }
  1742.  
  1743.         if (EWindowClose (theWind) == false)
  1744.             return (false);        /* cancel or error */
  1745.     }
  1746. }
  1747.