home *** CD-ROM | disk | FTP | other *** search
/ Amiga MA Magazine 1998 #6 / amigamamagazinepolishissue1998.iso / disks / tools / hdsleep / source / main.c < prev    next >
C/C++ Source or Header  |  1996-08-04  |  15KB  |  666 lines
  1. /*
  2. ** includes
  3. */
  4.  
  5. #include<dos.h>
  6. #include<stdio.h>
  7. #include<string.h>
  8. #include<stdlib.h>
  9. #include<proto/dos.h>
  10. #include<proto/exec.h>
  11. #include<proto/icon.h>
  12. #include<proto/commodities.h>
  13. #include<proto/intuition.h>
  14. #include<proto/gadtools.h>
  15. #include<exec/io.h>
  16. #include<exec/memory.h>
  17. #include<exec/interrupts.h>
  18. #include<exec/execbase.h>
  19. #include<exec/devices.h>
  20. #include<dos/rdargs.h>
  21. #include<devices/timer.h>
  22. #include"hdsleep_rev.h"
  23. #include"gadtools.h"
  24.  
  25. /*
  26. ** version
  27. */
  28.  
  29. char    ver[]=VERSTAG;
  30.  
  31. /*
  32. ** defines
  33. */
  34.  
  35. #define TYPE_RUN 0
  36. #define TYPE_END 1
  37. #define TYPE_SPINUP 2
  38. #define TYPE_SPINDOWN 3
  39. #define TYPE_HOTKEY 4
  40.  
  41. #define TEMPLATE "CX_PRIORITY/N/K,CX_POPKEY/K,CX_POPUP/K,HDSLEEPKEY=SKEY/K,MASTERTIME=MT/N,SLAVETIME=ST/N,WARNING=WARN/S,WARNINGTIMEOUT=WT/N,LOGFILE=L/K,A4000/S"
  42. #define ARG_PRIORITY        0
  43. #define ARG_POPKEY            1
  44. #define ARG_POPUP                2
  45. #define ARG_HDSLEEPKEY    3
  46. #define ARG_MASTERTIME    4
  47. #define ARG_SLAVETIME        5
  48. #define ARG_WARNING            6
  49. #define ARG_WARNINGTO        7
  50. #define ARG_LOGFILE            8
  51. #define ARG_A4000                9
  52. #define ARG_COUNT                10
  53.  
  54. #define OFF 0
  55. #define ON 1
  56. #define STOPPED 2
  57. #define EVT_POPKEY 1
  58. #define EVT_HOTKEY 2
  59. #define DRV_MASTER 0
  60. #define DRV_SLAVE 1
  61.  
  62. #define    unless(x) if ( !(x) )
  63. #define LEAVE goto exitit
  64.  
  65. ULONG DEF_PRIORITY=0;
  66. char    DEF_POPKEY[]="control alt h";
  67. char    DEF_POPUP2[]="YES";
  68. ULONG DEF_POPUP=1;
  69. char    DEF_HDSLEEPKEY[]="control h";
  70. ULONG DEF_MASTERTIME=360;    // 360 secs == 4 mins
  71. ULONG DEF_SLAVETIME=0;      // 360 secs == 4 mins
  72. ULONG DEF_WARNING=0;
  73. ULONG DEF_WARNINGTO=5;
  74. char DEF_LOGFILE[]="\0";
  75. ULONG DEF_A4000=FALSE;
  76.  
  77. /*
  78. ** prototypes
  79. */
  80.  
  81. void    main(int, char **);
  82. void    __saveds __asm MyBeginIO(register __a1 struct IORequest *);
  83. int        AddInt(void);
  84. void    RemInt(void);
  85. void    HandleCxMsg(void);
  86. void    RequestOK(char *);
  87. APTR    BusyWindow(struct Window *);
  88. void    UnbusyWindow(APTR);
  89. void    LogFile(UBYTE,UBYTE);
  90.  
  91. extern struct DiskObject *TTGetOurIcon(struct WBStartup *);
  92. extern void TTFreeOurIcon(struct DiskObject *);
  93. extern char *TTString(struct DiskObject *,char *, char *);
  94. extern LONG TTInt(struct DiskObject *,char *, LONG);
  95. extern int TTBool(struct DiskObject *,char *, BOOL);
  96.  
  97. //extern    void SPrintf(char *,const char *, ...);
  98. extern    void __asm CallBeginIO(register __a1 struct IORequest *);
  99. extern    void __asm HDDriveOff(register __d0 UBYTE);
  100. extern    UBYTE __asm CheckHD(register __d0 UBYTE);
  101.  
  102. /*
  103. ** variables
  104. */
  105.  
  106. extern struct ExecBase *SysBase;
  107. APTR OldBeginIO=NULL;
  108. struct DiskObject *icon=NULL;
  109. struct Library *SCSIBase=NULL;
  110. struct MsgPort *TimerPort=NULL;
  111. struct timerequest TimerReq;
  112. struct IntuiMessage *message;
  113. struct Gadget *gadget;
  114. struct MenuItem *item;
  115. BOOL running=TRUE,timerun=FALSE,POPUP=TRUE;//,SpinUp=FALSE;
  116. ULONG MASTERTIME,SLAVETIME,signals,MasterTime=0,SlaveTime=0,class,code;
  117. ULONG SigWin,WARNING=0,WARNINGTO,Computer=0;
  118. UBYTE MasterHD,SlaveHD;
  119.  
  120. struct BusyWin
  121. {
  122.     struct Requester Req;
  123.     struct Window *Win;
  124. };
  125.  
  126. /*
  127. ** commodities
  128. */
  129.  
  130. struct NewBroker newbroker=
  131. {
  132.     NB_VERSION,
  133.     "HDSleep",
  134.     "HDSleep v1.3 by Tomasz Muszynski",
  135.     "HD noise saver for A1200/A4000",
  136.     NBU_UNIQUE|NBU_NOTIFY,
  137.     COF_SHOW_HIDE
  138. };
  139.  
  140. struct MsgPort *broker_mp=NULL;
  141. CxObj *broker=NULL, *hdsleepobj, *popkeyobj;
  142. CxMsg *cxmsg;
  143. ULONG msgid, msgtype;
  144. UBYTE hdsleepstr[50],popkeystr[50],logfilestr[108];
  145.  
  146. /*
  147. ** functions
  148. */
  149.  
  150. void main(int argc,char *argv[])
  151. {
  152.     struct RDArgs *rdargs;
  153.     long *(opts[ARG_COUNT]),arg;
  154.     struct Node *SCSINode;
  155.     struct IORequest SCSIIOReq;
  156.     struct MsgPort SCSIPort;
  157.  
  158.     if(SysBase->LibNode.lib_Version<39)
  159.     {
  160.         RequestOK("You must have\nAmiga with OS3.0");
  161.         LEAVE;
  162.     }
  163.     MasterHD=TRUE;    // MasterHD=CheckHD(DRV_MASTER);
  164.     SlaveHD=TRUE;    // SlaveHD=CheckHD(DRV_SLAVE);
  165.  
  166.     if(argc!=0)
  167.     {
  168.         opts[ARG_PRIORITY]=&DEF_PRIORITY;
  169.         opts[ARG_POPKEY]=(long *)DEF_POPKEY;
  170.         opts[ARG_POPUP]=(long *)DEF_POPUP2;
  171.         opts[ARG_HDSLEEPKEY]=(long *)DEF_HDSLEEPKEY;
  172.         opts[ARG_MASTERTIME]=&DEF_MASTERTIME;
  173.         opts[ARG_SLAVETIME]=&DEF_SLAVETIME;
  174.         opts[ARG_WARNING]=(long *)DEF_WARNING;
  175.         opts[ARG_WARNINGTO]=&DEF_WARNINGTO;
  176.         opts[ARG_LOGFILE]=(long *)DEF_LOGFILE;
  177.         opts[ARG_A4000]=(long *)DEF_A4000;
  178.  
  179.         if(rdargs=ReadArgs(TEMPLATE,(long *) opts, NULL))
  180.         {
  181.             arg=FindArg(TEMPLATE,"CX_PRIORITY");
  182.             if(arg>-1)
  183.                 newbroker.nb_Pri=*opts[arg];
  184.  
  185.             arg=FindArg(TEMPLATE,"CX_POPUP");
  186.             if(arg>-1)
  187.             {
  188.                 if(!stricmp((char *)opts[arg],"NO")) POPUP=FALSE;
  189.                 if(!stricmp((char *)opts[arg],"FALSE")) POPUP=FALSE;
  190.                 if(!stricmp((char *)opts[arg],"OFF")) POPUP=FALSE;
  191.             }
  192.  
  193.             arg=FindArg(TEMPLATE,"CX_POPKEY");
  194.             if(arg>-1)
  195.                 strcpy(popkeystr,(char *)opts[arg]);
  196.  
  197.             arg=FindArg(TEMPLATE,"HDSLEEPKEY");
  198.             if(arg>-1)
  199.                 strcpy(hdsleepstr,(char *)opts[arg]);
  200.  
  201.             arg=FindArg(TEMPLATE,"MASTERTIME");
  202.             if(arg>-1)
  203.                 MASTERTIME=*opts[arg];
  204.  
  205.             arg=FindArg(TEMPLATE,"SLAVETIME");
  206.             if(arg>-1)
  207.                 SLAVETIME=*opts[arg];
  208.  
  209.             arg=FindArg(TEMPLATE,"WARNING");
  210.             if(arg>-1)
  211.                 WARNING=(ULONG)opts[arg];
  212.  
  213.             arg=FindArg(TEMPLATE,"WARNINGTIMEOUT");
  214.             if(arg>-1)
  215.                 WARNINGTO=*opts[arg];
  216.  
  217.             arg=FindArg(TEMPLATE,"LOGFILE");
  218.             if(arg>-1)
  219.                 strcpy(logfilestr,(char *)opts[arg]);
  220.  
  221.             arg=FindArg(TEMPLATE,"A4000");
  222.             if(arg>-1)
  223.                 Computer=(ULONG)opts[arg];
  224.  
  225.             FreeArgs(rdargs);
  226.         }
  227.         else
  228.         {
  229.             PrintFault(IoErr(),argv[0]);
  230.             LEAVE;
  231.         }
  232.     }
  233.     else
  234.     {
  235.         unless(icon=TTGetOurIcon(WBenchMsg)) icon=GetDiskObject(argv[0]);
  236.         newbroker.nb_Pri=TTInt(icon,"CX_PRIORITY",DEF_PRIORITY);
  237.         strcpy(popkeystr,TTString(icon,"CX_POPKEY",DEF_POPKEY));
  238.         POPUP=TTBool(icon,"CX_POPUP",DEF_POPUP);
  239.         strcpy(hdsleepstr,TTString(icon,"HDSLEEPKEY",DEF_HDSLEEPKEY));
  240.         MASTERTIME=TTInt(icon,"MASTERTIME",DEF_MASTERTIME);
  241.         SLAVETIME=TTInt(icon,"SLAVETIME",DEF_SLAVETIME);
  242.         WARNING=TTBool(icon,"WARNING",DEF_WARNING);
  243.         WARNINGTO=TTInt(icon,"WARNINGTIMEOUT",DEF_WARNINGTO);
  244.         strcpy(logfilestr,TTString(icon,"LOGFILE",DEF_LOGFILE));
  245.         Computer=(ULONG) TTBool(icon,"A4000",DEF_A4000);
  246.         TTFreeOurIcon(icon);
  247.     }
  248.  
  249.     if(MASTERTIME==0) MasterHD=FALSE;
  250.     if(SLAVETIME==0) SlaveHD=FALSE;
  251.  
  252.     MasterTime=MASTERTIME;
  253.     SlaveTime=SLAVETIME;
  254.  
  255.     unless(broker_mp=CreateMsgPort()) LEAVE;
  256.     newbroker.nb_Port=broker_mp;
  257.     unless(broker=CxBroker(&newbroker,NULL)) LEAVE;
  258.     unless(hdsleepobj=HotKey(hdsleepstr,broker_mp,EVT_HOTKEY)) LEAVE;
  259.     unless(popkeyobj=HotKey(popkeystr,broker_mp,EVT_POPKEY)) LEAVE;
  260.     AttachCxObj(broker,hdsleepobj);
  261.     if(CxObjError(hdsleepobj)) LEAVE;
  262.     AttachCxObj(broker,popkeyobj);
  263.     if(CxObjError(popkeyobj)) LEAVE;
  264.     ActivateCxObj(broker,1L);
  265.  
  266. // Get scsi.device base address
  267.  
  268.     unless(SCSINode=FindName(&SysBase->DeviceList,"scsi.device")) LEAVE;
  269.     AddPort(&SCSIPort);
  270.     SCSIIOReq.io_Message.mn_ReplyPort=&SCSIPort;
  271.     if(OpenDevice("scsi.device",0L, &SCSIIOReq,0L)) LEAVE;
  272.     SCSIBase=&SCSIIOReq.io_Device->dd_Library;
  273.     CloseDevice(&SCSIIOReq);
  274.     RemPort(&SCSIPort);
  275.  
  276. // Replace BeginIO
  277.  
  278.     Forbid();
  279.     SumLibrary(SCSIBase);
  280.     unless(OldBeginIO=SetFunction(SCSIBase,DEV_BEGINIO,(unsigned long (*)())MyBeginIO)) LEAVE;
  281.     SumLibrary(SCSIBase);
  282.     Permit();
  283.  
  284.     unless(timerun=AddInt()) LEAVE;
  285.  
  286.     SigWin=NULL;
  287.  
  288.     if(POPUP)
  289.     {
  290.         if(!SetupScreen())
  291.         {
  292.             if(!OpenMainWindow())
  293.             {
  294.                 SigWin=1L<<MainWnd->UserPort->mp_SigBit;
  295.                 GT_SetGadgetAttrs(MainGadgets[GD_MASTEROFF],MainWnd,NULL,GTNM_Number,MasterTime,TAG_DONE);
  296.                 GT_SetGadgetAttrs(MainGadgets[GD_SLAVEOFF],MainWnd,NULL,GTNM_Number,SlaveTime,TAG_DONE);
  297.             }
  298.         }
  299.     }
  300.  
  301.     LogFile(TYPE_RUN,0);
  302.  
  303.     while(running)
  304.     {
  305.         signals=Wait(SIGBREAKF_CTRL_C | (1L<<broker_mp->mp_SigBit) | SigWin | 1L<<TimerPort->mp_SigBit);
  306.         if(signals & (1L<<TimerPort->mp_SigBit))
  307.         {
  308.             if(MainWnd)
  309.             {
  310.                 GT_SetGadgetAttrs(MainGadgets[GD_MASTEROFF],MainWnd,NULL,GTNM_Number,MasterTime,TAG_DONE);
  311.                 GT_SetGadgetAttrs(MainGadgets[GD_SLAVEOFF],MainWnd,NULL,GTNM_Number,SlaveTime,TAG_DONE);
  312.             }
  313. //            if(SpinUp)
  314. //            {
  315. //                LogFile(TYPE_SPINUP,0);
  316. //                SpinUp=FALSE;
  317. //            }
  318.             if(MasterTime>0 && MasterHD)
  319.             {
  320.                 MasterTime--;
  321.                 if(MasterTime==0)
  322.                 {
  323.                     LogFile(TYPE_SPINDOWN,0);
  324.                     MasterTime=0;
  325.                     HDDriveOff(DRV_MASTER);
  326.                     if(MainWnd)
  327.                     {
  328.                         CloseMainWindow();
  329.                         CloseDownScreen();
  330.                         SigWin=NULL;
  331.                     }
  332.                 }
  333.             }
  334.             if(SlaveTime>0 && SlaveHD)
  335.             {
  336.                 SlaveTime--;
  337.                 if(SlaveTime==0)
  338.                 {
  339.                     LogFile(TYPE_SPINDOWN,1);
  340.                     SlaveTime=0;
  341.                     HDDriveOff(DRV_SLAVE);
  342.                     if(MainWnd)
  343.                     {
  344.                         CloseMainWindow();
  345.                         CloseDownScreen();
  346.                         SigWin=NULL;
  347.                     }
  348.                 }
  349.             }
  350.             TimerReq.tr_time.tv_secs=1;
  351.             TimerReq.tr_time.tv_micro=0;
  352.             SendIO((struct IORequest *) &TimerReq);
  353.             if(WARNING && (SlaveTime==WARNINGTO || MasterTime==WARNINGTO) && !MainWnd)
  354.             {
  355.                 if(!SetupScreen())
  356.                 {
  357.                     if(!OpenMainWindow())
  358.                     {
  359.                         SigWin=1L<<MainWnd->UserPort->mp_SigBit;
  360.                     }
  361.                 }
  362.             }
  363.             if(WARNING && (SlaveTime==WARNINGTO || MasterTime==WARNINGTO) && MainWnd) WindowToFront(MainWnd);
  364.         }
  365.         if(signals & SIGBREAKF_CTRL_C) running=FALSE;
  366.         if(signals & SigWin)
  367.         {
  368.             while(message=GT_GetIMsg(MainWnd->UserPort))
  369.             {
  370.                 class=message->Class;
  371.                 code=message->Code;
  372.                 gadget=(struct Gadget *)message->IAddress;
  373.                 GT_ReplyIMsg(message);
  374.                 switch(class)
  375.                 {
  376.                     case IDCMP_CLOSEWINDOW:
  377.                         goto gdhide;
  378.                         break;
  379.                     case IDCMP_MENUPICK:
  380.                         while(code!=MENUNULL) 
  381.                         {
  382.                             item=(struct MenuItem *)ItemAddress(MainMenus,code);
  383.                             switch(ITEMNUM(code))
  384.                             {
  385.                                 case 0: goto gdsleep; break;
  386.                                 case 1: goto gdabort; break;
  387.                                 case 3: RequestOK("HDSleep v1.3\n"\
  388.                                                         "     by     \n"\
  389.                                                         " Thom/Union \n"\
  390.                                                         "            \n"\
  391.                                                         "This program\n"\
  392.                                                         "is  FREEWARE");
  393.                                     break;
  394.                                 case 5: goto gdhide; break;
  395.                                 case 6: goto gdquit; break;
  396.                             }
  397.                             code = item->NextSelect;
  398.                         }
  399.                         break;
  400.                     case IDCMP_VANILLAKEY:
  401.                         switch(code)
  402.                         {
  403.                             case 's':
  404.                             case 'S': goto gdsleep; break;
  405.                             case 'a':
  406.                             case 'A': goto gdabort; break;
  407.                             case 'q':
  408.                             case 'Q': goto gdquit; break;
  409.                         }
  410.                         break;
  411.                     case IDCMP_GADGETUP:
  412.                         switch(gadget->GadgetID)
  413.                         {
  414.                             case GD_SLEEP:
  415. gdsleep:                while(message=(struct IntuiMessage *)GetMsg(MainWnd->UserPort)) ReplyMsg((struct Message *)message);
  416.                                 CloseMainWindow();
  417.                                 CloseDownScreen();
  418.                                 SigWin=NULL;
  419.                                 LogFile(TYPE_HOTKEY,0);
  420.                                 MasterTime=0;
  421.                                 HDDriveOff(DRV_MASTER);
  422.                                 SlaveTime=0;
  423.                                 HDDriveOff(DRV_SLAVE);
  424.                                 goto skip;
  425.                                 break;
  426.                             case GD_ABORT:
  427. gdabort:                MasterTime=MASTERTIME;
  428.                                 SlaveTime=SLAVETIME;
  429. gdhide:                    while(message=(struct IntuiMessage *)GetMsg(MainWnd->UserPort)) ReplyMsg((struct Message *)message);
  430.                                 CloseMainWindow();
  431.                                 CloseDownScreen();
  432.                                 SigWin=NULL;
  433.                                 goto skip;
  434.                                 break;
  435.                             case GD_QUIT:
  436. gdquit:                    running=FALSE;
  437.                                 break;
  438.                         }
  439.                         break;
  440.                 }
  441.             }
  442.         }
  443.         if(signals & (1L<<broker_mp->mp_SigBit)) HandleCxMsg();
  444. skip:;
  445.     }
  446.  
  447. exitit:
  448.     LogFile(TYPE_END,0);
  449.  
  450.     if(MainWnd)
  451.     {
  452.         CloseMainWindow();
  453.         CloseDownScreen();
  454.         SigWin=NULL;
  455.     }
  456.     RemInt();
  457.     if(OldBeginIO) SetFunction(SCSIBase,DEV_BEGINIO,(unsigned long (*)())OldBeginIO);
  458.     if(broker) DeleteCxObjAll(broker);
  459.     if(broker_mp) DeleteMsgPort(broker_mp);
  460. }
  461.  
  462. void __saveds __asm MyBeginIO(register __a1 struct IORequest *io)
  463. {
  464.     MasterTime=MASTERTIME;
  465.     SlaveTime=SLAVETIME;
  466.     CallBeginIO(io);
  467. //    SpinUp=TRUE;
  468. }
  469.  
  470. int AddInt()
  471. {
  472.     if(TimerPort=CreatePort("HDSleep Port",0L))
  473.     {
  474.         if(!OpenDevice(TIMERNAME,UNIT_MICROHZ,(struct IORequest *)&TimerReq,0))
  475.         {
  476.             MasterTime=MASTERTIME;
  477.             SlaveTime=SLAVETIME;
  478.             TimerReq.tr_node.io_Message.mn_ReplyPort=TimerPort;
  479.             TimerReq.tr_node.io_Command=TR_ADDREQUEST;
  480.             TimerReq.tr_time.tv_secs=1;
  481.             TimerReq.tr_time.tv_micro=0;
  482.             TimerReq.tr_node.io_Error=0;
  483.             TimerReq.tr_node.io_Flags=0;
  484.             SendIO((struct IORequest *)&TimerReq);
  485.             return 1;
  486.         }
  487.     }
  488.     return 0;
  489. }
  490.  
  491. void RemInt()
  492. {
  493.     if(timerun) CloseDevice((struct IORequest *)&TimerReq);
  494.     if(TimerPort) DeletePort(TimerPort);
  495. }
  496.  
  497. void HandleCxMsg()
  498. {
  499.     while(cxmsg=(CxMsg *)GetMsg(broker_mp))
  500.     {
  501.         msgid  = CxMsgID(cxmsg);
  502.         msgtype= CxMsgType(cxmsg);
  503.         ReplyMsg((struct Message *)cxmsg);
  504.         switch(msgtype)
  505.         {
  506.             case CXM_IEVENT:
  507.                 switch(msgid)
  508.                 {
  509.                     case EVT_HOTKEY:
  510.                         LogFile(TYPE_HOTKEY,0);
  511.                         MasterTime=0;
  512.                         HDDriveOff(DRV_MASTER);
  513.                         SlaveTime=0;
  514.                         HDDriveOff(DRV_SLAVE);
  515.                         if(MainWnd)
  516.                         {
  517.                             CloseMainWindow();
  518.                             CloseDownScreen();
  519.                             SigWin=NULL;
  520.                         }
  521.                         break;
  522.                     case EVT_POPKEY:
  523.                         if(!MainWnd)
  524.                         {
  525.                             if(!SetupScreen())
  526.                             {
  527.                                 if(!OpenMainWindow())
  528.                                 {
  529.                                     SigWin=1L<<MainWnd->UserPort->mp_SigBit;
  530.                                     GT_SetGadgetAttrs(MainGadgets[GD_MASTEROFF],MainWnd,NULL,GTNM_Number,MasterTime,TAG_DONE);
  531.                                     GT_SetGadgetAttrs(MainGadgets[GD_SLAVEOFF],MainWnd,NULL,GTNM_Number,SlaveTime,TAG_DONE);
  532.                                 }
  533.                             }
  534.                         }
  535.                         break;
  536.                 }
  537.                 break;
  538.             case CXM_COMMAND:
  539.                 switch(msgid)
  540.                 {
  541.                     case CXCMD_DISABLE:
  542.                         ActivateCxObj(broker,0L);
  543.                         break;
  544.                     case CXCMD_ENABLE:
  545.                         ActivateCxObj(broker,1L);
  546.                         break;
  547.                     case CXCMD_APPEAR:
  548.                         if(!MainWnd)
  549.                         {
  550.                             if(!SetupScreen())
  551.                             {
  552.                                 if(!OpenMainWindow())
  553.                                 {
  554.                                     SigWin=1L<<MainWnd->UserPort->mp_SigBit;
  555.                                     GT_SetGadgetAttrs(MainGadgets[GD_MASTEROFF],MainWnd,NULL,GTNM_Number,MasterTime,TAG_DONE);
  556.                                     GT_SetGadgetAttrs(MainGadgets[GD_SLAVEOFF],MainWnd,NULL,GTNM_Number,SlaveTime,TAG_DONE);
  557.                                 }
  558.                             }
  559.                         }
  560.                         break;
  561.                     case CXCMD_DISAPPEAR:
  562.                         if(MainWnd)
  563.                         {
  564.                             CloseMainWindow();
  565.                             CloseDownScreen();
  566.                             SigWin=NULL;
  567.                         }
  568.                         break;
  569.                     case CXCMD_KILL:
  570.                     case CXCMD_UNIQUE:
  571.                         running=FALSE;
  572.                         break;
  573.                 }
  574.                 break;
  575.         }
  576.     }
  577. }
  578.  
  579. void RequestOK(char *napis)
  580. {
  581.     struct EasyStruct easyreq;
  582.     APTR bw=NULL;
  583.  
  584.     easyreq.es_StructSize=sizeof(struct EasyStruct);
  585.     easyreq.es_Flags=0;
  586.     easyreq.es_Title="About";
  587.     easyreq.es_TextFormat=napis;
  588.     easyreq.es_GadgetFormat="Ok";
  589.  
  590.     if(MainWnd) bw=BusyWindow(MainWnd);
  591.     EasyRequest(MainWnd,&easyreq,NULL,NULL);
  592.     if(bw) UnbusyWindow(bw);
  593. }
  594.  
  595. APTR BusyWindow(struct Window *Win)
  596. {
  597.     struct BusyWin *bw=NULL;
  598.  
  599.     if(Win)
  600.     {
  601.         if(bw=AllocVec(sizeof(struct BusyWin),MEMF_ANY))
  602.         {
  603.             bw->Win=Win;
  604.             InitRequester(&bw->Req);
  605.             Request(&bw->Req,bw->Win);
  606.             SetWindowPointer(bw->Win,WA_BusyPointer,TRUE,TAG_DONE);
  607.         }
  608.     }
  609.     return((APTR) bw);
  610. }
  611.  
  612. void UnbusyWindow(APTR bwp)
  613. {
  614.     struct BusyWin *bw;
  615.  
  616.     if(bwp)
  617.     {
  618.         bw=(struct BusyWin *)bwp;
  619.         EndRequest(&bw->Req,bw->Win);
  620.         SetWindowPointer(bw->Win,WA_Pointer,NULL,TAG_DONE);
  621.         FreeVec(bwp);
  622.     }
  623. }
  624.  
  625. void LogFile(UBYTE type,UBYTE hd)
  626. {
  627.     FILE *fh;
  628.     char texttime[100];
  629.     unsigned char clock[8];
  630.  
  631.     if(logfilestr[0])
  632.     {
  633.         if(fh=fopen(logfilestr,"a"))
  634.         {
  635.             getclk(clock);
  636.             sprintf(texttime,"%02ld-%02ld-%02ld %02ld:%02ld:%02ld",(ULONG)clock[3],(ULONG)clock[2],(ULONG)clock[1]+80,(ULONG)clock[4],(ULONG)clock[5],(ULONG)clock[6]);
  637.             switch(type)
  638.             {
  639.                 case TYPE_RUN:
  640.                     fprintf(fh,"%s  HDSleep started.\n",texttime);
  641.                     break;
  642.                 case TYPE_END:
  643.                     fprintf(fh,"%s  HDSleep exited.\n\n*********************\n\n",texttime);
  644.                     break;
  645. //            case TYPE_SPINUP:
  646. //                fprintf(fh,"%s  HD Spinup.\n",texttime);
  647. //                break;
  648.                 case TYPE_SPINDOWN:
  649.                     fprintf(fh,"%s  %s HD spindown after %ld seconds inactivity.\n",texttime,hd?"Slave":"Master",hd?SLAVETIME:MASTERTIME);
  650.                     break;
  651.                 case TYPE_HOTKEY:
  652.                     fprintf(fh,"%s  All HDs have been spindown by the user.\n",texttime);
  653.                     break;
  654.             }
  655.             fclose(fh);
  656.         }
  657.         switch(type)
  658.         {
  659.             case TYPE_SPINDOWN:
  660.             case TYPE_HOTKEY:
  661.                 Delay(3*50);        // Delay to write log
  662.                 break;
  663.         }
  664.     }
  665. }
  666.