Return to keyfuncs.c CVS log

Up to [OS/2 SDKs] / os2sdk / demos / apps / sse

Annotation of os2sdk/demos/apps/sse/keyfuncs.c, revision 1.1

1.1     ! root        1: /****** KEYFUNCS.C - a collection of routines to service special keys
        !             2:  *                  each routine has the name of the key it services
        !             3:  */
        !             4: 
        !             5: #include <ctype.h>
        !             6: #include <dos.h>
        !             7: #include <doscalls.h>
        !             8: #include <subcalls.h>
        !             9: #include "ssedefs.h"
        !            10: #include "keydefs.h"
        !            11: 
        !            12: 
        !            13: /*** insert(c) - inserts the character c at the current cursor position
        !            14:  *
        !            15:  *   This routine is called when any regular printable character is hit.
        !            16:  *
        !            17:  *   insert(c) checks to see if there is room in EditBuff[] to insert the
        !            18:  *   character it is passed by seeing if there is already a printable
        !            19:  *   character in the 80th column. If so, no character can be inserted
        !            20:  *   so we just call badkey(). If there is room, insert the character
        !            21:  *   at the position indicated by CurCol and shift everything past that
        !            22:  *   over one; mark EditBuff[] as dirty.
        !            23:  *
        !            24:  *   If there is text that has been marked, insert() will call del() to
        !            25:  *   remove it before inserting its character where the marked text was.
        !            26:  *
        !            27:  *   The character we are passed has already been checked as being a
        !            28:  *   valid printable characters.
        !            29:  *
        !            30:  *   insert(c)
        !            31:  *
        !            32:  *   ENTRY:      c  -  the validated character to be inserted
        !            33:  *
        !            34:  *   EFFECTS:    EditBuff[]     - changes its contents if successful
        !            35:  *               EditBuffDirty  - sets this flag if EditBuff changed
        !            36:  *               LinesMarked    - clears this if set
        !            37:  *               CharsMarked    - clears this if set
        !            38:  *               CurCol         - increments this one
        !            39:  *
        !            40:  *   The effects of del() should also be considered since it may be
        !            41:  *   called from this function.
        !            42:  */
        !            43: 
        !            44: insert(c)
        !            45:     char c;             /* the character we are to insert, already validated */
        !            46:     {
        !            47: 
        !            48:     register short i;                                   /* indexing variable */
        !            49: 
        !            50:     if (LinesMarked || CharsMarked)       /* if there is marked text around, */
        !            51:        del();                             /* we first want to delete it      */
        !            52: 
        !            53:     if ( EditBuff[LINESIZE - 1] == ' ')  /* can only insert when there's room */
        !            54:        {
        !            55:        for ( i = (LINESIZE - 1); i > CurCol; i-- )
        !            56:            EditBuff[i] = EditBuff[i-1];         /* shift everything over one */
        !            57:        EditBuff[CurCol] = c;                    /* put in the new character  */
        !            58:        drawline();
        !            59:        CurCol += 1;                                        /* update display */
        !            60:        VIOSETCURPOS( CurRow, CurCol, 0 );
        !            61:        EditBuffDirty = 1;                       /* mark edit buffer as dirty */
        !            62:        }
        !            63: 
        !            64:     else badkey();                    /* if no room, exit as for invalid key */
        !            65: 
        !            66:     }
        !            67: 
        !            68: 
        !            69: /*** up() - moves the cursor up one row
        !            70:  *
        !            71:  *   up() moves the cursor position up one row. If we are at the top of
        !            72:  *   the screen already, up() scrolls the screen down one line. If we
        !            73:  *   are at the top of the file, it does nothing. If there is marked text
        !            74:  *   around, up() will clear it without deleting. Because the current row
        !            75:  *   in the file is changed by up(), EditBuff[] is flushed and refilled
        !            76:  *   and line25() is called to update the line information at the bottom
        !            77:  *   of the screen.
        !            78:  *
        !            79:  *   EFFECTS:    EditBuff[]     - flushes its current contents and reloads
        !            80:  *               EditBuffDirty  - clears this flag
        !            81:  *               LinesMarked    - clears this flag
        !            82:  *               MarkedLine[]   - clears all
        !            83:  *               CharsMarked    - clears this flag
        !            84:  *               MarkedChar[]   - clears all
        !            85:  *               TopRow         - if at top of screen, decrements this one
        !            86:  *               CurRow         - otherwise, decrements this one
        !            87:  */
        !            88: 
        !            89: 
        !            90: void up()
        !            91:     {
        !            92: 
        !            93:     register short i;                                /* indexing variable */
        !            94: 
        !            95:     char buff[2];            /* local buffer for scrolling fill character */
        !            96:     buff[0] = 32;            /*                 character = 32 = <blank>  */
        !            97:     buff[1] = ForeNorm;       /*                     attribute = normal   */
        !            98: 
        !            99:     if (EditBuffDirty) {                         /* this call will change */
        !           100:        EditBuffDirty = 0;                        /* cursor line, so flush */
        !           101:        flushline((TopRow + CurRow), EditBuff);   /* edit buffer if dirty  */
        !           102:        }
        !           103: 
        !           104:     if ( LinesMarked || CharsMarked ) {
        !           105:        LinesMarked = 0;                         /* if there's marked text */
        !           106:        CharsMarked = 0;                         /* around, clear it and   */
        !           107:        for ( i = 0; i < MAXLINES; i++ )         /* redraw the screen      */
        !           108:            MarkedLine[i] = 0;
        !           109:        for ( i = 0; i < LINESIZE; i++ )
        !           110:            MarkedChar[i] = 0;
        !           111:        drawscr(TopRow);
        !           112:        }
        !           113: 
        !           114:     if ( (TopRow + CurRow) != 0 ) {         /* if top of file, do nothing */
        !           115:        if ( CurRow == 0 ) {
        !           116:            TopRow -= 1;                  /* if top of screen, scroll down */
        !           117:            VIOSCROLLDN( 0, 0, (PageSize - 1), (LINESIZE - 1), 1,
        !           118:                       (char far *)buff, 0);
        !           119:            getline( (TopRow + CurRow), &EditBuff[0] );
        !           120:            drawline();
        !           121:            }
        !           122:        else {
        !           123:            CurRow -= 1;                  /* otherwise just move cursor up */
        !           124:            getline( (TopRow + CurRow), &EditBuff[0] );
        !           125:            VIOSETCURPOS( CurRow, CurCol, 0 );
        !           126:            }
        !           127:        }
        !           128: 
        !           129:     line25();        /* reset line numbers on 25th line to reflect change */
        !           130: 
        !           131:     }
        !           132: 
        !           133: 
        !           134: /*** down() - moves the cursor up one row
        !           135:  *
        !           136:  *   down() moves the cursor down one row. If we are at the top of
        !           137:  *   the screen already, down() scrolls the screen up one line. If we
        !           138:  *   are at the end of the file, it does nothing. If there is marked text
        !           139:  *   around, down() will clear it without deleting. Because the current row
        !           140:  *   in the file is changed by down(), EditBuff[] is flushed and refilled
        !           141:  *   and line25() is called to update the line information at the bottom
        !           142:  *   of the screen.
        !           143:  *
        !           144:  *   EFFECTS:    EditBuff[]     - flushes its current contents and reloads
        !           145:  *               EditBuffDirty  - clears this flag
        !           146:  *               LinesMarked    - clears this flag
        !           147:  *               MarkedLine[]   - clears all
        !           148:  *               CharsMarked    - clears this flag
        !           149:  *               MarkedChar[]   - clears all
        !           150:  *               TopRow         - if at bottom of screen, increments this one
        !           151:  *               CurRow         - otherwise, increments this one
        !           152:  */
        !           153: 
        !           154: 
        !           155: void down()
        !           156:     {
        !           157: 
        !           158:     register short i;                                /* indexing variable */
        !           159: 
        !           160:     char buff[2];            /* local buffer for scrolling fill character */
        !           161:     buff[0] = 32;            /*                  character = 32 = <blank> */
        !           162:     buff[1] = ForeNorm;       /*                      attribute = normal  */
        !           163: 
        !           164:     if (EditBuffDirty) {                         /* this call will change */
        !           165:        EditBuffDirty = 0;                        /* cursor line, so flush */
        !           166:        flushline((TopRow + CurRow), EditBuff);   /* edit buffer if dirty  */
        !           167:        }
        !           168: 
        !           169:     if ( LinesMarked || CharsMarked ) {
        !           170:        LinesMarked = 0;                         /* if there's marked text */
        !           171:        CharsMarked = 0;                         /* around, clear it and   */
        !           172:        for ( i = 0; i < MAXLINES; i++ )         /* redraw the screen      */
        !           173:            MarkedLine[i] = 0;
        !           174:        for ( i = 0; i < LINESIZE; i++ )
        !           175:            MarkedChar[i] = 0;
        !           176:        drawscr(TopRow);
        !           177:        }
        !           178: 
        !           179:     if ( (TopRow + CurRow) < (TotalLines) ) {       /* if EOF, do nothing */
        !           180:        if ( CurRow == (PageSize - 1) ) {   /* if end of screen, scroll up */
        !           181:            TopRow += 1;
        !           182:            VIOSCROLLUP( 0, 0, CurRow, (LINESIZE - 1), 1,
        !           183:                       (char far *)buff, 0);
        !           184:            getline( (TopRow + CurRow), &EditBuff[0] );
        !           185:            drawline();
        !           186:            }
        !           187:        else {
        !           188:            CurRow += 1;                          /* else move cursor down */
        !           189:            getline( (TopRow + CurRow), &EditBuff[0] );
        !           190:            VIOSETCURPOS( CurRow, CurCol, 0 );
        !           191:            }
        !           192:        }
        !           193: 
        !           194:     line25();        /* reset line numbers on 25th line to reflect change */
        !           195: 
        !           196:     }
        !           197: 
        !           198: 
        !           199: /*** home() - moves the cursor to beginning of the line
        !           200:  *
        !           201:  *   home() moves the cursor to the position of the first printable character
        !           202:  *   in the current line. If there is marked text, home() will clear it
        !           203:  *   without deleting. We need to be able to get correct information about
        !           204:  *   the length of the current line from LineTable[], so we flush EditBuff[]
        !           205:  *   on entry; but since the current line does not get changed, we do not
        !           206:  *   reload it (current contents remain correct) and we do not call line25().
        !           207:  *
        !           208:  *   EFFECTS:    EditBuffDirty  - clears this flag
        !           209:  *               LinesMarked    - clears this flag
        !           210:  *               MarkedLine[]   - clears all
        !           211:  *               CharsMarked    - clears this flag
        !           212:  *               MarkedChar[]   - clears all
        !           213:  *               CurCol         - set to position of first printable character
        !           214:  */
        !           215: 
        !           216: void home()
        !           217:     {
        !           218: 
        !           219:     register short i, j;                              /* indexing variables */
        !           220: 
        !           221: 
        !           222:     if (EditBuffDirty) {                          /* this call will need to */
        !           223:        EditBuffDirty = 0;                         /* get correct info on    */
        !           224:        flushline((TopRow + CurRow), EditBuff);    /* line length, so flush  */
        !           225:        }                                          /* edit buffer if dirty   */
        !           226: 
        !           227:     if ( LinesMarked || CharsMarked ) {
        !           228:        LinesMarked = 0;                           /* if there's marked text */
        !           229:        CharsMarked = 0;                           /* around, clear it and   */
        !           230:        for ( i = 0; i < MAXLINES; i++ )           /* redraw the screen      */
        !           231:            MarkedLine[i] = 0;
        !           232:        for ( i = 0; i < LINESIZE; i++ )
        !           233:            MarkedChar[i] = 0;
        !           234:        drawscr(TopRow);
        !           235:        }
        !           236: 
        !           237:     if( (TopRow + CurRow) < TotalLines ) {
        !           238:        i = LineTable[TopRow + CurRow]->linelength;     /* i is position of  */
        !           239:        i--;                                            /* last char in line */
        !           240:        }
        !           241:     else i = 0;            /* if we're off the end of the file, that's 0... */
        !           242: 
        !           243: 
        !           244:     for( j = 0; ( j <= i )  && !isgraph(EditBuff[j]); j++ );
        !           245: 
        !           246:     CurCol = j;                                         /* j is position of */
        !           247:     VIOSETCURPOS( CurRow, CurCol, 0 );                  /* first non-blank  */
        !           248: 
        !           249:     }
        !           250: 
        !           251: 
        !           252: /*** end_() - moves the cursor to one position past the end of the current line
        !           253:  *
        !           254:  *   end_() moves the cursor to one position beyond the position of the last
        !           255:  *   printable character in the current line. If the last printable character
        !           256:  *   is already in column 80, we just go there. If there is marked text,
        !           257:  *   end_() will clear it without deleting. We need to be able to get correct
        !           258:  *   information about the length of the current line from LineTable[], so
        !           259:  *   we flush EditBuff[] on entry; but since the current line does not get
        !           260:  *   changed, we do not reload it (current contents remain correct) and we
        !           261:  *   do not call line25(). Note that this routine had to be named end_() not
        !           262:  *   end() since that is a reserved word under the compiler used.
        !           263:  *
        !           264:  *   EFFECTS:    EditBuffDirty  - clears this flag
        !           265:  *               LinesMarked    - clears this flag
        !           266:  *               MarkedLine[]   - clears all
        !           267:  *               CharsMarked    - clears this flag
        !           268:  *               MarkedChar[]   - clears all
        !           269:  *               CurCol         - set to position of last printable
        !           270:  *                                character, plus one if possible
        !           271:  */
        !           272: 
        !           273: void end_()
        !           274:     {
        !           275: 
        !           276:     register short i;                                 /* indexing variable */
        !           277: 
        !           278:     if (EditBuffDirty) {                         /* this call will need to */
        !           279:        EditBuffDirty = 0;                        /* get correct info on    */
        !           280:        flushline((TopRow + CurRow), EditBuff);   /* line length, so flush  */
        !           281:        }                                         /* edit buffer if dirty   */
        !           282: 
        !           283:     if ( LinesMarked || CharsMarked ) {
        !           284:        LinesMarked = 0;                          /* if there's marked text */
        !           285:        CharsMarked = 0;                          /* around, clear it and   */
        !           286:        for ( i = 0; i < MAXLINES; i++ )          /* redraw the screen      */
        !           287:            MarkedLine[i] = 0;
        !           288:        for ( i = 0; i < LINESIZE; i++ )
        !           289:            MarkedChar[i] = 0;
        !           290:        drawscr(TopRow);
        !           291:        }
        !           292: 
        !           293:     if( (TopRow + CurRow) < TotalLines ) {
        !           294:        i = LineTable[TopRow + CurRow]->linelength;    /* i is position of  */
        !           295:        }                                              /* last char in line */
        !           296:     else i = 0;
        !           297: 
        !           298:     CurCol = i;
        !           299:     VIOSETCURPOS( CurRow, CurCol, 0 );
        !           300: 
        !           301:     }
        !           302: 
        !           303: 
        !           304: /*** pgup() - moves up one screen
        !           305:  *
        !           306:  *   pgup() subtracts PageSize from the current value of TopRow and then
        !           307:  *   redraws the screen, effectively moving us up one screen. If TopRow
        !           308:  *   is less than PageSize, we just go to the start of the file. The
        !           309:  *   position of the cursor on the screen is not altered. If there is marked
        !           310:  *   text, pgup() will clear it without deleting. Because this call changes
        !           311:  *   the current line, we flush and reload EditBuff[].
        !           312:  *
        !           313:  *   EFFECTS:    EditBuff[]     - flushes and reloads
        !           314:  *               EditBuffDirty  - clears this flag
        !           315:  *               LinesMarked    - clears this flag
        !           316:  *               MarkedLine[]   - clears all
        !           317:  *               CharsMarked    - clears this flag
        !           318:  *               MarkedChar[]   - clears all
        !           319:  *               TopRow         - gets PageSize subtracted from it
        !           320:  *                                if possible, otherwise set to 0.
        !           321:  */
        !           322: 
        !           323: void pgup()
        !           324:     {
        !           325: 
        !           326:     register short i;                                /* indexing variable */
        !           327: 
        !           328:     if (EditBuffDirty) {                         /* this call will change */
        !           329:        EditBuffDirty = 0;                        /* cursor line, so flush */
        !           330:        flushline((TopRow + CurRow), EditBuff);   /* edit buffer if dirty  */
        !           331:        }
        !           332: 
        !           333:     if ( LinesMarked || CharsMarked ) {
        !           334:        LinesMarked = 0;                         /* if there's marked text */
        !           335:        CharsMarked = 0;                         /* around, clear it and   */
        !           336:        for ( i = 0; i < MAXLINES; i++ )         /* redraw the screen      */
        !           337:            MarkedLine[i] = 0;
        !           338:        for ( i = 0; i < LINESIZE; i++ )
        !           339:            MarkedChar[i] = 0;
        !           340:        }
        !           341: 
        !           342:     if ( TopRow >= PageSize )           /* go up one page if there's room */
        !           343:        TopRow -= PageSize;
        !           344:     else {
        !           345:        TopRow = 0;                    /* otherwise just go to top of file */
        !           346:        CurRow = 0;
        !           347:        VIOSETCURPOS( CurRow, CurCol, 0 );
        !           348:        }
        !           349: 
        !           350:     drawscr(TopRow);                                /* redraw screen and  */
        !           351:     getline( (TopRow + CurRow), &EditBuff[0] );      /* update edit buffer */
        !           352:     line25();        /* reset line numbers on 25th line to reflect change */
        !           353: 
        !           354:     }
        !           355: 
        !           356: 
        !           357: /*** pgdn() - moves down one screen
        !           358:  *
        !           359:  *   pgdn() adds PageSize to the current value of TopRow and then
        !           360:  *   redraws the screen, effectively moving us down one screen. If the
        !           361:  *   result of adding TopRow and PageSize is greater than TotalLines
        !           362:  *   (in other words, we would be moving off the end of the file), then
        !           363:  *   we just move to one beyond the end of the file. The position of the
        !           364:  *   cursor on the screen is not altered. If there is marked text,
        !           365:  *   pgdn() will clear it without deleting. Because this call changes
        !           366:  *   the current line, we flush and reload EditBuff[].
        !           367:  *
        !           368:  *   EFFECTS:    EditBuff[]     - flushes and reloads
        !           369:  *               EditBuffDirty  - clears this flag
        !           370:  *               LinesMarked    - clears this flag
        !           371:  *               MarkedLine[]   - clears all
        !           372:  *               CharsMarked    - clears this flag
        !           373:  *               MarkedChar[]   - clears all
        !           374:  *               TopRow         - gets PageSize added to it if possible,
        !           375:  *                                otherwise set to TotalLines - PageSize - 1.
        !           376:  */
        !           377: 
        !           378: void pgdn()
        !           379:     {
        !           380: 
        !           381:     register short i;                                  /* indexing variable */
        !           382: 
        !           383:     if (EditBuffDirty) {                           /* this call will change */
        !           384:        EditBuffDirty = 0;                          /* cursor line, so flush */
        !           385:        flushline((TopRow + CurRow), EditBuff);     /* edit buffer if dirty  */
        !           386:        }
        !           387: 
        !           388:     if ( LinesMarked || CharsMarked ) {
        !           389:        LinesMarked = 0;                           /* if there's marked text */
        !           390:        CharsMarked = 0;                           /* around, clear it       */
        !           391:        for ( i = 0; i < MAXLINES; i++ )
        !           392:            MarkedLine[i] = 0;
        !           393:        for ( i = 0; i < LINESIZE; i++ )
        !           394:            MarkedChar[i] = 0;
        !           395:        }
        !           396: 
        !           397:     TopRow += PageSize;                                /* go down one page  */
        !           398:     if ( TopRow > (TotalLines - (PageSize -1)) ) {     /* if there's room,  */
        !           399:        TopRow = (TotalLines - (PageSize -1));          /* else stop at last */
        !           400:        CurRow = (PageSize -1);                         /* full page         */
        !           401:        VIOSETCURPOS(CurRow, CurCol, 0);
        !           402:        }
        !           403: 
        !           404:     drawscr(TopRow);                                  /* redraw screen and  */
        !           405:     getline( (TopRow + CurRow), &EditBuff[0] );        /* update edit buffer */
        !           406:     line25();          /* reset line numbers on 25th line to reflect change */
        !           407: 
        !           408:     }
        !           409: 
        !           410: 
        !           411: /*** bksp() - deletes character to right of the cursor; moves cursor right one
        !           412:  *
        !           413:  *   bksp() clears any marked text without deleting it, flushes EditBuff[],
        !           414:  *   moves the cursor right one position and calls del(). If we're at the
        !           415:  *   beginning of a line so there's nothing to our right, calls badkey().
        !           416:  *
        !           417:  *   EFFECTS:    EditBuff[]     - flushes and reloads
        !           418:  *               EditBuffDirty  - clears this flag
        !           419:  *               LinesMarked    - clears this flag
        !           420:  *               MarkedLine[]   - clears all
        !           421:  *               CharsMarked    - clears this flag
        !           422:  *               MarkedChar[]   - clears all
        !           423:  *               CurCol         - decrements if possible
        !           424:  *
        !           425:  *   The effects of del() should also be considered since it may be
        !           426:  *   called from this function.
        !           427:  */
        !           428: 
        !           429: void bksp()
        !           430:     {
        !           431: 
        !           432:     register short i;                                 /* indexing variable */
        !           433: 
        !           434:     if ( LinesMarked || CharsMarked ) {
        !           435:        LinesMarked = 0;                          /* if there's marked text */
        !           436:        CharsMarked = 0;                          /* around, clear it and   */
        !           437:        for ( i = 0; i < MAXLINES; i++ )          /* redraw the screen      */
        !           438:            MarkedLine[i] = 0;
        !           439:        for ( i = 0; i < LINESIZE; i++ )
        !           440:            MarkedChar[i] = 0;
        !           441: 
        !           442:        if (EditBuffDirty) {                         /* flush before redraw */
        !           443:            EditBuffDirty = 0;                       /* to get any changes  */
        !           444:            flushline((TopRow + CurRow), EditBuff);
        !           445:            }
        !           446:        drawscr(TopRow);
        !           447:        }
        !           448: 
        !           449:     if( CurCol == 0 )           /* can't backspace if already at left edge */
        !           450:        badkey();
        !           451:     else {
        !           452:        CurCol -= 1;                    /* otherwise, move left one and del */
        !           453:        VIOSETCURPOS( CurRow, CurCol, 0 );
        !           454:        del();
        !           455:        }
        !           456:     }
        !           457: 
        !           458: 
        !           459: /*** del() - deletes all indicated text
        !           460:  *
        !           461:  *   del() is the function for deleting text. What gets deleted depends on
        !           462:  *   what is marked. If there are marked lines around (as indicated by the
        !           463:  *   LinesMarked flag) then we delete the marked lines, clear all the line
        !           464:  *   marking flags, and adjust LineTable[] to reflect the change. Note that
        !           465:  *   if there are lines marked, there cannot be characters marked too. If
        !           466:  *   there are no lines marked, but characters marked, these characters are
        !           467:  *   deleted and EditBuff[] is adjusted to reflect the change and flagged
        !           468:  *   as dirty. If there are no lines or characters marked, then the character
        !           469:  *   under the cursor is deleted and EditBuff[] is adjusted accordingly and
        !           470:  *   marked as dirty.
        !           471:  *
        !           472:  *   EFFECTS:    EditBuff[]     - contents altered if no lines were marked
        !           473:  *               EditBuffDirty  - set if no lines were marked
        !           474:  *               LineTable[]    - contents altered if lines were marked
        !           475:  *               TotalLines     - altered if lines were marked
        !           476:  *               LinesMarked    - clears this flag
        !           477:  *               MarkedLine[]   - clears all
        !           478:  *               CharsMarked    - clears this flag
        !           479:  *               MarkedChar[]   - clears all
        !           480:  *               TopRow         - may change, depending on what's marked
        !           481:  *               CurRow         - may change, depending on what's marked
        !           482:  *
        !           483:  */
        !           484: 
        !           485: void del()
        !           486:     {
        !           487: 
        !           488:     register short i, j;                               /* indexing variables */
        !           489: 
        !           490:     if (LinesMarked) {                       /* if lines are marked, do this */
        !           491:        for( i = 0; !MarkedLine[i]; i++ );
        !           492:        j = i;                             /* i, j refer to first marked line */
        !           493:        if( i <= TopRow ) {
        !           494:            if( i != 0 ) {
        !           495:                TopRow = i - 1;           /* if first line to be deleted is   */
        !           496:                CurRow = 1;               /* off the top of the screen, then  */
        !           497:                }                         /* set TopRow to last unmarked line */
        !           498:            else {
        !           499:                TopRow = 0;                /* or if there are no unmarked     */
        !           500:                CurRow = 0;                /* lines ahead of the marked ones, */
        !           501:                }                          /* set TopRow to start of the file */
        !           502:            }
        !           503:        else CurRow = i - TopRow;
        !           504:        for( ; MarkedLine[i]; i++ )                /* delete all marked lines */
        !           505:            deleteline( i );               /* i refers to first unmarked line */
        !           506:        for( ; i < TotalLines; i++,j++ )                /* adjust LineTable[] */
        !           507:            LineTable[j] = LineTable[i];
        !           508:        TotalLines -= ( i - j );                         /* adjust TotalLines */
        !           509:        LinesMarked = 0;
        !           510:        for( i = 0; i < MAXLINES; i++ )           /* clear line marking flags */
        !           511:            MarkedLine[i] = 0;
        !           512:        drawscr(TopRow);                                     /* redraw screen */
        !           513:        VIOSETCURPOS(CurRow, CurCol, 0);
        !           514:        getline( (TopRow + CurRow), &EditBuff[0] );      /* reload EditBuff[] */
        !           515:        }
        !           516: 
        !           517:     else if (CharsMarked) {   /* if no lines marked but chars marked, do this */
        !           518:        for( i = 0; !MarkedChar[i] & ( i < LINESIZE ); i++ );
        !           519:        j = i;                        /* i, j refer to first marked character */
        !           520:        CurCol = j;
        !           521:        VIOSETCURPOS(CurRow, CurCol, 0);            /* adjust cursor position */
        !           522:        for( ; MarkedChar[i] & (i < LINESIZE); i++ ); /* i now first unmarked */
        !           523:        for( ; i < LINESIZE; i++, j++ )
        !           524:            EditBuff[j] = EditBuff[i];   /* remove characters between i and j */
        !           525:        for( ; j < LINESIZE; j++ )
        !           526:            EditBuff[j] = ' ';                /* fill end of line with blanks */
        !           527:        CharsMarked = 0;
        !           528:        for( i = 0; i < LINESIZE; i++ )  /* clear all character marking flags */
        !           529:            MarkedChar[i] = 0;
        !           530:        drawline();                                            /* redraw line */
        !           531:        EditBuffDirty = 1;                        /* mark EditBuff[] as dirty */
        !           532:        }
        !           533: 
        !           534:     else {                           /* if no lines or chars marked, do this */
        !           535:        for( i = (CurCol + 1); i < LINESIZE; i++ )
        !           536:           EditBuff[i-1] = EditBuff[i];      /* remove character under cursor */
        !           537:        EditBuff[LINESIZE-1] = ' ';            /* fill end of line with blank */
        !           538:        drawline();                                            /* redraw line */
        !           539:        EditBuffDirty = 1;                        /* mark EditBuff[] as dirty */
        !           540:        }
        !           541: 
        !           542:     line25();          /* reset line numbers on 25th line to reflect changes */
        !           543: 
        !           544:     }
        !           545: 
        !           546: 
        !           547: /*** F9() - saves the file being edited and exits
        !           548:  *
        !           549:  *   F9() save the file being edited with any changes that have been made
        !           550:  *   and exits the editor. The user is given a prompt to be sure they want
        !           551:  *   do quit; hitting carriage return goes ahead with the save-and-quit,
        !           552:  *   while any other key returns you to the editor.
        !           553:  *
        !           554:  *   EFFECTS:    If quit not completed:    EditBuff[]    -  gets flushed
        !           555:  *                                         EditBuffDirty -  gets cleared
        !           556:  */
        !           557: 
        !           558: void F9()
        !           559:     {
        !           560: 
        !           561:     static char message[LINESIZE] = "Save file as:";
        !           562:     struct  KeyData keydata;
        !           563:     char attrib = Fore25 + Back25;
        !           564:     int i;
        !           565: 
        !           566:     if (EditBuffDirty) {                  /* flush the edit buffer if dirty */
        !           567:        EditBuffDirty = 0;                 /* so all editting will be saved  */
        !           568:        flushline((TopRow + CurRow), EditBuff);
        !           569:        }
        !           570: 
        !           571:     for( i = 0; (i < 65) && (fname[i] != 0); message[i + 14] = fname[i], i++ );
        !           572:                                        /* copy filename into prompt message */
        !           573: 
        !           574:     VIOWRTCHARSTRATT( message, 80, PageSize, 0, &attrib, 0 );
        !           575:                                                        /* write out message */
        !           576: 
        !           577:     KBDCHARIN( &keydata, 0, 0 );                  /* wait for user response */
        !           578: 
        !           579:     if( keydata.char_code == CRETURN_CHAR ) {    /* if response was <CR>... */
        !           580:        if ( !savefile(fhandle)) {
        !           581:            freesegs();
        !           582:            VIOSETCURPOS( 24, 0, 0 );               /* ... clean up and quit */
        !           583:            quit(0);
        !           584:            }
        !           585:        else error25(11);
        !           586:        }
        !           587:     name25();                           /* ... otherwise restore message on */
        !           588:                                         /* 25th line and return to editor   */
        !           589:     }
        !           590: 
        !           591: 
        !           592: /*** F10() - exits the editor without saving the file being edited
        !           593:  *
        !           594:  *   F10() exits from the editor without saving back the file being edited,
        !           595:  *   leaving the file as it was before the editor was invoked. A prompt
        !           596:  *   will be issued to give the user a chance to change their mind before
        !           597:  *   all editing is lost.
        !           598:  *
        !           599:  *   EFFECTS:    If quit not completed:    EditBuff[]    -  gets flushed
        !           600:  *                                         EditBuffDirty -  gets cleared
        !           601:  */
        !           602: 
        !           603: 
        !           604: void F10()
        !           605:     {
        !           606:     static char message[51] = "WARNING: Any edits will be lost   (y/n)?           ";
        !           607:     struct  KeyData keydata;
        !           608:     char attrib = Fore25 + Back25;                /* attributes for message */
        !           609:     int  row, col;                       /* to save current cursor position */
        !           610:     int  done = 0;             /* flag to be set when have a valid response */
        !           611: 
        !           612:     if (EditBuffDirty) {                       /* flush EditBuff[] if dirty */
        !           613:        EditBuffDirty = 0;
        !           614:        flushline((TopRow + CurRow), EditBuff);
        !           615:        }
        !           616: 
        !           617:     VIOWRTCHARSTRATT( message, 51, PageSize, 0, &attrib, 0 );
        !           618:     VIOGETCURPOS( &row, &col, 0 );                 /* print prompt and set  */
        !           619:     VIOSETCURPOS( PageSize, 42, 0 );               /* cursor to await reply */
        !           620: 
        !           621:     while( !done ) {
        !           622: 
        !           623:        KBDCHARIN( &keydata, 0, 0 );             /* get a character from KBD */
        !           624: 
        !           625:        if( (keydata.char_code == 'y') || (keydata.char_code == 'Y') ) {
        !           626:            VIOWRTCHARSTRATT( &keydata.char_code, 1, PageSize, 42, &attrib, 0 );
        !           627:            freesegs();
        !           628:            quit(0);                            /* if Y, quit without saving */
        !           629:            }
        !           630:        else if( (keydata.char_code == 'n') || (keydata.char_code == 'N') ) {
        !           631:            VIOSETCURPOS( row, col, 0 );
        !           632:            name25();
        !           633:            done = 1;                              /* if N, return to editor */
        !           634:            }
        !           635:        else badkey();                     /* otherwise wait for another key */
        !           636: 
        !           637:        }
        !           638: 
        !           639:     }
        !           640: 
        !           641: 
        !           642: /*** ctrl_home() - repositions cursor to upper left hand corner of screen
        !           643:  *
        !           644:  *   ctrl_home() moves the cursor to the upper left hand corner of the
        !           645:  *   screen, coordinate position (0,0). Since the current cursor line is
        !           646:  *   probably changed, we flush and reload EditBuff[]. If there is any
        !           647:  *   text marked, this call will clear the marking without deleting.
        !           648:  *   Line number information on 25th line is redrawn to reflect changes.
        !           649:  *   The actual content of the screen - i.e. the value of TopRow - is
        !           650:  *   unchanged by this call.
        !           651:  *
        !           652:  *   EFFECTS:    EditBuff[]     - flushes and reloads
        !           653:  *               EditBuffDirty  - clears this flag
        !           654:  *               LinesMarked    - clears this flag
        !           655:  *               MarkedLine[]   - clears all
        !           656:  *               CharsMarked    - clears this flag
        !           657:  *               MarkedChar[]   - clears all
        !           658:  *               CurRow         - set to 0
        !           659:  *               CurCol         - set to 0
        !           660:  */
        !           661: 
        !           662: void ctrl_home()
        !           663:     {
        !           664: 
        !           665:     register short i;                                /* indexing variable */
        !           666: 
        !           667:     if (EditBuffDirty) {                         /* this call will change */
        !           668:        EditBuffDirty = 0;                        /* cursor line, so flush */
        !           669:        flushline((TopRow + CurRow), EditBuff);   /* edit buffer if dirty  */
        !           670:        }
        !           671: 
        !           672:     if ( LinesMarked || CharsMarked ) {
        !           673:        LinesMarked = 0;                         /* if there's marked text */
        !           674:        CharsMarked = 0;                         /* around, clear it and   */
        !           675:        for ( i = 0; i < MAXLINES; i++ )         /* redraw the screen      */
        !           676:            MarkedLine[i] = 0;
        !           677:        for ( i = 0; i < LINESIZE; i++ )
        !           678:            MarkedChar[i] = 0;
        !           679:        drawscr(TopRow);
        !           680:        }
        !           681: 
        !           682:     if ( CurRow != 0  ||  CurCol != 0 ) {
        !           683:        CurRow = 0;                                 /* reposition to (0,0) */
        !           684:        CurCol = 0;
        !           685:        VIOSETCURPOS( CurRow, CurCol, 0 );
        !           686:        getline( (TopRow + CurRow), &EditBuff[0] );
        !           687:        }
        !           688: 
        !           689:     line25();      /* update line numbers on 25th line to reflect changes */
        !           690: 
        !           691:     }
        !           692: 
        !           693: 
        !           694: /*** ctrl_end() - repositions cursor to lower left hand corner of screen
        !           695:  *
        !           696:  *   ctrl_end() moves the cursor to the lower left hand corner of the
        !           697:  *   screen. Since the current cursor line is probably changed, we flush
        !           698:  *   and reload EditBuff[]. If there is any text marked, this call will
        !           699:  *   clear the marking without deleting. Line number information on 25th
        !           700:  *   line is redrawn to reflect changes. The actual content of the screen
        !           701:  *   is unchanged by this call.
        !           702:  *
        !           703:  *   EFFECTS:    EditBuff[]     - flushes and reloads
        !           704:  *               EditBuffDirty  - clears this flag
        !           705:  *               LinesMarked    - clears this flag
        !           706:  *               MarkedLine[]   - clears all
        !           707:  *               CharsMarked    - clears this flag
        !           708:  *               MarkedChar[]   - clears all
        !           709:  *               CurRow         - set to PAGESIZE - 1
        !           710:  *               CurCol         - set to 0
        !           711:  */
        !           712: 
        !           713: void ctrl_end()
        !           714:     {
        !           715: 
        !           716:     register short i;
        !           717: 
        !           718:     if (EditBuffDirty) {                         /* this call will change */
        !           719:        EditBuffDirty = 0;                        /* cursor line, so flush */
        !           720:        flushline((TopRow + CurRow), EditBuff);   /* edit buffer if dirty  */
        !           721:        }
        !           722: 
        !           723:     if ( LinesMarked || CharsMarked ) {
        !           724:        LinesMarked = 0;                         /* if there's marked text */
        !           725:        CharsMarked = 0;                         /* around, clear it and   */
        !           726:        for ( i = 0; i < MAXLINES; i++ )         /* redraw the screen      */
        !           727:            MarkedLine[i] = 0;
        !           728:        for ( i = 0; i < LINESIZE; i++ )
        !           729:            MarkedChar[i] = 0;
        !           730:        drawscr(TopRow);
        !           731:        }
        !           732: 
        !           733:     if( CurRow != (PageSize - 1) || CurCol != 0 ) {
        !           734:        CurRow = (PageSize - 1);                      /* reposition cursor */
        !           735:        CurCol = 0;
        !           736:        VIOSETCURPOS( CurRow, CurCol, 0 );
        !           737:        getline( (TopRow + CurRow), &EditBuff[0] );
        !           738:        }
        !           739: 
        !           740:     line25();      /* update line numbers on 25th line to reflect changes */
        !           741: 
        !           742:     }
        !           743: 
        !           744: 
        !           745: /*** ctrl_pgup() - repositions cursor to beginning of file
        !           746:  *
        !           747:  *   ctrl_pgup() redraws the screen with the first screenfull of the file
        !           748:  *   and moves the cursor to the upper left hand corner of the screen,
        !           749:  *   coordinate position (0,0). Since the current cursor line is
        !           750:  *   probably changed, we flush and reload EditBuff[]. If there is any
        !           751:  *   text marked, this call will clear the marking without deleting.
        !           752:  *   Line number information on 25th line is redrawn to reflect changes.
        !           753:  *
        !           754:  *   EFFECTS:    EditBuff[]     - flushes and reloads
        !           755:  *               EditBuffDirty  - clears this flag
        !           756:  *               LinesMarked    - clears this flag
        !           757:  *               MarkedLine[]   - clears all
        !           758:  *               CharsMarked    - clears this flag
        !           759:  *               MarkedChar[]   - clears all
        !           760:  *               TopRow         - set to 0
        !           761:  *               CurRow         - set to 0
        !           762:  *               CurCol         - set to 0
        !           763:  */
        !           764: 
        !           765: void ctrl_pgup()
        !           766:     {
        !           767: 
        !           768:     register short i;                                /* indexing variable */
        !           769: 
        !           770:     if (EditBuffDirty) {                         /* this call will change */
        !           771:        EditBuffDirty = 0;                        /* cursor line, so flush */
        !           772:        flushline((TopRow + CurRow), EditBuff);   /* edit buffer if dirty  */
        !           773:        }
        !           774: 
        !           775:     if ( LinesMarked || CharsMarked ) {
        !           776:        LinesMarked = 0;                         /* if there's marked text */
        !           777:        CharsMarked = 0;                         /* around, clear it - no  */
        !           778:        for ( i = 0; i < MAXLINES; i++ )         /* need to redraw screen  */
        !           779:            MarkedLine[i] = 0;
        !           780:        for ( i = 0; i < LINESIZE; i++ )
        !           781:            MarkedChar[i] = 0;
        !           782:        }
        !           783: 
        !           784:     TopRow = 0;
        !           785:     CurRow = 0;                                  /* reposition and redraw */
        !           786:     CurCol = 0;
        !           787:     VIOSETCURPOS( CurRow, CurCol, 0 );
        !           788:     drawscr(TopRow);
        !           789:     getline( (TopRow + CurRow), &EditBuff[0] );       /* reload EditBuff[] */
        !           790:     line25();                                         /* update 25th line */
        !           791: 
        !           792:     }
        !           793: 
        !           794: 
        !           795: /*** ctrl_pgdn() - repositions cursor to beginning of file
        !           796:  *
        !           797:  *   ctrl_pgdn() redraws the screen with the last screenfull of the file
        !           798:  *   and moves the cursor to the lower left hand corner of the screen,
        !           799:  *   one line past the end of the file. Since the current cursor line is
        !           800:  *   probably changed, we flush and reload EditBuff[]. If there is any
        !           801:  *   text marked, this call will clear the marking without deleting.
        !           802:  *   Line number information on 25th line is redrawn to reflect changes.
        !           803:  *
        !           804:  *   EFFECTS:    EditBuff[]     - flushes and reloads
        !           805:  *               EditBuffDirty  - clears this flag
        !           806:  *               LinesMarked    - clears this flag
        !           807:  *               MarkedLine[]   - clears all
        !           808:  *               CharsMarked    - clears this flag
        !           809:  *               MarkedChar[]   - clears all
        !           810:  *               TopRow         - set to TotalLines - (PageSize - 1)
        !           811:  *               CurRow         - set to end of file + 1
        !           812:  *               CurCol         - set to 0
        !           813:  */
        !           814: 
        !           815: void ctrl_pgdn()
        !           816:     {
        !           817:     register short i;                                /* indexing variable */
        !           818: 
        !           819:     if (EditBuffDirty) {                         /* this call will change */
        !           820:        EditBuffDirty = 0;                        /* cursor line, so flush */
        !           821:        flushline((TopRow + CurRow), EditBuff);   /* edit buffer if dirty  */
        !           822:        }
        !           823: 
        !           824:     if ( LinesMarked || CharsMarked ) {
        !           825:        LinesMarked = 0;                         /* if there's marked text */
        !           826:        CharsMarked = 0;                         /* around, clear it - no  */
        !           827:        for ( i = 0; i < MAXLINES; i++ )         /* need to redraw screen  */
        !           828:            MarkedLine[i] = 0;                   /* as it gets done later  */
        !           829:        for ( i = 0; i < LINESIZE; i++ )
        !           830:            MarkedChar[i] = 0;
        !           831:        }
        !           832:     if (TotalLines > (PageSize - 1))
        !           833:        TopRow = TotalLines - (PageSize - 1);        /* recalculate TopRow */
        !           834:     else TopRow = 0;
        !           835:     CurRow = TotalLines - TopRow;            /* set cursor row and column */
        !           836:     CurCol = 0;
        !           837:     VIOSETCURPOS( CurRow, CurCol, 0 );
        !           838:     getline( (TopRow + CurRow), &EditBuff[0] );       /* reload EditBuff[] */
        !           839:     drawscr(TopRow);                                     /* redraw screen */
        !           840:     line25();                                         /* update 25th line */
        !           841: 
        !           842:     }
        !           843: 
        !           844: 
        !           845: /*** shift_left() - moves cursor left one and marks that character for deletion.
        !           846:  *
        !           847:  *   shift_left() moves the cursor one position to the left. If we are on
        !           848:  *   a line that is already marked, that's all it does - just like regular
        !           849:  *   left, but markings are not cleared. If we are not on a marked line,
        !           850:  *   then the character we just moved to is marked for deletion. Unless it
        !           851:  *   already was marked for deletion, in which case it gets un-marked.
        !           852:  *
        !           853:  *   EFFECTS:    CharsMarked    - sets this flag if LinesMarked not set
        !           854:  *               MarkedChar[]   - sets this for the character we just moved to
        !           855:  *               CurCol         - decremented one
        !           856:  */
        !           857: 
        !           858: void shift_left()
        !           859:     {
        !           860: 
        !           861:     if ( LinesMarked ) {          /* if this line is marked, just move left */
        !           862:        if ( CurCol > 0 ) {
        !           863:            CurCol -= 1;
        !           864:            VIOSETCURPOS( CurRow, CurCol, 0 );
        !           865:            }
        !           866:        }
        !           867:     else if( CurCol > 0 ) {            /* otherwise, see if there's room... */
        !           868:        CurCol -= 1;
        !           869:        VIOSETCURPOS( CurRow, CurCol, 0 );             /* ...if so move left */
        !           870:        CharsMarked = 1;
        !           871:        if (MarkedChar[CurCol])
        !           872:            MarkedChar[CurCol] = 0;    /* and set marking for that character */
        !           873:        else MarkedChar[CurCol] = 1;
        !           874:        drawline();                        /* redraw line to update markings */
        !           875:        }
        !           876: 
        !           877:     }
        !           878: 
        !           879: 
        !           880: /*** shift_right() - moves cursor right one and marks the character
        !           881:  *                  we were previously on for deletion.
        !           882:  *
        !           883:  *   shift_right() moves the cursor one position to the right. If we are on
        !           884:  *   a line that is already marked, that's all it does - just like regular
        !           885:  *   right, but markings are not cleared. If we are not on a marked line,
        !           886:  *   then the character we just moved from is marked for deletion. Unless it
        !           887:  *   already was marked for deletion, in which case it gets un-marked.
        !           888:  *
        !           889:  *   EFFECTS:    CharsMarked    - sets this flag if LinesMarked not set
        !           890:  *               MarkedChar[]   - sets this for the character we just left
        !           891:  *               CurCol         - incremented one
        !           892:  */
        !           893: 
        !           894: void shift_right()
        !           895:     {
        !           896: 
        !           897:     if ( LinesMarked ) {            /* if this line marked, just move right */
        !           898:        if (CurCol < (LINESIZE - 1)) {
        !           899:            CurCol += 1;
        !           900:            VIOSETCURPOS( CurRow, CurCol, 0 );
        !           901:            }
        !           902:        }
        !           903:     else if( CurCol < (LINESIZE - 1)) {  /* otherwise, see if there's room.. */
        !           904:        CharsMarked = 1;
        !           905:        if (MarkedChar[CurCol])            /* if so, mark character we're on */
        !           906:            MarkedChar[CurCol] = 0;
        !           907:        else MarkedChar[CurCol] = 1;
        !           908:        CurCol += 1;                                  /* then move right one */
        !           909:        VIOSETCURPOS( CurRow, CurCol, 0 );
        !           910:        drawline();                                       /* and redraw line */
        !           911:        }
        !           912: 
        !           913:     }
        !           914: 
        !           915: 
        !           916: /*** shift_up() - moves cursor up one line and marks lines for deletion
        !           917:  *
        !           918:  *   shift_up() moves the cursor one line up. If no lines are marked, then
        !           919:  *   both the previous line and the line moved to get marked for deletion.
        !           920:  *   If lines are already marked, and were marked starting with another
        !           921:  *   shift_up, then only the line we move to gets marked (the one we just
        !           922:  *   left would already be marked). If there are lines marked but they
        !           923:  *   were marked starting with a shift_down, then we un-mark the line we
        !           924:  *   just left and do nothing to the line moved to. Unless the line moved
        !           925:  *   to is the last one marked, in which case we un-mark it also to clear all
        !           926:  *   markings. To determine how lines first got marked - by a shift_up or
        !           927:  *   shift_down - we give the flag LinesMarked two different TRUE values,
        !           928:  *   1 or 2 respectively.
        !           929:  *
        !           930:  *   EFFECTS:    EditBuff[]     - flushes and reloads
        !           931:  *               EditBuffDirty  - clears
        !           932:  *               LinesMarked    - sets this flag, unless un-marking only
        !           933:  *                                marked line present, in which case clears it
        !           934:  *               MarkedLine[]   - may set or clear this
        !           935:  *               CharsMarked    - clears this flag as we now have marked lines
        !           936:  *               MarkedChar[]   - clears all
        !           937:  *               TopRow         - decremented one if at top of page
        !           938:  *               CurRow         - decremented one if not at top of page
        !           939:  */
        !           940: 
        !           941: void shift_up()
        !           942:     {
        !           943:     register short i;                                /* indexing variable */
        !           944: 
        !           945:     char buff[2];            /* local buffer for scrolling fill character */
        !           946:     buff[0] = 32;                             /* character = 32 = <blank> */
        !           947:     buff[1] = ForeHilite + BackHilite;        /*  attribute = highlighted */
        !           948: 
        !           949:     if (EditBuffDirty) {                         /* this call will change */
        !           950:        EditBuffDirty = 0;                        /* cursor line, so flush */
        !           951:        flushline((TopRow + CurRow), EditBuff);   /* edit buffer if dirty  */
        !           952:        }
        !           953: 
        !           954:     if ( CharsMarked ) {                       /* clear CharsMarked flags */
        !           955:        CharsMarked = 0;                        /* since we now will have  */
        !           956:        for ( i = 0; i < LINESIZE; i++ )        /* the whole line marked.  */
        !           957:            MarkedChar[i] = 0;
        !           958:        }
        !           959: 
        !           960:   /* if no lines currently marked, do this */
        !           961:     if( !LinesMarked ) {
        !           962:        LinesMarked = 1;        /* set flag to indicate marking started UP */
        !           963:        MarkedLine[ TopRow + CurRow ] = 1;                    /* mark line */
        !           964:        drawline();                                           /* redraw it */
        !           965:        if ( (TopRow + CurRow) != 0 ) {                /* if there's room, */
        !           966:            MarkedLine[ TopRow + CurRow - 1 ] = 1;      /* mark line above */
        !           967:            if ( CurRow == 0 ) {
        !           968:                TopRow -= 1;                      /* ...may have to scroll */
        !           969:                VIOSCROLLDN( 0, 0, (PageSize - 1), (LINESIZE - 1), 1,
        !           970:                           (char far *)buff, 0);
        !           971:                getline( (TopRow + CurRow), &EditBuff[0] );      /* reload */
        !           972:                }
        !           973:            else {                         /* ...or may not have to scroll */
        !           974:                CurRow -= 1;
        !           975:                getline( (TopRow + CurRow), &EditBuff[0] );      /* reload */
        !           976:                VIOSETCURPOS( CurRow, CurCol, 0 );
        !           977:                }
        !           978:            drawline();                                 /* redraw new line */
        !           979:            }
        !           980:        }
        !           981: 
        !           982:   /* if lines marked, and shift_up started marking, do this */
        !           983:     else if( LinesMarked == 1 ) {
        !           984:        if ( (TopRow + CurRow) != 0 ) {        /* if not at top of screen, */
        !           985:            MarkedLine[ TopRow + CurRow - 1 ] = 1;    /* mark next line up */
        !           986:            if ( CurRow == 0 ) {
        !           987:                TopRow -= 1;                      /* ...may have to scroll */
        !           988:                VIOSCROLLDN( 0, 0, (PageSize - 1), (LINESIZE - 1), 1,
        !           989:                           (char far *)buff, 0);
        !           990:                getline( (TopRow + CurRow), &EditBuff[0] );      /* reload */
        !           991:                }
        !           992:            else {
        !           993:                CurRow -= 1;               /* ...or may not have to scroll */
        !           994:                getline( (TopRow + CurRow), &EditBuff[0] );      /* reload */
        !           995:                VIOSETCURPOS( CurRow, CurCol, 0 );
        !           996:                }
        !           997:            drawline();                             /* redraw line move to */
        !           998:            }
        !           999:        }
        !          1000: 
        !          1001:   /* if lines marked, and shift_down started marking, do this */
        !          1002:     else if( LinesMarked == 2 ) {
        !          1003:        MarkedLine[ TopRow + CurRow ] = 0;         /* un-mark current line */
        !          1004:        drawline();                                           /* redraw it */
        !          1005:        if( (TopRow + CurRow) != 0 ) {
        !          1006:            if( CurRow == 0 ) {              /* ...may have to scroll down */
        !          1007:                TopRow -= 1;
        !          1008:                VIOSCROLLDN( 0, 0, (PageSize - 1), (LINESIZE - 1), 1,
        !          1009:                           (char far *)buff, 0);
        !          1010:                getline( (TopRow + CurRow), &EditBuff[0] );      /* reload */
        !          1011:                }
        !          1012:            else {                       /* or may not have to scroll down */
        !          1013:                CurRow -= 1;
        !          1014:                getline( (TopRow + CurRow), &EditBuff[0] );      /* reload */
        !          1015:                VIOSETCURPOS( CurRow, CurCol, 0 );
        !          1016:                }
        !          1017:            if( !MarkedLine[ TopRow + CurRow - 1 ] ) { /* if line moved to */
        !          1018:                MarkedLine[ TopRow + CurRow ] = 0;     /* is last marked,  */
        !          1019:                LinesMarked = 0;                       /* clear it too     */
        !          1020:                drawline();
        !          1021:                }
        !          1022:            }
        !          1023:        }
        !          1024: 
        !          1025:     line25();      /* update line numbers on 25th line to reflect changes */
        !          1026: 
        !          1027:     }
        !          1028: 
        !          1029: 
        !          1030: /*** shift_down() - moves cursor down one line and marks lines for deletion
        !          1031:  *
        !          1032:  *   shift_down() moves the cursor one line down. If no lines are marked, then
        !          1033:  *   both the previous line and the line moved to get marked for deletion.
        !          1034:  *   If lines are already marked, and were marked starting with another
        !          1035:  *   shift_down, then only the line we move to gets marked (the one we just
        !          1036:  *   left would already be marked). If there are lines marked but they
        !          1037:  *   were marked starting with a shift_up, then we un-mark the line we
        !          1038:  *   just left and do nothing to the line moved to. Unless the line moved
        !          1039:  *   to is the last one marked, in which case we un-mark it also to clear all
        !          1040:  *   markings. To determine how lines first got marked - by a shift_up or
        !          1041:  *   shift_down - we give the flag LinesMarked two different TRUE values,
        !          1042:  *   1 or 2 respectively.
        !          1043:  *
        !          1044:  *   EFFECTS:    EditBuff[]     - flushes and reloads
        !          1045:  *               EditBuffDirty  - clears
        !          1046:  *               LinesMarked    - sets this flag, unless un-marking only
        !          1047:  *                                marked line present, in which case clears it
        !          1048:  *               MarkedLine[]   - may set or clear this
        !          1049:  *               CharsMarked    - clears this flag as we now have marked lines
        !          1050:  *               MarkedChar[]   - clears all
        !          1051:  *               TopRow         - incremented one if at bottom of page
        !          1052:  *               CurRow         - incremented one if not at bottom of page
        !          1053:  */
        !          1054: 
        !          1055: void shift_down()
        !          1056:     {
        !          1057:     register short i;                                  /* indexing variable */
        !          1058: 
        !          1059:     char buff[2];                        /* local buffer for fill character */
        !          1060:     buff[0] = 32;                               /* character = 32 = <blank> */
        !          1061:     buff[1] = ForeHilite + BackHilite;          /* attribute =  highlighted */
        !          1062: 
        !          1063:     if (EditBuffDirty) {                           /* this call will change */
        !          1064:        EditBuffDirty = 0;                          /* cursor line, so flush */
        !          1065:        flushline((TopRow + CurRow), EditBuff);     /* edit buffer if dirty  */
        !          1066:        }
        !          1067: 
        !          1068:     if ( CharsMarked ) {                            /* clear all character  */
        !          1069:        CharsMarked = 0;                             /* markings, since line */
        !          1070:        for ( i = 0; i < LINESIZE; i++ )             /* is now marked.       */
        !          1071:            MarkedChar[i] = 0;
        !          1072:        }
        !          1073: 
        !          1074:   /* if no lines are currently marked, do this */
        !          1075:     if( !LinesMarked ) {
        !          1076:        LinesMarked = 2;       /* set flag to show marking started with DOWN */
        !          1077:        MarkedLine[ TopRow + CurRow ] = 1;              /* mark current line */
        !          1078:        drawline();                                         /* and redraw it */
        !          1079:        if( ( TopRow + CurRow ) < TotalLines ) {    /* if room to move down, */
        !          1080:            MarkedLine[ TopRow + CurRow + 1 ] = 1;        /* mark line below */
        !          1081:            if ( CurRow == (PageSize - 1) ) {
        !          1082:                TopRow += 1;                        /* ...may have to scroll */
        !          1083:                VIOSCROLLUP( 0, 0, CurRow, (LINESIZE - 1), 1,
        !          1084:                           (char far *)buff, 0);
        !          1085:                getline( (TopRow + CurRow), &EditBuff[0] );        /* reload */
        !          1086:                }
        !          1087:            else {                           /* ...or may not have to scroll */
        !          1088:                CurRow += 1;
        !          1089:                getline( (TopRow + CurRow), &EditBuff[0] );        /* reload */
        !          1090:                VIOSETCURPOS( CurRow, CurCol, 0 );
        !          1091:                }
        !          1092:            drawline();                                   /* redraw new line */
        !          1093:            }
        !          1094:        }
        !          1095: 
        !          1096:   /* if lines are marked, and first marking was another shift_down, do this */
        !          1097:     else if( LinesMarked == 2 ) {
        !          1098:        if ( (TopRow + CurRow) < TotalLines ) {     /* if room to move down */
        !          1099:            MarkedLine[ TopRow + CurRow + 1 ] = 1;       /* mark line below */
        !          1100:            if ( CurRow == (PageSize - 1) ) {
        !          1101:                TopRow += 1;                       /* ...may have to scroll */
        !          1102:                VIOSCROLLUP( 0, 0, CurRow, (LINESIZE - 1), 1,
        !          1103:                           (char far *)buff, 0);
        !          1104:                getline( (TopRow + CurRow), &EditBuff[0] );       /* reload */
        !          1105:                }
        !          1106:            else {                          /* ...or may not have to scroll */
        !          1107:                CurRow += 1;
        !          1108:                getline( (TopRow + CurRow), &EditBuff[0] );       /* reload */
        !          1109:                VIOSETCURPOS( CurRow, CurCol, 0 );
        !          1110:                }
        !          1111:            drawline();         /* redraw the current line to show markings */
        !          1112:            }
        !          1113:        }
        !          1114: 
        !          1115:   /* if lines are marked, and first marking was a shift_up, do this */
        !          1116:     else if( LinesMarked == 1 ) {
        !          1117:        MarkedLine[ TopRow + CurRow ] = 0;          /* un-mark current line */
        !          1118:        drawline();                                        /* and redraw it */
        !          1119:        if ( (TopRow + CurRow) < TotalLines ) {
        !          1120:            if ( CurRow == (PageSize - 1) ) {
        !          1121:                TopRow += 1;                       /* ...may have to scroll */
        !          1122:                VIOSCROLLUP( 0, 0, CurRow, (LINESIZE - 1), 1,
        !          1123:                           (char far *)buff, 0);
        !          1124:                getline( (TopRow + CurRow), &EditBuff[0] );       /* reload */
        !          1125:                }
        !          1126:            else {                          /* ...or may not have to scroll */
        !          1127:                CurRow += 1;
        !          1128:                getline( (TopRow + CurRow), &EditBuff[0] );       /* reload */
        !          1129:                VIOSETCURPOS( CurRow, CurCol, 0 );
        !          1130:                }
        !          1131:            }
        !          1132:        if( (TopRow + CurRow) < TotalLines ) {
        !          1133:            if( !MarkedLine[ TopRow + CurRow + 1 ] ) {
        !          1134:                MarkedLine[ TopRow + CurRow ] = 0;
        !          1135:                LinesMarked = 0;                     /* if only 1 line left */
        !          1136:                }                                 /* marked, un-mark it too */
        !          1137:            }
        !          1138:        drawline();                      /* redraw line to reflect markings */
        !          1139: 
        !          1140:        }
        !          1141: 
        !          1142:     line25();           /* update line info on bottom line to show changes */
        !          1143: 
        !          1144:     }
        !          1145: 
        !          1146: 
        !          1147: /*** shift_home() - moves cursor to first character in current line and
        !          1148:  *                 marks all characters in between for deletion
        !          1149:  *
        !          1150:  *   shift_down() moves the cursor to the first printable character in the
        !          1151:  *   current line. If the line is already marked, that's all it does, just
        !          1152:  *   like a regular home except markings are not cleared. Otherwise, all
        !          1153:  *   characters between the cursor position when the function is called and
        !          1154:  *   the first character in the line get their markings toggled - that is, if
        !          1155:  *   they are not marked they get marked, if they are already marked they
        !          1156:  *   get un-marked.
        !          1157:  *
        !          1158:  *   EFFECTS:    EditBuff[]     - flushes and reloads
        !          1159:  *               EditBuffDirty  - clears
        !          1160:  *               CharsMarked    - sets this flag unless line is marked
        !          1161:  *               MarkedChar[]   - sets for all appropriate characters
        !          1162:  *               CurCol         - set to position of first printable character
        !          1163:  */
        !          1164: 
        !          1165: void shift_home()
        !          1166:     {
        !          1167: 
        !          1168:     register short i, j;                              /* indexing variables */
        !          1169: 
        !          1170:     if (EditBuffDirty) {                          /* this call will need to */
        !          1171:        EditBuffDirty = 0;                         /* get correct info on    */
        !          1172:        flushline((TopRow + CurRow), EditBuff);    /* line length, so flush  */
        !          1173:        }                                          /* edit buffer if dirty   */
        !          1174: 
        !          1175:     if( (TopRow + CurRow) < TotalLines ) {
        !          1176:        i = LineTable[TopRow + CurRow]->linelength;     /* i is position + 1 */
        !          1177:        }                                               /* last char in line */
        !          1178:     else i = 0;
        !          1179: 
        !          1180:     for( j = 0; ( j < i )  &&  !isgraph(EditBuff[j]); j++ );
        !          1181:                                                         /* j is position of */
        !          1182:                                                         /* first non-blank  */
        !          1183:     if( !LinesMarked ) {                         /* if no lines marked,     */
        !          1184:        if( j < CurCol ) {                        /* flag everything between */
        !          1185:            CharsMarked = 1;                      /* CurCol and j as Marked  */
        !          1186:            for( i = j; i < CurCol; i++ ) {
        !          1187:                if( !MarkedChar[i] )
        !          1188:                    MarkedChar[i] = 1;           /* may be moving forward... */
        !          1189:                else MarkedChar[i] = 0;
        !          1190:                }
        !          1191:            }
        !          1192:        else if( j > CurCol ) {
        !          1193:            CharsMarked = 1;
        !          1194:            for( i = CurCol; i < j; i++ ) {               /* ... or backward */
        !          1195:                if( !MarkedChar[i] )
        !          1196:                    MarkedChar[i] = 1;
        !          1197:                else MarkedChar[i] = 0;
        !          1198:                }
        !          1199:            }
        !          1200:        }
        !          1201: 
        !          1202:     CurCol = j;                           /* if lines are marked, just move */
        !          1203:     VIOSETCURPOS( CurRow, CurCol, 0 );
        !          1204:     drawline();                             /* redraw line to show markings */
        !          1205: 
        !          1206:     }
        !          1207: 
        !          1208: 
        !          1209: /*** shift_end() - moves cursor to one beyond last character in current line
        !          1210:  *                and marks all characters in between for deletion
        !          1211:  *
        !          1212:  *   shift_down() moves the cursor to one position beyond the last printable
        !          1213:  *   character in the current line. If the line is already marked, that's all
        !          1214:  *   it does, just like a regular end_ except markings are not cleared.
        !          1215:  *   Otherwise, all characters between the cursor position when the function
        !          1216:  *   is called and the final cursor position get their markings toggled - that
        !          1217:  *   is, if they are not marked they get marked, if they are already marked
        !          1218:  *   they get un-marked.
        !          1219:  *
        !          1220:  *   EFFECTS:    EditBuff[]     - flushes and reloads
        !          1221:  *               EditBuffDirty  - clears
        !          1222:  *               CharsMarked    - sets this flag unless line is marked
        !          1223:  *               MarkedChar[]   - sets for all appropriate characters
        !          1224:  *               CurCol         - set to one beyond position of
        !          1225:  *                                last printable character
        !          1226:  */
        !          1227: 
        !          1228: void shift_end()
        !          1229:     {
        !          1230: 
        !          1231:     register short i, j;                             /* indexing variables */
        !          1232: 
        !          1233:     if (EditBuffDirty) {                         /* this call will need to */
        !          1234:        EditBuffDirty = 0;                        /* get correct info on    */
        !          1235:        flushline((TopRow + CurRow), EditBuff);   /* line length, so flush  */
        !          1236:        }                                         /* edit buffer if dirty   */
        !          1237: 
        !          1238:     if( (TopRow + CurRow) < TotalLines ) {
        !          1239:        i = LineTable[TopRow + CurRow]->linelength;    /* i is position + 1 */
        !          1240:        }                                              /* last char in line */
        !          1241:     else i = 0;
        !          1242: 
        !          1243:     if( !LinesMarked ) {                        /* if no lines marked,     */
        !          1244:        if( i < CurCol ) {                       /* flag everything between */
        !          1245:            CharsMarked = 1;                     /* CurCol and i as Marked  */
        !          1246:            for( j = i; j < CurCol; j++ ) {
        !          1247:                if( !MarkedChar[j] )                /* may move forwards... */
        !          1248:                    MarkedChar[j] = 1;
        !          1249:                else MarkedChar[j] = 0;
        !          1250:                }
        !          1251:            }
        !          1252:        else if( i > CurCol ) {
        !          1253:            CharsMarked = 1;                            /* ... or backwards */
        !          1254:            for( j = CurCol; j < i; j++ ) {
        !          1255:                if( !MarkedChar[j] )
        !          1256:                    MarkedChar[j] = 1;
        !          1257:                else MarkedChar[j] = 0;
        !          1258:                }
        !          1259:            }
        !          1260:        }
        !          1261: 
        !          1262:     CurCol = i;                            /* if line is marked, just move */
        !          1263:     VIOSETCURPOS( CurRow, CurCol, 0 );
        !          1264:     drawline();                                                  /* redraw */
        !          1265: 
        !          1266:     }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.