void CCueSheet::OnBnClickedButton1()
{
CreateSheet();
CUStringConvert strCnv;
CUStringConvert strCnv1;
CDInfo& cdInfo = m_pDoc->GetCDInfo();
CUString cueSheetName;
DWORD cdID = cdInfo.GetDiscID();
cueSheetName.Format( _W( "%s%08X.cue" ),
(LPCWSTR)g_config.GetMP3OutputDir(),
cdID );
CUString strFilter = g_language.GetString( IDS_CUESHEETFILESELECTION );
CFileDialog cueFileDlg(
FALSE,
_T( ".cue" ),
strCnv.ToT( cueSheetName ),
OFN_OVERWRITEPROMPT,
strCnv1.ToT( strFilter ) );
if ( IDOK == cueFileDlg.DoModal() )
{
CUString strFileName = CUString( cueFileDlg.GetPathName() );
FILE* pFile = CDexOpenFile( strFileName, _W( "w" ) );
if ( pFile )
{
#ifdef UNICODE
BYTE btBOM[] = { 0xEF, 0xBB, 0xBF };
fwrite( &btBOM, sizeof( btBOM ), 1, pFile );
#endif
LPCSTR lpszUtf = strCnv.ToUTF8( m_strCueSheet );
fwrite( lpszUtf,
strlen( lpszUtf ),
1,
pFile );
fclose( pFile );
}
}
}
bool CUIndexFile::Load( char *prefix )
{
Close();
char buf[1024];
sprintf( buf, "%s.uidx-key", prefix );
if( key_file.OpenFile( buf, "r" ) == false )
{
return false;
}
sprintf( buf, "%s.uidx-value", prefix );
if( value_file.OpenFile( buf, "r" ) == false )
{
return false;
}
info_map.clear();
while( true )
{
CUString line;
if( key_file.ReadLine( line ) == false ) break;
CUStringList list( line, "\t" );
if( list.GetSize() != 4 ) {
fprintf( stderr, "Error: Invalid format: %s\n", line.GetStr() );
return false;
}
if( info_map.find( list.GetAt(0) ) != info_map.end() )
{
fprintf( stderr, "Error: Duplicated key: %s\n", list.GetAt(0) );
return false;
}
CUIndexFileInfo info;
info.start = atol( list.GetAt(1) );
info.end = atol( list.GetAt(2) );
if( strcmp( list.GetAt(3), "0" ) == 0 ) info.enable = false;
else info.enable = true;
info_map[ list.GetAt(0) ] = info;
}
return true;
}
void CLanguage::ReportMissingID( int nID, const CUString& strEnglish, int nType ) const
{
if ( g_nReportMissing )
{
BOOL bAdd = TRUE;
CUString strWrite;
CString strRead;
CStdioFile cFile;
CUStringConvert strCnv;
switch ( nType )
{
case 0:
strWrite.Format( _W( "#%04X# \"%s\"" ), nID, (LPCWSTR)strEnglish );
break;
case 1:
strWrite.Format( _W( "#M%04X# \"%s\"" ), nID, (LPCWSTR)strEnglish );
break;
case 2:
strWrite.Format( _W( "#D%08X# \"%s\"" ), nID, (LPCWSTR)strEnglish );
break;
}
EncodeTab( strWrite );
if ( cFile.Open( _T( "c:\\temp\\missing.txt" ),
CFile::modeReadWrite | CFile::modeNoTruncate | CFile::modeCreate ) )
{
while ( cFile.ReadString( strRead ) )
{
if ( strWrite.Find( CUString( strRead ) ) >=0 )
{
bAdd = FALSE;
break;
}
}
if ( bAdd )
{
cFile.WriteString( strCnv.ToT( strWrite + _W( "\n" ) ) );
}
cFile.Close();
}
}
}
void CMP3ToWavDlg::OnTimer(UINT nIDEvent)
{
CUString strLang;
CString strTmp;
CUString strTime;
strTmp.Format( _T( " (%d/%d)" ), m_wCurrentTrack+1, m_nTotalFiles );
// Update the time statistics based on the percentage completed
m_TimeTrack.Calculate( m_nPercentCompleted );
// Call the default dialog timer event
CDialog::OnTimer( nIDEvent );
// Update progress bar position
m_Progress.SetPos( m_nPercentCompleted );
m_strFileName = m_strWavFileName + strTmp;
if ( m_strFileName.GetLength() > 65 )
{
int nPos = m_strFileName.Find( _T( ":" ) );
if ( nPos < 0 )
nPos = 0;
m_strFileName = m_strFileName.Left( nPos + 2 ) +
_T( " ... " ) +
m_strFileName.Right( 60 ) ;
}
// Get time estimate
strLang = g_language.GetString( IDS_ELAPSED_TIME );
strTime.Format( strLang, (LPCWSTR)m_TimeTrack.GetElapsedString(), (LPCWSTR)m_TimeTrack.GetRemainingString(), (LPCWSTR)m_TimeTrack.GetEstimateString() );
m_strTimeInfo = strTime;
// Update the controls
UpdateData(FALSE);
}
BOOL CGenreEditDlg::OnInitDialog()
{
CUString strLang;
CDialog::OnInitDialog();
// translate dialog resources
g_language.InitDialogStrings( this, IDD );
CUStringConvert strCnv;
strLang = g_language.GetString( IDS_GENRE_NAME );
m_List.InsertColumn( 0, strCnv.ToT( strLang ), LVCFMT_LEFT, 130, 0 );
strLang = g_language.GetString( IDS_GENRE_CDDB_NAME );
m_List.InsertColumn( 1, strCnv.ToT( strLang ), LVCFMT_LEFT, 100, 0 );
strLang = g_language.GetString( IDS_GENRE_ID3V1ID );
m_List.InsertColumn( 2, strCnv.ToT( strLang ), LVCFMT_LEFT, 70, 0 );
m_nInsertPosition = 0;
// Fill Category
for (WORD i=0; i < g_GenreTable.GetNumGenres(); i++)
{
if ( g_GenreTable.CanBeModified( i ) )
{
CUString strNmbr;
strNmbr.Format( _W( "%d" ) , g_GenreTable.GetID3V1ID( i) );
m_List.InsertItem( m_nInsertPosition, strCnv.ToT( g_GenreTable.GetGenre( i ) ) );
m_List.SetItemText( m_nInsertPosition, 1, strCnv.ToT( g_GenreTable.GetCDDBGenre( i ) ) );
m_List.SetItemText( m_nInsertPosition, 2, strCnv.ToT( strNmbr ) );
m_nInsertPosition++;
}
}
m_Spin.SetRange( 0, 255 );
m_List.SetCurSel( 0 );
SetControls( 0 );
return TRUE;
}
void CRipInfoDB::SetRipInfoFinshedOK(CUString strRipInfo, ULONG crc )
{
CUStringConvert strCnv;
// Open file for append
m_pFile = CDexOpenFile( m_strFileName, _W( "a+" ) );
if ( m_pFile )
{
CUString strOut;
strOut.Format( _W( "[%03d][C] : %s CRC=%08X\n" ), m_nTrack, (LPCWSTR) strRipInfo, crc );
_fputts( strCnv.ToT( strOut ), m_pFile );
fclose( m_pFile );
m_pFile = NULL;
}
}
void CRipInfoDB::SetRipInfo(CUString strRipInfo)
{
// Open file for append
CUStringConvert strCnv;
m_pFile = CDexOpenFile( m_strFileName, _W( "a+" ) );
if ( NULL != m_pFile )
{
CUString strOut;
strOut.Format( _W( "[%03d][I] : %s\n" ), m_nTrack, (LPCWSTR)strRipInfo );
_fputts( strCnv.ToT( strOut ), m_pFile );
fclose( m_pFile );
m_pFile = NULL;
}
}
void CLanguage::SearchLanguageFiles( )
{
CUString strSearchName;
CFileFind fileFind;
BOOL bFound = FALSE;
// PVOID pTest = (PVOID)m_strLanguageDir;
//CString str;
//CString str1 =_T( "CSTRING1" );
//CString str2 =_T( "CSTRING2" );
//CUString str3( _W("CUSTRING" ));
// str.Format( _W( "%s" ),str1 );
// str.Format( _W( "%s" ),(LPCWSTR)str3 );
// str.Format( _W( "%s\\lang\\*%s" ),
// str1,
// str3);
// CUString* p1 = &str3;
// CString* p2 = &str1;
// build the filename search string
strSearchName.Format( _W( "%s\\lang\\*%s" ), (LPCWSTR)m_strLanguageDir, (LPCWSTR)m_strLangFileExt );
CUStringConvert strCnv;
bFound = fileFind.FindFile( strCnv.ToT( strSearchName ) );
while ( bFound )
{
bFound = fileFind.FindNextFile();
CUString strFileName = fileFind.GetFileName();
CUString strLanguage = strFileName.Left( strFileName.GetLength() - m_strLangFileExt.GetLength() );
m_vLangFiles.push_back( strLanguage );
}
sort( m_vLangFiles.begin(), m_vLangFiles.end() );
}
HRESULT CLX3DViewer::OnDraw(ATL_DRAWINFO& di)
{
CRect& rc = *(CRect*)di.prcBounds;
CDCHandle dc(di.hdcDraw);
{
{
CUString str = "left/right/up/down";
dc.TextOut(0, 0, str, str.GetLength());
}
{
CUString str = "left/right/forward/backward";
dc.TextOut(125, 0, str, str.GetLength());
}
{
CUString str = "rotate";
dc.TextOut(315, 0, str, str.GetLength());
}
/*
CUString str;
str.Format("%g", m_currentSpeed);
TextOut(hdc, 0, 0, str, str.GetLength());
*/
}
{
m_slider.Draw(dc);
}
return 1; // ??
return S_OK;
}
CUString CLanguage::GetString( const DWORD nID ) const
{
CUString strRet;
DWORD dwIndex;
for ( dwIndex = 0; dwIndex < m_vStrings.size(); dwIndex++ )
{
if ( m_vStrings[ dwIndex ].nID == nID )
{
strRet = m_vStrings[ dwIndex ].strValue;
break;
}
}
if ( strRet.IsEmpty() )
{
CString strResource;
strResource.LoadString( nID );
strRet = CUString( strResource );
#ifdef _DEBUG
ReportMissingID( nID, strRet, 0 );
#endif
}
else
{
#ifdef _DEBUG
CString strResource;
strResource.LoadString( nID );
if ( 0 != strRet.Compare( CUString( strResource ) ) )
{
ReportChangedID( nID, CUString( strResource ), strRet, 0 );
}
#endif
}
return strRet;
}
UINT CAutoDetect::OnStartDetectionCache(void *lpParam)
{
const int bufferSize = 65535;
// create the stream buffer
BYTE* pbtStream = new BYTE[ bufferSize ];
// Read one chunk
for ( DWORD loop = 1; loop < 100; loop++ )
{
DWORD numSectors = loop;
LONG sector = 0;
__int64 startTime = PerformanceCounterGetTime();
while ( numSectors > 0 )
{
DWORD readSectors = min( numSectors, 20 );
if ( CDEX_ERROR == CR_ReadBlockDirect( pbtStream, bufferSize, sector, readSectors ) )
{
ASSERT( FALSE );
return CDEX_ERROR;
}
numSectors -= readSectors;
sector += readSectors;
}
double deltaTime = PerformanceCounterGetDelta( startTime, PerformanceCounterGetTime() );
CUString strOut;
strOut.Format( _W( "sectors: %d bytes: %d time(ms)=%10.3f transfer rate: %12.5f\n" ), loop, loop * 2352,deltaTime,(double)loop * 2352.0 / deltaTime / 1024.0 / 1024.0 );
CUStringConvert strCnv;
OutputDebugString( strCnv.ToT( strOut ) );
}
delete [] pbtStream;
return CDEX_OK;
}
void CWebSite::OnRescan(GUID* iid)
{
ATLASSERT(0);
try
{
WCHAR sql[256];
swprintf(sql, L"INSERT INTO files (filename) VALUES ('%s')", L"test.htm");
_variant_t va;
m_siteDataConnection->Execute(sql, &va, ADODB::adCmdText);
m_siteDataConnection->Close();
}
catch (_com_error &e)
{
_bstr_t bstrSource(e.Source());
_bstr_t bstrDescription(e.Description());
CUString msg;
msg.Format("\n\tSource : %s \n\tdescription : %s \n ",(LPCSTR)bstrSource,(LPCSTR)bstrDescription);
MessageBox(NULL, msg, "", MB_OK);
}
}
bool CUniString::TokenizeAsciiEscapedUnicode()
{
CUString tmp = GetStr();
while( true ) {
int idx = tmp.Find( "\\u" );
if( idx < 0 ) {
for( int i=0; i<tmp.GetLength(); i++ ) {
char ch = tmp.GetAt(i);
if( (int)ch >= 0 ) {
char buf[4]; sprintf( buf, "%c", ch );
unichar_list.PushBack( buf );
enc_byte += 1;
}
else {
return false;
}
}
break;
}
else {
for( int i=0; i<idx; i++ ) {
char ch = tmp.GetAt(i);
if( (int)ch >= 0 ) {
char buf[4]; sprintf( buf, "%c", ch );
unichar_list.PushBack( buf );
enc_byte += 1;
}
else {
return false;
}
}
CUString uni = tmp.SubStr( idx, idx+6 );
uni = EncodeUTF8( uni );
unichar_list.PushBack( uni );
enc_byte += uni.GetLength();
tmp = tmp.Mid( idx+6 );
}
}
return true;
}
void CLineImpl::Prepare(
IZ_UINT8* dst,
IZ_UINT pitch,
IZ_UINT ascent,
IFontHost* host)
{
IZ_UINT code = 0;
CUString string;
string.Init(m_Encode, m_Text, m_Bytes);
string.BeginIter();
IZ_UINT x = 0;
for (;;)
{
if (m_FontHost->GetEncodeType() == E_FONT_CHAR_ENCODE_UNICODE)
{
code = string.GetNextAsUnicode();
}
else
{
code = string.GetNext();
}
if (code == 0)
{
break;
}
IZ_UINT id = m_FontHost->GetGlyphID(code);
SGlyphMetrics metrics;
if (m_FontHost->GetGlyphMetricsByID(id, metrics))
{
x = this->CopyImage(
id,
dst,
x,
pitch,
ascent);
}
else
{
// TODO
}
}
string.EndIter();
}
IZ_UINT CLineImpl::GetLineWidth()
{
if (m_Text == IZ_NULL)
{
return 0;
}
CUString string;
string.Init(m_Encode, m_Text, m_Bytes);
IZ_UINT width = 0;
IZ_UINT code = 0;
string.BeginIter();
for (;;)
{
if (m_FontHost->GetEncodeType() == E_FONT_CHAR_ENCODE_UNICODE)
{
code = string.GetNextAsUnicode();
}
else
{
code = string.GetNext();
}
if (code == 0)
{
break;
}
SGlyphMetrics metrics;
if (m_FontHost->GetGlyphMetricsByCode(code, metrics))
{
width += metrics.advance;
}
else
{
// TODO
}
}
string.EndIter();
return width;
}
int CGenreTable::AddEntry( INT nID3V1ID, const CUString& strGenre, const CUString& strCDDBGenre, bool bCanBeModified )
{
bool bAdd = true;
int i = 0;
GENRETABLEENTRY newEntry;
newEntry.nID3V1ID = nID3V1ID;
newEntry.strGenre = strGenre;
newEntry.bCanBeModified = bCanBeModified;
newEntry.strCDDBGenre = strCDDBGenre;
newEntry.strGenre.TrimLeft();
newEntry.strGenre.TrimRight();
newEntry.strCDDBGenre.TrimLeft();
newEntry.strCDDBGenre.TrimRight();
// check if entry is already in this list
for ( i = 0 ; i < (int)v_Entries.size(); i++ )
{
if ( GetID3V1ID( i ) == nID3V1ID &&
( 0 == strGenre.CompareNoCase( GetGenre( i ) ) ) )
{
bAdd = false;
}
}
if ( true == bAdd )
{
v_Entries.push_back( newEntry );
// Sort();
}
return v_Entries.size();
}
CUString CLanguage::GetMainMenuItem( const DWORD nID, const DWORD nItem )
{
CUString strRet;
strRet = GetSubMenuItem( nID );
DWORD dwIndex = 0;
int nStart = 0;
int nStop = strRet.GetLength();
for ( dwIndex = 0; dwIndex < nItem; dwIndex++ )
{
nStart = strRet.Find( '#', nStart + 1 );
if ( -1 == nStart )
{
break;
}
}
if ( -1 != nStart )
{
nStop = strRet.Find( '#', nStart + 1 );
if ( -1 == nStop )
{
nStop = strRet.GetLength();
}
}
if ( nStop - nStart > 2 )
{
strRet = strRet.Mid( nStart + 1, nStop - nStart - 1 );
}
return strRet;
}
UINT CAutoDetect::OnStartDetection(void *lpParam)
{
bThreadActive=TRUE;
int nInsertItem=0;
int Endian=0;
CUString strTmp;
CUString strOk;
CUString strRead;
CUString strEbl;
CUString strEnd;
CUString strDens;
CUString strAtapi;
g_pThread->BeginWaitCursor();
CAutoDetect* pDlg=(CAutoDetect*)lpParam;
CDROMPARAMS cdTest;
CR_GetCDROMParameters(&cdTest);
CUString ReadMethodDescr[]={ _W("MMC "),
_W("Standard"),
_W("Nec "),
_W("Sony "),
_W("MMC1 "),
_W("MMC2 "),
_W("MMC3 "),
_W("Read C1 "),
_W("Read C2 "),
_W("Read C3 "),
_W("MMC4 "),
_W("????????")};
CUString EnableDescr[]={ g_language.GetString( IDS_NONE ),
g_language.GetString( IDS_STANDARD ),
_W( "????" )};
// Write header to Log file
dbgFile.printf( "ATAPI\tREAD\t\tENABLE\t\t%DENS\tENDIAN\tRESULT\n" );
for (int atapi = 0; atapi < NUMATAPI; atapi++ )
{
if ( 0 == atapi )
{
cdTest.DriveTable.bAtapi = FALSE;
strAtapi = g_language.GetString( IDNO );
}
else
{
cdTest.DriveTable.bAtapi = TRUE;
strAtapi = g_language.GetString( IDYES );
}
for (int rm = 0; rm < NUMREADMETHODS; rm++ )
{
strRead=ReadMethodDescr[ rm ];
for (int en=0;en<NUMENABLEMODES;en++)
{
strEbl = EnableDescr[ en ];
for (int ds=0;ds<NUMDENSITIES;ds++)
{
cdTest.DriveTable.nDensity = CheckDensities[ds];
strDens.Format( _W( "%2x" ), cdTest.DriveTable.nDensity );
CUStringConvert strCnv;
CUStringConvert strCnv1;
CUStringConvert strCnv2;
CUStringConvert strCnv3;
// Log what we are doing to file
dbgFile.printf("%s\t%s\t%s\t%s\t",
strCnv.ToACP( strAtapi ),
strCnv1.ToACP( strRead ),
strCnv2.ToACP( strEbl ),
strCnv3.ToACP( strDens ) );
cdTest.DriveTable.ReadMethod= READMETHOD( rm );
switch ( cdTest.DriveTable.ReadMethod )
{
case READMMC:
case READMMC2:
case READMMC3:
case READMMC4:
cdTest.DriveTable.SetSpeed= SPEEDMMC;
break;
case READSONY:
cdTest.DriveTable.SetSpeed= SPEEDSONY;
break;
case READ10:
case READNEC:
case READC1:
case READC2:
case READC3:
default:
cdTest.DriveTable.SetSpeed= SPEEDNONE;
break;
}
cdTest.DriveTable.EnableMode= ENABLEMODE(en);
cdTest.DriveTable.Endian = ENDIAN_LITTLE;
CDEX_ERR err = TestDrive( cdTest );
strEnd = _T( "-" );
if (err==CDEX_OK)
{
strOk = g_language.GetString( IDS_PASS );
if ( ENDIAN_LITTLE == cdTest.DriveTable.Endian )
{
strEnd = g_language.GetString( IDS_LITTLEENDIAN );
}
else
{
strEnd = g_language.GetString( IDS_BIGENDIAN );
}
}
else
{
strOk = g_language.GetString( IDS_FAIL );
}
pDlg->m_List.InsertItem( nInsertItem, strCnv.ToT( strRead ) );
pDlg->m_List.SetItemText( nInsertItem,1,strCnv.ToT( strAtapi ) );
pDlg->m_List.SetItemText( nInsertItem,2,strCnv.ToT( strEbl ) );
pDlg->m_List.SetItemText( nInsertItem,3,strCnv.ToT( strDens ) );
pDlg->m_List.SetItemText( nInsertItem,4,strCnv.ToT( strEnd ) );
pDlg->m_List.SetItemText( nInsertItem,5,strCnv.ToT( strOk ) );
myDriveTable[nCurrentDrive++]=cdTest.DriveTable;
ASSERT(nCurrentDrive<=nNumTableEntries);
// Log success
dbgFile.printf("%s\t%s\n",strEnd,strOk);
nInsertItem++;
::Sleep(0);
if (pDlg->m_bAbort)
{
pDlg-> GetDlgItem(IDC_ABORT)->EnableWindow(FALSE);
pDlg->GetDlgItem(IDOK)->EnableWindow(TRUE);
g_pThread->EndWaitCursor();
return 0;
}
}
}
}
}
pDlg-> GetDlgItem(IDC_ABORT)->EnableWindow(FALSE);
pDlg->GetDlgItem(IDOK)->EnableWindow(TRUE);
g_pThread->EndWaitCursor();
return 0;
}
CDEX_ERR CEncoderLameDll::OpenStream(CUString strOutFileName,DWORD dwSampleRate,WORD nChannels)
{
CDEX_ERR bReturn = CDEX_OK;
CUString strLang;
CUStringConvert strCnv;
ENTRY_TRACE( _T( "CEncoderLameDll::OpenStream( %s, %ld, %d" ),
strCnv.ToT( strOutFileName + _W( "." ) + GetExtension() ),
dwSampleRate,
nChannels );
DWORD dwInSampleRate = dwSampleRate;
m_strStreamFileName = strOutFileName;
// clear all config settings
memset( &m_beConfig, 0, sizeof(m_beConfig) );
// set the number of input channels
m_nInputChannels = nChannels;
// Divide sample rate by two for MPEG2
if ( ( GetVersion() >=1 ) && ( dwInSampleRate >= 32000 ) )
{
m_dResampleRatio = 2.0;
dwSampleRate = dwInSampleRate / 2;
}
// mask mode, just to be sure (due to an old hack)
m_nMode &= 0x0F;
// Do we have to downmix/upmix ?
if ( BE_MP3_MODE_MONO == m_nMode )
{
if ( 2 == nChannels )
{
m_bDownMixToMono = TRUE;
}
else
{
m_bDownMixToMono = FALSE;
}
}
else
{
if ( 1 == nChannels )
{
m_bUpMixToStereo = TRUE;
}
else
m_bUpMixToStereo=FALSE;
}
int nCRC = m_bCRC;
int nVBR = (nCRC>>12)&0x0F;
int nVbrMethod = (nCRC>>16)&0x0F;
m_beConfig.dwConfig = BE_CONFIG_LAME;
m_beConfig.format.LHV1.dwStructVersion = 1;
m_beConfig.format.LHV1.dwStructSize = sizeof(m_beConfig);
m_beConfig.format.LHV1.dwSampleRate = dwSampleRate;
m_beConfig.format.LHV1.dwReSampleRate = m_nOutSampleRate;
m_beConfig.format.LHV1.nMode = m_nMode;
m_beConfig.format.LHV1.dwBitrate = m_nBitrate;
m_beConfig.format.LHV1.dwMaxBitrate = m_nMaxBitrate;
m_beConfig.format.LHV1.dwMpegVersion = (dwSampleRate>=32000)?MPEG1:MPEG2;
m_beConfig.format.LHV1.dwPsyModel = 0;
m_beConfig.format.LHV1.dwEmphasis = 0;
m_beConfig.format.LHV1.bCRC = nCRC&0x01;;
m_beConfig.format.LHV1.bCopyright = m_bCopyRight;
m_beConfig.format.LHV1.bPrivate = m_bPrivate;
m_beConfig.format.LHV1.bOriginal = m_bOriginal;
// allways write the VBR header, even for CBR file
m_beConfig.format.LHV1.bWriteVBRHeader = TRUE;
if ( nVbrMethod > 0 )
{
m_beConfig.format.LHV1.bEnableVBR = TRUE;
m_beConfig.format.LHV1.nVbrMethod = (VBRMETHOD)(nVbrMethod-1) ;
// is this the ABR method ?
if ( ( VBR_METHOD_ABR + 1 ) == nVbrMethod )
{
// get the average bit rate
m_beConfig.format.LHV1.dwVbrAbr_bps= LOWORD( GetUserN1() )*1000;
m_beConfig.format.LHV1.nVBRQuality = 0 ;
}
else
{
// no ABR selected
m_beConfig.format.LHV1.dwVbrAbr_bps = 0;
m_beConfig.format.LHV1.nVBRQuality = nVBR ;
}
}
// Get Quality from third nibble
m_beConfig.format.LHV1.nPreset=( (nCRC >> 8 ) & 0x0F );
m_fpOut= CID3Tag::SaveInitialV2Tag( strOutFileName + _W( "." ) + GetExtension(), GetId3V2PadSize() );
//m_fpOut = CDexOpenFile( strOutFileName + _W( "." ) + GetExtension(), _W( "wb+" ) );
if ( NULL == m_fpOut )
{
CUString strErr;
strLang = g_language.GetString( IDS_ENCODER_ERROR_COULDNOTOPENFILE );
strErr.Format( strLang, (LPCWSTR)CUString( strOutFileName + _W( "." ) + GetExtension() ) );
CDexMessageBox( strErr );
bReturn = CDEX_FILEOPEN_ERROR;
}
if ( CDEX_OK == bReturn )
{
int nReturn = m_InitStream( &m_beConfig,
&m_dwInBufferSize,
&m_dwOutBufferSize,
&m_hbeStream );
switch ( nReturn )
{
case CDEX_OK:
// do nothing
break;
case -1:
strLang = g_language.GetString( IDS_ENCODER_ERROR_SAMPLERATEBITRATEMISMATCH );
CDexMessageBox( strLang );
bReturn = CDEX_ERROR;
break;
case -2:
strLang = g_language.GetString( IDS_ENCODER_ERROR_INVALIDINPUTSTREAM );
CDexMessageBox( strLang );
bReturn = CDEX_ERROR;
break;
default:
strLang = g_language.GetString( IDS_ENCODER_ERROR_INVALIDINPUTSTREAM );
CDexMessageBox( strLang );
bReturn = CDEX_ERROR;
break;
}
}
if ( CDEX_OK == bReturn )
{
if ( ( GetVersion() >= 1 ) && ( dwInSampleRate >= 32000 ) )
{
// Add multiplcation factor for resampling
m_dwInBufferSize *= 2;
}
if ( m_bDownMixToMono )
{
m_dwInBufferSize *= 2;
}
// Allocate Output Buffer size
m_pbOutputStream = new BYTE[ m_dwOutBufferSize ];
// Only expect halve the number of samples
// in case we have to upsample
if ( m_bUpMixToStereo )
{
// Allocate upsample Buffer size
m_psInputStream = new SHORT[ m_dwInBufferSize ];
m_dwInBufferSize /= 2;
}
}
if ( CDEX_OK == bReturn )
{
// Initialize the input stream
bReturn = InitInputStream();
}
EXIT_TRACE( _T( "CEncoderLameDll::OpenStream, return value %d" ), bReturn );
return bReturn;
}
CUString CTimeTrack::GetRemainingString()
{
CUString strTmp;
strTmp.Format( _W( "%02d:%02d" ), m_dwRemaining / 60, m_dwRemaining % 60 );
return strTmp;
}
CUString CTimeTrack::GetEstimateString()
{
CUString strTmp;
strTmp.Format( _W( "%02d:%02d" ), m_dwEstimated / 60, m_dwEstimated % 60 );
return strTmp;
}
CUString CTimeTrack::GetSpeedString()
{
CUString strTmp;
strTmp.Format( _W( "%4.1f" ), m_fSpeed);
return strTmp;
}
CDEX_ERR CEncoderFaacDll::OpenStream(CUString strOutFileName,DWORD dwSampleRate,WORD nChannels)
{
CDEX_ERR bReturn = CDEX_OK;
bool bStereo = true;
CUString strLang;
CUStringConvert strCnv;
ENTRY_TRACE( _T( "CEncoderFaacDll::OpenStream( %s, %d %d" ),
strCnv.ToT( strOutFileName + _W( "." ) + GetExtension() ),
dwSampleRate,
nChannels );
// setup number of input channels
m_nInputChannels = nChannels;
// setup number of output channels
if ( ( m_nMode & 0xFFFF ) == BE_MP3_MODE_MONO )
{
bStereo = false;
}
// mixer setup
if ( ( false == bStereo ) && ( 2 == nChannels ) )
{
m_bDownMixToMono = TRUE;
}
else
{
m_bDownMixToMono = FALSE;
}
if ( ( true == bStereo ) && ( 1 == nChannels ) )
{
m_bUpMixToStereo = TRUE;
}
else
{
m_bUpMixToStereo = FALSE;
}
// try to get a handle
m_handle = faacEncOpen( dwSampleRate,
(bStereo == true )? 2 : 1,
&m_dwInBufferSize,
&m_dwOutBufferSize );
if ( NULL == m_handle )
{
CUString strMsg;
strLang = g_language.GetString( IDS_LOADLIBRARY_FAILED );
strMsg.Format( strLang , (LPCWSTR)CUString( ( g_config.GetAppPath() + _W( "\\" ) + m_strEncoderPath ) ) );
CDexMessageBox( strMsg );
LTRACE( _T( "CEncoderFaacDll::OpenStream Failed to get handle" ) );
bReturn = CDEX_ERROR;
}
if ( CDEX_OK == bReturn )
{
// get current config
m_pConfig = faacEncGetCurrentConfiguration( m_handle );
// set settings
if ( GetUserN1() & 0x08 )
{
m_pConfig->mpegVersion = FAAC_MPEG4;
}
else
{
m_pConfig->mpegVersion = FAAC_MPEG2;
}
m_pConfig->bitRate = m_nBitrate * 1000;
m_pConfig->allowMidside = ( GetUserN1() & 0x02 ) ? TRUE : FALSE;
m_pConfig->useLfe = ( GetUserN1() & 0x04 ) ? TRUE : FALSE;; /* ? */
m_pConfig->useTns = ( GetUserN1() & 0x01 ) ? TRUE : FALSE;
m_pConfig->inputFormat = FAAC_INPUT_16BIT;
m_pConfig->aacObjectType = ( GetUserN2() & 0x07 );
m_pConfig->shortctl = SHORTCTL_NORMAL;
switch ( ( GetUserN1() >> 8 ) & 0x0F )
{
case 0: m_pConfig->bandWidth = 16000; break;
case 1: m_pConfig->bandWidth = 18000; break;
case 2: m_pConfig->bandWidth = 19500; break;
default: m_pConfig->bandWidth = 19500; break;
}
// set new config
if ( FALSE == faacEncSetConfiguration( m_handle, m_pConfig ) )
{
CUString strMsg;
strLang = g_language.GetString( IDS_LOADLIBRARY_FAILED );
strMsg.Format( strLang , (LPCWSTR)CUString( g_config.GetAppPath() + _W( "\\" ) + m_strEncoderPath ) );
CDexMessageBox( strMsg );
LTRACE( _T( "CEncoderFaacDll::OpenStream Failed to set config" ) );
bReturn = CDEX_ERROR;
}
}
void CLanguage::ParseLanguageFile( const CUString& strFileName )
{
BOOL bResult = TRUE;
DWORD dwRevision = 0;
FILE* pFile = NULL;
CUString strFullFileName = m_strLanguageDir + _W("\\lang\\") + strFileName + m_strLangFileExt;
CUStringConvert strCnv;
pFile = CDexOpenFile( strFullFileName, _W( "r" ) );
if ( NULL != pFile )
{
CHAR lpszRead[ 1024 ];
int nStart = 0;
int nStop = 0;
CUString strRead;
memset( lpszRead, 0, sizeof( lpszRead ) );
while ( fgets( lpszRead, sizeof( lpszRead ), pFile ) )
{
bool bHasNumber = false;
bool bIsMenu = false;
bool bIsDialog = false;
bool bHasString = false;
DWORD nIndex = 0;
CLangElement newElement;
strRead = _T( "" );
for ( nIndex = 0; nIndex< strlen( lpszRead ); nIndex++ )
{
if ( ( lpszRead[ nIndex ] != 0x0A ) &&
( lpszRead[ nIndex ] != 0x0D ) )
{
strRead += (TCHAR)lpszRead[ nIndex ];
}
}
TranslateTab( strRead );
nStart = strRead.Find( _T( '#' ) );
if ( nStart >= 0 )
{
if ( ( nStart + 1 ) == strRead.Find( _T( 'M' ) ) )
{
nStart++;
bIsMenu = TRUE;
}
else if ( ( nStart + 1 ) == strRead.Find( _T( 'D' ) ) )
{
nStart++;
bIsDialog = TRUE;
}
nStop = strRead.Find( _T( '#' ), nStart + 1 );
if ( nStop > 2 )
{
CUString strID ( strRead.Mid( nStart + 1, nStop - nStart -1 ) );
swscanf( strID, _W( "%x" ), &newElement.nID );
bHasNumber = true;
}
}
else
{
if ( strRead.Find( CODEPAGETAG ) == 0 )
{
m_dwCodePageID = _wtoi( strRead.Mid( CODEPAGETAG.GetLength() ) );
}
else if ( strRead.Find( LANGTAG ) == 0 )
{
m_dwLangID = _wtoi( strRead.Mid( LANGTAG.GetLength() ) );
}
else if ( strRead.Find( SUBLANGTAG ) == 0 )
{
m_dwSubLangID = _wtoi( strRead.Mid( SUBLANGTAG.GetLength() ) );
}
else if ( strRead.Find( REVISIONTAG ) == 0 )
{
int nPos;
nPos = strRead.Find( _W( ",v " ) );
if ( nPos >= 0 )
{
float fVersion = 1.0f;
swscanf( strRead.Mid( nPos+3,4 ), _W( "%f" ), &fVersion );
dwRevision = (DWORD)( 100 * ( fVersion + 0.005 ) );
}
}
}
nStart = strRead.Find( '"' );
if ( nStart >= 0 )
{
nStop = strRead.Find( '"', nStart + 1 );
if ( nStop > 2 )
{
lpszRead[ 0 ] = '\0';
for ( nIndex = nStart + 1; nIndex < (DWORD)nStop; nIndex++)
{
lpszRead[ nIndex - nStart - 1] = (CHAR)strRead.GetAt( nIndex );
lpszRead[ nIndex - nStart ] = '\0';
}
newElement.strValue = CUString( lpszRead, m_dwCodePageID );
bHasString = true;
}
}
if ( bHasString && bHasNumber )
{
if ( bIsMenu )
{
m_vMenus.push_back( newElement );
}
else if ( bIsDialog )
{
m_vDialogs.push_back( newElement );
}
else
{
m_vStrings.push_back( newElement );
}
}
memset( lpszRead, 0, sizeof( lpszRead ) );
}
fclose( pFile );
}
#ifdef UNICODE
TCHAR* pTest = _wsetlocale( LC_ALL, GetString( 99 ) );
#else
TCHAR* pTest = setlocale( LC_ALL, strCnv.ToT( GetString( 99 ) ) );
#endif
SetThreadLocale( MAKELCID( m_dwLangID, m_dwSubLangID ) );
setlocale( LC_NUMERIC, "English" );
}
void CMainFrame::OnLanguageSelection( UINT nID )
{
CDocTemplate* pTemplate = NULL;
POSITION pos;
CDocument* pDocument = NULL;
int nLanguageSelection = nID - ID_LANGUAGE_START;
if ( 0 == nLanguageSelection )
{
WORD nLanguage;
CHyperLink myLink;
CUString strVersions;
// FIXME
strVersions.Format( _W("cdexversion=1.70&beta=8&cdexdir=%s" ), (LPCWSTR)g_config.GetAppPath() );
for ( nLanguage=0; nLanguage < g_language.GetNumLanguageStrings(); nLanguage++)
{
CUString strLangName( g_language.GetLanguageString( nLanguage ) );
CUString strLangVersion;
strLangVersion.Format( _W("%s=%s"), (LPCWSTR)strLangName, (LPCWSTR)g_language.GetRevisionLevel( strLangName ) );
strVersions += _W( "&" ) + strLangVersion;
}
// myLink.GotoURL( _T("www.cdex.n3.net/lang/langcheck.php?") + strVersions , SW_SHOW );
myLink.GotoURL( _T("cdexos.sourceforge.net/lang/cdex_v1.70"), SW_SHOW );
}
else
{
// nLanguageSelection--;
// Switch to selected language
CString strMenu;
m_pPopupMenu->GetMenuString( nLanguageSelection, strMenu, MF_BYPOSITION );
g_language.SetLanguage( CUString( strMenu ) );
// get document template
pos = AfxGetApp()->GetFirstDocTemplatePosition();
pTemplate = AfxGetApp()->GetNextDocTemplate( pos );
POSITION docpos = pTemplate->GetFirstDocPosition( );
// Loop through documents in this template
while ( docpos )
{
VERIFY( pDocument = pTemplate->GetNextDoc(docpos) );
// update all view attached to this document
pDocument->UpdateAllViews( NULL,WM_CDEX_INITIAL_UPDATE, NULL );
}
g_config.SetLanguage( g_language.GetLanguage() );
g_config.Save();
SetLanguageMenu( );
}
}
CUString EncodeUTF8( CUString &str )
{
CUString ret = "";
if( str.GetLength() == 6 ) {
ret = str.SubStr( 2,6 );
unsigned long index;
index = strtoul( ret.GetStr(), 0, 16 );
if( 0x00 <= index && index <= 0x7F ) {
char buf[4]; sprintf( buf, "%c", (char)index );
ret = buf;
}
else if( 0x80 <= index && index <= 0x07FF ) {
// 2byte;
int enc_ch1 = 0xC0; // 11000000
int enc_ch2 = 0x80; // 10000000
char ch1 = (char)strtoul( ret.SubStr(0,2).GetStr(), 0, 16 );
char ch2 = (char)strtoul( ret.SubStr(2,4).GetStr(), 0, 16 );
if( ch1 & (1 << (3-1) ) ) { enc_ch1 |= (1 << (5-1) ); }
if( ch1 & (1 << (2-1) ) ) { enc_ch1 |= (1 << (4-1) ); }
if( ch1 & (1 << (1-1) ) ) { enc_ch1 |= (1 << (3-1) ); }
if( ch2 & (1 << (8-1) ) ) { enc_ch1 |= (1 << (2-1) ); }
if( ch2 & (1 << (7-1) ) ) { enc_ch1 |= (1 << (1-1) ); }
if( ch2 & (1 << (6-1) ) ) { enc_ch2 |= (1 << (6-1) ); }
if( ch2 & (1 << (5-1) ) ) { enc_ch2 |= (1 << (5-1) ); }
if( ch2 & (1 << (4-1) ) ) { enc_ch2 |= (1 << (4-1) ); }
if( ch2 & (1 << (3-1) ) ) { enc_ch2 |= (1 << (3-1) ); }
if( ch2 & (1 << (2-1) ) ) { enc_ch2 |= (1 << (2-1) ); }
if( ch2 & (1 << (1-1) ) ) { enc_ch2 |= (1 << (1-1) ); }
//dumptoBin( enc_ch1 ); dumptoBin( enc_ch2 );
char buf[4]; sprintf( buf, "%c%c", enc_ch1, enc_ch2 );
ret = buf;
}
else if( 0x0800 <= index && index <= 0xFFFF ) {
// 3byte;
char enc_ch1 = 0xE0; // 11100000
char enc_ch2 = 0x80; // 10000000
char enc_ch3 = 0x80; // 10000000
char ch1 = (char)strtoul( ret.SubStr(0,2).GetStr(), 0, 16 );
char ch2 = (char)strtoul( ret.SubStr(2,4).GetStr(), 0, 16 );
if( ch1 & (1 << (8-1) ) ) { enc_ch1 |= (1 << (4-1) ); }
if( ch1 & (1 << (7-1) ) ) { enc_ch1 |= (1 << (3-1) ); }
if( ch1 & (1 << (6-1) ) ) { enc_ch1 |= (1 << (2-1) ); }
if( ch1 & (1 << (5-1) ) ) { enc_ch1 |= (1 << (1-1) ); }
if( ch1 & (1 << (4-1) ) ) { enc_ch2 |= (1 << (6-1) ); }
if( ch1 & (1 << (3-1) ) ) { enc_ch2 |= (1 << (5-1) ); }
if( ch1 & (1 << (2-1) ) ) { enc_ch2 |= (1 << (4-1) ); }
if( ch1 & (1 << (1-1) ) ) { enc_ch2 |= (1 << (3-1) ); }
if( ch2 & (1 << (8-1) ) ) { enc_ch2 |= (1 << (2-1) ); }
if( ch2 & (1 << (7-1) ) ) { enc_ch2 |= (1 << (1-1) ); }
if( ch2 & (1 << (6-1) ) ) { enc_ch3 |= (1 << (6-1) ); }
if( ch2 & (1 << (5-1) ) ) { enc_ch3 |= (1 << (5-1) ); }
if( ch2 & (1 << (4-1) ) ) { enc_ch3 |= (1 << (4-1) ); }
if( ch2 & (1 << (3-1) ) ) { enc_ch3 |= (1 << (3-1) ); }
if( ch2 & (1 << (2-1) ) ) { enc_ch3 |= (1 << (2-1) ); }
if( ch2 & (1 << (1-1) ) ) { enc_ch3 |= (1 << (1-1) ); }
//dumptoBin( enc_ch1 ); dumptoBin( enc_ch2 ); dumptoBin( enc_ch3 );
char buf[4]; sprintf( buf, "%c%c%c", enc_ch1, enc_ch2, enc_ch3 );
ret = buf;
}
}
return ret;
}
void COpenFileDlg::AddRecursiveFiles( const CUString& strDir,int nItem )
{
CFileFind fileFind;
CUString pathAndFileType = strDir + CUString( _W( "\\*.*" ));
BOOL bStop=FALSE;
CUStringConvert strCnv;
// Iterate through the items in the listbox and populate the listconrol.
if (fileFind.FindFile( strCnv.ToT( pathAndFileType ) ) )
{
do
{
bStop=(fileFind.FindNextFile()==0);
CUString strFileName = CUString( fileFind.GetFileName() );
CUString strFileRoot = CUString( fileFind.GetRoot() );
CUString strFileType;
if ( TRUE == fileFind.IsDirectory() &&
FALSE == fileFind.IsDots() &&
TRUE == m_bRecursiveDir )
{
AddRecursiveFiles( strDir + CUString( _W( "\\" ) ) + strFileName, nItem );
}
if (fileFind.IsDirectory()==FALSE && fileFind.IsDots()==FALSE)
{
int nPos=strFileName.ReverseFind( _T( '.' ) );
if (nPos>0)
{
CUString strExt;
strExt = strFileName.Right(strFileName.GetLength()-nPos-1);
strFileType = strExt;
strExt.MakeUpper();
if ( CompareExt( strExt ) == TRUE )
{
CUString strFileSize;
CUString strFileDate;
CTime fileTime;
// Get the data/time stamp of this file
fileFind.GetLastWriteTime( fileTime );
// Format date time string
strFileDate.Format( _W( "%4d/%02d/%02d %02d:%02d" ), fileTime.GetYear(), fileTime.GetMonth(), fileTime.GetDay(), fileTime.GetHour(), fileTime.GetMinute() );
strFileSize.Format( _W( "%10.2f" ), fileFind.GetLength() / ( 1024.0 * 1024.0 ) );
CUStringConvert strCnv;
m_ctrlRequestedFiles.InsertItem( nItem, strCnv.ToT( strFileName ));
m_ctrlRequestedFiles.SetItemText( nItem, FILE_OPEN_TYPE, strCnv.ToT( strFileType ) );
m_ctrlRequestedFiles.SetItemText( nItem, FILE_OPEN_DATE ,strCnv.ToT( strFileDate ) );
m_ctrlRequestedFiles.SetItemText( nItem, FILE_OPEN_PATH, strCnv.ToT( strFileRoot ) );
m_ctrlRequestedFiles.SetItemText( nItem, FILE_OPEN_SIZE, strCnv.ToT( strFileSize ) );
m_ctrlRequestedFiles.SetItemData( nItem, (DWORD)fileTime.GetTime() );
nItem++;
}
}
}
} while (bStop!=TRUE);
}
m_bSortAscending=TRUE;
}
void CSVGGradientEditCtl::OnButtonDown(UINT nFlags, POINT point, int iButton, BOOL bDblClk)
{
if (point.x > m_previewRect.left-8 && point.y < m_previewRect.right+8 &&
point.y > m_previewRect.top && point.y < m_previewRect.bottom)
{
if (m_canEditStops)
{
POINT pt = point;
pt.x -= m_previewRect.left;
CComQIPtr<ILSVGStopElement> onStop;// = NULL;
CComQIPtr<ILSVGStopElement> stop;
m_gradient->get_firstChild((ILDOMNode**)&stop);
CComQIPtr<ILDOMNode> beforeNode = stop;
while (stop != NULL)
{
double offset;
CComQIPtr<ILSVGAnimatedNumber> aoffset;
stop->get_offset(&aoffset);
aoffset->get_baseVal(&offset);
int x = (int)(offset*m_previewRect.Width());
if (abs(pt.x-x) < 8)
{
onStop = stop;
}
CComQIPtr<ILDOMNode> nextSibling;
stop->get_nextSibling(&nextSibling);
stop = nextSibling;
if (pt.x > x)
{
beforeNode = stop;
}
}
if (iButton == 0)
{
if (onStop) // Already used
{
#if 0 // Have this
CElement* pElement = m_pElement->m_pDocument->m_pTree->FindDOMElement((IDOMNode*)onStop);
m_pElement->m_pDocument->SetTargetElement(pElement, 0);
#endif
m_activeStop = onStop; // hm instead of above (change this)
}
else
{
if (beforeNode == NULL)
{
m_gradient->get_firstChild(&beforeNode);
}
CUString str;
float offset = (float)pt.x / m_previewRect.Width();
CComQIPtr<ILDOMDocument> document;
m_pElement->get_ownerDocument(&document);
CComQIPtr<ILSVGStopElement> stop;
document->createElementNS(L"http://www.w3.org/2000/svg", L"stop", (ILDOMElement**)&stop);
CComQIPtr<ILSVGAnimatedNumber> aoffset;
stop->get_offset(&aoffset);
aoffset->put_baseVal(offset);
CComQIPtr<ILSVGStylable> stylable = stop;
CComQIPtr<ILCSSStyleDeclaration> style;
stylable->get_style(&style);
str.Format("#%2.2X%2.2X%2.2X", m_colorSpread[pt.x].red, m_colorSpread[pt.x].green, m_colorSpread[pt.x].blue);
style->setProperty(L"stop-color", _bstr_t(str), L"");
str.Format("%g", m_colorSpread[pt.x].alpha/255.0);
style->setProperty(L"stop-opacity", _bstr_t(str), L"");
m_gradient->insertBefore(stop, _variant_t(beforeNode), NULL);
#if 0 // Have this
CElement* pElement = m_pElement->m_pDocument->m_pTree->FindDOMElement((IDOMNode*)stop);
m_pElement->m_pDocument->SetTargetElement(pElement, 0);
#endif
m_activeStop = stop; // hm instead of above (change this)
}
if (m_activeStop != NULL)
{
SetCapture();
m_dragging = TRUE;
// OnMouseMove(nFlags, point);
}
}
else
{
#if 0
if (onStop)
{
m_pElement->m_pDocument->ActivateElement((CElement*)m_pElement->m_parent, 0);
onStop->parentNode->removeChild(onStop);
}
#endif
}
}
}
}
BOOL CLanguage::TranslateMenu( CMenu* pMenu, const int nMenuID, BOOL bTopLevel )
{
CMenu* pChildMenu = NULL;
static CUString strMissing;
BOOL bReturn = TRUE;
static int nPopUpIdx = 0;
if ( bTopLevel )
{
nPopUpIdx = MAKELPARAM( 0, nMenuID );
strMissing = _T( "" );
}
DWORD i = pMenu->GetMenuItemCount();
for( i = 0; i < pMenu->GetMenuItemCount(); i++ )
{
pChildMenu = pMenu->GetSubMenu( i );
int nItemID = pMenu->GetMenuItemID( i );
if ( MENU_SEPARARTOR != nItemID )
{
CUString strLang;
if ( bTopLevel )
{
strLang = GetMainMenuItem( nMenuID, i );
}
else
{
if ( MENU_POPUP != nItemID )
{
strLang = GetSubMenuItem( nItemID );
}
else
{
strLang = GetSubMenuItem( nPopUpIdx );
nPopUpIdx++;
}
}
if ( MENU_POPUP != nItemID )
{
CUStringConvert strCnv;
if ( !strLang.IsEmpty() )
{
pMenu->ModifyMenu( nItemID, MF_STRING, nItemID, strCnv.ToT( strLang ) );
}
else
{
CString strTmp;
pMenu->GetMenuString( nItemID, strTmp, MF_BYCOMMAND );
ReportMissingID( nItemID, CUString( strTmp ), 1 );
}
}
else
{
int nPosition = UINT( pChildMenu->m_hMenu );
if ( !strLang.IsEmpty() )
{
int nPosition = UINT( pChildMenu->m_hMenu );
CUStringConvert strCnv;
pMenu->ModifyMenu( UINT( pChildMenu->m_hMenu ),
MF_STRING | MF_POPUP,
UINT( pChildMenu->m_hMenu ),
strCnv.ToT( strLang ) );
}
else
{
if ( bTopLevel )
{
CString strTmp;
pMenu->GetMenuString( i, strTmp, MF_BYPOSITION );
strMissing += _W( "#" ) + CUString( strTmp );
}
else
{
CString strTmp;
pMenu->GetMenuString( 0, strTmp, MF_BYPOSITION );
ReportMissingID( nItemID, CUString( strTmp ), 1 );
}
}
TranslateMenu( pMenu->GetSubMenu(i), -1, FALSE );
}
}
}
if ( bTopLevel )
{
if ( !strMissing.IsEmpty() )
{
ReportMissingID( nMenuID, strMissing + _W( "#" ), 1 );
}
}
return bReturn;
}
BOOL CLanguage::InitDialogStrings( CDialog* pDialog, long lSection )
{
short nCtrlID;
CUString sText;
CWnd* pWndCtrl;
DWORD nIndex = 0;
CUStringConvert strCnv;
CUString strLang = GetDialogString( MAKELPARAM( 0, lSection ) );
if( !strLang.IsEmpty() )
{
pDialog->SetWindowText( strCnv.ToT( strLang ) );
}
else
{
CString strMissing;
pDialog->GetWindowText( strMissing );
ReportMissingID( MAKELPARAM( 0, lSection ), CUString( strMissing ), 2 );
}
// test if the dialog has child windows
if( pWndCtrl = pDialog->GetWindow( GW_CHILD | GW_HWNDFIRST ) )
{
// lool through all controls (windows) and replace text
do
{
nCtrlID = pWndCtrl->GetDlgCtrlID();
if ( !pWndCtrl->IsKindOf( RUNTIME_CLASS( CEdit ) ) &&
!pWndCtrl->IsKindOf( RUNTIME_CLASS( CListCtrl ) ) &&
!pWndCtrl->IsKindOf( RUNTIME_CLASS( CSpinButtonCtrl) )
)
{
if( nCtrlID > 0 )
{
// check if the Id is in the range of common strings
if( (nCtrlID >= COMMON_IDMIN) && (nCtrlID <= COMMON_IDMAX) )
{
strLang = GetString( nCtrlID );
}
else
{
strLang = GetDialogString( MAKELPARAM( nCtrlID, lSection ) );
}
if( !strLang.IsEmpty() )
{
if ( pWndCtrl->IsKindOf( RUNTIME_CLASS( CComboBox ) ) )
{
CUString strAdd;
int nPos = -1;
// remove old strings
((CComboBox*)pWndCtrl)->ResetContent();
while ( ( nPos = strLang.Find( '\n' ) ) >= 0 )
{
((CComboBox*)pWndCtrl)->AddString( strCnv.ToT( strLang.Left( nPos ) ) );
strLang = strLang.Mid( nPos + 1 );
nPos++;
}
if ( strLang.GetLength() > nPos )
{
((CComboBox*)pWndCtrl)->AddString( strCnv.ToT( strLang.Mid( nPos ) ) );
}
}
else
{
pDialog->SetDlgItemText( nCtrlID, strCnv.ToT( strLang ) );
}
}
else
{
CString strMissing;
if ( pWndCtrl->IsKindOf( RUNTIME_CLASS( CComboBox ) ) )
{
int nIndex = 0;
int nItems = ((CComboBox*)pWndCtrl)->GetCount();
for ( nIndex =0; nIndex < nItems; nIndex++ )
{
CString strTmp;
((CComboBox*)pWndCtrl)->GetLBText( nIndex, strTmp );
strMissing += strTmp;
if ( nIndex < nItems - 1 )
{
strMissing += _T( "\n" );
}
}
}
else
{
pDialog->GetDlgItemText( nCtrlID, strMissing );
}
if ( !strMissing.IsEmpty() )
{
ReportMissingID( MAKELPARAM( nCtrlID, lSection ), CUString( strMissing ), 2 );
}
}
}
}
pWndCtrl = pWndCtrl->GetWindow( GW_HWNDNEXT );
} while( (pWndCtrl != NULL) && (pWndCtrl != pDialog->GetWindow( GW_CHILD | GW_HWNDFIRST )) );
}
return TRUE;
}
