mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1273 lines
26 KiB
1273 lines
26 KiB
/*++
|
|
|
|
Copyright (c) 1992 Microsoft Corporation
|
|
|
|
|
|
Module Name:
|
|
|
|
|
|
database.c
|
|
|
|
|
|
Abstract:
|
|
|
|
|
|
This module implements the database routines for the CD Audio app.
|
|
The information is stored in the ini file "cdaudio.ini" which should
|
|
be located in the nt\windows directory.
|
|
|
|
|
|
|
|
Author:
|
|
|
|
|
|
Rick Turner (ricktu) 31-Jan-1992
|
|
|
|
|
|
Revision History:
|
|
|
|
04-Aug-1992 (ricktu) Incorperated routines from old cdaudio.c,
|
|
and made work w/new child window framework.
|
|
|
|
--*/
|
|
|
|
#include <windows.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "cdplayer.h"
|
|
#include "cdwindef.h"
|
|
#include "toolbar.h"
|
|
#include "control.h"
|
|
#include "trkinfo.h"
|
|
#include "status.h"
|
|
//#include "ruler.h"
|
|
#include "discinfo.h"
|
|
|
|
|
|
#define INI_FILE_NAME "cdplayer.ini"
|
|
|
|
|
|
//
|
|
// Private entrypoints
|
|
//
|
|
|
|
BOOL
|
|
AddThisEntry(
|
|
IN INT cdrom
|
|
);
|
|
|
|
BOOL
|
|
AddThisDisc(
|
|
IN INT cdrom
|
|
);
|
|
|
|
DWORD
|
|
ComputeOldDiscId(
|
|
IN INT cdrom
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
This routine computes a unique ID based on the information
|
|
in the table of contexts a given disc.
|
|
|
|
Arguments:
|
|
|
|
cdrom - supplies an index into the gDevices structure, used to
|
|
specify which disc to compute an ID for.
|
|
|
|
|
|
Return Value:
|
|
|
|
A DWORD unique ID.
|
|
|
|
--*/
|
|
|
|
{
|
|
INT NumTracks,i;
|
|
DWORD DiscId = 0;
|
|
|
|
|
|
NumTracks = gDevices[ cdrom ]->toc.LastTrack -
|
|
gDevices[ cdrom ]->toc.FirstTrack;
|
|
|
|
for (i=0; i<NumTracks; i++)
|
|
DiscId += ( (TRACK_M(cdrom,i) << 16) +
|
|
(TRACK_S(cdrom,i) << 8) +
|
|
TRACK_F(cdrom,i) );
|
|
|
|
return( DiscId );
|
|
|
|
}
|
|
|
|
|
|
DWORD
|
|
ComputeNewDiscId(
|
|
IN INT cdrom
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
This routine computes a unique ID based on the information
|
|
in the table of contexts a given disc. This is done by taking
|
|
the TMSF value for each track and XOR'ing it with the previous
|
|
quantity shifted left one bit.
|
|
|
|
Arguments:
|
|
|
|
cdrom - supplies an index into the gDevices structure, used to
|
|
specify which disc to compute an ID for.
|
|
|
|
|
|
Return Value:
|
|
|
|
A DWORD unique ID.
|
|
|
|
--*/
|
|
|
|
{
|
|
INT NumTracks,i;
|
|
DWORD DiscId = 0;
|
|
|
|
|
|
NumTracks = gDevices[ cdrom ]->toc.LastTrack -
|
|
gDevices[ cdrom ]->toc.FirstTrack + 1;
|
|
|
|
for (i=0; i<NumTracks; i++)
|
|
DiscId = (DiscId << 1) ^
|
|
((i<<24) +
|
|
(TRACK_M(cdrom,i) << 16) +
|
|
(TRACK_S(cdrom,i) << 8) +
|
|
TRACK_F(cdrom,i) );
|
|
|
|
return( DiscId );
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
ErasePlayList(
|
|
IN INT cdrom
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Erases the current play list. This includes freeing the memory
|
|
for the nodes in the play list, and resetting the current track
|
|
pointer to NULL.
|
|
|
|
Arguments:
|
|
|
|
cdrom - supplies an index into the global structure gDevices
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
none
|
|
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
|
|
PTRACK_PLAY temp, temp1;
|
|
|
|
//
|
|
// Free memory for each track in play list
|
|
//
|
|
|
|
DBGPRINT(( 1, "ErasePlayList: PLAYLIST( cdrom ) is 0x%lx\n", PLAYLIST( cdrom ) ));
|
|
|
|
temp = PLAYLIST( cdrom );
|
|
while (temp!=NULL) {
|
|
|
|
DBGPRINT(( 1, " erasing: (0x%08lx) TocIndex = %d, PP(0x%08lx) NP(0x%08lx)\n",
|
|
temp, temp->TocIndex, temp->prevplay, temp->nextplay ));
|
|
temp1 = temp->nextplay;
|
|
LocalFree( (HLOCAL)temp );
|
|
temp = temp1;
|
|
|
|
}
|
|
|
|
//
|
|
// Reset pointers
|
|
//
|
|
|
|
PLAYLIST( cdrom ) = NULL;
|
|
CURRTRACK( cdrom ) = NULL;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
EraseSaveList(
|
|
IN INT cdrom
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Erases the current save list. This includes freeing the memory
|
|
for the nodes in the save list.
|
|
|
|
Arguments:
|
|
|
|
cdrom - supplies an index into the global structure gDevices
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
none
|
|
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
|
|
PTRACK_PLAY temp, temp1;
|
|
|
|
//
|
|
// Free memory for each track in play list
|
|
//
|
|
|
|
DBGPRINT(( 1, "EraseSaveList: PLAYLIST( cdrom ) is 0x%lx\n", SAVELIST( cdrom ) ));
|
|
|
|
temp = SAVELIST( cdrom );
|
|
while (temp!=NULL) {
|
|
|
|
DBGPRINT(( 1, " erasing: (0x%08lx) TocIndex = %d, PP(0x%08lx) NP(0x%08lx)\n",
|
|
temp, temp->TocIndex, temp->prevplay, temp->nextplay ));
|
|
temp1 = temp->nextplay;
|
|
LocalFree( (HLOCAL)temp );
|
|
temp = temp1;
|
|
|
|
}
|
|
|
|
//
|
|
// Reset pointers
|
|
//
|
|
|
|
SAVELIST( cdrom ) = NULL;
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
EraseTrackList(
|
|
IN INT cdrom
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Erases the current track list. This includes freeing the memory
|
|
for the nodes in the track list, and resetting the track list
|
|
pointer to NULL.
|
|
|
|
Arguments:
|
|
|
|
cdrom - supplies an index into the global structure gDevices
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
none
|
|
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
|
|
PTRACK_INF temp, temp1;
|
|
|
|
//
|
|
// Free memory for each track in track list
|
|
//
|
|
|
|
DBGPRINT(( 1, "EraseTrackList: ALLTRACKS( cdrom ) is 0x%lx\n", ALLTRACKS( cdrom ) ));
|
|
temp = ALLTRACKS( cdrom );
|
|
while (temp!=NULL) {
|
|
|
|
DBGPRINT(( 1, " erasing: (0x%08lx) TocIndex = %d, next(0x%08lx)\n",
|
|
temp, temp->TocIndex, temp->next ));
|
|
temp1 = temp->next;
|
|
LocalFree( (HLOCAL)temp );
|
|
temp = temp1;
|
|
|
|
}
|
|
|
|
//
|
|
// Reset pointers
|
|
//
|
|
|
|
ALLTRACKS( cdrom ) = NULL;
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
ResetPlayList(
|
|
IN INT cdrom
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Resets play order for the disc. Used to initialize/reset
|
|
the play list. This is done by reseting the doubly-linked list
|
|
of tracks in the gDevices[...]->CdInfo.PlayList.[prevplay,nextplay]
|
|
pointers. All the tracks on the CD are stored in a singly linked list
|
|
pointed to by gDevices[...]->CdInfo.AllTracks pointer.
|
|
|
|
Arguments:
|
|
|
|
|
|
cdrom - supplies an index into the global structure gDevices
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
none
|
|
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
PTRACK_INF t;
|
|
PTRACK_PLAY temp, prev;
|
|
|
|
DBGPRINT(( 1, "ResetPlayList: Killing old play list...\n" ));
|
|
|
|
//
|
|
// Kill old play list
|
|
//
|
|
|
|
ErasePlayList( cdrom );
|
|
EraseSaveList( cdrom );
|
|
|
|
//
|
|
// Duplicate each node in AllTracks and insert in-oder
|
|
// in SaveList list. The SaveList is the master which is
|
|
// used for the playlist.
|
|
//
|
|
|
|
DBGPRINT(( 1, "ResetPlayList: Create default play list...\n" ));
|
|
|
|
t = ALLTRACKS( cdrom );
|
|
prev = NULL;
|
|
|
|
while (t!=NULL) {
|
|
|
|
temp = (PTRACK_PLAY) LocalAlloc( LPTR, sizeof( TRACK_PLAY ) );
|
|
|
|
//
|
|
// BUGBUG -- need to check for NULL return
|
|
//
|
|
|
|
temp->TocIndex = t->TocIndex;
|
|
temp->min = 0;
|
|
temp->sec = 0;
|
|
temp->prevplay = prev;
|
|
temp->nextplay = NULL;
|
|
|
|
if (prev!=NULL) {
|
|
|
|
prev->nextplay = temp;
|
|
|
|
} else {
|
|
|
|
SAVELIST( cdrom ) = temp;
|
|
|
|
}
|
|
|
|
prev = temp;
|
|
t=t->next;
|
|
|
|
}
|
|
|
|
PLAYLIST( cdrom ) = CopyPlayList( SAVELIST( cdrom) );
|
|
|
|
DUMPPLAYLIST(( PLAYLIST(cdrom) ));
|
|
|
|
}
|
|
|
|
|
|
BOOL
|
|
DeleteEntry(
|
|
IN DWORD Id
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
The ID format has changed to make the id's for the different CD's
|
|
more unique. This routine will completely delete the old key value
|
|
from the ini file. We remove it by writing a NULL entry.
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Id - Id of the key to delete from the INI file
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
TRUE if successful, FALSE if not
|
|
|
|
--*/
|
|
{
|
|
TCHAR Section[80], Buffer[2]="";
|
|
|
|
sprintf( Section, "%lX", Id );
|
|
return( WritePrivateProfileSection( Section, Buffer, INI_FILE_NAME ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
BOOL
|
|
WriteEntry(
|
|
IN INT cdrom
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Write current disc information into database ini file.
|
|
The section for the current disc (section name is a hex
|
|
value of the disc id) is completely rewritten.
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
cdrom - supplies an index into the global array gDevices
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
TRUE if successful, FALSE if not
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
|
|
TCHAR Buffer[ 64000 ];
|
|
LPTSTR s;
|
|
INT i;
|
|
TCHAR Section[ 10 ];
|
|
PTRACK_INF temp;
|
|
PTRACK_PLAY temp1;
|
|
|
|
//
|
|
// Construct ini file buffer, form of:
|
|
//
|
|
// artist = artist name
|
|
// title = Title of disc
|
|
// numtracks = n
|
|
// 0 = Title of track 1
|
|
// 1 = Title of track 2
|
|
// n-1 = Title of track n
|
|
// order = 0 4 3 2 6 7 8 ... (n-1)
|
|
// numplay = # of entries in order list
|
|
//
|
|
|
|
//
|
|
// Is it legal to save this information?
|
|
//
|
|
|
|
if (!gDevices[ cdrom ]->CdInfo.save)
|
|
return( TRUE );
|
|
|
|
gDevices[ cdrom ]->CdInfo.IsVirginCd = FALSE;
|
|
|
|
sprintf( Section, "%lX", gDevices[ cdrom ]->CdInfo.Id );
|
|
|
|
s = Buffer;
|
|
|
|
sprintf( s, "EntryType=%d", 1 );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "artist=%s", gDevices[ cdrom ]->CdInfo.Artist );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "title=%s", gDevices[ cdrom ]->CdInfo.Title );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "numtracks=%d", gDevices[ cdrom ]->CdInfo.NumTracks );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
for ( temp = gDevices[ cdrom ]->CdInfo.AllTracks;
|
|
temp!=NULL;
|
|
temp = temp->next
|
|
) {
|
|
|
|
sprintf( s, "%d=%s", temp->TocIndex, temp->name );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
}
|
|
|
|
sprintf( s, "order=" );
|
|
s += strlen(s);
|
|
|
|
i = 0;
|
|
for ( temp1 = gDevices[ cdrom ]->CdInfo.SaveList;
|
|
temp1!=NULL;
|
|
temp1 = temp1->nextplay
|
|
) {
|
|
|
|
sprintf( s, "%d ", temp1->TocIndex );
|
|
s += strlen(s);
|
|
i++;
|
|
|
|
}
|
|
|
|
s+=sizeof(TCHAR);
|
|
|
|
sprintf( s, "numplay=%d", i );
|
|
s += strlen(s);
|
|
|
|
//
|
|
// Just make sure there are NULLs at end of buffer
|
|
//
|
|
|
|
sprintf( s, "\0\0\0" );
|
|
|
|
sprintf( Section, "%lX", gDevices[ cdrom ]->CdInfo.Id );
|
|
|
|
//
|
|
// Try writing buffer into ini file
|
|
//
|
|
|
|
return( WritePrivateProfileSection( Section, Buffer, INI_FILE_NAME ) );
|
|
|
|
}
|
|
|
|
|
|
BOOL
|
|
ReadEntry(
|
|
IN INT cdrom,
|
|
IN DWORD dwId
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Try to read entry for new disc from database ini file.
|
|
The section name we are trying to read is a hex
|
|
value of the disc id. If the sections is found,
|
|
fill in the data for the disc in the cdrom drive.
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
cdrom - supplies an index into the global array gDevices
|
|
|
|
dwId - supplies id of disc in cdrom drive
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
TRUE if successful, FALSE if not
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
DWORD rc;
|
|
TCHAR Section[10];
|
|
TCHAR s[100],s1[100];
|
|
TCHAR order[ 8192 ];
|
|
TCHAR torder[ 8192 ];
|
|
INT i;
|
|
LPSTR porder;
|
|
DWORD numtracks, numplay;
|
|
PTRACK_INF temp, curr;
|
|
PTRACK_PLAY temp1, prev;
|
|
BOOL OldEntry;
|
|
|
|
|
|
gDevices[ cdrom ]->CdInfo.iFrameOffset = NEW_FRAMEOFFSET;
|
|
|
|
|
|
//
|
|
// Try to read in section from ini file
|
|
//
|
|
|
|
sprintf( Section, "%lX", dwId );
|
|
|
|
rc = GetPrivateProfileString( Section,
|
|
"title",
|
|
"~~^^",
|
|
(LPSTR)gDevices[ cdrom ]->CdInfo.Title,
|
|
TITLE_LENGTH,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
//
|
|
// Was the section found?
|
|
//
|
|
|
|
if ((gDevices[ cdrom ]->CdInfo.Title[0]=='~') &&
|
|
(gDevices[ cdrom ]->CdInfo.Title[1]=='~') &&
|
|
(gDevices[ cdrom ]->CdInfo.Title[2]=='^') &&
|
|
(gDevices[ cdrom ]->CdInfo.Title[3]=='^') &&
|
|
(gDevices[ cdrom ]->CdInfo.Title[4]=='\0')
|
|
)
|
|
|
|
//
|
|
// Nope, notify caller
|
|
//
|
|
|
|
return( FALSE );
|
|
|
|
//
|
|
// We found an entry for this disc, so copy all the information
|
|
// from the ini file entry
|
|
//
|
|
|
|
gDevices[ cdrom ]->CdInfo.Id = dwId;
|
|
gDevices[ cdrom ]->CdInfo.save = TRUE;
|
|
|
|
//
|
|
// Is this an old entry?
|
|
//
|
|
|
|
i = GetPrivateProfileInt( Section,
|
|
"EntryType",
|
|
0,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
OldEntry = (i==0);
|
|
|
|
numtracks = GetPrivateProfileInt( Section,
|
|
"numtracks",
|
|
0,
|
|
INI_FILE_NAME
|
|
);
|
|
gDevices[ cdrom ]->CdInfo.NumTracks = numtracks;
|
|
|
|
rc = GetPrivateProfileString( Section,
|
|
"artist",
|
|
gszUnknownTxt,
|
|
(LPSTR)ARTIST(cdrom),
|
|
ARTIST_LENGTH,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
//
|
|
// Read the track list information
|
|
//
|
|
|
|
DBGPRINT(( 1, "ReadEntry: creating track list from entry...\n" ));
|
|
|
|
for (i=0, curr = NULL; i<(INT)numtracks; i++) {
|
|
|
|
temp = (PTRACK_INF) LocalAlloc( LPTR, sizeof( TRACK_INF ) );
|
|
temp->TocIndex = i;
|
|
temp->next = NULL;
|
|
sprintf( s1, IdStr(STR_INIT_TRACK), i+1 );
|
|
sprintf( s, "%d", i );
|
|
rc = GetPrivateProfileString( Section,
|
|
s,
|
|
s1,
|
|
(LPSTR)temp->name,
|
|
TRACK_TITLE_LENGTH,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
if (curr==NULL) {
|
|
|
|
ALLTRACKS( cdrom ) = curr = temp;
|
|
|
|
} else {
|
|
|
|
curr->next = temp;
|
|
curr = temp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
DUMPTRACKLIST(( ALLTRACKS(cdrom) ));
|
|
|
|
if (OldEntry) {
|
|
|
|
//
|
|
// Generate generic play list (all tracks in order)
|
|
//
|
|
|
|
DBGPRINT(( 1, "ReadEntry: Generating default play list (old entry)\n" ));
|
|
ResetPlayList( cdrom );
|
|
|
|
//
|
|
// Need to rewrite this entry in new format
|
|
//
|
|
|
|
WriteEntry( cdrom );
|
|
|
|
} else {
|
|
|
|
//
|
|
// Read play list (order) information and construct play list doubly
|
|
// linked list
|
|
//
|
|
|
|
DBGPRINT(( 1, "ReadEntry: Generating PlayList based on entry.\n" ));
|
|
numplay = GetPrivateProfileInt( Section,
|
|
"numplay",
|
|
0,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
porder = torder;
|
|
memset( porder, '\0', 8192 );
|
|
for (i=0; i<(INT)numtracks; i++) {
|
|
|
|
sprintf( porder, "%d ", i );
|
|
porder += (strlen( porder ) * sizeof( TCHAR ));
|
|
|
|
}
|
|
|
|
rc = GetPrivateProfileString( Section,
|
|
"order",
|
|
torder,
|
|
(LPTSTR)order,
|
|
8192,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
//
|
|
// Ensure a trailing space
|
|
//
|
|
|
|
strcat( order, " " );
|
|
porder = order;
|
|
prev = NULL;
|
|
|
|
while ( sscanf( porder, "%d", &i )!=EOF ) {
|
|
|
|
temp1 = (PTRACK_PLAY) LocalAlloc( LPTR, sizeof( TRACK_PLAY ) );
|
|
temp1->TocIndex = i;
|
|
temp1->min = 0;
|
|
temp1->sec = 0;
|
|
temp1->prevplay = prev;
|
|
temp1->nextplay = NULL;
|
|
|
|
if (prev==NULL) {
|
|
|
|
SAVELIST( cdrom ) = temp1;
|
|
|
|
} else {
|
|
|
|
prev->nextplay = temp1;
|
|
|
|
}
|
|
prev = temp1;
|
|
|
|
porder = (LPSTR)(((DWORD)strchr( porder, ' ' )) + sizeof(TCHAR));
|
|
|
|
}
|
|
|
|
PLAYLIST( cdrom ) = CopyPlayList( SAVELIST( cdrom ) );
|
|
DUMPPLAYLIST(( PLAYLIST(cdrom) ));
|
|
|
|
}
|
|
|
|
|
|
return( TRUE );
|
|
|
|
}
|
|
|
|
BOOL
|
|
WriteSettings(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Read app settings from ini file.
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
none.
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
TRUE if successful, FALSE if not
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR Buffer[ 1024 ];
|
|
LPTSTR s;
|
|
WINDOWPLACEMENT wndpl;
|
|
|
|
|
|
s = Buffer;
|
|
|
|
|
|
if (!gSaveSettings) {
|
|
|
|
WritePrivateProfileString("Settings","SaveSettingsOnExit","0",INI_FILE_NAME);
|
|
return(TRUE);
|
|
|
|
}
|
|
|
|
sprintf( s, "SaveSettingsOnExit=%lu", (DWORD)gSaveSettings );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
//
|
|
// Save disc play settings
|
|
//
|
|
|
|
sprintf( s, "DisplayT=%lu",(DWORD)gDisplayT );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "DisplayTr=%lu",(DWORD)gDisplayTr );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "DisplayDr=%lu",(DWORD)gDisplayDr );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "InOrderPlay=%lu",(DWORD)gOrder );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "RandomPlay=%lu", (DWORD)gRandom );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "MultiDiscPlay=%lu", (DWORD)gMulti );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "IntroPlay=%lu", (DWORD)gIntro );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "ContinuousPlay=%lu", (DWORD)gContinuous );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "ToolBar=%lu", (DWORD)(gToolBarWnd!=NULL) );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "DiscAndTrackDisplay=%lu", (DWORD)(gTrackInfoWnd!=NULL) );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
// sprintf( s, "Ruler=%lu", (DWORD)(gRulerWnd!=NULL) );
|
|
// s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "StatusBar=%lu", (DWORD)(gStatusWnd!=NULL) );
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
GetWindowPlacement(gMainWnd,&wndpl);
|
|
|
|
sprintf( s, "WindowOrigin=%d %d",wndpl.rcNormalPosition.left,
|
|
wndpl.rcNormalPosition.top);
|
|
s += (strlen(s) + sizeof(TCHAR));
|
|
|
|
sprintf( s, "\0\0\0" );
|
|
|
|
return( WritePrivateProfileSection( "Settings",
|
|
Buffer,
|
|
INI_FILE_NAME
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
|
|
BOOL
|
|
ReadSettings(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Read app settings from ini file.
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
none.
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
TRUE if successful, FALSE if not
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
INT y;
|
|
RECT r;
|
|
CHAR s[80],t[80];
|
|
|
|
//
|
|
// Get disc play settings
|
|
//
|
|
|
|
gOrder = (BOOL)GetPrivateProfileInt( "Settings",
|
|
"InOrderPlay",
|
|
(DWORD)FALSE,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
gRandom = (BOOL)GetPrivateProfileInt( "Settings",
|
|
"RandomPlay",
|
|
(DWORD)FALSE,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
gMulti = (BOOL)GetPrivateProfileInt( "Settings",
|
|
"MultiDiscPlay",
|
|
(DWORD)FALSE,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
if (gNumCdDevices<=1) {
|
|
|
|
gMulti = FALSE;
|
|
|
|
}
|
|
|
|
if (gOrder && gRandom) {
|
|
|
|
gRandom = FALSE;
|
|
|
|
}
|
|
|
|
gIntro = (BOOL)GetPrivateProfileInt( "Settings",
|
|
"IntroPlay",
|
|
(DWORD)FALSE,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
gContinuous = (BOOL)GetPrivateProfileInt( "Settings",
|
|
"ContinuousPlay",
|
|
(DWORD)TRUE,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
gSaveSettings = (BOOL)GetPrivateProfileInt( "Settings",
|
|
"SaveSettingsOnExit",
|
|
(DWORD)TRUE,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
gDisplayT = (BOOL)GetPrivateProfileInt( "Settings",
|
|
"DisplayT",
|
|
(DWORD)TRUE,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
gDisplayTr = (BOOL)GetPrivateProfileInt( "Settings",
|
|
"DisplayTr",
|
|
(DWORD)FALSE,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
gDisplayDr = (BOOL)GetPrivateProfileInt( "Settings",
|
|
"DisplayDr",
|
|
(DWORD)FALSE,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
if ((BOOL)GetPrivateProfileInt( "Settings",
|
|
"ToolBar",
|
|
(DWORD)FALSE,
|
|
INI_FILE_NAME )) {
|
|
|
|
ToolBarCreate( 0, 0, TOOLBAR_WIN_W, TOOLBAR_WIN_H );
|
|
|
|
}
|
|
|
|
if (gToolBarWnd)
|
|
y = TOOLBAR_WIN_H;
|
|
else
|
|
y = 0;
|
|
|
|
ControlCreate( 0, y, CONTROL_WIN_W, CONTROL_WIN_H );
|
|
|
|
if ((BOOL)GetPrivateProfileInt( "Settings",
|
|
"DiscAndTrackDisplay",
|
|
(DWORD)TRUE,
|
|
INI_FILE_NAME )) {
|
|
|
|
y = CONTROL_WIN_H;
|
|
|
|
if (gToolBarWnd)
|
|
y += TOOLBAR_WIN_H;
|
|
|
|
TrackInfoCreate( 0, y, TRACKINFO_WIN_W, TRACKINFO_WIN_H );
|
|
|
|
}
|
|
|
|
if ((BOOL)GetPrivateProfileInt( "Settings",
|
|
"Ruler",
|
|
(DWORD)FALSE,
|
|
INI_FILE_NAME )) {
|
|
|
|
y = CONTROL_WIN_H;
|
|
|
|
if (gToolBarWnd) y+=TOOLBAR_WIN_H;
|
|
if (gTrackInfoWnd) y+=TRACKINFO_WIN_H;
|
|
|
|
//RulerCreate( 0, y, RULER_WIN_W, RULER_WIN_H );
|
|
|
|
}
|
|
|
|
if ((BOOL)GetPrivateProfileInt( "Settings",
|
|
"StatusBar",
|
|
(DWORD)TRUE,
|
|
INI_FILE_NAME )) {
|
|
|
|
y = CONTROL_WIN_H;
|
|
|
|
if (gToolBarWnd) y+=TOOLBAR_WIN_H;
|
|
if (gTrackInfoWnd) y+=TRACKINFO_WIN_H;
|
|
// if (gRulerWnd) y+=RULER_WIN_H;
|
|
|
|
StatusCreate( 0, y, STATUS_WIN_W, STATUS_WIN_H );
|
|
|
|
}
|
|
|
|
|
|
GetWindowRect( gMainWnd, &r );
|
|
|
|
sprintf(t,"%d %d",r.left, r.top);
|
|
|
|
GetPrivateProfileString( "Settings",
|
|
"WindowOrigin",
|
|
(LPSTR) t,
|
|
(LPSTR) s,
|
|
80,
|
|
INI_FILE_NAME
|
|
);
|
|
|
|
sscanf(s,"%d %d", &r.left, &r.top);
|
|
|
|
y = CONTROL_WIN_H;
|
|
if (gToolBarWnd) y+=TOOLBAR_WIN_H;
|
|
if (gTrackInfoWnd) y+=TRACKINFO_WIN_H;
|
|
// if (gRulerWnd) y+=RULER_WIN_H;
|
|
if (gStatusWnd) y+=STATUS_WIN_H;
|
|
|
|
MoveWindow( gMainWnd,
|
|
r.left,
|
|
r.top,
|
|
MAIN_WIN_W,
|
|
y+
|
|
GetSystemMetrics( SM_CYCAPTION ) +
|
|
GetSystemMetrics( SM_CYMENU ) + 2,
|
|
FALSE
|
|
);
|
|
|
|
return( TRUE );
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
AddFindEntry(
|
|
IN INT cdrom,
|
|
IN DWORD key,
|
|
IN PCDROM_TOC lpTOC
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Search the database file for the current disc,
|
|
if found, read the information, otherwise, ask
|
|
user if they want to add this disc to the database.
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
cdrom - supplies an index into the global array gDevices
|
|
|
|
key - disc id of current disc
|
|
|
|
lpTOC - supplies pointer to table of contents read from
|
|
this disc
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
none
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
INT i,num;
|
|
PTRACK_INF temp, temp1;
|
|
|
|
//
|
|
// Kill off old PlayList, Save lists if they exists.
|
|
//
|
|
|
|
ErasePlayList( cdrom );
|
|
EraseSaveList( cdrom );
|
|
EraseTrackList( cdrom );
|
|
|
|
//
|
|
// Check ini file for an existing entry
|
|
//
|
|
|
|
//
|
|
// Note that we've been passed the new ID, and some old ones
|
|
// may be out there. Use short circuit to determine whether
|
|
// it's possibly the old ID as well.
|
|
//
|
|
|
|
if (ReadEntry( cdrom, key )) {
|
|
|
|
gDevices[ cdrom ]->CdInfo.IsVirginCd = FALSE;
|
|
|
|
} else {
|
|
|
|
if (ReadEntry(cdrom,ComputeOldDiscId(cdrom))) {
|
|
//
|
|
// If the disc was under an OLD id, we need to delete the
|
|
// old one, convert it to the new format, and save it under
|
|
// its new key.
|
|
//
|
|
DeleteEntry( ComputeOldDiscId(cdrom) );
|
|
gDevices[ cdrom ]->CdInfo.IsVirginCd = FALSE;
|
|
gDevices[ cdrom ]->CdInfo.Id = key;
|
|
gDevices[ cdrom ]->CdInfo.save = TRUE;
|
|
WriteEntry( cdrom );
|
|
} else {
|
|
//
|
|
// This is a new entry, fill it in and store it in the database.
|
|
//
|
|
gDevices[ cdrom ]->CdInfo.IsVirginCd = TRUE;
|
|
gDevices[ cdrom ]->CdInfo.Id = key;
|
|
sprintf( (LPSTR)ARTIST( cdrom ), IdStr( STR_NEW_ARTIST ) );
|
|
sprintf( (LPSTR)TITLE( cdrom ), IdStr( STR_NEW_TITLE ) );
|
|
num = lpTOC->LastTrack - lpTOC->FirstTrack + 1;
|
|
NUMTRACKS( cdrom ) = num;
|
|
|
|
//
|
|
// Create generic playlist, which is all audio tracks
|
|
// played in the order they are on the CD. First, create
|
|
// a singly linked list that contains all the tracks.
|
|
// Then, create a double linked list, using the nodes of
|
|
// from the single linked list for the play list.
|
|
//
|
|
|
|
|
|
DBGPRINT(( 1, "AddFindEntry: Creating default track list...\n" ));
|
|
for( i=0; i<num; i++ ) {
|
|
|
|
//
|
|
// Create storage for track
|
|
//
|
|
|
|
temp = (PTRACK_INF)LocalAlloc( LPTR, sizeof( TRACK_INF ) );
|
|
|
|
//
|
|
// Initialize information (storage already ZERO initialized)
|
|
//
|
|
|
|
sprintf( (LPSTR)temp->name, IdStr( STR_INIT_TRACK ), i+1 );
|
|
temp->TocIndex = i;
|
|
temp->next = NULL;
|
|
|
|
//
|
|
// Add node to singly linked list of all tracks
|
|
//
|
|
|
|
if (i==0) {
|
|
|
|
temp1 = ALLTRACKS( cdrom ) = temp;
|
|
|
|
} else {
|
|
|
|
temp1->next = temp;
|
|
temp1 = temp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
DUMPTRACKLIST(( ALLTRACKS(cdrom) ));
|
|
|
|
//
|
|
// Generate generic play list (all tracks in order)
|
|
//
|
|
|
|
ResetPlayList( cdrom );
|
|
|
|
//
|
|
// Save this disc in the .ini file
|
|
//
|
|
|
|
gDevices[ cdrom ]->CdInfo.save = TRUE;
|
|
WriteEntry( cdrom );
|
|
}
|
|
}
|
|
|
|
}
|
|
|