home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / APPS / dm.lzh / diskmaster.c < prev    next >
C/C++ Source or Header  |  1995-11-14  |  18KB  |  484 lines
  1. /* DISKMASTER v1.0                            */
  2. /* copyright (c) 1995 by Bob Devries          */
  3. /* email: bdevries@gil.ipswichcity.qld.gov.au */
  4.  
  5. #include <stdio.h>
  6. #include <dir.h>
  7. #include <sgstat.h>
  8. #include "screen.h"
  9. #include "diskmaster.h"
  10. /* added mouse here */
  11. #include "mspak.h"
  12. int mouse;     /* global mouse var */
  13. /* end mouse here */
  14.  
  15. int clsflag;
  16.  
  17. struct sgbuf buff;
  18. char orig_echo;
  19. char orig_eofch;
  20. char orig_kbich;
  21. char orig_kbach;
  22.  
  23. main(argc,argv)
  24. int argc;
  25. char *argv[];
  26. {
  27.        int useflag = 0;
  28.        int tdly, filecount,success;
  29.        int filepos,startpos, newpos;
  30.        char dirname[80];
  31.        char userdir[256];
  32.        char newdir[256];
  33.        char *getcwd();
  34.        extern char **nameptr;
  35.        extern char *buffer;
  36.        extern short *attrptr;
  37.        
  38.        int c;
  39.        int ch;
  40.        int quit = 0;
  41.        int tagged = 0;
  42.        extern char *optarg;
  43.        extern int optind;
  44.        
  45.        clsflag = 0;
  46.        filepos = 0;
  47.        startpos = 0;
  48.        stdout->_flag |= _UNBUF;
  49.        stdin->_flag |= _UNBUF;
  50.        strcpy(dirname,".");
  51.        while ((c = getopt(argc, argv, "h?cd:")) != EOF)
  52.               switch (c) {
  53.                       case 'h':
  54.                       case '?':
  55.                                useflag++;
  56.                                break;
  57.                       case 'd':
  58.                                strcpy(dirname,optarg);
  59.                                break;
  60.                       case 'c':
  61.                                clsflag++;
  62.                                break;
  63.                       default:
  64.                                useflag++;
  65.                                break;
  66.               }
  67.        if (useflag) {
  68.               usage();
  69.               exit(0);
  70.        }
  71.        
  72.        /* start main programme here */
  73.  
  74.  
  75.        clearscreen();
  76.        opts();
  77. /* mouse added here */
  78.        mouse = MsOpen("/mouse");
  79.        if(!mouse) {
  80.               MsMnMxX(1,80);
  81.               MsMnMxY(1,24);
  82.               MsSetPos(40,12);
  83.               MsSetSns(20,20);
  84.               MsSetPol(1,-1);
  85.               MsSetDbl(200,200);
  86.        }
  87. /* end mouse here */
  88.        foreground(WHITE);
  89.        background(BLUE);
  90.        if(mouse) {
  91.               box_doub(30,10,21,5);
  92.        } else {
  93.               box_doub(30,10,21,6);
  94.        }
  95.        gotoxy(31,11);
  96.        printf("  DiskMaster v%d.%d  ",VER,REV);
  97.        gotoxy(31,12);
  98.        printf(" Copyright(c) 1995 ");
  99.        gotoxy(31,13);
  100.        printf("  by Bob Devries   ");
  101.        if(!mouse) {
  102.               gotoxy(31,14);
  103.               printf("  Mouse  Detected  ");
  104.        }
  105.        gotoxy(1,24);
  106.        getcwd(userdir,255);
  107.        chdir(dirname);
  108.        getcwd(newdir,255);
  109.        mainscreen(newdir);
  110.        filecount = dirread(dirname);
  111.        showfiles(filecount,startpos,filepos,REDO);
  112.        
  113.        while (!quit) {
  114. /* added mouse here */
  115.               ch = '\0';
  116.               do {
  117.                      if(_gs_rdy(STDIN) > 0) {
  118.                             ch = getchar();
  119.                             flush_kbd();
  120.                      } else {
  121.                             if(!mouse) {
  122.                                    newpos = filepos - startpos;
  123.                                    readmouse(&newpos,&ch);
  124.                                    if(newpos + startpos != filepos) {
  125.                                           filepos = newpos + startpos;
  126.                                           showfiles(filecount,startpos,filepos,REDO);
  127.                                    }
  128.                             }
  129.                      }
  130.                } while (ch == '\0');
  131. /* end mouse here */
  132. /*              ch=getchar(); */ /* removed for mouse working */
  133.               switch (ch) {
  134.                      case '\n':
  135.                                success = changedir(dirname,filepos);
  136.                                if(success == FAIL) break;
  137.                                getcwd(newdir,255);
  138.                                horiz_doub(2,23,78);
  139.                                gotoxy(48,23);
  140.                                putc(DBOT_TEE,stdout);
  141.                                gotoxy(3,23);
  142.                                printf(" %s ",newdir);
  143.                                freeram();
  144.                                filecount = dirread(dirname);
  145.                                clearwin(2,3,28,20);
  146.                                filepos = 0;
  147.                                startpos = 0;
  148.                                tagged = 0;
  149.                                showfiles(filecount,startpos,filepos,REDO);
  150.                                break;
  151.                      case 'c':
  152.                                 if(tagged) {
  153.                                           multicopy(filecount);
  154.                                           showfiles(filecount,startpos,filepos,REDO);
  155.                                           tagged = 0;
  156.                                           break;
  157.                                 }
  158.                                success = copy(filepos);
  159.                                if(success == PASS) {
  160.                                       freeram();
  161.                                       freedev();
  162.                                       filecount = dirread(dirname);
  163.                                       showfiles(filecount,startpos,filepos,REDO);
  164.                                }
  165.                                break;
  166.                      case 'd':
  167.                                 if(tagged) {
  168.                                           multidel(filecount);
  169.                                           filecount = dirread(dirname);
  170.                                           if(filepos > filecount) {
  171.                                                  filepos = filecount;
  172.                                                  startpos = (filecount/MAXCNT)*MAXCNT;
  173.                                           }
  174.                                           clearwin(2,3,28,20);
  175.                                            showfiles(filecount,startpos,filepos,REDO);
  176.                                           tagged = 0;
  177.                                           freedev();
  178.                                           break;
  179.                                 }
  180.                                success = delete(filepos);
  181.                                if(success == PASS) {
  182.                                       freeram();
  183.                                       freedev();
  184.                                       filecount = dirread(dirname);
  185.                                       if(filepos > filecount) {
  186.                                              filepos = filecount;
  187.                                              startpos = (filecount/MAXCNT)*MAXCNT;
  188.                                       }
  189.                                       clearwin(2,3,28,20);
  190.                                       showfiles(filecount,startpos,filepos,REDO);
  191.                                }
  192.                                break;
  193.                      case 'm':
  194.                                success = makedir();
  195.                                if(success == PASS) {
  196.                                       freeram();
  197.                                       freedev();
  198.                                       filecount = dirread(dirname);
  199.                                       showfiles(filecount,startpos,filepos,REDO);
  200.                                }
  201.                                break;
  202.                      case 'o':
  203.                                if(tagged) {
  204.                                          multimove(filecount);
  205.                                          filecount = dirread(dirname);
  206.                                          if(filepos > filecount) {
  207.                                                  filepos = filecount;
  208.                                                  startpos = (filecount/MAXCNT)*MAXCNT;
  209.                                          }
  210.                                          clearwin(2,3,28,20);
  211.                                          showfiles(filecount,startpos,filepos,REDO);
  212.                                         tagged = 0;
  213.                                         break;
  214.                                }
  215.                                success = move(filepos,NULL);
  216.                                if(success == PASS) {
  217.                                       freeram();
  218.                                       freedev();
  219.                                       filecount = dirread(dirname);
  220.                                       if(filepos > filecount) {
  221.                                               filepos = filecount;
  222.                                               startpos = (filecount/MAXCNT)*MAXCNT;
  223.                                       }
  224.                                       clearwin(2,3,28,20);
  225.                                       showfiles(filecount,startpos,filepos,REDO);
  226.                                }
  227.                                break;
  228.                      case 'a':
  229.                                if(tagged) {
  230.                                          multiattr(filecount);
  231.                                          showfiles(filecount,startpos,filepos,REDO);
  232.                                         tagged = 0;
  233.                                         break;
  234.                                }
  235.                                attr(filepos);
  236.                                break;
  237.                      case 'r':
  238.                                success = renfile(filepos);
  239.                                if(success == PASS) {
  240.                                       clearwin(2,3,28,20);
  241.                                       showfiles(filecount,startpos,filepos,REDO);
  242.                                }
  243.                                break;
  244.                      case 't':
  245.                                tagfile(filepos,&tagged);
  246.                                showfiles(filecount,startpos,filepos,TAG);
  247.                                 if(++filepos > filecount) {
  248.                                           filepos--;
  249.                                           break;
  250.                                 }
  251.                                 if(filepos - startpos < MAXCNT) {
  252.                                     showfiles(filecount,startpos,filepos,DOWN);
  253.                                  } else {
  254.                                            startpos += MAXCNT;
  255.                                            clearwin(2,3,28,20);
  256.                                            showfiles(filecount,startpos,filepos,REDO);
  257.                                  }
  258.                                break;
  259.                      case '\x14':            /* CTRL-T tags ALL files */
  260.                                 multitag(filecount, &tagged);
  261.                                 showfiles(filecount,startpos,filepos,REDO);
  262.                                 break;
  263.                      case 'l':
  264.                                gotoxy(48,2);
  265.                                putc(DHORZ_BAR,stdout);
  266.                                clearwin(2,3,78,20);
  267.                                gotoxy(48,23);
  268.                                putc(DHORZ_BAR,stdout);
  269.                                gotoxy(80,15);
  270.                                putc(DVERT_BAR,stdout);
  271.                                list(filepos);
  272.                                mainscreen(newdir);
  273.                                freedev();
  274.                                showfiles(filecount,startpos,filepos,REDO);
  275.                                break;
  276.                      case 'q':
  277.                                quit++;
  278.                                break;
  279.                      case 'h':
  280.                                gotoxy(48,2);
  281.                                putc(DHORZ_BAR,stdout);
  282.                                clearwin(2,3,78,20);
  283.                                gotoxy(48,23);
  284.                                putc(DHORZ_BAR,stdout);
  285.                                gotoxy(80,15);
  286.                                putc(DVERT_BAR,stdout);
  287.                                list(HELP);
  288.                                mainscreen(newdir);
  289.                                showfiles(filecount,startpos,filepos,REDO);
  290.                                break;
  291.                      case 'n':
  292.                                if(logdev(dirname) == FAIL) break;
  293.                                success = changedir(dirname,-1);
  294.                                if(success == FAIL) break;
  295.                                getcwd(newdir,255);
  296.                                gotoxy(2,23);
  297.                                horiz_doub(2,23,78);
  298.                                gotoxy(48,23);
  299.                                putc(DBOT_TEE,stdout);
  300.                                gotoxy(3,23);
  301.                                printf(" %s ",newdir);
  302.                                freeram();
  303.                                freedev();
  304.                                filecount = dirread(dirname);
  305.                                clearwin(2,3,28,20);
  306.                                filepos = 0;
  307.                                startpos = 0;
  308.                                tagged = 0;
  309.                                showfiles(filecount,startpos,filepos,REDO);
  310.                                break;
  311.                      case 'u':
  312.                                success = unarc(filepos);
  313.                                if(success == PASS) {
  314.                                       freeram();
  315.                                       freedev();
  316.                                       filecount = dirread(dirname);
  317.                                       showfiles(filecount,startpos,filepos,REDO);
  318.                                }
  319.                                break;
  320.                      case 's':
  321.                                 clearscreen();
  322.                                 cleanup();
  323.                                 printf("Type 'logout' to return to DiskMaster\n");
  324.                                 system("-p=DM:");
  325.                                 opts();
  326.                                 foreground(WHITE);
  327.                                 background(BLUE);
  328.                                 mainscreen(newdir);
  329.                                 showfiles(filecount,startpos,filepos,REDO);
  330.                                 break;
  331.                      case ' ':
  332.                      case DA:
  333.                                if(++filepos > filecount) {
  334.                                       filepos--;
  335.                                       break;
  336.                                }
  337.                                if(filepos - startpos < MAXCNT) {
  338.                                       showfiles(filecount,startpos,filepos,DOWN);
  339.                                } else {
  340.                                       startpos += MAXCNT;
  341.                                       clearwin(2,3,28,20);
  342.                                       showfiles(filecount,startpos,filepos,REDO);
  343.                                }
  344.                                break;
  345.                      case BS:
  346.                      case UA:
  347.                                if(filepos - startpos > MINCNT) {
  348.                                       filepos--;
  349.                                       showfiles(filecount,startpos,filepos,UP);
  350.                                } else {
  351.                                       if(startpos > 0) {
  352.                                              startpos -= MAXCNT;
  353.                                              filepos--;
  354.                                              showfiles(filecount,startpos,filepos,REDO);
  355.                                        }
  356.                                }
  357.                                break;
  358.                      case HOME:        /* also Ctrl-A */
  359.                                filepos = startpos;
  360.                                showfiles(filecount,startpos,filepos,REDO);
  361.                                break;
  362.                      case END:         /* also Ctrl-E */
  363.                                filepos = startpos + MAXCNT - 1;
  364.                                if(filepos > filecount) filepos = filecount;
  365.                                showfiles(filecount,startpos,filepos,REDO);
  366.                                break;
  367.                      case PgUp:        /* also Ctrl-Z */
  368.                                filepos = startpos - MAXCNT;
  369.                                startpos -= MAXCNT;
  370.                                if(filepos < MINCNT) {
  371.                                       filepos = MINCNT;
  372.                                       startpos = MINCNT;
  373.                                }
  374.                                showfiles(filecount,startpos,filepos,REDO);
  375.                                break;
  376.                      case PgDn:        /* also Ctrl-V */
  377.                                filepos = startpos + MAXCNT;
  378.                                startpos += MAXCNT;
  379.                                if(filepos > filecount) {
  380.                                       filepos = filecount;
  381.                                       startpos -= MAXCNT;
  382.                                }
  383.                                clearwin(2,3,28,20);
  384.                                showfiles(filecount,startpos,filepos,REDO);
  385.                                break;
  386.                }
  387.        }
  388.        free(nameptr);
  389.        free(attrptr);
  390.        free(buffer);
  391.        chdir(userdir);
  392.        cleanup();
  393. }
  394.  
  395. mainscreen(newdir)
  396. char *newdir;
  397. {
  398.        clearscreen();
  399.        gotoxy(32,1);
  400.        printf("Disk Master v%d.%d",VER,REV);
  401.        box_doub(1,2,80,22);
  402.        info_screen();
  403.        gotoxy(48,15);
  404.        putc(DLFT_TEE,stdout);
  405.        gotoxy(80,15);
  406.        putc(DRIT_TEE,stdout);
  407.        horiz_doub(49,15,31);
  408.        gotoxy(56,17);
  409.        printf("Current disk info");
  410.        freedev();
  411.        commands();
  412.        gotoxy(3,23);
  413.        printf(" %s ",newdir);
  414. }
  415.  
  416. usage()
  417. {
  418.        fprintf(stderr,"Usage: DiskMaster [-c] [-d<dir name>]\n");
  419.        fprintf(stderr,"       -c don't clear screen on exit\n");
  420.        fprintf(stderr,"       dir name is initial directory\n");
  421. }
  422.  
  423. echo(state)    /* change the echo state */
  424. char state;
  425. {
  426.        buff.sg_echo = (char) state;
  427.        _ss_opt(STDOUT,&buff);
  428. }
  429.  
  430. freeram()
  431. {
  432.        extern char *buffer;
  433.        extern char **nameptr;
  434.        extern short *attrptr;
  435.        extern char *fildesbuf;
  436.        extern char **fildesptr;
  437.        free(buffer);
  438.        free(nameptr);
  439.        free(attrptr);
  440.        free(fildesbuf);
  441.        free(fildesptr);
  442. }
  443.  
  444. opts()
  445. {
  446.        _gs_opt(STDOUT,&buff);
  447.        orig_echo = buff.sg_echo;
  448.        orig_eofch = buff.sg_eofch;
  449.        orig_kbich = buff.sg_kbich;
  450.        orig_kbach = buff.sg_kbach;
  451.        buff.sg_eofch = (char)0;
  452.        buff.sg_kbich = (char)0;
  453.        buff.sg_kbach = (char)0;
  454.        _ss_opt(STDOUT,&buff);
  455.        echo(OFF);
  456. }
  457.  
  458. cleanup()
  459. {
  460.     foreground(WHITE);
  461.     background(BLACK);
  462.     echo(orig_echo);
  463.     buff.sg_eofch = orig_eofch;
  464.     buff.sg_kbich = orig_kbich;
  465.     buff.sg_kbach = orig_kbach;
  466.     _ss_opt(STDOUT,&buff);
  467.     if(!clsflag) {
  468.         clearscreen();
  469.     } else {
  470.         gotoxy(1,24);
  471.     }
  472. }
  473.  
  474. flush_kbd()
  475. {
  476.     int ch;
  477.     
  478.     while(_gs_rdy(STDIN) > 0) {
  479.         ch = getchar();
  480.     }
  481. }
  482.  
  483. /* EOF diskmaster.c */
  484.