home *** CD-ROM | disk | FTP | other *** search
/ Amiga Elysian Archive / AmigaElysianArchive.iso / wp_dtp / tpp400en.lha / tpp / pd / MSClock23.lzh / MSClock / source / MSClock-Handler.c < prev    next >
C/C++ Source or Header  |  1991-08-10  |  19KB  |  507 lines
  1. /*
  2.  *    MSClock-Handler.c        © by Martin Steppler
  3.  *
  4.  *    last change: 05.08.91
  5.  */
  6.  
  7. // prototypes
  8.  
  9. int   GetWidth(LONG DefFlag);
  10.  
  11. // interrupt register saving functions
  12. VOID int_start(VOID);
  13. VOID int_end(VOID);
  14. struct InputEvent *myhandler(struct InputEvent *ev);
  15.  
  16. // reference to the absolute address of ciab
  17. extern struct CIA ciab;
  18.  
  19. // pragma for my interrupt handler
  20. #pragma regcall(myhandler(a0))
  21.  
  22. // globals
  23. char                  DateBuf[100];
  24. struct IntuiText      TextPrint    = { 0,1,JAM2,0,0,NULL,(UBYTE *)DateBuf,NULL};
  25. struct NewWindow      ClockWindow  = { 146,1,432,8,1,0,EOS, BORDERLESS, NULL,NULL,EOS,NULL,NULL,0,0,0,0,WBENCHSCREEN};
  26. struct Window        *Window=NULL;
  27. struct IntuitionBase *IntuitionBase=NULL;
  28. struct GfxBase       *GfxBase=NULL;
  29. struct DosLibrary    *DosBase=NULL;
  30. struct TheClock      *TheClock;
  31. struct MsgPort       *inputDevPort=NULL;
  32. struct IOStdReq      *inputRequestBlock=NULL;
  33. struct Interrupt     *handlerStuff=NULL;
  34. LONG                  DisplaySig = -1, JumpSig = -1;
  35.  
  36.  
  37. // this is my interrupt handler
  38.  
  39. struct InputEvent *
  40. myhandler(struct InputEvent *ev)
  41. {
  42.    register struct InputEvent *ep;
  43.  
  44.    // preserve registers
  45.    int_start();
  46.  
  47.    // run down the list of events to see if they pressed the magic buttons
  48.    for (ep = ev; ep != NULL; ep = ep->ie_NextEvent) {
  49.       if((ep->ie_Class == IECLASS_RAWKEY) &&
  50.         (ep->ie_Qualifier & TheClock->JumpQualif) &&
  51.         (!((ep->ie_Qualifier & TheClock->JumpQualif) ^ TheClock->JumpQualif)) &&
  52.         (ep->ie_Code == TheClock->JumpCode)) {
  53.  
  54.          ep -> ie_Class = IECLASS_NULL;
  55.  
  56.          // now tell myself to jump to the next screen
  57.          if(TheClock->Child) Signal(TheClock->Child, SIG_JUMP);
  58.  
  59.          // switch auto-jump to active screen off
  60.          if(TheClock->Flags & AUTO_JUMP_FLAG) {
  61.             TheClock->FlagsBackup &= (SUM_FLAG - AUTO_JUMP_FLAG);
  62.             Signal(TheClock->Child, SIG_CHANGE);
  63.          }
  64.       }
  65.       else if((ep->ie_Class == IECLASS_RAWKEY) &&
  66.         (ep->ie_Qualifier & TheClock->HotKeyQualif) &&
  67.         (!((ep->ie_Qualifier & TheClock->HotKeyQualif) ^ TheClock->HotKeyQualif)) &&
  68.         (ep->ie_Code == TheClock->HotKeyCode)) {
  69.  
  70.          ep -> ie_Class = IECLASS_NULL;
  71.  
  72.          // now tell myself to change the view mode
  73.          if(TheClock->Child) Signal(TheClock->Child, SIG_NEWMODE);
  74.       }
  75.       else if((ep->ie_Class == IECLASS_RAWKEY) &&
  76.          (ep->ie_Qualifier & TheClock->StartStopQualif) &&
  77.          (!((ep->ie_Qualifier & TheClock->StartStopQualif) ^ TheClock->StartStopQualif)) &&
  78.          (ep->ie_Code == TheClock->StartStopCode)) {
  79.  
  80.          ep -> ie_Class = IECLASS_NULL;
  81.  
  82.          // now tell myself to start/stop the counter
  83.          Signal(TheClock->Child, SIG_COUNTER);
  84.       }
  85.    }
  86.  
  87.    // refresh the time display ?
  88.    if(ev -> ie_TimeStamp . tv_secs != TheClock -> LastSecs) {
  89.       TheClock -> LastSecs = ev -> ie_TimeStamp . tv_secs;
  90.  
  91.       // now tell myself to refresh the display
  92.       if(TheClock->Child) Signal(TheClock->Child, SIG_DISPLAY);
  93.    }
  94.  
  95.    // restore registers
  96.    int_end();
  97.  
  98.    // pass on the pointer to the event
  99.    return(ev);
  100. }
  101.  
  102. //  _main():
  103. //             no CLI/WB parsing 8-)
  104.  
  105. LONG
  106. _main()
  107. {
  108.    register struct Process *ThatsMe = (struct Process *)FindTask(NULL);
  109.    register ULONG           SignalSet;
  110.    char TempBuf[100];
  111.    char *Days[14]={ "Son","Mon","Die","Mit","Don","Fre","Sam",
  112.                     "Sun","Mon","Tue","Wed","Thu","Fri","Sat" };
  113.    struct DateStamp Date;
  114.    LONG n,eng,Month,Day,Year,chip_free,fast_free,hh=0,mm=0,ss=0,lastsec=-1;
  115.    LONG i, dm=0, pf=0, dmt=0, pft=0, interval=0, Today, mins, hours, secs;
  116.    BYTE failed=1;
  117.    BPTR file;
  118.  
  119.       // If somebody called us from CLI...
  120.  
  121.    if(ThatsMe -> pr_CLI) return(10);
  122.  
  123.       // Is the TheClock structure anywhere?
  124.  
  125.    if(!(TheClock = (struct TheClock *)FindPort((UBYTE *)PORTNAME))) {
  126.       Forbid();
  127.       Signal(TheClock -> Father, CHILD_READY);
  128.       return(10);
  129.    }
  130.  
  131.    TheClock->Child = (struct Task *)ThatsMe;
  132.  
  133.    // open libraries
  134.  
  135.    if(IntuitionBase = (struct IntuitionBase *)OpenLibrary((UBYTE *)"intuition.library",0)) {
  136.       if(GfxBase = (struct GfxBase *)OpenLibrary((UBYTE *)"graphics.library",0)) {
  137.          if(DosBase = (struct DosLibrary *)OpenLibrary((UBYTE *)"dos.library",0)) {
  138.             if((DisplaySig = AllocSignal(-1)) != -1) {
  139.                if((JumpSig = AllocSignal(-1)) != -1) {
  140.                   // install input handler
  141.                   if(handlerStuff = (struct Interrupt *)AllocMem(sizeof(struct Interrupt), MEMF_PUBLIC)) {
  142.                      if((inputDevPort = (struct MsgPort *)CreatePort(NULL,0L)) != NULL) {
  143.                         if(inputRequestBlock = (struct IOStdReq *)CreateStdIO(inputDevPort)) {
  144.                            if(OpenDevice((UBYTE *)"input.device",0L,(struct IORequest *)inputRequestBlock,0L) == 0) {
  145.                               handlerStuff->is_Node.ln_Name = "MSClock-Input-Handler";
  146.                               handlerStuff->is_Node.ln_Pri  = 51;
  147.                               handlerStuff->is_Code         = (VOID *)myhandler;
  148.                               inputRequestBlock->io_Command = IND_ADDHANDLER;
  149.                               inputRequestBlock->io_Data    = (APTR)handlerStuff;
  150.                               DoIO((struct IORequest *)inputRequestBlock);
  151.  
  152.                               // everything worked *fine*
  153.  
  154.                               failed = 0;
  155.                            }
  156.                         }
  157.                      }
  158.                   }
  159.                }
  160.             }
  161.          }
  162.       }
  163.    }
  164.  
  165.    // this is the end of the world as we know it ...
  166.  
  167.    if(failed) goto abort;
  168.  
  169.    // ... but I feel fine 8-)
  170.  
  171.    TheClock -> Status = 1;
  172.  
  173.    // read in the amount of telephone charges that have been spent so far
  174.    if(file=(BPTR)Open((UBYTE *)TheClock->Logfile, MODE_OLDFILE)) {
  175.       Seek(file, -8, OFFSET_END);
  176.       i=Read(file, TempBuf, 20);
  177.       Close(file);
  178.       if(i>=8) {
  179.          i = strlen(TempBuf)-2; n=1;
  180.          if(isdigit(TempBuf[i]) && isdigit(TempBuf[i-1])) {
  181.             pft = TempBuf[i] - '0' + 10 * (TempBuf[i-1] - '0');
  182.             i-=3;
  183.          }
  184.          while(i && isdigit(TempBuf[i])) {
  185.             dmt += (TempBuf[i] - '0') * n;
  186.             n*=10; i--;
  187.          }
  188.       }
  189.    }
  190.  
  191.    // Go into infinite loop waiting for signals.
  192.  
  193.    FOREVER
  194.    {
  195.  
  196.       // switch clock on
  197.  
  198.       if(TheClock -> Status == 1) {
  199.          TheClock -> Status = 2;
  200.          switch(TheClock->Viewmodes) {
  201.             case 0:
  202.                TheClock -> Width    = GetWidth(TheClock->Flags);
  203.                ClockWindow.LeftEdge = TheClock -> OverScan - TheClock->Width - TheClock->FBGadWidth;
  204.                ClockWindow.Width    = TheClock -> Width;
  205.                break;
  206.             case 1:
  207.                if((TheClock->Flags) & (NO_SECONDS_FLAG)) {
  208.                   ClockWindow.LeftEdge = TheClock -> OverScan - TheClock->FBGadWidth - (SHORT_TIME_WIDTH + DATE_WIDTH) * TheClock->Font->tf_XSize;
  209.                   ClockWindow.Width    = (SHORT_TIME_WIDTH + DATE_WIDTH) * TheClock->Font->tf_XSize;
  210.                }
  211.                else {
  212.                   ClockWindow.LeftEdge = TheClock -> OverScan - TheClock->FBGadWidth - (TIME_WIDTH + DATE_WIDTH) * TheClock->Font->tf_XSize;
  213.                   ClockWindow.Width    = (TIME_WIDTH + DATE_WIDTH) * TheClock->Font->tf_XSize;
  214.                }
  215.                break;
  216.             case 2:
  217.                ClockWindow.LeftEdge = TheClock -> OverScan - TheClock->FBGadWidth - LONG_MEM_WIDTH * TheClock->Font->tf_XSize;
  218.                ClockWindow.Width    = LONG_MEM_WIDTH * TheClock->Font->tf_XSize;
  219.                break;
  220.             case 3:
  221.                ClockWindow.LeftEdge = TheClock -> OverScan - TheClock->FBGadWidth - ONLINE_WIDTH * TheClock->Font->tf_XSize;
  222.                ClockWindow.Width    = ONLINE_WIDTH * TheClock->Font->tf_XSize;
  223.                break;
  224.          }
  225.  
  226.          ClockWindow.Height = TheClock->Font->tf_YSize;
  227.  
  228.          if(Window=(struct Window *) OpenWindow(&ClockWindow)) {
  229.             SetFont(Window->RPort, TheClock->Font);
  230.             SetAPen(Window->RPort, 1);
  231.             RectFill(Window->RPort, 0, 0, (LONG)Window->Width, (LONG)Window->Height);
  232.             TheClock->Status = 0;
  233.          }
  234.       }
  235.  
  236.       // show mem, date, online-time and/or time
  237.  
  238.       if(!TheClock->Status) {
  239.  
  240.          chip_free = AvailMem(MEMF_CHIP);
  241.          fast_free = AvailMem(MEMF_FAST);
  242.          DateStamp((struct DateStamp *)&Date) ;
  243.          n = Date.ds_Days - 2251;
  244.          Year = (4 * n + 3) / 1461;
  245.          n -= 1461 * Year / 4;
  246.          Year += 1984;
  247.          Month = (5 * n + 2) / 153;
  248.          Day = n - (153 * Month + 2) / 5 + 1;
  249.          Month += 3;
  250.          hours = Date.ds_Minute/60;
  251.          mins  = Date.ds_Minute%60;
  252.          secs  = Date.ds_Tick/TICKS_PER_SECOND;
  253.          n=TheClock->Flags;
  254.  
  255.          // partial display ?
  256.          if(TheClock->Viewmodes) {
  257.             // filter all unneeded flags
  258.             n &= (SUM_FLAG - ONLINE_FLAG - MEMORY_FLAG - DATE_FLAG - TIME_FLAG);
  259.          }
  260.  
  261.          if(Month>12) { Year++; Month -= 12; }
  262.          Today = (Day + Year + (Year - (Month < 3)) / 4 + 3 * Month - 2 * (Month > 2) - (Month - 1 - (Month > 8)) / 2 + 2) % 7;
  263.          DateBuf[0]=EOS;
  264.  
  265.          // Check port a of cia b. Is there a carrier?
  266.          // Is '-s' flag set ?
  267.  
  268.          // Online ?
  269.  
  270.          if(!(ciab . ciapra & CIAF_COMCD) || (n & START_STOP_FLAG))
  271.          {
  272.             if(!TheClock -> Online) {
  273.                // Time reset
  274.                dm=hh=mm=ss=0;
  275.                pf = TheClock -> Unit;
  276.                if((pft = pft + TheClock->Unit)>=100) {
  277.                   pft -= 100; dmt++;
  278.                }
  279.                // current hour
  280.                i = Date.ds_Minute/60;
  281.                // cheap or not cheap this is here the question
  282.                // cheap interval, holidy, sunday or saturday
  283.                if((i>=TheClock->LowChargesStart || i<TheClock->LowChargesEnd)
  284.                   || (n & HOLIDAY_FLAG) || !Today || Today==6)
  285.                   interval = TheClock->CInterval;
  286.                else interval = TheClock ->Interval;
  287.                TheClock -> Online = TRUE;
  288.                // write log entry
  289.                if(!(n & NO_LOGFILE_FLAG)) {
  290.                   // append to existing logfile
  291.                   if(file=(BPTR)Open((UBYTE *)TheClock->Logfile, MODE_OLDFILE)) {
  292.                      Seek(file, 0, OFFSET_END);
  293.                   }
  294.                   else file = (BPTR)Open((UBYTE *)TheClock->Logfile, MODE_NEWFILE);
  295.  
  296.                   if(file) {
  297.                      eng = (n & ENGLISH_FLAG) ? 7:0;
  298.                      if(n & REVERSE_FLAG) sprintf(TempBuf, "%s %02ld-%02ld-%02ld", Days[Today+eng], Month, Day, Year-1900);
  299.                      else                 sprintf(TempBuf, "%s %02ld.%02ld.%02ld", Days[Today+eng], Day, Month, Year-1900);
  300.                      Write(file, TempBuf, strlen(TempBuf));
  301.                      sprintf(TempBuf, "  %02ld:%02ld:%02ld  ONLINE\n", hours, mins, secs);
  302.                      Write(file, TempBuf, strlen(TempBuf));
  303.                      Close(file);
  304.                   }
  305.                }
  306.             }
  307.  
  308.                     // Increment time counter.
  309.  
  310.             if(lastsec != secs) {
  311.                lastsec = secs;
  312.                if(++ss == 60) {
  313.                   ss=0; if(++mm == 60) { mm=0; ++hh; }
  314.                }
  315.  
  316.                    // Decrement interval counter.
  317.  
  318.                if(--interval == 0) {
  319.                   // current hour
  320.                   i = hours;
  321.  
  322.                   // reset interval counter.
  323.                   // Today 0 == Sunday // 6 == Saturday
  324.                   if((i>=TheClock->LowChargesStart || i<TheClock->LowChargesEnd) ||
  325.                      (n & HOLIDAY_FLAG) || !Today || Today==6) interval = TheClock->CInterval;
  326.                   else interval = TheClock -> Interval;
  327.  
  328.                   // increment charges counter.
  329.                   pf += TheClock->Unit;
  330.                   pft += TheClock->Unit;
  331.                   if(pf>=100) {
  332.                      pf-=100; dm++;
  333.                   }
  334.                   if(pft>=100) {
  335.                      pft-=100; dmt++;
  336.                   }
  337.                }
  338.             }
  339.          }
  340.          else {
  341.             if(TheClock->Online == TRUE) {
  342.                // write log entry
  343.                if(!(n & NO_LOGFILE_FLAG)) {
  344.                   // append to existing logfile
  345.                   if(file=(BPTR)Open((UBYTE *)TheClock->Logfile, MODE_OLDFILE)) {
  346.                      Seek(file, 0, OFFSET_END);
  347.                      eng = (n & ENGLISH_FLAG) ? 7:0;
  348.                      if(n & REVERSE_FLAG) sprintf(TempBuf, "%s %02ld-%02ld-%02ld", Days[Today+eng], Month, Day, Year-1900);
  349.                      else                 sprintf(TempBuf, "%s %02ld.%02ld.%02ld", Days[Today+eng], Day, Month, Year-1900);
  350.                      Write(file, TempBuf, strlen(TempBuf));
  351.                      sprintf(TempBuf, "  %02ld:%02ld:%02ld  OFFLINE", hours, mins, secs);
  352.                      Write(file, TempBuf, strlen(TempBuf));
  353.                      sprintf(TempBuf, "  %02ld:%02ld:%02ld  %02ld,%02ld  TOTAL  %03ld,%02ld\n", hh, mm, ss, dm , pf, dmt, pft);
  354.                      Write(file, TempBuf, strlen(TempBuf));
  355.                      Close(file);
  356.                   }
  357.                }
  358.             }
  359.             TheClock -> Online = FALSE;
  360.          }
  361.          if((n & ONLINE_FLAG) || (TheClock->Viewmodes == DISPLAY_ONLINE_TIME)) {
  362.             sprintf(TempBuf, "%02ld:%02ld:%02ld  %02ld,%02ld  %03ld,%02ld", hh, mm, ss, dm, pf, dmt, pft);
  363.             strcat(DateBuf,TempBuf);
  364.          }
  365.          if(n & MEMORY_FLAG) {
  366.             chip_free /= 1000;  // no real KByte
  367.             fast_free /= 1000;  // yields to more RAM :-)
  368.             sprintf(TempBuf, "  A:%04d C:%04d F:%04d", chip_free+fast_free, chip_free, fast_free);
  369.             strcat(DateBuf,TempBuf);
  370.          }
  371.          else if(TheClock->Viewmodes == DISPLAY_MEMORY) {
  372.             sprintf(TempBuf, "F:%08ld C:%07ld", fast_free, chip_free);
  373.             strcat(DateBuf,TempBuf);
  374.          }
  375.          if((n & DATE_FLAG) || (TheClock->Viewmodes == DISPLAY_DATE_AND_TIME)) {
  376.             eng = (n & ENGLISH_FLAG) ? 7:0;
  377.             if(n & REVERSE_FLAG) sprintf(TempBuf, "  %s %02ld-%02ld-%02ld", Days[Today+eng], Month, Day, Year-1900);
  378.             else                 sprintf(TempBuf, "  %s %02ld.%02ld.%02ld", Days[Today+eng], Day, Month, Year-1900);
  379.             strcat(DateBuf,TempBuf);
  380.          }
  381.          if((n & TIME_FLAG) || (TheClock->Viewmodes == DISPLAY_DATE_AND_TIME)) {
  382.             if(n & NO_SECONDS_FLAG) sprintf(TempBuf, "  %02ld:%02ld",    hours, mins);
  383.             else                    sprintf(TempBuf, "  %02ld:%02ld:%02ld", hours, mins, secs);
  384.             strcat(DateBuf, TempBuf);
  385.          }
  386.          if(n & AUTO_JUMP_FLAG) {
  387.             register ULONG IntuiLock;
  388.             register struct Screen *ActiveScreen;
  389.  
  390.             IntuiLock = LockIBase(0L);
  391.             ActiveScreen = IntuitionBase -> ActiveScreen;
  392.             UnlockIBase(IntuiLock);
  393.  
  394.             // If not on active screen -> signal myself to jump
  395.             if(ActiveScreen != Window->WScreen) Signal(TheClock->Child, SIG_JUMP);
  396.          }
  397.          // justify to the right border
  398.          if((n=Window->Width-TextLength(Window->RPort, (UBYTE *)DateBuf, strlen(DateBuf))) < 0) n=0;
  399.          TextPrint.LeftEdge = n;
  400.          PrintIText(Window->RPort,&TextPrint, 0,0);
  401.       }
  402.  
  403.       // Tell father to finish.
  404.  
  405.       if(!failed) { Signal(TheClock -> Father, CHILD_READY); failed = 1; }
  406.  
  407.       SignalSet = Wait(SIG_CLOSE | SIG_CHANGE | SIG_COUNTER | SIG_NEWMODE | SIG_DISPLAY | SIG_JUMP);
  408.  
  409.       if(SignalSet & SIG_CLOSE) break;
  410.       else if(SignalSet & SIG_CHANGE) {
  411.          if(Window) { CloseWindow(Window); Window = NULL; }
  412.          TheClock->Flags = TheClock->FlagsBackup;
  413.          TheClock->Viewmodes = TheClock->ModesBackup;
  414.          TheClock->Status = 1;
  415.            // Tell father to finish.
  416.          Signal(TheClock -> Father, CHILD_READY);
  417.       }
  418.       // change
  419.       else if(SignalSet & SIG_NEWMODE) {
  420.          if(Window) { CloseWindow(Window); Window = NULL; }
  421.          TheClock->Status = 1;
  422.          TheClock->Viewmodes = TheClock->Viewmodes + 1;
  423.          if(TheClock->Viewmodes == 4) TheClock->Viewmodes = 0;
  424.       }
  425.       // start/stop counter
  426.       else if(SignalSet & SIG_COUNTER) {
  427.          TheClock->Flags = (TheClock->Flags & 128) ? (TheClock->Flags & 127):(TheClock->Flags | 128);
  428.       }
  429.       // jump to next screen
  430.       else if(SignalSet & SIG_JUMP) {
  431.          register struct Screen *NextScreen;
  432.          register ULONG IntuiLock;
  433.  
  434.          // start with the first one
  435.          IntuiLock = LockIBase(0L);
  436.          NextScreen = IntuitionBase -> ActiveScreen;
  437.          UnlockIBase(IntuiLock);
  438.          // watch out for another screen
  439.  
  440.          // and jump
  441.          if(Window) { CloseWindow(Window); Window = NULL; }
  442.          TheClock->Status = 1;
  443.          // change font
  444.          TheClock->Font = NextScreen->RastPort.Font;
  445.          // and NewWindow entries
  446.          if((NextScreen -> Flags & SCREENTYPE) == WBENCHSCREEN) {
  447.             ClockWindow.Screen = NULL;
  448.             ClockWindow.Type   = WBENCHSCREEN;
  449.          }
  450.          else {
  451.             ClockWindow.Screen = NextScreen;
  452.             ClockWindow.Type   = CUSTOMSCREEN;
  453.          }
  454.          ScreenToFront(NextScreen);
  455.       }
  456.    }
  457.  
  458. abort:
  459.  
  460.    TheClock -> Child = NULL;
  461.  
  462.    if(inputRequestBlock != NULL) {
  463.       if(inputRequestBlock->io_Device != NULL) {
  464.          inputRequestBlock->io_Command = IND_REMHANDLER;
  465.          inputRequestBlock->io_Data = (APTR)handlerStuff;
  466.          DoIO((struct IORequest *)inputRequestBlock);
  467.          CloseDevice((struct IORequest *)inputRequestBlock);
  468.       }
  469.       DeleteStdIO(inputRequestBlock);
  470.    }
  471.    if(inputDevPort != NULL) DeletePort(inputDevPort);
  472.    if(handlerStuff)         FreeMem(handlerStuff, sizeof(struct Interrupt));
  473.    if(Window) {             CloseWindow(Window); Window = NULL; }
  474.    if(DisplaySig != -1)     FreeSignal(DisplaySig);
  475.    if(JumpSig != -1)        FreeSignal(JumpSig);
  476.    if(DosBase)              CloseLibrary((struct Library *)DosBase);
  477.    if(GfxBase)              CloseLibrary((struct Library *)GfxBase);
  478.    if(IntuitionBase)        CloseLibrary((struct Library *)IntuitionBase);
  479.  
  480.    // tell daddy to kill us
  481.  
  482.    Forbid();
  483.    Signal(TheClock -> Father, CHILD_READY);
  484.    return(20);
  485. }
  486.  
  487. // calculate width of our window
  488.  
  489. GetWidth(LONG DefFlag)
  490. {
  491.    int Width = 0, Fact = TheClock->Font->tf_XSize;
  492.  
  493.    if(DefFlag & TIME_FLAG) {
  494.       if(DefFlag & NO_SECONDS_FLAG) Width+= (Fact * (SHORT_TIME_WIDTH));
  495.       else                          Width+= (Fact * (TIME_WIDTH));
  496.    }
  497.    if(DefFlag & DATE_FLAG)   Width+= (Fact * (DATE_WIDTH));
  498.    if(DefFlag & MEMORY_FLAG) Width+= (Fact * (MEM_WIDTH));
  499.    if(DefFlag & ONLINE_FLAG) Width+= (Fact * (ONLINE_WIDTH));
  500.  
  501.    // default width
  502.  
  503.    if(!Width) Width = (Fact * (TIME_WIDTH));
  504.  
  505.    return(Width);
  506. }
  507.