// -------------------------------------------------------------------------------- //
guGIO_VolumeMonitor::~guGIO_VolumeMonitor( void )
{
guLogMessage( wxT( "Destroying the volume monitor object..." ) );
if( m_VolumeMonitor )
{
g_signal_handler_disconnect( m_VolumeMonitor, m_VolumeAddedId );
g_signal_handler_disconnect( m_VolumeMonitor, m_VolumeRemovedId );
g_signal_handler_disconnect( m_VolumeMonitor, m_MountRemovedId );
g_signal_handler_disconnect( m_VolumeMonitor, m_MountPreUnmountId );
g_signal_handler_disconnect( m_VolumeMonitor, m_MountAddedId );
while( m_MountedVolumes->Count() )
{
delete ( * m_MountedVolumes )[ 0 ];
m_MountedVolumes->RemoveAt( 0 );
}
if( m_MountedVolumes )
{
delete m_MountedVolumes;
}
guLogMessage( wxT( ">> ~guGIO_VolumeMonitor()" ) );
g_object_unref( m_VolumeMonitor );
guLogMessage( wxT( "<< ~guGIO_VolumeMonitor()" ) );
}
}
// -------------------------------------------------------------------------------- //
guGIO_Mount::guGIO_Mount( GMount * mount, wxString &mountpath )
{
m_Mount = mount;
g_object_ref( mount );
// m_PanelActive = wxNOT_FOUND;
m_MountPath = mountpath;
if( !m_MountPath.EndsWith( wxT( "/" ) ) )
m_MountPath.Append( wxT( "/" ) );
char * mount_name = g_mount_get_name( m_Mount );
if( mount_name )
{
m_Name = wxString( mount_name, wxConvUTF8 );
g_free( mount_name );
}
guLogMessage( wxT( "Mount Path: %s" ), m_MountPath.c_str() );
GIcon * Icon = g_mount_get_icon( mount );
if( Icon )
{
char * IconStr = g_icon_to_string( Icon );
if( IconStr )
{
m_IconString = wxString( IconStr, wxConvUTF8 );
guLogMessage( wxT( "IconStr: '%s'" ), m_IconString.c_str() );
g_free( IconStr );
}
g_object_unref( Icon );
}
wxFileConfig * Config = new wxFileConfig( wxEmptyString, wxEmptyString, m_MountPath + wxT( ".is_audio_player" ) );
m_Id = Config->Read( wxT( "audio_player_id" ), wxString::Format( wxT( "%08lX" ), wxGetLocalTime() ) );
}
// -------------------------------------------------------------------------------- //
void guGIO_VolumeMonitor::OnMountAdded( GMount * mount )
{
guLogMessage( wxT( "Mount Added..." ) );
if( FindMount( mount ) == wxNOT_FOUND )
{
if( g_mount_is_shadowed( mount ) )
{
//g_object_unref( mount );
guLogMessage( wxT( "ignored shadowed mount" ) );
return;
}
GVolume * Volume = g_mount_get_volume( mount );
if( !Volume )
{
guLogMessage( wxT( "mount without volume?" ) );
//g_object_unref( mount );
return;
}
g_object_unref( Volume );
GFile * MountRoot = g_mount_get_root( mount );
if( MountRoot )
{
char * mount_path = g_file_get_path( MountRoot );
if( mount_path )
{
wxString MountPath = wxString( mount_path, wxConvUTF8 );
guGIO_Mount * Mount = new guGIO_Mount( mount, MountPath );
if( Mount )
{
m_MountedVolumes->Add( Mount );
wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_VOLUMEMANAGER_MOUNT_CHANGED );
event.SetInt( 1 );
wxPostEvent( m_MainFrame, event );
}
g_free( mount_path );
}
g_object_unref( MountRoot );
}
else
{
guLogMessage( wxT( "ignored mount without mount root" ) );
g_object_unref( mount );
return;
}
}
else
{
guLogMessage( wxT( "Mount already added?" ) );
}
}
// -------------------------------------------------------------------------------- //
void ExecuteOnlineLink( const int linkid, const wxString &text )
{
int index = linkid - ID_LINKS_BASE;
//guLogMessage( wxT( "ExecuteOnlineLink( %i, '%s' )" ), index, text.c_str() );
guConfig * Config = ( guConfig * ) guConfig::Get();
wxArrayString Links = Config->ReadAStr( wxT( "Link" ), wxEmptyString, wxT( "searchlinks/links" ) );
if( index >= 0 && ( index < ( int ) Links.Count() ) )
{
wxString SearchLink = Links[ index ];
wxString Lang = Config->ReadStr( wxT( "Language" ), wxT( "en" ), wxT( "lastfm" ) );
if( Lang.IsEmpty() )
{
Lang = ( ( guMainApp * ) wxTheApp )->GetLocale()->GetCanonicalName().Mid( 0, 2 );
//guLogMessage( wxT( "Locale: %s" ), ( ( guMainApp * ) wxTheApp )->GetLocale()->GetCanonicalName().c_str() );
}
SearchLink.Replace( wxT( "{lang}" ), Lang );
SearchLink.Replace( wxT( "{text}" ), guURLEncode( text ) );
guWebExecute( SearchLink );
}
else
{
guLogMessage( wxT( "Online Link out of rante %i" ), index );
}
}
// -------------------------------------------------------------------------------- //
void guJamendoPanel::OnDownloadAlbum( wxCommandEvent &event )
{
guLogMessage( wxT( "OnDownloadAlbum" ) );
wxArrayInt Albums = m_AlbumListCtrl->GetSelectedItems();
( ( guMediaViewerJamendo * ) m_MediaViewer )->DownloadAlbums( Albums, ( event.GetId() == ID_JAMENDO_DOWNLOAD_TORRENT_ALBUM ) );
}
// -------------------------------------------------------------------------------- //
bool guRemoveDir( const wxString &path )
{
wxString CurPath = path;
if( !CurPath.EndsWith( wxT( "/" ) ) )
CurPath += wxT( "/" );
wxDir Dir;
wxString FileName;
Dir.Open( CurPath );
if( Dir.IsOpened() )
{
if( Dir.GetFirst( &FileName, wxEmptyString, wxDIR_FILES | wxDIR_DIRS ) )
{
do {
if( FileName == wxT( "." ) )
continue;
if( FileName == wxT( ".." ) )
continue;
if( Dir.Exists( CurPath + FileName ) )
{
if( !guRemoveDir( CurPath + FileName ) )
{
guLogMessage( wxT( "Could not remove dir '%s'" ), wxString( CurPath + FileName ).c_str() );
return false;
}
}
else
{
if( !wxRemoveFile( CurPath + FileName ) )
{
guLogMessage( wxT( "Could not remove file '%s'" ), wxString( CurPath + FileName ).c_str() );
return false;
}
}
} while( Dir.GetNext( &FileName ) );
}
return wxRmdir( CurPath );
}
return false;
}
// -------------------------------------------------------------------------------- //
void guMediaRecordCtrl::SetStation( const wxString &station )
{
guLogMessage( wxT( "guMediaRecordCtrl::SetStation" ) );
if( m_TrackInfo.m_AlbumName != station )
{
m_TrackInfo.m_AlbumName = station;
SplitTrack();
}
}
// -------------------------------------------------------------------------------- //
void guMediaRecordCtrl::SplitTrack( void )
{
guLogMessage( wxT( "guMediaRecordCtrl::SplitTrack" ) );
m_FileName = GenerateRecordFileName();
m_MediaCtrl->SetRecordFileName( m_FileName );
SaveTagInfo( m_PrevFileName, &m_PrevTrack );
m_PrevFileName = m_FileName;
m_PrevTrack = m_TrackInfo;
}
// -------------------------------------------------------------------------------- //
void guAuiManagerPanel::OnPaneClose( wxAuiManagerEvent &event )
{
wxAuiPaneInfo * PaneInfo = event.GetPane();
int PanelIndex = m_PanelNames.Index( PaneInfo->name );
if( PanelIndex != wxNOT_FOUND )
{
guLogMessage( wxT( "OnPaneClose: %s %i" ), m_PanelNames[ PanelIndex ].c_str(), m_PanelCmdIds[ PanelIndex ] );
ShowPanel( m_PanelIds[ PanelIndex ], false );
}
event.Veto();
}
// -------------------------------------------------------------------------------- //
wxArrayString guGIO_VolumeMonitor::GetMountNames( void )
{
wxArrayString RetVal;
int Index;
int Count = m_MountedVolumes->Count();
for( Index = 0; Index < Count; Index++ )
{
guGIO_Mount * Mount = m_MountedVolumes->Item( Index );
guLogMessage( wxT( "... '%s'" ), Mount->GetName().c_str() );
RetVal.Add( Mount->GetName() );
}
return RetVal;
}
// -------------------------------------------------------------------------------- //
void guGIO_VolumeMonitor::OnMountRemoved( GMount * mount )
{
guLogMessage( wxT( "Mount Removed..." ) );
int MountIndex;
if( ( MountIndex = FindMount( mount ) ) != wxNOT_FOUND )
{
//guGIO_Mount * Mount = m_MountedVolumes->Item( MountIndex );
m_MountedVolumes->RemoveAt( MountIndex );
wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_VOLUMEMANAGER_MOUNT_CHANGED );
event.SetClientData( ( void * ) mount );
event.SetInt( 0 );
wxPostEvent( m_MainFrame, event );
//guLogMessage( wxT( "Posted mount changed event..." ) );
}
}
// -------------------------------------------------------------------------------- //
wxImage * guDbCache::GetImage( const wxString &url, wxBitmapType &imgtype, const int imgsize )
{
wxImage * Img = NULL;
wxString query;
wxSQLite3ResultSet dbRes;
const unsigned char * Data;
int DataLen = 0;
query = wxString::Format( wxT( "SELECT cache_data, cache_type FROM cache WHERE cache_key = '%s' " \
"AND cache_size = %u LIMIT 1;" ),
escape_query_str( url ).c_str(), imgsize );
dbRes = ExecuteQuery( query );
if( dbRes.NextRow() )
{
Data = dbRes.GetBlob( 0, DataLen );
imgtype = wxBitmapType( dbRes.GetInt( 1 ) );
if( DataLen )
{
wxMemoryInputStream Ins( Data, DataLen );
Img = new wxImage( Ins, imgtype );
if( Img )
{
if( !Img->IsOk() )
{
guLogMessage( wxT( "Image is not OK" ) );
delete Img;
Img = NULL;
}
}
// else
// {
// guLogMessage( wxT( "Could not create the image" ) );
// }
}
}
// else
// {
// guLogMessage( wxT( "DbCache failed '%s'" ), url.c_str() );
// }
dbRes.Finalize();
return Img;
}
// -------------------------------------------------------------------------------- //
void CheckSymLinks( wxArrayString &libpaths )
{
char TmpBuf[ 4096 ];
int Result;
int Index;
int Count = libpaths.Count();
for( Index = 0; Index < Count; Index++ )
{
Result = readlink( libpaths[ Index ].char_str(), TmpBuf, WXSIZEOF( TmpBuf ) - sizeof( char ) );
if( Result != -1 )
{
TmpBuf[ Result ] = 0;
libpaths[ Index ] = wxString::FromUTF8( TmpBuf );
guLogMessage( wxT( "Detected symbolic link pointing to %s" ), libpaths[ Index ].c_str() );
}
}
}
// -------------------------------------------------------------------------------- //
void guJamendoPanel::OnDownloadTrackAlbum( wxCommandEvent &event )
{
guLogMessage( wxT( "OnDownloadTrackAlbum" ) );
guTrackArray Tracks;
m_SongListCtrl->GetSelectedSongs( &Tracks );
wxArrayInt Albums;
int Index;
int Count = Tracks.Count();
for( Index = 0; Index < Count; Index++ )
{
if( Albums.Index( Tracks[ Index ].m_AlbumId ) == wxNOT_FOUND )
Albums.Add( Tracks[ Index ].m_AlbumId );
}
( ( guMediaViewerJamendo * ) m_MediaViewer )->DownloadAlbums( Albums, ( event.GetId() == ID_JAMENDO_DOWNLOAD_TORRENT_TRACK_ALBUM ) );
}
// -------------------------------------------------------------------------------- //
void guAuiManagerPanel::ShowPanel( const int panelid, bool show )
{
int PanelIndex = m_PanelIds.Index( panelid );
if( PanelIndex != wxNOT_FOUND )
{
wxString PaneName = m_PanelNames[ PanelIndex ];
wxAuiPaneInfo &PaneInfo = m_AuiManager.GetPane( PaneName );
if( PaneInfo.IsOk() )
{
if( show )
PaneInfo.Show();
else
PaneInfo.Hide();
m_AuiManager.Update();
}
if( show )
m_VisiblePanels |= panelid;
else
m_VisiblePanels ^= panelid;
if( !m_MenuBar )
{
guMainFrame * MainFrame = ( guMainFrame * ) wxTheApp->GetTopWindow();
m_MenuBar = MainFrame->GetMenuBar();
}
if( m_MenuBar )
{
wxMenuItem * MenuItem = m_MenuBar->FindItem( m_PanelCmdIds[ PanelIndex ] );
if( MenuItem )
{
MenuItem->Check( show );
}
}
guLogMessage( wxT( "Id: %i Pane: %s Show:%i Flags:%08X" ), panelid, PaneName.c_str(), show, m_VisiblePanels );
}
}
// -------------------------------------------------------------------------------- //
void guDbCache::ClearExpired( void )
{
// TODO : Clear different types with different periods
// last.fm queries are kept only 7 days
wxString query = wxString::Format( wxT( "DELETE FROM cache WHERE cache_time < %lu AND cache_type = %u" ),
wxDateTime::Now().GetTicks() - ( guDAY_SECONDS * 7 ), guDBCACHE_TYPE_TEXT );
ExecuteUpdate( query );
// Images are kept 30 days
// query = wxString::Format( wxT( "DELETE FROM cache WHERE cache_time < %lu" ), wxDateTime::Now().GetTicks() - ( guDAY_SECONDS * 30 ) );
// ExecuteUpdate( query );
query = wxString::Format( wxT( "DELETE FROM cache WHERE cache_time < %lu AND cache_type = %u" ),
wxDateTime::Now().GetTicks() - ( guDAY_SECONDS * 30 ), guDBCACHE_TYPE_LASTFM );
ExecuteUpdate( query );
query = wxString::Format( wxT( "DELETE FROM cache WHERE cache_time < %lu AND cache_type = %u" ),
wxDateTime::Now().GetTicks() - ( guDAY_SECONDS * 3 ), guDBCACHE_TYPE_TUNEIN );
ExecuteUpdate( query );
guLogMessage( wxT( "Delete expired Cache elements done" ) );
}
// -------------------------------------------------------------------------------- //
void Unmounted_Device( GObject * object, GAsyncResult * result, guGIO_Mount * mnt )
{
GError * error = NULL;
if( G_IS_MOUNT( object ) )
{
GMount * mount = ( GMount * ) object;
g_mount_eject_with_operation_finish( mount, result, &error);
}
if( error )
{
if( !g_error_matches( error, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED ) )
{
guLogError( wxT( "Unable to eject %s" ), error->message );
}
else
{
guLogMessage( wxT( "Eject was already done" ) );
}
g_error_free (error);
}
}
// -------------------------------------------------------------------------------- //
guJamendoDownloadThread::ExitCode guJamendoDownloadThread::Entry()
{
int Count;
int LoopCount = 0;
guConfig * Config = ( guConfig * ) guConfig::Get();
int AudioFormat = Config->ReadNum( CONFIG_KEY_JAMENDO_AUDIOFORMAT, 1, CONFIG_PATH_JAMENDO );
wxString TorrentCmd = Config->ReadStr( CONFIG_KEY_JAMENDO_TORRENT_COMMAND, wxEmptyString, CONFIG_PATH_JAMENDO );
while( !TestDestroy() )
{
m_CoversMutex.Lock();
Count = m_Covers.Count();
m_CoversMutex.Unlock();
size_t CurTime = wxGetLocalTimeMillis().GetLo();
if( Count )
{
LoopCount = 0;
wxString CoverFile = guPATH_JAMENDO_COVERS;
CoverFile += wxString::Format( wxT( "%u.jpg" ), m_Covers[ 0 ] );
if( !wxFileExists( CoverFile ) )
{
if( !wxDirExists( wxPathOnly( CoverFile ) + wxT( "/" ) ) )
{
wxMkdir( wxPathOnly( CoverFile ) + wxT( "/" ), 0770 );
}
wxString CoverUrl = wxString::Format( guJAMENDO_COVER_DOWNLOAD_URL, m_Covers[ 0 ], 300 );
DownloadImage( CoverUrl, CoverFile, 300 );
}
if( wxFileExists( CoverFile ) )
{
int CoverId = m_Db->AddCoverFile( CoverFile );
wxString query = wxString::Format( wxT( "UPDATE songs SET song_coverid = %u WHERE song_albumid = %u" ),
CoverId, m_Covers[ 0 ] );
m_Db->ExecuteUpdate( query );
// Notify the panel that the cover is downloaded
wxCommandEvent event( wxEVT_MENU, ID_JAMENDO_COVER_DOWNLAODED );
event.SetInt( m_Covers[ 0 ] );
wxPostEvent( m_MediaViewer, event );
}
else
{
guLogMessage( wxT( "Could not get the jamendo cover art %s" ), CoverFile.c_str() );
}
m_CoversMutex.Lock();
m_Covers.RemoveAt( 0 );
m_CoversMutex.Unlock();
}
else
{
LoopCount++;
if( LoopCount > 8 )
{
break;
}
}
if( TestDestroy() )
break;
size_t Elapsed = wxGetLocalTimeMillis().GetLo() - CurTime;
if( !( Elapsed > 1000 ) )
{
Sleep( 1000 - Elapsed );
}
//
// Album Torrents
//
m_AlbumsMutex.Lock();
Count = m_Albums.Count();
m_AlbumsMutex.Unlock();
CurTime = wxGetLocalTimeMillis().GetLo();
if( Count )
{
LoopCount = 0;
wxString Url = wxString::Format( guJAMENDO_TORRENT_DOWNLOAD_URL, m_Albums[ 0 ] );
Url += AudioFormat ? guJAMENDO_DOWNLOAD_FORMAT_OGG : guJAMENDO_DOWNLOAD_FORMAT_MP3;
//guLogMessage( wxT( "Getting %s" ), Url.c_str() );
wxString TorrentUrl = GetUrlContent( Url );
//guLogMessage( wxT( "Downloading '%s'" ), TorrentUrl.c_str() );
if( !TorrentUrl.IsEmpty() )
{
wxString TmpFileName = wxFileName::CreateTempFileName( wxString::Format( wxT( "%u" ), m_Albums[ 0 ] ) );
TmpFileName += wxT( ".torrent" );
if( DownloadFile( TorrentUrl, TmpFileName ) )
{
guExecute( TorrentCmd + wxT( " " ) + TmpFileName );
}
}
m_AlbumsMutex.Lock();
m_Albums.RemoveAt( 0 );
m_AlbumsMutex.Unlock();
}
else
{
LoopCount++;
if( LoopCount > 8 )
{
break;
}
}
if( TestDestroy() )
break;
Elapsed = wxGetLocalTimeMillis().GetLo() - CurTime;
if( !( Elapsed > 1000 ) )
{
Sleep( 1000 - Elapsed );
}
}
return 0;
}
// -------------------------------------------------------------------------------- //
guLibUpdateThread::ExitCode guLibUpdateThread::Entry()
{
int Index;
int Count;
int LastIndex;
wxCommandEvent evtup( wxEVT_MENU, ID_STATUSBAR_GAUGE_UPDATE );
evtup.SetInt( m_GaugeId );
wxCommandEvent evtmax( wxEVT_MENU, ID_STATUSBAR_GAUGE_SETMAX );
evtmax.SetInt( m_GaugeId );
if( m_ScanPath.IsEmpty() )
{
Count = m_LibPaths.Count();
if( !Count )
{
guLogError( wxT( "No library directories to scan" ) );
return 0;
}
// For every directory in the library scan for new files and add them to m_TrackFiles
Index = 0;
while( !TestDestroy() && ( Index < Count ) )
{
guLogMessage( wxT( "Doing Library Update in %s" ), m_LibPaths[ Index ].c_str() );
ScanDirectory( m_LibPaths[ Index ] );
Index++;
}
}
else
{
ScanDirectory( m_ScanPath, true );
}
bool EmbeddMetadata = m_MediaViewer->GetMediaCollection()->m_EmbeddMetadata;
// For every new track file update it in the database
Count = m_TrackFiles.Count();
if( Count )
{
m_Db->ExecuteUpdate( wxT( "BEGIN TRANSACTION;" ) );
Index = 0;
evtmax.SetExtraLong( Count );
wxPostEvent( m_MainFrame, evtmax );
LastIndex = -1;
while( !TestDestroy() )
{
//guLogMessage( wxT( "%i - %i" ), Index, Count );
if( ( Index >= Count ) )
break;
//guLogMessage( wxT( "Scanning: '%s'" ), m_TrackFiles[ Index ].c_str() );
m_Db->ReadFileTags( m_TrackFiles[ Index ], EmbeddMetadata );
//Sleep( 1 );
Index++;
if( Index > LastIndex )
{
evtup.SetExtraLong( Index );
wxPostEvent( m_MainFrame, evtup );
LastIndex = Index + 5;
}
}
m_Db->ExecuteUpdate( wxT( "COMMIT TRANSACTION;" ) );
}
Count = m_CueFiles.Count();
if( Count )
{
m_Db->ExecuteUpdate( wxT( "BEGIN TRANSACTION;" ) );
evtmax.SetExtraLong( Count );
wxPostEvent( m_MainFrame, evtmax );
for( Index = 0; Index < Count; Index++ )
{
//
// Delete all files from the same cue files
//
wxString query = wxT( "DELETE FROM songs WHERE song_path = '" );
query += escape_query_str( wxPathOnly( m_CueFiles[ Index ] + wxT( "/" ) ) );
query += wxT( "' AND song_offset > 0" );
m_Db->ExecuteUpdate( query );
//guLogMessage( wxT( "DELETE:\n%s" ), query.c_str() );
}
Index = 0;
LastIndex = -1;
while( !TestDestroy() )
{
//guLogMessage( wxT( "%i - %i" ), Index, Count );
if( ( Index >= Count ) )
break;
//guLogMessage( wxT( "Scanning: '%s'" ), m_TrackFiles[ Index ].c_str() );
m_Db->ReadFileTags( m_CueFiles[ Index ], EmbeddMetadata );
//Sleep( 1 );
Index++;
if( Index > LastIndex )
{
evtup.SetExtraLong( Index );
wxPostEvent( m_MainFrame, evtup );
LastIndex = Index + 5;
}
}
m_Db->ExecuteUpdate( wxT( "COMMIT TRANSACTION;" ) );
}
ProcessCovers();
Count = m_PlayListFiles.Count();
if( Count )
{
m_Db->ExecuteUpdate( wxT( "BEGIN TRANSACTION;" ) );
Index = 0;
evtmax.SetExtraLong( Count );
wxPostEvent( m_MainFrame, evtmax );
LastIndex = -1;
while( !TestDestroy() )
{
//guLogMessage( wxT( "%i - %i" ), Index, Count );
if( ( Index >= Count ) )
break;
guPlaylistFile PlayList( m_PlayListFiles[ Index ] );
wxArrayInt PlayListIds;
int ItemTrackId;
int ItemIndex;
int ItemCount;
if( ( ItemCount = PlayList.Count() ) )
{
for( ItemIndex = 0; ItemIndex < ItemCount; ItemIndex++ )
{
if( wxFileExists( PlayList.GetItem( ItemIndex ).m_Location ) )
{
ItemTrackId = m_Db->FindTrackFile( PlayList.GetItem( ItemIndex ).m_Location, NULL );
if( ItemTrackId )
{
PlayListIds.Add( ItemTrackId );
}
}
}
if( PlayListIds.Count() )
{
if( m_Db->GetStaticPlayList( m_PlayListFiles[ Index ] ) == wxNOT_FOUND )
{
m_Db->CreateStaticPlayList( m_PlayListFiles[ Index ], PlayListIds );
wxCommandEvent evt( wxEVT_MENU, ID_PLAYLIST_UPDATED );
evt.SetClientData( ( void * ) m_MediaViewer );
wxPostEvent( m_MainFrame, evt );
}
}
}
Index++;
if( Index > LastIndex )
{
evtup.SetExtraLong( Index );
wxPostEvent( m_MainFrame, evtup );
LastIndex = Index + 5;
}
}
m_Db->ExecuteUpdate( wxT( "COMMIT TRANSACTION;" ) );
}
//
// This cant be called here as wxBitmap do X11 calls and this can only be done from the main
// thread. So we must call DoCleanUp from the main thread once this thread is finished.
// in the OnLibraryUpdated Event handler
//
// delete all orphans entries
// m_Db->DoCleanUp();
return 0;
}
// -------------------------------------------------------------------------------- //
void guMediaRecordCtrl::SetTrack( const guTrack &track )
{
guLogMessage( wxT( "guMediaRecordCtrl::SetTrack" ) );
m_TrackInfo = track;
SplitTrack();
}
// -------------------------------------------------------------------------------- //
int guLibUpdateThread::ScanDirectory( wxString dirname, bool includedir )
{
wxDir Dir;
wxString FileName;
wxString LowerFileName;
bool FoundCover = false;
wxString FirstAudioFile;
if( !dirname.EndsWith( wxT( "/" ) ) )
dirname += wxT( "/" );
//guLogMessage( wxT( "Scanning dir (%i) '%s'" ), includedir, dirname.c_str() );
Dir.Open( dirname );
if( !TestDestroy() && Dir.IsOpened() )
{
if( Dir.GetFirst( &FileName, wxEmptyString, wxDIR_FILES | wxDIR_DIRS ) )
{
do {
if( FileName[ 0 ] == '.' )
continue;
if ( !m_ScanSymlinks && IsFileSymbolicLink( dirname + FileName ) )
continue;
int FileDate = GetFileLastChangeTime( dirname + FileName );
if( Dir.Exists( dirname + FileName ) )
{
//guLogMessage( wxT( "Scanning dir '%s' : FileDate: %u -> %u\n%u Tracks found" ), ( dirname + FileName ).c_str(), m_LastUpdate, FileDate, m_TrackFiles.Count() );
ScanDirectory( dirname + FileName, includedir || ( FileDate > m_LastUpdate ) );
wxCommandEvent event( wxEVT_MENU, ID_STATUSBAR_GAUGE_SETMAX );
event.SetInt( m_GaugeId );
event.SetExtraLong( m_TrackFiles.Count() );
wxPostEvent( m_MainFrame, event );
}
else
{
//guLogMessage( wxT( "%s (%i): FileDate: %u -> %u" ), ( dirname + FileName ).c_str(), includedir, m_LastUpdate, FileDate );
if( includedir || ( FileDate > m_LastUpdate ) )
{
LowerFileName = FileName.Lower();
if( guIsValidAudioFile( LowerFileName ) )
{
if( !m_Db->FindDeletedFile( dirname + FileName, false ) )
{
m_TrackFiles.Add( dirname + FileName );
if( m_ScanEmbeddedCovers && FirstAudioFile.IsEmpty() )
FirstAudioFile = dirname + FileName;
}
}
else if( guIsValidImageFile( LowerFileName ) )
{
if( SearchCoverWords( LowerFileName, m_CoverSearchWords ) )
{
//guLogMessage( wxT( "Adding image '%s'" ), wxString( dirname + FileName ).c_str() );
m_ImageFiles.Add( dirname + FileName );
FoundCover = true;
}
}
else if( m_ScanAddPlayLists && guPlaylistFile::IsValidPlayList( LowerFileName ) )
{
m_PlayListFiles.Add( dirname + FileName );
}
else if( guCuePlaylistFile::IsValidFile( LowerFileName ) )
{
//
m_CueFiles.Add( dirname + FileName );
}
//else
//{
// guLogMessage( wxT( "Unknown file: '%s'"), ( dirname + FileName ).c_str() );
//}
}
}
} while( !TestDestroy() && Dir.GetNext( &FileName ) );
if( m_ScanEmbeddedCovers && !FoundCover && !FirstAudioFile.IsEmpty() )
{
m_ImageFiles.Add( FirstAudioFile );
}
}
}
else
{
guLogMessage( wxT( "Could not open the dir '%s'" ), dirname.c_str() );
}
return 1;
}
// -------------------------------------------------------------------------------- //
int guExecute( const wxString &Command )
{
guLogMessage( wxT( "Running command %s" ), Command.c_str() );
return wxExecute( Command );
}
// -------------------------------------------------------------------------------- //
void guGIO_VolumeMonitor::OnVolumeRemoved( GVolume * volume )
{
guLogMessage( wxT( "Volume Removed..." ) );
}