Pershin Sergey - 2002-01-14

Logged In: YES
user_id=426587

hmm.. attachment doesn't work, so i'll put it here:
----------------- okay, let's go! -------------------------
void StatusCheck(DISCINFO* psDI)
{
BOOL bTmpMediaPresent;
unsigned int nTmp;

EnterCriticalSection(&gs.sDiscInfoLock);

DebugPrintf("-> Status check!");
DebugPrintf("Current device = %c", gs.nCurrentDevice
+ 'A');

// If CDOpen has failed, try again
if (!gs.state.bCDOpened) {
// CDClose(&gs.wDeviceID); //029ah - When
switching CD-drives:
// NotifyMCI error: Invalid MCI device ID. Use the ID
returned when
// opening the MCI device.
//
// I think, you just have to remove it.

if (!CDOpen(&gs.wDeviceID)) {
gs.state.bMediaPresent = FALSE;
gs.state.bAudio = FALSE;
psDI->zCDDBID[0] = 0;
gs.state.bPaused = FALSE;
gs.state.bPlaying = FALSE;
psDI->nCurrTrack = 0;
gs.state.bInit = FALSE;

LeaveCriticalSection(&gs.sDiscInfoLock);

return;
}
}

nTmp = CDGetStatus(gs.wDeviceID);
if (gs.nStatus != nTmp) {
gs.nStatus = nTmp;
}

bTmpMediaPresent = CDGetMediaPresent(gs.wDeviceID);
if (!gs.state.bMediaPresent && bTmpMediaPresent) {
DebugPrintf("Found media!");

gs.state.bMediaPresent = TRUE;
gs.state.bPaused = FALSE;
gs.state.bPlaying = FALSE;
psDI->nCurrTrack = 0;

// If we don't remeber status, revert to normal
playmode
if (!(gs.nOptions & OPTIONS_REMEMBERSTATUS)) {
gs.state.bRandomize = FALSE;
gs.state.bPlayWhole = FALSE;
gs.state.bRepeat = FALSE;
gs.state.bRepeatTrack = FALSE;
}

if (!gs.state.bInit) {
DWORD dwId;
gs.state.bInit=0;

DebugPrintf("Killing TIMER");
KillTimer(gs.hMainWnd, 1);

DiscInit(&gs.di[0]);

// Create version check thread
if (gs.nOptions &
OPTIONS_AUTOCHECKFORNEWVERSION)
CloseHandle(CreateThread
(NULL, 0, CheckVersionThread, NULL, 0, &dwId));

SetTimer(gs.hMainWnd, 1, gs.nPollTime*1000,
NULL);

DebugPrintf("Restarting TIMER");
}

if (gs.nStatus == 2)
CDResume(gs.wDeviceID);
}
else if (gs.state.bMediaPresent && !bTmpMediaPresent) {
DebugPrintf("Media lost!");

gs.state.bMediaPresent = FALSE;
gs.state.bAudio = FALSE;
psDI->zCDDBID[0] = 0;
psDI->zMCIID[0] = 0;
gs.state.bPaused = FALSE;
gs.state.bPlaying = FALSE;
psDI->nCurrTrack = 0;
gs.state.bInit = FALSE;
gs.state.bRepeatTrack = FALSE;

if (gs.nOptions & OPTIONS_EXITONCDREMOVE)
DestroyWindow(gs.hMainWnd);
}

LeaveCriticalSection(&gs.sDiscInfoLock);
DebugPrintf("<- Status check!");
}

