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