home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / dtx9202 / dbase / screenh.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-09-26  |  10.7 KB  |  368 lines
  1. /********************************************************/
  2. /*            Modul: SCREENH.C        */
  3. /*    stellt Textwindows und schnelle Textausgabe    */
  4. /*    in definierten Windows zur Verfügung        */
  5. /********************************************************/
  6.  
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <conio.h>
  10. #include <dir.h>
  11. #include <io.h>
  12. #include <dos.h>
  13. #include <alloc.h>
  14. #include "serv.h"
  15.  
  16. /* einige Variablen aus dem Hauptmodul LOADER.C */
  17. extern int temphandle;
  18. extern char tempname[50];
  19. extern struct text_info ti;
  20.  
  21. unsigned *s_st;        /* Zeiger auf Beginn des Window-
  22.                stacks */
  23. unsigned *s_st_top;    /* Zeiger auf 1. freies Wort des
  24.                Windowstacks */
  25. signed char s_st_ind=-1;/* Index für Windows (max.
  26.                stmax) */
  27. int swappage=0;        /* Seitennummer des aktuellen
  28.                Stacks */
  29. int far *videoseg;    /* Pointer auf Segment des Bild-
  30.                schirmadapters */
  31.  
  32. windows s_stack[STINDMAX];/* Array für die Windows */
  33. windows initpage=
  34.     {NULL,NULL,0,0,0,79,24,7,0,0,0,0x0B0D,NULL};
  35.  
  36. windows *wptr=&initpage;/* wptr ist der Zeiger auf die ak-
  37.                tuellen Windowdaten, vorbesetzt
  38.                mit initpage */
  39.  
  40. /* screenhandler : ---
  41.    Hier folgt nun die eigentliche Routinen für die Bild-
  42.    schirmunterstützung. Zur Verfügung stehen damit dem
  43.    Anwender:
  44.     1 : scroll        + oder - n Zeilen 'rauf
  45.                 oder 'runter
  46.     2 : window_clear    lösche aktives Window
  47.     3 : window_push        lege neues Window auf den
  48.                 Stack und aktiviere es
  49.     4 : window_get        hole verdeckten window
  50.                 Inhalt vom Stack
  51.     5 : window_pop        hole verdeckten window
  52.                 Inhalt vom Stack und akti-
  53.                 viere altes window
  54.    In der Prozedurdatei zu dBASE/FoxBase sind unter den
  55.    obigen Namen die Schnittstellen zu diesem Programm ange-
  56.    geben. Die drei letzten Funktionen kennen auch eine
  57.    Fehlerrückmeldung. Falls bei push, get und pop kein
  58.    Fehler aufgetreten ist enthält der Aufrufstring hinter
  59.    dem Doppelpunkt (also an der 4. Stelle) eine 0, anderen-
  60.    falls eine Ziffer größer als 0 (s.u.). */
  61. void screenhandler (int subfunc, unsigned ds, unsigned bx)
  62. {
  63.  char *cmdstr;
  64.  switch (subfunc)
  65.  {
  66.   /******************************************************/
  67.   /*            SCROLL                 */
  68.   /*    Form :    11:<n>                            */
  69.   /*         mit <n> +/-Dezimalzahl            */
  70.   /******************************************************/
  71.   case 1 :
  72.   {
  73.    int lines;
  74.    cmdstr=MK_FP(ds,bx);    /* Setze cmdstr auf den übergebenen
  75.                String */
  76.    lines=atoi(cmdstr);  /* Ermittle aus dem String die An-
  77.                zahl der Zeilen */
  78.    wscroll(lines);    /* scroll (siehe Modul SERV.C)*/
  79.    break;
  80.   }
  81.   /******************************************************/
  82.   /*            CLR_WINDOW             */
  83.   /*    Form:    12:                    */
  84.   /******************************************************/
  85.   case 2 :
  86.    wclear();        /* siehe Modul SERV.C */
  87.    break;
  88.   /******************************************************/
  89.   /*             WRITE_STRING             */
  90.   /*    direktes Schreiben, absolute Koordianten    */
  91.   /*    Form:    13:<y>,<x>,<col>;<string>        */
  92.   /*        mit     <y>    Zeile [0..24]        */
  93.   /*            <x>    Spalte [0..79]        */
  94.   /*            <col>    Farbe [0..255]        */
  95.   /*            <string> Text            */
  96.   /******************************************************/
  97.   case 3 :
  98.   {
  99.    int cx,cy,col;    /* Koordinaten für die Ausgabe und
  100.                Farbe */
  101.    char *pos;        /* Zeiger auf den zu zerlegenden
  102.                String */
  103.    cmdstr=MK_FP(ds,bx);
  104.    pos=cmdstr;
  105.    cy=atoi(pos);          /* Hole die Werte aus dem String,
  106.                  die */
  107.    pos=strchr(pos,',')+1; /* durch Kommata getrennt sein
  108.                  müssen */
  109.    cx=atoi(pos);
  110.    pos=strchr(pos,',')+1;
  111.    col=atoi(pos);
  112.    pos=strchr(pos,';')+1; /* Der Text wird durch ein Semi-
  113.                  kolon abgetrennt */
  114.    if (pos!=NULL)      /* Falls die Zeichenkette hier
  115.                  noch nicht zu Ende ist ... */
  116.     dispstr(pos,cy,cx,col);/* schreibe sie direkt in den
  117.                   Bildschirmspeicher */
  118.    break;
  119.   }
  120.   /******************************************************/
  121.   /*             WRITE_STRING             */
  122.   /*    mit Zeichenkontrolle und window relativer       */
  123.   /*    Cursorpositionierung                */
  124.   /*    Form:    14:<y>,<x>,<col>;<string>        */
  125.   /*        Erläuterung siehe oben            */
  126.   /*    oder:    14:<col>;<string>            */
  127.   /*        Zeichenausgabe ab aktueller Cursor-    */
  128.   /*        position                */
  129.   /******************************************************/
  130.   case 4 :
  131.   {
  132.    int cx,cy,col;        /* wie oben */
  133.    char *pos,*search;
  134.    cmdstr=MK_FP(ds,bx);
  135.    pos=cmdstr;
  136.    /* Suche nach Vorkommen von ',' oder ';'. Falls zuerst
  137.       ein ';' auftaucht, liegt Form 2 vor sonst Form 1.
  138.       Der unzulässige Fall, daß gar nichts entdeckt wird,
  139.       wird auch gleich mit abgefangen. */
  140.    for (search=pos;
  141.     *search!=0 && *search!=';' && *search!=',';
  142.     search++);
  143.    if (*search==0)
  144.     break;
  145.    if (*search==',')
  146.    {
  147.     cy=atoi(pos);
  148.     pos=strchr(pos,',')+1;
  149.     cx=atoi(pos);
  150.     pos=strchr(pos,',')+1;
  151.     col=atoi(pos);
  152.     pos=strchr(pos,';')+1;
  153.     wptr->attr=col;
  154.     if (pos!=NULL)
  155.     {
  156.      setwcurpos((cy<<8)|cx);    /* positioniere Cursor
  157.                    (siehe Modul SERV.C)*/
  158.      wputs(pos);        /* schreibe Text (siehe
  159.                    Modul SERV.C) */
  160.     }
  161.    }
  162.    else
  163.    {
  164.     col=atoi(pos);
  165.     pos=strchr(pos,';')+1;
  166.     wptr->attr=col;
  167.     if (pos!=NULL)
  168.     {
  169.      wputs(pos);        /* schreibe Text (siehe
  170.                    Modul SERV.C) */
  171.     }
  172.    }
  173.    break;
  174.   }
  175.   /******************************************************/
  176.   /*             WINDOW_PUSH            */
  177.   /*    Form:    14:<uly>,<ulx>,<lry,<lrx>,        */
  178.   /*           <fr_attr>,<fr_type>,<attr>;<string>    */
  179.   /*        mit     <y>    Zeile [0..24]        */
  180.   /*            <x>    Spalte [0..79]        */
  181.   /*            <col>    Farbe [0..255]        */
  182.   /*            <string> Text            */
  183.   /* Ergebnis : 0                    */
  184.   /* Fehler:                        */
  185.   /*        2 : Stack voll                */
  186.   /*        3 : ungültige Parameter            */
  187.   /******************************************************/
  188.   case 5 :
  189.   {
  190.    int ulx,uly,lrx,lry;        /* Window Koordinaten:
  191.                    upper left x usw. */
  192.    int size,fr_attr,fr_type,attr; /* siehe Def. struct
  193.                      window */
  194.    char fr_attrs[5],attrs[5];    /* Stringdefinitionen der
  195.                    Farben nach dBASE */
  196.    char *pos,*posn;
  197.    cmdstr=MK_FP(ds,bx);        /* Zerlege String */
  198.    pos=cmdstr;
  199.    uly=atoi(pos);
  200.    pos=strchr(pos,',')+1;
  201.    ulx=atoi(pos);
  202.    pos=strchr(pos,',')+1;
  203.    lry=atoi(pos);
  204.    pos=strchr(pos,',')+1;
  205.    lrx=atoi(pos);
  206.    pos=strchr(pos,',')+1;
  207.  
  208.    strncpy(fr_attrs,pos,
  209.     (size_t)((posn=strchr(pos,','))-pos));
  210.    *(fr_attrs+(int)((posn++)-pos))=0;
  211.    pos=posn;        /* Hier wurde der Farbname für den
  212.                Rahmen gelesen */
  213.  
  214.    fr_type=atoi(pos);   /* hier die Art (einfach, doppelt
  215.                usw.) */
  216.    pos=strchr(pos,',')+1;
  217.  
  218.    strncpy(attrs,pos,(size_t)((posn=strchr(pos,';'))-pos));
  219.    *(attrs+(int)((posn++)-pos))=0;
  220.    pos=posn;        /* und hier die Farbe für den
  221.                Inhalt des Windows */
  222.  
  223.    if (temphandle==0)    /* falls noch kein swap file
  224.                geöffnet wurde ... */
  225.    {
  226.     getcwd(tempname,sizeof tempname-1); /* ... hole Ver-
  227.                        zeichnisname, */
  228.     strcat(tempname,"\\");    /* füge ein '\' dran */
  229.     temphandle=creattemp(tempname,0);    /* hole von DOS
  230.                        einen noch nicht
  231.                        existiierenden
  232.                        Dateinamen und
  233.                        öffne damit eine
  234.                        Binärdatei */
  235.    }
  236.    if (*fr_attrs)
  237.     fr_attr=attr_string(fr_attrs); /* Wandele Farbnamen in
  238.                       Farbnummer um (siehe
  239.                       Modul SERV.C) */
  240.    else
  241.     fr_attr=7;
  242.    if (*attrs)
  243.     attr=attr_string(attrs);
  244.    else
  245.     attr=7;
  246.    if (uly>=0 && uly<25 && ulx>=0 && ulx<80 && lry>=uly
  247.        && lry<25 && lrx>=ulx && lrx<80)
  248.        /* Koordinaten sind gültig */
  249.    {
  250.     if (s_st_ind<STINDMAX-1) /* maximale Anzahl Fenster
  251.                 noch nicht erreicht */
  252.     {
  253.      if (s_st_top+(size=(lrx-ulx+1)*(lry-uly+1))>
  254.         s_st+stmax)
  255.      /* Rest der Pufferseite zu klein für Window */
  256.      {
  257.       /* swap out page */
  258.       lseek(temphandle,swappage*stmax,0);
  259.       write(temphandle,s_st,stmax*2);
  260.       swappage++;        /* Pufferseite  +1 */
  261.       memset(s_st,0,stmax*2);    /* setze Puffer auf 0 */
  262.       s_st_top=s_st;    /* stack top = stack begin */
  263.      }
  264.      s_stack[s_st_ind+1].s_p=s_st_top;    /* Trage stack top
  265.                        im Array ein, er
  266.                        stellt den
  267.                        Pointer zum Puf-
  268.                        ferbereich dar.
  269.                        */
  270.      s_st_top+=size;        /* neuer stack top */
  271.      s_stack[s_st_ind+1].s_np=s_st_top; /* eintragen */
  272.      /* aktuelle Seitennummer: */
  273.      s_stack[s_st_ind+1].s_swappage=swappage;
  274.      s_st_ind++;        /* Window index */
  275.      wptr=&s_stack[s_st_ind];    /* Zeiger auf neue Window-
  276.                    Daten */
  277.      wptr->curs_shape=getcurshape();    /* Sichere letzte
  278.                        Cursorform, */
  279.      wptr->curs_pos=getcurpos();    /* und letzte
  280.                        Position
  281.                        (siehe Modul
  282.                        SERV.C)*/
  283.      wopen(wptr->s_p,ulx,uly,lrx,lry,attr,fr_type,
  284.     fr_attr,pos);
  285.     /* Öffne Fenster (siehe Modul SERV.C) */
  286.      ccmdstr(0,cmdstr); /* O.K. (siehe Modul SERV.C) */
  287.     }
  288.     else
  289.      ccmdstr(2,cmdstr);
  290.    }
  291.    else
  292.     ccmdstr(3,cmdstr);
  293.    break;
  294.   }
  295.   /******************************************************/
  296.   /*             WINDOW_GET            */
  297.   /* Ergebnis : 0                    */
  298.   /* Fehler:                        */
  299.   /*        2 : Stack leer                */
  300.   /******************************************************/
  301.   case 6 :
  302.   {
  303.    cmdstr=MK_FP(ds,bx);
  304.    if (s_st_ind>-1)
  305.    {
  306.     puttext(wptr->ulx+1,wptr->uly+1,wptr->lrx+1,
  307.     wptr->lry+1,wptr->s_p);
  308.     /* Hole verdeckten Text zurück */
  309.     ccmdstr(0,cmdstr);
  310.    }
  311.    else
  312.     ccmdstr(2,cmdstr);
  313.    break;
  314.   }
  315.   /******************************************************/
  316.   /*             WINDOW_POP            */
  317.   /* Ergebnis : 0                    */
  318.   /* Fehler:                        */
  319.   /*        2 : Stack leer                */
  320.   /*        3 : ungültige Parameter            */
  321.   /******************************************************/
  322.   case 7 :
  323.   {
  324.    cmdstr=MK_FP(ds,bx);
  325.     if (s_st_ind>-1)
  326.     {
  327.      puttext(wptr->ulx+1,wptr->uly+1,wptr->lrx+1,
  328.     wptr->lry+1,wptr->s_p);
  329.     /* schreibe gesicherten Bildschirminhalt zurück */
  330.      setcurpos(wptr->curs_pos);        /* gesicherte Cur-
  331.                        sorposition */
  332.      setcurshape(wptr->curs_shape);    /* gesicherte Cur-
  333.                        sorform */
  334.      s_stack[s_st_ind].s_p=NULL;    /* setze Pointer
  335.                        auf NULL */
  336.      s_st_ind--;
  337.      if (s_st_ind>-1 && s_stack[s_st_ind].s_swappage!=
  338.         swappage)
  339.      /* das letzte aktive Window befindet sich eine
  340.         Seite vorher */
  341.      {
  342.       /* setze swappage zurück */
  343.       swappage=s_stack[s_st_ind].s_swappage;
  344.       /* positioniere swap file */
  345.       lseek(temphandle,swappage*stmax*2,0);
  346.       /* lese */
  347.       read(temphandle,s_st,stmax*2);
  348.       /* setze Größe zurück */
  349.       chsize(temphandle,tell(temphandle));
  350.      }
  351.      if (s_st_ind>-1)
  352.      {
  353.       s_st_top=s_stack[s_st_ind].s_np;    /* setze stack top */
  354.       wptr=&s_stack[s_st_ind];        /* aktives Window */
  355.      }
  356.      else
  357.      {
  358.       s_st_top=s_st;            /* Anfangsdaten */
  359.       wptr=&initpage;
  360.      }
  361.      ccmdstr(0,cmdstr);
  362.     }
  363.     else
  364.      ccmdstr(2,cmdstr);
  365.    break;
  366.   }
  367.  }
  368. }