home *** CD-ROM | disk | FTP | other *** search
/ FreeWare Collection 2 / FreeSoftwareCollection2pd199x-jp.img / look / src / look.c < prev    next >
Text File  |  1990-06-14  |  13KB  |  566 lines
  1. /*************************************************
  2.  
  3.     File Selecter Program
  4.  
  5. *************************************************/
  6. #include    <stdio.h>
  7. #include    <stdlib.h>
  8. #include    <strings.h>
  9. #include    <mos.h>
  10.  
  11. #define    SHORT    short int
  12. #define    ULONG    unsigned long int
  13.  
  14. #define    TRUE    0
  15. #define    FALSE    1
  16. #define    ERR        (-1)
  17.  
  18. #define    M_PSET        0
  19. #define    M_PRESET    1
  20. #define    M_OR        2
  21. #define    M_AND        3
  22. #define    M_XOR        4
  23. #define    M_NOT        5
  24. #define    M_MATTE        6
  25. #define    M_PASTEL    7
  26.  
  27. #define C_HWHITE     15
  28. #define C_HYELLOW    14
  29. #define C_HLIGHTBLUE 13
  30. #define C_HGREEN     12
  31. #define C_HPURPLE    11
  32. #define C_HRED       10
  33. #define C_HBLUE       9
  34. #define C_HBLACK      8
  35. #define C_WHITE       7
  36. #define C_YELLOW      6
  37. #define C_LIGHTBLUE   5
  38. #define C_GREEN       4
  39. #define C_PURPLE      3
  40. #define C_RED         2
  41. #define C_BLUE        1
  42. #define C_BLACK       0
  43.  
  44. #define    FORCOL        15
  45. #define    BAKCOL        8
  46.  
  47. typedef struct {
  48.     SHORT    wb_dsp;
  49.     SHORT   wb_att;
  50.     SHORT   wb_time,wb_date;
  51.     ULONG   wb_size;
  52.     char    wb_name[14];
  53. } WCBUF;
  54.  
  55. typedef struct wdtmp {
  56.     SHORT    wd_mode;
  57.     SHORT    wd_lx, wd_ly;
  58.     SHORT    wd_rx, wd_ry;
  59.     char    *wd_img;
  60.     struct    wdtmp *wd_forwfp;
  61.     struct    wdtmp *wd_nxtwfp;
  62. } WINDFP;
  63.  
  64. extern void grainit(void);
  65. extern void graend(void);
  66. extern void    line(int x1,int y1,int x2,int y2,int col,int mode);
  67. extern void    box(int x1,int y1,int x2,int y2,int col,int mode);
  68. extern void    fbox(int x1,int y1,int x2,int y2,int col,int bcol,int mode);
  69. extern void    wrtptn(char *ptn,int x,int y,int sx,int sy,int col,int bak);
  70. extern void    wrtstr(char *str,int x,int y,int font,int ccol,int bcol);
  71. extern void    wrtmos(int sw);
  72. extern int    mosclip(int sw,int x,int y);
  73. extern int  WC_open(char *dir,char *wild);
  74. extern char *subname(char *name);
  75. extern int  retdir(char *dir);
  76. extern int  drvsts(int no);
  77.  
  78. extern int        wcmax;
  79. extern WCBUF    *topwcp;
  80. extern char        diskptn[];
  81. extern char        exitptn[];
  82. extern char        subptn[];
  83. extern char        lftptn[];
  84. extern char        ritptn[];
  85. extern char        *work;
  86.  
  87. int        ofx=0,ofy=0,dspoff=0;
  88. int        wd=1,lx=10,ly=5,rx=630,ry=475;
  89.  
  90. static SHORT    maxdrv=0;
  91. static SHORT    rdydrv[20],dspdrv[20];
  92. static int        fs_x1=0,fs_y1=0,fs_x2=0,fs_y2=0;
  93. static int        fs_dx=0,fs_dy=0,fs_ds;
  94. static int        fs_drv=0;
  95. static int        fs_off=0;
  96. static char        fs_dir[80];
  97. static WINDFP    *fsfp;    
  98.  
  99. void    MOS_getpos(sw,x,y)
  100. int        *sw,*x,*y;
  101. {
  102.     int        cgx=0,cgy=0;
  103.  
  104.     MOS_rdpos(sw,x,y);
  105.     if ( *x > (ofx + 640) )
  106.         ofx = *x - 640;
  107.     else if ( *x < ofx )
  108.         ofx = *x;
  109.     else
  110.         cgx = 1;
  111.  
  112.     if ( *y > (ofy + 480) )
  113.         ofy = *y - 480;
  114.     else if ( *y < ofy )
  115.         ofy = *y;
  116.     else
  117.         cgy = 1;
  118.  
  119.     if ( cgx != 0 || cgy != 0 ) {
  120.         EGB_writePage(work,1);
  121.         EGB_displayStart(work,1,ofx,(ofy + dspoff) & (512 - 1));
  122.         EGB_writePage(work,0);
  123.         EGB_displayStart(work,1,ofx,ofy);
  124.     }
  125. }
  126. void    drvset(void)
  127. {
  128.     int        i;
  129.  
  130.     for ( i = maxdrv = 0 ; i < 20 ; i++ ) {
  131.         if ( drvsts(i) == 0 ) {
  132.             dspdrv[i] = maxdrv;
  133.             rdydrv[maxdrv++] = i;
  134.         }
  135.     }
  136. }
  137. void    FS_dspdrv(int drv,int mode)
  138. {
  139.     int        n,x,y,fcol,bcol;
  140.  
  141.     n = dspdrv[drv];
  142.     if ( mode == 0 ) {
  143.         fcol = FORCOL; bcol = BAKCOL;
  144.     } else {
  145.         bcol = FORCOL; fcol = BAKCOL;
  146.     }
  147.     x = fs_dx + (n % 5) * 64;
  148.     y = fs_y1 + 26 + (n / 5) * 16;
  149.     wrtstrf(x,y,0,fcol,bcol,"%c:",'A'+drv);
  150.     wrtptn(diskptn,x+16,y,32,16,fcol,bcol);    
  151. }
  152. void    FS_dspfile(int no)
  153. {
  154.     int        i,fcol,bcol;
  155.  
  156.     if ( no >= wcmax || no < fs_off || no >= (fs_off + 27) )
  157.         return;
  158.  
  159.     if ( topwcp[no].wb_dsp == 0 ) {
  160.         fcol = FORCOL; bcol = BAKCOL;
  161.     } else {
  162.         bcol = FORCOL; fcol = BAKCOL;
  163.     }        
  164.  
  165.     i = no - fs_off;
  166.     wrtstr(subname(topwcp[no].wb_name),
  167.            fs_dx + (i / 9) * 106, fs_dy + 32 + (i % 9) * 16,
  168.            (topwcp[no].wb_att & 0x10) != 0 ? 1 : 0,
  169.            fcol,bcol);
  170. }
  171. void    FS_alldsp(int off)
  172. {
  173.     int        i,j,k;
  174.  
  175.     fbox(fs_dx, fs_dy + 32, fs_x2 - 4, fs_y2 - 22,
  176.          BAKCOL,BAKCOL,M_PSET);
  177.     fs_off = off;
  178.     for ( i = 0 ; i < 27 ; i++ )
  179.         FS_dspfile(off + i);
  180.  
  181.     if ( wcmax == 0 ) {
  182.         j = 0; k = 285;
  183.     } else {
  184.         i = (285 * 9) / wcmax;
  185.         j = (fs_off / 9) * i;
  186.         if ( (k = j + 3 * i) > 285 )
  187.             k = 285;
  188.     }
  189.     fbox(fs_x1+19,fs_y2-18,fs_x1+308,fs_y2-3,FORCOL,BAKCOL,M_PSET);
  190.     box(fs_x1+21+j,fs_y2-16,fs_x1+21+k,fs_y2-5,FORCOL,M_PSET);
  191. }
  192. void    FS_cngdrv(char *dir,char *wild)
  193. {
  194.     int        x,y;
  195.     char    tmp[80];
  196.  
  197.     wrtmos(1);
  198.     x = fs_dx + (dspdrv[fs_drv] % 5) * 64 + 21;
  199.     y = fs_y1 + (dspdrv[fs_drv] / 5) * 16 + 36;
  200.     box(x,y,x+1,y+1,C_HRED,M_PSET);
  201.     sprintf(tmp,"%c:%s",'A'+fs_drv,dir);
  202.     WC_open(tmp,wild);
  203.     fs_drv = retdir(fs_dir);
  204.     fbox(fs_dx,fs_dy+8,fs_x2 - 8,fs_dy+24,BAKCOL,BAKCOL,M_PSET);
  205.     wrtstr(fs_dir,fs_dx,fs_dy+8,0,FORCOL,BAKCOL);
  206.     FS_alldsp(0);
  207.     box(x,y,x+1,y+1,BAKCOL,M_PSET);
  208.     wrtmos(0);
  209. }
  210. void    FS_open(int dx, int dy)
  211. {
  212.     int        i;
  213.  
  214.     if ( maxdrv == 0 )
  215.         drvset();
  216.     fs_ds = ((maxdrv + 4) / 5) * 16;
  217.     fs_x1 = dx & 0xfffe; 
  218.     fs_y1 = dy & 0xfffe;
  219.     fs_x2 = fs_x1 + 328;
  220.     fs_y2 = fs_y1 + 224 + fs_ds;
  221.  
  222.     fs_dx = fs_x1 + 8;
  223.     fs_dy = fs_y1 + 26 + fs_ds;
  224.  
  225.     fbox(fs_x1,fs_y1,fs_x2,fs_y2,FORCOL,BAKCOL,M_PSET);
  226.     fbox(fs_x1+2,fs_y1+2,fs_x2-2,fs_y1+20,FORCOL,FORCOL,M_PSET);
  227.     wrtstr("FILE SELECTER",fs_x1+112,fs_y1+3,1,BAKCOL,FORCOL);
  228.     wrtptn(subptn,fs_x2-20,fs_y1+3,16,16,BAKCOL,FORCOL);
  229.     wrtptn(exitptn,fs_dx,fs_y1+3,16,16,BAKCOL,FORCOL);
  230.     line(fs_x1,fs_dy+4,fs_x2,fs_dy+4,FORCOL,M_PSET);
  231.     line(fs_x1,fs_dy+28,fs_x2,fs_dy+28,FORCOL,M_PSET);
  232.     wrtptn(lftptn,fs_x1+2,fs_y2-18,16,16,FORCOL,BAKCOL);
  233.     wrtptn(ritptn,fs_x2-18,fs_y2-18,16,16,FORCOL,BAKCOL);
  234.     fsfp = (WINDFP *)WIN_dmyopen(fs_x1,fs_y1,fs_x2,fs_y2);
  235.  
  236.     fs_drv = retdir(fs_dir);
  237.     for ( i = 0 ; i < maxdrv ; i++ )
  238.         FS_dspdrv(rdydrv[i],(rdydrv[i] == fs_drv ? 1 : 0));
  239.     FS_cngdrv("","*.*");
  240. }
  241. void    FS_drvsel(void)
  242. {
  243.     int        old,i,b,x,y;
  244.  
  245.     old = dspdrv[fs_drv];
  246.     do {
  247.         MOS_rdpos(&b,&x,&y);
  248.         i = (x - fs_dx) / 64 + ((y - fs_y1 - 26) / 16) * 5;
  249.         if ( i >= 0 && i < maxdrv ) {
  250.             if ( old != i ) {
  251.                 FS_dspdrv(rdydrv[old],0);
  252.                 FS_dspdrv(rdydrv[i],1);
  253.                 old = i;
  254.             }
  255.         }
  256.     } while ( b != 0 );
  257.     if ( old != fs_drv ) {
  258.         fs_drv = rdydrv[old];
  259.         FS_cngdrv("","*.*");
  260.     }
  261. }
  262. void    FS_dspdir(int len)
  263. {
  264.     char    tmp[80];
  265.  
  266.     if ( len > 0 ) {
  267.         strcpy(tmp,fs_dir);
  268.         tmp[len] = '\0';
  269.         wrtstr(tmp,fs_dx,fs_dy+8,0,BAKCOL,FORCOL);
  270.     }
  271.     wrtstr(fs_dir+len,fs_dx + len * 8,fs_dy+8,0,FORCOL,BAKCOL);
  272. }
  273. void    FS_dirsel(void)
  274. {
  275.     int        len,old,i,b,x,y;
  276.  
  277.     len = strlen(fs_dir);
  278.     i = old = 0;
  279.     do {
  280.         MOS_rdpos(&b,&x,&y);
  281.         if ( y >= (fs_dy + 8) && y <= (fs_dy + 24) &&
  282.              x >= fs_dx && x <= (fs_dx + len * 8) ) {
  283.             i = (x - fs_dx) / 8;
  284.             while ( fs_dir[i] != '\0' && fs_dir[i] != '\\' )
  285.                 i++;
  286.             if ( fs_dir[i] == '\\' ) i++;
  287.         } else
  288.             i = 0;
  289.         if ( i != old ) {
  290.             FS_dspdir(i);
  291.             old = i;
  292.         }
  293.     } while ( b != 0 );
  294.     if ( old > 2 ) {
  295.         if ( old > 3 && fs_dir[old] != '\0' )
  296.             old--;
  297.         fs_dir[old] = '\0';
  298.         FS_cngdrv(fs_dir+2,"*.*");
  299.     }
  300. }
  301. void    FS_newwind(int no)
  302. {
  303.     int        i,b,x,y;
  304.     int        x1,y1,x2,y2;
  305.     int        sx1,sy1,sx2,sy2;
  306.  
  307.     wrtmos(2);
  308.     i = no - fs_off;
  309.     x1 = fs_dx + (i / 9) * 106; y1 = fs_dy + 32 + (i % 9) * 16;
  310.     x2 = x1 + 96; y2 = y1 + 15;
  311.  
  312.     MOS_getpos(&b,&x,&y);
  313.     sx1 = x - x1; sy1 = y - y1;
  314.     do {
  315.         box(x1,y1,x2,y2,15,M_XOR);
  316.         MOS_getpos(&b,&x,&y);
  317.         box(x1,y1,x2,y2,15,M_XOR);
  318.         x -= sx1; y -= sy1;
  319.         if ( x >= 0 ) x1 = x; else x1 = 0;
  320.         if ( y >= 0 ) y1 = y; else y1 = 0;
  321.         x2 = x1 + 96; y2 = y1 + 15;
  322.         if ( x2 >= 1024 ) { x1 = 926; x2 = 1023; }
  323.         if ( y2 >= 512 ) { y1 = 496; y2 = 511; }
  324.     } while ( b == 0 );
  325.  
  326.     if ( (b & 2) != 0 ) goto ABORT;
  327.     if ( (lx = x1 - 102) < 0 ) lx = 0;
  328.     if ( (ly = y1 - 50 ) < 0 ) ly = 0;
  329.     if ( (rx = lx + 300) >= 1024 ) { lx = 723; rx = 1023; }
  330.     if ( (ry = ly + 200) >= 512 ) { ly = 311; ry = 511; }
  331.  
  332.     sx1 = (lx - x1) / 10; sy1 = (ly - y1) / 10;
  333.     sx2 = (rx - x2) / 10; sy2 = (ry - y2) / 10;
  334.  
  335.     for ( i = 10 ; i > 0 ; i-- ) {
  336.         box(x1,y1,x2,y2,15,M_XOR);
  337.         box(x1,y1,x2,y2,15,M_XOR);
  338.         x1 += sx1; y1 += sy1;
  339.         x2 += sx2; y2 += sy2;
  340.     }
  341.     wrtmos(1);
  342.     if ( WIN_open(topwcp[no].wb_name,topwcp[no].wb_name,
  343.                   topwcp[no].wb_size,0,lx,ly,rx,ry,
  344.                   C_HWHITE, C_HBLACK, C_HWHITE) == 0 )
  345.         MSG_disp("Can't open Text Wind...",C_HRED);
  346. ABORT:
  347.     wrtmos(0);
  348. }
  349. void    FS_filesel(void)
  350. {
  351.     int        old,i,b,x,y;
  352.     char    *p;
  353.  
  354.     old = wcmax;
  355.     do {
  356.         MOS_rdpos(&b,&x,&y);        
  357.         i = ((x - fs_dx) / 106) * 9 + (y - fs_dy - 32) /16;
  358.         if ( y >= (fs_dy + 32 ) && y <= (fs_dy + 176) &&
  359.              i >= 0 && i < (wcmax - fs_off) ) {
  360.             i += fs_off;
  361.             if ( old != i ) {
  362.                 if ( old < wcmax ) {
  363.                     topwcp[old].wb_dsp = 0;
  364.                     FS_dspfile(old);
  365.                 }
  366.                 if ( topwcp[i].wb_dsp != 0 )
  367.                     topwcp[i].wb_dsp = 0;
  368.                 else
  369.                     topwcp[i].wb_dsp = 1;
  370.                 FS_dspfile(i);
  371.                 old = i;
  372.             }
  373.         } else if ( old < wcmax ) {
  374.             topwcp[old].wb_dsp = 0;
  375.             FS_dspfile(old);
  376.             old = wcmax;
  377.         }
  378.     } while ( b != 0 );
  379.  
  380.     if ( old < wcmax ) {
  381.         topwcp[old].wb_dsp = 0;
  382.         FS_dspfile(old);
  383.         if ( (topwcp[old].wb_att & 0x10) != 0 )
  384.             FS_cngdrv(topwcp[old].wb_name,"*.*");
  385.         else {
  386.             p = subname(topwcp[old].wb_name);
  387.             if ( strcmp(p+9,"SND") == 0 )
  388.                 runsnd(topwcp[old].wb_name);
  389.             else if ( strcmp(p+9,"EUP") == 0 )
  390.                 runeup(topwcp[old].wb_name);
  391.             else
  392.                 FS_newwind(old);
  393.         }
  394.     }
  395. }
  396. void    FS_dspmov(int old,int fra,int bak)
  397. {
  398.     if ( old > fs_off )
  399.         wrtptn(lftptn,fs_x1+2,fs_y2-18,16,16,fra,bak);
  400.     else
  401.         wrtptn(ritptn,fs_x2-18,fs_y2-18,16,16,fra,bak);
  402. }
  403. void    FS_movesel()
  404. {
  405.     int        old,b,x,y;
  406.  
  407.     old = fs_off;
  408.     MOS_rdpos(&b,&x,&y);        
  409.     if ( x >= fs_x1 && x <= fs_x2 && 
  410.          y >= (fs_y2 - 20) && y <= (fs_y2 - 4) ) {
  411.         if ( x <= (fs_x1 + 24) && fs_off > 0 )
  412.             fs_off -= 9;
  413.         else if ( x >= (fs_x2 - 24) && (fs_off + 27) <= wcmax )
  414.             fs_off += 9;
  415.         if ( old != fs_off ) {
  416.             FS_dspmov(old,BAKCOL,FORCOL);
  417.             FS_alldsp(fs_off);
  418.             FS_dspmov(old,FORCOL,BAKCOL);
  419.             old = fs_off;
  420.         }
  421.     }
  422. }
  423. void    FS_resize(void)
  424. {
  425.     fs_x1 = fsfp->wd_lx;
  426.     fs_y1 = fsfp->wd_ly;
  427.     fs_x2 = fs_x1 + 328;
  428.     fs_y2 = fs_y1 + 224 + fs_ds;
  429.     fs_dx = fs_x1 + 8;
  430.     fs_dy = fs_y1 + 26 + fs_ds;
  431. }
  432. int        FS_finis(void)
  433. {
  434.     static char *menu[]={ "CLOSE ALL WIND","END OF LOOKING",NULL };
  435.     int        i;
  436.  
  437. /*    wrtptn(exitptn,fs_dx,fs_y1+3,16,16,FORCOL,BAKCOL); */
  438.     i = MENU_select(menu);
  439. /*    wrtptn(exitptn,fs_dx,fs_y1+3,16,16,BAKCOL,FORCOL); */
  440.     if ( i == 1 )
  441.         return (-1);
  442.     else if ( i == 0 )
  443.         WIN_allclose(fsfp);
  444.     return 0;
  445. }
  446. void    FS_fremem(void)
  447. {
  448.     int        mx,sz,fm;
  449.     char    *dmy[128];
  450.     char    tmp[80];
  451.  
  452.     for ( sz = 0x10000,fm = mx = 0 ; mx < 128 ; mx++ ) {
  453.         while ( (dmy[mx] = malloc(sz)) == NULL ) {
  454.             if ( (sz /= 2) < 0x1000 )
  455.                 break;
  456.         }
  457.         if ( dmy[mx] == NULL )
  458.             break;
  459.         fm += sz;
  460.     }
  461.     while ( mx > 0 )
  462.         free(dmy[--mx]);
  463.     sprintf(tmp,"%dK Byte Free Memory",fm / 1000);
  464.     MSG_disp(tmp,C_HGREEN);
  465. }
  466. void    FS_sub(void)
  467. {
  468.     static char *menu[]={ "FREE MEMORY","WILD CARD",NULL };
  469.     static char *wmenu[]={ "*.*",  "TEXT","SUND","GRPH",NULL };
  470.     static char *wildt[]={ "*.*",  "*.DOC","*.HLP","*.BAT",
  471.                            "*.C",  "*.ASM","*.LST","*.TXT",NULL };
  472.     static char *wilds[]={ "*.EUP","*.SND","*.FMB","*.PMB",NULL };
  473.     static char *wildg[]={ "*.TIF","*.GRP","*.GIF","*.GED","*.FIG",
  474.                            "*.PIC","*.P16","*.P25","*.P32",NULL };
  475.     int        i;
  476.     char    *p;
  477.  
  478. /*    wrtptn(subptn,fs_x2-20,fs_y1+3,16,16,FORCOL,BAKCOL); */
  479.     i = MENU_select(menu);
  480.     if ( i == 0 )
  481.         FS_fremem();
  482.     else if ( i == 1 && (i = MENU_select(wmenu)) >= 0 ) {
  483.         switch(i) {
  484.             case 0: p = wmenu[0]; break;
  485.             case 1:
  486.                 if ( (i = MENU_select(wildt)) >= 0 ) 
  487.                     p = wildt[i];
  488.                 break;
  489.             case 2:
  490.                 if ( (i = MENU_select(wilds)) >= 0 )
  491.                     p = wilds[i];
  492.                 break;
  493.             case 3:
  494.                 if ( (i = MENU_select(wildg)) >= 0 )
  495.                     p = wildg[i];
  496.                 break;
  497.         }
  498.         if ( i >= 0 )
  499.             FS_cngdrv("",p);
  500.     }
  501. /*    wrtptn(subptn,fs_x2-20,fs_y1+3,16,16,BAKCOL,FORCOL); */
  502. }
  503. int        FS_select(void)
  504. {
  505.     int        b,x,y;
  506.  
  507.     MOS_rdpos(&b,&x,&y);
  508.     if ( b != 0 && x >= fs_x1 && x <= fs_x2 && 
  509.                    y >= fs_y1 && y <= fs_y2 ) {
  510.         if ( y >= (fs_y1 + 26) && y <= fs_dy )
  511.             FS_drvsel();
  512.         else if ( y >= (fs_dy + 8) && y <= (fs_dy + 24) )
  513.             FS_dirsel();
  514.         else if ( y >= (fs_dy + 32) && y <= (fs_dy + 176) )
  515.             FS_filesel();
  516.         else if ( y >= (fs_y2 - 20) && y <= (fs_y2 - 4) )
  517.             FS_movesel();
  518.         else if ( x <= (fs_x1 + 20) && y <= (fs_y1 + 20) )
  519.             return FS_finis();
  520.         else if ( x >= (fs_x2 - 20) && y <= (fs_y1 + 20) )
  521.             FS_sub();
  522.         else if ( y <= (fs_y1 + 20) ) {
  523.             WIN_move(fsfp);
  524.             FS_resize();
  525.         } else
  526.             return 1;
  527.     }
  528.     return 0;
  529. }
  530. /***********************************************************/
  531. /***********************************************************/
  532. void    main(int argc,char *argv[])
  533. {
  534.     int        i,b,x,y,ev;
  535.     WINDFP    *dmy;
  536.  
  537.     grainit();
  538.     if ( argc > 1 ) {
  539.         y = 470 / (argc - 1);
  540.         while ( --argc > 0 ) {
  541.             argv++;
  542.             WIN_open(argv[0],argv[0],16384,0,lx,ly,rx,ly+y,
  543.                      C_HWHITE, C_HBLACK, C_HWHITE);
  544.         }
  545.         WIN_allselect();
  546.     } else {
  547.         FS_open(10,180);
  548.         for ( ; ; ) {
  549.             MOS_getpos(&b,&x,&y);
  550.             if ( (dmy = (WINDFP *)WIN_allevent(&ev)) != NULL ) {
  551.                 if ( ev == (-1) )
  552.                     MSG_disp("Memory Full Error !!",C_HRED);
  553.                 else if ( dmy == fsfp ) {
  554.                     if ( FS_select() == (-1) )
  555.                         break;
  556.                 } else
  557.                     WIN_select(dmy,ev);
  558.             }
  559.         }
  560.     }
  561.     fbox(220,190,440,290,C_LIGHTBLUE,C_HBLACK,M_PSET);
  562.     wrtstr("ＬＯＯＫを終了しました",244,220,0,C_LIGHTBLUE,C_HBLACK);
  563.     wrtstr("しばらくお待ちください｡",244,250,0,C_LIGHTBLUE,C_HBLACK);
  564.     graend();
  565. }
  566.