开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
xtractor.c
资源名称：xtractor.zip　[点击查看]
上传用户：xmgzy123
上传日期：2007-01-07
资源大小：373k
文件大小：43k
源码类别：

SCSI/ASPI

开发平台：

WINDOWS

xtractor.c：源码内容
  1. /*
  2.  * xtractor.c - Copyright (C) 1999,2000 Jay A. Key
  3.  *
  4.  * Main file for CD-DA X-Tractor, a CD audio extaction tool for 32-bit
  5.  * windows platforms.
  6.  *
  7.  **********************************************************************
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22.  *
  23.  */
  24. #include <windows.h>
  25. #include <wingdi.h>
  26. #include <commctrl.h>
  27. #include <math.h>
  29. #include "akrip/akrip32.h"
  30. #include "resources.h"
  31. #include "trackwnd.h"
  32. #include "globals.h"
  33. #include "id3.h"
  34. #include "riptracks.h"
  35. #include "statusbar.h"
  36. #include "cddbdlg.h"
  37. #include "config.h"
  39. #if (__IBMC__)                         /* BWT (20000127)                   */
  40. WINCOMMCTRLAPI void WINAPI InitCommonControls(void);   /* BWT (20000127)   */
  41. #endif                                 /* BWT (20000127)                   */
  43. void logMessage( int which, UINT uMsg, WPARAM wParam, LPARAM lParam );
  44. LRESULT CALLBACK Edit0Proc( HWND, UINT, WPARAM, LPARAM );
  45. LRESULT CALLBACK Edit1Proc( HWND, UINT, WPARAM, LPARAM );
  46. LRESULT CALLBACK Edit2Proc( HWND, UINT, WPARAM, LPARAM );
  50. LRESULT CALLBACK akripWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
  51. HWND createToolbar( HWND hWnd, HINSTANCE hInst );
  52. HWND createHeader( HWND hWnd, HINSTANCE hInst );
  53. void doPaint( HWND hWnd );
  54. void ComputeHeaderPos( HWND hParent );
  55. void handleToolbarNotify( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
  56. int WindowHeight( HWND hWnd );
  57. void RefreshTrackList( void );
  58. int DoConfig( HWND hParent, HINSTANCE hInst, UINT uiStartPage );
  59. void InitAKRip( void );
  60. void DeinitAKRip( void );
  61. void MSB2DWORD( DWORD *d, BYTE *b );
  62. int readRegSZ( HKEY hKey, LPCTSTR lpszValue, LPSTR lpszData, DWORD dwDataLen );
  63. int readRegDWORD( HKEY hKey, LPCTSTR lpszValue, DWORD *pdw );
  64. int doTrackContextMenu( HWND hParent, HWND hChild, LPARAM lParam );
  65. BOOL InitGauge( HINSTANCE hInst );
  66. BOOL RipTrackDlgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
  67. BOOL loadBladeEnc( void );
  68. void disableAutoPlay( void );
  69. void restoreAutoPlay( void );
  70. void GetEditItemText( int iCtlId, HWND hCtl );
  71. BOOL CALLBACK ID3InfoDlgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
  72. void SetEditItemText( int iCtlId, char *s );
  73. void CheckEnableID3MenuItem( HWND hWnd );
  74. void CheckEnableCDDBMenuItem( HWND hWnd );
  75. void CheckEnableHiColorMenuItem( HWND hWnd );
  76. BOOL CALLBACK AboutDialogProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
  77. void InitBmpPanel( void );
  78. void DynamicAboutDialog( HWND hParent );
  79. void ShowHelpFile( HWND hWnd, int topic );
  80. void DiffTimeToString( double d, char *buf );
  81. static void GetLineFromBuf( char *tgt, char **src, int len );
  82. void DoCDDBQuery( HWND hWnd );
  83. void SetTrackText( char *buf, int i );
  84. DWORD DoCDDBQueryThread( LPVOID lpParam );
  85. HCDROM findAvailableCD( void );
  86. BOOL RipTrackSegment( HWND hParent, HWND hTrckWnd );
  87. BOOL CALLBACK CDPropertiesDlgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
  88. void dbprintf( char *fmt, ... );
  89. DWORD GetDllVersion( LPCTSTR lpszDllName );
  90. LRESULT CALLBACK SubToolbarProc( HWND hWnd, UINT uMsg, WPARAM wParam,
  91.  LPARAM lParam );
  92. HIMAGELIST CreateToolbarImageList( HWND hWnd, HINSTANCE hInst, int idResource );
  93. int AddToolbarImages( HINSTANCE hInst, HWND hWnd, BOOL bSysColorChange, BOOL bToggleHiColor );
  94. BOOL DisplayIsHiColor( void );
  96. char szClassName[] = "xtractor";
  98. static int  iStatusHeight = 0;
  99. static int  iToolbarHeight;
  100. HWND hStatus = NULL;
  101. HWND hTrackWnd = NULL;
  102. static HWND hToolbar = NULL;
  103. static HWND hEditArtist, hEditAlbum;
  104. static HIMAGELIST hImgLists[3] = { NULL, NULL, NULL };
  105. static WNDPROC lpfnToolbarProc = NULL;
  107. static char regKeyName[] = "SOFTWARE\AKSoft\X-Tractor";
  108. static unsigned long ulOldAutorun = (unsigned long)0x95;
  109. static char szOldAutoPlay[256] = "Play";
  110. static char regAutoPlay[] = "Software\Microsoft\Windows\CurrentVersion\Policies\Explorer";
  111. static char regAutoAudioCD[] = "AudioCD\Shell";
  113. /*
  114.  * Global variables
  115.  */
  116. int WINAPI WinMain( HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpszCmdLine,
  117.     int nCmdShow )
  118. {
  119.   WNDCLASSEX wc;
  120.   HWND hWnd;
  121.   MSG msg;
  122.   RECT rc;
  123.   static int aStatusWidths[3] = {40, 290,-1};
  124.   INITCOMMONCONTROLSEX ic;
  126.   ic.dwSize = sizeof(ic);
  127.   ic.dwICC = ICC_WIN95_CLASSES;
  128.   InitCommonControlsEx(&ic);
  130.   ghInstance = hInst;
  132.   hPrevInst = hPrevInst;
  133.   lpszCmdLine = lpszCmdLine;
  135.   InitTrackWnd( hInst );
  136.   InitAKRip( );
  137.   InitGauge( hInst );
  138.   bMP3 = loadBladeEnc();
  139.   InitBmpPanel();
  141.   ZeroMemory( &wc, sizeof(wc) );
  142.   wc.cbSize        = sizeof(WNDCLASSEX);
  143.   wc.style         = CS_HREDRAW | CS_VREDRAW;
  144.   wc.lpfnWndProc   = (WNDPROC)akripWndProc;
  145.   wc.hInstance     = hInst;
  146.   wc.hIcon         = LoadIcon( hInst, "ALTRIP3" );
  147.   wc.hCursor       = LoadCursor( NULL, IDC_ARROW );
  148.   wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
  149.   wc.lpszClassName = szClassName;
  150.   wc.lpszMenuName  = "akripMenu";
  151.   wc.hIconSm       = LoadIcon( hInst, "ALTRIP3" );
  153.   if ( !RegisterClassEx( &wc ) )
  154.     return FALSE;
  156.   hWnd = CreateWindowEx( WS_EX_APPWINDOW, szClassName, "CD-DA X-Tractor",
  157.  WS_OVERLAPPEDWINDOW,
  158.  CW_USEDEFAULT, CW_USEDEFAULT,
  159.  540, 400,
  160.  NULL, NULL, hInst, NULL );
  162.   if ( !hWnd )
  163.     return FALSE;
  165.   hToolbar = createToolbar( hWnd, hInst );
  166.   iToolbarHeight = WindowHeight( hToolbar );
  168.   hStatus = CreateStatusWindow( WS_VISIBLE | WS_CHILD | SBARS_SIZEGRIP,
  169. "", hWnd, IDM_STATUSBAR );
  170.   SendMessage( hStatus, SB_SETPARTS, 3, (LPARAM)aStatusWidths );
  171.   iStatusHeight = WindowHeight( hStatus );
  173.   GetClientRect( hWnd, &rc );
  175.   rc.top += iToolbarHeight;
  176.   rc.bottom -= iStatusHeight;
  178.   hTrackWnd = createTrackWnd( hWnd, hInst, IDM_TRACKWND, &rc );
  180.   if ( bAutoTOC )
  181.     {
  182.       SendMessage( hWnd, WM_COMMAND, MAKEWPARAM( IDM_REFRESH, BN_CLICKED ), 0L );
  183.       if ( bAutoCheck )
  184. SendMessage( hTrackWnd, WM_CHECKTRACK, (WPARAM)ALLTRACKS, (LPARAM)TRUE );
  185.     }
  187.   ShowWindow( hWnd, nCmdShow );
  188.   UpdateWindow( hWnd );
  190.   disableAutoPlay();
  192.   while( GetMessage( &msg, NULL, 0, 0 ) )
  193.     {
  194.       TranslateMessage( &msg );
  195.       DispatchMessage( &msg );
  196.     }
  198.   restoreAutoPlay();
  200.   if ( hImgLists[0] ) ImageList_Destroy( hImgLists[0] );
  201.   if ( hImgLists[1] ) ImageList_Destroy( hImgLists[1] );
  202.   if ( hImgLists[2] ) ImageList_Destroy( hImgLists[2] );
  204.   return msg.wParam;
  205. }
  208. LRESULT CALLBACK akripWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  209. {
  210.   RECT rc;
  212.   switch( uMsg )
  213.     {
  214.     case WM_CREATE:
  215.       CheckEnableID3MenuItem( hWnd );
  216.       CheckEnableCDDBMenuItem( hWnd );
  217.       if ( GetDllVersion( "comctl32.dll" ) < MAKELONG(4,71) )
  218. {
  219.   // disallow switching between 8- and 24-bit bitmaps in the toolbar
  220.   bHiColor = FALSE;
  221.   EnableMenuItem( GetMenu( hWnd ), IDM_HICOLOR, MF_BYCOMMAND | MF_GRAYED );
  222. }
  223.       CheckEnableHiColorMenuItem( hWnd );
  224.     break;
  226.     case WM_COMMAND:
  227.       switch( LOWORD( wParam ) )
  228. {
  229. case IDM_EXIT:
  230.   DestroyWindow( hWnd );
  231.   break;
  232. case IDM_REFRESH:
  233.   if ( !bInCDDBQuery )
  234.     {
  235.       RefreshTrackList( );
  236.       asSetID3Info( ID3_ERASE, NULL, 0 );
  237.       SetEditItemText( IDE_ARTIST, "" );
  238.       SetEditItemText( IDE_ALBUM, "" );
  239.       if ( bAutoCheck )
  240. SendMessage( hTrackWnd, WM_CHECKTRACK, (WPARAM)ALLTRACKS, (LPARAM)TRUE );
  241.       if ( bCDDB )
  242. DoCDDBQuery( hWnd );
  243.     }
  244.   break;
  245. case IDM_RIP:
  246.   DialogBoxParam( ghInstance, "RipTrackDialog", hWnd, (DLGPROC)RipTrackDlgProc, (LPARAM)hTrackWnd );
  247.   break;
  248. case IDM_ID3:
  249. case IDM_ID3TAGEDIT:
  250.   DialogBox( ghInstance, "ID3InfoDialog", hWnd, (DLGPROC)ID3InfoDlgProc );
  251.   break;
  252. case IDM_CDPARMS:
  253.   DialogBox( ghInstance, "CDPropertiesDialog", hWnd, (DLGPROC)CDPropertiesDlgProc );
  254.   break;
  255. case IDM_CDSETTINGS:
  256. case IDM_OPTIONS:
  257.   DoConfig( hWnd, ghInstance, 0 );
  258.   break;
  259. case IDM_DIRSETTINGS:
  260.   DoConfig( hWnd, ghInstance, 1 );
  261.   break;
  262. case IDM_MP3SETTINGS:
  263.   DoConfig( hWnd, ghInstance, 2 );
  264.   break;
  265. case IDM_CDDBSETTINGS:
  266.   DoConfig( hWnd, ghInstance, 3 );
  267.   break;
  268. case IDM_CHECKALL:
  269.   SendMessage( hTrackWnd, WM_CHECKTRACK, ALLTRACKS, (LPARAM)TRUE );
  270.   break;
  271. case IDM_INVERT:
  272.   SendMessage( hTrackWnd, WM_INVERTCHECK, ALLTRACKS, 0L );
  273.   break;
  274. case IDM_RENAME:
  275.   SendMessage( hTrackWnd, WM_RENSELTRACK, 0, 0L );
  276.   break;
  277. case IDE_ARTIST:
  278. case IDE_ALBUM:
  279.   if ( (int)HIWORD( wParam ) == EN_CHANGE )
  280.     GetEditItemText( (int)LOWORD( wParam ), (HWND)lParam );
  281.   break;
  282. case IDM_ENABLEID3:
  283.   bID3 = !bID3;
  284.   CheckEnableID3MenuItem( hWnd );
  285.   break;
  286. case IDM_ENABLECDDB:
  287.   bCDDB = !bCDDB;
  288.   CheckEnableCDDBMenuItem( hWnd );
  289.   break;
  290. case IDM_HICOLOR:
  291.   bHiColor = !bHiColor;
  292.   CheckEnableHiColorMenuItem( hWnd );
  293.   AddToolbarImages( ghInstance, hToolbar, FALSE, TRUE );
  294.   break;
  295. case IDM_ABOUT:
  296.   DynamicAboutDialog( hWnd );
  297.   break;
  298. case IDM_HELPTOPICS:
  299.   ShowHelpFile( hWnd, IDM_HELPTOPICS );
  300.   break;
  301. case IDM_RIPSEGMENT:
  302.   RipTrackSegment( hWnd, hTrackWnd );
  303.   break;
  304. }
  305.       break;
  307.     case WM_DESTROY:
  308.       DeinitAKRip( );
  309.       PostQuitMessage( 0 );
  310.       break;
  312.     case WM_NOTIFY:
  313.       switch( wParam )
  314. {
  315. case IDM_TOOLBAR:
  316.   handleToolbarNotify( hWnd, uMsg, wParam, lParam );
  317.   break;
  318. }
  319.       break;
  321.     case WM_SYSCOLORCHANGE:
  322.       SendMessage( hToolbar, uMsg, wParam, lParam );
  323.       SendMessage( hTrackWnd, uMsg, wParam, lParam );
  324.       break;
  326.     case WM_PAINT:
  327.       doPaint( hWnd );
  328.       break;
  330.     case WM_SIZE:
  331.       SendMessage( hToolbar, TB_AUTOSIZE, 0, 0L );
  332.       GetClientRect( hWnd, &rc );
  333.       MoveWindow( hStatus, 0, rc.bottom - iStatusHeight, rc.right - rc.left, rc.bottom, TRUE );
  334.       rc.top += iToolbarHeight;
  335.       rc.bottom -= iStatusHeight;
  336.       MoveWindow( hTrackWnd, 0, rc.top, rc.right - rc.left, rc.bottom - rc.top, TRUE );
  337.       break;
  339.     default:
  340.       return DefWindowProc( hWnd, uMsg, wParam, lParam );
  341.     }
  343.   return 0L;
  344. }
  347. /*
  348.  * Subclass wndproc for Toolbar.  Handles the WM_SYSCOLORCHANGE and
  349.  * also the tooltip messages
  350.  */
  351. #define WM_SETSUBCLASSPROC  (WM_USER+999)
  352. LRESULT CALLBACK SubToolbarProc( HWND hWnd, UINT uMsg, WPARAM wParam,
  353.  LPARAM lParam )
  354. {
  355.   LPTOOLTIPTEXT lpt = (LPTOOLTIPTEXT)lParam;
  357.   if ( uMsg == WM_SETSUBCLASSPROC )
  358.     {
  359.       lpfnToolbarProc = (WNDPROC)GetWindowLong( hWnd, GWL_WNDPROC );
  360.       SetWindowLong( hWnd, GWL_WNDPROC, (LONG)SubToolbarProc );
  361.       return 0L;
  362.     }
  364.   switch( uMsg )
  365.     {
  366.     case WM_SYSCOLORCHANGE:
  367.       AddToolbarImages( ghInstance, hWnd, TRUE, FALSE );
  368.       return CallWindowProc( lpfnToolbarProc, hWnd, uMsg, wParam, lParam );
  370.     case WM_NOTIFY:
  371.       if ( lpt->hdr.code == TTN_GETDISPINFOA || lpt->hdr.code == TTN_GETDISPINFOW )
  372. {
  373.   lpt->hinst = ghInstance;
  374.   lpt->lpszText = MAKEINTRESOURCE(lpt->hdr.idFrom);
  375.   return 0L;
  376. }
  377.       break;
  379.     default:
  380.       break;
  381.     }
  383.   return CallWindowProc( lpfnToolbarProc, hWnd, uMsg, wParam, lParam );
  384. }
  387. HIMAGELIST CreateToolbarImageList( HWND hWnd, HINSTANCE hInst, int idResource )
  388. {
  389.   HIMAGELIST retVal;
  390.   HBITMAP hBmp;
  392.   retVal = ImageList_Create( 50, 50, ILC_COLOR24 | ILC_MASK, 5, 0 );
  393.   hBmp = LoadBitmap( hInst, MAKEINTRESOURCE(idResource) );
  394.   ImageList_AddMasked( retVal, hBmp, RGB(192,192,192) );
  395.   DeleteObject( hBmp );
  397.   return retVal;
  398. }
  401. int AddToolbarImages( HINSTANCE hInst, HWND hWnd, BOOL bSysColorChange,
  402.       BOOL bToggleHiColor )
  403. {
  404.   TBADDBITMAP tbBitmaps;
  405.   HIMAGELIST hOldImageList[3] = { NULL, NULL, NULL };
  406.   int iBmp, iHotBmp, iOldBmp;
  408.   if ( bHiColor )
  409.     {
  410.       iBmp = idToolbar24Bmp;
  411.       iOldBmp = idToolbarBmp;
  412.       iHotBmp = idToolbarHot24Bmp;
  413.     }
  414.   else
  415.     {
  416.       iBmp = idToolbarBmp;
  417.       iOldBmp = idToolbar24Bmp;
  418.       iHotBmp = idToolbarHotBmp;
  419.     }
  421.   // check if we can use the flat toolbar with "hot" buttons
  422.   if ( GetDllVersion( "comctl32.dll" ) < MAKELONG(4,71) )
  423.     {
  424.       /*
  425.        * Only add the bitmap on initial creation when using older version
  426.        * of comctl32.dll.  Otherwise we ignore the call.
  427.        */
  428.       if ( !bSysColorChange && !bToggleHiColor )
  429. {
  430.   // use old style
  431.   tbBitmaps.hInst = NULL;
  432.   tbBitmaps.nID = (UINT)LoadBitmap( hInst, MAKEINTRESOURCE( iBmp ) );
  433.   SendMessage( hWnd, TB_ADDBITMAP, 5, (LPARAM)&tbBitmaps );
  434. }
  435.     }
  436.   else
  437.     {
  438.       /*
  439.        * We'll actually change imagelists for v4.71+ of comctl32.dll.
  440.        */
  441.       if ( bSysColorChange || bToggleHiColor )
  442. {
  443.   hOldImageList[0] = hImgLists[0];
  444.   hOldImageList[1] = hImgLists[1];
  445.   hOldImageList[2] = hImgLists[2];
  446. }
  447.       // create image lists
  448.       hImgLists[0] = CreateToolbarImageList( hWnd, hInst, iBmp );
  449.       SendMessage( hWnd, TB_SETIMAGELIST, 0, (LPARAM)hImgLists[0] );
  450. #if _CONFIG_FLAT_TOOLBAR
  451.       hImgLists[1] = CreateToolbarImageList( hWnd, hInst, iHotBmp );
  452.       SendMessage( hWnd, TB_SETHOTIMAGELIST, 0, (LPARAM)hImgLists[1] );
  453. #endif
  454.     }
  456.   if ( hOldImageList[0] ) ImageList_Destroy( hOldImageList[0] );
  457.   if ( hOldImageList[1] ) ImageList_Destroy( hOldImageList[1] );
  458.   if ( hOldImageList[2] ) ImageList_Destroy( hOldImageList[2] );
  460.   return 0;
  461. }
  464. /*
  465.  * Creates the toolbar, loads bitmap resources, etc.  InitCommonControls()
  466.  * must be called prior to calling this function
  467.  */
  468. HWND createToolbar( HWND hWnd, HINSTANCE hInst )
  469. {
  470.   HWND hRet;
  471.   TBBUTTON tb[4];
  472.   int idx = 0;
  473.   RECT rc;
  474.   DWORD dwToolbarStyle = WS_CHILD | WS_BORDER | WS_VISIBLE | TBSTYLE_TOOLTIPS;
  476.   memset( tb, 0, sizeof(TBBUTTON[4]) );
  477.   tb[idx].iBitmap = 0;
  478.   tb[idx].idCommand = IDM_REFRESH;
  479.   tb[idx].fsState = TBSTATE_ENABLED;
  480.   tb[idx].fsStyle = TBSTYLE_BUTTON;
  481.   tb[idx].dwData = 0;
  482.   tb[idx++].iString = -1;
  484.   tb[idx].iBitmap = 2;
  485.   tb[idx].idCommand = IDM_RIP;
  486.   tb[idx].fsState = TBSTATE_ENABLED;
  487.   tb[idx].fsStyle = TBSTYLE_BUTTON;
  488.   tb[idx].dwData = 0;
  489.   tb[idx++].iString = -1;
  491. #if 0
  492.   tb[idx].iBitmap = 1;
  493.   tb[idx].idCommand = IDM_MP3;
  494.   tb[idx].fsState = TBSTATE_ENABLED;
  495.   tb[idx].fsStyle = TBSTYLE_CHECK;
  496.   tb[idx].dwData = 0;
  497.   tb[idx++].iString = -1;
  498. #endif
  500.   tb[idx].iBitmap = 3;
  501.   tb[idx].idCommand = IDM_OPTIONS;
  502.   tb[idx].fsState = TBSTATE_ENABLED;
  503.   tb[idx].fsStyle = TBSTYLE_BUTTON;
  504.   tb[idx].dwData = 0;
  505.   tb[idx++].iString = -1;
  507.   tb[idx].iBitmap = 4;
  508.   tb[idx].idCommand = IDM_ID3;
  509.   tb[idx].fsState = TBSTATE_ENABLED;
  510.   tb[idx].fsStyle = TBSTYLE_BUTTON;
  511.   tb[idx].dwData = 0;
  512.   tb[idx++].iString = -1;
  514.   hRet = CreateWindowEx( WS_EX_TOOLWINDOW, TOOLBARCLASSNAME, "",
  515.  dwToolbarStyle,
  516.  0, 0, 100, 64,
  517.  hWnd, (HMENU)IDM_TOOLBAR, hInst, NULL );
  519. #if _CONFIG_FLAT_TOOLBAR
  520.   dwToolbarStyle = (DWORD)SendMessage( hRet, TB_GETSTYLE, 0, 0L );
  521.   dwToolbarStyle |= TBSTYLE_FLAT;
  522.   SendMessage( hRet, TB_SETSTYLE, 0, (LPARAM)dwToolbarStyle );
  523. #endif
  525.   SendMessage( hRet, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0L );
  526.   SendMessage( hRet, TB_SETBITMAPSIZE, 0, MAKELONG( 50, 46 ) );
  527.   SendMessage( hRet, TB_SETBUTTONSIZE, 0, MAKELONG( 58, 53 ) );
  528.   SendMessage( hRet, TB_AUTOSIZE, 0, 0L );
  529.   AddToolbarImages( hInst, hRet, FALSE, FALSE );
  531.   SendMessage( hRet, TB_ADDBUTTONS, idx, (LPARAM)&tb );
  532.   SubToolbarProc( hRet, WM_SETSUBCLASSPROC, 0, 0L );
  534.   SendMessage( hRet, TB_GETITEMRECT, (WPARAM)(idx-1), (LPARAM)&rc );
  536.   CreateWindowEx( 0L, "STATIC", "Artist: ",
  537.   SS_RIGHT | WS_CHILD | WS_VISIBLE,
  538.   rc.right + 10, rc.top + 6, 60, 20, hRet,
  539.   (HMENU)NULL, hInst, NULL );
  540.   CreateWindowEx( 0L, "STATIC", "Album: ",
  541.   SS_RIGHT | WS_CHILD | WS_VISIBLE,
  542.   rc.right + 10, rc.top + 32, 60, 20, hRet,
  543.   (HMENU)NULL, hInst, NULL );
  544.   hEditArtist = CreateWindowEx( WS_EX_CLIENTEDGE, "EDIT", "",
  545.   ES_LEFT | WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL
  546.   | WS_BORDER | WS_TABSTOP | WS_GROUP ,
  547.   rc.right + 72, rc.top + 2, 210, 24, hRet,
  548.   (HMENU)IDE_ARTIST, hInst, NULL );
  550.   hEditAlbum = CreateWindowEx( WS_EX_CLIENTEDGE, "EDIT", "",
  551.   ES_LEFT | WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL
  552.   | WS_BORDER | WS_TABSTOP,
  553.   rc.right + 72, rc.top + 26, 210, 24, hRet,
  554.   (HMENU)IDE_ALBUM, hInst, NULL );
  556.   return hRet;
  557. }
  560. void doPaint( HWND hWnd )
  561. {
  562.   PAINTSTRUCT p;
  563.   HDC hDC;
  565.   hDC = BeginPaint( hWnd, &p );
  566.   if ( !hDC )
  567.     return;
  569.   EndPaint( hWnd, &p );
  570. }
  573. void handleToolbarNotify( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  574. {
  575. #if 0
  576.   LPTOOLTIPTEXT lpt = (LPTOOLTIPTEXT)lParam;
  578.   if ( lpt->hdr.code == TTN_NEEDTEXT )
  579.     {
  580.       // we should put in tool-text code here
  581.       //OutputDebugString( "Got a TTN_NEEDTEXT" );
  582.     }
  583. #else
  584.   hWnd = hWnd; uMsg = uMsg; wParam = wParam; lParam = lParam;
  585. #endif
  586. }
  589. int WindowHeight( HWND hWnd )
  590. {
  591.   RECT rc;
  593.   GetWindowRect( hWnd, &rc );
  594.   return ( rc.bottom - rc.top );
  595. }
  598. void DoCDDBQuery( HWND hWnd )
  599. {
  600.   DWORD dwThreadID;
  602.   bInCDDBQuery = TRUE;
  604.   CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)DoCDDBQueryThread,
  605. (LPVOID)hWnd, 0, &dwThreadID );
  606. }
  609. DWORD DoCDDBQueryThread( LPVOID lpParam )
  610. {
  611.   CDDBQUERYITEM cdq[5];
  612.   CDDBQUERY query;
  613.   char linebuf[81];
  614.   int i;
  615.   BOOL bCDDB = FALSE;
  616.   char *buf, *p;
  617.   HWND hWnd = (HWND)lpParam;
  619.   ZeroMemory( cdq, sizeof(cdq) );
  621.   buf = (char *)GlobalAlloc( GPTR, 32000 );
  623. #if 1
  624.   CDDBSetOption( CDDB_OPT_USECDPLAYERINI, "", TRUE );
  625. #endif
  626.   CDDBSetOption( CDDB_OPT_SERVER, szCDDBServer, 0 );
  627.   CDDBSetOption( CDDB_OPT_CGI, szCGI, 0 );
  628.   CDDBSetOption( CDDB_OPT_USEPROXY, "", bUseProxy );
  629.   if ( bUseProxy )
  630.     {
  631.       CDDBSetOption( CDDB_OPT_PROXY, szProxyAddr, 0 );
  632.       CDDBSetOption( CDDB_OPT_PROXYPORT, "", iProxyPort );
  633.     }
  634.   CDDBSetOption( CDDB_OPT_USER, "user@akrip.sourceforge.net", 0 );
  635.   CDDBSetOption( CDDB_OPT_AGENT, "xtractor 0.12", 0 );
  637.   SetStatusMessage( "Contacting CDDB Server..." );
  638.   query.num = 5;
  639.   query.q = cdq;
  640.   bCDDB = (CDDBQuery( hCD, &query ) == SS_COMP);
  641. #if 0
  642.   if ( !bCDDB )
  643.     OutputDebugString( "Something's not quite right here..." );
  644.   wsprintf( linebuf, "After CDDBQuery(), num == %d", query.num );
  645.   OutputDebugString( linebuf );
  646. #endif
  647.   if ( bCDDB && (query.num == 0) )
  648.     {
  649.       SetStatusMessage( "No matches in CDDB database..." );
  650.     }
  652.   if ( query.num )
  653.     {
  654.       // If we're in the middle of a rip operation, just use the first one
  655.       // as a default.  Otherwise, pop up a dialog to let the user choose
  656.       // which one to use
  657.       if ( bRippingTracks || (query.num == 1) )
  658. {
  659.   SetStatusMessage( "Retrieving CD info..." );
  660.   query.num = 0;
  661.   bCDDB = (CDDBGetDiskInfo( &cdq[0], buf, 32000 ) == SS_COMP);
  662.   if ( !bCDDB )
  663.     {
  664.       SetStatusMessage( "Error retrieving CDDB info..." );
  665.     }
  666. }
  667.       else
  668. {
  669.   DialogBoxParam( ghInstance, "MultipleCDDBQueryDialog", hWnd,
  670.   (DLGPROC)MultipleCDDBQueryDlgProc, (LPARAM)&query );
  671.   if ( query.num < 0 )
  672.     {
  673.       SetStatusMessage( "CDDB Query cancelled..." );
  674.       bCDDB = FALSE;
  675.     }
  676.   else
  677.     {
  678.       SetStatusMessage( "Retrieving CD info..." );
  679.       bCDDB = (CDDBGetDiskInfo( &cdq[query.num], buf, 32000 ) == SS_COMP);
  680.       if ( !bCDDB )
  681. {
  682.   SetStatusMessage( "Error retrieving CDDB info..." );
  683. }
  684.     }
  685. }
  686.     }
  689.   // probably want to pop up an error message here
  690.   if ( !bCDDB )
  691.     {
  692.       bInCDDBQuery = FALSE;
  693.       GlobalFree( (HGLOBAL)buf );  
  694.       return 0;
  695.     }
  697.   SetEditItemText( IDE_ARTIST, cdq[query.num].artist );
  698.   SetEditItemText( IDE_ALBUM, cdq[query.num].title );
  699.   id3CDDBCat2Genre( cdq[query.num].categ );
  701.   p = buf;
  702.   i = 0;
  703.   while( p && *p )
  704.     {
  705.       GetLineFromBuf( linebuf, &p, 81 );
  706.       if ( !strncmp( linebuf, "TTITLE", 6 ) )
  707. {
  708.   SetTrackText( linebuf, i );
  709.   i++;
  710. }
  711.       else if ( linebuf[0] == '.' )
  712. p = NULL;     // last line read
  713.     }
  715.   GlobalFree( (HGLOBAL)buf );  
  716.   bInCDDBQuery = FALSE;
  718.   UpdateStatusBar();
  719.   return 0;
  720. }
  723. void SetTrackText( char *buf, int i )
  724. {
  725.   char *p;
  727.   p = strstr( buf, "=" );
  728.   if ( p )
  729.     {
  730.       p++;
  731.       if ( *p )
  732. SendMessage( hTrackWnd, WM_SETTRACKTEXT, (WPARAM)i, (LPARAM)p );
  733.     }
  734. }
  737. void RefreshTrackList( void )
  738. {
  739.   ADDTRACK at;
  740.   TOC toc;
  741.   int i;
  743.   SendMessage( hTrackWnd, WM_DELTRACK, ALLTRACKS, 0L );
  745.   ZeroMemory( &toc, sizeof(TOC) );
  746.   ModifyCDParms( hCD, CDP_MSF, (DWORD)FALSE );
  747.   ReadTOC( hCD, &toc );
  749.   for( i = toc.firstTrack; i <= toc.lastTrack; i++ )
  750.     {
  751.       TOCTRACK *t;
  752.       int idx;
  754.       idx = i - toc.firstTrack;
  756.       ZeroMemory( &at, sizeof(at) );
  757.       wsprintf( at.name, "Track %d", i );
  759.       t = &(toc.tracks[idx]);
  760.       MSB2DWORD( &(at.start), t->addr );
  761.       if ( t->ADR & 0x04 )
  762. {
  763.   // will need to fix the leadout detection code here
  764.   at.bData = TRUE;
  765.   lstrcpy( at.name, "Data Track" );
  766. }
  768.       t = &(toc.tracks[idx+1]);
  769.       MSB2DWORD( &(at.len), t->addr );
  770.       at.len -= at.start;
  772.       #define LEADOUT  (150*75)
  773.       // if the next track is a data track, subtract 150 seconds of leadout
  774.       if ( (t->ADR & 0x04) && (at.len > LEADOUT) )
  775. at.len -= LEADOUT;
  777.       SendMessage( hTrackWnd, WM_ADDTRACK, 0, (LPARAM)&at );
  778.     }
  779. }
  783. /*
  784.  * Save parameters to the registry
  785.  */
  786. void DeinitAKRip( void )
  787. {
  788.   HKEY hKey;
  789.   DWORD dwDisposition, driveInfo, dwAutoTOC;
  790.   DWORD dwTmp;
  791.   LONG retVal;
  793.   retVal = RegCreateKeyEx( HKEY_LOCAL_MACHINE, regKeyName, 0L,
  794.  "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,
  795.  NULL, &hKey, &dwDisposition );
  796.   if ( retVal != ERROR_SUCCESS )
  797.     {
  798.       return;
  799.     }
  801.   RegSetValueEx( hKey, "numRip", 0L, REG_DWORD, (BYTE *)(&maxRip),
  802.  sizeof(DWORD) );
  803.   RegSetValueEx( hKey, "jitterCheck", 0L, REG_DWORD, (LPBYTE)&jitterCheck,
  804.  4L );
  805.   RegSetValueEx( hKey, "overlap", 0L, REG_DWORD, (LPBYTE)&numOverlap, 4L );
  806.   RegSetValueEx( hKey, "readMode", 0L, REG_DWORD, (LPBYTE)&readMode, 4L );
  807.   dwAutoTOC = (DWORD)bAutoTOC;
  808.   RegSetValueEx( hKey, "autoTOC", 0L, REG_DWORD, (LPBYTE)&dwAutoTOC, 4L );
  809.   dwTmp = (DWORD)bAutoCheck;
  810.   RegSetValueEx( hKey, "autoCheck", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  811.   dwTmp = (DWORD)bMP3;
  812.   RegSetValueEx( hKey, "MP3", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  813.   dwTmp = (DWORD)wBitrate;
  814.   RegSetValueEx( hKey, "bitrate", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  815.   dwTmp = (DWORD)wMaxBitrate;
  816.   RegSetValueEx( hKey, "maxbitrate", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  817.   dwTmp = (DWORD)wMode;
  818.   RegSetValueEx( hKey, "mpegmode", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  819.   dwTmp = (DWORD)bID3;
  820.   RegSetValueEx( hKey, "id3level", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  821.   dwTmp = bCRC;
  822.   RegSetValueEx( hKey, "crc", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  823.   dwTmp = bUseProxy;
  824.   RegSetValueEx( hKey, "useproxy", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  825.   dwTmp = iProxyPort;
  826.   RegSetValueEx( hKey, "proxyport", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  827.   RegSetValueEx( hKey, "proxyaddr", 0L, REG_SZ, szProxyAddr, lstrlen(szProxyAddr)+1 );
  828.   RegSetValueEx( hKey, "cddbaddr", 0L, REG_SZ, szCDDBServer, lstrlen(szCDDBServer)+1 );
  829.   RegSetValueEx( hKey, "cddbcgi", 0L, REG_SZ, szCGI, lstrlen(szCGI)+1 );
  830.   dwTmp = bCDDB;
  831.   RegSetValueEx( hKey, "enablecddb", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  832.   dwTmp = iEncoder;
  833.   RegSetValueEx( hKey, "encoder", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  834.   dwTmp = (DWORD)bHiColor;
  835.   RegSetValueEx( hKey, "hicolor", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  836.   dwTmp = 0;
  837.   if ( bVBR )
  838.     dwTmp |= 0x80000000;
  839.   if ( bVBRHeader )
  840.     dwTmp |= 0x40000000;
  841.   dwTmp |= ( (wMaxBitrate & 0x1FF) << 21 );
  842.   dwTmp |= ( (nQuality & 0x03) << 19 );
  843.   dwTmp |= ( (nVBRQuality & 0x0F) << 15 );
  844.   RegSetValueEx( hKey, "lameopts", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  846.   if ( cdlistIdx >= 0 )
  847.     {
  848.       driveInfo = ((DWORD)bReadType) << 24 |
  849. ((DWORD)cdlist.cd[cdlistIdx].ha) << 16 |
  850. ((DWORD)cdlist.cd[cdlistIdx].tgt) << 8 |
  851. ((DWORD)cdlist.cd[cdlistIdx].lun);
  852.       RegSetValueEx( hKey, "driveInfo", 0L, REG_DWORD,
  853.      (LPBYTE)&driveInfo, 4L );
  854.     }
  855.   else
  856.     RegDeleteValue( hKey, "driveInfo" );
  858.   RegSetValueEx( hKey, "wavOutputdir", 0L, REG_SZ, (LPBYTE)szWavOutputDir,
  859.  lstrlen( szWavOutputDir)+1 );
  860.   RegSetValueEx( hKey, "mp3Outputdir", 0L, REG_SZ, (LPBYTE)szMP3OutputDir,
  861.  lstrlen( szMP3OutputDir)+1 );
  863.   RegCloseKey( hKey );
  864. }
  866. /*
  867.  * void InitAKRip( void );
  868.  *
  869.  * Reads initialization values from the registry, if present.  Currently
  870.  * looks for the following values:
  871.  *   numRip      - (DWORD) number of frames to read at once
  872.  *   jitterCheck - (DWORD) number of frames to try to match
  873.  *   overlap     - (DWORD) number of frames of overlap (at least
  874.  *                 jitterCheck + 1
  875.  *   autoTOC     - (DWORD) boolean, whether to automatically scan the TOC on
  876.  *                 startup
  877.  *   driveInfo   - (DWORD) ha, tgt, lun identifier of last CD unit used
  878.  *   driveString - (REG_SZ) string identifier of CD unit
  879.  *   driveVendor - (REG_SZ) vendor identifier of CD unit
  880.  *   driveProdID - (REG_SZ) product identifier of CD unit
  881.  *   driveRev    - (REG_SZ) hardware revision number of CD unit
  882.  *   driveVendSp - (REG_SZ) vendor specific info for CD unit
  883.  *   
  884.  */
  885. void InitAKRip( void )
  886. {
  887.   HKEY hKey;
  888.   DWORD dwDisposition, driveInfo, dwAutoTOC;
  889.   DWORD dwTmp;
  890.   LONG retVal;
  891.   CDREC cd;
  893.   // scan the list of available cd drives
  894.   ZeroMemory( &cdlist, sizeof(CDLIST) );
  895.   cdlist.max = MAXCDLIST;
  896.   GetCDList( &cdlist );
  897.   cdlistIdx = -1;
  899.   memset( &cd, 0, sizeof(cd) );
  900.   memset( validFnameChar, 0xFF, 256 );
  901.   validFnameChar['\'] = 0;
  902.   validFnameChar['/'] = 0;
  903.   validFnameChar[':'] = 0;
  904.   validFnameChar['*'] = 0;
  905.   validFnameChar['?'] = 0;
  906.   validFnameChar['"'] = 0;
  907.   validFnameChar['<'] = 0;
  908.   validFnameChar['>'] = 0;
  909.   validFnameChar['|'] = 0;
  911.   retVal = RegCreateKeyEx( HKEY_LOCAL_MACHINE, regKeyName, 0L,
  912.  "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,
  913.  NULL, &hKey, &dwDisposition );
  914.   if ( retVal != ERROR_SUCCESS )
  915.     {
  916.       // UserOutput( UO_ERROPENREG, regKeyName, retVal );
  917.       return;
  918.     }
  920.   if ( !readRegDWORD( hKey, "numRip", &maxRip ) )
  921.     {
  922.       maxRip = 26;  /* default value */
  923.       RegSetValueEx( hKey, "numRip", 0L, REG_DWORD, (BYTE *)(&maxRip),
  924.      sizeof(DWORD) );
  925.     }
  926.   if ( !readRegDWORD( hKey, "jitterCheck", &jitterCheck ) )
  927.     {
  928.       jitterCheck = 1;
  929.       RegSetValueEx( hKey, "jitterCheck", 0L, REG_DWORD,
  930.      (LPBYTE)&jitterCheck, 4L );
  931.     }
  932.   if ( !readRegDWORD( hKey, "overlap", &numOverlap ) )
  933.     {
  934.       numOverlap = jitterCheck + 2;
  935.       RegSetValueEx( hKey, "overlap", 0L, REG_DWORD,
  936.      (LPBYTE)&numOverlap, 4L );
  937.     }
  939.   if ( !readRegDWORD( hKey, "autoTOC", &dwAutoTOC ) )
  940.     {
  941.       dwAutoTOC = 1;
  942.       RegSetValueEx( hKey, "autoTOC", 0L, REG_DWORD,
  943.      (LPBYTE)&dwAutoTOC, 4L );
  944.     }
  945.   bAutoTOC = (BOOL)dwAutoTOC;
  947.   if ( !readRegDWORD( hKey, "autoCheck", &dwAutoTOC ) )
  948.     {
  949.       dwAutoTOC = 1;
  950.       RegSetValueEx( hKey, "autoCheck", 0L, REG_DWORD,
  951.      (LPBYTE)&dwAutoTOC, 4L );
  952.     }
  953.   bAutoCheck = (BOOL)dwAutoTOC;
  955.   if ( !readRegDWORD( hKey, "readMode", &readMode ) )
  956.     {
  957.       readMode = CDRM_JITTERONERR;
  958.       RegSetValueEx( hKey, "readMode", 0L, REG_DWORD,
  959.      (LPBYTE)&readMode, 4L );
  960.     }
  962.   if ( readRegDWORD( hKey, "MP3", &dwTmp ) )
  963.     bMP3 = (BOOL)dwTmp;
  964.   else
  965.     {
  966.       bMP3 = FALSE;
  967.       dwTmp = 0L;
  968.       RegSetValueEx( hKey, "MP3", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  969.     }
  971.   if ( readRegDWORD( hKey, "bitrate", &dwTmp ) )
  972.     wBitrate = (WORD)dwTmp;
  973.   else
  974.     {
  975.       wBitrate = 192;
  976.       dwTmp = 192L;
  977.       RegSetValueEx( hKey, "bitrate", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  978.     }
  980.   if ( readRegDWORD( hKey, "maxbitrate", &dwTmp ) )
  981.     wMaxBitrate = (WORD)dwTmp;
  982.   else
  983.     {
  984.       wMaxBitrate = 320;
  985.       dwTmp = 320L;
  986.       RegSetValueEx( hKey, "maxbitrate", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  987.     }
  989.   if ( readRegDWORD( hKey, "mpegmode", &dwTmp ) )
  990.     wMode = (WORD)dwTmp;
  991.   else
  992.     {
  993.       wMode = BE_MP3_MODE_STEREO;
  994.       dwTmp = BE_MP3_MODE_STEREO;
  995.       RegSetValueEx( hKey, "mpegmode", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  996.     }
  998.   if ( readRegDWORD( hKey, "id3level", &dwTmp ) )
  999.     bID3 = (BOOL)dwTmp;
  1000.   else
  1001.     {
  1002.       bID3 = FALSE;
  1003.       dwTmp = (DWORD)FALSE;
  1004.       RegSetValueEx( hKey, "id3level", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  1005.     }
  1007.   if ( readRegDWORD( hKey, "crc", &dwTmp ) )
  1008.     bCRC = (BOOL)dwTmp;
  1009.   else
  1010.     {
  1011.       bCRC = FALSE;
  1012.       dwTmp = (DWORD)FALSE;
  1013.       RegSetValueEx( hKey, "crc", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  1014.     }
  1016.   if ( readRegDWORD( hKey, "useproxy", &dwTmp ) )
  1017.     bUseProxy = (BOOL)dwTmp;
  1018.   else
  1019.     {
  1020.       bUseProxy = FALSE;
  1021.       dwTmp = (DWORD)FALSE;
  1022.       RegSetValueEx( hKey, "useproxy", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  1023.     }
  1025.   if ( readRegDWORD( hKey, "lameopts", &dwTmp ) )
  1026.     {
  1027.       bVBR        = (BOOL)(dwTmp & 0x80000000);
  1028.       bVBRHeader  = (BOOL)(dwTmp & 0x40000000);
  1029.       wMaxBitrate = (dwTmp >> 21) & 0x1FF;
  1030.       nQuality    = (dwTmp >> 19) & 0x03;
  1031.       nVBRQuality = (dwTmp >> 15) & 0x0F;
  1032.     }
  1034.   if ( readRegDWORD( hKey, "encoder", &dwTmp ) )
  1035.     iEncoder = (int)dwTmp;
  1036.   else
  1037.     {
  1038.       iEncoder = NOENCODER;
  1039.       dwTmp = NOENCODER;
  1040.       RegSetValueEx( hKey, "encoder", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  1041.    }
  1043.   if ( readRegDWORD( hKey, "proxyport", &dwTmp ) )
  1044.     iProxyPort = (int)dwTmp;
  1045.   else
  1046.     {
  1047.       iProxyPort = 0;
  1048.       dwTmp = 0;
  1049.       RegSetValueEx( hKey, "proxyport", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  1050.     }
  1052.   if ( !readRegSZ( hKey, "proxyaddr", szProxyAddr, 81 ) )
  1053.     lstrcpy( szProxyAddr, "" );
  1055.   if ( !readRegSZ( hKey, "cddbaddr", szCDDBServer, 81 ) )
  1056.     lstrcpy( szCDDBServer, "www.freedb.org" );
  1058.   if ( !readRegSZ( hKey, "cddbcgi", szCGI, 81 ) )
  1059.     lstrcpy( szCGI, "/~cddb/cddb.cgi" );
  1061.   if ( readRegDWORD( hKey, "enablecddb", &dwTmp ) )
  1062.     bCDDB = (BOOL)dwTmp;
  1063.   else
  1064.     {
  1065.       bCDDB = FALSE;
  1066.       dwTmp = 0;
  1067.       RegSetValueEx( hKey, "enablecddb", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  1068.     }
  1070.   if ( readRegDWORD( hKey, "hicolor", &dwTmp ) )
  1071.     bHiColor = (BOOL)dwTmp;
  1072.   else
  1073.     {
  1074.       bHiColor = DisplayIsHiColor();
  1075.       dwTmp = (DWORD)bHiColor;
  1076.       RegSetValueEx( hKey, "hicolor", 0L, REG_DWORD, (LPBYTE)&dwTmp, 4L );
  1077.     }
  1079.   if ( readRegDWORD( hKey, "driveInfo", &driveInfo ) )
  1080.     {
  1081.       //      BYTE bRead;
  1082.       GETCDHAND cdh;
  1084.       cd.ha = (BYTE)((0x00FF0000 & driveInfo) >> 16);
  1085.       cd.tgt = (BYTE)((0x0000FF00 & driveInfo) >> 8 );
  1086.       cd.lun = (BYTE)(0x000000FF & driveInfo);
  1087.       bReadType = (BYTE)((0xFF000000 & driveInfo) >> 24);
  1088.       memset( &cdh, 0, sizeof(GETCDHAND) );
  1089.       cdh.size       = sizeof(GETCDHAND);
  1090.       cdh.ver        = 1;
  1091.       cdh.ha         = cd.ha;
  1092.       cdh.tgt        = cd.tgt;
  1093.       cdh.lun        = cd.lun;
  1094.       cdh.readType   = bReadType;
  1095.       cdh.numOverlap = numOverlap;
  1096.       cdh.numJitter  = jitterCheck;
  1097.       hCD = GetCDHandle( &cdh );
  1098.       if ( !hCD )
  1099. MessageBox( NULL, "Unable to allocate default CD device", "X-Tractor",
  1100.     MB_APPLMODAL | MB_ICONSTOP | MB_OK );
  1101.       else
  1102. {
  1103.   BYTE i;
  1104.   // locate the drive in the list of available drives
  1105.   for( i = 0; i < cdlist.num; i++ )
  1106.     {
  1107.       if ( (cdh.ha  == cdlist.cd[i].ha) &&
  1108.    (cdh.tgt == cdlist.cd[i].tgt) &&
  1109.    (cdh.lun == cdlist.cd[i].lun) )
  1110. cdlistIdx = i;
  1111.     }
  1112. }
  1113.     }
  1114.   else
  1115.     {
  1116.       hCD = findAvailableCD( );
  1117.     }
  1119.   if ( !readRegSZ( hKey, "wavOutputDir", szWavOutputDir, MAX_PATH + 1 ) )
  1120.     GetCurrentDirectory( MAX_PATH + 1, szWavOutputDir );
  1122.   if ( !readRegSZ( hKey, "mp3OutputDir", szMP3OutputDir, MAX_PATH + 1 ) )
  1123.     GetCurrentDirectory( MAX_PATH + 1, szMP3OutputDir );
  1125.   asSetID3Info( ID3_TITLE, "", 0 );
  1126.   asSetID3Info( ID3_ARTIST, "", 0 );
  1127.   asSetID3Info( ID3_ALBUM, "", 0 );
  1128.   asSetID3Info( ID3_YEAR, "", 0 );
  1129.   asSetID3Info( ID3_GENRE, NULL, 0 );
  1131.   if ( hKey )
  1132.     RegCloseKey( hKey );
  1133. }
  1136. HCDROM findAvailableCD( void )
  1137. {
  1138.   GETCDHAND cdh;
  1139.   BYTE i;
  1141.   if ( hCD )
  1142.     {
  1143.       CloseCDHandle( hCD );
  1144.       hCD = NULL;
  1145.     }
  1147.   ZeroMemory( &cdh, sizeof(cdh) );
  1148.   for( i = 0; i < cdlist.num && !hCD; i++ )
  1149.     {
  1150.       cdh.size        = sizeof(GETCDHAND);
  1151.       cdh.ver         = 1;
  1152.       cdh.ha          = cdlist.cd[i].ha;
  1153.       cdh.tgt         = cdlist.cd[i].tgt;
  1154.       cdh.lun         = cdlist.cd[i].lun;
  1155.       cdh.readType    = bReadType;
  1156.       cdh.numOverlap  = numOverlap;
  1157.       cdh.numJitter   = jitterCheck;
  1158.       hCD = GetCDHandle( &cdh );
  1159.       if ( hCD )
  1160. cdlistIdx = i;
  1161.     }
  1163.   return hCD;
  1164. }
  1167. /*
  1168.  * Reads a DWORD from the registry given an already open key
  1169.  * The value read is stored into pdw, and the function returns
  1170.  * 0 if it fails
  1171.  */
  1172. int readRegDWORD( HKEY hKey, LPCTSTR lpszValue, DWORD *pdw )
  1173. {
  1174.   DWORD dwSize = 4L;
  1175.   DWORD dwType;
  1176.   LONG retVal;
  1178.   retVal = RegQueryValueEx( hKey, lpszValue, NULL, &dwType, (LPBYTE)pdw,
  1179.     &dwSize );
  1180.   if ( retVal != ERROR_SUCCESS )
  1181.     {
  1182.       return 0;
  1183.     }
  1185.   return -1;
  1186. }
  1187.  
  1189. /*
  1190.  * Reads an ASCIIZ string from the registry given an already open key
  1191.  * The value read is stored into lpszData, and the function returns
  1192.  * 0 if it fails
  1193.  */
  1194. int readRegSZ( HKEY hKey, LPCTSTR lpszValue, LPSTR lpszData, DWORD dwDataLen )
  1195. {
  1196.   DWORD dwType;
  1197.   LONG retVal;
  1199.   retVal = RegQueryValueEx( hKey, lpszValue, NULL, &dwType, (LPBYTE)lpszData,
  1200.     &dwDataLen );
  1201.   if ( (retVal != ERROR_SUCCESS) || (dwType != REG_SZ) )
  1202.     {
  1203.       return 0;
  1204.     }
  1206.   return -1;
  1207. }
  1210. /*
  1211.  * Sets the registry to disable autoplay under Win95.  Probably won't
  1212.  * work under NT due to security settings
  1213.  */
  1214. void disableAutoPlay( void )
  1215. {
  1216.   HKEY hKey;
  1217.   unsigned long ulDisable = (unsigned long)0xFF;
  1218.   DWORD dwDataSize = sizeof( ulDisable );
  1219.   DWORD dwDataType;
  1220.   LONG lErr = 0;
  1222.   if ( ( lErr = RegOpenKeyEx( HKEY_CURRENT_USER, regAutoPlay, 0,
  1223.      KEY_ALL_ACCESS, &hKey ) ) == ERROR_SUCCESS )
  1224.     {
  1225.       if ( RegQueryValueEx( hKey, "NoDriveTypeAutoRun", 0, NULL,
  1226.     (unsigned char *)&ulOldAutorun,
  1227.     &dwDataSize ) == ERROR_SUCCESS )
  1228. {
  1229.   RegSetValueEx( hKey, "NoDriveTypeAutoRun", 0, REG_BINARY,
  1230.  (unsigned char *)&ulDisable, 4 );
  1231. }
  1232.       else
  1233. ulOldAutorun = (unsigned long)0x95;
  1235.       RegFlushKey( hKey );
  1236.       RegCloseKey( hKey );
  1237.     }
  1239.   if ( ( lErr = RegOpenKeyEx( HKEY_CLASSES_ROOT, regAutoAudioCD, 0,
  1240.                               KEY_ALL_ACCESS, &hKey ) ) == ERROR_SUCCESS )
  1241.     {
  1242.       dwDataSize = 256;
  1243.       if ( RegQueryValueEx( hKey, "", NULL, &dwDataType,
  1244.                             szOldAutoPlay,
  1245.                             &dwDataSize ) == ERROR_SUCCESS )
  1246.         {
  1247.           RegSetValueEx( hKey, "", 0, REG_SZ, (unsigned char *)"", 1 );
  1248.         }
  1250.       RegFlushKey( hKey );
  1251.       RegCloseKey( hKey );
  1252.     }
  1253. }
  1256. void restoreAutoPlay( void )
  1257. {
  1258.   HKEY hKey;
  1260.   if ( RegOpenKeyEx( HKEY_CURRENT_USER, regAutoPlay, 0,
  1261.      KEY_ALL_ACCESS, &hKey ) == ERROR_SUCCESS )
  1262.     {
  1263.       RegSetValueEx( hKey, "NoDriveTypeAutoRun", 0, REG_BINARY,
  1264.      (unsigned char *)&ulOldAutorun, 4 );
  1266.       RegFlushKey( hKey );
  1267.       RegCloseKey( hKey );
  1268.     }
  1270.   if ( RegOpenKeyEx( HKEY_CLASSES_ROOT, regAutoAudioCD, 0,
  1271.                      KEY_ALL_ACCESS, &hKey ) == ERROR_SUCCESS )
  1272.     {
  1273.       RegSetValueEx( hKey, "", 0, REG_SZ,
  1274.                      (unsigned char *)&szOldAutoPlay,
  1275.                      lstrlen(szOldAutoPlay)+1 );
  1277.       RegFlushKey( hKey );
  1278.       RegCloseKey( hKey );
  1279.     }
  1280. }
  1283. BOOL DirExists( char *dir )
  1284. {
  1285.   char curDir[MAX_PATH+1];
  1286.   //  BOOL bSet;
  1288.   if ( !GetCurrentDirectory( MAX_PATH + 1, curDir ) )
  1289.     return FALSE;
  1291.   if ( !SetCurrentDirectory( dir ) )
  1292.      return FALSE;
  1293.   SetCurrentDirectory( curDir );
  1295.   return TRUE;
  1296. }
  1299. void MSB2DWORD( DWORD *d, BYTE *b )
  1300. {
  1301.   DWORD retVal;
  1303.   retVal = (DWORD)b[0];
  1304.   retVal = (retVal<<8) + (DWORD)b[1];
  1305.   retVal = (retVal<<8) + (DWORD)b[2];
  1306.   retVal = (retVal<<8) + (DWORD)b[3];
  1308.   *d = retVal;
  1309. }
  1312. void GetEditItemText( int iCtlId, HWND hCtl )
  1313. {
  1314.   char buf[31];
  1316.   ZeroMemory( buf, 31 );
  1317.   SendMessage( hCtl, WM_GETTEXT, 31, (LPARAM)buf );
  1318.   switch( iCtlId )
  1319.     {
  1320.     case IDE_ARTIST:
  1321.       asSetID3Info( ID3_ARTIST, buf, 0 );
  1322.       break;
  1323.     case IDE_ALBUM:
  1324.       asSetID3Info( ID3_ALBUM, buf, 0 );
  1325.       break;
  1326.     }
  1327. }
  1330. void SetEditItemText( int iCtlId, char *s )
  1331. {
  1332.   switch( iCtlId )
  1333.     {
  1334.     case IDE_ARTIST:
  1335.       SendMessage( hEditArtist, WM_SETTEXT, 0, (LPARAM)s );
  1336.       break;
  1337.     case IDE_ALBUM:
  1338.       SendMessage( hEditAlbum, WM_SETTEXT, 0, (LPARAM)s );
  1339.       break;
  1340.     }
  1341. }
  1345. void CheckEnableID3MenuItem( HWND hWnd )
  1346. {
  1347.   HMENU hPopup;
  1349.   hPopup = GetSubMenu( GetMenu(hWnd), 3 ); // get handle to Tools menu
  1350.   if ( bID3 )
  1351.     CheckMenuItem( hPopup, IDM_ENABLEID3, MF_BYCOMMAND | MF_CHECKED );
  1352.   else
  1353.     CheckMenuItem( hPopup, IDM_ENABLEID3, MF_BYCOMMAND | MF_UNCHECKED );
  1354. }
  1357. void CheckEnableCDDBMenuItem( HWND hWnd )
  1358. {
  1359.   HMENU hPopup;
  1361.   hPopup = GetSubMenu( GetMenu(hWnd), 3 ); // get handle to Tools menu
  1362.   if ( bCDDB )
  1363.     CheckMenuItem( hPopup, IDM_ENABLECDDB, MF_BYCOMMAND | MF_CHECKED );
  1364.   else
  1365.     CheckMenuItem( hPopup, IDM_ENABLECDDB, MF_BYCOMMAND | MF_UNCHECKED );
  1366. }
  1369. void CheckEnableHiColorMenuItem( HWND hWnd )
  1370. {
  1371.   HMENU hPopup;
  1373.   hPopup = GetSubMenu( GetMenu(hWnd), 2 );  //options menu
  1374.   if ( bHiColor )
  1375.     CheckMenuItem( hPopup, IDM_HICOLOR, MF_BYCOMMAND | MF_CHECKED );
  1376.   else
  1377.     CheckMenuItem( hPopup, IDM_HICOLOR, MF_BYCOMMAND | MF_UNCHECKED );
  1378. }
  1382. void ShowHelpFile( HWND hWnd, int topic )
  1383. {
  1384.   char buf[MAX_PATH+1];
  1386.   topic = topic;
  1388.   GetCurrentDirectory( MAX_PATH+1, buf );
  1389.   lstrcat( buf, "\help" );
  1390.   ShellExecute( hWnd, "open", "index.html", NULL, buf, SW_SHOWNORMAL );
  1391. }
  1395. void setRipTrackStatus( LPENCODETHREAD e )
  1396. {
  1397.   char buf[61];
  1398.   char buf2[81];
  1399.   char *p = buf;
  1400.   double d;
  1401.   int a,b;
  1403.   time( &e->tnow );
  1404.   d = difftime( e->tnow, e->tstart );
  1405.   switch( e->status )
  1406.     {
  1407.     case EST_SUCCESS:
  1408.       lstrcpy( buf, "OK, " );
  1409.       DiffTimeToString( d, buf+4 );
  1410.       p += lstrlen( buf );
  1411.       d = ((double)(e->trackLen/75)) / d;
  1412.       a = d;
  1413.       b = ((d-(double)a) * 100.0);
  1414.       wsprintf( p, ", %s: %d.%02dx", bMP3?"rip/encode":"rip", a, b );
  1415.       wsprintf( buf2, "lstrlen(buf) == %d", lstrlen(buf) );
  1416.       OutputDebugString( buf2 );
  1417.       break;
  1418.     case EST_ERROR:
  1419.       wsprintf( buf, "Error: 0x%04X", GetAspiLibAspiError() );
  1420.       break;
  1421.     case EST_ABORTED:
  1422.       lstrcpy( buf, "Rip Aborted" );
  1423.       break;
  1424.     default:
  1425.       lstrcpy( buf, "" );
  1426.       break;
  1427.     }
  1428.   SendMessage( hTrackWnd, WM_SETTRACKSTATUS, (WPARAM)e->idx,
  1429.        (LPARAM)buf );
  1430. }
  1432. void DiffTimeToString( double d, char *buf )
  1433. {
  1434.   unsigned long hrs, min, sec;
  1435.   
  1436.   hrs = (unsigned long)(d / 3600.0);
  1437.   min = (unsigned long)((d - (double)((hrs) * 3600))/60.0);
  1438.   sec = ((unsigned long)d) - (hrs)*3600 - (min)*60;
  1440.   wsprintf( buf, "%02d:%02d", hrs * 60 + min, sec );
  1441. }
  1443. static void GetLineFromBuf( char *tgt, char **src, int len )
  1444. {
  1445.   char *p;
  1447.   if ( !src || !*src || !tgt )
  1448.     return;
  1450.   p = *src;
  1452.   ZeroMemory( tgt, len );
  1453.   len--;
  1455.   while( *p && len )
  1456.     {
  1457.       if ( *p == 'n' )
  1458.         break;
  1459.       *tgt++ = *p;
  1460.       p++;
  1461.       len--;
  1462.     }
  1464.   // advance *src to end of last read string
  1465.   if ( *p == 'n' )
  1466.     p++;
  1467.   *src = p;
  1469.   len = lstrlen( tgt );
  1470.   if ( tgt[len-2] == 'r' )
  1471.     tgt[len-2] = '';
  1472.   if ( (tgt[len-1] == 'r') || (tgt[len-1] == 'n') )
  1473.     tgt[len-1] = '';
  1474. }
  1477. #if 0
  1478. LRESULT CALLBACK Edit0Proc( HWND hWnd, UINT uMsg, WPARAM wParam,
  1479.     LPARAM lParam )
  1480. {
  1481.   WNDPROC lpfnWndProc;
  1482.   lpfnWndProc = (WNDPROC)GetWindowLong( hWnd, GWL_USERDATA );
  1484.   logMessage( 0, uMsg, wParam, lParam );
  1486.   return lpfnWndProc( hWnd, uMsg, wParam, lParam );
  1487. }
  1489. LRESULT CALLBACK Edit1Proc( HWND hWnd, UINT uMsg, WPARAM wParam,
  1490.     LPARAM lParam )
  1491. {
  1492.   WNDPROC lpfnWndProc;
  1493.   lpfnWndProc = (WNDPROC)GetWindowLong( hWnd, GWL_USERDATA );
  1495.   logMessage( 1, uMsg, wParam, lParam );
  1497.   return lpfnWndProc( hWnd, uMsg, wParam, lParam );
  1498. }
  1500. LRESULT CALLBACK Edit2Proc( HWND hWnd, UINT uMsg, WPARAM wParam,
  1501.     LPARAM lParam )
  1502. {
  1503.   WNDPROC lpfnWndProc;
  1504.   lpfnWndProc = (WNDPROC)GetWindowLong( hWnd, GWL_USERDATA );
  1506.   logMessage( 2, uMsg, wParam, lParam );
  1508.   return lpfnWndProc( hWnd, uMsg, wParam, lParam );
  1509. }
  1512. void logMessage( int which, UINT uMsg, WPARAM wParam, LPARAM lParam )
  1513. {
  1514.   char buf[128];
  1515.   char *p;
  1517.   p = buf;
  1518.   wsprintf( buf, "%d: ", which );
  1519.   p += lstrlen( p );
  1521.   switch( uMsg )
  1522.     {
  1523.     case WM_SETCURSOR:
  1524.     case WM_MOUSEMOVE:
  1525.     case WM_NCHITTEST:
  1526.     case WM_NCMOUSEMOVE:
  1527.     case WM_PAINT:
  1528.     case WM_NCPAINT:
  1529.       return;
  1531.     case WM_MOUSEACTIVATE:
  1532.       wsprintf( p, "WM_MOUSEACTIVATE  0x%08X  0x%08X", wParam, lParam );
  1533.       break;
  1535.     case WM_GETDLGCODE:
  1536.       wsprintf( p, "WM_GETDLGCODE  0x%08X  0x%08X", wParam, lParam );
  1537.       break;
  1539.     case WM_LBUTTONDOWN:
  1540.       wsprintf( p, "WM_LBUTTONDOWN  0x%08X  0x%08X", wParam, lParam );
  1541.       break;
  1543.     case WM_LBUTTONUP:
  1544.       wsprintf( p, "WM_LBUTTONUP  0x%08X  0x%08X", wParam, lParam );
  1545.       break;
  1547.     case WM_KILLFOCUS:
  1548.       wsprintf( p, "WM_KILLFOCUS  0x%08X  0x%08X", wParam, lParam );
  1549.       break;
  1551.     case WM_SETFOCUS:
  1552.       wsprintf( p, "WM_SETFOCUS  0x%08X  0x%08X", wParam, lParam );
  1553.       break;
  1555.     case WM_CAPTURECHANGED:
  1556.       wsprintf( p, "WM_CAPTURECHANGED  0x%08X  0x%08X", wParam, lParam );
  1557.       break;
  1559.     default:
  1560.       wsprintf( p, "unknown 0x%04X (%d)", uMsg, uMsg );
  1561.       break;
  1562.     }
  1564.   OutputDebugString( buf );
  1565. }
  1566. #endif
  1570. void dbprintf( char *fmt, ... )
  1571. {
  1572.   char buf[512];
  1573.   va_list arg;
  1575.   va_start( arg, fmt );
  1577.   vsprintf( buf, fmt, arg );
  1578.   OutputDebugString( buf );
  1580.   va_end( arg );
  1581. }
  1583. /*
  1584.  * Attempt to determine the version of comctl32.dll available.
  1585.  */
  1586. #if (!_CONFIG_DLLVERINFO)
  1587. typedef struct
  1588. {
  1589.   DWORD cbSize;
  1590.   DWORD dwMajorVersion;
  1591.   DWORD dwMinorVersion;
  1592.   DWORD dwBuildNumber;
  1593.   DWORD dwPlatformID;
  1594. } DLLVERSIONINFO;
  1595. typedef HRESULT CALLBACK (*DLLGETVERSIONPROC)(DLLVERSIONINFO *);
  1596. #endif
  1598. DWORD GetDllVersion( LPCTSTR lpszDllName )
  1599. {
  1600.   HINSTANCE hDll;
  1601.   DWORD retVal = 0;
  1603.   hDll = LoadLibrary( lpszDllName );
  1604.   if ( hDll )
  1605.     {
  1606.       DLLGETVERSIONPROC pDllGetVer;
  1608.       pDllGetVer = (DLLGETVERSIONPROC)GetProcAddress( hDll, "DllGetVersion" );
  1609.       if ( pDllGetVer )
  1610. {
  1611.   DLLVERSIONINFO dvi;
  1612.   HRESULT hr;
  1614.   ZeroMemory( &dvi, sizeof(dvi) );
  1615.   dvi.cbSize = sizeof(dvi);
  1617.   hr = (*pDllGetVer)(&dvi);
  1618.   if ( SUCCEEDED(hr) )
  1619.     {
  1620.       retVal = MAKELONG( dvi.dwMajorVersion, dvi.dwMinorVersion );
  1621.     }
  1623.   FreeLibrary( hDll );
  1624. }
  1625.     }
  1627.   return retVal;
  1628. }
  1631. /*
  1632.  * Returns TRUE if color depth >= 16 bpp
  1633.  */
  1634. BOOL DisplayIsHiColor( void )
  1635. {
  1636.   HDC hDC;
  1637.   int iBPP;
  1639.   hDC = GetDC( NULL );
  1641.   iBPP = GetDeviceCaps( hDC, BITSPIXEL );
  1643.   ReleaseDC( NULL, hDC );
  1645.   return (iBPP >= 16);
  1646. }