home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 2001 June / VPR0106A.BIN / OLS / TCL228 / TCL228.lzh / EXESRC.lzh / alarm.c next >
C/C++ Source or Header  |  1999-09-18  |  11KB  |  463 lines
  1. /*-------------------------------------------
  2.   alarm.c
  3.     Sound a wave, a media file, or open a file
  4.     KAZUBON 1997-1999
  5. ---------------------------------------------*/
  6.  
  7. #include "tclock.h"
  8.  
  9. static PALARMSTRUCT pAS = NULL;
  10. static int maxAlarm = 1;
  11. static BOOL bJihou, bJihouRepeat, bJihouBlink;
  12. static int daySaved = -1;
  13. static int hourLast = -1, minuteLast = -1;
  14.  
  15. static WAVEFORMATEX *pFormat = NULL;
  16. static HWAVEOUT hWaveOut = NULL;
  17. static HPSTR pData = NULL;
  18. static WAVEHDR wh;
  19.  
  20. static BOOL bMCIPlaying = FALSE;
  21. static int countPlay = 0, countPlayNum = 0;
  22. static int nTrack;
  23. static BOOL bTrack;
  24. BOOL bPlayingNonstop = FALSE;
  25.  
  26. BOOL PlayWave(HWND hwnd, char *fname, DWORD dwLoops);
  27. int PlayMCI(HWND hwnd, int nt);
  28. void StopWave(void);
  29. // page3.c
  30. BOOL IsMMFile(char* fname);
  31.  
  32. /*------------------------------------------------
  33. 　アラーム/時報の初期化
  34. --------------------------------------------------*/
  35. void InitAlarm(void)
  36. {
  37.     char subkey[20];
  38.     int i;
  39.  
  40.     maxAlarm = GetMyRegLong("", "AlarmNum", 1);
  41.     if(maxAlarm < 1) maxAlarm = 1;
  42.     if(pAS) free(pAS);
  43.     pAS = malloc(sizeof(ALARMSTRUCT) * maxAlarm);
  44.     for(i = 0; i < maxAlarm; i++)
  45.     {
  46.         wsprintf(subkey, "Alarm%d", i + 1);
  47.         
  48.         pAS[i].bAlarm = GetMyRegLong(subkey, "Alarm", FALSE);
  49.         pAS[i].hour = GetMyRegLong(subkey, "Hour", 12);
  50.         pAS[i].minute = GetMyRegLong(subkey, "Minute", 0);
  51.         GetMyRegStr(subkey, "File", pAS[i].fname, 1024, "");
  52.         pAS[i].bHour12 = GetMyRegLong(subkey, "Hour12", TRUE);
  53.         pAS[i].bRepeat = GetMyRegLong(subkey, "Repeat", FALSE);
  54.         pAS[i].bBlink = GetMyRegLong(subkey, "Blink", FALSE);
  55.         pAS[i].days = GetMyRegLong(subkey, "Days", 0x7f);
  56.     }
  57.  
  58.     bJihou = GetMyRegLong("", "Jihou", FALSE);
  59.     if(bJihou)
  60.     {
  61.         bJihouRepeat = GetMyRegLong("", "JihouRepeat", FALSE);
  62.         bJihouBlink = GetMyRegLong("", "JihouBlink", FALSE);
  63.     }
  64. }
  65.  
  66. void EndAlarm(void)
  67. {
  68.     if(pAS) free(pAS); pAS = NULL;
  69.     StopFile();
  70. }
  71.  
  72. /*------------------------------------------------
  73. 　アラーム/時報を鳴らす
  74. --------------------------------------------------*/
  75. void CheckAlarm(HWND hwnd, SYSTEMTIME* st)
  76. {
  77.     int i, rep, h, fday;
  78.     
  79.     if(hourLast == (int)st->wHour &&
  80.         minuteLast == (int)st->wMinute)
  81.     {
  82.         return;
  83.     }
  84.     hourLast = st->wHour;
  85.     minuteLast = st->wMinute;
  86.     
  87.     if(daySaved >= 0 && st->wDay != daySaved)
  88.     {
  89.         if(ExecDeskcal(hwnd)) daySaved = st->wDay;
  90.     }
  91.     else daySaved = st->wDay;
  92.     
  93.     if(st->wDayOfWeek > 0)
  94.         fday = 1 << (st->wDayOfWeek - 1);
  95.     else fday = 1 << 6;
  96.     
  97.     for(i = 0; i < maxAlarm; i++)
  98.     {
  99.         if(!pAS[i].bAlarm) continue;
  100.         h = st->wHour;
  101.         if(pAS[i].bHour12)
  102.         {
  103.             if(h == 0) h = 12;
  104.             else if(h >= 13) h -= 12;
  105.         }
  106.         if(pAS[i].hour == h && pAS[i].minute == st->wMinute
  107.             && (pAS[i].days & fday))
  108.         {
  109.             if(pAS[i].bBlink)
  110.                 PostMessage(hwndClock, WM_USER+2, FALSE, 0);
  111.  
  112.             if(pAS[i].fname[0])
  113.             {
  114.                 if(pAS[i].bRepeat) rep = -1; else rep = 0;
  115.                 if(PlayFile(hwnd, pAS[i].fname, rep)) return;
  116.             }
  117.         }
  118.     }
  119.  
  120.     if(bJihou && st->wMinute == 0)
  121.     {
  122.         char fname[1024];
  123.         h = st->wHour;
  124.         if(bJihouBlink)
  125.             PostMessage(hwndClock, WM_USER+2, TRUE, 0);
  126.         if(h == 0) h = 12;
  127.         else if(h >= 13) h -= 12;
  128.         if(GetMyRegStr("", "JihouFile", fname, 1024, "") > 0)
  129.         {
  130.             if(bJihouRepeat) rep = h; else rep = 0;
  131.             PlayFile(hwnd, fname, rep);
  132.         }
  133.     }
  134. }
  135.  
  136. /*------------------------------------------------
  137. 　ファイルの再生/実行   dwLoops：繰り返し回数
  138. --------------------------------------------------*/
  139. BOOL PlayFile(HWND hwnd, char *fname, DWORD dwLoops)
  140. {
  141.     BOOL b;
  142.     b = GetMyRegLong("", "MCIWave", FALSE);
  143.     
  144.     if(*fname == 0) return FALSE;
  145.     
  146.     if(!b && ext_cmp(fname, "wav") == 0)
  147.     {
  148.         if(bMCIPlaying) return FALSE;
  149.         return PlayWave(hwnd, fname, dwLoops);
  150.     }
  151.     else if(IsMMFile(fname))
  152.     {
  153.         char command[1024];
  154.         if(bMCIPlaying) return FALSE;
  155.         strcpy(command, "open \"");
  156.         strcat(command, fname);
  157.         strcat(command, "\" alias myfile");
  158.         if(mciSendString(command, NULL, 0, NULL) == 0)
  159.         {
  160.             strcpy(command, "set myfile time format ");
  161.             if(_stricmp(fname, "cdaudio") == 0 || ext_cmp(fname, "cda") == 0)
  162.             {
  163.                 strcat(command, "tmsf"); bTrack = TRUE;
  164.             }
  165.             else
  166.             {
  167.                 strcat(command, "milliseconds"); bTrack = FALSE;
  168.             }
  169.             mciSendString(command, NULL, 0, NULL);
  170.             
  171.             nTrack = -1;
  172.             if(ext_cmp(fname, "cda") == 0)
  173.             {
  174.                 char* p;
  175.                 p = fname; nTrack = 0;
  176.                 while(*p)
  177.                 {
  178.                     if('0' <= *p && *p <= '9') nTrack = nTrack * 10 + *p - '0';
  179.                     p++;
  180.                 }
  181.             }
  182.             if(PlayMCI(hwnd, nTrack) == 0)
  183.             {
  184.                 bMCIPlaying = TRUE;
  185.                 countPlay = 1; countPlayNum = dwLoops;
  186.             }
  187.             else mciSendString("close myfile", NULL, 0, NULL);
  188.         }
  189.         return bMCIPlaying;
  190.     }
  191.     else ExecFile(hwnd, fname);
  192.     return FALSE;
  193. }
  194.  
  195. int PlayMCI(HWND hwnd, int nt)
  196. {
  197.     char command[80], s[80];
  198.     char start[40], end[40];
  199.     
  200.     strcpy(command, "play myfile");
  201.     if(nt >= 0)
  202.     {
  203.         wsprintf(s, "status myfile position track %d", nt);
  204.         if(mciSendString(s, start, 40, NULL) == 0)
  205.         {
  206.             strcat(command, " from ");
  207.             strcat(command, start);
  208.             wsprintf(s, "status myfile position track %d", nt+1);
  209.             if(mciSendString(s, end, 40, NULL) == 0)
  210.             {
  211.                 strcat(command, " to ");
  212.                 strcat(command, end);
  213.             }
  214.         }
  215.     }
  216.     strcat(command, " notify");
  217.     return mciSendString(command, NULL, 0, hwnd);
  218. }
  219.  
  220. /*------------------------------------------------
  221. 　再生停止
  222. --------------------------------------------------*/
  223. void StopFile(void)
  224. {
  225.     StopWave();
  226.     if(bMCIPlaying)
  227.     {
  228.         mciSendString("stop myfile", NULL, 0, NULL);
  229.         mciSendString("close myfile", NULL, 0, NULL);
  230.         bMCIPlaying = FALSE;
  231.         countPlay = 0; countPlayNum = 0;
  232.     }
  233.     bPlayingNonstop = FALSE;
  234. }
  235.  
  236. void OnMCINotify(HWND hwnd)
  237. {
  238.     if(bMCIPlaying)
  239.     {
  240.         if(countPlay < countPlayNum || countPlayNum < 0)
  241.         {
  242.             mciSendString("seek myfile to start wait", NULL, 0, NULL);
  243.             if(PlayMCI(hwnd, nTrack) == 0)
  244.             {
  245.                 countPlay++;
  246.             }
  247.             else
  248.                 StopFile();
  249.         }
  250.         else StopFile();
  251.     }
  252. }
  253.  
  254. /*--------------------------------------------------------
  255.   Retreive a file name and option from a command string
  256. ----------------------------------------------------------*/
  257. void GetFileAndOption(const char* command, char* fname, char* opt)
  258. {
  259.     const char *p, *pe;
  260.     char *pd;
  261.     WIN32_FIND_DATA fd;
  262.     HANDLE hfind;
  263.     
  264.     p = command; pd = fname;
  265.     pe = NULL;
  266.     for(; ;)
  267.     {
  268.         if(*p == ' ' || *p == 0)
  269.         {
  270.             *pd = 0;
  271.             hfind = FindFirstFile(fname, &fd);
  272.             if(hfind != INVALID_HANDLE_VALUE)
  273.             {
  274.                 FindClose(hfind);
  275.                 pe = p;
  276.             }
  277.             if(*p == 0) break;
  278.         }
  279.         *pd++ = *p++;
  280.     }
  281.     if(pe == NULL) pe = p;
  282.     
  283.     p = command; pd = fname;
  284.     for(; p != pe; )
  285.     {
  286.         *pd++ = *p++;
  287.     }
  288.     *pd = 0;
  289.     if(*p == ' ') p++;
  290.     
  291.     pd = opt;
  292.     for(; *p; ) *pd++ = *p++;
  293.     *pd = 0;
  294. }
  295.  
  296. /*------------------------------------------------
  297.   Open a file
  298. --------------------------------------------------*/
  299. BOOL ExecFile(HWND hwnd, char* command)
  300. {
  301.     char fname[MAX_PATH], opt[MAX_PATH];
  302.     
  303.     if(*command == 0) return FALSE;
  304.     
  305.     GetFileAndOption(command, fname, opt);
  306.     
  307.     if((int)ShellExecute(hwnd, NULL, fname,
  308.         opt[0]?opt:NULL, "", SW_SHOW) < 32) return FALSE;
  309.     return TRUE;
  310. }
  311.  
  312. /*------------------------------------------------
  313. 　WAVEの再生   dwLoops：繰り返し回数
  314. 　参考：Visual C++ 1.x のサンプルREVERSE
  315. --------------------------------------------------*/
  316. BOOL PlayWave(HWND hwnd, char *fname, DWORD dwLoops)
  317. {
  318.     HMMIO hmmio;
  319.     MMCKINFO mmckinfoParent;
  320.     MMCKINFO mmckinfoSubchunk;
  321.     LONG lFmtSize;
  322.     LONG lDataSize;
  323.     
  324.     if(hWaveOut != NULL) return FALSE;
  325.     
  326.     if(!(hmmio = mmioOpen(fname, NULL, MMIO_READ | MMIO_ALLOCBUF)))
  327.         return FALSE;
  328.     
  329.     mmckinfoParent.fccType = mmioFOURCC('W', 'A', 'V', 'E');
  330.     if(mmioDescend(hmmio, (LPMMCKINFO) &mmckinfoParent, NULL, MMIO_FINDRIFF))
  331.     {
  332.         mmioClose(hmmio, 0);
  333.         return FALSE;
  334.     }
  335.  
  336.     mmckinfoSubchunk.ckid = mmioFOURCC('f', 'm', 't', ' ');
  337.     if(mmioDescend(hmmio, &mmckinfoSubchunk, &mmckinfoParent,
  338.         MMIO_FINDCHUNK))
  339.     {
  340.         mmioClose(hmmio, 0);
  341.         return FALSE;
  342.     }
  343.     
  344.     lFmtSize = mmckinfoSubchunk.cksize;
  345.     pFormat = (WAVEFORMATEX*)malloc(lFmtSize);
  346.     if(pFormat == NULL)
  347.     {
  348.         mmioClose(hmmio, 0);
  349.         return FALSE;
  350.     }
  351.     
  352.     if(mmioRead(hmmio, (HPSTR)pFormat, lFmtSize) != lFmtSize)
  353.     {
  354.         free(pFormat); pFormat = NULL;
  355.         mmioClose(hmmio, 0);
  356.         return FALSE;
  357.     }
  358.     
  359.     /*
  360.     if(pFormat->wFormatTag != WAVE_FORMAT_PCM)
  361.     {
  362.         free(pFormat); pFormat = NULL;
  363.         mmioClose(hmmio, 0);
  364.         return FALSE;
  365.     }
  366.     */
  367.  
  368.     if(waveOutOpen(&hWaveOut, (UINT)WAVE_MAPPER, (LPWAVEFORMATEX)pFormat,
  369.         0, 0, (DWORD)WAVE_FORMAT_QUERY))
  370.     {
  371.         free(pFormat); pFormat = NULL;
  372.         mmioClose(hmmio, 0);
  373.         return FALSE;
  374.     }
  375.     
  376.     mmioAscend(hmmio, &mmckinfoSubchunk, 0);
  377.     
  378.     mmckinfoSubchunk.ckid = mmioFOURCC('d', 'a', 't', 'a');
  379.     if(mmioDescend(hmmio, &mmckinfoSubchunk, &mmckinfoParent,
  380.         MMIO_FINDCHUNK))
  381.     {
  382.         free(pFormat); pFormat = NULL;
  383.         mmioClose(hmmio, 0);
  384.         return FALSE;
  385.     }
  386.  
  387.     lDataSize = mmckinfoSubchunk.cksize;
  388.     if(lDataSize == 0)
  389.     {
  390.         free(pFormat); pFormat = NULL;
  391.         mmioClose(hmmio, 0);
  392.         return FALSE;
  393.     }
  394.     
  395.     pData = (HPSTR)malloc(lDataSize);
  396.     if(pData == NULL)
  397.     {
  398.         free(pFormat); pFormat = NULL;
  399.         mmioClose(hmmio, 0);
  400.         return FALSE;
  401.     }
  402.     
  403.     if(mmioRead(hmmio, pData, lDataSize) != lDataSize)
  404.     {
  405.         free(pFormat); pFormat = NULL;
  406.         free(pData); pData = NULL;
  407.         mmioClose(hmmio, 0);
  408.         return FALSE;
  409.     }
  410.     mmioClose(hmmio, 0);
  411.     
  412.     if(waveOutOpen((LPHWAVEOUT)&hWaveOut, (UINT)WAVE_MAPPER,
  413.         (LPWAVEFORMATEX)pFormat, (UINT)hwnd, 0,
  414.         (DWORD)CALLBACK_WINDOW))
  415.     {
  416.         free(pFormat); pFormat = NULL;
  417.         free(pData); pData = NULL;
  418.         return FALSE;
  419.     }
  420.     
  421.     memset(&wh, 0, sizeof(WAVEHDR));
  422.     wh.lpData = pData;
  423.     wh.dwBufferLength = lDataSize;
  424.     if(dwLoops != 0)
  425.     {
  426.         wh.dwFlags = WHDR_BEGINLOOP|WHDR_ENDLOOP;
  427.         wh.dwLoops = dwLoops;
  428.     }
  429.     if(waveOutPrepareHeader(hWaveOut, &wh, sizeof(WAVEHDR)))
  430.     {
  431.         waveOutClose(hWaveOut); hWaveOut = NULL;
  432.         free(pFormat); pFormat = NULL;
  433.         free(pData); pData = NULL;
  434.         return FALSE;
  435.     }
  436.     
  437.     if(waveOutWrite(hWaveOut, &wh, sizeof(WAVEHDR)) != 0)
  438.     {
  439.         waveOutUnprepareHeader(hWaveOut, &wh, sizeof(WAVEHDR));
  440.         waveOutClose(hWaveOut);    hWaveOut = NULL;
  441.         free(pFormat); pFormat = NULL;
  442.         free(pData); pData = NULL;
  443.         return FALSE;
  444.     }
  445.  
  446.     return TRUE;
  447. }
  448.  
  449. /*------------------------------------------------
  450. 　WAVE再生停止
  451. --------------------------------------------------*/
  452. void StopWave(void)
  453. {
  454.     if(hWaveOut == NULL) return;
  455.  
  456.     waveOutReset(hWaveOut);
  457.     waveOutUnprepareHeader(hWaveOut, &wh, sizeof(WAVEHDR));
  458.     waveOutClose(hWaveOut);        
  459.     hWaveOut = NULL;
  460.     free(pFormat); pFormat = NULL;
  461.     free(pData); pData = NULL;
  462. }
  463.