home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / c-kermit / ckmwin.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  18KB  |  695 lines
  1. /* $Id: ckmwin.c,v 1.2 91/12/27 21:51:47 fdc Exp $
  2.  * $Source: /uw/mackermit/RCS/ckmwin.c,v $
  3.  *------------------------------------------------------------------
  4.  * $Log:    ckmwin.c,v $
  5.  * Revision 1.2  91/12/27  21:51:47  fdc
  6.  * Change fatal to macfatal.
  7.  * 
  8.  * Revision 1.1  91/10/30  23:06:06  rick
  9.  * Initial revision
  10.  * 
  11.  *------------------------------------------------------------------
  12.  * $Endlog$
  13.  */
  14.  
  15. /*
  16.  * cmkwin.c
  17.  * Common window handling routines for the command and remote
  18.  * windows.
  19.  * 
  20.  * R. Watson
  21.  * The University of Texas
  22.  * 12-Sep-1991
  23.  */
  24. /*
  25.   Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
  26.   York.  Permission is granted to any individual or institution to use this
  27.   software as long as it is not sold for profit.  This copyright notice must be
  28.   retained.  This software may not be included in commercial products without
  29.   written permission of Columbia University.
  30. */
  31. #include "ckcdeb.h"
  32. #include "ckcasc.h"
  33. #include "ckcker.h"
  34. #include "ckmdef.h"            /* General Mac defs */
  35. #include "ckmres.h"            /* Resource file defs */
  36. #include "ckmwin.h"            /* Window handling defs */
  37. #include "ckmcon.h"
  38. #include "ckmptp.h"            /* Prototypes */
  39.  
  40. #define LMARGIN 4            /* left margin in teviewr */
  41.  
  42. struct cmdw *cmdwl = NULL;        /* list of TE windows */
  43. struct cmdw *rcmdw = NULL;        /* remote command window */
  44. struct cmdw *prntw = NULL;        /* local "printer" window */
  45. struct cmdw *activecmdw = NULL;        /* cmdw if window is active */
  46. struct cmdw *docmdw;            /* cmdw for rdoscroll() */
  47. int cmdinterminal = FALSE;        /* cmd output to term window if true */
  48.  
  49. extern MenuHandle menus[];
  50. extern int connected;
  51. extern Boolean have_128roms;    /* actually, a Mac + or better */
  52. extern Cursor *textcurs, *normcurs, *watchcurs;    /* mouse cursor shapes */
  53. extern Cursor *lastCursor;        /* what we set the cursor to last */
  54.  
  55. void cmdwSelectWindow (struct cmdw *cmdw);
  56. void updateTakeMenu (struct cmdw *cmdw);
  57. void setWindowLoc (int id);
  58.  
  59. /*
  60.  * initcmdw()
  61.  * Initialize a TE based window.
  62.  */
  63. struct cmdw *initcmdw (id, vscroll, hscroll)
  64.     int id;                /* window id */
  65.     int vscroll;            /* vertical scroll CTRL id */
  66.     int hscroll;            /* horiz scroll CTRL id */
  67. {
  68.     struct cmdw *cmdw;
  69.     GrafPtr savePort;
  70.     static int ourid = 1;        /* unique id of this cmdw */
  71.  
  72.     GetPort (&savePort);        /* save current port */
  73.  
  74.     cmdw = (struct cmdw *)malloc(sizeof(struct cmdw));
  75.     if (!cmdw)
  76.     macfatal("No memory for cmdw", 0);
  77.     bzero((char *)cmdw, sizeof(struct cmdw));
  78.     cmdw->next = cmdwl;            /* link on list */
  79.     cmdwl = cmdw;
  80.     cmdw->id = ourid++;            /* allocate unique id */
  81.  
  82.     setWindowLoc(id);
  83. #ifdef notdef
  84.     cmdw->window = GetNewWindow(id, (Ptr) &cmdw->WRec, (WindowPtr) 0L);
  85. #else
  86.     cmdw->window = GetNewWindow(id, (Ptr) 0L, (WindowPtr) -1L);
  87. #endif
  88.     SetPort (cmdw->window);        /* set new stuff */
  89.     TextFont (monaco);
  90.     TextSize (9);
  91.  
  92.     /* min and max are defined in the resource declaration */
  93.     cmdw->vscroll = GetNewControl(vscroll, cmdw->window);
  94.     cmdw->hscroll = GetNewControl(hscroll, cmdw->window); 
  95.  
  96.     sizescrollbars(cmdw);        /* make controls adjust to wind size */
  97.     sizeteviewr(cmdw);            /* resize text edit rect */
  98.  
  99.     /* create text edit portion */
  100.     cmdw->teh = TENew (&cmdw->teviewr, &cmdw->teviewr);
  101.     HLock((Handle)cmdw->teh);
  102.     (*cmdw->teh)->crOnly = -1;    /* only break lines at CR */
  103.  
  104.     cmdw->theorigin.h = 0;
  105.     cmdw->theorigin.v = 0;
  106.  
  107.     SetPort (savePort);        /* restore previous port */
  108.  
  109.     return cmdw;
  110. }
  111.  
  112.  
  113. /****************************************************************************/
  114. /* sizescrollbars - called when window is created and after a window grow */
  115. /*                      sequence to resize the scroll window's bars. */
  116. /****************************************************************************/
  117. sizescrollbars (cmdw)
  118.     struct cmdw *cmdw;
  119. {
  120.     register Rect *r;
  121.  
  122.     r = &cmdw->window->portRect;    /* window size */
  123.     HideControl (cmdw->vscroll);
  124.     HideControl (cmdw->hscroll);
  125.  
  126.     MoveControl (cmdw->vscroll, r->right - 15, r->top - 1);
  127.     SizeControl (cmdw->vscroll, 16, r->bottom - r->top - 13);
  128.  
  129.     MoveControl (cmdw->hscroll, r->left - 1, r->bottom - 15);
  130.     SizeControl (cmdw->hscroll, r->right - r->left - 13, 16);
  131.  
  132.     ShowControl (cmdw->vscroll);
  133.     ShowControl (cmdw->hscroll);
  134. }
  135.  
  136.  
  137. /****************************************************************************/
  138. /****************************************************************************/
  139. sizeteviewr (cmdw)
  140.     struct cmdw *cmdw;
  141. {
  142.     cmdw->teviewr = cmdw->window->portRect;
  143.     cmdw->teviewr.left = cmdw->teviewr.left + LMARGIN;
  144.     cmdw->teviewr.right = cmdw->teviewr.right - 15;
  145.     cmdw->teviewr.bottom = cmdw->teviewr.bottom - 15;
  146. } 
  147.  
  148.  
  149. /****************************************************************************/
  150. /****************************************************************************/
  151. void
  152. growremwindow (cmdw, p)
  153.     struct cmdw *cmdw;
  154.     Point p;
  155. {
  156.     long gr;
  157.     int height;
  158.     int width;
  159.     Rect growRect;
  160.     GrafPtr savePort;
  161.  
  162.     growRect = qd.screenBits.bounds;
  163.     growRect.top = 50;        /* minimal horizontal size */
  164.     growRect.left = 50;        /* minimal vertical size */
  165.  
  166.     gr = GrowWindow (cmdw->window, p, &growRect);
  167.  
  168.     if (gr == 0)
  169.     return;
  170.     height = HiWord (gr);
  171.     width = LoWord (gr);
  172.  
  173.     SizeWindow (cmdw->window, width, height, FALSE); /* resize the window */
  174.     sizescrollbars(cmdw);        /* size the scroll bars */
  175.     sizeteviewr(cmdw);            /* size for text edit */
  176.     (*cmdw->teh)->viewRect = cmdw->teviewr; /* set it */
  177.  
  178.     GetPort (&savePort);
  179.     SetPort (cmdw->window);
  180.     InvalRect (&cmdw->window->portRect);/* invalidate whole window rectangle */
  181.     SetPort (savePort);
  182. }
  183.  
  184.  
  185. /****************************************************************************/
  186. /****************************************************************************/
  187. rcmdwhide (cmdw)
  188.     struct cmdw *cmdw;
  189. {
  190.     HideWindow(cmdw->window);        /* hide it */
  191.     HideControl(cmdw->vscroll);        /* these will be shown on select */
  192.     HideControl(cmdw->hscroll);
  193. }
  194.  
  195.  
  196. /*
  197.  * rrcmdwshow
  198.  * Show the remote window.
  199.  * Here so ckuus4.c doesn't need to know about window details.
  200.  */
  201. rrcmdwshow()
  202. {
  203.     rcmdwshow(rcmdw);
  204. }
  205.  
  206.  
  207. /****************************************************************************/
  208. /****************************************************************************/
  209. rcmdwshow (cmdw)
  210.     struct cmdw *cmdw;
  211. {
  212.     ShowWindow (cmdw->window);        /* show it */
  213.     cmdwSelectWindow (cmdw);
  214. }
  215.  
  216.  
  217. /****************************************************************************/
  218. /* rcdactivate - activate event on rcd window */
  219. /****************************************************************************/
  220. rcdactivate (cmdw, mod)
  221.     struct cmdw *cmdw;
  222.     int mod;
  223. {
  224.     DrawGrowIcon(cmdw->window);
  225.     if (mod & activeFlag) {
  226.     TEFromScrap();
  227.     TEActivate(cmdw->teh);
  228.     ShowControl (cmdw->vscroll);
  229.     ShowControl (cmdw->hscroll);
  230.     DisableItem(menus[EDIT_MENU], UNDO_EDIT);
  231.     updateTakeMenu(cmdw);
  232.     activecmdw = cmdw;
  233.     } else {
  234.     ZeroScrap();
  235.     TEToScrap();
  236.     TEDeactivate(cmdw->teh);
  237.     HideControl(cmdw->vscroll);
  238.     HideControl(cmdw->hscroll);
  239.     EnableItem(menus[EDIT_MENU], UNDO_EDIT);
  240.     activecmdw = NULL;
  241.     }
  242. }
  243.  
  244.  
  245. /****************************************************************************/
  246. /****************************************************************************/
  247. pascal void
  248. rdoscroll (WHICHCONTROL, THECODE)
  249.     ControlHandle WHICHCONTROL;
  250.     short THECODE;
  251. {
  252.     register int amount = 0, val, max;
  253.  
  254.     if (THECODE == inUpButton)
  255.     amount = -1;
  256.     if (THECODE == inDownButton)
  257.     amount = 1;
  258.     if (amount == 0)
  259.     return;
  260.     val = GetCtlValue (WHICHCONTROL) + amount;
  261.     max = GetCtlMax (WHICHCONTROL);
  262.     if ((val < 0) || (val > max))
  263.     return;
  264.     SetCtlValue (WHICHCONTROL, GetCtlValue (WHICHCONTROL) + amount);
  265.     scrollbits(docmdw);
  266. }                /* rdoscroll */
  267.  
  268.  
  269. /****************************************************************************/
  270. /* rcdkey - key event on rcd window */
  271. /****************************************************************************/
  272. rcdkey (cmdw, evt)
  273.     struct cmdw *cmdw;
  274.     EventRecord *evt;
  275. {
  276.     int i, y;
  277.     int nl;                /* num lines in window */
  278.     unsigned char the_char;
  279.     TEPtr ptr;
  280.     Point pt;
  281.     
  282.     the_char = evt->message & charCodeMask;
  283.     TEKey(the_char, cmdw->teh);
  284.     cmdw->flags |= CMDWF_MODIFIED;    /* buffer is modified */
  285.  
  286.     if (the_char == '\n')        /* if extending number of lines */
  287.     setscrollmax(cmdw);
  288.  
  289.     /*
  290.      * Find location of insertion point.  
  291.      * TODO: Do this for horizontal locations also.  Will need to
  292.      * use TextWidth() I think.
  293.      */
  294.     ptr = *cmdw->teh;
  295.     for (i = ptr->nLines; i >= 0; i--)    /* set i to line number */
  296.     if (ptr->selEnd >= ptr->lineStarts[i])
  297.         break;
  298.     y = (i - GetCtlValue(cmdw->vscroll)) * ptr->lineHeight;
  299.     pt.h = LMARGIN;
  300.     pt.v = y + ptr->lineHeight/2;
  301.  
  302.     nl = ((ptr->viewRect.bottom-ptr->viewRect.top) / ptr->lineHeight);
  303.     if (!PtInRect(pt, &cmdw->teviewr)) {
  304.     if (pt.v > cmdw->teviewr.bottom) { /* if past bottom */
  305.         SetCtlValue(cmdw->vscroll, i-nl+1);
  306.         scrollbits(cmdw);
  307.     } else {            /* must be above top */
  308.         SetCtlValue(cmdw->vscroll, i);
  309.         scrollbits(cmdw);
  310.     }
  311.     }
  312. }
  313.  
  314. /****************************************************************************/
  315. /* rcdmouse - mouse event on rcd window */
  316. /****************************************************************************/
  317. rcdmouse (cmdw, evt)
  318.     struct cmdw *cmdw;
  319.     EventRecord *evt;
  320. {
  321.     int actrlcode;
  322.     int t;
  323.     ControlHandle acontrol;
  324.     GrafPtr savePort;
  325.     
  326.     GetPort (&savePort);    /* save the current port */
  327.     SetPort (cmdw->window);
  328.  
  329.     GlobalToLocal (&evt->where);/* convert to local */
  330.     if (PtInRect (evt->where, &cmdw->teviewr)) {    /* in text edit? */
  331.     TEClick(evt->where, (evt->modifiers) & shiftKey, cmdw->teh);
  332.     SetPort (savePort);    /* restore previous port */
  333.     return;            /* yes, do nothing */
  334.     }
  335.     actrlcode = FindControl (evt->where, cmdw->window, &acontrol);
  336.     switch (actrlcode) {
  337.       case inUpButton:
  338.       case inDownButton:
  339.     docmdw = cmdw;            /* save pointer for rdoscroll */
  340.     t = TrackControl (acontrol, evt->where, (ProcPtr) rdoscroll);
  341.     break;
  342.  
  343.       case inPageUp:
  344.     pagescroll (cmdw, actrlcode, -10, acontrol);
  345.     break;
  346.  
  347.       case inPageDown:
  348.     pagescroll (cmdw, actrlcode, 10, acontrol);
  349.     break;
  350.  
  351.       case inThumb:
  352.     t = TrackControl (acontrol, evt->where, (ProcPtr) NIL);
  353.     scrollbits(cmdw);
  354.     break;
  355.     }
  356.     SetPort (savePort);        /* restore previous port */
  357. }                /* rcdmouse */
  358.  
  359. rcd_cut(cmdw)
  360.     struct cmdw *cmdw;
  361. {
  362.     invalidate_scr_clip();
  363.     TECut(cmdw->teh);
  364. }
  365.  
  366. rcd_copy(cmdw)
  367.     struct cmdw *cmdw;
  368. {
  369.     invalidate_scr_clip();
  370.     TECopy(cmdw->teh);
  371. }
  372.  
  373. rcd_paste(cmdw)
  374.     struct cmdw *cmdw;
  375. {
  376.     /*
  377.      * If the internal clip is newer, it will have been already copied to the
  378.      * global clip, so this will just work.
  379.      */
  380.     TEPaste(cmdw->teh);
  381. }
  382.  
  383. rcd_clear(cmdw)
  384.     struct cmdw *cmdw;
  385. {
  386.     TEDelete(cmdw->teh);
  387. }
  388.  
  389.  
  390. /****************************************************************************/
  391. /****************************************************************************/
  392. rcdupdate (cmdw)
  393.     struct cmdw *cmdw;
  394. {
  395.     EraseRect(&cmdw->teviewr);
  396.     TEUpdate(&cmdw->teviewr, cmdw->teh);
  397.     DrawGrowIcon(cmdw->window);
  398.     DrawControls(cmdw->window);
  399. }
  400.  
  401.  
  402. /****************************************************************************/
  403. /****************************************************************************/
  404. scrollbits (cmdw)
  405.     struct cmdw *cmdw;
  406. {
  407.     Point oldorigin;
  408.     int dh, dv;
  409.  
  410.     oldorigin = cmdw->theorigin;
  411.     cmdw->theorigin.h = GetCtlValue(cmdw->hscroll);
  412.     cmdw->theorigin.v = GetCtlValue(cmdw->vscroll);
  413.     dh = (oldorigin.h - cmdw->theorigin.h);
  414.     dv = (oldorigin.v - cmdw->theorigin.v) * (*cmdw->teh)->lineHeight;
  415.     TEScroll (dh, dv, cmdw->teh);
  416. }
  417.  
  418.  
  419. /****************************************************************************/
  420. /****************************************************************************/
  421. rcdwscroll (cmdw)
  422.     struct cmdw *cmdw;
  423. {
  424.     GrafPtr savePort;
  425.  
  426.     GetPort (&savePort);
  427.     SetPort (cmdw->window);        /* our window is the port */
  428.     setscrollmax (cmdw);        /* set the max */
  429.     SetCtlValue (cmdw->vscroll, GetCtlMax (cmdw->vscroll)); /* & set control */
  430.     scrollbits(cmdw);            /* do scroll */
  431.     SetPort (savePort);            /* back to old port */
  432. }
  433.  
  434.  
  435. /****************************************************************************/
  436. /****************************************************************************/
  437. pagescroll (cmdw, code, amount, ctrlh)
  438.     struct cmdw *cmdw;
  439.     ControlHandle ctrlh;
  440. {
  441.     Point myPt;
  442.  
  443.     do {
  444.     GetMouse (&myPt);
  445.     if (TestControl (ctrlh, myPt) != code)
  446.         continue;
  447.     SetCtlValue (ctrlh, GetCtlValue (ctrlh) + amount);
  448.     scrollbits(cmdw);
  449.     } while (StillDown ());
  450. }
  451.  
  452.  
  453. /****************************************************************************/
  454. /* setscrollmax - sets the vertical scroll control's maximum value.
  455.  *                    The max is the total number of lines in the te record
  456.  *                    minus the number of lines that can be displayed in the
  457.  *                    viewing rectangle (plus 1).  This makes the max setting
  458.  *                    of the control result in the display of the last chunk
  459.  *                    of text.
  460.  */
  461. /****************************************************************************/
  462. int setscrollmax (cmdw)
  463.     struct cmdw *cmdw;
  464. {
  465.     int maxv;
  466.  
  467.     maxv = (*cmdw->teh)->nLines + 1 -
  468.     (((*cmdw->teh)->viewRect.bottom-(*cmdw->teh)->viewRect.top) / 
  469.      (*cmdw->teh)->lineHeight);
  470.     if (maxv < 0)            /* for less than one page */
  471.     maxv = 0;            /* use this value as max */
  472.     SetCtlMax (cmdw->vscroll, maxv);    /* set it... */
  473.     return maxv;
  474. }                    /* setscrollmax */
  475.  
  476.  
  477. /****************************************************************************/
  478. /* PWP: trimcon(length) should be called before TEInsert()ing <length>    */
  479. /*      number of bytes.  This function checks to see if there is enough  */
  480. /*    room for this many characters, and deletes a bit from the beginning  */
  481. /*    if there isn't space.  */
  482. /*      Returns 1 if it trimmed, 0 if it didn't.  */
  483. /****************************************************************************/
  484. int
  485. trimcon(cmdw, l)
  486.     struct cmdw *cmdw;
  487.     register int l;
  488. {
  489.     if (cmdw) {
  490.     if (((*cmdw->teh)->teLength + l) > TE_TOOBIG) {
  491.         TESetSelect(0, TE_TRIM, cmdw->teh);/* select beginning part */
  492.         TEDelete(cmdw->teh);    /* nuke it */
  493.         /* and make insertion point at end again */
  494.         TESetSelect(TE_MAX, TE_MAX, cmdw->teh);
  495.         return (1);
  496.     }
  497.     }
  498.     return (0);
  499. }
  500.  
  501.  
  502. /*
  503.  * cmdwbywindow
  504.  * Find a cmdw given a WindowPtr
  505.  */
  506. struct cmdw *cmdwbywindow (WindowPtr w)
  507. {
  508.     struct cmdw *cmdw;
  509.  
  510.     cmdw = cmdwl;
  511.     while (cmdw) {
  512.     if (cmdw->window == w)
  513.         break;
  514.     cmdw = cmdw->next;
  515.     }
  516.     return(cmdw);
  517. }
  518.  
  519.  
  520. /*
  521.  * termwbywindow
  522.  * Find a termw given a WindowPtr
  523.  */
  524. struct termw *termwbywindow (WindowPtr w)
  525. {
  526.     struct termw *termw;
  527.     extern struct termw *termwl;
  528.  
  529.     termw = termwl;
  530.     while (termw) {
  531.     if (termw->window == w)
  532.         break;
  533.     termw = termw->next;
  534.     }
  535.     return(termw);
  536. }
  537.  
  538.  
  539. /*
  540.  * cmdwSelectWindow
  541.  */
  542. void cmdwSelectWindow (struct cmdw *cmdw)
  543. {
  544.     SelectWindow(cmdw->window);
  545.     updateTakeMenu(cmdw);
  546. }
  547.  
  548.  
  549. /*
  550.  * updateTakeMenu
  551.  */
  552. void updateTakeMenu (struct cmdw *cmdw)
  553. {
  554.     char scratch[255];
  555.  
  556.     /*
  557.      * If this is a file window, update and enable the Take
  558.      * Command from Window menu item.  Otherwise, disable
  559.      * the item.
  560.      */
  561.     if (cmdw->flags & CMDWF_FILE) {
  562.     if (have_128roms) {
  563.         sprintf(scratch, "Take \"%s\"", p2c_tmp(cmdw->wname));
  564.         c2pstr(scratch);
  565.         DelMenuItem(menus[FILE_MENU], TAKEW_FIL);
  566.         InsMenuItem(menus[FILE_MENU], scratch, TAKEW_FIL-1);
  567.     }
  568.     EnableItem(menus[FILE_MENU], TAKEW_FIL);
  569.     } else {
  570.     DisableItem(menus[FILE_MENU], TAKEW_FIL);
  571.     }
  572. }
  573.  
  574.  
  575. /*
  576.  * kSelectWindow
  577.  */
  578. VOID kSelectWindow (WindowPtr w)
  579. {
  580.     SelectWindow(w);
  581.  
  582.     /*
  583.      * Selecting the terminal window or the command window implicitly
  584.      * connects or disconnects us.
  585.      */
  586.     if (ttermw->window == w)
  587.     connected = TRUE;
  588.     else if (ctermw->window == w)
  589.     connected = FALSE;
  590.  
  591.     DisableItem(menus[FILE_MENU], TAKEW_FIL);
  592. }
  593.  
  594.  
  595. /*
  596.  * kShowWindow
  597.  * Only call ShowWindow if window is not showing.
  598.  */
  599. VOID kShowWindow (struct termw *termw)
  600. {
  601.     if (termw->showing)
  602.     return;
  603.  
  604.     ShowWindow(termw->window);
  605.  
  606.     termw->showing = TRUE;
  607. }
  608.  
  609.  
  610. /*
  611.  * kHideWindow
  612.  * Only call HideWindow if window is showing.
  613.  */
  614. VOID kHideWindow (struct termw *termw)
  615. {
  616.     if (!termw->showing)
  617.     return;
  618.  
  619.     HideWindow(termw->window);
  620.  
  621.     termw->showing = FALSE;
  622. }
  623.  
  624.  
  625. /*
  626.  * setWindowLoc
  627.  * Set initial location of a window we're about to create.
  628.  */
  629. #define TCORNER 40            /* corner of first window */
  630. #define LCORNER 5
  631. #define TINC 15                /* how far to move each window */
  632. #define LINC 10
  633.  
  634. void setWindowLoc (int id)
  635. {
  636.     int ldiff, tdiff;
  637.     Handle wh;                /* window handle */
  638.     Rect *rectp;
  639.     static int tcorner = TCORNER;    /* window (top, left) corner */
  640.     static int lcorner = LCORNER;
  641.     static int n = 0;
  642.  
  643.     /*
  644.      * Wrap window location after so many windows.
  645.      */
  646.     if (++n > 9) {
  647.     n = 0;
  648.     tcorner = TCORNER + TINC;    /* don't re-use first slot */
  649.     lcorner = LCORNER + LINC;
  650.     }
  651.  
  652.     /*
  653.      * Get the window resource and modify the location.
  654.      * Since it will already be in memory, GetNewWindow will use
  655.      * the values we just set.
  656.      */
  657.     wh = GetResource('WIND', id);
  658.     rectp = (Rect *)*wh;
  659.     ldiff = lcorner - rectp->left;
  660.     tdiff = tcorner - rectp->top;
  661.     rectp->top = tcorner;
  662.     rectp->left = lcorner;
  663.     rectp->bottom = rectp->bottom + tdiff;
  664.     rectp->right = rectp->right + ldiff;
  665.     tcorner += TINC;
  666.     lcorner += LINC;
  667. }
  668.  
  669.  
  670. /*
  671.  * cmdwUpdateCursor
  672.  * Update cursor when a cmdw window is the front window.
  673.  */
  674. void cmdwUpdateCursor (struct cmdw *cmdw)
  675. {
  676.     Point MousePt;
  677.     GrafPtr savePort;
  678.     Cursor *curs;
  679.  
  680.     GetPort (&savePort);
  681.     SetPort (cmdw->window);
  682.  
  683.     GetMouse(&MousePt);
  684.  
  685.     if (PtInRect(MousePt, &cmdw->teviewr))
  686.     curs = textcurs;
  687.     else
  688.     curs = normcurs;
  689.  
  690.     if  (lastCursor!= curs) {
  691.     SetCursor(curs);
  692.     lastCursor = curs;
  693.     }
  694. }
  695.