home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 3 / FREEWARE.BIN / towns_os / look / source / wind.c < prev   
Text File  |  1980-01-02  |  20KB  |  857 lines
  1. /********************************
  2.     ウインド－型コンソ－ル
  3.  
  4.     89/04/14        Make By Ken
  5.     89/04/21        VRAM Direct Sring display & Scroll
  6.  
  7. ********************************/
  8. #include    <stdio.h>
  9. #include    <stdlib.h>
  10. #include    <string.h>
  11. #include    <ctype.h>
  12. #include    <mmi.h>
  13. #include    <egb.h>
  14. #include    <mos.h>
  15.  
  16. #define PAGE0   0
  17. #define    PAGE1    0x040000
  18.  
  19. #define SHORT   short int
  20. #define UCHAR   unsigned char
  21.  
  22. #define    NOTBAK    ((wfp->wd_mode & 0x0001) != 0)
  23. #define    TIFF    ((wfp->wd_mode & 0x0002) != 0)
  24.  
  25. #define    WLX        wfp->wd_lx
  26. #define    WLY        wfp->wd_ly
  27. #define    WRX        wfp->wd_rx
  28. #define    WRY        wfp->wd_ry
  29. #define    WFRA    wfp->wd_fra
  30. #define    WBAK    wfp->wd_bak
  31.  
  32. typedef struct wdtmp {
  33.     SHORT    wd_mode;
  34.     SHORT    wd_lx, wd_ly;
  35.     SHORT    wd_rx, wd_ry;
  36.     char    *wd_img;
  37.     struct    wdtmp *wd_forwfp;
  38.     struct    wdtmp *wd_nxtwfp;
  39.  
  40.     SHORT    wd_fntsiz;
  41.     SHORT    wd_x, wd_y;        /* ｸﾞﾗﾌｨｯｸ座標 */
  42.     SHORT    wd_len;
  43.     char    wd_buf[256];
  44.     SHORT    wd_dx, wd_dy;    /* ｸﾞﾗﾌｨｯｸ･表示座標 */
  45.     SHORT    wd_cx, wd_cy;    /* ｺﾝｿ-ﾙ座標 */
  46.     SHORT    wd_mx, wd_my;    /* ｺﾝｿ-ﾙ･ｻｲｽﾞ */
  47.     SHORT    wd_tab;
  48.     SHORT    wd_offx;
  49.  
  50.     SHORT    wd_fra, wd_bak, wd_chr;
  51.  
  52.     SHORT    wd_valsiz;
  53.     SHORT    wd_valtop;
  54.     int        wd_entsiz;
  55.     int        wd_bufsiz;
  56.     char    *wd_bftop;
  57.     char    *wd_bfbtm;
  58.     char    *wd_dptop;
  59.     char    *wd_dpptr;
  60.     SHORT    wd_dpflg;
  61.  
  62.     char    wd_ttl[80];
  63. } WINDFP;
  64.  
  65. extern void    box(int x1,int y1,int x2,int y2,int col,int mode);
  66. extern void    fbox(int x1,int y1,int x2,int y2,int col,int bcol,int mode);
  67. extern void    wrtptn(char *ptn,int x,int y,int sx,int sy,int col,int bak);
  68. extern void    wrtstr(char *str,int x,int y,int font,int ccol,int bcol);
  69. extern char *getvram(int x1,int y1,int x2,int y2);
  70. extern void    putvram(char *vram,int x1,int y1,int x2,int y2);
  71. extern WINDFP *GRA_open(char *f,int lx,int ly,int rx,int ry,int f,int b);
  72.  
  73. extern    int        ofx,ofy,dspoff;
  74. extern     char     *work;
  75. extern    char    lftptn[],ritptn[];
  76.  
  77. static    WINDFP    *topwfp = NULL;
  78. static    int        topsip=0;
  79.  
  80. static char    upbar[]={
  81.     0xFF,0xFF,0x80,0x01,0x80,0x01,0x81,0x81,
  82.     0x83,0xC1,0x87,0xE1,0x8F,0xF1,0x9F,0xF9,
  83.     0x83,0xC1,0x83,0xC1,0x83,0xC1,0x83,0xC1,
  84.     0x83,0xC1,0x80,0x01,0x80,0x01,0xFF,0xFF };
  85. static char    downbar[]={
  86.     0xFF,0xFF,0x80,0x01,0x80,0x01,0x83,0xC1,
  87.     0x83,0xC1,0x83,0xC1,0x83,0xC1,0x83,0xC1,
  88.     0x9F,0xF9,0x8F,0xF1,0x87,0xE1,0x83,0xC1,
  89.     0x81,0x81,0x80,0x01,0x80,0x01,0xFF,0xFF };
  90. static char    dspbar[]={
  91.     0x3F,0xFC,0x40,0x02,0x80,0x01,0x80,0x01,
  92.     0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,
  93.     0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,
  94.     0x80,0x01,0x80,0x01,0x40,0x02,0x3F,0xFC };
  95. static char    erabar[]={
  96.     0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,
  97.     0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,
  98.     0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,
  99.     0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01 };
  100. static char    closeptn[]={
  101.     0x03, 0xA0, 0x07, 0xD0, 0x03, 0xE8, 0x01, 0xF0, 
  102.     0x02, 0xF8, 0x04, 0x7C, 0x08, 0xB8, 0x11, 0x10, 
  103.     0x22, 0x00, 0x14, 0x00, 0x08, 0x00, 0xD3, 0xB6, 
  104.     0x92, 0xA4, 0x92, 0xB6, 0x92, 0x94, 0xDB, 0xB6 };
  105. static char    menuptn[]={
  106.     0x03, 0x80, 0x0D, 0x60, 0x31, 0x18, 0x25, 0x08, 
  107.     0x29, 0x08, 0x21, 0x08, 0x21, 0x08, 0x23, 0x88, 
  108.     0x2C, 0x68, 0x30, 0x18, 0x00, 0x00, 0x56, 0xAA, 
  109.     0x74, 0xEA, 0x76, 0xEA, 0x54, 0xEA, 0x56, 0xA4 };
  110. static char    resizeptn[]={
  111.     0xFF, 0xFF, 0xF8, 0xF9, 0xFF, 0xF9, 0x80, 0x09, 
  112.     0xBF, 0x09, 0x80, 0x09, 0xBC, 0x09, 0x80, 0x09, 
  113.     0x80, 0x09, 0x80, 0x09, 0x80, 0x09, 0xFF, 0xF9, 
  114.     0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0xFF, 0xFF };
  115.  
  116. void    WIN_bakput(wfp)
  117. register WINDFP    *wfp;
  118. {
  119.     fbox(WLX+2,WLY+2,WRX-2,WLY+20,2,2,4);
  120.  
  121.     if ( NOTBAK )
  122.         return;
  123.  
  124.     MOS_disp(0);
  125.     VRAM_move(wfp->wd_dx, wfp->wd_dy, 
  126.               wfp->wd_mx * 8, wfp->wd_my * wfp->wd_fntsiz,
  127.               PAGE0, PAGE1, 0, dspoff);
  128.     VRAM_clear(wfp->wd_dx, wfp->wd_dy, 
  129.                wfp->wd_mx * 8, wfp->wd_my * wfp->wd_fntsiz,
  130.                0, PAGE0, 0);
  131.     MOS_disp(1);
  132. }
  133. void    WIN_bakget(wfp)
  134. register WINDFP    *wfp;
  135. {
  136.     fbox(WLX+2,WLY+2,WRX-2,WLY+20,2,2,4);
  137.  
  138.     if ( NOTBAK )
  139.         return;
  140.  
  141.     MOS_disp(0);
  142.     VRAM_move(wfp->wd_dx, wfp->wd_dy, 
  143.               wfp->wd_mx * 8, wfp->wd_my * wfp->wd_fntsiz,
  144.               PAGE1, PAGE0, dspoff, 0);
  145.     VRAM_clear(wfp->wd_dx, wfp->wd_dy, 
  146.                wfp->wd_mx * 8, wfp->wd_my * wfp->wd_fntsiz,
  147.                0, PAGE1, dspoff);
  148.     MOS_disp(1);
  149. }
  150. void    VRAM_roll(wfp)
  151. register WINDFP    *wfp;
  152. {
  153.     int        i;
  154.  
  155.     i = dspoff;
  156.     dspoff += wfp->wd_fntsiz; dspoff &= 0x3FFFF;
  157.     EGB_writePage(work,1);
  158.     EGB_displayStart(work,1,ofx,(ofy + dspoff) & (512 - 1));
  159.     VRAM_clear(wfp->wd_dx, wfp->wd_dy + (wfp->wd_my - 1) * wfp->wd_fntsiz,
  160.                wfp->wd_mx * 8, wfp->wd_fntsiz,
  161.                WBAK, PAGE1, dspoff);
  162.     VRAM_clear(wfp->wd_dx, wfp->wd_dy,
  163.                wfp->wd_mx * 8, wfp->wd_fntsiz,
  164.                0, PAGE1, i);
  165.     EGB_writePage(work,0);
  166. }
  167. void    VRAM_broll(wfp)
  168. register WINDFP    *wfp;
  169. {
  170.     int        i;
  171.  
  172.     i = dspoff;
  173.     dspoff -= wfp->wd_fntsiz; dspoff &= 0x3FFFF;
  174.     EGB_writePage(work,1);
  175.     EGB_displayStart(work,1,ofx,(ofy + dspoff) & (512 - 1));
  176.     VRAM_clear(wfp->wd_dx, wfp->wd_dy,
  177.                wfp->wd_mx * 8, wfp->wd_fntsiz,
  178.                WBAK, PAGE1, dspoff);
  179.     VRAM_clear(wfp->wd_dx, wfp->wd_dy + (wfp->wd_my - 1) * wfp->wd_fntsiz,
  180.                wfp->wd_mx * 8, wfp->wd_fntsiz,
  181.                0, PAGE1, i);
  182.     EGB_writePage(work,0);
  183. }
  184. void    WIN_valmove(wfp)
  185. register WINDFP  *wfp;
  186. {
  187.     int     i,j,top;
  188.     
  189.     if ( TIFF )
  190.         return;
  191.     if ( wfp->wd_entsiz == 0 )
  192.         top = 0;
  193.     else {
  194.         i = (int)wfp->wd_dptop - (int)wfp->wd_bftop;
  195.         top = i * wfp->wd_valsiz / wfp->wd_entsiz;
  196.     }
  197.     j = (WLY + 39);
  198.     if ( wfp->wd_valtop != (-1) )
  199.         wrtptn(erabar,WRX-18,wfp->wd_valtop+j,16,16,WFRA,WBAK);
  200.     wrtptn(dspbar,WRX-18,top+j,16,16,WFRA,WBAK);
  201.     wfp->wd_valtop = top;
  202. }
  203. void    WIN_display(wfp)
  204. register WINDFP    *wfp;
  205. {
  206.     int        i;
  207.     void    WIN_reprint();
  208.  
  209.     fbox(WLX,WLY,WRX,WRY,WFRA,WBAK,0);
  210.     fbox(WLX+2,WLY+2,WRX-2,WLY+20,WFRA,WFRA,0);
  211.  
  212.     i = WLX + (WRX - WLX) / 2 - strlen(wfp->wd_ttl) * 4;
  213.     wrtstr(wfp->wd_ttl,i,WLY+4,1,WBAK,WFRA);
  214.  
  215.     wrtptn(upbar,WRX-18,WLY+22,16,16,WFRA,WBAK);
  216.     box(WRX-18,WLY+38,WRX-3,WRY-37,WFRA,0);
  217.     wrtptn(downbar,WRX-18,WRY-36,16,16,WFRA,WBAK);
  218.  
  219.     wrtptn(lftptn,WLX+2,WRY-18,16,16,WFRA,WBAK);
  220.     box(WLX+18,WRY-18,WRX-37,WRY-3,WFRA,0);
  221.     wrtptn(ritptn,WRX-36,WRY-18,16,16,WFRA,WBAK);
  222.  
  223.     wrtptn(resizeptn,WRX-18,WRY-18,16,16,WFRA,WBAK);
  224.     wrtptn(closeptn,WLX+5,WLY+4,16,16,WBAK,WFRA);
  225.     wrtptn(menuptn,WRX-17,WLY+4,16,16,WBAK,WFRA);
  226.  
  227.     WIN_bakput(wfp);
  228.     if ( wfp->wd_entsiz > 0 )
  229.         WIN_reprint(wfp);
  230.     wfp->wd_valtop = (-1);
  231.     wfp->wd_valsiz = (WRY - 55) - (WLY + 38);
  232.     WIN_valmove(wfp);
  233. }
  234. char    *WIN_cls(wfp)
  235. WINDFP    *wfp;
  236. {
  237.     int        i;
  238.  
  239.     if ( wfp->wd_img != NULL )
  240.         free(wfp->wd_img);
  241.     WIN_bakget(wfp);
  242.     wfp->wd_img = getvram(WLX,WLY,WRX,WRY);
  243.     return wfp->wd_img;
  244. }
  245. void    WIN_redsp(wfp)
  246. WINDFP    *wfp;
  247. {
  248.     if ( wfp->wd_img != NULL )
  249.         putvram(wfp->wd_img,WLX,WLY,WRX,WRY);
  250. }
  251. int        WIN_activ(wfp)
  252. register WINDFP    *wfp;
  253. {
  254.     WINDFP    *p;
  255.  
  256.     if ( wfp == topwfp )
  257.         return 1;
  258.     if ( WIN_cls(topwfp) == NULL )
  259.         return 0;
  260.     if ( (p = wfp->wd_forwfp) != NULL )
  261.         p->wd_nxtwfp = wfp->wd_nxtwfp;
  262.     if ( (p = wfp->wd_nxtwfp) != NULL )
  263.         p->wd_forwfp = wfp->wd_forwfp;
  264.  
  265.     topwfp->wd_nxtwfp = wfp;
  266.     wfp->wd_forwfp = topwfp;
  267.     wfp->wd_nxtwfp = NULL;
  268.     WIN_redsp(wfp);
  269.     topwfp = wfp;
  270.     if ( wfp->wd_img != NULL )
  271.         free(wfp->wd_img); 
  272.     wfp->wd_img = NULL;
  273.     WIN_bakput(wfp);
  274.     return 1;
  275. }
  276. void    WIN_alldsp(wfp)
  277. register WINDFP    *wfp;
  278. {
  279.     WINDFP    *p,*n;
  280.  
  281.     for ( p = n = wfp->wd_forwfp ; p != NULL ; n = p, p = p->wd_forwfp );
  282.     
  283.     EGB_writePage(work,1);
  284.     EGB_displayStart(work,1,ofx,ofy);
  285.     for ( ; n != NULL && n != wfp ; n = n->wd_nxtwfp )
  286.         WIN_redsp(n);
  287.     MOS_disp(0);
  288.     VRAM_move(WLX, WLY, 
  289.               (WRX - WLX + 8) & 0xFFF8, 
  290.               WRY - WLY + 1,
  291.               PAGE1, PAGE0, 0, 0);
  292.     EGB_writePage(work,0);
  293.     VRAM_allclear(PAGE1);
  294.     MOS_disp(1);
  295.     dspoff = 0;
  296. }
  297. WINDFP  *WIN_open(ttl,file,size,mode,lx,ly,rx,ry,fra,bak,chr)
  298. char    *ttl,*file;
  299. int     size,mode;
  300. SHORT   lx,ly,rx,ry;
  301. int        fra,bak,chr;
  302. {
  303.     FILE    *fp;
  304.     register WINDFP  *wfp;
  305.  
  306.     if ( (wfp = GRA_open(file,lx,ly,rx,ry,fra,bak)) != NULL )
  307.         return wfp;
  308.  
  309.     if ( (wfp = (WINDFP *)malloc(sizeof(WINDFP))) == NULL )
  310.         return NULL;
  311.  
  312.     if ( (wfp->wd_bftop = malloc(size)) == NULL ) {
  313.         free(wfp);
  314.         return NULL;
  315.     }
  316.  
  317.     if ( topwfp != NULL ) {
  318.         if ( WIN_cls(topwfp) == NULL )
  319.             return NULL;
  320.         wfp->wd_forwfp = topwfp;
  321.         topwfp->wd_nxtwfp = wfp;
  322.     } else
  323.         wfp->wd_forwfp = NULL;
  324.     wfp->wd_nxtwfp = NULL;
  325.  
  326.     lx &= 0xfffe; rx &= 0xfffe;
  327.     fbox(lx,ly,rx,ry,fra,bak,0);
  328.  
  329.     wfp->wd_mode = mode; 
  330.     wfp->wd_fntsiz = 16;
  331.     wfp->wd_entsiz = 0; wfp->wd_bufsiz = size;
  332.     wfp->wd_bfbtm = wfp->wd_dptop = wfp->wd_dpptr = wfp->wd_bftop;
  333.     wfp->wd_img = NULL;
  334.     strcpy(wfp->wd_ttl,ttl);
  335.  
  336.     if ( file != NULL && (fp = fopen(file,"r")) != NULL ) {
  337.         wfp->wd_entsiz = fread(wfp->wd_bftop,sizeof(char),size,fp);
  338.         wfp->wd_bfbtm = wfp->wd_bftop + wfp->wd_entsiz;
  339.         fclose(fp);
  340.     }
  341.  
  342.     WLX = lx; WLY = ly;
  343.     WRX = rx; WRY = ry;
  344.     WFRA = fra; WBAK = bak; wfp->wd_chr = chr;
  345.  
  346.     lx += 4; ly += 24; 
  347.     rx -= 24; ry -= 4;
  348.     wfp->wd_cx = wfp->wd_cy = wfp->wd_len = 0;
  349.     wfp->wd_dx = lx; wfp->wd_dy = ly;
  350.     wfp->wd_mx = (rx - lx) / 8; wfp->wd_my = (ry- ly - 18) / wfp->wd_fntsiz;
  351.     wfp->wd_x = wfp->wd_dx; wfp->wd_y = wfp->wd_dy;
  352.     wfp->wd_tab = 4;
  353.     wfp->wd_offx = 0;
  354.  
  355.     WIN_display(wfp);
  356.     topwfp = wfp;
  357.  
  358.     return wfp;
  359. }
  360. WINDFP    *WIN_dmyopen(lx,ly,rx,ry)
  361. int        lx,ly,rx,ry;
  362. {
  363.     WINDFP    *wfp;
  364.  
  365.     if ( (wfp = (WINDFP *)malloc(sizeof(WINDFP))) == NULL )
  366.         return NULL;
  367.  
  368.     if ( topwfp != NULL ) {
  369.         WIN_cls(topwfp);
  370.         wfp->wd_forwfp = topwfp;
  371.         topwfp->wd_nxtwfp = wfp;
  372.     } else
  373.         wfp->wd_forwfp = NULL;
  374.  
  375.     wfp->wd_nxtwfp = NULL;
  376.     wfp->wd_mode = 0x001;
  377.     wfp->wd_img = NULL;
  378.     WLX = lx; WLY = ly;
  379.     WRX = rx; WRY = ry;
  380.     topwfp = wfp;
  381.     
  382.     WIN_bakput(wfp);
  383.     return wfp;
  384. }
  385. void    WIN_era(wfp)
  386. WINDFP    *wfp;
  387. {
  388.     WIN_bakget(wfp);
  389.     WIN_alldsp(wfp);
  390. }
  391. void    WIN_close(wfp)
  392. register WINDFP    *wfp;
  393. {
  394.     WINDFP    *p;
  395.  
  396.     WIN_era(wfp);
  397.  
  398.     if ( (p = wfp->wd_nxtwfp) != NULL )
  399.         p->wd_forwfp = wfp->wd_forwfp;
  400.     if ( (p = wfp->wd_forwfp) != NULL )
  401.         p->wd_nxtwfp = wfp->wd_nxtwfp;
  402.     if ( topwfp == wfp ) {
  403.         topwfp = wfp->wd_forwfp;
  404.         WIN_bakput(topwfp);
  405.     }
  406.     if ( wfp->wd_img != NULL )
  407.         free(wfp->wd_img);
  408.     free(wfp->wd_bftop);
  409.     free(wfp);
  410. }
  411. void    WIN_allclose(wfp)
  412. WINDFP    *wfp;
  413. {
  414.     WINDFP    *p,*n;
  415.  
  416.     for ( p = n = wfp->wd_forwfp ; p != NULL ; n = p, p = p->wd_forwfp );
  417.     
  418.     for ( ; n != NULL ; n = p->wd_nxtwfp ) {
  419.         p = n;
  420.         if ( n != wfp ) {
  421.             if ( n->wd_img != NULL )
  422.                 free(n->wd_img);
  423.             if ( n->wd_bftop != NULL )
  424.                 free(n->wd_bftop);
  425.             free(n);
  426.         }
  427.     }
  428.     topwfp = wfp;
  429.     wfp->wd_nxtwfp = wfp->wd_forwfp = NULL;
  430.     WIN_cls(wfp);
  431.     MOS_disp(0);
  432.     VRAM_allclear(PAGE1);
  433.     VRAM_allclear(PAGE0);
  434.     MOS_disp(1);
  435.     WIN_redsp(wfp);
  436.     WIN_bakput(wfp);
  437. }
  438. void    WIN_flush(wfp)
  439. register WINDFP  *wfp;
  440. {
  441.     if ( wfp->wd_len > 0 ) {
  442.         wfp->wd_buf[wfp->wd_len] = '\0';
  443.         VRAM_wrtstr(wfp->wd_buf,
  444.                     wfp->wd_x, wfp->wd_y, wfp->wd_fntsiz,
  445.                     wfp->wd_chr, WBAK, PAGE1, dspoff);
  446.     }
  447.     wfp->wd_len = 0;
  448.     wfp->wd_x = wfp->wd_dx + wfp->wd_cx * 8;
  449.     wfp->wd_y = wfp->wd_dy + wfp->wd_cy * wfp->wd_fntsiz;
  450. }
  451. void    WIN_scroll(wfp)
  452. WINDFP    *wfp;
  453. {
  454.     if ( ++wfp->wd_cy >= wfp->wd_my ) {
  455.         wfp->wd_cy = wfp->wd_my -1;
  456.         WIN_flush(wfp);
  457.         VRAM_roll(wfp);
  458.     } else
  459.         WIN_flush(wfp);
  460. }
  461. void    WIN_nxtptr(wfp)
  462. register WINDFP    *wfp;
  463. {
  464.     int        i,n;
  465.     char    *p;
  466.  
  467.     p = wfp->wd_dpptr;
  468.     wfp->wd_len = 0;
  469.     for ( i=0 ; i < (wfp->wd_offx + wfp->wd_mx) &&
  470.                 p != wfp->wd_bfbtm && *p != '\n' ; p++ ) {
  471.         if ( *p == '\t' ) {
  472.             n = i & (wfp->wd_tab - 1);
  473.             while ( i < (wfp->wd_offx + wfp->wd_mx) && n++ < wfp->wd_tab ) {
  474.                 if ( i++ >= wfp->wd_offx )
  475.                     wfp->wd_buf[wfp->wd_len++] = ' ';
  476.             }
  477.         } else if ( iskanji((UCHAR)*p) && iskanji2((UCHAR)*(p+1)) ) {
  478.             p++;
  479.             if ( (i + 2) > (wfp->wd_offx + wfp->wd_mx) )
  480.                 break;
  481.             if ( i++ >= wfp->wd_offx ) {
  482.                 wfp->wd_buf[wfp->wd_len++] = *(p-1);
  483.                 i++;
  484.                 wfp->wd_buf[wfp->wd_len++] = *p;
  485.             } else {
  486.                 if ( i++ >= wfp->wd_offx )
  487.                     wfp->wd_buf[wfp->wd_len++] = ' ';
  488.             }
  489.         } else if ( *p != '\r' && *p != '\0' ) {
  490.             if ( i++ >= wfp->wd_offx )
  491.                 wfp->wd_buf[wfp->wd_len++] = *p;
  492.         }
  493.     }
  494.     for ( ; i < 120 && p != wfp->wd_bfbtm && *p != '\n' ; i++,p++ );
  495.     if  ( p != wfp->wd_bfbtm && *p == '\n' ) {
  496.         if ( *(++p) == '\r' && p != wfp->wd_bfbtm )
  497.             p++;
  498.     }
  499.     wfp->wd_dpptr = p;
  500. }
  501. void    WIN_reprint(wfp)
  502. register WINDFP    *wfp;
  503. {
  504.     int        i;
  505.     
  506.     if ( wfp->wd_mode != 0 )
  507.         return;
  508.  
  509.     wfp->wd_dpptr = wfp->wd_dptop;
  510.     wfp->wd_cx = wfp->wd_len = 0;
  511.     for ( i = 0 ; i < wfp->wd_my ; i++ ) {
  512.         wfp->wd_cy = i;
  513.         WIN_flush(wfp);
  514.         WIN_nxtptr(wfp);
  515.         while ( wfp->wd_len < wfp->wd_mx )
  516.             wfp->wd_buf[wfp->wd_len++] = ' ';
  517.     }
  518.     WIN_flush(wfp);
  519.     wfp->wd_mode &= 0xFF7F;
  520.     wfp->wd_dpflg = 1;
  521.     i = (WRX - WLX - 72) * wfp->wd_offx / 120;
  522.     fbox(WLX+18,WRY-18,WRX-37,WRY-3,WFRA,WBAK,0);
  523.     wrtptn(dspbar,WLX+18+i,WRY-18,16,16,WFRA,WBAK);
  524. }
  525. void    WIN_imgup(wfp)
  526. register WINDFP  *wfp;
  527. {
  528.     int        i;
  529.     char    *p;
  530.  
  531.     if ( wfp->wd_dptop == wfp->wd_bfbtm )
  532.         return;
  533.     p = wfp->wd_dpptr;
  534.     wfp->wd_dpptr = wfp->wd_dptop;
  535.     WIN_nxtptr(wfp);
  536.     wfp->wd_dptop = wfp->wd_dpptr;
  537.     if ( wfp->wd_dpflg == 0 ) {
  538.         for ( i=0 ; i < wfp->wd_my ; i++ )
  539.             WIN_nxtptr(wfp);
  540.         wfp->wd_dpflg = 1;
  541.     } else {
  542.         wfp->wd_dpptr = p;
  543.         WIN_nxtptr(wfp);
  544.     }
  545.     VRAM_roll(wfp);
  546.     wfp->wd_x = wfp->wd_dx;
  547.     wfp->wd_y = wfp->wd_dy + (wfp->wd_my - 1) * wfp->wd_fntsiz;
  548.     WIN_flush(wfp);
  549. }
  550. void    WIN_bakptr(wfp)
  551. register WINDFP    *wfp;
  552. {
  553.     int        i;
  554.     char    *p,*b;
  555.  
  556.     i = 0;
  557.     if ( (b = p = wfp->wd_dpptr) == wfp->wd_bftop ) {
  558.         wfp->wd_len = 0;
  559.         return;
  560.     }
  561.     while ( --p != wfp->wd_bftop ) {
  562.         if ( *p == '\n' ) {
  563.             if ( i != 0 )
  564.                 break;
  565.             i++;
  566.         }
  567.     }
  568.     if ( p != wfp->wd_bftop ) {
  569.         for ( ; p != wfp->wd_bfbtm ; p++ ) {
  570.             if ( *p != '\n' && *p != '\r' )
  571.                 break;
  572.             else if ( *p == '\n' ) {
  573.                 if ( i == 0 )
  574.                     break;
  575.                 i--;
  576.             }
  577.         }
  578.     }
  579.     wfp->wd_dpptr = p;
  580.     do {
  581.         p = wfp->wd_dpptr;
  582.         WIN_nxtptr(wfp);
  583.     } while ( wfp->wd_dpptr < b );
  584.     wfp->wd_dpptr = p;
  585. }
  586. void    WIN_imgdown(wfp)
  587. register WINDFP    *wfp;
  588. {
  589.     if ( wfp->wd_dptop == wfp->wd_bftop )
  590.         return;
  591.     wfp->wd_dpptr = wfp->wd_dptop;
  592.     WIN_bakptr(wfp);
  593.     wfp->wd_dptop = wfp->wd_dpptr;
  594.  
  595.     VRAM_broll(wfp);
  596.     wfp->wd_x = wfp->wd_dx;
  597.     wfp->wd_y = wfp->wd_dy;
  598.     WIN_flush(wfp);
  599.     wfp->wd_dpflg = 0;
  600. }
  601. void    WIN_move(wfp)
  602. register WINDFP    *wfp;
  603. {
  604.     int        b,x,y,sx,sy,ox,oy;
  605.     int        x1,y1,x2,y2;
  606.     char    *tmp;
  607.  
  608.     MOS_rdpos(&b,&ox,&oy);
  609.  
  610.     x1 = WLX; y1 = WLY;
  611.     x2 = WRX; y2 = WRY;
  612.     sx = WRX - WLX;
  613.     sy = WRY - WLY;
  614.     ox -= WLX; oy -= WLY;
  615.  
  616.     do {
  617.         box(x1,y1,x2,y2,15,4);
  618.         do {
  619.             MOS_rdpos(&b,&x,&y);
  620.             x -= ox; y -= oy;
  621.         } while ( (b & 1) != 0 &&
  622.                    x == x1 && y == y1 );
  623.         box(x1,y1,x2,y2,15,4);
  624.         if ( x < 0 ) x = 0;
  625.         if ( y < 0 ) y = 0;
  626.         if ( (x + sx) >= 1024 ) x = 1022 - sx;
  627.         if ( (y + sy) >= 512 )  y = 510 - sy;
  628.         x &= 0xfffe;
  629.         x1 = x; y1 = y; x2 = x + sx; y2 = y + sy;
  630.     } while ( (b & 1) != 0 );
  631.  
  632.     WIN_bakget(wfp);
  633.     if ( (tmp = getvram(WLX,WLY,WRX,WRY)) == NULL ) {
  634.         WIN_bakput(wfp);
  635.         return;
  636.     }
  637.     WIN_alldsp(wfp);
  638.  
  639.     WLX = x1; WLY = y1;
  640.     WRX = x2; WRY = y2;
  641.     if ( wfp->wd_mode == 0 ) {
  642.         wfp->wd_dx = WLX + 4;
  643.         wfp->wd_dy = WLY + 24;
  644.         wfp->wd_x = wfp->wd_dx + wfp->wd_cx * 8;
  645.         wfp->wd_y = wfp->wd_dy + wfp->wd_cy * wfp->wd_fntsiz;
  646.     }
  647.  
  648.     putvram(tmp,x1,y1,x2,y2);
  649.     WIN_bakput(wfp);
  650.     free(tmp);
  651. }
  652. void    WIN_size(wfp)
  653. register WINDFP    *wfp;
  654. {
  655.     int        b,x,y;
  656.     int        x1,y1,x2,y2;
  657.  
  658.     x1 = WLX;
  659.     y1 = WLY;
  660.     x2 = WRX;
  661.     y2 = WRY;
  662.  
  663.     do {
  664.         box(x1,y1,x2,y2,WFRA,4);
  665.         do {
  666.             MOS_rdpos(&b,&x,&y);
  667.         } while ( (b & 1) != 0 &&
  668.                    x == x2 && y == y2 );
  669.         box(x1,y1,x2,y2,WFRA,4);
  670.         x &= 0xfffe;
  671.         if ( x >= (x1 + 140) )
  672.             x2 = x; 
  673.         if ( y >= (y1 + 100) )
  674.             y2 = y;
  675.     } while ( (b & 1) != 0 );
  676.  
  677.     WIN_era(wfp);
  678.  
  679.     WRX = x2;
  680.     WRY = y2;
  681.     if ( wfp->wd_mode == 0 ) {
  682.         wfp->wd_cx = wfp->wd_cy = wfp->wd_len = 0;
  683.         wfp->wd_mx = ((WRX - 24) - wfp->wd_dx) / 8;
  684.         wfp->wd_my = ((WRY - 4) - wfp->wd_dy - 20) / wfp->wd_fntsiz;
  685.     }
  686.     WIN_display(wfp);
  687. }
  688. void    WIN_seek(wfp)
  689. register WINDFP    *wfp;
  690. {
  691.     int        i,j,new,od,ou;
  692.     int        b,x,y,sx=0,sy=0;
  693.  
  694.     MOS_rdpos(&b,&x,&y);
  695.     if ( x >= (WRX - 18) && x <= WRX &&
  696.          y >= (WLY + 36) && y <= (WRY - 38) ) {
  697.         new = (y - (WLY + 36)) * wfp->wd_entsiz / wfp->wd_valsiz;
  698.         if ( (wfp->wd_dpptr = wfp->wd_bftop + new) > wfp->wd_bfbtm )
  699.             wfp->wd_dpptr = wfp->wd_bfbtm;
  700.         WIN_bakptr(wfp);
  701.         wfp->wd_dptop = wfp->wd_dpptr;
  702.         WIN_reprint(wfp);
  703.     }
  704.     wrtmos(2);
  705.     MOS_horizon(WRX-18,WRX-8);
  706.     MOS_vertical(WLY + 20,WRY - 32);
  707.     i = j = 0;
  708.     od = ou = (int)wfp->wd_dptop - (int)wfp->wd_bftop;
  709.     do {
  710.         MOS_rdpos(&b,&x,&y);
  711.         if ( x >= (WRX - 18) && x <= WRX &&
  712.              y >= (WLY + 20) && y <= (WRY - 16) ) {
  713.             new = (y - (WLY + 36)) * wfp->wd_entsiz / wfp->wd_valsiz;
  714.             if ( new < od ) {
  715.                 ou = od;
  716.                 WIN_imgdown(wfp);
  717.                 od = (int)wfp->wd_dptop - (int)wfp->wd_bftop;
  718.                 j = 1;
  719.             } else if ( new > ou ) {
  720.                 od = ou;
  721.                 WIN_imgup(wfp);
  722.                 ou = (int)wfp->wd_dptop - (int)wfp->wd_bftop;
  723.                 j = 1;
  724.             } else if ( j != 0 ) {
  725.                 WIN_valmove(wfp);
  726.                 i = j = 0;
  727.             }
  728.             if ( j != 0 && i++ >= 20 ) {
  729.                 WIN_valmove(wfp);
  730.                 i = 0;
  731.             }
  732.         }
  733.     } while ( (b & 1) != 0 );
  734.     WIN_valmove(wfp);
  735.     MOS_horizon(0,1023);
  736.     MOS_vertical(0,511);
  737.     wrtmos(0);
  738. }
  739. void    WIN_xseek(wfp)
  740. register WINDFP    *wfp;
  741. {
  742.     int        i;
  743.     int        b,x,y;
  744.  
  745.     wrtmos(2);
  746.     MOS_horizon(WLX,WRX-20);
  747.     MOS_vertical(WRY-18,WRY-2);
  748.     do {
  749.         MOS_rdpos(&b,&x,&y);
  750.         if ( x < (WLX + 18) && y >= (WRY - 18) ) {
  751.             if ( --wfp->wd_offx < 0 ) wfp->wd_offx = 0;
  752.             WIN_reprint(wfp);
  753.         } else if ( x >= (WRX - 36) && x <= (WRX - 16) && y >= (WRY-18 ) ) {
  754.             if ( ++wfp->wd_offx > 120 ) wfp->wd_offx = 120;
  755.             WIN_reprint(wfp);
  756.         } else if ( x >= (WLX + 18) && x < (WRX - 36) && y >= (WRY - 18) ) {
  757.             wfp->wd_offx = (x - WLX - 18) * 120 / (WRX - WLX - 72);
  758.             if ( wfp->wd_offx > 120 ) wfp->wd_offx = 120;
  759.             WIN_reprint(wfp);
  760.         }
  761.     } while ( (b & 1) != 0 );
  762.     MOS_horizon(0,1023);
  763.     MOS_vertical(0,511);
  764.     wrtmos(0);
  765. }
  766. void    WIN_subcom(wfp)
  767. WINDFP    *wfp;
  768. {
  769.     static char *menu[]={"TAB SIZE","FONT SIZE",NULL};
  770.     int        i;
  771.  
  772.     i = MENU_select(menu);
  773.     if ( i == 0 ) {
  774.         wfp->wd_tab = (wfp->wd_tab == 4) ? 8 : 4;
  775.         WIN_display(wfp);
  776.     } else if ( i == 1 ) {
  777.         if ( wfp->wd_fntsiz == 16 )
  778.             wfp->wd_fntsiz = 10;
  779.         else
  780.             wfp->wd_fntsiz = 16;
  781.         wfp->wd_my = (((WRY - 4) - wfp->wd_dy) - 20) / wfp->wd_fntsiz;
  782.         WIN_display(wfp);
  783.     }
  784. }
  785. int        WIN_event(wfp)
  786. register WINDFP    *wfp;
  787. {
  788.     int        b,x,y;
  789.     WINDFP    *p,*n;
  790.  
  791.     MOS_rdpos(&b,&x,&y);
  792.     if ( b != 0 &&
  793.           x >= WLX && x <= WRX &&
  794.           y >= WLY && y <= WRY ) {
  795.         if ( WIN_activ(wfp) == 0 )
  796.             return (-1);
  797.         if ( TIFF )
  798.             return TIF_select(wfp);
  799.         else if ( NOTBAK )
  800.             return 7;
  801.         else if ( x <= (WLX + 16) && y <= (WLY + 16) )
  802.             return 1;
  803.         else if ( x >= (WRX - 16) && y >= (WRY - 16) )
  804.             return 2;
  805.         else if ( x >= (WRX - 16) && y <= (WLY + 16) )
  806.             return 3;
  807.         else if ( x >= (WRX - 18) )
  808.             return 4;
  809.         else if ( y <= (WLY + 20) )
  810.             return 5;
  811.         else if ( x < (WRX - 16) && y >= (WRY - 20) )
  812.             return 6;
  813.         return 7;
  814.     } else if ( (b & 2) != 0 && topwfp != NULL ) {
  815.         for ( p=n=topwfp ; p != NULL ; n=p,p=p->wd_forwfp );
  816.         if ( WIN_activ(n) == 0 )
  817.             return (-1);    
  818.     }
  819.     return 0;
  820. }
  821. WINDFP    *WIN_allevent(ev)
  822. int        *ev;
  823. {
  824.     WINDFP    *wfp;
  825.  
  826.     wfp = topwfp;
  827.     while ( wfp != NULL ) {
  828.         if ( (*ev = WIN_event(wfp)) != 0 )
  829.             return wfp;
  830.         wfp = wfp->wd_forwfp;
  831.     }
  832.     return NULL;
  833. }
  834. int        WIN_select(WINDFP *wfp,int ev)
  835. {
  836.     switch(ev) {
  837.         case 0: return FALSE;
  838.         case 1: WIN_close(wfp); break;
  839.         case 2: WIN_size(wfp); break;
  840.         case 3: WIN_subcom(wfp); break;
  841.         case 4: WIN_seek(wfp); break;
  842.         case 5: WIN_move(wfp); break;
  843.         case 6: WIN_xseek(wfp); break;
  844.     }
  845.     return TRUE;
  846. }
  847. void    WIN_allselect(void)
  848. {
  849.     int        i,b,x,y;
  850.     WINDFP    *dmy;
  851.  
  852.     while ( topwfp != NULL ) {
  853.         if ( (dmy = WIN_allevent(&i)) != NULL )
  854.             WIN_select(dmy,i);
  855.     }
  856. }
  857.