home *** CD-ROM | disk | FTP | other *** search
/ Amiga Elysian Archive / AmigaElysianArchive.iso / wp_dtp / tpp400en.lha / tpp / pd / MSClock23.lzh / MSClock / source / MSClock.c < prev    next >
C/C++ Source or Header  |  1991-08-05  |  16KB  |  395 lines
  1. /*
  2.  *    MSClock.c        © by Martin Steppler
  3.  *
  4.  *    Yet another clock utility for use with L:MSClock-Handler
  5.  *
  6.  *    last change: 05.08.91
  7.  */
  8.  
  9. // defines
  10.  
  11. #define WriteStdOut(str) Write(StdOut, str, (LONG)strlen(str))
  12. #define LOGNAME "S:MSClock.log"
  13. #define PROCNAME "MSClock2.3"
  14.  
  15. // prototypes
  16.  
  17. VOID  main(int, char **);
  18. int   GetOverscan(VOID);
  19. UWORD htoin(register char *str);
  20.  
  21. // globals
  22.  
  23. struct IntuitionBase *IntuitionBase;
  24. struct TheClock      *TheClock;
  25. struct TextFont      *Font;
  26.  
  27. // here we go ...
  28.  
  29. void
  30. main(argc, argv)
  31. int argc;
  32. char *argv[];
  33. {
  34.    register struct Process *ThatsMe = (struct Process *)FindTask(NULL);
  35.    LONG DefFlag = 39; // display time, date, online time and mem
  36.    SHORT i, quit=0, help=0, log=0;
  37.    // we spent in 360 seconds 23 pfennings
  38.    // in the interval during which charges are low we spent 23 pfennigs in 720 secs
  39.    SHORT interval=360, unit=23, cinterval = 720;
  40.    // low charges interval from 18h to 8h
  41.    SHORT LCStart = 18, LCEnd = 8;
  42.    // default hotkeys: RIGHT ALT + DEL, RIGHT ALT + HELP, RIGHT (ALT+SHIFT) + DEL
  43.    UWORD DCode = 0x0046, DQualif = 0x0020, SCode = 0x005F, SQualif = 0x0020,
  44.          JCode = 0x0041, JQualif = 0x0020;
  45.    // default viewmode: view all
  46.    BYTE  v=0, GadWidth;
  47.    BPTR StdOut = (BPTR)Open((UBYTE *)"*", MODE_OLDFILE);
  48.    LONG flag = 0;
  49.  
  50.  
  51.       // open libraries
  52.  
  53.       // check for OS2.0  / VERSION 36 or higher
  54.  
  55.    if(!(IntuitionBase = (struct IntuitionBase *)OpenLibrary((UBYTE *)"intuition.library", 36))) {
  56.       if(!(IntuitionBase = (struct IntuitionBase *)OpenLibrary((UBYTE *)"intuition.library",0))) {
  57.          goto abort;
  58.       }
  59.       else GadWidth = FRONTBACKGAD_WIDTH;
  60.    }
  61.    else GadWidth = FBGAD_WIDTH_NEW_OS;
  62.  
  63.    // Is the TheClock structure anywhere?
  64.  
  65.    if(TheClock = (struct TheClock *)FindPort((UBYTE *)PORTNAME)) DefFlag = TheClock->Flags;
  66.    for (i = 1; i < argc; i++) {
  67.       if(!strcmp(argv[i], "quit") || !strcmp(argv[i], "-q")) {
  68.          quit = 1;
  69.          break;
  70.       }
  71.       else if(!strcmp(argv[i], "-t"))  { DefFlag = (DefFlag & TIME_FLAG)       ? (DefFlag & (SUM_FLAG - TIME_FLAG))       :(DefFlag | TIME_FLAG);       }
  72.       else if(!strcmp(argv[i], "-d"))  { DefFlag = (DefFlag & DATE_FLAG)       ? (DefFlag & (SUM_FLAG - DATE_FLAG))       :(DefFlag | DATE_FLAG);       }
  73.       else if(!strcmp(argv[i], "-m"))  { DefFlag = (DefFlag & MEMORY_FLAG)     ? (DefFlag & (SUM_FLAG - MEMORY_FLAG))     :(DefFlag | MEMORY_FLAG);     }
  74.       else if(!strcmp(argv[i], "-e"))  { DefFlag = (DefFlag & ENGLISH_FLAG)    ? (DefFlag & (SUM_FLAG - ENGLISH_FLAG))    :(DefFlag | ENGLISH_FLAG);    }
  75.       else if(!strcmp(argv[i], "-r"))  { DefFlag = (DefFlag & REVERSE_FLAG)    ? (DefFlag & (SUM_FLAG - REVERSE_FLAG))    :(DefFlag | REVERSE_FLAG);    }
  76.       else if(!strcmp(argv[i], "-o"))  { DefFlag = (DefFlag & ONLINE_FLAG)     ? (DefFlag & (SUM_FLAG - ONLINE_FLAG))     :(DefFlag | ONLINE_FLAG);     }
  77.       else if(!strcmp(argv[i], "-h"))  { DefFlag = (DefFlag & HOLIDAY_FLAG)    ? (DefFlag & (SUM_FLAG - HOLIDAY_FLAG))    :(DefFlag | HOLIDAY_FLAG);    }
  78.       else if(!strcmp(argv[i], "-s"))  { DefFlag = (DefFlag & START_STOP_FLAG) ? (DefFlag & (SUM_FLAG - START_STOP_FLAG)) :(DefFlag | START_STOP_FLAG); }
  79.       else if(!strcmp(argv[i], "-nl")) { DefFlag = (DefFlag & NO_LOGFILE_FLAG) ? (DefFlag & (SUM_FLAG - NO_LOGFILE_FLAG)) :(DefFlag | NO_LOGFILE_FLAG); }
  80.       else if(!strcmp(argv[i], "-ns")) { DefFlag = (DefFlag & NO_SECONDS_FLAG) ? (DefFlag & (SUM_FLAG - NO_SECONDS_FLAG)) :(DefFlag | NO_SECONDS_FLAG); }
  81.       else if(!strcmp(argv[i], "-aj")) { DefFlag = (DefFlag & AUTO_JUMP_FLAG)  ? (DefFlag & (SUM_FLAG - AUTO_JUMP_FLAG))  :(DefFlag | AUTO_JUMP_FLAG);  }
  82.       else if(!strcmp(argv[i], "-u")) {
  83.          if(i+1 < argc) {
  84.             unit = atoi(argv[++i]);
  85.             if(unit>=1 || unit<=99) flag |= 1;
  86.             else unit = 23;
  87.          }
  88.          else help = 1;
  89.       }
  90.       // interval
  91.       else if(!strcmp(argv[i], "-i")) {
  92.          if(i+1 < argc) {
  93.             interval = atoi(argv[++i]);
  94.             if(interval>=1 && interval <=1000) flag |= 2;
  95.             else interval = 360;
  96.          }
  97.          else help = 1;
  98.       }
  99.       // low charges interval
  100.       else if(!strcmp(argv[i], "-c")) {
  101.          if(i+1 < argc) {
  102.             cinterval = atoi(argv[++i]);
  103.             if(cinterval>=1 && cinterval <=1000) flag |= 4;
  104.             else cinterval = 720;
  105.          }
  106.          else help = 1;
  107.       }
  108.       // view mode
  109.       else if(!strcmp(argv[i], "-v")) {
  110.          if(i+1 < argc) {
  111.             v = atoi(argv[++i]);
  112.             if(v<0 || v >3) v=0;
  113.             else flag |= 512;
  114.          }
  115.          else help = 1;
  116.       }
  117.       // change display code
  118.       else if(!strcmp(argv[i], "-dc")) {
  119.          if(i+1 < argc) {
  120.             DCode = htoin(argv[++i]);
  121.             if(DCode <=255) flag |= 8;
  122.             else DCode = 0x0046;
  123.          }
  124.          else help = 1;
  125.       }
  126.       // change display qualifier
  127.       else if(!strcmp(argv[i], "-dq")) {
  128.          if(i+1 < argc) {
  129.             DQualif = htoin(argv[++i]);
  130.             if(DQualif <=255) flag |= 16;
  131.             else DQualif = 0x0020;
  132.          }
  133.          else help = 1;
  134.       }
  135.       // start/stop counter code
  136.       else if(!strcmp(argv[i], "-sc")) {
  137.          if(i+1 < argc) {
  138.             SCode = htoin(argv[++i]);
  139.             if(SCode<=255) flag |= 32;
  140.             else SCode = 0x005F;
  141.          }
  142.          else help = 1;
  143.       }
  144.       // start/stop counter qualifier
  145.       else if(!strcmp(argv[i], "-sq")) {
  146.          if(i+1 < argc) {
  147.             SQualif = htoin(argv[++i]);
  148.             if(SQualif<=255) flag |= 64;
  149.             else SQualif=0x0020;
  150.          }
  151.          else help = 1;
  152.       }
  153.       // start of low charges interval
  154.       else if(!strcmp(argv[i], "-cs")) {
  155.          if(i+1 < argc) {
  156.             LCStart = atoi(argv[++i]);
  157.             if(LCStart>=0 && LCStart <=24) flag |= 128;
  158.             else LCStart = 18;
  159.          }
  160.          else help = 1;
  161.       }
  162.       // end of low charges interval
  163.       else if(!strcmp(argv[i], "-ce")) {
  164.          if(i+1 < argc) {
  165.             LCEnd = atoi(argv[++i]);
  166.             if(LCEnd>=0 && LCEnd <=24) LCEnd |= 256;
  167.             else LCEnd=8;
  168.          }
  169.          else help = 1;
  170.       }
  171.       // jump to next screen code
  172.       else if(!strcmp(argv[i], "-jc")) {
  173.          if(i+1 < argc) {
  174.             JCode = htoin(argv[++i]);
  175.             if(JCode<=255) flag |= 1024;
  176.             else JCode = 0x0046;
  177.          }
  178.          else help = 1;
  179.       }
  180.       // jump to next screen qualifier
  181.       else if(!strcmp(argv[i], "-jq")) {
  182.          if(i+1 < argc) {
  183.             JQualif = htoin(argv[++i]);
  184.             if(JQualif<=255) flag |= 2048;
  185.             else JQualif=0x0022;
  186.          }
  187.          else help = 1;
  188.       }
  189.       // change name of logfile
  190.       else if(!strcmp(argv[i], "-l")) {
  191.          if(++i < argc) log=i;
  192.          else help = 1;
  193.       }
  194.       else { help = 1; break; }
  195.    }
  196.    if(help && StdOut) {
  197.        WriteStdOut("\33[33mMSClock V2.3\33[31m © 05.08.91 by Martin Steppler\n");
  198.        WriteStdOut("USAGE:  MSClock {<flag> [<value>]}\n");
  199.        WriteStdOut("  -t            Time   off/on                 default: on\n");
  200.        WriteStdOut("  -d            Date   off/on                 default: on\n");
  201.        WriteStdOut("  -m            Memory off/on                 default: on\n");
  202.        WriteStdOut("  -e            English weekdays on/off       default: German on\n");
  203.        WriteStdOut("  -r            Reverse date display on/off   default: off\n");
  204.        WriteStdOut("  -o            Online time off/on            default: on\n");
  205.        WriteStdOut("  -s            Start/stop counter            default: off\n");
  206.        WriteStdOut("  -h            Holiday on/off                default: off\n");
  207.        WriteStdOut("  -u 1-99       Unit spent in one interval    default: 23\n");
  208.        WriteStdOut("  -i 1-1000     Interval in seconds           default: 360\n");
  209.        WriteStdOut("  -c 1-1000     interval in seconds during    default: 720\n");
  210.        WriteStdOut("                which Charges are low\n");
  211.        WriteStdOut("  -cs 0-24      low Charges Start (0-24 h)    default: 18 h\n");
  212.        WriteStdOut("  -ce 0-24      low Charges End   (0-24 h)    default:  8 h\n");
  213.        WriteStdOut("  -dq Qual      Display Qualifier             default: 20 (RIGHT ALT)\n");
  214.        WriteStdOut("  -dc Code      Display Code                  default: 46 (DEL)\n");
  215.        WriteStdOut("  -sq Qual      Start/stop counter Qualifier  default: 20 (RIGHT ALT)\n");
  216.        WriteStdOut("  -sc Code      Start/stop counter Code       default: 5F (HELP)\n");
  217.        WriteStdOut("  -jq Qual      Jump to active screen Qual.   default: 20 (RIGHT ALT)\n");
  218.        WriteStdOut("  -jc Code      Jump to active screen Code    default: 41 (BS)\n");
  219.        WriteStdOut("  -aj           Auto-Jump to active screen    default: off\n");
  220.        WriteStdOut("  -l T:MyLog    use MyLog as logfile          default: S:MSClock.log\n");
  221.        WriteStdOut("  -nl           do Not use any Logfile        default: off\n");
  222.        WriteStdOut("  -ns           do Not display Seconds        default: off\n");
  223.        WriteStdOut("  -v 0-3        Viewmodes 0-3 all/t+d/m/o     default: 0\n");
  224.        WriteStdOut("  -q            Quit MSClock\n");
  225.    }
  226.    else if(!TheClock && !quit) {
  227.  
  228.                // No, then Create Process
  229.  
  230.       if(TheClock = (struct TheClock *)AllocMem(sizeof(struct TheClock),MEMF_PUBLIC | MEMF_CLEAR)) {
  231.  
  232.                // Dummy MessagePort.
  233.  
  234.          TheClock -> Port . mp_Flags         = PA_IGNORE;
  235.          TheClock -> Port . mp_Node . ln_Pri = 0;
  236.          TheClock -> Port . mp_Node . ln_Type= NT_MSGPORT;
  237.          TheClock -> Port . mp_Node . ln_Name= AllocMem(sizeof(PORTNAME),MEMF_PUBLIC);
  238.  
  239.                // initialize TheClock structure
  240.  
  241.          TheClock -> Child                   = NULL;
  242.          TheClock -> Father                  = (struct Task *)ThatsMe;
  243.          TheClock -> SegSize                 = sizeof(struct TheClock);
  244.          TheClock -> LastSecs                = 100;
  245.          TheClock -> OverScan                = GetOverscan();
  246.          TheClock -> Online                  = FALSE;
  247.          TheClock -> Flags                   = DefFlag;
  248.          TheClock -> FlagsBackup             = DefFlag;
  249.          TheClock -> Unit                    = unit;
  250.          TheClock -> Interval                = interval;
  251.          TheClock -> CInterval               = cinterval;
  252.          TheClock -> HotKeyCode              = DCode;
  253.          TheClock -> HotKeyQualif            = DQualif;
  254.          TheClock -> StartStopCode           = SCode;
  255.          TheClock -> StartStopQualif         = SQualif;
  256.          TheClock -> JumpCode                = JCode;
  257.          TheClock -> JumpQualif              = JQualif;
  258.          TheClock -> LowChargesStart         = LCStart;
  259.          TheClock -> LowChargesEnd           = LCEnd;
  260.          TheClock -> Viewmodes               = v;
  261.          TheClock -> ModesBackup             = v;
  262.          TheClock -> FBGadWidth              = GadWidth;
  263.          TheClock -> Font                    = Font;
  264.          if(log) strcpy(TheClock->Logfile, argv[log]);
  265.          else    strcpy(TheClock->Logfile, LOGNAME);
  266.  
  267.                // Init port.
  268.  
  269.          strcpy(TheClock -> Port . mp_Node . ln_Name,PORTNAME);
  270.          NewList(&TheClock -> Port . mp_MsgList);
  271.  
  272.                // Load the handler code.
  273.  
  274.          if(!(TheClock -> Segment = LoadSeg((UBYTE *)"MSClock-Handler")))
  275.             TheClock -> Segment = LoadSeg((UBYTE *)"L:MSClock-Handler");
  276.          if(!TheClock -> Segment)
  277.          {
  278.             FreeMem(TheClock -> Port . mp_Node . ln_Name,sizeof(PORTNAME));
  279.             FreeMem(TheClock,TheClock -> SegSize);
  280.             if(StdOut)  WriteStdOut("Installation of \33[33mMartin Steppler's Clock V2.3\33[31m failed. Don't panic!!!\n");
  281.          }
  282.          else
  283.          {
  284.                // Install the port and start the handler.
  285.  
  286.             AddPort(&TheClock -> Port);
  287.             CreateProc((UBYTE *)PROCNAME, 5,TheClock -> Segment,4096);
  288.  
  289.                // Wait for child task to ring back...
  290.  
  291.             Wait(CHILD_READY);
  292.             if(!TheClock -> Child)  // failed
  293.             {
  294.                RemPort(&TheClock -> Port);
  295.                FreeMem(TheClock -> Port . mp_Node . ln_Name,sizeof(PORTNAME));
  296.                if(TheClock -> Segment) UnLoadSeg(TheClock -> Segment);
  297.                FreeMem(TheClock,TheClock -> SegSize);
  298.                if(StdOut)  WriteStdOut("Installation of \33[33mMartin Steppler's Clock V2.3\33[31m failed. Don't panic!\n");
  299.             }
  300.             else             // Yeah, it works
  301.                if(StdOut)  WriteStdOut("It is my pleasure to install \33[33mMartin Steppler's Clock V2.3\33[31m for you!\n");
  302.          }
  303.       }
  304.    }
  305.    else if(TheClock && quit) {
  306.       TheClock -> Father = (struct Task *)ThatsMe;
  307.       Signal(TheClock -> Child,SIG_CLOSE);
  308.       Wait(CHILD_READY);
  309.  
  310.          // Remove port and associated data.
  311.  
  312.       RemPort(&TheClock -> Port);
  313.       FreeMem(TheClock -> Port . mp_Node . ln_Name,sizeof(PORTNAME));
  314.       if(TheClock -> Segment) UnLoadSeg(TheClock -> Segment);
  315.       FreeMem(TheClock,TheClock -> SegSize);
  316.       if(StdOut) {
  317.          WriteStdOut("It is my satisfaction to close \33[33mMartin Steppler's Clock V2.3\33[31m again\n");
  318.          WriteStdOut("with the knowledge of a job well done!\n");
  319.       }
  320.    }
  321.    else if(TheClock) {
  322.  
  323.       // store changes and signal child
  324.  
  325.       TheClock->FlagsBackup = DefFlag;
  326.       TheClock->OverScan = GetOverscan();
  327.       TheClock->ModesBackup = TheClock->Viewmodes;
  328.       if(flag & 1)    TheClock -> Unit              = unit;
  329.       if(flag & 2)    TheClock -> Interval          = interval;
  330.       if(flag & 4)    TheClock -> CInterval         = cinterval;
  331.       if(flag & 8)    TheClock -> HotKeyCode        = DCode;
  332.       if(flag & 16)   TheClock -> HotKeyQualif      = DQualif;
  333.       if(flag & 32)   TheClock -> StartStopCode     = SCode;
  334.       if(flag & 64)   TheClock -> StartStopQualif   = SQualif;
  335.       if(flag & 128)  TheClock -> LowChargesStart   = LCStart;
  336.       if(flag & 256)  TheClock -> LowChargesEnd     = LCEnd;
  337.       if(flag & 512)  TheClock -> ModesBackup       = v;
  338.       if(flag & 1024) TheClock -> JumpCode          = JCode;
  339.       if(flag & 2048) TheClock -> JumpQualif        = JQualif;
  340.       if(log) strcpy(TheClock->Logfile, argv[log]);
  341.       TheClock -> Father = (struct Task *)ThatsMe;
  342.       Signal(TheClock -> Child, SIG_CHANGE);
  343.       Wait(CHILD_READY);
  344.       if(StdOut) {
  345.          WriteStdOut("It is my satisfaction to change \33[33mMartin Steppler's Clock V2.3\33[31m for you\n");
  346.          WriteStdOut("with the knowledge of a job well done!\n");
  347.       }
  348.    }
  349. abort:
  350.    if(StdOut)          Close(StdOut);
  351.    if(IntuitionBase)   CloseLibrary((struct Library *)IntuitionBase);
  352. }
  353.  
  354. GetOverscan(void)
  355. {
  356.    register struct Screen *WBench;
  357.    register ULONG IntuiLock;
  358.  
  359.            // Start with the first one.
  360.  
  361.    IntuiLock = LockIBase(0L);
  362.    WBench = IntuitionBase -> FirstScreen;
  363.    UnlockIBase(IntuiLock);
  364.  
  365.            // Scan the list...
  366.    do
  367.    {
  368.            // The type we want?
  369.  
  370.       if((WBench -> Flags & SCREENTYPE) == WBENCHSCREEN) {
  371.          Font = WBench -> RastPort . Font;
  372.          return(WBench -> Width);
  373.       }
  374.    }
  375.    while(WBench = WBench -> NextScreen);
  376.  
  377.            // Failed!
  378.  
  379.    return(640);
  380. }
  381.  
  382. // HEX --> UWORD
  383. UWORD
  384. htoin(register char *str)
  385. {
  386.     REGISTER UWORD val = 0;
  387.     REGISTER char c;
  388.     while (c = *str) {
  389.         val <<= 4;
  390.         val |= (c & 15) + (isdigit(c) ? 0 : 9);
  391.         str++;
  392.     }
  393.     return(val);
  394. }
  395.