home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Moscow ML 1.42 / ANSIshellƒ / os_mac_eKeys.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-18  |  19.7 KB  |  761 lines  |  [TEXT/R*ch]
  1. /* os_mac_eKeys.c
  2.  * 3May92  e
  3.  */
  4.  
  5. #include "os_mac.h"
  6.  
  7. /* extensions to an editor for text files by e
  8.    questions/comments via Internet <e@Flavors.COM> */
  9. /* Copyright © e, 1989,1992. All rights reserved.
  10.     Developed using THINK C 5.0.1 for use with Gambit Scheme.
  11.     This code may be freely distributed as long as this notice remains.
  12.    thanks to Marc Feeley.
  13. */
  14.  
  15. #if LISPmodeP
  16.  
  17. #define graphic_char(c) (!(((c)>=0) && ((c)<=32)))
  18.  
  19. static long whsp_fwd_guts( eRec **hE, long offs )
  20. { 
  21.   register char *text = *((**hE).hText);
  22.   register char *p = text + offs;
  23.   register char *end = text + eTeTextLength( hE );
  24.   register char c;
  25.  
  26.   while( p < end )
  27.   { c = *p++;
  28.     if( graphic_char(c) )
  29.     { if( c != ';' )
  30.           return p - text - 1;
  31.       else
  32.         while ( p < end && *p++ != '\r' )  ;
  33.     }
  34.   }
  35.   return end - text;
  36. }
  37.  
  38. static long whsp_fwd( eRec **hE )
  39. { 
  40.   long offs = eTeChPosToOffset( hE, (**hE).selActive ? (**hE).selEnd : (**hE).caretChPos );
  41.   return whsp_fwd_guts( hE, offs );
  42. }
  43.  
  44. static long whsp_bwd( eRec **hE )
  45. {
  46.   long offs = eTeChPosToOffset( hE, (**hE).selActive ? (**hE).selStart : (**hE).caretChPos );
  47.   register char *text = *((**hE).hText);
  48.   register char *p = text + offs - 1;
  49.   register char c;
  50.  
  51.   while( p >= text )
  52.   { if( graphic_char( *p ) )
  53.         return p - text + 1;
  54.     else
  55.       p--;
  56.   }
  57.   return 0;
  58. }
  59.  
  60. long balance_fwd_guts( eRec **hE, long offs, int bal )
  61. { 
  62.   register char *text = *((**hE).hText);
  63.   register char *p = text + offs;
  64.   register char *end = text + eTeTextLength( hE );
  65.   register int b = bal;
  66.   register char c;
  67.  
  68.   while( p < end && !graphic_char(*p) ) p++;
  69.  
  70.   while( p < end )
  71.   { c = *p++;
  72.     if( graphic_char(c) )
  73.       switch (c)
  74.       { case '(':
  75.           b++;
  76.           break;
  77.         case ')':
  78.           b--;
  79.           if (b <= 0) goto scan_done;
  80.           break;
  81.         case ';':
  82.           while ( p < end && *p++ != '\r' )  ;
  83.           break;
  84.         case '"':
  85.         { while (p<end)
  86.           { c = *p++;
  87.               if( c == '"' ) goto breake;
  88.               if( c == '\\' ) p++;
  89.           }
  90.           return -1;
  91.           breake:
  92.           if( b <= 0 ) goto scan_done;
  93.           break;
  94.         }
  95.         case '#':
  96.           if( *p == '\\' ) p += 2;
  97.           break;
  98.         case ',':
  99.           if( *p == '@' ) p++;
  100.           break;
  101.         case '\'':
  102.         case '`':
  103.           break;
  104.         default:
  105.         { while ((p<=end) && graphic_char(c) && (c!='(') && (c!=')') && (c!='"'))
  106.             c = *p++;
  107.           p--;
  108.           if (b <= 0) goto scan_done;
  109.           break;
  110.         }
  111.      }
  112.   }
  113.   return -1;
  114.  
  115.   scan_done:
  116.   return p-text;
  117. }
  118.  
  119. long balance_fwd( eRec **hE, int bal )
  120. { 
  121.   long offs = eTeChPosToOffset( hE, (**hE).selActive ? (**hE).selEnd : (**hE).caretChPos );
  122.   return balance_fwd_guts( hE, offs, bal );
  123. }
  124.  
  125. long balance_bwd_guts( eRec **hE, long offs, int bal, int prefix )
  126. {
  127.   register char *text = *((**hE).hText);
  128.   register char *p = text + offs;
  129.   register int b = bal;
  130.  
  131.   while ((p>text) && !graphic_char(p[-1])) p--;
  132.  
  133.   while (p>text)
  134.     if ((p>=text+3) && (p[-2]=='\\') && (p[-3]=='#'))
  135.     { p -= 3;
  136.       if (b <= 0) goto scan_prefix;
  137.     }
  138.     else
  139.     { register char c = *--p;
  140.       if (graphic_char(c))
  141.         switch (c)
  142.         { case '(':
  143.             b--;
  144.             if (b <= 0) goto scan_prefix;
  145.             break;
  146.           case ')':
  147.             b++;
  148.             break;
  149.           case '"':
  150.           { while (p>text)
  151.             { register char *q = --p;
  152.               while ((q>text) && (q[-1]=='\\')) q--;
  153.               if ((p-q)&1L)
  154.                 p = q;
  155.               else if (*p=='"')
  156.                 if (b <= 0) goto scan_prefix; else goto brak;
  157.             }
  158.             return -1;
  159.             brak:
  160.             break;
  161.           }
  162.           default:
  163.           { while ((p>=text) && graphic_char(c) &&
  164.                    (c!='(') && (c!=')') && (c!='"'))
  165.               c = *--p;
  166.             p++;
  167.             if (b <= 0) goto scan_prefix;
  168.             break;
  169.           }
  170.       }
  171.   }
  172.   return -1;
  173.  
  174.   scan_prefix:
  175.   if (prefix)
  176.     while (p>text)
  177.     { register char c = *--p;
  178.       if ((c!='\'') && (c!='`') && (c!=',') && (c!='@') && (c!='#'))
  179.       { p++; break; }
  180.     }
  181.   return p-text;
  182. }
  183.  
  184. long balance_bwd( eRec **hE, int bal, int prefix )
  185. {
  186.   long offs = eTeChPosToOffset( hE, (**hE).selActive ? (**hE).selStart : (**hE).caretChPos );
  187.   return balance_bwd_guts( hE, offs, bal, prefix );
  188. }
  189.  
  190. static int rangeBalance( register char *beg, register char *end )
  191. {
  192.     register int n = 0;
  193.     
  194.     while(beg < end)
  195.     {    if (*beg == '(')        n++;
  196.         else if (*beg == ')')    n--;
  197.         beg++;
  198.     }
  199.     return(n);
  200. }
  201.  
  202. /* 23Jul92  e  */
  203.  
  204. extern int check_TEInsert( char *ptr, long len, eRec **hE, int bold );
  205.  
  206. #if 0
  207.  
  208. /* 17Aug92  e  */
  209.  
  210. void eTabCommand( eRec **hE, short modifiers, short style )
  211. { long open_paren;
  212.   long selStart, selEnd, selLen;
  213.   ChPos solcp, eolcp;
  214.   char *p;
  215.   long sol, eol;
  216.   long adj = 0;
  217.   Boolean selActive;
  218.  
  219.   if( ( selActive = (**hE).selActive ) )
  220.   {    selStart = eTeChPosToOffset( hE, (**hE).selStart );
  221.     selEnd   = eTeChPosToOffset( hE, (**hE).selEnd );
  222.     selLen   = selEnd - selStart;
  223.     eTeSetSelect( hE, selStart, selStart );
  224.     solcp = (**hE).selStart;
  225.   }
  226.   else
  227.   {    selStart = eTeChPosToOffset( hE, (**hE).caretChPos );
  228.     selLen = 0;
  229.     solcp = (**hE).caretChPos;
  230.   }
  231.   eolcp.h = solcp.h = 0;    /* start of line */
  232.   eolcp.v = solcp.v + 1;
  233.   eol = eTeChPosToOffset( hE, eolcp );    /* next line */
  234.   sol = eTeChPosToOffset( hE, solcp );    /* this line */
  235.   p = *((**hE).hText) + sol;
  236.   while( ! graphic_char( *p ) && sol < eol && *p != RETURN ) { p++; sol++; solcp.h++; }
  237.   if( sol != selStart ) eTeSetSelect( hE, sol, sol );
  238.   if( sol < selStart )  adj = selStart - sol;
  239.   
  240.   open_paren = balance_bwd( hE, 0, 1 );
  241.   eolcp = eTeOffsetToChPos( hE, open_paren );
  242.   if( solcp.h > eolcp.h )
  243.   { eolcp.v = solcp.v;
  244.     eol = eTeChPosToOffset( hE, eolcp );
  245.     eTeSetSelect( hE, eol, eol );
  246.     eTeKillTo( hE, solcp );
  247.   }
  248.   else while (solcp.h < eolcp.h)
  249.   { long len = (eolcp.h - solcp.h < 80) ? eolcp.h - solcp.h : 80;
  250.     if (check_TEInsert( "                                                                                ",
  251.                         len, hE, style )) goto err;
  252.     solcp.h += len;
  253.   }
  254.   err:
  255.   if( sol < selStart || selActive )
  256.   { selStart = eTeChPosToOffset( hE, (**hE).caretChPos ) + adj;
  257.     eTeSetSelect( hE, selStart, selStart + selLen );
  258.   }
  259.   eTeShowCaret( hE );
  260. }
  261.  
  262. #else
  263.  
  264. /* 14Oct92  e  */
  265.  
  266. static char dncase( char c )
  267. { if( c >= 'A' &&  c <= 'Z' ) return c + 0x20;
  268.   else return c;
  269. }
  270.  
  271. static Boolean eq_subfs( char *p, char *q )
  272. { char c;
  273.   while( c = *p++ )
  274.     if( c != dncase( *q++ ) )
  275.       return ( ( c == '•' ) ? TRUE : FALSE ); /* was always FALSE -- 05Jan95 e */
  276.   c = *q;
  277.   return( ( graphic_char(c) && c != '(' && c != '"' ) ? FALSE : TRUE );
  278. }
  279.  
  280. /* subforms of forms whose car is in this table are indented specially...
  281.   call the subform to be indented "the target":
  282.   if there are more than cnt subforms between the car and the target,
  283.     then the last subform before the target determines the postion of the target,
  284.   otherwise the target is indented one more space than the car
  285. */ 
  286.  
  287. struct _spec_subfs { char *str; char cnt; };
  288.  
  289. static struct _spec_subfs spec_subfs_data[] =
  290.     { { "if", 1 },
  291.       { "do", 2 },
  292.       { "do*", 2 },
  293.       { "let", 18 },    /* special case for named let */
  294.       { "let*", 1 },
  295.       { "case", 1 },
  296.       { "begin", 0 },
  297.       { "lambda", 1 },
  298.       { "letrec", 1 },
  299.       { "define", 1 },
  300.       { "##declare", 0 },
  301.       { "##define-macro", 1 },
  302.       { "syntax-rules", 1 },       /* s48 05Jan95 e */
  303.       { "define-structure", 2 },   /* s48 05Jan95 e */
  304.       { "define-record-type", 2 }, /* s48 05Jan95 e */
  305.       { "define-•", 1 },           /* s48 05Jan95 e -- handles many, e.g., { "define-syntax", 1 } */
  306.       { "with-•", 1 },             /* s48 05Jan95 e -- handles many */
  307.       { "call-with-•", 1 },        /* s48 05Jan95 e -- handles many */
  308.       { "", -1 }
  309.     };
  310.  
  311. static long spec_subfs( char *p )
  312. { char c;
  313.   long res = -1;
  314.   struct _spec_subfs *s = spec_subfs_data;
  315.   if( (c = dncase(*p)) >= 'a' && c <= 'z' )
  316.     while( (res = (*s).cnt) >= 0 )
  317.       if( eq_subfs( (*s).str, p ) )
  318.         break;
  319.       else
  320.         s++;
  321.   return res;
  322. }
  323.  
  324. void eTabCommand( eRec **hE, short modifiers, short style )
  325. { long open_paren, upen_paren;
  326.   long selStart, selEnd, selLen;
  327.   ChPos solcp, eolcp;
  328.   char *p;
  329.   long sol, eol;
  330.   long adj = 0;
  331.   Boolean selActive;
  332.   
  333.   if( ( selActive = (**hE).selActive ) )
  334.   {    selStart = eTeChPosToOffset( hE, (**hE).selStart );
  335.     selEnd   = eTeChPosToOffset( hE, (**hE).selEnd );
  336.     selLen   = selEnd - selStart;
  337.     eTeSetSelect( hE, selStart, selStart );
  338.     solcp = (**hE).selStart;
  339.   }
  340.   else
  341.   {    selStart = eTeChPosToOffset( hE, (**hE).caretChPos );
  342.     selLen = 0;
  343.     solcp = (**hE).caretChPos;
  344.   }
  345.   eolcp.h = solcp.h = 0;    /* start of line */
  346.   eolcp.v = solcp.v + 1;
  347.   eol = eTeChPosToOffset( hE, eolcp );    /* next line */
  348.   sol = eTeChPosToOffset( hE, solcp );    /* this line */
  349.   p = *((**hE).hText) + sol;
  350.   while( ! graphic_char( *p ) && sol < eol && *p != RETURN ) { p++; sol++; solcp.h++; }
  351.   if( sol != selStart ) eTeSetSelect( hE, sol, sol );
  352.   if( sol < selStart )  adj = selStart - sol;
  353.   
  354.   open_paren = balance_bwd_guts( hE, sol, 0, 1 );
  355.   /*  14Oct92  e  */
  356.   if( open_paren > 0 )
  357.   { upen_paren = balance_bwd_guts( hE, sol, 1, 1 );
  358.     if( upen_paren < 0 )
  359.     { /* a toplevel form should be at column zero !? */
  360.       eolcp.h = 0;
  361.       goto justdotab;
  362.     }
  363.     else
  364.     { long rover, prevr, first;
  365.       long count = 0;
  366.       char *text = *((**hE).hText);
  367.       p = text + upen_paren;
  368.       while( *p != '(' ) p++;    /* there must be a '(' since upen_paren >= 0 */ 
  369.       upen_paren = p - text;    /* the offset of the '(' */
  370.       prevr = upen_paren + 1;
  371.       rover = first = whsp_fwd_guts( hE, prevr );
  372.       while( rover > 0 && rover < open_paren )
  373.       { prevr = rover;
  374.           count++;
  375.         rover = balance_fwd_guts( hE, rover, 0 );
  376.         if( rover > 0 ) rover = whsp_fwd_guts( hE, rover );
  377.       }
  378.       /* now...
  379.         upen_paren = start of enclosing form
  380.         open_paren = start of preceeding form
  381.         first = first sub-form of enclosing form
  382.         prevr = last sub-form of enclosing form <= open_paren, or upen_paren+1 if none
  383.         rover = last sub-form of enclosing form >= open_paren, or -1 if none
  384.         count = position of rover in subforms of enclosing form
  385.       */ /* this catches subforms inside comments... */
  386.       if( rover != open_paren ) { open_paren = prevr; count--; }
  387.       /* this handles special indentation for special forms... */
  388.       if( first < sol
  389.           && (rover = spec_subfs( text + first ) ) >= 0
  390.           && ( count == 0 || count == rover || ( rover > 15 && count <= (rover&15)) ) )
  391.       { eolcp = eTeOffsetToChPos( hE, first );
  392.           eolcp.h += 1;
  393.           goto justdotab;
  394.       }
  395.     }
  396.   }
  397.   /* */
  398.   eolcp = eTeOffsetToChPos( hE, open_paren );
  399. justdotab:
  400.   if( solcp.h > eolcp.h )
  401.   { eolcp.v = solcp.v;
  402.     eol = eTeChPosToOffset( hE, eolcp );
  403.     /* 27Jan93  e  -- this mungs the scrap...
  404.     eTeSetSelect( hE, eol, eol );
  405.     eTeKillTo( hE, solcp );
  406.     instead... */
  407.     eTeSetSelect( hE, eol, sol );
  408.     eTeDelete( hE );
  409.   }
  410.   else while (solcp.h < eolcp.h)
  411.   { long len = (eolcp.h - solcp.h < 80) ? eolcp.h - solcp.h : 80;
  412.     if (check_TEInsert( "                                                                                ",
  413.                         len, hE, style )) goto err;
  414.     solcp.h += len;
  415.   }
  416.   err:
  417.   if( sol < selStart || selActive )
  418.   { selStart = eTeChPosToOffset( hE, (**hE).caretChPos ) + adj;
  419.     eTeSetSelect( hE, selStart, selStart + selLen );
  420.   }
  421.   eTeShowCaret( hE );
  422. }
  423.  
  424. #endif
  425.  
  426. #define mCheck(n, ch) ((rover[n] == ch) && (n >= 0) && (n < teLength))
  427.  
  428. void eEditCommand( eRec **hE, char ch, short modifiers, short style )
  429. {
  430.     register char *rover;
  431.     register long needLeft, needRight;
  432.     long selStart, selEnd, teLength;
  433.     short wanted;    /* -1 at start, 0 range, 1 at end */
  434.     Boolean selActive;
  435.     short optioned = modifiers & optionKey;
  436.     short shifted  = modifiers & shiftKey;
  437.     
  438.     ch += 0x40;    /* undo control key */
  439.     modifiers &= ~controlKey;
  440.     
  441.     if( ( selActive = (**hE).selActive ) )
  442.     {    selStart = eTeChPosToOffset( hE, (**hE).selStart );
  443.         selEnd =   eTeChPosToOffset( hE, (**hE).selEnd );
  444.     }
  445.     else
  446.     {    selEnd = selStart = eTeChPosToOffset( hE, (**hE).caretChPos );
  447.     }
  448.     teLength = eTeTextLength( hE );
  449.     
  450.     rover = (char *)*(**hE).hText;
  451.     wanted = 0;                        /* always range; someday use mark */
  452.     needLeft = needRight = 0;
  453.  
  454.     switch( ch )
  455.     {
  456.         case 'T':            /* Transpose */        /* 22Jul92  e  */
  457.         case 't':
  458.         case '†':    /* option-t */
  459.         case 'ˇ':    /* option-shift-t */
  460.             if( selActive )
  461.               SysBeep(6);
  462.             else if( optioned )
  463.             { needLeft  = balance_bwd( hE, 0, 1 );
  464.               needRight = balance_fwd( hE, 0 );
  465.               if( needLeft >= 0 && needRight >= 0 )
  466.                 eTeTranspose( hE, needLeft, whsp_bwd( hE ), whsp_fwd( hE ), needRight );
  467.               else
  468.                 SysBeep(6); /* can't be done! */
  469.             }
  470.             else
  471.               eTeTranspose( hE, selStart - 1, selStart, selStart, selStart + 1 );
  472.             return;
  473.  
  474.         case 'K':            /* Kill */
  475.         case 'k':
  476.         case '':    /* option-k */
  477.         case '˚':    /* option-shift-k */
  478.             if( ! selActive && optioned )
  479.             { /* c-m-k (del-fwd-sexp) */
  480.               selEnd = balance_fwd( hE, 0 );
  481.               if( selEnd >= 0 )
  482.               { eTeKillTo( hE, eTeOffsetToChPos( hE, selEnd ) );
  483.               }
  484.               else SysBeep( 3 );
  485.             }
  486.             else /* Kill line */
  487.               eTeKey( hE, 0x7f, KeyDel, optionKey, style);
  488.             return;
  489.  
  490.         case 'D':            /* Delete */
  491.         case 'd':
  492.             eTeKey( hE, 0x7f, KeyDel, 0, style);
  493.             return;
  494.  
  495.         case 'O':            /* Open line */
  496.         case 'o':
  497.         case 'ø':    /* option-o */
  498.         case 'Ø':    /* option-shift-o */
  499.             if( selActive )
  500.                 eTeSetSelect( hE, selStart, selStart );
  501.             eTeKey( hE, '\r', 0, 0, style);
  502.             eTeSetSelect( hE, selStart, selStart );
  503.             return;
  504.  
  505.         case 'A':
  506.         case 'a':
  507.         case 'å':    /* option-a */
  508.         case 'Å':    /* option-shift-a */
  509.             if( optioned )
  510.             {    wanted = shifted ? 0 : -1;
  511.                 needLeft = 2;
  512.                 /* needRight = 2; */
  513.                 break;
  514.             }
  515.             eTeKey( hE, LEFT_ARROW, 0, modifiers | cmdKey, style );
  516.             return;
  517.  
  518.         case 'E':
  519.         case 'e':
  520.                     /* option-e is a dead key */
  521.         case '´':    /* option-shift-e */
  522.             if( optioned )
  523.             {    wanted = shifted ? 0 : 1;
  524.                 /* needLeft = 2; */
  525.                 needRight = 2;
  526.                 break;
  527.             }
  528.             eTeKey( hE, RIGHT_ARROW, 0, modifiers | cmdKey, style );
  529.             return;
  530.  
  531.         case 'P':                            /* Previous */
  532.         case 'p':
  533.         case 'π':    /* option-p */
  534.         case '∏':    /* option-shift-p */
  535.             eTeKey( hE, UP_ARROW, 0, modifiers, style );
  536.             return;
  537.  
  538.         case 'N':                            /* Next */
  539.         case 'n':
  540.                     /* option-n is a dead key */
  541.         case '˜':    /* option-shift-n */
  542.             eTeKey( hE, DOWN_ARROW, 0, modifiers, style );
  543.             return;
  544.  
  545.         case 'M':                            /* Match (Balance) */
  546.         case 'm':
  547.         case 'µ':    /* option-m */
  548.         case 'Â':    /* option-shift-m */
  549.             if( ! selActive )
  550.             {    /* too smart?  22Jul92  e
  551.                 if( mCheck( selStart, '(' ) )
  552.                 {    selEnd = selStart + 1;
  553.                     needLeft = 0;
  554.                     needRight = 1;
  555.                 }
  556.                 else if( mCheck( selStart - 1, ')' ) )
  557.                 {    selStart = selEnd - 1;
  558.                     needLeft = 1;
  559.                     needRight = 0;
  560.                 }
  561.                 else
  562.                 {    needLeft = 1;
  563.                     needRight = 1;
  564.                 }
  565.                 */
  566.                 needLeft = 2;
  567.                 needRight = 2;
  568.             }
  569.             else
  570.             {    needRight = rangeBalance( &rover[selStart], &rover[selEnd] );
  571.                 /* too smart?  22Jul92  e
  572.                 if( needRight == 0 )
  573.                 {    needLeft = 1;
  574.                     needRight = 1;
  575.                 }
  576.                 else if( needRight < 0 )
  577.                 {    needLeft = -needRight;
  578.                     if( mCheck(selEnd - 1, ')' ) )
  579.                         needRight = 0;
  580.                     else
  581.                     {    needRight = 1;
  582.                         needLeft += 1;
  583.                     }
  584.                 }
  585.                 else
  586.                 {    if( mCheck( selStart, '(' ) )
  587.                         needLeft = 0;
  588.                     else
  589.                     {    needLeft = 1;
  590.                         needRight += 1;
  591.                     }
  592.                 }
  593.                 */
  594.                 if( needRight == 0 )
  595.                 {    needLeft = 2;
  596.                     needRight = 2;
  597.                 }
  598.                 else if( needRight < 0 )
  599.                 {    needLeft = -needRight;
  600.                     needRight = 2;
  601.                     needLeft += 2;
  602.                 }
  603.                 else
  604.                 {    needLeft = 2;
  605.                     needRight += 2;
  606.                 }
  607.             }
  608.             break;
  609.  
  610.         case 'ƒ':    /* option f */                /* Forward */
  611.         case 'f':
  612.         case 'Ï':    /* option shift f */
  613.         case 'F':
  614.             wanted = shifted ? 0 : 1;
  615.             if( ! selActive || shifted )
  616.             {    if( optioned ) needRight = 1;
  617.                 else
  618.                 {    eTeKey( hE, RIGHT_ARROW, 0, modifiers, style );
  619.                     return;
  620.                 }
  621.             }
  622.             /* else    selection range case automatic */
  623.             break;
  624.  
  625.         case '∫':    /* option b */                /* Back */
  626.         case 'b':
  627.         case 'ı':    /* option shift b */
  628.         case 'B':
  629.             wanted = shifted ? 0 : -1;
  630.             if( ! selActive || shifted )
  631.             {    if( optioned ) needLeft = 1;
  632.                 else
  633.                 {    eTeKey( hE, LEFT_ARROW, 0, modifiers, style );
  634.                     return;
  635.                 }
  636.             }
  637.             /* else    selection range case automatic */
  638.             break;
  639.  
  640.         default:
  641.             return;
  642.     }
  643.     if( needRight != 0 )
  644.     {     selEnd   = balance_fwd( hE, needRight - 1 );
  645.         if( selEnd   < 0 ) { SysBeep(6); return; } /* can't be done! */
  646.     }
  647.     if( needLeft  != 0 )
  648.     {     selStart = balance_bwd( hE, needLeft  - 1, 1 );
  649.         if( selStart < 0 ) { SysBeep(6); return; } /* can't be done! */
  650.     }
  651.     eTeSetSelect( hE,
  652.                   (wanted ==  1) ? selEnd : selStart,
  653.                   (wanted == -1) ? selStart : selEnd  );
  654.     eTeShowCaret( hE );
  655. }
  656.  
  657. #else
  658.  
  659. #define whsp_char(c) (((c)>=0) && ((c)<=32))
  660.  
  661. /* 16Dec92  e  -- miniature version of os_mac_eKeys.c for ML */
  662.  
  663. /* <tab> documentation
  664.  * C1 is the position of the first graphic character on the current line
  665.  * P1 is the position of the first graphic character on the previous line
  666.  * <option-tab>
  667.  *   inserts or removes space on the current line to align C1 with P1
  668.  * <tab>
  669.  *   if C1 < P1 then same as <option-tab>
  670.  *              else insert sufficient space on the current line
  671.  *                   to move C1 right to next tab stop
  672.  * <shift-tab>
  673.  *   if C1 > P1 then same as <option-tab>
  674.  *              else remove sufficient space on the current line
  675.  *                   to move C1 left to previous tab stop
  676.  * Notes: 
  677.  *  <tab> does not move the insert point or selection relative to the text
  678.  *  <tab> characters are never inserted into the text
  679.  */
  680.  
  681. extern short check_TEInsert( char *ptr, long len, eRec **hE, short bold );
  682.  
  683. static char *eighty = "                                                                                ";
  684.  
  685. void eTabCommand( eRec **hE, short modifiers, short style )
  686. { long selStart, selEnd, selLen;
  687.   ChPos plcp, tlcp, nlcp;
  688.   char *p;
  689.   long pl, tl, nl;
  690.   long adj = 0;
  691.   Boolean selActive;
  692.  
  693.   if( ( selActive = (**hE).selActive ) != 0 )
  694.   {    selStart = eTeChPosToOffset( hE, (**hE).selStart );
  695.     selEnd   = eTeChPosToOffset( hE, (**hE).selEnd );
  696.     selLen   = selEnd - selStart;
  697.     eTeSetSelect( hE, selStart, selStart );
  698.     tlcp = (**hE).selStart;
  699.   }
  700.   else
  701.   {    selStart = eTeChPosToOffset( hE, (**hE).caretChPos );
  702.     selLen = 0;
  703.     tlcp = (**hE).caretChPos;
  704.   }
  705.   plcp.h = tlcp.h = nlcp.h = 0;    /* start of {prev,this,next} line */
  706.   plcp.v = tlcp.v - 1;
  707.   nlcp.v = tlcp.v + 1;
  708.   nl = eTeChPosToOffset( hE, nlcp );    /* next line */
  709.   tl = eTeChPosToOffset( hE, tlcp );    /* this line */
  710.   if (plcp.v < 0)
  711.   {    pl = 0;
  712.       plcp.v = 0;
  713.   }
  714.   else
  715.   { pl = eTeChPosToOffset( hE, plcp );
  716.     p = *((**hE).hText) + pl;
  717.     while( whsp_char( *p ) && pl < tl && *p != RETURN ) { p++; pl++; plcp.h++; }
  718.   }
  719.   p = *((**hE).hText) + tl;
  720.   while( whsp_char( *p ) && tl < nl && *p != RETURN ) { p++; tl++; tlcp.h++; }
  721.  
  722.   if( tl != selStart ) eTeSetSelect( hE, tl, tl );
  723.   if( tl < selStart )  adj = selStart - tl;
  724.   
  725.   if ( ! ( modifiers & optionKey ) )
  726.   {    short tabStops = (**hE).tabStops;
  727.     if( modifiers & shiftKey )
  728.     { if( tlcp.h <= plcp.h )
  729.         if( tlcp.h > 0 && tabStops > 0 )
  730.             plcp.h = ( (tlcp.h - 1) / tabStops ) * tabStops;
  731.         else
  732.             plcp.h = 0;
  733.     }
  734.     else
  735.     { if( tlcp.h >= plcp.h && tabStops > 0 )
  736.         plcp.h = tlcp.h + tabStops - tlcp.h % tabStops;
  737.     }
  738.   }
  739.   if( tlcp.h > plcp.h )
  740.   { plcp.v = tlcp.v;
  741.     pl = eTeChPosToOffset( hE, plcp );
  742.     eTeSetSelect( hE, pl, pl );
  743.     eTeKillTo( hE, tlcp );
  744.   }
  745.   else while (tlcp.h < plcp.h)
  746.   { long len = (plcp.h - tlcp.h < 80) ? plcp.h - tlcp.h : 80;
  747.     if (check_TEInsert( eighty, len, hE, style )) goto err;
  748.     tlcp.h += len;
  749.   }
  750.   err:
  751.   if( tl < selStart || selActive )
  752.   { selStart = eTeChPosToOffset( hE, (**hE).caretChPos ) + adj;
  753.     eTeSetSelect( hE, selStart, selStart + selLen );
  754.   }
  755.   eTeShowCaret( hE );
  756. }
  757.  
  758. #endif
  759.  
  760. /* end of os_mac_eKeys.c */
  761.