home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / edit / point20 / interfac.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-04  |  10.6 KB  |  455 lines
  1. #include "pt.h"
  2. #include "string.h"
  3.  
  4. #ifdef OVERLAYS
  5. void cdecl
  6. /* XTAG:overlayDriver */
  7. overlayDriver(ax, bx, cx, dx, si, di)
  8.     unsigned int ax, bx, cx, dx, si, di;
  9. {
  10.     extern unsigned char msgBuffer[];
  11.     extern unsigned char textBuffer[];
  12.     extern unsigned char *screenMap;
  13.     extern struct SREGS segRegs;
  14.     extern int scrRows, scrCols;
  15.     extern struct window *windowList;
  16.     extern struct window *selWindow;
  17.     extern long selBegin, selEnd;
  18.     extern int selMode;
  19.     extern int debug;
  20.     extern struct window *activeWindow;
  21.     extern struct openFile *files;
  22.     extern struct event events[];
  23.     extern int addHandle;
  24.     extern unsigned char charTable[];
  25.     extern int quitExecuted;
  26.  
  27.     struct window *w, *wId;
  28.     unsigned char ch, *cp;
  29.     unsigned char far *fp;
  30.     unsigned int i, n, iBuffer, *p;
  31.     long l, offset, block;
  32.     struct diskBuffer *buf;
  33.  
  34.     switch( ax ) {
  35.     default:
  36.         break;
  37.  
  38.     case 1:        /* read one character */
  39.         fp = makeFarPointer(cx, dx);
  40.         ax = (unsigned int)readChar(activeWindow->fileId, (long)fp);
  41.         break;
  42.  
  43.     case 2:        /* get span in disk cache buffer */
  44.         l = (long)makeFarPointer(cx, dx);
  45.         ax = getSpan(activeWindow->fileId, l,
  46.             (unsigned char far **)&cx, (unsigned char far **)&si,
  47.             0);
  48.         break;
  49.  
  50.     case 3:        /* top the active window */
  51.         doTopWindow(activeWindow, bx);
  52.         break;
  53.  
  54.     case 4:        /* scroll the active window up or down */
  55.         setMap(activeWindow->row1, activeWindow->col1,
  56.             activeWindow->row2, activeWindow->col2, 1, 0x07);
  57.         maskTop(activeWindow);
  58.         if( bx == 0 )
  59.             downScroll(activeWindow, cx);
  60.         else
  61.             upScroll(activeWindow, cx);
  62.         break;
  63.  
  64.     case 5:        /* change the active window */
  65.         cx = (unsigned int)activeWindow;
  66.         if( validWindowIdentifier(bx) ) {
  67.             activeWindow = (struct window *)bx;
  68.             ax = 0;
  69.         } else
  70.             ax = 1;
  71.         break;
  72.  
  73.     case 6:        /* set the selection */
  74.         /* convert to segment/offset (=long) form */
  75.         selBegin = (((long)(unsigned)dx) << 16) + ((unsigned)cx);
  76.         selEnd = (((long)(unsigned)di) << 16) + ((unsigned)si);
  77.         /* Do some checking to be safe. We don't want some other */
  78.         /* program to be able to crash Point*/
  79.         l = fileSize(selWindow->fileId) - 1;
  80.         if( selBegin < 0 )
  81.             selBegin = 0;
  82.         if( selBegin > l )
  83.             selBegin = l;
  84.         if( selEnd < selBegin )
  85.             selEnd = selBegin;
  86.         if( selEnd > l )
  87.             selEnd = l;
  88.         if( bx == 1 ) {
  89.             doGoSel(selWindow);
  90.             goto deleteChars;
  91.         }
  92.         break;
  93.  
  94.     case 7:        /* redraw the screen */
  95.     redrawScreen:
  96.         redrawBox(0, 0, scrRows-1, scrCols-1);
  97.         updateScreen(0, scrRows-1);
  98.         break;
  99.  
  100.     case 8:        /* insert character at insertion point */
  101.         insertChar((unsigned char)bx);
  102.         break;
  103.  
  104.     case 9:        /* delete characters */
  105.     deleteChars:
  106.         deleteChars(selWindow->fileId, 0, 1);
  107.         break;
  108.  
  109.     case 10:    /* display message */
  110.         movedata(dx, cx, segRegs.ds, (unsigned int)&msgBuffer[0], 78);
  111.         msgBuffer[78] = '\0';
  112.         msg(msgBuffer, bx);
  113.         break;
  114.  
  115.     case 11:    /* insert string at insertion point */
  116.         fp = makeFarPointer(cx, dx);
  117.         if( si == 1 ) {        /* hide the inserted piece */
  118.             l = selBegin;    /* save the beginning of the insert */
  119.         }
  120.         for(i = 0; i < bx; ++i)
  121.             insertChar(*fp++);
  122.         if( si == 1 ) {
  123.             insertChar(0);    /* mark the end */
  124.             hidePiece(l);
  125.         }
  126.         break;
  127.  
  128.     case 12:    /* return selection information */
  129.         ax = selMode;
  130.         bx = (unsigned int)selWindow;
  131.         p = (unsigned int *)&selBegin;
  132.         cx = *p++;
  133.         dx = *p;
  134.         p = (unsigned int *)&selEnd;
  135.         si = *p++;
  136.         di = *p;
  137.         break;
  138.  
  139.     case 13:    /* set selection information */
  140.         if( validWindowIdentifier(bx) ) {
  141.             ax = 0;
  142.             selWindow = (struct window *)bx;
  143.             if( 0 <= cx && cx <= 2 )
  144.                 selMode = cx;
  145.             else
  146.                 ax = 2;
  147.         } else
  148.             ax = 1;
  149.         break;
  150.  
  151.     case 14:        /* get input from user */
  152.         movedata(dx, cx, segRegs.ds, (int)&msgBuffer[0], 80);
  153.         msgBuffer[79] = '\0';
  154.         movedata(di, si, segRegs.ds, (int)&msgBuffer[80], 80);
  155.         msgBuffer[159] = '\0';
  156.         cp = getInput(&msgBuffer[0], &msgBuffer[80], bx);
  157.         if( cp != NULL ) {
  158.             n = 1 + strlen(&cp[0]);    /* +1 for the newline */
  159.             movedata(segRegs.ds, (int)cp, dx, cx, n);
  160.             ax = 0;
  161.         } else    /* user pressed ESCape */
  162.             ax = 1;
  163.         break;
  164.  
  165.     case 15:    /* get window location */
  166.         if( validWindowIdentifier(bx) ) {
  167.             si = 0;
  168.             w = (struct window *)bx;
  169.             ax = w->row1;
  170.             bx = w->col1;
  171.             cx = w->row2;
  172.             dx = w->col2;
  173.         } else
  174.             si = 1;
  175.         break;
  176.  
  177.     case 16:    /* get window information */
  178.         if( validWindowIdentifier(bx) ) {
  179.             w = (struct window *)bx;
  180.             n = strlen(files[w->fileId].origName);
  181.             movedata(segRegs.ds,
  182.                 (unsigned int)files[w->fileId].origName,
  183.                 dx, cx, n + 1);
  184.             ax = w->numTopline;
  185.             bx = w->numBotline;
  186.             p = (unsigned int *)&w->posTopline;
  187.             cx = *p++;
  188.             dx = *p;
  189.             p = (unsigned int *)&w->posBotline;
  190.             si = *p++;
  191.             di = *p;
  192.         } else
  193.             ax = (unsigned int)-1;
  194.         break;
  195.  
  196.     case 17:    /* move window to line number */
  197.         doGoto(activeWindow, bx);
  198.         break;
  199.  
  200.     case 18:    /* move the active window */
  201.         /* make sure the values are vaild */
  202.         if( cx < 0 )
  203.             cx = 0;
  204.         else if( cx > scrRows - 4 )
  205.             cx = scrRows - 4;
  206.         if( si < cx + 3 )
  207.             si = cx + 3;
  208.         else if( si >= scrRows )
  209.             si = scrRows - 1;
  210.  
  211.         if( dx < 0 )
  212.             dx = 0;
  213.         else if( dx > scrCols - 11 )
  214.             dx = scrCols - 11;
  215.         if( di < dx + 10 )
  216.             di = dx + 10;
  217.         else if( dx >= scrCols )
  218.             dx = scrCols - 1;
  219.  
  220.         activeWindow->row1 = cx;
  221.         activeWindow->col1 = dx;
  222.         activeWindow->row2 = si;
  223.         activeWindow->col2 = di;
  224.         break;
  225.  
  226.     case 19:    /* create a new window */
  227.         if( bx != 0 ) {        /* temporary window */
  228.             cp = NULL;
  229.         } else {
  230.             cp = &msgBuffer[150];
  231.             movedata(di, si, segRegs.ds, (unsigned int)cp, 80);
  232.         }
  233.         w = createWindow(cp, cx&0xFF, (cx>>8)&0xFF, dx&0xFF,
  234.             (dx>>8)&0xFF, 0, bx);
  235.         if( w == NULL )
  236.             ax = 1;
  237.         else {
  238.             activeWindow = w;
  239.             ax = 0;
  240.             if( bx != 0 ) {
  241.                 /* save the selection state so we can */
  242.                 /* insert characters into the new window */
  243.                 wId = selWindow;
  244.                 selWindow = w;
  245.                 block = selBegin;
  246.                 offset = selEnd;
  247.                 selBegin = selEnd = 0L;
  248.                 fp = makeFarPointer(si, di);
  249.                 while( 1 ) {
  250.                     ch = *fp++;
  251.                     if( ch == '\0' )
  252.                         break;
  253.                     insertChar(ch);
  254.                 }
  255.                 /* restore the selection state */
  256.                 selWindow = wId;
  257.                 selBegin = block;
  258.                 selEnd = offset;
  259.                 /* return the windowId */
  260.                 bx = (unsigned int)w;
  261.                 goto redrawScreen;
  262.             }
  263.         }
  264.         bx = (unsigned int)w;    /* return the windowId */
  265.         break;
  266.  
  267.     case 20:    /* close the active window */
  268.         closeWindow(activeWindow, bx, 1);
  269.         activeWindow = windowList;
  270.         break;
  271.  
  272.     case 21:    /* save the file in the active window */
  273.         saveFile(activeWindow);
  274.         break;
  275.  
  276.     case 22:    /* get identifier of the next window */
  277.         ax = 0;
  278.         if( bx == 0 ) {
  279.             bx = (unsigned int)windowList;
  280.             break;
  281.         }
  282.         if( validWindowIdentifier(bx) ) {
  283.             w = (struct window *)bx;
  284.             bx = (unsigned int)(w->nextWindow);
  285.         } else
  286.             ax = 1;
  287.         break;
  288.  
  289.     case 23:    /* convert from line numbers and offsets */
  290.         --bx;    /* user line numbers start with 1, so line */
  291.             /* number 5 (for instance) starts by going 4 */
  292.             /* lines down from the beginning of the file */
  293.         l = nextLine(activeWindow->fileId, 0L, &bx);
  294.         p = (unsigned int *)&l;
  295.         cx = *p++;
  296.         dx = *p;
  297.         break;
  298.  
  299.     case 24:    /* search for a string */
  300.         movedata(dx, cx, segRegs.ds, (unsigned int)&msgBuffer[0], 80);
  301.         l = searchExternal(msgBuffer, selWindow, (bx>>8)&0xFF,
  302.             bx&0xFF);
  303.         p = (unsigned int *)&l;
  304.         cx = *p++;
  305.         dx = *p;
  306.         break;
  307.  
  308.     case 25:    /* execute a Point command */
  309.         if( validWindowIdentifier(bx) ) {
  310.             ax = 0;
  311.             command(cx, '\0', (struct window*)bx);
  312.         } else
  313.             ax = 1;
  314.         break;
  315.  
  316.     case 26:    /* get input event */
  317.         /* are there any typed characters? */
  318.         if( isKeystroke() != 0 ) {
  319.             cx = getKeystroke((unsigned char *)&dx);
  320.             bx = 1;        /* keystroke found */
  321.             break;
  322.         }
  323.         /* is there a mouse event? */
  324.         if( isMouseEvent(0) ) {
  325.             bx = 2;        /* mouse event found */
  326.             ax = getMouseEvent();
  327.             cx = events[ax].vertical>>3;
  328.             dx = events[ax].horizontal>>3;
  329.             si = events[ax].buttons;
  330.             di = events[ax].mask;
  331.             break;
  332.         }
  333.         bx = 0;        /* no event pending */
  334.         break;
  335.  
  336.     case 27:    /* handle input event */
  337.         if( bx == 1 ) {        /* keyboard event */
  338.             interp((unsigned char)cx, (unsigned char)dx);
  339.             break;
  340.         } else if( bx == 2 ) {    /* mouse event */
  341.             (void)mouseButton(cx);
  342.         } else {    /* error -- invalid event type */
  343.             msg("Invalid event on interface call", 3);
  344.         }
  345.         break;
  346.  
  347.     case 28:    /* find next file mark */
  348.         if( !validWindowIdentifier(bx) ) {
  349.             ax = 1;
  350.             break;
  351.         }
  352.         ax = 0;        /* no errors yet! */
  353.         l = (((long)(unsigned)di) << 16) + ((unsigned)si);
  354.         l = findHiddenPiece((struct window *)bx, l, &offset);
  355.         if( l != -1L ) {
  356.             i = 0;    /* index into screenMap buffer */
  357.             /* use screenMap as a scratch buffer since it */
  358.             /* will not be in user here */
  359.             iBuffer = BUFFERSIZE;
  360.             while( 1 ) {
  361.                 if( iBuffer >= BUFFERSIZE ) {
  362.                     block = offset>>BUFFERSHIFT;
  363.                     iBuffer = (unsigned int)
  364.                             offset % BUFFERSIZE;
  365.                     buf = getBuffer(addHandle, block);
  366.                     fp = buf->bufferAddress;
  367.                 }
  368.                 ch = *(fp + (iBuffer++));
  369.                 ++offset;
  370.                 /* check for scratch buffer overflow */
  371.                 if( i >= MAXROWS*MAXCOLS-1) {
  372.                     /* simuate the end of the string */
  373.                     ch = '\0';
  374.                     ax = 2;
  375.                 }
  376.                 screenMap[i++] = ch;
  377.                 /* check for the end of the string */
  378.                 if( ch == '\0' )
  379.                     break;
  380.             }
  381.             movedata(segRegs.ds, (unsigned int)&screenMap[0], dx,
  382.                 cx, i);
  383.         }
  384.         p = (unsigned int *)&l;
  385.         cx = *p++;
  386.         dx = *p;
  387.         break;
  388.  
  389.     case 29:    /* delete all file marks in file in window bx */
  390.         if( !validWindowIdentifier(bx) ) {
  391.             ax = 1;
  392.             break;
  393.         }
  394.         ax = deleteHiddenText((struct window *)bx);
  395.         break;
  396.  
  397.     case 30:    /* display a menu */
  398.         fp = makeFarPointer(si, di);
  399.         bx = menu((struct menuBlock far *)fp, cx, dx);
  400.         break;
  401.  
  402.     case 31:    /* set up Anasazi */
  403. #ifdef ANASAZI
  404.         anasazi = bx;
  405.         if( bx == 1 ) {
  406.             charTable[cx] = 5;
  407.             charTable[dx] = 5;
  408.         }
  409. #endif
  410.         break;
  411.  
  412.     case 32:    /* overlay suspend */
  413.         mainLoop();
  414.         /* pass on the new argument string */
  415.         if( quitExecuted )
  416.             strcpy(textBuffer, "0" );
  417.         cx = (unsigned int)&textBuffer[0];
  418.         dx = segRegs.ds;
  419.         /* return to the overlay */
  420.         break;
  421.     }
  422. }
  423.  
  424. int pascal
  425. /* XTAG:validWindowIdentifier */
  426. validWindowIdentifier(n)
  427.     unsigned int n;
  428. {
  429.     extern struct window *windowList;
  430.  
  431.     register struct window *w;
  432.     struct window *wId;
  433.  
  434.     wId = (struct window *)n;
  435.     w = windowList;
  436.     while( w != NULL && w != wId )
  437.         w = w->nextWindow;
  438.     return (w != NULL);
  439. }
  440. #endif
  441.  
  442. unsigned char far * pascal
  443. /* XTAG:makeFarPointer */
  444. makeFarPointer(offset, segment)
  445.     unsigned int offset, segment;
  446. {
  447.     register unsigned int *p;
  448.     unsigned char far *fp;
  449.  
  450.     p = (unsigned int *)&fp;
  451.     *p++ = offset;
  452.     *p = segment;
  453.     return fp;
  454. }
  455.