LRESULT CALLBACK MainWindowProc(
HWND hWnd,
UINT nMsg,
WPARAM wParam,
LPARAM lParam)
{
switch(nMsg) {
case WM_CREATE: {
DWORD dwId;

gs.hTrayIcon = gs.hIconStop;

NotifyAdd(hWnd, 100, gs.hTrayIcon,
gs.szToolTip);

CDOpen(&gs.wDeviceID);

SetTimer(hWnd, 1,
gs.nPollTime*1000, NULL);
SetTimer(hWnd, 3, 1000, NULL);

if (gs.nOptions &
OPTIONS_AUTOCHECKFORNEWVERSION)
CloseHandle(CreateThread
(NULL, 0, CheckVersionThread, NULL, 0, &dwId));
}
break;

case WM_ENDSESSION: {
if (wParam) {
SaveConfig();

DestroyWindow(hWnd);

CDClose(&gs.wDeviceID);
}
}
break;

case WM_CLOSE:
NotifyDelete(gs.hMainWnd, 100);

PostQuitMessage(0);
break;

case MM_MCINOTIFY: {
if (wParam == MCI_NOTIFY_SUCCESSFUL) {
DebugPrintf("MCI success");

if (gs.state.bPlayWhole && !
gs.state.bRepeatTrack) {
gs.di[0].nCurrTrack = gs.di
[0].nProgrammedTracks - 1;
ResetPlaylist(&gs.di[0], TRUE);
}

gs.state.bPlaying = FALSE;

UpdateDiscInformation
(&gs.di[0], TRUE, TRUE, NULL);

if (gs.state.bRepeat && !
gs.state.bRepeatTrack && !gs.state.bRandomize &&
(!
gs.state.bProgrammed || (gs.state.bProgrammed &&
gs.nNextProgrammedTrack == gs.di[0].nProgrammedTracks))) {
DebugPrintf
("Playing from first track on the playlist");

CDPlay
(gs.wDeviceID, 0);
}
else if (!gs.state.bRandomize && !
gs.state.bRepeatTrack && gs.state.bProgrammed &&
gs.nNextProgrammedTrack < gs.di[0].nProgrammedTracks) {
DebugPrintf
("Playing next track on the playlist");

CDPlay(gs.wDeviceID,
gs.nNextProgrammedTrack);
}
else if (gs.state.bRepeatTrack) {
DebugPrintf("Repeating track");

CDPlay
(gs.wDeviceID, gs.nRepeatTrack);
}
else if
(gs.state.bRandomize) {
DebugPrintf
("Playing random track");

PlayRandTrack();
}
else
gs.state.bPlaying = FALSE;
}
else if (wParam == MCI_NOTIFY_ABORTED) {
DebugPrintf("MCI aborted");

StatusCheck(&gs.di[0]);
}
else if (wParam == MCI_NOTIFY_FAILURE) {
DebugPrintf("MCI failure");

StatusCheck(&gs.di[0]);
}
else if (wParam == MCI_NOTIFY_SUPERSEDED) {
DebugPrintf("MCI superseeded");

StatusCheck(&gs.di[0]);
}

if (!gs.state.bPlaying && !gs.state.bPaused)
gs.di[0].nCurrTrack = 0;
}
break;

case WM_DISPLAYCHANGE: {
DebugPrintf("WM_DISPLAYCHANGE");

NotifyDelete(gs.hMainWnd, 100);
NotifyAdd(gs.hMainWnd, 100, gs.hTrayIcon,
gs.szToolTip);
}
break;

case WM_DEVICECHANGE: {
if ((gs.nOptions &
OPTIONS_NOINSERTNOTIFICATION) && gs.bHasNotification)
DebugPrintf("No insert
notification enabled, skipping WM_DEVICECHANGE");
else {
switch(wParam) {
case
DBT_DEVICEARRIVAL: {

DEV_BROADCAST_HDR* p = (DEV_BROADCAST_HDR*)lParam;
DebugPrintf
("Device Arrival: Type = %d", p->dbch_devicetype);

if (p-
>dbch_devicetype == DBT_DEVTYP_VOLUME) {
if
(!gs.bHasNotification) {

gs.bHasNotification = TRUE;

DebugPrintf("Use of notification found!");
}

gs.di[0].nCurrTrack = 0;

StatusCheck(&gs.di[0]);
}
else

DebugPrintf("Not a volume!");
}
break;

case
DBT_DEVICEREMOVECOMPLETE: {

DEV_BROADCAST_HDR* p = (DEV_BROADCAST_HDR*) lParam;
DebugPrintf
("Device Remove Complete: Type = %d", p->dbch_devicetype);

if (p-
>dbch_devicetype == DBT_DEVTYP_VOLUME) {
if
(!gs.bHasNotification) {

gs.bHasNotification = TRUE;

DebugPrintf("Use of notification found!");

gs.nOptions &= ~OPTIONS_NOINSERTNOTIFICATION;
}

StatusCheck(&gs.di[0]);
}
else

DebugPrintf("Not a volume!");
}
break;

// default:
// DebugPrintf
("WM_DEVICECHANGE: %x", wParam);
}
}
}
break;

case WM_TIMER: {
if (gs.bQueryThreadHasUpdatedDI) {
EnterCriticalSection(&gs.sDiscInfoLock);

gs.bQueryThreadHasUpdatedDI = FALSE;

DebugPrintf("QueryThread has updated
DiscInfo");

GetDiscInfo(gs.wDeviceID,
&gs.sQueryThreadDI);
ResetPlaylist(&gs.sQueryThreadDI, TRUE);

CheckProgrammed(gs.wDeviceID,
&gs.sQueryThreadDI);

FreeDiscInfo(&gs.di[0]);

gs.di[0] = gs.sQueryThreadDI;

RunExternalCommand(&gs.di
[0]);

LeaveCriticalSection(&gs.sDiscInfoLock);
}

if (wParam == 1) {
if (gs.bCreateWindowFinished && !
gs.bFirstStatusCheckDone) {
StatusCheck(&gs.di[0]);

gs.bFirstStatusCheckDone = TRUE;
}
/* if (!gs.state.bMediaPresent || !
gs.state.bAudio || (!gs.state.bPlaying))
StatusCheck();
else*/ if (gs.nOptions &
OPTIONS_NOINSERTNOTIFICATION)
StatusCheck(&gs.di[0]);

// Check for correct icon
if (gs.state.bMediaPresent &&
gs.state.bAudio && gs.state.bPlaying && !gs.state.bPaused
&& gs.hTrayIcon != gs.hIconPlay) {
gs.hTrayIcon = gs.hIconPlay;

NotifyModify(gs.hMainWnd, 100,
gs.hTrayIcon, gs.szToolTip);
}
else if (gs.state.bMediaPresent &&
gs.state.bAudio && !gs.state.bPlaying && !gs.state.bPaused
&& gs.hTrayIcon != gs.hIconStop) {
gs.hTrayIcon = gs.hIconStop;

NotifyModify(gs.hMainWnd, 100,
gs.hTrayIcon, gs.szToolTip);
}
else if (gs.state.bMediaPresent &&
gs.state.bAudio && !gs.state.bPlaying && gs.state.bPaused
&& gs.hTrayIcon != gs.hIconPause) {
gs.hTrayIcon = gs.hIconPause;

NotifyModify(gs.hMainWnd, 100,
gs.hTrayIcon, gs.szToolTip);
}
else if ((!gs.state.bMediaPresent || !
gs.state.bAudio) && gs.hTrayIcon != gs.hIconNoAudio) {
gs.hTrayIcon = gs.hIconNoAudio;

NotifyModify(gs.hMainWnd, 100,
gs.hTrayIcon, gs.szToolTip);
}
}
else if (wParam == 2) {
KillTimer(hWnd, 2);

if (gs.state.bMediaPresent) {
if (gs.nClicks > 0 && gs.nClicks <= 5
&& gs.anBindings[gs.nClicks-1]) {
SendMessage(hWnd, WM_COMMAND,
MAKELONG(gs.anBindings[gs.nClicks-1], 0), 0L);
}
}

gs.nClicks = 0;
}
else if (wParam == 3) {
if (gs.nOptions & OPTIONS_SHOWONCAPTION)
DrawOnCaption();
}
}
break;

case WM_DESTROY:
if (gs.nOptions & OPTIONS_STOPONEXIT)
CDStop(gs.wDeviceID);

NotifyDelete(gs.hMainWnd, 100);

PostQuitMessage(1);
break;
/*
// multimedia keyboard handling
routines ...
case WM_APPCOMMAND:
switch (GET_APPCOMMAND_LPARAM
(lParam)) {
case
APPCOMMAND_MEDIA_NEXTTRACK:
break;
case
APPCOMMAND_MEDIA_PREVIOUSTRACK:
break;
case
APPCOMMAND_MEDIA_PLAY_PAUSE:
break;
case
APPCOMMAND_MEDIA_SELECT:
break;
case APPCOMMAND_MEDIA_STOP:
break;
}
break;
*/
case WM_COMMAND:
if (LOWORD(wParam) >= IDM_TRACKS && LOWORD
(wParam) < IDM_TRACKS + 100) {
CDPlay(gs.wDeviceID, LOWORD(wParam) -
IDM_TRACKS);
}
else if (LOWORD(wParam) >= IDM_DEVICES &&
LOWORD(wParam) <= IDM_DEVICES + 'Z') {
CDStop(gs.wDeviceID);

CDClose(&gs.wDeviceID);

gs.state.bInit=0; //029ah - When switching
CD-drives Notify CD doesn't re-read CD-content because of
gs.state.bInit=1. This line - solving the problem.
gs.nCurrentDevice = LOWORD(wParam) -
IDM_DEVICES - 'A';

DebugPrintf("Changing device to %c", (char)
gs.nCurrentDevice + 'A');

// Modify devices menu

HMENU hDevicesMenu;
hDevicesMenu = GetSubMenu(GetSubMenu
(gs.hTrackMenu, 0), gs.nMenuIndexDevices);

if (hDevicesMenu) {
char szTmp[80];

for (unsigned int nLoop = 'A' ; nLoop
<= 'Z' ; nLoop ++) {
if (gs.abDevices[nLoop - 'A']) {
sprintf(szTmp, "Drive %c:",
nLoop);
if (nLoop - 'A' ==
gs.nCurrentDevice)
ModifyMenu(hDevicesMenu,
IDM_DEVICES+nLoop, MF_BYCOMMAND | MF_STRING | MF_CHECKED,
IDM_DEVICES+nLoop, szTmp);
else
ModifyMenu(hDevicesMenu,
IDM_DEVICES+nLoop, MF_BYCOMMAND | MF_STRING,
IDM_DEVICES+nLoop, szTmp);
}
}
}

StatusCheck(&gs.di[0]);

DiscInit(&gs.di[0]);
}
else {
switch(LOWORD(wParam)) {
case IDM_PLAY:
// Call status check to determine
CD change if another instance
// sent us this command and we
haven't detected the CD change!

StatusCheck(&gs.di[0]);

if (gs.state.bPlayWhole)
ResetPlaylist(&gs.di[0], TRUE);

if (gs.state.bMediaPresent &&
gs.state.bAudio) {
if
(!gs.state.bPaused) {

CDPlay(gs.wDeviceID, gs.di[0].nCurrTrack);
}

else

CDResume(gs.wDeviceID);
}

StatusCheck(&gs.di[0]);
break;

case IDM_PLAYWHOLE: {
HMENU hSubMenu;

hSubMenu = GetSubMenu
(gs.hTrackMenu, 0);

if (!gs.state.bPlayWhole) {

CheckMenuItem(hSubMenu, IDM_PLAYWHOLE, MF_BYCOMMAND |
MF_CHECKED);

ResetPlaylist(&gs.di[0],
FALSE);
}
else {

CheckMenuItem(hSubMenu, IDM_PLAYWHOLE, MF_BYCOMMAND |
MF_UNCHECKED);

ResetPlaylist(&gs.di[0], TRUE);
}

CDPlay(gs.wDeviceID, 0);
}
break;

case IDM_STOP:
if (gs.state.bMediaPresent &&
gs.state.bAudio)

CDStop(gs.wDeviceID);
break;

case IDM_PAUSE:
if
(gs.state.bMediaPresent && gs.state.bAudio) {
if
(!gs.state.bPaused && gs.state.bPlaying)

CDPause(gs.wDeviceID);

else if (gs.state.bPaused)

CDResume(gs.wDeviceID);

else if (!gs.state.bPaused && !gs.state.bPlaying)

CDPlay(gs.wDeviceID, gs.di[0].nCurrTrack);
}
break;

case IDM_NEXT:
if
(gs.state.bMediaPresent && gs.state.bAudio) {
if
(gs.state.bRandomize)

PlayRandTrack();

else {

if (gs.di[0].nCurrTrack < gs.di[0].nProgrammedTracks -
1)

gs.di[0].nCurrTrack ++;

else

gs.di[0].nCurrTrack = 0;

if (!gs.state.bPaused && gs.state.bPlaying)

CDPlay(gs.wDeviceID, gs.di[0].nCurrTrack);

else if (!gs.state.bPaused && !gs.state.bPlaying)

CDPlay(gs.wDeviceID, 0);
else if (gs.state.bPaused)
CDResume(gs.wDeviceID);
}
}
break;

case IDM_PREV: {
if
(gs.state.bMediaPresent && gs.state.bAudio) {
if
(gs.state.bRandomize)

PlayRandTrack();

else {
unsigned int nTrack, nMin,
nSec, nFrame;

if (!(gs.nOptions &
OPTIONS_PREVALWAYSPREV))
CDGetTime
(gs.wDeviceID, 0, NULL, TRUE, &nTrack, &nMin, &nSec,
&nFrame);

if ((gs.nOptions &
OPTIONS_PREVALWAYSPREV) || (nMin < 1 && nSec <= 5)) {
if (gs.di
[0].nCurrTrack > 0)

gs.di[0].nCurrTrack--;

else

gs.di[0].nCurrTrack = gs.di
[0].nProgrammedTracks - 1;
}

if (!gs.state.bPaused)

CDPlay(gs.wDeviceID, gs.di[0].nCurrTrack);
}
}
}
break;

case IDM_OPEN: {
if (!gs.state.bCDOpened)
CDOpen(&gs.wDeviceID);

CDEject(gs.wDeviceID);

SendMessage(hWnd, WM_TIMER, 1, 0);
}
break;

case IDM_CLOSE: {
CDLoad
(gs.wDeviceID);

SendMessage(hWnd, WM_TIMER, 1, 0);
}
break;

case IDM_REPEAT: {
HMENU
hSubMenu;

hSubMenu =
GetSubMenu(gs.hTrackMenu, 0);

if (!
gs.state.bRepeat) {

ModifyMenu(hSubMenu, IDM_REPEAT, MF_BYCOMMAND | MF_STRING
| MF_CHECKED, IDM_REPEAT, "Repeat");

gs.state.bRepeat = TRUE;
}
else {

ModifyMenu(hSubMenu, IDM_REPEAT, MF_BYCOMMAND | MF_STRING,
IDM_REPEAT, "Repeat");

gs.state.bRepeat = FALSE;
}
}
break;

case
IDM_REPEATTRACK: {
HMENU
hSubMenu;

hSubMenu = GetSubMenu
(gs.hTrackMenu, 0);
hSubMenu =
GetSubMenu(hSubMenu, gs.nMenuIndexOther);

if (!
gs.state.bRepeatTrack) {

ModifyMenu(gs.hTrackMenu, IDM_REPEATTRACK, MF_BYCOMMAND |
MF_STRING | MF_CHECKED, IDM_REPEATTRACK, "Repeat track");

gs.state.bRepeatTrack = TRUE;

UpdateDiscInformation(&gs.di
[0], FALSE, TRUE, NULL);

gs.nRepeatTrack = gs.di
[0].nCurrTrack;
}
else {

ModifyMenu(gs.hTrackMenu, IDM_REPEATTRACK, MF_BYCOMMAND |
MF_STRING, IDM_REPEATTRACK, "Repeat track");

gs.state.bRepeatTrack = FALSE;
}

CDResume(gs.wDeviceID);
}
break;

case
IDM_RANDOMIZE: {
if
(gs.state.bMediaPresent && gs.state.bAudio) {
HMENU
hSubMenu;

hSubMenu = GetSubMenu(gs.hTrackMenu, 0);

if (!
gs.state.bRandomize) {

ModifyMenu(hSubMenu, IDM_RANDOMIZE, MF_BYCOMMAND |
MF_STRING | MF_CHECKED, IDM_RANDOMIZE, "Random Play");

gs.state.bRandomize = TRUE;

gs.nLastRandomTrack = 0;

PlayRandTrack();
}
else {

ModifyMenu(hSubMenu, IDM_RANDOMIZE, MF_BYCOMMAND |
MF_STRING, IDM_RANDOMIZE, "Random Play");

gs.state.bRandomize = FALSE;
}
}
}
break;

case IDM_SETABSTRACKPOS:
DialogBox(gs.hMainInstance,
MAKEINTRESOURCE(IDD_SETABSTRACKPOS), NULL, (DLGPROC)
SetAbsTrackPosDlgProc);
break;

case IDM_SKIP:
DialogBox(gs.hMainInstance,
MAKEINTRESOURCE(IDD_SKIP), NULL, (DLGPROC)SkipDlgProc);
break;

case IDM_CDDB:
DialogBox(gs.hMainInstance,
MAKEINTRESOURCE(IDD_CDDB), NULL, (DLGPROC)DatabaseDlgProc);
break;

case IDM_OPTIONS:
DoOptions();
break;

case IDM_ABOUT:
DialogBox(gs.hMainInstance,
MAKEINTRESOURCE(IDD_ABOUT), NULL, (DLGPROC)AboutDlgProc);
break;

case IDM_INFO:
INFODLGPARAM sParam;
DISCINFO sEditInfo;

InitDiscInfo(&sEditInfo);

CopyDiscInfo(&sEditInfo, &gs.di
[0]);

sParam.psDI = &sEditInfo;
sParam.bSave = TRUE;

if (DialogBoxParam
(gs.hMainInstance, MAKEINTRESOURCE(IDD_INFO), NULL,
(DLGPROC)InfoDlgProc, (LPARAM)&sParam) == IDOK) {
if (!stricmp(gs.di[0].zCDDBID,
sEditInfo.zCDDBID)) {
CopyDiscInfo(&gs.di[0],
&sEditInfo);

CheckProgrammed
(gs.wDeviceID, &gs.di[0]);

InitMenu(&gs.di[0]);
}
}
break;

case IDM_INTERNETGET: {
if (gs.state.bInit) {
DISCINFO sQueryDI;

CopyQueryInfo(&gs.di[0],
&sQueryDI);

if (DBInternetGet(&sQueryDI,
hWnd)) {
GetDiscInfo(gs.wDeviceID,
&sQueryDI);
SetDiscInfo(&sQueryDI);

EnterCriticalSection
(&gs.sDiscInfoLock);

FreeDiscInfo(&gs.di[0]);

gs.di[0] = sQueryDI;

ResetPlaylist(&gs.di[0],
TRUE);

CheckProgrammed
(gs.wDeviceID, &gs.di[0]);

LeaveCriticalSection
(&gs.sDiscInfoLock);
}
else
MessageBox(hWnd, "No disc
info found on remote server", APPNAME, MB_OK |
MB_ICONINFORMATION);
}
else
MessageBox(hWnd, "There's no
disc in the drive!", APPNAME, MB_OK | MB_ICONINFORMATION);
}
break;

case IDM_INTERNETSEND: {
DBInternetSend(&gs.di[0], hWnd);
}
break;

case IDM_ADDTOQUEUE: {
if (MessageBox(hWnd, "Do you want
to add this disc to the queue for later retrieval?",
APPNAME, MB_YESNO | MB_ICONQUESTION) == IDYES)

AddToQueue(&gs.di[0]);
}
break;

case IDM_GETQUEUEDITEMS: {
if (MessageBox(hWnd, "Do you want
to try to retrieve the queued items?", APPNAME, MB_YESNO |
MB_ICONQUESTION) == IDYES) {
GetQueuedItems();

if
(gs.nNumberOfItemsInQueue)
MessageBox
(hWnd, "One or more queued items still remain due to
server error or since they where not found! You might
wan't to remove the items or it will be seached for the
next time the queue is retrieved.", APPNAME,
MB_ICONEXCLAMATION);
}
}
break;

case IDM_REMOVEQUEUEDITEMS: {
if (MessageBox(hWnd, "Do you want
to remove all queued items?", APPNAME, MB_YESNO |
MB_ICONQUESTION) == IDYES) {
while
(gs.nNumberOfItemsInQueue)
RemoveQueueItem
(gs.nNumberOfItemsInQueue);
}
}
break;

case IDM_QUIT: {
if
(gs.state.bProgrammed && gs.state.bMediaPresent &&
gs.state.bPlaying && !(gs.nOptions & OPTIONS_STOPONEXIT)) {
if
(MessageBox(NULL, "The CD is programmed. It will stop
after the last sequential track if You continue this
action. Are You sure You want to quit?", APPNAME, MB_YESNO
| MB_ICONQUESTION) == IDYES)

DestroyWindow(hWnd);
}
else

DestroyWindow(hWnd);
}
break;
}
}
break;

case MYWM_WAKEUP: {
DebugPrintf("Wakeup call!");
switch(wParam) {
case IDM_PLAY: {
StatusCheck(&gs.di[0]);

if (lParam == -1 && gs.state.bPlaying)
DebugPrintf("Ignoring wakeup call
to start playing since we are already playing and no track
was specified");
else {
if (gs.state.bRandomize) {

DebugPrintf("Skipping requested track since we are in
repeat mode!");

gs.di[0].nCurrTrack = GetRandTrack();
}
else

gs.di[0].nCurrTrack = LOWORD(lParam);

DebugPrintf("Wakeup call to play
track %d", gs.di[0].nCurrTrack);

SendMessage(hWnd, WM_COMMAND,
MAKELONG(IDM_PLAY, 0), 0);

SendMessage(hWnd, WM_TIMER, 1, 0);
}
}
break;

case IDM_DEVICES: {
DebugPrintf("Version is %d", HIWORD
(lParam));
DebugPrintf("Wakeup call to change
device to %d(%c)", LOWORD(lParam), (char)LOWORD(lParam));
if ((unsigned)(LOWORD(lParam) - 'A') !
= gs.nCurrentDevice) {
DebugPrintf("Changing...");
SendMessage(hWnd, WM_COMMAND,
MAKELONG(IDM_DEVICES+LOWORD(lParam), 0), 0);
}
else
DebugPrintf("No change!");
}
break;

case IDM_PAUSE:
DebugPrintf("Wakeup call to PAUSE");

SendMessage(hWnd,
WM_COMMAND, MAKELONG(IDM_PAUSE, 0), 0);
break;

case IDM_RANDOMIZE:
DebugPrintf("Wakeup call to
RANDOMIZE");

SendMessage(hWnd,
WM_COMMAND, MAKELONG(IDM_RANDOMIZE, 0), 0);
break;

case IDM_REPEAT:
DebugPrintf("Wakeup call to REPEAT");

SendMessage(hWnd,
WM_COMMAND, MAKELONG(IDM_REPEAT, 0), 0);
break;

case IDM_STOP:
DebugPrintf("Wakeup call to STOP");

SendMessage(hWnd,
WM_COMMAND, MAKELONG(IDM_STOP, 0), 0);
break;

case IDM_NEXT:
DebugPrintf("Wakeup call to NEXT");

SendMessage(hWnd,
WM_COMMAND, MAKELONG(IDM_NEXT, 0), 0);
break;

case IDM_PREV:
DebugPrintf("Wakeup call to PREV");

SendMessage(hWnd,
WM_COMMAND, MAKELONG(IDM_PREV, 0), 0);
break;

case IDM_OPEN:
DebugPrintf("Wakeup call to OPEN");

SendMessage(hWnd,
WM_COMMAND, MAKELONG(IDM_OPEN, 0), 0);
break;

case IDM_CLOSE:
DebugPrintf("Wakeup call to CLOSE");

SendMessage(hWnd,
WM_COMMAND, MAKELONG(IDM_CLOSE, 0), 0);
break;
}
}
break;

case WM_MEASUREITEM: {
MEASUREITEMSTRUCT* psI = (MEASUREITEMSTRUCT*)
lParam;
if (psI->itemID == 999) {
psI->itemWidth = 15;

return TRUE;
}
}
break;

case WM_DRAWITEM: {
DRAWITEMSTRUCT* psI = (DRAWITEMSTRUCT*) lParam;
if (psI->itemID == 999 && psI->itemAction ==
ODA_DRAWENTIRE) {
HWND hMenuWnd = WindowFromDC(psI->hDC);
RECT sRect;

GetClientRect(hMenuWnd, &sRect);

// TEMP

HDC hDC = CreateCompatibleDC(psI->hDC);
gs.hMenuBitmap = (HBITMAP)SelectObject
(hDC, gs.hMenuBitmap);

psI->rcItem.bottom = (sRect.bottom -
sRect.top);
BitBlt(psI->hDC, psI->rcItem.left, psI-
>rcItem.bottom - 330, 26, 330, hDC, 0, 0, SRCCOPY);
RealizePalette(psI->hDC);

if (psI->rcItem.bottom - 330 > 0) {
psI->rcItem.top = 0;
psI->rcItem.bottom = 330 - psI-
>rcItem.bottom;

FillRect(psI->hDC, &psI->rcItem,
(HBRUSH)GetStockObject(BLACK_BRUSH));
}

gs.hMenuBitmap = (HBITMAP)SelectObject
(hDC, gs.hMenuBitmap);
DeleteDC(hDC);

return TRUE;
}
}
break;

case WM_HOTKEY: {
PostMessage(hWnd, WM_COMMAND, gs.anBindings
[wParam], 0);
}
break;

case MYWM_NOTIFYICON: {
switch (lParam) {
case WM_RBUTTONUP: {
POINT sPoint;
HMENU hSubMenu = GetSubMenu
(gs.hTrackMenu, 0);

GetCursorPos(&sPoint);

SetForegroundWindow(hWnd);

UpdateMenu(&gs.di[0], hSubMenu);
TrackPopupMenu(hSubMenu,
TPM_RIGHTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
sPoint.x, sPoint.y, 0, hWnd, NULL);

PostMessage(hWnd, WM_USER, 0, 0);
}
break;

case WM_LBUTTONDOWN: {
if (gs.nClicks == 0) {
gs.bCaptured = TRUE;
gs.bDragged = FALSE;
SetCapture(hWnd);
POINT p;
GetCursorPos(&p);
gs.nCaptureX=p.x;
gs.nCaptureY=p.y;
}
} break;

case WM_LBUTTONUP: {
if (gs.bCaptured) {
ReleaseCapture();
gs.bCaptured = FALSE;
}

if (!gs.bDragged) { // Don't perform
click action if user dragged
gs.nClicks ++;

SetTimer(hWnd, 2,
GetDoubleClickTime(), NULL);
}
}
break;

case WM_CANCELMODE: {
if (gs.bCaptured) {
ReleaseCapture();
gs.bCaptured = FALSE;
}
} break;

case WM_MOUSEMOVE: {
char szStr[512];
if (gs.bCaptured) {
POINT p;
GetCursorPos(&p);
int x=p.x;
int y=p.y;
int dx=x-gs.nCaptureX;
int dy=y-gs.nCaptureY;
/* Pick an axis */
if (abs(dx)<GetSystemMetrics
(SM_CXDRAG)) dx=0;
if (abs(dy)<GetSystemMetrics
(SM_CYDRAG)) dy=0;
if (abs(dx)>abs(dy)) dy=0;
else dx=0;
if (dx || dy) {
ReleaseCapture();
gs.bCaptured = FALSE;
gs.bDragged=TRUE;
int binding=0;
if (dx>0) {
binding=5;
} else if (dx<0) {
binding=6;
} else if (dy<0) {
binding=7;
} else if (dy>0) {
binding=8;
}
if (gs.anBindings[binding]) {
SendMessage(hWnd,
WM_COMMAND, MAKELONG(gs.anBindings[binding], 0), 0L);
}
}
}

UpdateDiscInformation(&gs.di[0],
FALSE, TRUE, szStr);
}
break;

default:
break;
}
}
break;

default: {
return DefWindowProc(hWnd, nMsg, wParam,
lParam);
}
}

return 0L;
}
--------------------- fine! --------------------------