home *** CD-ROM | disk | FTP | other *** search
/ modiromppu / modiromppu.iso / PROGRAMS / ORGPACKS / DIDO4.ZIP / SOURCE.ZIP / DIDO.C next >
C/C++ Source or Header  |  1995-06-01  |  22KB  |  668 lines
  1.  
  2. // This is the source to Dido 4.
  3. //
  4. // Lossless digital sound copy from AUDIO CD to WAV files, without crackle &
  5. // pops. No sampling involved. The best quality you can get.
  6. //
  7. // Windows 3.1 freeware by
  8. //                          Michiel Overtoom   (motoom@xs4all.nl)
  9. // Bases on work done by
  10. //                          Yeng-Chee Su       (yenchee@csie.nctu.edu.tw)
  11. // and
  12. //                          Klaas Hemstra      (hst@mh.nl)
  13. //
  14. // and of course... source available.
  15.  
  16. #include <windows.h>
  17. #include <commdlg.h>
  18. #include <dos.h>
  19. #include <stdio.h>
  20. #include <io.h>
  21. #include <stdlib.h>
  22. #include <string.h>
  23. #include <dir.h>
  24. #include <time.h>
  25. #include <mmsystem.h>            // for mciSendstring
  26. #include "dido.h"                // defines for program resources
  27.  
  28. #define HELPFILE "dido.hlp"
  29.  
  30. HINSTANCE hinst;
  31. WORD    nbuf;                    // number of low memory dos buffers (set by allocating routine)
  32. #define MAXNBUF 20                // Max. number of low mem buffers that can be allocated
  33. int     CDROM;                     // CDROM unit. 0==a, 1==b, etc
  34. int     lowest, highest;        // Lowest and highest track on the CD
  35. int        lineinc=4,pageinc=12;    // skipping factors for scrollbar (in seconds)
  36. DWORD     total_time;                // Total time on CD
  37. char     s[160],t[80],u[80];        // scratch strings
  38. char    waveditor[160]="MPLAYER.EXE";    // editor for WAV files (INI setting)
  39. BOOL     bit16=1,hz44=1,stereo=1;        // settings from recording dialog; options for
  40.                                         // thinning out the recorded sound.
  41.  
  42. #define mb(x) MessageBox(0,x,"Error",0);
  43.  
  44. #include "didod.h"        // low level cd defines/structs
  45. #include "didod.c"        // low level cd routines via DPMI
  46. #include "didologo.c"    // logo routines
  47.  
  48.  
  49. // Set all the controls in a Dialog to the same font
  50. BOOL CALLBACK EnumDialogChild(HWND hw,LPARAM font) {
  51.     SendMessage(hw,WM_SETFONT,(WPARAM)font,0);
  52.        return 1;
  53.     }
  54. void SetDialogFont(HWND dialog,HFONT font)
  55. {
  56.     EnumChildWindows(dialog,EnumDialogChild,(LPARAM)font);
  57. }
  58.  
  59.  
  60. // Center a window
  61. void CenterWindow(HWND hwnd) 
  62. { 
  63.     RECT r; 
  64.     GetWindowRect(hwnd, &r); 
  65.     SetWindowPos(hwnd, NULL,  
  66.        ((GetSystemMetrics(SM_CXSCREEN) - (r.right - r.left)) / 2),  
  67.        ((GetSystemMetrics(SM_CYSCREEN) - (r.bottom - r.top)) / 2),  
  68.        0, 0, SWP_NOSIZE | SWP_NOACTIVATE);  
  69. } 
  70.  
  71. #include "didorec.c"    // recording routine
  72.  
  73.  
  74. // Delay routine, used in initialization
  75. void delay(long ticks)
  76. {
  77.     long expire=clock()+ticks;
  78.     while(clock()<expire);
  79. }
  80.  
  81.  
  82. // Storage for track table
  83. #define MAXTRACK 100        // Have you ever seen a CD with more than 100 tracks?
  84. int   ntrack=0;                // Nr. of tracks on the CD
  85. int   tracknr[MAXTRACK];    // The track number
  86. DWORD trackloc[MAXTRACK];    // Track start in redbook format
  87. DWORD tracklen[MAXTRACK];    // Duration of track, in sectors
  88.  
  89.  
  90. // Build a table of tracks
  91. int BuildTrackTable(void)
  92. {
  93.     int i;
  94.     DWORD loc;
  95.     // Scan the tracks
  96.     ntrack=0;
  97.     for (i=lowest;i<=highest;i++) {
  98.         if (!GetTrackInfo(i,&loc)) return 0;
  99.         tracknr[ntrack]=i;
  100.         trackloc[ntrack]=loc;
  101.         ntrack++;
  102.         }
  103.     // Calculate the durations
  104.     trackloc[ntrack]=total_time;
  105.     for (i=0;i<ntrack;i++) tracklen[i]=Red2Sierra(trackloc[i+1])-Red2Sierra(trackloc[i]);
  106.     return 1;
  107. }
  108.  
  109.  
  110. // Ask for a WAV file
  111. int ChooseWavFile(HWND hwnd,char *fn)
  112. {
  113.     OPENFILENAME ofn;
  114.     char szFile[128]={0};
  115.     char szFileTitle[128]={0};
  116.     memset(&ofn, 0, sizeof(ofn));
  117.     strcpy(szFile,fn);
  118.     strcpy(szFileTitle,fn);
  119.     ofn.lStructSize = sizeof(ofn);
  120.     ofn.hwndOwner = hwnd;
  121.     ofn.lpstrFilter = "Wave audio (*.wav)\0*.wav\0";
  122.     ofn.nFilterIndex = 1;
  123.     ofn.lpstrFile= szFile;
  124.     ofn.nMaxFile = 128;
  125.     ofn.lpstrFileTitle= szFileTitle;
  126.     ofn.nMaxFileTitle = 128;
  127.     ofn.Flags = OFN_PATHMUSTEXIST|OFN_HIDEREADONLY;
  128.     if (!GetSaveFileName(&ofn)) return 0;
  129.     strcpy(fn,ofn.lpstrFile);
  130.     return 1;
  131. }
  132.  
  133.  
  134. // Get-a-value dialog proc
  135. struct values {
  136.     DWORD    val;
  137.     DWORD     from;
  138.     DWORD    to; 
  139.     };
  140. #pragma argsused
  141. BOOL CALLBACK ValueDlgProc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp)
  142. {
  143.     char s[20];
  144.     static struct values *value; 
  145.     if (msg==WM_INITDIALOG) {
  146.         value=(struct values *)lp;
  147.         SetDialogFont(hdlg,GetStockObject(ANSI_VAR_FONT));
  148.            sprintf(s,"%ld",value->val);
  149.         SetDlgItemText(hdlg,VALUE,s);
  150.         }
  151.     if (msg==WM_COMMAND && wp==IDOK) {
  152.         GetDlgItemText(hdlg,VALUE,s,19);
  153.         value->val=atol(s);
  154.         if (value->val < value->from)
  155.             value->val=value->from;
  156.         else if (value->val > value->to)
  157.             value->val=value->to;
  158.         EndDialog(hdlg,1);
  159.         }
  160.     return 0;
  161. }
  162.  
  163.  
  164. // Wrapper for get-a-value dialog. Provides default, ranges, etc...
  165. DWORD GetValue(HWND caller,DWORD defalt,DWORD from,DWORD to)
  166. {
  167.     struct values value;
  168.     value.from=from; value.to=to; value.val=defalt;
  169.     DialogBoxParam(hinst,"ValueDlg",caller,ValueDlgProc,(LPARAM)&value);
  170.     return value.val;
  171. }
  172.  
  173.  
  174. // Record dialog
  175. #pragma argsused
  176. BOOL CALLBACK RecDlgProc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp)
  177. {
  178.     static int restartsound=0,autorewind=1,autorepeat=1;
  179.     static int refresh=0;
  180.     static int tnr;                    // track number
  181.     static DWORD start,end;            // Start/ending recording position, redbook format
  182.     static WORD  sm,ss,sf;            // Start recording position: minute, second, frame
  183.     static WORD  em,es,ef;            // idem, End position
  184.     static DWORD sc,ec;                // Start/ending recording sectors
  185.     static char fn[80];                // Last used filename
  186.     DWORD dur;
  187.     WORD  div;
  188.  
  189.     if (msg==WM_INITDIALOG) {
  190.         // Initialize record dialog
  191.         fn[0]=0;                                              // Zap filename
  192.         tnr=(WORD)lp;                                        // Remember track number
  193.         sprintf(s,"Search (track %d)",tracknr[tnr]);        // put it also in the
  194.         SetWindowText(hdlg,s);                                // dialog title
  195.         CenterWindow(hdlg);
  196.         SetDialogFont(hdlg,GetStockObject(ANSI_VAR_FONT));
  197.         // Fill inputs with track defaults
  198.         Red2MSFC(start=trackloc[tnr],&sm,&ss,&sf,&sc);
  199.         Red2MSFC(end=trackloc[tnr+1],&em,&es,&ef,&ec);
  200.         // Set scroll bar extents en posities
  201.         SetScrollRange(GetDlgItem(hdlg,SBAR),SB_CTL,0,Red2Sierra(total_time)/75L,0);
  202.         SetScrollRange(GetDlgItem(hdlg,EBAR),SB_CTL,0,Red2Sierra(total_time)/75L,0);
  203.         SetScrollPos(GetDlgItem(hdlg,SBAR),SB_CTL,Red2Sierra(start)/75L,0);
  204.         SetScrollPos(GetDlgItem(hdlg,EBAR),SB_CTL,Red2Sierra(end)/75L,0);
  205.         // Assure all fields will be refreshed; also start playing the track
  206.         refresh=1;
  207.         restartsound=1;
  208.         }
  209.  
  210.     // Button pressed!
  211.     #define FRESH refresh=1; if (autorewind) restartsound=1
  212.     if (msg==WM_COMMAND) {
  213.         if (wp==LISTEN) restartsound=1;
  214.         if (wp==IDOK) {StopAudio(); EndDialog(hdlg,1);}
  215.         if (wp==STEREO) {stereo=1; refresh=1;}
  216.         if (wp==MONO) {stereo=0; refresh=1;}
  217.         if (wp==HZ44) {hz44=1; refresh=1;}
  218.         if (wp==HZ22) {hz44=0; refresh=1;}
  219.         if (wp==BIT16) {bit16=1; refresh=1;}
  220.         if (wp==BIT8) {bit16=0; refresh=1;}
  221.         if (wp==RECORD) {
  222.             StopAudio(); PlayAudio(start,10);            // This prevents sync errors (? beats me but it does!)
  223.             EnableWindow(hdlg,0);                        
  224.             sprintf(fn,"%d-%d-%d.wav",sm,ss,sf);        // Compose a filename using start time
  225.             if (ChooseWavFile(hdlg,fn)) {                // File selection box
  226.                 dur=Red2Sierra(end)-Red2Sierra(start);
  227.                 if (!record(fn,Red2Sierra(start),dur)) mb(error);    // record it.
  228.                 FRESH;
  229.                 }
  230.             EnableWindow(hdlg,1); SetFocus(hdlg);
  231.             }
  232.         if (wp==EDIT) {
  233.             if (access(fn,0)==0) {                        // Edit only allowed when last used
  234.                 sprintf(s,"%s %s",waveditor,fn);        // is present, and if the file exist.
  235.                 StopAudio();
  236.                 if (WinExec(s,SW_SHOWNORMAL)<32)        // Spawn the WAV editor
  237.                     MessageBox(hdlg,s,"cant execute editor",MB_OK);
  238.                 }
  239.             }
  240.         if (wp==AUTOREWIND) {autorewind=1-autorewind; refresh=1;}
  241.         if (wp==AUTOREPEAT) {autorepeat=1-autorepeat; refresh=1;}
  242.         // Adjusting start time...
  243.         if (wp==SM) {
  244.             sm=GetValue(hdlg,sm,0,99);
  245.             MSF2Red(sm,ss,sf,&start,&sc);    FRESH;
  246.             }
  247.         if (wp==SMDOWN) {
  248.             if (sm) sm--;
  249.             MSF2Red(sm,ss,sf,&start,&sc);    FRESH;
  250.             }
  251.         if (wp==SMUP)   {
  252.             sm++;
  253.             MSF2Red(sm,ss,sf,&start,&sc);   FRESH;
  254.             }
  255.         if (wp==SS) {
  256.             ss=GetValue(hdlg,ss,0,59);
  257.             MSF2Red(sm,ss,sf,&start,&sc);    FRESH;
  258.             }
  259.         if (wp==SSDOWN) {
  260.             if (ss) ss--;
  261.             else if (sm) {sm--; ss=59;}
  262.             MSF2Red(sm,ss,sf,&start,&sc);   FRESH;
  263.             }
  264.         if (wp==SSUP)   {
  265.             ss++;
  266.             if (ss>59) {ss=0; sm++;}
  267.             MSF2Red(sm,ss,sf,&start,&sc);   FRESH;
  268.             }
  269.         if (wp==SF) {
  270.             sf=GetValue(hdlg,sf,0,74);
  271.             MSF2Red(sm,ss,sf,&start,&sc);    FRESH;
  272.             }
  273.         if ((wp==SFDOWN)||(wp==SCDOWN)) {
  274.             if (sf) {
  275.                 sf--;
  276.                 }
  277.             else if (ss) {
  278.                 ss--; sf=74;
  279.                 }
  280.             else if (sm) {
  281.                 sm--; ss=59; sf=74;
  282.                 }
  283.             MSF2Red(sm,ss,sf,&start,&sc);   FRESH;
  284.             }
  285.         if ((wp==SFUP)||(wp==SCUP))   {
  286.             sf++;
  287.             if (sf>74) {
  288.                 sf=0; ss++;
  289.                 if (ss>59) {
  290.                     sm++; ss=0;
  291.                     }
  292.                 }
  293.             MSF2Red(sm,ss,sf,&start,&sc);   FRESH;
  294.             }
  295.         // Adjusting end time...
  296.         if (wp==EM) {
  297.             em=GetValue(hdlg,em,0,99);
  298.             MSF2Red(em,es,ef,&end,&ec);    FRESH;
  299.             }
  300.         if (wp==EMDOWN) {
  301.             if (em) em--;
  302.             MSF2Red(em,es,ef,&end,&ec);        FRESH;
  303.             }
  304.         if (wp==EMUP)   {
  305.             em++;
  306.             MSF2Red(em,es,ef,&end,&ec);       FRESH;
  307.             }
  308.         if (wp==ES) {
  309.             es=GetValue(hdlg,es,0,59);
  310.             MSF2Red(em,es,ef,&end,&ec);    FRESH;
  311.             }
  312.         if (wp==ESDOWN) {
  313.             if (es) es--;
  314.             else if (em) {em--; es=59;}
  315.             MSF2Red(em,es,ef,&end,&ec);        FRESH;
  316.             }
  317.         if (wp==ESUP)   {
  318.             es++;
  319.             if (es>59) {es=0; em++;}
  320.             MSF2Red(em,es,ef,&end,&ec);        FRESH;
  321.             }
  322.         if (wp==EF) {
  323.             ef=GetValue(hdlg,ef,0,74);
  324.             MSF2Red(em,es,ef,&end,&ec);    FRESH;
  325.             }
  326.         if ((wp==EFDOWN)||(wp==ECDOWN)) {
  327.             if (ef) {
  328.                 ef--;
  329.                 }
  330.             else if (es) {
  331.                 es--; ef=74;
  332.                 }
  333.             else if (em) {
  334.                 em--; es=59; ef=74;
  335.                 }
  336.             MSF2Red(em,es,ef,&end,&ec);        FRESH;
  337.             }
  338.         if ((wp==EFUP)||(wp==ECUP))   {
  339.             ef++;
  340.             if (ef>74) {
  341.                 ef=0; es++;
  342.                 if (es>59) {
  343.                     em++; es=0;
  344.                     }
  345.                 }
  346.             MSF2Red(em,es,ef,&end,&ec);        FRESH;
  347.             }
  348.         }
  349.  
  350.     // Scroll bar?
  351.     if (msg==WM_HSCROLL) { // SBAR, EBAR
  352.         BOOL isstart=0;
  353.         int sc=wp;                // Scrollcode
  354.         int pos=LOWORD(lp);        // position
  355.         if (GetDlgItem(hdlg,SBAR)==(HWND)HIWORD(lp)) isstart=1;
  356.         if (sc==SB_THUMBPOSITION || sc==SB_THUMBTRACK) {
  357.             if (isstart) 
  358.                 Red2MSFC(start=Sierra2Red(75L*pos),&sm,&ss,&sf,&sc);
  359.             else 
  360.                 Red2MSFC(end=Sierra2Red(75L*pos),&em,&es,&ef,&ec);
  361.             FRESH;
  362.             }
  363.         if (sc==SB_LINEUP) {
  364.             if (isstart) {
  365.                 long newstart=Red2Sierra(start)-75L*lineinc;
  366.                 if (newstart<0) newstart=0;
  367.                 Red2MSFC(start=Sierra2Red(newstart),&sm,&ss,&sf,&sc);
  368.                 }
  369.             else {
  370.                 long newend=Red2Sierra(end)-75L*lineinc;
  371.                 if (newend<0) newend=0;
  372.                 Red2MSFC(end=Sierra2Red(newend),&em,&es,&ef,&ec);
  373.                 }
  374.             FRESH;
  375.             }
  376.         if (sc==SB_LINEDOWN) {
  377.             if (isstart) {
  378.                 long newstart=Red2Sierra(start)+75L*lineinc;
  379.                 Red2MSFC(start=Sierra2Red(newstart),&sm,&ss,&sf,&sc);
  380.                 }
  381.             else {
  382.                 long newend=Red2Sierra(end)+75L*lineinc;
  383.                 Red2MSFC(end=Sierra2Red(newend),&em,&es,&ef,&ec);
  384.                 }
  385.             FRESH;
  386.             }
  387.         if (sc==SB_PAGEUP) {
  388.             if (isstart) {
  389.                 long newstart=Red2Sierra(start)-75L*pageinc;
  390.                 if (newstart<0) newstart=0;
  391.                 Red2MSFC(start=Sierra2Red(newstart),&sm,&ss,&sf,&sc);
  392.                 }
  393.             else {
  394.                 long newend=Red2Sierra(end)-75L*pageinc;
  395.                 if (newend<0) newend=0;
  396.                 Red2MSFC(end=Sierra2Red(newend),&em,&es,&ef,&ec);
  397.                 }
  398.             FRESH;
  399.             }
  400.         if (sc==SB_PAGEDOWN) {
  401.             if (isstart) {
  402.                 long newstart=Red2Sierra(start)+75L*pageinc;
  403.                 Red2MSFC(start=Sierra2Red(newstart),&sm,&ss,&sf,&sc);
  404.                 }
  405.             else {
  406.                 long newend=Red2Sierra(end)+75L*pageinc;
  407.                 Red2MSFC(end=Sierra2Red(newend),&em,&es,&ef,&ec);
  408.                 }
  409.             FRESH;
  410.             }
  411.         }
  412.  
  413.  
  414.     // Something needs redrawing? Well, redraw them all.
  415.     if (refresh) {
  416.         refresh=0;
  417.         // Never play outside CD tracks - may hang the driver
  418.         if (start<trackloc[0])         Red2MSFC(start=trackloc[0],&sm,&ss,&sf,&sc);
  419.         if (start>trackloc[ntrack]) Red2MSFC(start=trackloc[ntrack],&sm,&ss,&sf,&sc);
  420.         if (end<trackloc[0])         Red2MSFC(end=trackloc[0],&em,&es,&ef,&ec);
  421.         if (end>trackloc[ntrack])     Red2MSFC(end=trackloc[ntrack],&em,&es,&ef,&ec);
  422.         if (start>end)                 Red2MSFC(end=start,&em,&es,&ef,&ec);
  423.         // Update the numerals in the edit controls
  424.         Red2MSFC(start,&sm,&ss,&sf,&sc);
  425.         Red2MSFC(end,&em,&es,&ef,&ec);
  426.  
  427.         SetDlgItemInt(hdlg,SM,sm,0);    SetDlgItemInt(hdlg,SS,ss,0);
  428.         SetDlgItemInt(hdlg,SF,sf,0);
  429.         sprintf(s,"%lu",sc); SetDlgItemText(hdlg,SC,s);
  430.  
  431.         SetDlgItemInt(hdlg,EM,em,0);    SetDlgItemInt(hdlg,ES,es,0);
  432.         SetDlgItemInt(hdlg,EF,ef,0);
  433.         sprintf(s,"%lu",ec); SetDlgItemText(hdlg,EC,s);
  434.         // Update scroll bars
  435.         SetScrollPos(GetDlgItem(hdlg,SBAR),SB_CTL,Red2Sierra(start)/75L,1);
  436.         SetScrollPos(GetDlgItem(hdlg,EBAR),SB_CTL,Red2Sierra(end)/75L,1);
  437.  
  438.         // Set radiobuttons
  439.         if (!bit16) {
  440.             hz44=0; stereo=0;
  441.             EnableWindow(GetDlgItem(hdlg,HZ22),0);
  442.             EnableWindow(GetDlgItem(hdlg,HZ44),0);
  443.             EnableWindow(GetDlgItem(hdlg,MONO),0);
  444.             EnableWindow(GetDlgItem(hdlg,STEREO),0);
  445.             }
  446.         else {
  447.             EnableWindow(GetDlgItem(hdlg,HZ22),1);
  448.             EnableWindow(GetDlgItem(hdlg,HZ44),1);
  449.             EnableWindow(GetDlgItem(hdlg,MONO),1);
  450.             EnableWindow(GetDlgItem(hdlg,STEREO),1);
  451.             }
  452.         CheckRadioButton(hdlg,MONO,STEREO,stereo?STEREO:MONO);
  453.         CheckRadioButton(hdlg,HZ22,HZ44,hz44?HZ44:HZ22);
  454.         CheckRadioButton(hdlg,BIT8,BIT16,bit16?BIT16:BIT8);
  455.         CheckDlgButton(hdlg,AUTOREWIND,autorewind);
  456.         CheckDlgButton(hdlg,AUTOREPEAT,autorepeat);
  457.         if (*fn && access(fn,0)==0)
  458.             EnableWindow(GetDlgItem(hdlg,EDIT),1);
  459.         else
  460.             EnableWindow(GetDlgItem(hdlg,EDIT),0);
  461.         // Calculate projected file size and duration
  462.         dur=Red2Sierra(end)-Red2Sierra(start);
  463.         div=0; if (!stereo) div++; if (!hz44) div++; if (!bit16) div++;
  464.         sprintf(s,"%ld Kbytes",((dur*2352)>>div)/1024);
  465.         SetDlgItemText(hdlg,FSIZE,s);
  466.         sprintf(s,"%s   /  %ld sectors",Sector2MSF(dur),dur);
  467.         SetDlgItemText(hdlg,DUR,s);
  468.         }
  469.  
  470.     // Issue a play command to the CD player
  471.     if (restartsound) {
  472.         restartsound=0;
  473.         StopAudio();
  474.         PlayAudio(start,Red2Sierra(end)-Red2Sierra(start));
  475.         }
  476.     return 0;
  477. }
  478.  
  479.  
  480. // Preferences dialog proc
  481. #pragma argsused
  482. BOOL CALLBACK PrefDlgProc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp)
  483. {
  484.     if (msg==WM_INITDIALOG) {
  485.         SetDialogFont(hdlg,GetStockObject(ANSI_VAR_FONT));
  486.         sprintf(s,"%d audio buffers allocated",nbuf);
  487.         SetDlgItemText(hdlg,BUFRESULT,s);
  488.  
  489.         if (CheckSmartdrv()) {
  490.             if (CheckCDROMCached()) 
  491.                 strcpy(s,"Smartdrv caches the CDROM");
  492.             else
  493.                 strcpy(s,"Smartdrv does not cache the CDROM");
  494.             }
  495.         else 
  496.             strcpy(s,"Smartdrv not installed");
  497.         SetDlgItemText(hdlg,CACHERESULT,s);
  498.  
  499.         SetDlgItemText(hdlg,WAVEDITOR,waveditor);
  500.         }
  501.     if (msg==WM_COMMAND && wp==IDOK) {
  502.         GetDlgItemText(hdlg,WAVEDITOR,waveditor,159);
  503.         WriteProfileString("Dido","WAVeditor",waveditor);
  504.         EndDialog(hdlg,1);
  505.         }
  506.     return 0;
  507. }
  508.  
  509. // Sync error dialog proc
  510. #pragma argsused
  511. BOOL CALLBACK SyncErrDlgProc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp)
  512. {
  513.     if (msg==WM_INITDIALOG) SetDialogFont(hdlg,GetStockObject(ANSI_VAR_FONT));
  514.     if (msg==WM_COMMAND) {
  515.         if (wp==ABOUT) {
  516.             WinHelp(hdlg,HELPFILE,HELP_KEY,"SyncErr");
  517.             EndDialog(hdlg,1);
  518.             }
  519.         if (wp==IDCANCEL) {
  520.             EndDialog(hdlg,1);
  521.             }
  522.         }
  523.     return 0;
  524. }
  525.  
  526. // Memalloc error dialog proc
  527. #pragma argsused
  528. BOOL CALLBACK MemErrDlgProc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp)
  529. {
  530.     if (msg==WM_INITDIALOG) SetDialogFont(hdlg,GetStockObject(ANSI_VAR_FONT));
  531.     if (msg==WM_COMMAND) {
  532.         if (wp==ABOUT) {
  533.             WinHelp(hdlg,HELPFILE,HELP_KEY,"MemErr");
  534.             EndDialog(hdlg,1);
  535.             }
  536.         if (wp==IDCANCEL) {
  537.             EndDialog(hdlg,1);
  538.             }
  539.         }
  540.     return 0;
  541. }
  542.  
  543. // Main dialog proc
  544. #pragma argsused
  545. BOOL CALLBACK MainDlgProc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp)
  546. {
  547.     int i;
  548.     if (msg==WM_INITDIALOG) {
  549.         SetDialogFont(hdlg,GetStockObject(ANSI_VAR_FONT));
  550.         // Infoheaderts at top 
  551.         SetDlgItemText(hdlg,PLAYINGTIME,Sector2MSF(Red2Sierra(total_time)));
  552.         sprintf(s,"%d",highest-lowest+1);
  553.         SetDlgItemText(hdlg,NRTRACKS,s);
  554.         // Track table
  555.         if (!BuildTrackTable()) mb("Error building the track table");
  556.         SendDlgItemMessage(hdlg,TRACKLIST,LB_RESETCONTENT,0,0);
  557.         for (i=0;i<ntrack;i++) {
  558.             strcpy(t,Red2MSF(trackloc[i]));
  559.             sprintf(s," %2d.   %s     start at %s    %ld sectors",
  560.                         tracknr[i],
  561.                         Sector2MSF(tracklen[i]),
  562.                         Red2MSF(trackloc[i]),
  563.                         tracklen[i]
  564.                         );
  565.             SendDlgItemMessage(hdlg,TRACKLIST,LB_ADDSTRING,0,(LPARAM)s);
  566.             }
  567.         }
  568.     // Some button or track line clicked?
  569.     if (msg==WM_COMMAND) {
  570.         if (HIWORD(lp)==LBN_SELCHANGE) {
  571.             int item;
  572.             if (hlogo) ToggleLogo();
  573.             item=(WORD)SendDlgItemMessage(hdlg,TRACKLIST,LB_GETCURSEL,0,0L);
  574.             if (item!=LB_ERR) {
  575.                 EnableWindow(hdlg,0);
  576.                 if (-1==DialogBoxParam(hinst,"RecDlg",0,RecDlgProc,item))
  577.                     mb("cant create record dialog");
  578.                 EnableWindow(hdlg,1); SetFocus(GetDlgItem(hdlg,TRACKLIST));
  579.                 }
  580.             }
  581.         else {
  582.             if (wp==PREFS) {
  583.                 EnableWindow(hdlg,0);
  584.                 DialogBox(hinst,"PrefDlg",0,PrefDlgProc);
  585.                 EnableWindow(hdlg,1); SetFocus(GetDlgItem(hdlg,TRACKLIST));
  586.                 }
  587.             if (wp==QUIT || wp==EJECT) {StopAudio(); EndDialog(hdlg,wp);}
  588.             if (wp==ABOUT) WinHelp(GetDesktopWindow(),HELPFILE,HELP_CONTENTS,0);
  589.             }
  590.         }
  591.     return 0;
  592. }
  593.  
  594.  
  595. // Mainprogram entry point
  596. #pragma argsused
  597. int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,LPSTR lpszCmdLine, int cmdShow)
  598. {
  599.     MSG msg;
  600.     int try,status,result,warn;
  601.     hinst=hInstance;
  602.  
  603.     // Allocate buffers in low memory
  604.     if (!startinterfacing()) {
  605.         DialogBox(hInstance,"MemErrDlg",0,MemErrDlgProc);
  606.         return 0;
  607.         }
  608.     // Is MSCDEX installed? If not, abort.
  609.     if (!CheckMscdex()) {
  610.         mb("MSCDEX not installed");
  611.         return 0;
  612.         }
  613.     // Is there a SMARTDRV cache on the CD? Issue a warning, except when
  614.     // CDROMCachewarning=0 is specified in INI file
  615.     warn=GetProfileInt("Dido","CDROMCachewarning",1);
  616.     if (warn) {
  617.         if (CheckSmartdrv() && CheckCDROMCached()) {
  618.             warn=MessageBox(0,"You have SMARTDRV enabled on your CDROM. On some systems, this can"
  619.                          " cause Dido to lose synchronization during audio copy. If this happens"
  620.                          " to you, try to disable CDROM caching before you start Windows.      "
  621.                          "Would you like to skip this warning in the future?","Warning",MB_YESNO);
  622.             if (warn==IDYES) WriteProfileString("Dido","CDROMCachewarning","0");
  623.             }
  624.         }
  625.  
  626.     // Display logo
  627.     RegisterLogo(hinst);
  628.     ToggleLogo();
  629.     // Give some time slices so the logo will display
  630.     while (PeekMessage(&msg,0,0,0,PM_REMOVE)) {
  631.         TranslateMessage(&msg);
  632.            DispatchMessage(&msg);
  633.         }
  634.     // Wait a bit
  635.     delay(CLK_TCK*2);
  636. Rescan:
  637.     // Get global information about CD
  638.     status=GetDiskInfo(); try=0;
  639.     while (status!=0x0100) {
  640.         delay(CLK_TCK);
  641.         if (++try>=3) {
  642.             if (MessageBox(0,"Insert an audio CD in the drive","CDROM is busy",MB_RETRYCANCEL)==IDCANCEL) {
  643.                 // ieks... terminate
  644.                 stopinterfacing();
  645.                 return 0;
  646.                 }
  647.             try=0;
  648.             }
  649.         status=GetDiskInfo();
  650.         }
  651.     // Do the interaction
  652.     GetProfileString("Dido","WAVeditor",waveditor,waveditor,159);
  653.     result=DialogBox(hinst,"MainDlg",0,MainDlgProc);
  654.     if (result==EJECT) {
  655.         // Try MCI, for a change
  656.         mciSendString("SET CDAUDIO DOOR OPEN", NULL, 0, NULL ); // This one works OK on my drive...
  657.         MessageBox(0,"You can change the CD now","Dido",MB_OK);
  658.         mciSendString("SET CDAUDIO DOOR CLOSED", NULL, 0, NULL ); // This does NOT work on my drive...
  659.         delay(6*CLK_TCK);
  660.         goto Rescan;
  661.         }
  662.     WinHelp(GetDesktopWindow(),HELPFILE,HELP_QUIT,0);
  663.     // Free up
  664.     stopinterfacing();
  665.     if (hlogo) ToggleLogo();
  666.     return 0;
  667. }
  668.