~ubuntu-branches/ubuntu/vivid/guayadeque/vivid

Connect( ID_PLAYER_PLAYLIST_UPDATETITLE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerPlayListUpdateTitle ), NULL, this );

477

546

Connect( ID_MENU_ABOUT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnAbout ), NULL, this );

547

Connect( ID_MENU_HELP, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnHelp ), NULL, this );

548

Connect( ID_MENU_COMMUNITY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnCommunity ), NULL, this );

478

549

479

550

Connect( ID_MAINFRAME_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnCopyTracksTo ), NULL, this );

551

Connect( ID_MAINFRAME_COPYTODEVICE_TRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnCopyTracksToDevice ), NULL, this );

552

Connect( ID_MAINFRAME_COPYTODEVICE_PLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnCopyPlayListToDevice ), NULL, this );

480

553

481

554

Connect( ID_LABEL_UPDATELABELS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnUpdateLabels ), NULL, this );

482

555

488

561

Connect( ID_MENU_VIEW_PLAYER_FILTERS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerShowPanel ), NULL, this );

489

562

Connect( ID_MENU_VIEW_PLAYER_VUMETERS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerShowPanel ), NULL, this );

490

563

Connect( ID_MENU_VIEW_PLAYER_SELECTOR, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerShowPanel ), NULL, this );

564

Connect( ID_MENU_VIEW_MAIN_LOCATIONS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerShowPanel ), NULL, this );

565

Connect( ID_MENU_VIEW_MAIN_SHOWCOVER, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerShowPanel ), NULL, this );

491

566

492

567

Connect( ID_MENU_VIEW_LIBRARY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewLibrary ), NULL, this );

493

568

Connect( ID_MENU_VIEW_LIB_TEXTSEARCH, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnLibraryShowPanel ), NULL, this );

520

595

521

596

Connect( ID_MENU_VIEW_FILEBROWSER, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewFileBrowser ), NULL, this );

522

597

598

Connect( ID_MENU_VIEW_JAMENDO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewJamendo ), NULL, this );

599

Connect( ID_MENU_VIEW_JAMENDO_TEXTSEARCH, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnJamendoShowPanel ), NULL, this );

600

Connect( ID_MENU_VIEW_JAMENDO_LABELS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnJamendoShowPanel ), NULL, this );

601

Connect( ID_MENU_VIEW_JAMENDO_GENRES, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnJamendoShowPanel ), NULL, this );

602

Connect( ID_MENU_VIEW_JAMENDO_ARTISTS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnJamendoShowPanel ), NULL, this );

603

Connect( ID_MENU_VIEW_JAMENDO_COMPOSERS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnJamendoShowPanel ), NULL, this );

604

Connect( ID_MENU_VIEW_JAMENDO_ALBUMARTISTS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnJamendoShowPanel ), NULL, this );

605

Connect( ID_MENU_VIEW_JAMENDO_ALBUMS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnJamendoShowPanel ), NULL, this );

606

Connect( ID_MENU_VIEW_JAMENDO_YEARS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnJamendoShowPanel ), NULL, this );

607

Connect( ID_MENU_VIEW_JAMENDO_RATINGS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnJamendoShowPanel ), NULL, this );

608

Connect( ID_MENU_VIEW_JAMENDO_PLAYCOUNT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnJamendoShowPanel ), NULL, this );

609

610

Connect( ID_MENU_VIEW_MAGNATUNE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewMagnatune ), NULL, this );

611

Connect( ID_MENU_VIEW_MAGNATUNE_TEXTSEARCH, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnMagnatuneShowPanel ), NULL, this );

612

Connect( ID_MENU_VIEW_MAGNATUNE_LABELS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnMagnatuneShowPanel ), NULL, this );

613

Connect( ID_MENU_VIEW_MAGNATUNE_GENRES, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnMagnatuneShowPanel ), NULL, this );

614

Connect( ID_MENU_VIEW_MAGNATUNE_ARTISTS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnMagnatuneShowPanel ), NULL, this );

615

Connect( ID_MENU_VIEW_MAGNATUNE_COMPOSERS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnMagnatuneShowPanel ), NULL, this );

616

Connect( ID_MENU_VIEW_MAGNATUNE_ALBUMARTISTS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnMagnatuneShowPanel ), NULL, this );

617

Connect( ID_MENU_VIEW_MAGNATUNE_ALBUMS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnMagnatuneShowPanel ), NULL, this );

618

Connect( ID_MENU_VIEW_MAGNATUNE_YEARS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnMagnatuneShowPanel ), NULL, this );

619

Connect( ID_MENU_VIEW_MAGNATUNE_RATINGS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnMagnatuneShowPanel ), NULL, this );

620

Connect( ID_MENU_VIEW_MAGNATUNE_PLAYCOUNT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnMagnatuneShowPanel ), NULL, this );

621

622

Connect( ID_ALBUM_COVER_CHANGED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnLibraryCoverChanged ), NULL, this );

623

Connect( ID_JAMENDO_COVER_DOWNLAODED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnJamendoCoverDownloaded ), NULL, this );

624

Connect( ID_MAGNATUNE_COVER_DOWNLAODED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnMagnatuneCoverDownloaded ), NULL, this );

625

Connect( ID_PLAYERPANEL_COVERUPDATED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerPanelCoverChanged ), NULL, this );

626

523

627

Connect( ID_MENU_VIEW_FULLSCREEN, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewFullScreen ), NULL, this );

524

628

Connect( ID_MENU_VIEW_STATUSBAR, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewStatusBar ), NULL, this );

525

629

526

630

527

Connect( ID_GAUGE_PULSE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugePulse ), NULL, this );

528

Connect( ID_GAUGE_SETMAX, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeSetMax ), NULL, this );

529

Connect( ID_GAUGE_UPDATE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeUpdate ), NULL, this );

530

Connect( ID_GAUGE_REMOVE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeRemove ), NULL, this );

631

Connect( ID_VOLUMEMANAGER_MOUNT_CHANGED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnVolumeMonitorUpdated ), NULL, this );

632

//Connect( ID_MENU_VIEW_PORTABLE_DEVICES, ID_MENU_VIEW_PORTABLE_DEVICES + 100, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnVolumeMonitorUpdated ), NULL, this );

633

634

Connect( ID_STATUSBAR_GAUGE_CREATE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeCreate ), NULL, this );

635

Connect( ID_STATUSBAR_GAUGE_PULSE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugePulse ), NULL, this );

636

Connect( ID_STATUSBAR_GAUGE_SETMAX, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeSetMax ), NULL, this );

637

Connect( ID_STATUSBAR_GAUGE_UPDATE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeUpdate ), NULL, this );

638

Connect( ID_STATUSBAR_GAUGE_REMOVE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeRemove ), NULL, this );

531

639

532

640

Connect( ID_PLAYLIST_UPDATED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayListUpdated ), NULL, this );

533

641

534

642

Connect( ID_PODCASTS_ITEM_UPDATED, guPodcastEvent, wxCommandEventHandler( guMainFrame::OnPodcastItemUpdated ), NULL, this );

535

643

Connect( ID_MAINFRAME_REMOVEPODCASTTHREAD, wxCommandEventHandler( guMainFrame::OnRemovePodcastThread ), NULL, this );

536

644

645

Connect( ID_MAINFRAME_SETFORCEGAPLESS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnSetForceGapless ), NULL, this );

646

537

647

m_AuiManager.Connect( wxEVT_AUI_PANE_CLOSE, wxAuiManagerEventHandler( guMainFrame::OnMainPaneClose ), NULL, this );

538

648

539

649

m_CatNotebook->Connect( wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED, wxAuiNotebookEventHandler( guMainFrame::OnPageChanged ), NULL, this );

547

657

548

658

//Connect( wxEVT_SYS_COLOUR_CHANGED, wxSysColourChangedEventHandler( guMainFrame::OnSysColorChanged ), NULL, this );

549

659

660

Connect( ID_LYRICS_LYRICFOUND, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnLyricFound ), NULL, this );

661

Connect( ID_MAINFRAME_LYRICSSEARCHFIRST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnLyricSearchFirst ), NULL, this );

662

Connect( ID_MAINFRAME_LYRICSSEARCHNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnLyricSearchNext ), NULL, this );

663

Connect( ID_MAINFRAME_LYRICSSAVECHANGES, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnLyricSaveChanges ), NULL, this );

664

Connect( ID_MAINFRAME_LYRICSEXECCOMMAND, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnLyricExecCommand ), NULL, this );

665

666

Connect( ID_CONFIG_UPDATED, guConfigUpdatedEvent, wxCommandEventHandler( guMainFrame::OnConfigUpdated ), NULL, this );

667

550

668

}

551

669

552

670

// -------------------------------------------------------------------------------- //

560

678

Disconnect( ID_MENU_QUIT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnQuit ), NULL, this );

561

679

562

680

Disconnect( ID_LIBRARY_UPDATED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::LibraryUpdated ), NULL, this );

681

Disconnect( ID_JAMENDO_UPDATE_FINISHED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnJamendoUpdated ), NULL, this );

563

682

Disconnect( ID_LIBRARY_DOCLEANDB, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::DoLibraryClean ), NULL, this );

564

683

Disconnect( ID_LIBRARY_CLEANFINISHED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::LibraryCleanFinished ), NULL, this );

684

Disconnect( ID_LIBRARY_RELOADCONTROLS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::LibraryReloadControls ), NULL, this );

565

685

566

686

Disconnect( ID_AUDIOSCROBBLE_UPDATED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnAudioScrobbleUpdate ), NULL, this );

567

687

Disconnect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( guMainFrame::OnCloseWindow ), NULL, this );

572

692

Disconnect( ID_PLAYERPANEL_STATUSCHANGED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerStatusChanged ), NULL, this );

573

693

Disconnect( ID_PLAYERPANEL_TRACKLISTCHANGED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerTrackListChanged ), NULL, this );

574

694

Disconnect( ID_PLAYERPANEL_CAPSCHANGED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerCapsChanged ), NULL, this );

695

Disconnect( ID_PLAYERPANEL_VOLUMECHANGED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerVolumeChanged ), NULL, this );

575

696

576

697

Disconnect( ID_MAINFRAME_SELECT_TRACK, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnSelectTrack ), NULL, this );

577

698

Disconnect( ID_MAINFRAME_SELECT_ALBUM, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnSelectAlbum ), NULL, this );

578

699

Disconnect( ID_MAINFRAME_SELECT_ARTIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnSelectArtist ), NULL, this );

579

700

Disconnect( ID_MAINFRAME_SELECT_YEAR, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnSelectYear ), NULL, this );

580

701

Disconnect( ID_MAINFRAME_SELECT_GENRE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnSelectGenre ), NULL, this );

702

Disconnect( ID_MAINFRAME_SELECT_LOCATION, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnSelectLocation ), NULL, this );

703

Disconnect( ID_MENU_VIEW_MAIN_SHOWCOVER, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerShowPanel ), NULL, this );

581

704

582

705

Disconnect( ID_GENRE_SETSELECTION, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGenreSetSelection ), NULL, this );

583

706

Disconnect( ID_ARTIST_SETSELECTION, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnArtistSetSelection ), NULL, this );

596

719

Disconnect( ID_PLAYER_PLAYLIST_REPEATTRACK, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnRepeat ), NULL, this );

597

720

Disconnect( ID_PLAYER_PLAYLIST_UPDATETITLE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerPlayListUpdateTitle ), NULL, this );

598

721

Disconnect( ID_MENU_ABOUT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnAbout ), NULL, this );

722

Disconnect( ID_MENU_HELP, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnHelp ), NULL, this );

723

Disconnect( ID_MENU_COMMUNITY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnCommunity ), NULL, this );

599

724

600

725

Disconnect( ID_MAINFRAME_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnCopyTracksTo ), NULL, this );

726

Disconnect( ID_MAINFRAME_COPYTODEVICE_TRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnCopyTracksToDevice ), NULL, this );

727

Disconnect( ID_MAINFRAME_COPYTODEVICE_PLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnCopyPlayListToDevice ), NULL, this );

601

728

602

729

Disconnect( ID_LABEL_UPDATELABELS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnUpdateLabels ), NULL, this );

603

730

607

734

608

735

Disconnect( ID_MENU_VIEW_PLAYER_PLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerShowPanel ), NULL, this );

609

736

Disconnect( ID_MENU_VIEW_PLAYER_FILTERS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerShowPanel ), NULL, this );

737

Disconnect( ID_MENU_VIEW_PLAYER_VUMETERS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerShowPanel ), NULL, this );

610

738

Disconnect( ID_MENU_VIEW_PLAYER_SELECTOR, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerShowPanel ), NULL, this );

739

Disconnect( ID_MENU_VIEW_MAIN_LOCATIONS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayerShowPanel ), NULL, this );

611

740

612

741

Disconnect( ID_MENU_VIEW_LIBRARY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewLibrary ), NULL, this );

613

742

Disconnect( ID_MENU_VIEW_LIB_TEXTSEARCH, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnLibraryShowPanel ), NULL, this );

640

769

641

770

Disconnect( ID_MENU_VIEW_FILEBROWSER, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewFileBrowser ), NULL, this );

642

771

772

Disconnect( ID_ALBUM_COVER_CHANGED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnLibraryCoverChanged ), NULL, this );

773

Disconnect( ID_JAMENDO_COVER_DOWNLAODED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnJamendoCoverDownloaded ), NULL, this );

774

Disconnect( ID_MAGNATUNE_COVER_DOWNLAODED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnMagnatuneCoverDownloaded ), NULL, this );

775

643

776

Disconnect( ID_MENU_VIEW_FULLSCREEN, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewFullScreen ), NULL, this );

644

777

Disconnect( ID_MENU_VIEW_STATUSBAR, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewStatusBar ), NULL, this );

645

778

646

Disconnect( ID_GAUGE_PULSE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugePulse ), NULL, this );

647

Disconnect( ID_GAUGE_SETMAX, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeSetMax ), NULL, this );

648

Disconnect( ID_GAUGE_UPDATE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeUpdate ), NULL, this );

649

Disconnect( ID_GAUGE_REMOVE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeRemove ), NULL, this );

779

Disconnect( ID_STATUSBAR_GAUGE_CREATE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeCreate ), NULL, this );

780

Disconnect( ID_STATUSBAR_GAUGE_PULSE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugePulse ), NULL, this );

781

Disconnect( ID_STATUSBAR_GAUGE_SETMAX, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeSetMax ), NULL, this );

782

Disconnect( ID_STATUSBAR_GAUGE_UPDATE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeUpdate ), NULL, this );

783

Disconnect( ID_STATUSBAR_GAUGE_REMOVE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnGaugeRemove ), NULL, this );

650

784

651

785

Disconnect( ID_PLAYLIST_UPDATED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnPlayListUpdated ), NULL, this );

652

786

653

787

Disconnect( ID_PODCASTS_ITEM_UPDATED, guPodcastEvent, wxCommandEventHandler( guMainFrame::OnPodcastItemUpdated ), NULL, this );

654

788

Disconnect( ID_MAINFRAME_REMOVEPODCASTTHREAD, wxCommandEventHandler( guMainFrame::OnRemovePodcastThread ), NULL, this );

655

789

790

Disconnect( ID_MAINFRAME_SETFORCEGAPLESS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnSetForceGapless ), NULL, this );

791

656

792

m_AuiManager.Disconnect( wxEVT_AUI_PANE_CLOSE, wxAuiManagerEventHandler( guMainFrame::OnMainPaneClose ), NULL, this );

657

793

658

794

m_CatNotebook->Disconnect( wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED, wxAuiNotebookEventHandler( guMainFrame::OnPageChanged ), NULL, this );

661

797

Disconnect( ID_MAINFRAME_UPDATE_SELINFO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnUpdateSelInfo ), NULL, this );

662

798

Disconnect( ID_MAINFRAME_REQUEST_CURRENTTRACK, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnRequestCurrentTrack ), NULL, this );

663

799

800

Disconnect( ID_LYRICS_LYRICFOUND, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnLyricFound ), NULL, this );

801

Disconnect( ID_MAINFRAME_LYRICSSEARCHFIRST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnLyricSearchFirst ), NULL, this );

802

Disconnect( ID_MAINFRAME_LYRICSSEARCHNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnLyricSearchNext ), NULL, this );

803

Disconnect( ID_MAINFRAME_LYRICSSAVECHANGES, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnLyricSaveChanges ), NULL, this );

804

Disconnect( ID_CONFIG_UPDATED, guConfigUpdatedEvent, wxCommandEventHandler( guMainFrame::OnConfigUpdated ), NULL, this );

805

806

if( m_LibUpdateThread )

807

{

808

m_LibUpdateThread->Pause();

809

m_LibUpdateThread->Delete();

810

}

811

812

if( m_LibCleanThread )

813

{

814

m_LibCleanThread->Pause();

815

m_LibCleanThread->Delete();

816

}

817

818

while( m_PortableMediaViewCtrls.Count() )

819

{

820

guPortableMediaViewCtrl * PortableMediaViewCtrl = m_PortableMediaViewCtrls[ 0 ];

821

int VisiblePanels = PortableMediaViewCtrl->VisiblePanels();

822

823

if( VisiblePanels & guPANEL_MAIN_LIBRARY )

824

RemoveTabPanel( PortableMediaViewCtrl->LibPanel() );

825

if( VisiblePanels & guPANEL_MAIN_PLAYLISTS )

826

RemoveTabPanel( PortableMediaViewCtrl->PlayListPanel() );

827

if( VisiblePanels & guPANEL_MAIN_ALBUMBROWSER )

828

RemoveTabPanel( PortableMediaViewCtrl->AlbumBrowserPanel() );

829

830

delete PortableMediaViewCtrl;

831

m_PortableMediaViewCtrls.RemoveAt( 0 );

832

}

833

664

834

guConfig * Config = ( guConfig * ) guConfig::Get();

665

835

if( Config )

666

836

{

680

850

681

851

Config->WriteBool( wxT( "ShowFullScreen" ), IsFullScreen() , wxT( "General" ) );

682

852

Config->WriteBool( wxT( "ShowStatusBar" ), m_MainStatusBar->IsShown() , wxT( "General" ) );

683

}

684

685

if( m_LibUpdateThread )

686

{

687

m_LibUpdateThread->Pause();

688

m_LibUpdateThread->Delete();

689

}

690

691

if( m_LibCleanThread )

692

{

693

m_LibCleanThread->Pause();

694

m_LibCleanThread->Delete();

853

guLogMessage( wxT( "VisiblePanels: %08X" ), m_VisiblePanels );

695

854

}

696

855

697

856

if( m_TaskBarIcon )

698

857

delete m_TaskBarIcon;

699

858

859

#ifdef WITH_LIBINDICATE_SUPPORT

860

if( m_IndicateServer )

861

{

862

indicate_server_hide( m_IndicateServer );

863

g_object_unref( m_IndicateServer );

864

}

865

#endif

866

700

867

// destroy the mpris object

701

868

if( m_MPRIS )

702

869

{

703

870

delete m_MPRIS;

704

871

}

705

872

873

if( m_MPRIS2 )

874

{

875

delete m_MPRIS2;

876

}

877

706

878

if( m_GSession )

707

879

{

708

880

delete m_GSession;

724

896

delete m_DBusServer;

725

897

}

726

898

899

if( m_VolumeMonitor )

900

{

901

delete m_VolumeMonitor;

902

}

903

727

904

m_AuiManager.UnInit();

728

905

729

// if( m_Db )

730

// {

731

// m_Db->Close();

732

// delete m_Db;

733

// }

734

735

// if( m_DbCache )

736

// {

737

// m_DbCache->Close();

738

// delete m_DbCache;

739

// }

906

if( m_JamendoDb )

907

{

908

m_JamendoDb->Close();

909

delete m_JamendoDb;

910

}

911

912

if( m_MagnatuneDb )

913

{

914

m_MagnatuneDb->Close();

915

delete m_MagnatuneDb;

916

}

917

918

if( m_CopyToThread )

919

{

920

m_CopyToThreadMutex.Lock();

921

delete m_CopyToThread;

922

m_CopyToThreadMutex.Unlock();

923

}

924

925

if( m_LyricSearchContext )

926

{

927

delete m_LyricSearchContext;

928

}

929

930

if( m_LyricSearchEngine )

931

{

932

delete m_LyricSearchEngine;

933

}

740

934

}

741

935

742

936

extern void wxClearGtkSystemObjects();

750

944

//}

751

945

752

946

// -------------------------------------------------------------------------------- //

947

void guMainFrame::OnVolumeMonitorUpdated( wxCommandEvent &event )

948

{

949

guLogMessage( wxT( "guMainFrame::OnVolumeMonitorUpdated" ) );

950

// a mount point have been removed

951

if( !event.GetInt() )

952

{

953

guLogMessage( wxT( "It was unmounted..." ) );

954

GMount * Mount = ( GMount * ) event.GetClientData();

955

int Index;

956

int Count = m_PortableMediaViewCtrls.Count();

957

for( Index = 0; Index < Count; Index++ )

958

{

959

guPortableMediaViewCtrl * PortableMediaViewCtrl = m_PortableMediaViewCtrls[ Index ];

960

guLogMessage( wxT( "Checking device %i" ), Index );

961

if( PortableMediaViewCtrl->IsMount( Mount ) )

962

{

963

guLogMessage( wxT( "The mount had a view already added ..." ) );

964

int VisiblePanels = PortableMediaViewCtrl->VisiblePanels();

965

if( VisiblePanels & guPANEL_MAIN_LIBRARY )

966

{

967

guLogMessage( wxT( "The MediaViewCtrl had a library pane visible... Need to close it" ) );

968

event.SetClientData( ( void * ) PortableMediaViewCtrl->LibPanel() );

969

//int CmdId = ( event.GetId() - ID_MENU_VIEW_PORTABLE_DEVICE ) % 20;

970

//int DeviceNum = ( event.GetId() - ID_MENU_VIEW_PORTABLE_DEVICE ) / 20;

971

event.SetId( ID_MENU_VIEW_PORTABLE_DEVICE + ( Index * guPORTABLEDEVICE_COMMANDS_COUNT ) );

972

OnViewPortableDevice( event );

973

}

974

975

if( VisiblePanels & guPANEL_MAIN_PLAYLISTS )

976

{

977

guLogMessage( wxT( "The MediaViewCtrl had a library pane visible... Need to close it" ) );

978

event.SetClientData( ( void * ) PortableMediaViewCtrl->PlayListPanel() );

979

// //int CmdId = ( event.GetId() - ID_MENU_VIEW_PORTABLE_DEVICE ) % 20;

980

// //int DeviceNum = ( event.GetId() - ID_MENU_VIEW_PORTABLE_DEVICE ) / 20;

981

event.SetId( ID_MENU_VIEW_PORTABLE_DEVICE + ( Index * guPORTABLEDEVICE_COMMANDS_COUNT ) + 18 );

982

OnViewPortableDevice( event );

983

}

984

985

if( VisiblePanels & guPANEL_MAIN_ALBUMBROWSER )

986

{

987

guLogMessage( wxT( "The MediaViewCtrl had a library pane visible... Need to close it" ) );

988

event.SetClientData( ( void * ) PortableMediaViewCtrl->AlbumBrowserPanel() );

989

//int CmdId = ( event.GetId() - ID_MENU_VIEW_PORTABLE_DEVICE ) % 20;

990

//int DeviceNum = ( event.GetId() - ID_MENU_VIEW_PORTABLE_DEVICE ) / 20;

991

event.SetId( ID_MENU_VIEW_PORTABLE_DEVICE + ( Index * guPORTABLEDEVICE_COMMANDS_COUNT ) + 19 );

992

OnViewPortableDevice( event );

993

}

994

995

break;

996

}

997

}

998

}

999

CreatePortablePlayersMenu( m_PortableDevicesMenu );

1000

1001

if( m_LocationPanel )

1002

{

1003

m_LocationPanel->OnPortableDeviceChanged();

1004

}

1005

}

1006

1007

// -------------------------------------------------------------------------------- //

1008

guPortableMediaViewCtrl * guMainFrame::GetPortableMediaViewCtrl( const int basecmd )

1009

{

1010

int Index;

1011

int Count = m_PortableMediaViewCtrls.Count();

1012

guLogMessage( wxT( "Searching for basecmd %u" ), basecmd );

1013

for( Index = 0; Index < Count; Index++ )

1014

{

1015

guLogMessage( wxT( "Current basecmd %u" ), m_PortableMediaViewCtrls[ Index ]->BaseCommand() );

1016

if( m_PortableMediaViewCtrls[ Index ]->BaseCommand() == basecmd )

1017

{

1018

guLogMessage( wxT( "found the basecmd %u" ), basecmd );

1019

return m_PortableMediaViewCtrls[ Index ];

1020

}

1021

}

1022

return NULL;

1023

}

1024

1025

// -------------------------------------------------------------------------------- //

1026

guPortableMediaViewCtrl * guMainFrame::GetPortableMediaViewCtrl( wxWindow * windowptr, const int windowtype )

1027

{

1028

int Index;

1029

int Count = m_PortableMediaViewCtrls.Count();

1030

for( Index = 0; Index < Count; Index++ )

1031

{

1032

guPortableMediaViewCtrl * PortableMediaViewCtrl = m_PortableMediaViewCtrls[ Index ];

1033

switch( windowtype )

1034

{

1035

case guPANEL_MAIN_LIBRARY :

1036

if( PortableMediaViewCtrl->LibPanel() == ( guLibPanel * ) windowptr )

1037

{

1038

return PortableMediaViewCtrl;

1039

}

1040

break;

1041

1042

case guPANEL_MAIN_ALBUMBROWSER :

1043

if( PortableMediaViewCtrl->AlbumBrowserPanel() == ( guAlbumBrowser * ) windowptr )

1044

{

1045

return PortableMediaViewCtrl;

1046

}

1047

break;

1048

1049

case guPANEL_MAIN_PLAYLISTS :

1050

if( PortableMediaViewCtrl->PlayListPanel() == ( guPlayListPanel * ) windowptr )

1051

{

1052

return PortableMediaViewCtrl;

1053

}

1054

break;

1055

}

1056

}

1057

return NULL;

1058

}

1059

1060

// -------------------------------------------------------------------------------- //

1061

void guMainFrame::CreatePortableMediaDeviceMenu( wxMenu * menu, const wxString &devicename, const int basecmd )

1062

{

1063

wxMenu * SubMenu;

1064

wxMenuItem * MenuItem;

1065

guPortableMediaViewCtrl * PortableMediaViewCtrl = GetPortableMediaViewCtrl( basecmd );

1066

1067

if( !PortableMediaViewCtrl )

1068

{

1069

MenuItem = new wxMenuItem( menu, basecmd, devicename, _( "Show/Hide the portable media device panel" ), wxITEM_CHECK );

1070

menu->Append( MenuItem );

1071

}

1072

else

1073

{

1074

int VisiblePanels = PortableMediaViewCtrl->VisiblePanels();

1075

SubMenu = new wxMenu();

1076

1077

if( VisiblePanels & guPANEL_MAIN_LIBRARY )

1078

{

1079

guPortableMediaLibPanel * PortableMediaLibPanel = PortableMediaViewCtrl->LibPanel();

1080

int LibVisiblePanels = PortableMediaLibPanel->VisiblePanels();

1081

wxMenu * LibSubMenu = new wxMenu();

1082

1083

MenuItem = new wxMenuItem( LibSubMenu, basecmd, _( "Library" ), _( "Show/Hide the portable media device panel" ), wxITEM_CHECK );

1084

LibSubMenu->Append( MenuItem );

1085

MenuItem->Check( true );

1086

1087

LibSubMenu->AppendSeparator();

1088

1089

MenuItem = new wxMenuItem( LibSubMenu, basecmd + guLIBRARY_ELEMENT_TEXTSEARCH, _( "Text Search" ), _( "Show/Hide the Portable Media Device text search" ), wxITEM_CHECK );

1090

LibSubMenu->Append( MenuItem );

1091

MenuItem->Check( LibVisiblePanels & guPANEL_LIBRARY_TEXTSEARCH );

1092

1093

MenuItem = new wxMenuItem( LibSubMenu, basecmd + guLIBRARY_ELEMENT_LABELS, _( "Labels" ), _( "Show/Hide the Portable Media Device labels" ), wxITEM_CHECK );

1094

LibSubMenu->Append( MenuItem );

1095

MenuItem->Check( LibVisiblePanels & guPANEL_LIBRARY_LABELS );

1096

1097

MenuItem = new wxMenuItem( LibSubMenu, basecmd + guLIBRARY_ELEMENT_GENRES, _( "Genres" ), _( "Show/Hide the Portable Media Device genres" ), wxITEM_CHECK );

1098

LibSubMenu->Append( MenuItem );

1099

MenuItem->Check( LibVisiblePanels & guPANEL_LIBRARY_GENRES );

1100

1101

MenuItem = new wxMenuItem( LibSubMenu, basecmd + guLIBRARY_ELEMENT_ARTISTS, _( "Artists" ), _( "Show/Hide the Portable Media Device artists" ), wxITEM_CHECK );

1102

LibSubMenu->Append( MenuItem );

1103

MenuItem->Check( LibVisiblePanels & guPANEL_LIBRARY_ARTISTS );

1104

1105

MenuItem = new wxMenuItem( LibSubMenu, basecmd + guLIBRARY_ELEMENT_COMPOSERS, _( "Composers" ), _( "Show/Hide the Portable Media Device composers" ), wxITEM_CHECK );

1106

LibSubMenu->Append( MenuItem );

1107

MenuItem->Check( LibVisiblePanels & guPANEL_LIBRARY_COMPOSERS );

1108

1109

MenuItem = new wxMenuItem( LibSubMenu, basecmd + guLIBRARY_ELEMENT_ALBUMARTISTS, _( "Album Artist" ), _( "Show/Hide the Portable Media Device album artist" ), wxITEM_CHECK );

1110

LibSubMenu->Append( MenuItem );

1111

MenuItem->Check( LibVisiblePanels & guPANEL_LIBRARY_ALBUMARTISTS );

1112

1113

MenuItem = new wxMenuItem( LibSubMenu, basecmd + guLIBRARY_ELEMENT_ALBUMS, _( "Albums" ), _( "Show/Hide the Portable Media Device albums" ), wxITEM_CHECK );

1114

LibSubMenu->Append( MenuItem );

1115

MenuItem->Check( LibVisiblePanels & guPANEL_LIBRARY_ALBUMS );

1116

1117

MenuItem = new wxMenuItem( LibSubMenu, basecmd + guLIBRARY_ELEMENT_YEARS, _( "Years" ), _( "Show/Hide the Portable Media Device years" ), wxITEM_CHECK );

1118

LibSubMenu->Append( MenuItem );

1119

MenuItem->Check( LibVisiblePanels & guPANEL_LIBRARY_YEARS );

1120

1121

MenuItem = new wxMenuItem( LibSubMenu, basecmd + guLIBRARY_ELEMENT_RATINGS, _( "Ratings" ), _( "Show/Hide the Portable Media Device ratings" ), wxITEM_CHECK );

1122

LibSubMenu->Append( MenuItem );

1123

MenuItem->Check( LibVisiblePanels & guPANEL_LIBRARY_RATINGS );

1124

1125

MenuItem = new wxMenuItem( LibSubMenu, basecmd + guLIBRARY_ELEMENT_PLAYCOUNT, _( "Play Counts" ), _( "Show/Hide the Portable Media Device play counts" ), wxITEM_CHECK );

1126

LibSubMenu->Append( MenuItem );

1127

MenuItem->Check( LibVisiblePanels & guPANEL_LIBRARY_PLAYCOUNT );

1128

1129

SubMenu->AppendSubMenu( LibSubMenu, _( "Library" ), _( "Set the Portable Media Device visible panels" ) );

1130

}

1131

else

1132

{

1133

MenuItem = new wxMenuItem( menu, basecmd, _( "Library" ), _( "Show/Hide the portable media device panel" ), wxITEM_CHECK );

1134

SubMenu->Append( MenuItem );

1135

}

1136

1137

MenuItem = new wxMenuItem( menu, basecmd + 18, _( "PlayLists" ), _( "Show/Hide the portable media device panel" ), wxITEM_CHECK );

1138

SubMenu->Append( MenuItem );

1139

MenuItem->Check( VisiblePanels & guPANEL_MAIN_PLAYLISTS );

1140

1141

MenuItem = new wxMenuItem( menu, basecmd + 19, _( "Album Browser" ), _( "Show/Hide the portable media device panel" ), wxITEM_CHECK );

1142

SubMenu->Append( MenuItem );

1143

MenuItem->Check( VisiblePanels & guPANEL_MAIN_ALBUMBROWSER );

1144

1145

menu->AppendSubMenu( SubMenu, devicename, _( "Set the Portable Media Device visible panels" ) );

1146

}

1147

}

1148

1149

// -------------------------------------------------------------------------------- //

1150

void guMainFrame::CreatePortablePlayersMenu( wxMenu * menu )

1151

{

1152

wxMenuItem * MenuItem;

1153

1154

// Empty the submenu items

1155

int Index = 0;

1156

int BaseCmd;

1157

while( menu->GetMenuItemCount() )

1158

{

1159

menu->Delete( menu->FindItemByPosition( 0 ) );

1160

BaseCmd = ID_MENU_VIEW_PORTABLE_DEVICE + ( Index * guPORTABLEDEVICE_COMMANDS_COUNT );

1161

Disconnect( BaseCmd, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewPortableDevice ), NULL, this );

1162

Disconnect( BaseCmd + 1, BaseCmd + 15, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewPortableDevicePanel ), NULL, this );

1163

Disconnect( BaseCmd + 16, BaseCmd + 19, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewPortableDevice ), NULL, this );

1164

Index++;

1165

}

1166

1167

if( m_VolumeMonitor )

1168

{

1169

wxArrayString VolumeNames = m_VolumeMonitor->GetMountNames();

1170

int Count;

1171

if( ( Count = VolumeNames.Count() ) )

1172

{

1173

for( Index = 0; Index < Count; Index++ )

1174

{

1175

BaseCmd = ID_MENU_VIEW_PORTABLE_DEVICE + ( Index * guPORTABLEDEVICE_COMMANDS_COUNT );

1176

CreatePortableMediaDeviceMenu( menu, VolumeNames[ Index ], BaseCmd );

1177

1178

Connect( BaseCmd, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewPortableDevice ), NULL, this );

1179

Connect( BaseCmd + 1, BaseCmd + 15, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewPortableDevicePanel ), NULL, this );

1180

Connect( BaseCmd + 16, BaseCmd + 19, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guMainFrame::OnViewPortableDevice ), NULL, this );

1181

}

1182

}

1183

else

1184

{

1185

MenuItem = new wxMenuItem( m_MainMenu, -1, _( "No device found" ), _( "Show the Library for the selected portable volume" ), wxITEM_NORMAL );

1186

menu->Append( MenuItem );

1187

MenuItem->Enable( false );

1188

}

1189

}

1190

1191

}

1192

1193

// -------------------------------------------------------------------------------- //

753

1194

void guMainFrame::CreateMenu()

754

1195

{

755

1196

wxMenuBar * MenuBar;

839

1280

m_MainMenu->Append( m_ViewPlayerVumeters );

840

1281

m_ViewPlayerVumeters->Check( m_VisiblePanels & guPANEL_MAIN_PLAYERVUMETERS );

841

1282

1283

m_ViewMainLocations = new wxMenuItem( m_MainMenu, ID_MENU_VIEW_MAIN_LOCATIONS, _( "Sources" ), _( "Show/Hide the locatons" ), wxITEM_CHECK );

1284

m_MainMenu->Append( m_ViewMainLocations );

1285

m_ViewMainLocations->Check( m_VisiblePanels & guPANEL_MAIN_LOCATIONS );

1286

1287

m_ViewMainShowCover = new wxMenuItem( m_MainMenu, ID_MENU_VIEW_MAIN_SHOWCOVER, _( "Cover" ), _( "Show/Hide the cover" ), wxITEM_CHECK );

1288

m_MainMenu->Append( m_ViewMainShowCover );

1289

m_ViewMainShowCover->Check( m_VisiblePanels & guPANEL_MAIN_SHOWCOVER );

1290

842

1291

SubMenu = new wxMenu();

843

1292

844

1293

m_ViewLibrary = new wxMenuItem( SubMenu, ID_MENU_VIEW_LIBRARY, _( "&Library" ), _( "Show/Hide the library panel" ), wxITEM_CHECK );

976

1425

m_MainMenu->Append( m_ViewFileBrowser );

977

1426

m_ViewFileBrowser->Check( m_VisiblePanels & guPANEL_MAIN_FILEBROWSER );

978

1427

1428

1429

SubMenu = new wxMenu();

1430

1431

m_ViewJamendo = new wxMenuItem( SubMenu, ID_MENU_VIEW_JAMENDO, wxT( "Jamendo" ), _( "Show/Hide the Jamendo panel" ), wxITEM_CHECK );

1432

SubMenu->Append( m_ViewJamendo );

1433

m_ViewJamendo->Check( m_VisiblePanels & guPANEL_MAIN_JAMENDO );

1434

1435

SubMenu->AppendSeparator();

1436

1437

m_ViewJamTextSearch = new wxMenuItem( SubMenu, ID_MENU_VIEW_JAMENDO_TEXTSEARCH, _( "Text Search" ), _( "Show/Hide the Jamendo text search" ), wxITEM_CHECK );

1438

SubMenu->Append( m_ViewJamTextSearch );

1439

m_ViewJamTextSearch->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_TEXTSEARCH ) );

1440

m_ViewJamTextSearch->Enable( m_ViewJamendo->IsChecked() );

1441

1442

m_ViewJamLabels = new wxMenuItem( SubMenu, ID_MENU_VIEW_JAMENDO_LABELS, _( "Labels" ), _( "Show/Hide the Jamendo labels" ), wxITEM_CHECK );

1443

SubMenu->Append( m_ViewJamLabels );

1444

m_ViewJamLabels->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_LABELS ) );

1445

m_ViewJamLabels->Enable( m_ViewJamendo->IsChecked() );

1446

1447

m_ViewJamGenres = new wxMenuItem( SubMenu, ID_MENU_VIEW_JAMENDO_GENRES, _( "Genres" ), _( "Show/Hide the Jamendo genres" ), wxITEM_CHECK );

1448

SubMenu->Append( m_ViewJamGenres );

1449

m_ViewJamGenres->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_GENRES ) );

1450

m_ViewJamGenres->Enable( m_ViewJamendo->IsChecked() );

1451

1452

m_ViewJamArtists = new wxMenuItem( SubMenu, ID_MENU_VIEW_JAMENDO_ARTISTS, _( "Artists" ), _( "Show/Hide the Jamendo artists" ), wxITEM_CHECK );

1453

SubMenu->Append( m_ViewJamArtists );

1454

m_ViewJamArtists->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_ARTISTS ) );

1455

m_ViewJamArtists->Enable( m_ViewJamendo->IsChecked() );

1456

1457

m_ViewJamComposers = new wxMenuItem( SubMenu, ID_MENU_VIEW_JAMENDO_COMPOSERS, _( "Composers" ), _( "Show/Hide the Jamendo composers" ), wxITEM_CHECK );

1458

SubMenu->Append( m_ViewJamComposers );

1459

m_ViewJamComposers->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_COMPOSERS ) );

1460

m_ViewJamComposers->Enable( m_ViewJamendo->IsChecked() );

1461

1462

m_ViewJamAlbumArtists = new wxMenuItem( SubMenu, ID_MENU_VIEW_JAMENDO_ALBUMARTISTS, _( "Album Artist" ), _( "Show/Hide the Jamendo album artist" ), wxITEM_CHECK );

1463

SubMenu->Append( m_ViewJamAlbumArtists );

1464

m_ViewJamAlbumArtists->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_ALBUMARTISTS ) );

1465

m_ViewJamAlbumArtists->Enable( m_ViewJamendo->IsChecked() );

1466

1467

m_ViewJamAlbums = new wxMenuItem( SubMenu, ID_MENU_VIEW_JAMENDO_ALBUMS, _( "Albums" ), _( "Show/Hide the Jamendo albums" ), wxITEM_CHECK );

1468

SubMenu->Append( m_ViewJamAlbums );

1469

m_ViewJamAlbums->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_ALBUMS ) );

1470

m_ViewJamAlbums->Enable( m_ViewJamendo->IsChecked() );

1471

1472

m_ViewJamYears = new wxMenuItem( SubMenu, ID_MENU_VIEW_JAMENDO_YEARS, _( "Years" ), _( "Show/Hide the Jamendo years" ), wxITEM_CHECK );

1473

SubMenu->Append( m_ViewJamYears );

1474

m_ViewJamYears->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_YEARS ) );

1475

m_ViewJamYears->Enable( m_ViewJamendo->IsChecked() );

1476

1477

m_ViewJamRatings = new wxMenuItem( SubMenu, ID_MENU_VIEW_JAMENDO_RATINGS, _( "Ratings" ), _( "Show/Hide the Jamendo ratings" ), wxITEM_CHECK );

1478

SubMenu->Append( m_ViewJamRatings );

1479

m_ViewJamRatings->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_RATINGS ) );

1480

m_ViewJamRatings->Enable( m_ViewJamendo->IsChecked() );

1481

1482

m_ViewJamPlayCounts = new wxMenuItem( SubMenu, ID_MENU_VIEW_JAMENDO_PLAYCOUNT, _( "Play Counts" ), _( "Show/Hide the Jamendo play counts" ), wxITEM_CHECK );

1483

SubMenu->Append( m_ViewJamPlayCounts );

1484

m_ViewJamPlayCounts->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_PLAYCOUNT ) );

1485

m_ViewJamPlayCounts->Enable( m_ViewJamendo->IsChecked() );

1486

1487

m_MainMenu->AppendSubMenu( SubMenu, wxT( "Jamendo" ), _( "Set the Jamendo visible panels" ) );

1488

1489

SubMenu = new wxMenu();

1490

1491

m_ViewMagnatune = new wxMenuItem( SubMenu, ID_MENU_VIEW_MAGNATUNE, wxT( "Magnatune" ), _( "Show/Hide the Magnatune panel" ), wxITEM_CHECK );

1492

SubMenu->Append( m_ViewMagnatune );

1493

m_ViewMagnatune->Check( m_VisiblePanels & guPANEL_MAIN_MAGNATUNE );

1494

1495

SubMenu->AppendSeparator();

1496

1497

m_ViewMagTextSearch = new wxMenuItem( SubMenu, ID_MENU_VIEW_MAGNATUNE_TEXTSEARCH, _( "Text Search" ), _( "Show/Hide the Magnatune text search" ), wxITEM_CHECK );

1498

SubMenu->Append( m_ViewMagTextSearch );

1499

m_ViewMagTextSearch->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_TEXTSEARCH ) );

1500

m_ViewMagTextSearch->Enable( m_ViewMagnatune->IsChecked() );

1501

1502

m_ViewMagLabels = new wxMenuItem( SubMenu, ID_MENU_VIEW_MAGNATUNE_LABELS, _( "Labels" ), _( "Show/Hide the Magnatune labels" ), wxITEM_CHECK );

1503

SubMenu->Append( m_ViewMagLabels );

1504

m_ViewMagLabels->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_LABELS ) );

1505

m_ViewMagLabels->Enable( m_ViewMagnatune->IsChecked() );

1506

1507

m_ViewMagGenres = new wxMenuItem( SubMenu, ID_MENU_VIEW_MAGNATUNE_GENRES, _( "Genres" ), _( "Show/Hide the Magnatune genres" ), wxITEM_CHECK );

1508

SubMenu->Append( m_ViewMagGenres );

1509

m_ViewMagGenres->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_GENRES ) );

1510

m_ViewMagGenres->Enable( m_ViewMagnatune->IsChecked() );

1511

1512

m_ViewMagArtists = new wxMenuItem( SubMenu, ID_MENU_VIEW_MAGNATUNE_ARTISTS, _( "Artists" ), _( "Show/Hide the Magnatune artists" ), wxITEM_CHECK );

1513

SubMenu->Append( m_ViewMagArtists );

1514

m_ViewMagArtists->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_ARTISTS ) );

1515

m_ViewMagArtists->Enable( m_ViewMagnatune->IsChecked() );

1516

1517

m_ViewMagComposers = new wxMenuItem( SubMenu, ID_MENU_VIEW_MAGNATUNE_COMPOSERS, _( "Composers" ), _( "Show/Hide the Magnatune composers" ), wxITEM_CHECK );

1518

SubMenu->Append( m_ViewMagComposers );

1519

m_ViewMagComposers->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_COMPOSERS ) );

1520

m_ViewMagComposers->Enable( m_ViewMagnatune->IsChecked() );

1521

1522

m_ViewMagAlbumArtists = new wxMenuItem( SubMenu, ID_MENU_VIEW_MAGNATUNE_ALBUMARTISTS, _( "Album Artist" ), _( "Show/Hide the Magnatune album artist" ), wxITEM_CHECK );

1523

SubMenu->Append( m_ViewMagAlbumArtists );

1524

m_ViewMagAlbumArtists->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_ALBUMARTISTS ) );

1525

m_ViewMagAlbumArtists->Enable( m_ViewMagnatune->IsChecked() );

1526

1527

m_ViewMagAlbums = new wxMenuItem( SubMenu, ID_MENU_VIEW_MAGNATUNE_ALBUMS, _( "Albums" ), _( "Show/Hide the Magnatune albums" ), wxITEM_CHECK );

1528

SubMenu->Append( m_ViewMagAlbums );

1529

m_ViewMagAlbums->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_ALBUMS ) );

1530

m_ViewMagAlbums->Enable( m_ViewMagnatune->IsChecked() );

1531

1532

m_ViewMagYears = new wxMenuItem( SubMenu, ID_MENU_VIEW_MAGNATUNE_YEARS, _( "Years" ), _( "Show/Hide the Magnatune years" ), wxITEM_CHECK );

1533

SubMenu->Append( m_ViewMagYears );

1534

m_ViewMagYears->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_YEARS ) );

1535

m_ViewMagYears->Enable( m_ViewMagnatune->IsChecked() );

1536

1537

m_ViewMagRatings = new wxMenuItem( SubMenu, ID_MENU_VIEW_MAGNATUNE_RATINGS, _( "Ratings" ), _( "Show/Hide the Magnatune ratings" ), wxITEM_CHECK );

1538

SubMenu->Append( m_ViewMagRatings );

1539

m_ViewMagRatings->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_RATINGS ) );

1540

m_ViewMagRatings->Enable( m_ViewMagnatune->IsChecked() );

1541

1542

m_ViewMagPlayCounts = new wxMenuItem( SubMenu, ID_MENU_VIEW_MAGNATUNE_PLAYCOUNT, _( "Play Counts" ), _( "Show/Hide the Magnatune play counts" ), wxITEM_CHECK );

1543

SubMenu->Append( m_ViewMagPlayCounts );

1544

m_ViewMagPlayCounts->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_PLAYCOUNT ) );

1545

m_ViewMagPlayCounts->Enable( m_ViewMagnatune->IsChecked() );

1546

1547

m_MainMenu->AppendSubMenu( SubMenu, wxT( "Magnatune" ), _( "Set the Magnatune visible panels" ) );

1548

1549

m_PortableDevicesMenu = new wxMenu();

1550

1551

CreatePortablePlayersMenu( m_PortableDevicesMenu );

1552

1553

m_MainMenu->AppendSubMenu( m_PortableDevicesMenu, _( "Portable devices" ), _( "View the portable devices library" ) );

1554

1555

979

1556

m_MainMenu->AppendSeparator();

980

1557

981

1558

m_ViewFullScreen = new wxMenuItem( m_MainMenu, ID_MENU_VIEW_FULLSCREEN, _( "Full Screen" ), _( "Show/Restore the main window in full screen" ), wxITEM_CHECK );

1034

1611

MenuBar->Append( m_MainMenu, _( "&Control" ) );

1035

1612

1036

1613

m_MainMenu = new wxMenu();

1614

1615

MenuItem = new wxMenuItem( m_MainMenu, ID_MENU_HELP, _( "&Help" ), _( "Get help using guayadeque" ), wxITEM_NORMAL );

1616

m_MainMenu->Append( MenuItem );

1617

1618

MenuItem = new wxMenuItem( m_MainMenu, ID_MENU_COMMUNITY, _( "&Community" ), _( "Get guayadeque support from guayadeque.org" ), wxITEM_NORMAL );

1619

m_MainMenu->Append( MenuItem );

1620

1621

m_MainMenu->AppendSeparator();

1037

1622

MenuItem = new wxMenuItem( m_MainMenu, ID_MENU_ABOUT, _( "&About" ), _( "Show information about guayadeque music player" ), wxITEM_NORMAL );

1038

1623

//MenuItem->SetBitmap( guImage( guIMAGE_INDEX_tiny_volume_high ) );

1039

1624

m_MainMenu->Append( MenuItem );

1625

1040

1626

MenuBar->Append( m_MainMenu, _( "&Help" ) );

1041

1627

1042

1628

SetMenuBar( MenuBar );

1053

1639

PrefDialog->SaveSettings();

1054

1640

1055

1641

guConfig * Config = ( guConfig * ) guConfig::Get();

1642

1056

1643

if( !m_TaskBarIcon && Config->ReadBool( wxT( "ShowTaskBarIcon" ), true, wxT( "General" ) ) )

1057

1644

{

1058

CreateTaskBarIcon();

1645

#ifdef WITH_LIBINDICATE_SUPPORT

1646

if( Config->ReadBool( wxT( "SoundMenuIntegration" ), false, wxT( "General" ) ) )

1647

{

1648

if( !m_IndicateServer )

1649

{

1650

m_IndicateServer = indicate_server_ref_default();

1651

indicate_server_set_type( m_IndicateServer, GUAYADEQUE_INDICATOR_NAME );

1652

indicate_server_set_desktop_file( m_IndicateServer, GUAYADEQUE_DESKTOP_PATH );

1653

indicate_server_show( m_IndicateServer );

1654

}

1655

}

1656

else if( m_IndicateServer ) // SoundMenuIntegration == false

1657

{

1658

indicate_server_hide( m_IndicateServer );

1659

g_object_unref( m_IndicateServer );

1660

m_IndicateServer = NULL;

1661

1662

CreateTaskBarIcon();

1663

}

1664

else // SoundMenuIntegration == false && !m_IndicateServer

1665

#endif

1666

{

1667

CreateTaskBarIcon();

1668

}

1059

1669

}

1060

else if( m_TaskBarIcon && !Config->ReadBool( wxT( "ShowTaskBarIcon" ), true, wxT( "General" ) ) )

1670

else if( m_TaskBarIcon && ( !Config->ReadBool( wxT( "ShowTaskBarIcon" ), true, wxT( "General" ) ) ||

1671

Config->ReadBool( wxT( "SoundMenuIntegration" ), false, wxT( "General" ) ) ) )

1061

1672

{

1062

1673

m_TaskBarIcon->RemoveIcon();

1063

1674

delete m_TaskBarIcon;

1064

1675

m_TaskBarIcon = NULL;

1065

1676

}

1066

1677

1067

Config->SendConfigChangedEvent();

1678

Config->SendConfigChangedEvent( PrefDialog->GetVisiblePanels() );

1068

1679

m_Db->ConfigChanged();

1069

1680

}

1070

1681

PrefDialog->Destroy();

1074

1685

// -------------------------------------------------------------------------------- //

1075

1686

void guMainFrame::OnCloseWindow( wxCloseEvent &event )

1076

1687

{

1077

guConfig * Config = ( guConfig * ) guConfig::Get();

1078

if( Config )

1079

{

1688

1689

#ifdef WITH_LIBINDICATE_SUPPORT

1690

if( m_IndicateServer )

1691

{

1692

guMediaState State = m_PlayerPanel->GetState();

1693

if( State == guMEDIASTATE_PLAYING )

1694

{

1695

if( event.CanVeto() )

1696

{

1697

Show( false );

1698

return;

1699

}

1700

}

1701

}

1702

else

1703

#endif

1704

{

1705

guConfig * Config = ( guConfig * ) guConfig::Get();

1080

1706

// If the icon

1081

1707

if( m_TaskBarIcon &&

1082

1708

Config->ReadBool( wxT( "ShowTaskBarIcon" ), false, wxT( "General" ) ) &&

1105

1731

}

1106

1732

}

1107

1733

}

1734

1108

1735

event.Skip();

1109

1736

}

1110

1737

1138

1765

void guMainFrame::LibraryCleanFinished( wxCommandEvent &event )

1139

1766

{

1140

1767

m_LibCleanThread = NULL;

1141

//m_Db->LoadCache();

1142

1143

if( m_LibPanel )

1144

m_LibPanel->ReloadControls( event );

1145

1146

if( m_AlbumBrowserPanel )

1147

m_AlbumBrowserPanel->LibraryUpdated();

1768

1769

LibraryReloadControls( event );

1770

}

1771

1772

// -------------------------------------------------------------------------------- //

1773

void guMainFrame::LibraryReloadControls( wxCommandEvent &event )

1774

{

1775

guLibPanel * LibPanel = ( guLibPanel * ) event.GetClientData();

1776

guAlbumBrowser * AlbumBrowser = NULL;

1777

1778

if( !LibPanel )

1779

{

1780

LibPanel = m_LibPanel;

1781

AlbumBrowser = m_AlbumBrowserPanel;

1782

}

1783

else

1784

{

1785

guPortableMediaViewCtrl * PortableMediaViewCtrl = GetPortableMediaViewCtrl( LibPanel );

1786

if( PortableMediaViewCtrl )

1787

{

1788

AlbumBrowser = PortableMediaViewCtrl->AlbumBrowserPanel();

1789

}

1790

}

1791

1792

if( LibPanel )

1793

LibPanel->ReloadControls();

1794

1795

if( AlbumBrowser )

1796

AlbumBrowser->LibraryUpdated();

1148

1797

}

1149

1798

1150

1799

// -------------------------------------------------------------------------------- //

1151

1800

void guMainFrame::DoLibraryClean( wxCommandEvent &event )

1152

1801

{

1802

guLogMessage( wxT( "guMainFrame::DoLibraryClean" ) );

1153

1803

if( m_LibCleanThread )

1154

1804

{

1155

1805

m_LibCleanThread->Pause();

1156

1806

m_LibCleanThread->Delete();

1157

1807

}

1158

1808

1159

m_LibCleanThread = new guLibCleanThread( m_Db );

1809

guLibPanel * LibPanel = ( guLibPanel * ) event.GetClientData();

1810

if( !LibPanel )

1811

LibPanel = m_LibPanel;

1812

if( LibPanel )

1813

{

1814

m_LibCleanThread = new guLibCleanThread( LibPanel );

1815

}

1816

else

1817

{

1818

m_LibCleanThread = new guLibCleanThread( m_Db );

1819

}

1160

1820

}

1161

1821

1162

1822

// -------------------------------------------------------------------------------- //

1166

1826

//m_Db->DoCleanUp();

1167

1827

1168

1828

// if( m_LibPanel )

1169

// m_LibPanel->ReloadControls( event );

1829

// m_LibPanel->ReloadControls();

1170

1830

1171

1831

// if( m_AlbumBrowserPanel )

1172

1832

// m_AlbumBrowserPanel->LibraryUpdated();

1177

1837

}

1178

1838

1179

1839

// -------------------------------------------------------------------------------- //

1840

void guMainFrame::OnJamendoUpdated( wxCommandEvent &event )

1841

{

1842

if( m_JamendoPanel )

1843

m_JamendoPanel->ReloadControls();

1844

}

1845

1846

// -------------------------------------------------------------------------------- //

1847

void guMainFrame::OnMagnatuneUpdated( wxCommandEvent &event )

1848

{

1849

if( m_MagnatunePanel )

1850

m_MagnatunePanel->ReloadControls();

1851

}

1852

1853

// -------------------------------------------------------------------------------- //

1180

1854

void guMainFrame::OnUpdateTrack( wxCommandEvent &event )

1181

1855

{

1182

1856

guTrack * Track = ( guTrack * ) event.GetClientData();

1203

1877

}

1204

1878

}

1205

1879

1206

1207

1880

if( m_LastFMPanel )

1208

1881

{

1209

1882

m_LastFMPanel->OnUpdatedTrack( event );

1210

1883

}

1884

1211

1885

if( m_LyricsPanel )

1212

1886

{

1213

m_LyricsPanel->OnUpdatedTrack( event );

1214

}

1887

m_LyricsPanel->OnSetCurrentTrack( event );

1888

}

1889

1890

if( m_LyricSearchEngine )

1891

{

1892

if( m_LyricSearchContext )

1893

delete m_LyricSearchContext;

1894

m_LyricSearchContext = m_LyricSearchEngine->CreateContext( this, Track );

1895

m_LyricSearchEngine->SearchStart( m_LyricSearchContext );

1896

}

1897

1215

1898

if( m_MPRIS )

1216

1899

{

1217

1900

m_MPRIS->OnPlayerTrackChange();

1218

1901

}

1219

1902

1220

if( event.GetClientData() )

1221

{

1222

delete ( guTrack * ) event.GetClientData();

1903

if( m_MPRIS2 )

1904

{

1905

m_MPRIS2->OnPlayerTrackChange();

1906

}

1907

1908

if( Track )

1909

{

1910

delete Track;

1223

1911

}

1224

1912

}

1225

1913

1226

1914

// -------------------------------------------------------------------------------- //

1227

1915

void guMainFrame::OnPlayerStatusChanged( wxCommandEvent &event )

1228

1916

{

1229

//guLogError( wxT( "Player Status Change Fired" ) );

1230

1917

if( m_MPRIS )

1231

1918

{

1232

1919

m_MPRIS->OnPlayerStatusChange();

1233

1920

}

1234

1921

1922

if( m_MPRIS2 )

1923

{

1924

m_MPRIS2->OnPlayerStatusChange();

1925

}

1926

1235

1927

if( m_PlayerPanel )

1236

1928

{

1237

1929

m_PlaySmartMenuItem->Check( m_PlayerPanel->GetPlaySmart() );

1243

1935

// -------------------------------------------------------------------------------- //

1244

1936

void guMainFrame::OnPlayerTrackListChanged( wxCommandEvent &event )

1245

1937

{

1246

//guLogError( wxT( "Player TrackList Change Fired" ) );

1247

1938

if( m_MPRIS )

1248

1939

{

1249

1940

m_MPRIS->OnTrackListChange();

1250

1941

}

1942

1943

if( m_MPRIS2 )

1944

{

1945

m_MPRIS2->OnTrackListChange();

1946

}

1251

1947

}

1252

1948

1253

1949

// -------------------------------------------------------------------------------- //

1254

1950

void guMainFrame::OnPlayerCapsChanged( wxCommandEvent &event )

1255

1951

{

1256

//guLogError( wxT( "Player TrackList Change Fired" ) );

1257

1952

if( m_MPRIS )

1258

1953

{

1259

1954

m_MPRIS->OnPlayerCapsChange();

1260

1955

}

1956

1957

if( m_MPRIS2 )

1958

{

1959

m_MPRIS2->OnPlayerCapsChange();

1960

}

1961

}

1962

1963

// -------------------------------------------------------------------------------- //

1964

void guMainFrame::OnPlayerVolumeChanged( wxCommandEvent &event )

1965

{

1966

if( m_MPRIS2 )

1967

{

1968

m_MPRIS2->OnPlayerVolumeChange();

1969

}

1261

1970

}

1262

1971

1263

1972

// -------------------------------------------------------------------------------- //

1291

2000

}

1292

2001

1293

2002

// -------------------------------------------------------------------------------- //

1294

void guMainFrame::OnUpdateLibrary( wxCommandEvent& WXUNUSED(event) )

2003

void guMainFrame::OnUpdateLibrary( wxCommandEvent &event )

1295

2004

{

1296

2005

if( m_LibUpdateThread )

1297

2006

return;

1298

int gaugeid = m_MainStatusBar->AddGauge( _( "Library" ), false );

1299

m_LibUpdateThread = new guLibUpdateThread( m_Db, gaugeid );

2007

2008

int gaugeid;

2009

guLibPanel * LibPanel = ( guLibPanel * ) event.GetClientData();

2010

if( LibPanel )

2011

{

2012

gaugeid = m_MainStatusBar->AddGauge( LibPanel->GetName(), false );

2013

m_LibUpdateThread = new guLibUpdateThread( LibPanel, gaugeid );

2014

}

2015

else

2016

{

2017

gaugeid = m_MainStatusBar->AddGauge( _( "Library" ), false );

2018

if( m_LibPanel )

2019

{

2020

m_LibUpdateThread = new guLibUpdateThread( m_LibPanel, gaugeid );

2021

}

2022

else

2023

{

2024

m_LibUpdateThread = new guLibUpdateThread( m_Db, gaugeid );

2025

}

2026

}

1300

2027

}

1301

2028

1302

2029

// -------------------------------------------------------------------------------- //

1303

2030

void guMainFrame::OnForceUpdateLibrary( wxCommandEvent &event )

1304

2031

{

2032

guLogMessage( wxT( "The forced update started..." ) );

1305

2033

if( m_LibUpdateThread )

1306

2034

return;

1307

guConfig * Config = ( guConfig * ) guConfig::Get();

1308

Config->WriteNum( wxT( "LastUpdate" ), 0, wxT( "General" ) );

1309

int gaugeid = m_MainStatusBar->AddGauge( _( "Library" ), false );

1310

m_LibUpdateThread = new guLibUpdateThread( m_Db, gaugeid );

2035

guLibPanel * LibPanel = ( guLibPanel * ) event.GetClientData();

2036

if( LibPanel )

2037

{

2038

LibPanel->SetLastUpdate( 0 );

2039

}

2040

else

2041

{

2042

if( m_LibPanel )

2043

{

2044

m_LibPanel->SetLastUpdate( 0 );

2045

}

2046

else

2047

{

2048

guConfig * Config = ( guConfig * ) guConfig::Get();

2049

wxDateTime Now = wxDateTime::Now();

2050

Config->WriteNum( wxT( "LastUpdate" ), Now.GetTicks(), wxT( "General" ) );

2051

Config->Flush();

2052

}

2053

}

2054

OnUpdateLibrary( event );

1311

2055

}

1312

2056

1313

2057

// -------------------------------------------------------------------------------- //

1343

2087

//AddPendingEvent( event );

1344

2088

if( !m_LibUpdateThread )

1345

2089

{

1346

int gaugeid = m_MainStatusBar->AddGauge( _( "Library" ), false );

1347

m_LibUpdateThread = new guLibUpdateThread( m_Db, gaugeid, PathValue );

2090

int gaugeid;

2091

gaugeid = m_MainStatusBar->AddGauge( _( "Library" ), false );

2092

m_LibUpdateThread = new guLibUpdateThread( m_LibPanel, gaugeid );

1348

2093

}

1349

2094

else

1350

2095

{

1472

2217

}

1473

2218

1474

2219

// -------------------------------------------------------------------------------- //

2220

void guMainFrame::OnHelp( wxCommandEvent &event )

2221

{

2222

guWebExecute( wxT( "http://guayadeque.org/forums/index.php?p=/page/manual#TableOfContent" ) );

2223

}

2224

2225

// -------------------------------------------------------------------------------- //

2226

void guMainFrame::OnCommunity( wxCommandEvent &event )

2227

{

2228

guWebExecute( wxT( "http://guayadeque.org/forums/index.php?p=/discussions" ) );

2229

}

2230

2231

// -------------------------------------------------------------------------------- //

1475

2232

void guMainFrame::OnPlayerPlayListUpdateTitle( wxCommandEvent &event )

1476

2233

{

1477

2234

wxAuiPaneInfo &PaneInfo = m_AuiManager.GetPane( wxT( "PlayerPlayList" ) );

1502

2259

{

1503

2260

if( DirDialog->ShowModal() == wxID_OK )

1504

2261

{

1505

int GaugeId = m_MainStatusBar->AddGauge( _( "Copy To..." ) );

1506

guCopyToDirThread * CopyToDirThread = new guCopyToDirThread( DirDialog->GetPath().c_str(),

1507

Tracks, GaugeId );

1508

if( !CopyToDirThread )

2262

m_CopyToThreadMutex.Lock();

2263

2264

if( !m_CopyToThread )

1509

2265

{

1510

guLogError( wxT( "Could not create the CopyTo thread object" ) );

1511

delete Tracks;

2266

int GaugeId = m_MainStatusBar->AddGauge( _( "Copy To..." ), false );

2267

m_CopyToThread = new guCopyToThread( this, GaugeId );

1512

2268

}

1513

}

1514

else

1515

{

1516

delete Tracks;

2269

2270

guConfig * Config = ( guConfig * ) guConfig::Get();

2271

wxArrayString CopyToOptions = Config->ReadAStr( wxT( "Option"), wxEmptyString, wxT( "CopyTo") );

2272

wxArrayString SelCopyTo = wxStringTokenize( CopyToOptions[ event.GetInt() ], wxT( ":") );

2273

2274

while( SelCopyTo.Count() != 5 )

2275

SelCopyTo.Add( wxT( "0" ) );

2276

2277

m_CopyToThread->AddAction( Tracks, m_LibPanel, DirDialog->GetPath(),

2278

unescape_configlist_str( SelCopyTo[ 1 ] ),

2279

wxAtoi( SelCopyTo[ 2 ] ),

2280

wxAtoi( SelCopyTo[ 3 ] ),

2281

wxAtoi( SelCopyTo[ 4 ] ) );

2282

2283

m_CopyToThreadMutex.Unlock();

2284

1517

2285

}

1518

2286

DirDialog->Destroy();

1519

2287

}

1520

2288

}

2289

else

2290

{

2291

delete Tracks;

2292

}

2293

}

2294

}

2295

2296

// -------------------------------------------------------------------------------- //

2297

void guMainFrame::OnCopyTracksToDevice( wxCommandEvent &event )

2298

{

2299

guLogMessage( wxT( "guMainFrame::OnCopyTracksToDevice" ) );

2300

guTrackArray * Tracks = ( guTrackArray * ) event.GetClientData();

2301

if( Tracks )

2302

{

2303

if( Tracks->Count() )

2304

{

2305

int PortableIndex = event.GetInt();

2306

if( PortableIndex >= 0 && PortableIndex < ( int ) m_PortableMediaViewCtrls.Count() )

2307

{

2308

guPortableMediaViewCtrl * PortableMediaViewCtrl = m_PortableMediaViewCtrls[ PortableIndex ];

2309

2310

m_CopyToThreadMutex.Lock();

2311

2312

if( !m_CopyToThread )

2313

{

2314

int GaugeId = m_MainStatusBar->AddGauge( _( "Copy To..." ), false );

2315

m_CopyToThread = new guCopyToThread( this, GaugeId );

2316

}

2317

2318

m_CopyToThread->AddAction( Tracks, m_Db, PortableMediaViewCtrl );

2319

2320

m_CopyToThreadMutex.Unlock();

2321

2322

}

2323

else

2324

{

2325

guLogMessage( wxT( "Wrong portable device index in copy tracks to device command" ) );

2326

}

2327

}

2328

else

2329

{

2330

delete Tracks;

2331

}

2332

}

2333

}

2334

2335

// -------------------------------------------------------------------------------- //

2336

void guMainFrame::OnCopyPlayListToDevice( wxCommandEvent &event )

2337

{

2338

guLogMessage( wxT( "guMainFrame::OnCopyPlayListToDevice" ) );

2339

wxString * PlayListPath = ( wxString * ) event.GetClientData();

2340

if( PlayListPath )

2341

{

2342

int PortableIndex = event.GetInt();

2343

if( PortableIndex >= 0 && PortableIndex < ( int ) m_PortableMediaViewCtrls.Count() )

2344

{

2345

guPortableMediaViewCtrl * PortableMediaViewCtrl = m_PortableMediaViewCtrls[ PortableIndex ];

2346

2347

m_CopyToThreadMutex.Lock();

2348

2349

if( !m_CopyToThread )

2350

{

2351

int GaugeId = m_MainStatusBar->AddGauge( _( "Copy To..." ), false );

2352

m_CopyToThread = new guCopyToThread( this, GaugeId );

2353

}

2354

2355

m_CopyToThread->AddAction( PlayListPath, m_Db, PortableMediaViewCtrl );

2356

2357

m_CopyToThreadMutex.Unlock();

2358

2359

}

2360

else

2361

{

2362

guLogMessage( wxT( "Wrong portable device index in copy playlist to device command" ) );

2363

}

1521

2364

}

1522

2365

}

1523

2366

1684

2527

1685

2528

m_ViewLibPlayCounts->Check( m_LibPanel && m_LibPanel->IsPanelShown( guPANEL_LIBRARY_PLAYCOUNT ) );

1686

2529

m_ViewLibPlayCounts->Enable( IsEnabled );

2530

2531

if( m_LocationPanel )

2532

{

2533

m_LocationPanel->OnPanelVisibleChanged();

2534

}

1687

2535

}

1688

2536

1689

2537

// -------------------------------------------------------------------------------- //

1690

2538

void guMainFrame::OnLibraryShowPanel( wxCommandEvent &event )

1691

2539

{

1692

unsigned int PanelId = 0;

2540

int PanelId = 0;

1693

2541

1694

2542

switch( event.GetId() )

1695

2543

{

1750

2598

}

1751

2599

1752

2600

// -------------------------------------------------------------------------------- //

2601

void guMainFrame::OnJamendoShowPanel( wxCommandEvent &event )

2602

{

2603

int PanelId = 0;

2604

2605

switch( event.GetId() )

2606

{

2607

case ID_MENU_VIEW_JAMENDO_TEXTSEARCH :

2608

PanelId = guPANEL_LIBRARY_TEXTSEARCH;

2609

m_ViewJamTextSearch->Check( event.IsChecked() );

2610

break;

2611

2612

case ID_MENU_VIEW_JAMENDO_LABELS :

2613

PanelId = guPANEL_LIBRARY_LABELS;

2614

m_ViewJamLabels->Check( event.IsChecked() );

2615

break;

2616

2617

case ID_MENU_VIEW_JAMENDO_GENRES :

2618

PanelId = guPANEL_LIBRARY_GENRES;

2619

m_ViewJamGenres->Check( event.IsChecked() );

2620

break;

2621

2622

case ID_MENU_VIEW_JAMENDO_ARTISTS :

2623

PanelId = guPANEL_LIBRARY_ARTISTS;

2624

m_ViewJamArtists->Check( event.IsChecked() );

2625

break;

2626

2627

case ID_MENU_VIEW_JAMENDO_ALBUMS :

2628

PanelId = guPANEL_LIBRARY_ALBUMS;

2629

m_ViewJamAlbums->Check( event.IsChecked() );

2630

break;

2631

2632

case ID_MENU_VIEW_JAMENDO_YEARS :

2633

PanelId = guPANEL_LIBRARY_YEARS;

2634

m_ViewJamYears->Check( event.IsChecked() );

2635

break;

2636

2637

case ID_MENU_VIEW_JAMENDO_RATINGS :

2638

PanelId = guPANEL_LIBRARY_RATINGS;

2639

m_ViewJamRatings->Check( event.IsChecked() );

2640

break;

2641

2642

case ID_MENU_VIEW_JAMENDO_PLAYCOUNT :

2643

PanelId = guPANEL_LIBRARY_PLAYCOUNT;

2644

m_ViewJamPlayCounts->Check( event.IsChecked() );

2645

break;

2646

2647

case ID_MENU_VIEW_JAMENDO_COMPOSERS :

2648

PanelId = guPANEL_LIBRARY_COMPOSERS;

2649

m_ViewJamComposers->Check( event.IsChecked() );

2650

break;

2651

2652

case ID_MENU_VIEW_JAMENDO_ALBUMARTISTS :

2653

PanelId = guPANEL_LIBRARY_ALBUMARTISTS;

2654

m_ViewJamAlbumArtists->Check( event.IsChecked() );

2655

break;

2656

}

2657

2658

if( PanelId && m_JamendoPanel )

2659

m_JamendoPanel->ShowPanel( PanelId, event.IsChecked() );

2660

2661

}

2662

2663

// -------------------------------------------------------------------------------- //

2664

void guMainFrame::OnMagnatuneShowPanel( wxCommandEvent &event )

2665

{

2666

int PanelId = 0;

2667

2668

switch( event.GetId() )

2669

{

2670

case ID_MENU_VIEW_MAGNATUNE_TEXTSEARCH :

2671

PanelId = guPANEL_LIBRARY_TEXTSEARCH;

2672

m_ViewMagTextSearch->Check( event.IsChecked() );

2673

break;

2674

2675

case ID_MENU_VIEW_MAGNATUNE_LABELS :

2676

PanelId = guPANEL_LIBRARY_LABELS;

2677

m_ViewMagLabels->Check( event.IsChecked() );

2678

break;

2679

2680

case ID_MENU_VIEW_MAGNATUNE_GENRES :

2681

PanelId = guPANEL_LIBRARY_GENRES;

2682

m_ViewMagGenres->Check( event.IsChecked() );

2683

break;

2684

2685

case ID_MENU_VIEW_MAGNATUNE_ARTISTS :

2686

PanelId = guPANEL_LIBRARY_ARTISTS;

2687

m_ViewMagArtists->Check( event.IsChecked() );

2688

break;

2689

2690

case ID_MENU_VIEW_MAGNATUNE_ALBUMS :

2691

PanelId = guPANEL_LIBRARY_ALBUMS;

2692

m_ViewMagAlbums->Check( event.IsChecked() );

2693

break;

2694

2695

case ID_MENU_VIEW_MAGNATUNE_YEARS :

2696

PanelId = guPANEL_LIBRARY_YEARS;

2697

m_ViewMagYears->Check( event.IsChecked() );

2698

break;

2699

2700

case ID_MENU_VIEW_MAGNATUNE_RATINGS :

2701

PanelId = guPANEL_LIBRARY_RATINGS;

2702

m_ViewMagRatings->Check( event.IsChecked() );

2703

break;

2704

2705

case ID_MENU_VIEW_MAGNATUNE_PLAYCOUNT :

2706

PanelId = guPANEL_LIBRARY_PLAYCOUNT;

2707

m_ViewMagPlayCounts->Check( event.IsChecked() );

2708

break;

2709

2710

case ID_MENU_VIEW_MAGNATUNE_COMPOSERS :

2711

PanelId = guPANEL_LIBRARY_COMPOSERS;

2712

m_ViewMagComposers->Check( event.IsChecked() );

2713

break;

2714

2715

case ID_MENU_VIEW_MAGNATUNE_ALBUMARTISTS :

2716

PanelId = guPANEL_LIBRARY_ALBUMARTISTS;

2717

m_ViewMagAlbumArtists->Check( event.IsChecked() );

2718

break;

2719

}

2720

2721

if( PanelId && m_MagnatunePanel )

2722

m_MagnatunePanel->ShowPanel( PanelId, event.IsChecked() );

2723

2724

}

2725

2726

// -------------------------------------------------------------------------------- //

1753

2727

void guMainFrame::OnViewRadio( wxCommandEvent &event )

1754

2728

{

1755

2729

// guConfig * Config = ( guConfig * ) guConfig::Get();

1793

2767

m_ViewRadGenres->Check( m_RadioPanel && m_RadioPanel->IsPanelShown( guPANEL_RADIO_GENRES ) );

1794

2768

m_ViewRadGenres->Enable( IsEnabled );

1795

2769

2770

if( m_LocationPanel )

2771

{

2772

m_LocationPanel->OnPanelVisibleChanged();

2773

}

1796

2774

}

1797

2775

1798

2776

// -------------------------------------------------------------------------------- //

1903

2881

m_CatNotebook->Refresh();

1904

2882

1905

2883

m_ViewLastFM->Check( m_VisiblePanels & guPANEL_MAIN_LASTFM );

2884

2885

if( m_LocationPanel )

2886

{

2887

m_LocationPanel->OnPanelVisibleChanged();

2888

}

1906

2889

}

1907

2890

1908

2891

// -------------------------------------------------------------------------------- //

1911

2894

if( event.IsChecked() )

1912

2895

{

1913

2896

if( !m_LyricsPanel )

1914

m_LyricsPanel = new guLyricsPanel( m_CatNotebook, m_Db );

2897

{

2898

m_LyricsPanel = new guLyricsPanel( m_CatNotebook, m_Db, m_LyricSearchEngine );

2899

}

1915

2900

1916

2901

// CheckShowNotebook();

1917

2902

1936

2921

m_CatNotebook->Refresh();

1937

2922

1938

2923

m_ViewLyrics->Check( m_VisiblePanels & guPANEL_MAIN_LYRICS );

2924

2925

if( m_LocationPanel )

2926

{

2927

m_LocationPanel->OnPanelVisibleChanged();

2928

}

1939

2929

}

1940

2930

1941

2931

// -------------------------------------------------------------------------------- //

1976

2966

1977

2967

m_ViewPodDetails->Check( m_PodcastsPanel && m_PodcastsPanel->IsPanelShown( guPANEL_PODCASTS_DETAILS ) );

1978

2968

m_ViewPodDetails->Enable( m_ViewPodcasts->IsChecked() );

2969

2970

if( m_LocationPanel )

2971

{

2972

m_LocationPanel->OnPanelVisibleChanged();

2973

}

1979

2974

}

1980

2975

1981

2976

// -------------------------------------------------------------------------------- //

2010

3005

2011

3006

m_ViewAlbumBrowser->Check( m_VisiblePanels & guPANEL_MAIN_ALBUMBROWSER );

2012

3007

3008

if( m_LocationPanel )

3009

{

3010

m_LocationPanel->OnPanelVisibleChanged();

3011

}

2013

3012

}

2014

3013

2015

3014

// -------------------------------------------------------------------------------- //

2042

3041

m_CatNotebook->Refresh();

2043

3042

2044

3043

m_ViewFileBrowser->Check( m_VisiblePanels & guPANEL_MAIN_FILEBROWSER );

3044

3045

if( m_LocationPanel )

3046

{

3047

m_LocationPanel->OnPanelVisibleChanged();

3048

}

3049

}

3050

3051

// -------------------------------------------------------------------------------- //

3052

void guMainFrame::OnViewJamendo( wxCommandEvent &event )

3053

{

3054

bool IsEnabled = event.IsChecked();

3055

if( IsEnabled )

3056

{

3057

if( !m_JamendoDb )

3058

m_JamendoDb = new guJamendoLibrary( wxGetHomeDir() + wxT( "/.guayadeque/Jamendo/Jamendo.db" ) );

3059

3060

if( !m_JamendoPanel )

3061

m_JamendoPanel = new guJamendoPanel( m_CatNotebook, m_JamendoDb, m_PlayerPanel, wxT( "Jam" ) );

3062

3063

InsertTabPanel( m_JamendoPanel, 8, wxT( "Jamendo" ) );

3064

3065

m_VisiblePanels |= guPANEL_MAIN_JAMENDO;

3066

}

3067

else

3068

{

3069

RemoveTabPanel( m_JamendoPanel );

3070

m_VisiblePanels ^= guPANEL_MAIN_JAMENDO;

3071

}

3072

m_CatNotebook->Refresh();

3073

3074

m_ViewJamendo->Check( m_VisiblePanels & guPANEL_MAIN_JAMENDO );

3075

3076

m_ViewJamTextSearch->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_TEXTSEARCH ) );

3077

m_ViewJamTextSearch->Enable( IsEnabled );

3078

3079

m_ViewJamLabels->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_LABELS ) );

3080

m_ViewJamLabels->Enable( IsEnabled );

3081

3082

m_ViewJamGenres->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_GENRES ) );

3083

m_ViewJamGenres->Enable( IsEnabled );

3084

3085

m_ViewJamArtists->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_ARTISTS ) );

3086

m_ViewJamArtists->Enable( IsEnabled );

3087

3088

m_ViewJamComposers->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_COMPOSERS ) );

3089

m_ViewJamComposers->Enable( IsEnabled );

3090

3091

m_ViewJamAlbumArtists->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_ALBUMARTISTS ) );

3092

m_ViewJamAlbumArtists->Enable( IsEnabled );

3093

3094

m_ViewJamAlbums->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_ALBUMS ) );

3095

m_ViewJamAlbums->Enable( IsEnabled );

3096

3097

m_ViewJamYears->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_YEARS ) );

3098

m_ViewJamYears->Enable( IsEnabled );

3099

3100

m_ViewJamRatings->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_RATINGS ) );

3101

m_ViewJamRatings->Enable( IsEnabled );

3102

3103

m_ViewJamPlayCounts->Check( m_JamendoPanel && m_JamendoPanel->IsPanelShown( guPANEL_LIBRARY_PLAYCOUNT ) );

3104

m_ViewJamPlayCounts->Enable( IsEnabled );

3105

3106

if( m_LocationPanel )

3107

{

3108

m_LocationPanel->OnPanelVisibleChanged();

3109

}

3110

}

3111

3112

// -------------------------------------------------------------------------------- //

3113

void guMainFrame::OnViewMagnatune( wxCommandEvent &event )

3114

{

3115

bool IsEnabled = event.IsChecked();

3116

if( IsEnabled )

3117

{

3118

if( !m_MagnatuneDb )

3119

m_MagnatuneDb = new guMagnatuneLibrary( wxGetHomeDir() + wxT( "/.guayadeque/Magnatune/Magnatune.db" ) );

3120

3121

if( !m_MagnatunePanel )

3122

m_MagnatunePanel = new guMagnatunePanel( m_CatNotebook, m_MagnatuneDb, m_PlayerPanel, wxT( "Mag" ) );

3123

3124

InsertTabPanel( m_MagnatunePanel, 9, wxT( "Magnatune" ) );

3125

3126

m_VisiblePanels |= guPANEL_MAIN_MAGNATUNE;

3127

}

3128

else

3129

{

3130

RemoveTabPanel( m_MagnatunePanel );

3131

m_VisiblePanels ^= guPANEL_MAIN_MAGNATUNE;

3132

}

3133

m_CatNotebook->Refresh();

3134

3135

m_ViewMagnatune->Check( m_VisiblePanels & guPANEL_MAIN_MAGNATUNE );

3136

3137

m_ViewMagTextSearch->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_TEXTSEARCH ) );

3138

m_ViewMagTextSearch->Enable( IsEnabled );

3139

3140

m_ViewMagLabels->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_LABELS ) );

3141

m_ViewMagLabels->Enable( IsEnabled );

3142

3143

m_ViewMagGenres->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_GENRES ) );

3144

m_ViewMagGenres->Enable( IsEnabled );

3145

3146

m_ViewMagArtists->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_ARTISTS ) );

3147

m_ViewMagArtists->Enable( IsEnabled );

3148

3149

m_ViewMagComposers->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_COMPOSERS ) );

3150

m_ViewMagComposers->Enable( IsEnabled );

3151

3152

m_ViewMagAlbumArtists->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_ALBUMARTISTS ) );

3153

m_ViewMagAlbumArtists->Enable( IsEnabled );

3154

3155

m_ViewMagAlbums->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_ALBUMS ) );

3156

m_ViewMagAlbums->Enable( IsEnabled );

3157

3158

m_ViewMagYears->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_YEARS ) );

3159

m_ViewMagYears->Enable( IsEnabled );

3160

3161

m_ViewMagRatings->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_RATINGS ) );

3162

m_ViewMagRatings->Enable( IsEnabled );

3163

3164

m_ViewMagPlayCounts->Check( m_MagnatunePanel && m_MagnatunePanel->IsPanelShown( guPANEL_LIBRARY_PLAYCOUNT ) );

3165

m_ViewMagPlayCounts->Enable( IsEnabled );

3166

3167

if( m_LocationPanel )

3168

{

3169

m_LocationPanel->OnPanelVisibleChanged();

3170

}

3171

}

3172

3173

// -------------------------------------------------------------------------------- //

3174

void guMainFrame::OnViewPlayLists( wxCommandEvent &event )

3175

{

3176

if( event.IsChecked() )

3177

{

3178

if( !m_PlayListPanel )

3179

m_PlayListPanel = new guPlayListPanel( m_CatNotebook, m_Db, m_PlayerPanel );

3180

3181

// CheckShowNotebook();

3182

3183

// m_CatNotebook->InsertPage( wxMin( 4, m_CatNotebook->GetPageCount() ), m_PlayListPanel, _( "PlayLists" ), true );

3184

InsertTabPanel( m_PlayListPanel, 4, _( "PlayLists" ) );

3185

3186

m_VisiblePanels |= guPANEL_MAIN_PLAYLISTS;

3187

}

3188

else

3189

{

3190

// int PageIndex = m_CatNotebook->GetPageIndex( m_PlayListPanel );

3191

// if( PageIndex >= 0 )

3192

// {

3193

// m_CatNotebook->RemovePage( PageIndex );

3194

// }

3195

3196

// CheckHideNotebook();

3197

RemoveTabPanel( m_PlayListPanel );

3198

3199

m_VisiblePanels ^= guPANEL_MAIN_PLAYLISTS;

3200

}

3201

m_CatNotebook->Refresh();

3202

3203

m_ViewPlayLists->Check( m_VisiblePanels & guPANEL_MAIN_PLAYLISTS );

3204

3205

m_ViewPLTextSearch->Check( m_PlayListPanel && m_PlayListPanel->IsPanelShown( guPANEL_PLAYLIST_TEXTSEARCH ) );

3206

m_ViewPLTextSearch->Enable( m_ViewPlayLists->IsChecked() );

3207

3208

if( m_LocationPanel )

3209

{

3210

m_LocationPanel->OnPanelVisibleChanged();

3211

}

3212

}

3213

3214

// -------------------------------------------------------------------------------- //

3215

void guMainFrame::OnViewPortableDevice( wxCommandEvent &event )

3216

{

3217

bool IsEnabled = event.IsChecked();

3218

int CmdId = ( event.GetId() - ID_MENU_VIEW_PORTABLE_DEVICE ) % 20;

3219

int DeviceNum = ( event.GetId() - ID_MENU_VIEW_PORTABLE_DEVICE ) / 20;

3220

int BaseCommand = ID_MENU_VIEW_PORTABLE_DEVICE + ( DeviceNum * guPORTABLEDEVICE_COMMANDS_COUNT );

3221

guPortableMediaViewCtrl * PortableMediaViewCtrl = GetPortableMediaViewCtrl( BaseCommand );

3222

guLogMessage( wxT( "Its the device %i and cmd %i" ), DeviceNum, CmdId );

3223

3224

if( IsEnabled )

3225

{

3226

if( !PortableMediaViewCtrl )

3227

{

3228

guGIO_Mount * DeviceMount = m_VolumeMonitor->GetMount( DeviceNum );

3229

if( DeviceMount)

3230

{

3231

PortableMediaViewCtrl = new guPortableMediaViewCtrl( this, DeviceMount, event.GetId() );

3232

guPortableMediaLibPanel * PortableMediaLibPanel = PortableMediaViewCtrl->CreateLibPanel( m_CatNotebook, m_PlayerPanel );

3233

3234

InsertTabPanel( PortableMediaLibPanel, 10, PortableMediaViewCtrl->DeviceName() + wxT( " : " ) + _( "Library" ) );

3235

m_PortableMediaViewCtrls.Add( PortableMediaViewCtrl );

3236

3237

PortableMediaLibPanel->SetPanelActive( m_PortableMediaViewCtrls.Count() - 1 );

3238

3239

CreatePortablePlayersMenu( m_PortableDevicesMenu );

3240

3241

guConfig * Config = ( guConfig * ) guConfig::Get();

3242

if( Config->ReadBool( wxT( "UpdateOnStart" ), true, wxT( "PortableDevice" ) ) )

3243

PortableMediaLibPanel->DoUpdate( true );

3244

}

3245

else

3246

{

3247

guLogMessage( wxT( "Could not find the mount device object %i" ), DeviceNum );

3248

}

3249

}

3250

else

3251

{

3252

int VisiblePanels = PortableMediaViewCtrl->VisiblePanels();

3253

if( CmdId == 0 ) // Its the library panel

3254

{

3255

if( !( VisiblePanels & guPANEL_MAIN_LIBRARY ) )

3256

{

3257

guPortableMediaLibPanel * PortableMediaLibPanel = PortableMediaViewCtrl->CreateLibPanel( m_CatNotebook, m_PlayerPanel );

3258

3259

InsertTabPanel( PortableMediaLibPanel, 10, PortableMediaViewCtrl->DeviceName() + wxT( " : " ) + _( "Library" ) );

3260

//m_PortableMediaViewCtrls.Add( PortableMediaViewCtrl ); // Sure about this ?

3261

3262

PortableMediaLibPanel->SetPanelActive( m_PortableMediaViewCtrls.Count() - 1 );

3263

3264

CreatePortablePlayersMenu( m_PortableDevicesMenu );

3265

3266

guConfig * Config = ( guConfig * ) guConfig::Get();

3267

if( Config->ReadBool( wxT( "UpdateDeviceOnStart" ), true, wxT( "PortableDevice" ) ) )

3268

PortableMediaLibPanel->DoUpdate( true );

3269

}

3270

}

3271

else if( CmdId == 18 ) // Its the Playlists panel

3272

{

3273

if( !( VisiblePanels & guPANEL_MAIN_PLAYLISTS ) )

3274

{

3275

guPortableMediaPlayListPanel * PortableMediaPlayListPanel = PortableMediaViewCtrl->CreatePlayListPanel( m_CatNotebook, m_PlayerPanel );

3276

3277

InsertTabPanel( PortableMediaPlayListPanel, 10, PortableMediaViewCtrl->DeviceName() + wxT( " : " ) + _( "PlayLists" ) );

3278

3279

//PortableMediaLibPanel->SetPanelActive( m_PortableMediaViewCtrls.Count() - 1 );

3280

3281

CreatePortablePlayersMenu( m_PortableDevicesMenu );

3282

}

3283

}

3284

else if( CmdId == 19 ) // Its the AlbumBrowser panel

3285

{

3286

if( !( VisiblePanels & guPANEL_MAIN_ALBUMBROWSER ) )

3287

{

3288

guPortableMediaAlbumBrowser * PortableMediaAlbumBrowser = PortableMediaViewCtrl->CreateAlbumBrowser( m_CatNotebook, m_PlayerPanel );

3289

3290

InsertTabPanel( PortableMediaAlbumBrowser, 10, PortableMediaViewCtrl->DeviceName() + wxT( " : " ) + _( "Album Browser" ) );

3291

3292

//PortableMediaLibPanel->SetPanelActive( m_PortableMediaViewCtrls.Count() - 1 );

3293

3294

CreatePortablePlayersMenu( m_PortableDevicesMenu );

3295

}

3296

}

3297

}

3298

}

3299

else

3300

{

3301

if( PortableMediaViewCtrl )

3302

{

3303

if( CmdId == 0 ) // Its the library panel

3304

{

3305

guPortableMediaLibPanel * PortableMediaLibPanel = PortableMediaViewCtrl->LibPanel();

3306

if( PortableMediaLibPanel )

3307

{

3308

if( m_LibUpdateThread )

3309

{

3310

if( m_LibUpdateThread->LibPanel() == ( guLibPanel * ) PortableMediaLibPanel )

3311

{

3312

m_LibUpdateThread->Pause();

3313

m_LibUpdateThread->Delete();

3314

m_LibUpdateThread = NULL;

3315

}

3316

}

3317

3318

if( m_LibCleanThread )

3319

{

3320

if( m_LibCleanThread->LibPanel() == ( guLibPanel * ) PortableMediaLibPanel )

3321

{

3322

m_LibCleanThread->Pause();

3323

m_LibCleanThread->Delete();

3324

m_LibCleanThread = NULL;

3325

}

3326

}

3327

3328

RemoveTabPanel( PortableMediaLibPanel );

3329

PortableMediaViewCtrl->DestroyLibPanel();

3330

}

3331

}

3332

else if( CmdId == 18 ) // Its the Playlists panel

3333

{

3334

guPortableMediaPlayListPanel * PortableMediaPlayListPanel = PortableMediaViewCtrl->PlayListPanel();

3335

if( PortableMediaPlayListPanel )

3336

{

3337

RemoveTabPanel( PortableMediaPlayListPanel );

3338

PortableMediaViewCtrl->DestroyPlayListPanel();

3339

}

3340

}

3341

else if( CmdId == 19 ) // Its the AlbumBrowser panel

3342

{

3343

guPortableMediaAlbumBrowser * PortableMediaAlbumBrowser = PortableMediaViewCtrl->AlbumBrowserPanel();

3344

if( PortableMediaAlbumBrowser )

3345

{

3346

RemoveTabPanel( PortableMediaAlbumBrowser );

3347

PortableMediaViewCtrl->DestroyAlbumBrowser();

3348

}

3349

}

3350

3351

if( !PortableMediaViewCtrl->VisiblePanels() )

3352

{

3353

int DeviceIndex = m_PortableMediaViewCtrls.Index( PortableMediaViewCtrl );

3354

delete m_PortableMediaViewCtrls[ DeviceIndex ];

3355

m_PortableMediaViewCtrls.RemoveAt( DeviceIndex );

3356

}

3357

3358

CreatePortablePlayersMenu( m_PortableDevicesMenu );

3359

}

3360

}

3361

3362

m_CatNotebook->Refresh();

3363

3364

if( m_LocationPanel )

3365

{

3366

m_LocationPanel->OnPanelVisibleChanged();

3367

}

3368

}

3369

3370

// -------------------------------------------------------------------------------- //

3371

void guMainFrame::OnViewPortableDevicePanel( wxCommandEvent &event )

3372

{

3373

int PanelId = ( event.GetId() - ID_MENU_VIEW_PORTABLE_DEVICE ) % 20;

3374

int DeviceNum = ( event.GetId() - ID_MENU_VIEW_PORTABLE_DEVICE ) / 20;

3375

guLogMessage( wxT( "Its the device %i pane %i" ), DeviceNum, PanelId );

3376

3377

guPortableMediaViewCtrl * PortableMediaViewCtrl = m_PortableMediaViewCtrls[ DeviceNum ];

3378

3379

switch( PanelId )

3380

{

3381

case guLIBRARY_ELEMENT_TEXTSEARCH :

3382

PanelId = guPANEL_LIBRARY_TEXTSEARCH;

3383

break;

3384

3385

case guLIBRARY_ELEMENT_LABELS :

3386

PanelId = guPANEL_LIBRARY_LABELS;

3387

break;

3388

3389

case guLIBRARY_ELEMENT_GENRES :

3390

PanelId = guPANEL_LIBRARY_GENRES;

3391

break;

3392

3393

case guLIBRARY_ELEMENT_ARTISTS :

3394

PanelId = guPANEL_LIBRARY_ARTISTS;

3395

break;

3396

3397

case guLIBRARY_ELEMENT_COMPOSERS :

3398

PanelId = guPANEL_LIBRARY_COMPOSERS;

3399

break;

3400

3401

case guLIBRARY_ELEMENT_ALBUMARTISTS :

3402

PanelId = guPANEL_LIBRARY_ALBUMARTISTS;

3403

break;

3404

3405

case guLIBRARY_ELEMENT_ALBUMS :

3406

PanelId = guPANEL_LIBRARY_ALBUMS;

3407

break;

3408

3409

case guLIBRARY_ELEMENT_YEARS :

3410

PanelId = guPANEL_LIBRARY_YEARS;

3411

break;

3412

3413

case guLIBRARY_ELEMENT_RATINGS :

3414

PanelId = guPANEL_LIBRARY_RATINGS;

3415

break;

3416

3417

case guLIBRARY_ELEMENT_PLAYCOUNT :

3418

PanelId = guPANEL_LIBRARY_PLAYCOUNT;

3419

break;

3420

}

3421

3422

if( PanelId && PortableMediaViewCtrl )

3423

{

3424

if( PortableMediaViewCtrl->LibPanel() )

3425

PortableMediaViewCtrl->LibPanel()->ShowPanel( PanelId, event.IsChecked() );

3426

}

3427

3428

CreatePortablePlayersMenu( m_PortableDevicesMenu );

2045

3429

}

2046

3430

2047

3431

// -------------------------------------------------------------------------------- //

2105

3489

}

2106

3490

2107

3491

// -------------------------------------------------------------------------------- //

2108

void guMainFrame::OnViewPlayLists( wxCommandEvent &event )

2109

{

2110

if( event.IsChecked() )

2111

{

2112

if( !m_PlayListPanel )

2113

m_PlayListPanel = new guPlayListPanel( m_CatNotebook, m_Db, m_PlayerPanel );

2114

2115

// CheckShowNotebook();

2116

2117

// m_CatNotebook->InsertPage( wxMin( 4, m_CatNotebook->GetPageCount() ), m_PlayListPanel, _( "PlayLists" ), true );

2118

InsertTabPanel( m_PlayListPanel, 4, _( "PlayLists" ) );

2119

2120

m_VisiblePanels |= guPANEL_MAIN_PLAYLISTS;

2121

}

2122

else

2123

{

2124

// int PageIndex = m_CatNotebook->GetPageIndex( m_PlayListPanel );

2125

// if( PageIndex >= 0 )

2126

// {

2127

// m_CatNotebook->RemovePage( PageIndex );

2128

// }

2129

2130

// CheckHideNotebook();

2131

RemoveTabPanel( m_PlayListPanel );

2132

2133

m_VisiblePanels ^= guPANEL_MAIN_PLAYLISTS;

2134

}

2135

m_CatNotebook->Refresh();

2136

2137

m_ViewPlayLists->Check( m_VisiblePanels & guPANEL_MAIN_PLAYLISTS );

2138

2139

m_ViewPLTextSearch->Check( m_PlayListPanel && m_PlayListPanel->IsPanelShown( guPANEL_PLAYLIST_TEXTSEARCH ) );

2140

m_ViewPLTextSearch->Enable( m_ViewPlayLists->IsChecked() );

2141

}

2142

2143

// -------------------------------------------------------------------------------- //

2144

3492

void guMainFrame::OnSelectTrack( wxCommandEvent &event )

2145

3493

{

2146

if( event.GetExtraLong() == guTRACK_TYPE_PODCAST )

3494

int Type = event.GetExtraLong();

3495

if( Type == guTRACK_TYPE_PODCAST )

2147

3496

{

2148

3497

if( m_PodcastsPanel )

2149

3498

{

2155

3504

m_PodcastsPanel->SelectPodcast( event.GetInt() );

2156

3505

}

2157

3506

}

3507

else if( Type == guTRACK_TYPE_JAMENDO )

3508

{

3509

if( m_JamendoPanel )

3510

{

3511

int PaneIndex = m_CatNotebook->GetPageIndex( m_JamendoPanel );

3512

if( PaneIndex != wxNOT_FOUND )

3513

{

3514

m_CatNotebook->SetSelection( PaneIndex );

3515

}

3516

m_JamendoPanel->SelectTrack( event.GetInt() );

3517

}

3518

}

3519

else if( Type == guTRACK_TYPE_MAGNATUNE )

3520

{

3521

if( m_MagnatunePanel )

3522

{

3523

int PaneIndex = m_CatNotebook->GetPageIndex( m_MagnatunePanel );

3524

if( PaneIndex != wxNOT_FOUND )

3525

{

3526

m_CatNotebook->SetSelection( PaneIndex );

3527

}

3528

m_MagnatunePanel->SelectTrack( event.GetInt() );

3529

}

3530

}

2158

3531

else

2159

3532

{

2160

if( m_LibPanel )

3533

guLibPanel * LibPanel = ( guLibPanel * ) event.GetClientData();

3534

if( !LibPanel )

3535

LibPanel = m_LibPanel;

3536

if( LibPanel )

2161

3537

{

2162

int PaneIndex = m_CatNotebook->GetPageIndex( m_LibPanel );

3538

int PaneIndex = m_CatNotebook->GetPageIndex( LibPanel );

2163

3539

if( PaneIndex != wxNOT_FOUND )

2164

3540

{

2165

3541

m_CatNotebook->SetSelection( PaneIndex );

2166

3542

}

2167

m_LibPanel->SelectTrack( event.GetInt() );

3543

LibPanel->SelectTrack( event.GetInt() );

2168

3544

}

2169

3545

}

2170

3546

}

2172

3548

// -------------------------------------------------------------------------------- //

2173

3549

void guMainFrame::OnSelectAlbum( wxCommandEvent &event )

2174

3550

{

2175

if( event.GetExtraLong() == guTRACK_TYPE_PODCAST )

3551

int Type = event.GetExtraLong();

3552

if( Type == guTRACK_TYPE_PODCAST )

2176

3553

{

2177

3554

if( m_PodcastsPanel )

2178

3555

{

2184

3561

m_PodcastsPanel->SelectChannel( event.GetInt() );

2185

3562

}

2186

3563

}

3564

else if( Type == guTRACK_TYPE_JAMENDO )

3565

{

3566

if( m_JamendoPanel )

3567

{

3568

int PaneIndex = m_CatNotebook->GetPageIndex( m_JamendoPanel );

3569

if( PaneIndex != wxNOT_FOUND )

3570

{

3571

m_CatNotebook->SetSelection( PaneIndex );

3572

}

3573

m_JamendoPanel->SelectAlbum( event.GetInt() );

3574

}

3575

}

3576

else if( Type == guTRACK_TYPE_MAGNATUNE )

3577

{

3578

if( m_MagnatunePanel )

3579

{

3580

int PaneIndex = m_CatNotebook->GetPageIndex( m_MagnatunePanel );

3581

if( PaneIndex != wxNOT_FOUND )

3582

{

3583

m_CatNotebook->SetSelection( PaneIndex );

3584

}

3585

m_MagnatunePanel->SelectAlbum( event.GetInt() );

3586

}

3587

}

2187

3588

else

2188

3589

{

2189

if( m_LibPanel )

3590

guLibPanel * LibPanel = ( guLibPanel * ) event.GetClientData();

3591

if( !LibPanel )

3592

LibPanel = m_LibPanel;

3593

if( LibPanel )

2190

3594

{

2191

int PaneIndex = m_CatNotebook->GetPageIndex( m_LibPanel );

3595

int PaneIndex = m_CatNotebook->GetPageIndex( LibPanel );

2192

3596

if( PaneIndex != wxNOT_FOUND )

2193

3597

{

2194

3598

m_CatNotebook->SetSelection( PaneIndex );

2195

3599

}

2196

m_LibPanel->SelectAlbum( event.GetInt() );

3600

LibPanel->SelectAlbum( event.GetInt() );

2197

3601

}

2198

3602

}

2199

3603

}

2201

3605

// -------------------------------------------------------------------------------- //

2202

3606

void guMainFrame::OnSelectArtist( wxCommandEvent &event )

2203

3607

{

2204

if( event.GetExtraLong() == guTRACK_TYPE_PODCAST )

3608

int Type = event.GetExtraLong();

3609

if( Type == guTRACK_TYPE_PODCAST )

2205

3610

{

2206

3611

return;

2207

3612

}

3613

else if( Type == guTRACK_TYPE_JAMENDO )

3614

{

3615

if( m_JamendoPanel )

3616

{

3617

int PaneIndex = m_CatNotebook->GetPageIndex( m_JamendoPanel );

3618

if( PaneIndex != wxNOT_FOUND )

3619

{

3620

m_CatNotebook->SetSelection( PaneIndex );

3621

}

3622

m_JamendoPanel->SelectArtist( event.GetInt() );

3623

}

3624

}

3625

else if( Type == guTRACK_TYPE_MAGNATUNE )

3626

{

3627

if( m_MagnatunePanel )

3628

{

3629

int PaneIndex = m_CatNotebook->GetPageIndex( m_MagnatunePanel );

3630

if( PaneIndex != wxNOT_FOUND )

3631

{

3632

m_CatNotebook->SetSelection( PaneIndex );

3633

}

3634

m_MagnatunePanel->SelectArtist( event.GetInt() );

3635

}

3636

}

2208

3637

else

2209

3638

{

2210

if( m_LibPanel )

3639

guLibPanel * LibPanel = ( guLibPanel * ) event.GetClientData();

3640

if( !LibPanel )

3641

LibPanel = m_LibPanel;

3642

if( LibPanel )

2211

3643

{

2212

int PaneIndex = m_CatNotebook->GetPageIndex( m_LibPanel );

3644

int PaneIndex = m_CatNotebook->GetPageIndex( LibPanel );

2213

3645

if( PaneIndex != wxNOT_FOUND )

2214

3646

{

2215

3647

m_CatNotebook->SetSelection( PaneIndex );

2216

3648

}

2217

m_LibPanel->SelectArtist( event.GetInt() );

3649

LibPanel->SelectArtist( event.GetInt() );

2218

3650

}

2219

3651

}

2220

3652

}

2222

3654

// -------------------------------------------------------------------------------- //

2223

3655

void guMainFrame::OnSelectYear( wxCommandEvent &event )

2224

3656

{

2225

if( m_LibPanel )

2226

{

2227

int PaneIndex = m_CatNotebook->GetPageIndex( m_LibPanel );

2228

if( PaneIndex != wxNOT_FOUND )

2229

{

2230

m_CatNotebook->SetSelection( PaneIndex );

2231

}

2232

m_LibPanel->SelectYear( event.GetInt() );

3657

int Type = event.GetExtraLong();

3658

if( Type == guTRACK_TYPE_JAMENDO )

3659

{

3660

if( m_JamendoPanel )

3661

{

3662

int PaneIndex = m_CatNotebook->GetPageIndex( m_JamendoPanel );

3663

if( PaneIndex != wxNOT_FOUND )

3664

{

3665

m_CatNotebook->SetSelection( PaneIndex );

3666

}

3667

m_JamendoPanel->SelectYear( event.GetInt() );

3668

}

3669

}

3670

else if( Type == guTRACK_TYPE_MAGNATUNE )

3671

{

3672

if( m_MagnatunePanel )

3673

{

3674

int PaneIndex = m_CatNotebook->GetPageIndex( m_MagnatunePanel );

3675

if( PaneIndex != wxNOT_FOUND )

3676

{

3677

m_CatNotebook->SetSelection( PaneIndex );

3678

}

3679

m_MagnatunePanel->SelectYear( event.GetInt() );

3680

}

3681

}

3682

else

3683

{

3684

guLibPanel * LibPanel = ( guLibPanel * ) event.GetClientData();

3685

if( !LibPanel )

3686

LibPanel = m_LibPanel;

3687

if( LibPanel )

3688

{

3689

int PaneIndex = m_CatNotebook->GetPageIndex( LibPanel );

3690

if( PaneIndex != wxNOT_FOUND )

3691

{

3692

m_CatNotebook->SetSelection( PaneIndex );

3693

}

3694

LibPanel->SelectYear( event.GetInt() );

3695

}

2233

3696

}

2234

3697

}

2235

3698

2236

3699

// -------------------------------------------------------------------------------- //

2237

3700

void guMainFrame::OnSelectGenre( wxCommandEvent &event )

2238

3701

{

2239

if( m_LibPanel )

2240

{

2241

int PaneIndex = m_CatNotebook->GetPageIndex( m_LibPanel );

2242

if( PaneIndex != wxNOT_FOUND )

2243

{

2244

m_CatNotebook->SetSelection( PaneIndex );

2245

}

2246

wxArrayInt Genres;

2247

Genres.Add( event.GetInt() );

2248

m_LibPanel->SelectGenres( &Genres );

2249

}

3702

int Type = event.GetExtraLong();

3703

if( Type == guTRACK_TYPE_JAMENDO )

3704

{

3705

if( m_JamendoPanel )

3706

{

3707

int PaneIndex = m_CatNotebook->GetPageIndex( m_JamendoPanel );

3708

if( PaneIndex != wxNOT_FOUND )

3709

{

3710

m_CatNotebook->SetSelection( PaneIndex );

3711

}

3712

wxArrayInt Genres;

3713

Genres.Add( event.GetInt() );

3714

m_JamendoPanel->SelectGenres( &Genres );

3715

}

3716

}

3717

else if( Type == guTRACK_TYPE_MAGNATUNE )

3718

{

3719

if( m_MagnatunePanel )

3720

{

3721

int PaneIndex = m_CatNotebook->GetPageIndex( m_MagnatunePanel );

3722

if( PaneIndex != wxNOT_FOUND )

3723

{

3724

m_CatNotebook->SetSelection( PaneIndex );

3725

}

3726

wxArrayInt Genres;

3727

Genres.Add( event.GetInt() );

3728

m_MagnatunePanel->SelectGenres( &Genres );

3729

}

3730

}

3731

else

3732

{

3733

guLibPanel * LibPanel = ( guLibPanel * ) event.GetClientData();

3734

if( !LibPanel )

3735

LibPanel = m_LibPanel;

3736

if( LibPanel )

3737

{

3738

int PaneIndex = m_CatNotebook->GetPageIndex( LibPanel );

3739

if( PaneIndex != wxNOT_FOUND )

3740

{

3741

m_CatNotebook->SetSelection( PaneIndex );

3742

}

3743

wxArrayInt Genres;

3744

Genres.Add( event.GetInt() );

3745

LibPanel->SelectGenres( &Genres );

3746

}

3747

}

3748

}

3749

3750

// -------------------------------------------------------------------------------- //

3751

void guMainFrame::OnSelectLocation( wxCommandEvent &event )

3752

{

3753

int PanelIndex = wxNOT_FOUND;

3754

switch( event.GetInt() )

3755

{

3756

case ID_MENU_VIEW_LIBRARY :

3757

PanelIndex = m_CatNotebook->GetPageIndex( m_LibPanel );

3758

break;

3759

3760

case ID_MENU_VIEW_RADIO :

3761

PanelIndex = m_CatNotebook->GetPageIndex( m_RadioPanel );

3762

break;

3763

3764

case ID_MENU_VIEW_LASTFM :

3765

PanelIndex = m_CatNotebook->GetPageIndex( m_LastFMPanel );

3766

break;

3767

3768

case ID_MENU_VIEW_LYRICS :

3769

PanelIndex = m_CatNotebook->GetPageIndex( m_LyricsPanel );

3770

break;

3771

3772

case ID_MENU_VIEW_PLAYLISTS :

3773

PanelIndex = m_CatNotebook->GetPageIndex( m_PlayListPanel );

3774

break;

3775

3776

case ID_MENU_VIEW_PODCASTS :

3777

PanelIndex = m_CatNotebook->GetPageIndex( m_PodcastsPanel );

3778

break;

3779

3780

case ID_MENU_VIEW_JAMENDO :

3781

PanelIndex = m_CatNotebook->GetPageIndex( m_JamendoPanel );

3782

break;

3783

3784

case ID_MENU_VIEW_MAGNATUNE :

3785

PanelIndex = m_CatNotebook->GetPageIndex( m_MagnatunePanel );

3786

break;

3787

3788

case ID_MENU_VIEW_ALBUMBROWSER :

3789

PanelIndex = m_CatNotebook->GetPageIndex( m_AlbumBrowserPanel );

3790

break;

3791

3792

case ID_MENU_VIEW_FILEBROWSER :

3793

PanelIndex = m_CatNotebook->GetPageIndex( m_FileBrowserPanel );

3794

break;

3795

3796

default : // Must be a portable device

3797

int CmdId = ( event.GetInt() - ID_MENU_VIEW_PORTABLE_DEVICE ) % 20;

3798

int DeviceNum = ( event.GetInt() - ID_MENU_VIEW_PORTABLE_DEVICE ) / 20;

3799

guPortableMediaViewCtrl * PortableMediaViewCtrl = m_PortableMediaViewCtrls[ DeviceNum ];

3800

if( CmdId == 0 ) // Library

3801

PanelIndex = m_CatNotebook->GetPageIndex( PortableMediaViewCtrl->LibPanel() );

3802

else if( CmdId == 18 ) // PlayList

3803

PanelIndex = m_CatNotebook->GetPageIndex( PortableMediaViewCtrl->PlayListPanel() );

3804

else if( CmdId == 19 ) // AlbumBrowser

3805

PanelIndex = m_CatNotebook->GetPageIndex( PortableMediaViewCtrl->AlbumBrowserPanel() );

3806

3807

break;

3808

3809

}

3810

3811

if( PanelIndex != wxNOT_FOUND )

3812

{

3813

m_CatNotebook->SetSelection( PanelIndex );

3814

}

3815

if( m_LocationPanel )

3816

m_LocationPanel->SetFocus();

2250

3817

}

2251

3818

2252

3819

// -------------------------------------------------------------------------------- //

2300

3867

// -------------------------------------------------------------------------------- //

2301

3868

void guMainFrame::OnPlayListUpdated( wxCommandEvent &event )

2302

3869

{

2303

if( m_PlayListPanel )

2304

m_PlayListPanel->PlayListUpdated();

2305

2306

if( m_PlayerFilters )

2307

m_PlayerFilters->UpdateFilters();

3870

guLibPanel * LibPanel = ( guLibPanel * ) event.GetClientData();

3871

if( !LibPanel )

3872

{

3873

if( m_PlayListPanel )

3874

m_PlayListPanel->PlayListUpdated();

3875

3876

if( m_PlayerFilters )

3877

m_PlayerFilters->UpdateFilters();

3878

3879

}

3880

else

3881

{

3882

guPortableMediaViewCtrl * PortableMediaViewCtrl = GetPortableMediaViewCtrl( LibPanel );

3883

if( PortableMediaViewCtrl )

3884

{

3885

guPlayListPanel * PlayListPanel = PortableMediaViewCtrl->PlayListPanel();

3886

if( PlayListPanel )

3887

PlayListPanel->PlayListUpdated();

3888

}

3889

}

3890

}

3891

3892

// -------------------------------------------------------------------------------- //

3893

void guMainFrame::OnGaugeCreate( wxCommandEvent &event )

3894

{

3895

wxString * Label = ( wxString * ) event.GetClientData();

3896

if( Label )

3897

{

3898

int NewGauge = m_MainStatusBar->AddGauge( * Label, event.GetInt() );

3899

wxEvtHandler * SourceCtrl = ( wxEvtHandler * ) event.GetEventObject();

3900

event.SetId( ID_STATUSBAR_GAUGE_CREATED );

3901

event.SetInt( NewGauge );

3902

event.SetEventObject( this );

3903

wxPostEvent( SourceCtrl, event );

3904

3905

delete Label;

3906

}

2308

3907

}

2309

3908

2310

3909

// -------------------------------------------------------------------------------- //

2410

4009

m_ViewFileBrowser->Check( false );

2411

4010

PanelId = guPANEL_MAIN_FILEBROWSER;

2412

4011

}

4012

else if( CurPage == m_JamendoPanel )

4013

{

4014

m_ViewJamendo->Check( false );

4015

m_ViewJamTextSearch->Enable( false );

4016

m_ViewJamLabels->Enable( false );

4017

m_ViewJamGenres->Enable( false );

4018

m_ViewJamArtists->Enable( false );

4019

m_ViewJamComposers->Enable( false );

4020

m_ViewJamAlbumArtists->Enable( false );

4021

m_ViewJamAlbums->Enable( false );

4022

m_ViewJamYears->Enable( false );

4023

m_ViewJamRatings->Enable( false );

4024

m_ViewJamPlayCounts->Enable( false );

4025

PanelId = guPANEL_MAIN_JAMENDO;

4026

}

4027

else if( CurPage == m_MagnatunePanel )

4028

{

4029

m_ViewMagnatune->Check( false );

4030

m_ViewMagTextSearch->Enable( false );

4031

m_ViewMagLabels->Enable( false );

4032

m_ViewMagGenres->Enable( false );

4033

m_ViewMagArtists->Enable( false );

4034

m_ViewMagComposers->Enable( false );

4035

m_ViewMagAlbumArtists->Enable( false );

4036

m_ViewMagAlbums->Enable( false );

4037

m_ViewMagYears->Enable( false );

4038

m_ViewMagRatings->Enable( false );

4039

m_ViewMagPlayCounts->Enable( false );

4040

PanelId = guPANEL_MAIN_MAGNATUNE;

4041

}

4042

else

4043

{

4044

int Index;

4045

int Count = m_PortableMediaViewCtrls.Count();

4046

for( Index = 0; Index < Count; Index++ )

4047

{

4048

guPortableMediaViewCtrl * PortableMediaViewCtrl = m_PortableMediaViewCtrls[ Index ];

4049

guPortableMediaLibPanel * PortableMediaLibPanel = PortableMediaViewCtrl->LibPanel();

4050

4051

guPortableMediaAlbumBrowser * PortableMediaAlbumBrowser = PortableMediaViewCtrl->AlbumBrowserPanel();

4052

guPortableMediaPlayListPanel * PortableMediaPlayListPanel = PortableMediaViewCtrl->PlayListPanel();

4053

if( PortableMediaLibPanel == ( guPortableMediaLibPanel * ) CurPage )

4054

{

4055

if( m_LibUpdateThread )

4056

{

4057

if( m_LibUpdateThread->LibPanel() == ( guLibPanel * ) PortableMediaLibPanel )

4058

{

4059

m_LibUpdateThread->Pause();

4060

m_LibUpdateThread->Delete();

4061

m_LibUpdateThread = NULL;

4062

}

4063

}

4064

4065

if( m_LibCleanThread )

4066

{

4067

if( m_LibCleanThread->LibPanel() == ( guLibPanel * ) PortableMediaLibPanel )

4068

{

4069

m_LibCleanThread->Pause();

4070

m_LibCleanThread->Delete();

4071

m_LibCleanThread = NULL;

4072

}

4073

}

4074

4075

PortableMediaViewCtrl->DestroyLibPanel();

4076

4077

if( !PortableMediaViewCtrl->VisiblePanels() )

4078

{

4079

delete m_PortableMediaViewCtrls[ Index ];

4080

m_PortableMediaViewCtrls.RemoveAt( Index );

4081

}

4082

4083

break;

4084

}

4085

else if( PortableMediaPlayListPanel == ( guPortableMediaPlayListPanel * ) CurPage )

4086

{

4087

PortableMediaViewCtrl->DestroyPlayListPanel();

4088

4089

if( !PortableMediaViewCtrl->VisiblePanels() )

4090

{

4091

delete m_PortableMediaViewCtrls[ Index ];

4092

m_PortableMediaViewCtrls.RemoveAt( Index );

4093

}

4094

break;

4095

}

4096

else if( PortableMediaAlbumBrowser == ( guPortableMediaAlbumBrowser * ) CurPage )

4097

{

4098

PortableMediaViewCtrl->DestroyAlbumBrowser();

4099

4100

if( !PortableMediaViewCtrl->VisiblePanels() )

4101

{

4102

delete m_PortableMediaViewCtrls[ Index ];

4103

m_PortableMediaViewCtrls.RemoveAt( Index );

4104

}

4105

break;

4106

}

4107

}

4108

4109

CreatePortablePlayersMenu( m_PortableDevicesMenu );

4110

}

2413

4111

2414

4112

//CheckHideNotebook();

2415

4113

m_VisiblePanels ^= PanelId;

2416

4114

4115

if( m_LocationPanel )

4116

{

4117

m_LocationPanel->OnPanelVisibleChanged();

4118

}

4119

2417

4120

event.Veto();

2418

4121

}

2419

4122

2467

4170

SizeToString( m_SelSize.GetValue() ).c_str() );

2468

4171

m_MainStatusBar->SetSelInfo( SelInfo );

2469

4172

}

4173

else if( m_CurrentPage == ( wxWindow * ) m_LyricsPanel )

4174

{

4175

m_MainStatusBar->SetSelInfo( m_LyricsPanel->GetLyricSource() );

4176

}

2470

4177

else if( m_CurrentPage == ( wxWindow * ) m_FileBrowserPanel )

2471

4178

{

2472

4179

if( m_FileBrowserPanel->GetCounters( &m_SelCount, &m_SelLength, &m_SelSize ) )

2486

4193

m_MainStatusBar->SetSelInfo( wxEmptyString );

2487

4194

}

2488

4195

}

4196

else if( m_CurrentPage == ( wxWindow * ) m_JamendoPanel )

4197

{

4198

m_JamendoDb->GetTracksCounters( &m_SelCount, &m_SelLength, &m_SelSize );

4199

4200

wxString SelInfo = wxString::Format( wxT( "%llu " ), m_SelCount.GetValue() );

4201

SelInfo += m_SelCount == 1 ? _( "track" ) : _( "tracks" );

4202

SelInfo += wxString::Format( wxT( ", %s" ), LenToString( m_SelLength.GetLo() ).c_str() );

4203

m_MainStatusBar->SetSelInfo( SelInfo );

4204

}

4205

else if( m_CurrentPage == ( wxWindow * ) m_MagnatunePanel )

4206

{

4207

m_MagnatuneDb->GetTracksCounters( &m_SelCount, &m_SelLength, &m_SelSize );

4208

4209

wxString SelInfo = wxString::Format( wxT( "%llu " ), m_SelCount.GetValue() );

4210

SelInfo += m_SelCount == 1 ? _( "track" ) : _( "tracks" );

4211

SelInfo += wxString::Format( wxT( ", %s" ), LenToString( m_SelLength.GetLo() ).c_str() );

4212

m_MainStatusBar->SetSelInfo( SelInfo );

4213

}

2489

4214

else

2490

4215

{

2491

//m_SelCount = wxNOT_FOUND;

2492

//m_SelLength = wxNOT_FOUND;

2493

//m_SelSize = wxNOT_FOUND;

2494

m_MainStatusBar->SetSelInfo( wxEmptyString );

4216

guPortableMediaViewCtrl * PortableMediaViewCtrl = GetPortableMediaViewCtrl( ( guLibPanel * ) m_CurrentPage );

4217

if( PortableMediaViewCtrl )

4218

{

4219

PortableMediaViewCtrl->Db()->GetTracksCounters( &m_SelCount, &m_SelLength, &m_SelSize );

4220

4221

wxString SelInfo = wxString::Format( wxT( "%llu " ), m_SelCount.GetValue() );

4222

SelInfo += m_SelCount == 1 ? _( "track" ) : _( "tracks" );

4223

SelInfo += wxString::Format( wxT( ", %s, %s" ),

4224

LenToString( m_SelLength.GetLo() ).c_str(),

4225

SizeToString( m_SelSize.GetValue() ).c_str() );

4226

m_MainStatusBar->SetSelInfo( SelInfo );

4227

}

4228

else

4229

{

4230

PortableMediaViewCtrl = GetPortableMediaViewCtrl( m_CurrentPage, guPANEL_MAIN_PLAYLISTS );

4231

if( PortableMediaViewCtrl )

4232

{

4233

if( PortableMediaViewCtrl->PlayListPanel()->GetPlayListCounters( &m_SelCount, &m_SelLength, &m_SelSize ) )

4234

{

4235

wxString SelInfo = wxString::Format( wxT( "%llu " ), m_SelCount.GetValue() );

4236

SelInfo += m_SelCount == 1 ? _( "track" ) : _( "tracks" );

4237

SelInfo += wxString::Format( wxT( ", %s, %s" ),

4238

LenToString( m_SelLength.GetLo() ).c_str(),

4239

SizeToString( m_SelSize.GetValue() ).c_str() );

4240

m_MainStatusBar->SetSelInfo( SelInfo );

4241

}

4242

else

4243

{

4244

m_MainStatusBar->SetSelInfo( wxEmptyString );

4245

}

4246

}

4247

else

4248

{

4249

//m_SelCount = wxNOT_FOUND;

4250

//m_SelLength = wxNOT_FOUND;

4251

//m_SelSize = wxNOT_FOUND;

4252

m_MainStatusBar->SetSelInfo( wxEmptyString );

4253

}

4254

}

2495

4255

}

2496

4256

}

2497

4257

2504

4264

2505

4265

if( event.GetClientData() == m_LyricsPanel )

2506

4266

{

2507

m_LyricsPanel->OnUpdatedTrack( UpdateEvent );

4267

m_LyricsPanel->OnSetCurrentTrack( UpdateEvent );

4268

4269

if( m_LyricSearchEngine )

4270

{

4271

if( m_LyricSearchContext )

4272

delete m_LyricSearchContext;

4273

m_LyricSearchContext = m_LyricSearchEngine->CreateContext( this, CurTrack );

4274

m_LyricSearchEngine->SearchStart( m_LyricSearchContext );

4275

}

2508

4276

}

2509

4277

else if( event.GetClientData() == m_LastFMPanel )

2510

4278

{

2525

4293

// If the database need to be updated

2526

4294

if( m_Db->NeedUpdate() || Config->ReadBool( wxT( "UpdateLibOnStart" ), false, wxT( "General" ) ) )

2527

4295

{

2528

guLogMessage( wxT( "Database updating started." ) );

4296

guLogMessage( wxT( "Database updating started. %i" ), m_Db->NeedUpdate() );

2529

4297

wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED,

2530

4298

m_Db->NeedUpdate() ? ID_MENU_UPDATE_LIBRARYFORCED : ID_MENU_UPDATE_LIBRARY );

2531

4299

AddPendingEvent( event );

2548

4316

// Now we can start the dbus server

2549

4317

m_DBusServer->Run();

2550

4318

4319

CreatePortablePlayersMenu( m_PortableDevicesMenu );

4320

2551

4321

// // If enabled Show the Splash Screen on Startup

2552

4322

// guSplashFrame * SplashFrame = NULL;

2553

4323

// if( Config->ReadBool( wxT( "ShowSplashScreen" ), true, wxT( "General" ) ) )

2875

4645

{

2876

4646

m_VisiblePanels = m_VisiblePanels & ( guPANEL_MAIN_PLAYERPLAYLIST |

2877

4647

guPANEL_MAIN_PLAYERFILTERS |

2878

guPANEL_MAIN_PLAYERVUMETERS );

4648

guPANEL_MAIN_PLAYERVUMETERS |

4649

guPANEL_MAIN_LOCATIONS |

4650

guPANEL_MAIN_SHOWCOVER );

2879

4651

2880

4652

// Reset the Menu entry for all elements

2881

4653

m_ViewLibrary->Check( false );

2902

4674

m_ViewPlayLists->Check( false );

2903

4675

2904

4676

m_ViewPodcasts->Check( false );

2905

m_ViewPodChannels->Enable( m_ViewPodcasts->IsChecked() );

2906

m_ViewPodDetails->Enable( m_ViewPodcasts->IsChecked() );

4677

m_ViewPodChannels->Enable( false );

4678

m_ViewPodDetails->Enable( false );

2907

4679

2908

4680

m_ViewAlbumBrowser->Check( false );

2909

4681

2910

4682

m_ViewFileBrowser->Check( false );

4683

4684

m_ViewJamendo->Check( false );

4685

m_ViewJamTextSearch->Enable( false );

4686

m_ViewJamLabels->Enable( false );

4687

m_ViewJamGenres->Enable( false );

4688

m_ViewJamArtists->Enable( false );

4689

m_ViewJamAlbums->Enable( false );

4690

m_ViewJamYears->Enable( false );

4691

m_ViewJamRatings->Enable( false );

4692

m_ViewJamPlayCounts->Enable( false );

4693

m_ViewJamComposers->Enable( false );

4694

m_ViewJamAlbumArtists->Enable( false );

4695

4696

m_ViewMagnatune->Check( false );

4697

m_ViewMagTextSearch->Enable( false );

4698

m_ViewMagLabels->Enable( false );

4699

m_ViewMagGenres->Enable( false );

4700

m_ViewMagArtists->Enable( false );

4701

m_ViewMagAlbums->Enable( false );

4702

m_ViewMagYears->Enable( false );

4703

m_ViewMagRatings->Enable( false );

4704

m_ViewMagPlayCounts->Enable( false );

4705

m_ViewMagComposers->Enable( false );

4706

m_ViewMagAlbumArtists->Enable( false );

2911

4707

}

2912

4708

2913

4709

m_AuiManager.Update();

2923

4719

{

2924

4720

wxCommandEvent event;

2925

4721

4722

if( m_LocationPanel )

4723

m_LocationPanel->Lock();

4724

2926

4725

// Empty the tabs

2927

4726

int Index = 0;

2928

4727

int Count = m_CatNotebook->GetPageCount();

2941

4740

//@

2942

4741

m_VisiblePanels = m_VisiblePanels & ( guPANEL_MAIN_PLAYERPLAYLIST |

2943

4742

guPANEL_MAIN_PLAYERFILTERS |

2944

guPANEL_MAIN_PLAYERVUMETERS );

4743

guPANEL_MAIN_PLAYERVUMETERS |

4744

guPANEL_MAIN_LOCATIONS |

4745

guPANEL_MAIN_SHOWCOVER );

2945

4746

2946

4747

// Reset the Menu entry for all elements

2947

4748

m_ViewLibrary->Check( false );

2968

4769

m_ViewPlayLists->Check( false );

2969

4770

2970

4771

m_ViewPodcasts->Check( false );

2971

m_ViewPodChannels->Enable( m_ViewPodcasts->IsChecked() );

2972

m_ViewPodDetails->Enable( m_ViewPodcasts->IsChecked() );

4772

m_ViewPodChannels->Enable( false );

4773

m_ViewPodDetails->Enable( false );

2973

4774

2974

4775

m_ViewAlbumBrowser->Check( false );

2975

4776

2976

4777

m_ViewFileBrowser->Check( false );

2977

4778

4779

m_ViewJamendo->Check( false );

4780

m_ViewJamTextSearch->Enable( false );

4781

m_ViewJamLabels->Enable( false );

4782

m_ViewJamGenres->Enable( false );

4783

m_ViewJamArtists->Enable( false );

4784

m_ViewJamAlbums->Enable( false );

4785

m_ViewJamYears->Enable( false );

4786

m_ViewJamRatings->Enable( false );

4787

m_ViewJamPlayCounts->Enable( false );

4788

m_ViewJamComposers->Enable( false );

4789

m_ViewJamAlbumArtists->Enable( false );

4790

4791

m_ViewMagnatune->Check( false );

4792

m_ViewMagTextSearch->Enable( false );

4793

m_ViewMagLabels->Enable( false );

4794

m_ViewMagGenres->Enable( false );

4795

m_ViewMagArtists->Enable( false );

4796

m_ViewMagAlbums->Enable( false );

4797

m_ViewMagYears->Enable( false );

4798

m_ViewMagRatings->Enable( false );

4799

m_ViewMagPlayCounts->Enable( false );

4800

m_ViewMagComposers->Enable( false );

4801

m_ViewMagAlbumArtists->Enable( false );

2978

4802

2979

4803

Index = 0;

2980

4804

while( true )

3018

4842

{

3019

4843

OnViewFileBrowser( event );

3020

4844

}

3021

4845

else if( TabName == wxT( "Jamendo" ) )

4846

{

4847

OnViewJamendo( event );

4848

}

4849

else if( TabName == wxT( "Magnatune" ) )

4850

{

4851

OnViewMagnatune( event );

4852

}

3022

4853

Index++;

3023

4854

}

3024

4855

3025

4856

m_CatNotebook->LoadPerspective( layout );

4857

4858

if( m_LocationPanel )

4859

m_LocationPanel->Unlock();

3026

4860

}

3027

4861

3028

4862

// -------------------------------------------------------------------------------- //

3048

4882

{

3049

4883

CmdId = ID_MENU_VIEW_PLAYER_SELECTOR;

3050

4884

}

4885

else if( PaneName == wxT( "MainSources" ) )

4886

{

4887

CmdId = ID_MENU_VIEW_MAIN_LOCATIONS;

4888

}

4889

else if( PaneName == wxT( "MainShowCover" ) )

4890

{

4891

CmdId = ID_MENU_VIEW_MAIN_SHOWCOVER;

4892

}

3051

4893

3052

4894

guLogMessage( wxT( "OnMainPaneClose: %s %i" ), PaneName.c_str(), CmdId );

3053

4895

if( CmdId )

3110

4952

if( m_VisiblePanels & guPANEL_MAIN_FILEBROWSER )

3111

4953

OnViewFileBrowser( event );

3112

4954

4955

if( m_VisiblePanels & guPANEL_MAIN_JAMENDO )

4956

OnViewJamendo( event );

4957

4958

if( m_VisiblePanels & guPANEL_MAIN_MAGNATUNE )

4959

OnViewMagnatune( event );

4960

4961

break;

4962

}

4963

4964

case ID_MENU_VIEW_MAIN_LOCATIONS :

4965

{

4966

PanelId = guPANEL_MAIN_LOCATIONS;

4967

break;

4968

}

4969

4970

case ID_MENU_VIEW_MAIN_SHOWCOVER :

4971

{

4972

PanelId = guPANEL_MAIN_SHOWCOVER;

3113

4973

break;

3114

4974

}

3115

4975

3139

4999

break;

3140

5000

3141

5001

case guPANEL_MAIN_PLAYERVUMETERS :

5002

if( !m_PlayerVumeters )

5003

{

5004

guConfig * Config = ( guConfig * ) guConfig::Get();

5005

m_PlayerVumeters = new guPlayerVumeters( this );

5006

m_AuiManager.AddPane( m_PlayerVumeters, wxAuiPaneInfo().Name( wxT( "PlayerVumeters" ) ).Caption( _( "VU Meters" ) ).

5007

DestroyOnClose( false ).Resizable( true ).Floatable( true ).MinSize( 20, 20 ).

5008

CloseButton( Config->ReadBool( wxT( "ShowPaneCloseButton" ), true, wxT( "General" ) ) ).

5009

Bottom().Layer( 0 ).Row( 3 ).Position( 0 ).Hide() );

5010

if( m_PlayerPanel )

5011

m_PlayerPanel->SetPlayerVumeters( m_PlayerVumeters );

5012

}

3142

5013

PaneName = wxT( "PlayerVumeters" );

3143

m_ViewPlayerVumeters->Check( show );

5014

if( m_ViewPlayerVumeters )

5015

m_ViewPlayerVumeters->Check( show );

5016

break;

5017

5018

case guPANEL_MAIN_LOCATIONS :

5019

if( !m_LocationPanel )

5020

{

5021

guConfig * Config = ( guConfig * ) guConfig::Get();

5022

m_LocationPanel = new guLocationPanel( this );

5023

5024

m_AuiManager.AddPane( m_LocationPanel, wxAuiPaneInfo().Name( wxT( "MainSources" ) ).Caption( _( "Sources" ) ).

5025

DestroyOnClose( false ).Resizable( true ).Floatable( true ).MinSize( 20, 20 ).

5026

CloseButton( Config->ReadBool( wxT( "ShowPaneCloseButton" ), true, wxT( "General" ) ) ).

5027

Left().Layer( 3 ).Row( 0 ).Position( 0 ).Hide() );

5028

}

5029

PaneName = wxT( "MainSources" );

5030

if( m_ViewMainLocations )

5031

m_ViewMainLocations->Check( show );

5032

break;

5033

5034

case guPANEL_MAIN_SHOWCOVER :

5035

if( !m_CoverPanel )

5036

{

5037

guConfig * Config = ( guConfig * ) guConfig::Get();

5038

m_CoverPanel = new guCoverPanel( this, m_PlayerPanel );

5039

5040

m_AuiManager.AddPane( m_CoverPanel, wxAuiPaneInfo().Name( wxT( "MainShowCover" ) ).Caption( _( "Cover" ) ).

5041

DestroyOnClose( false ).Resizable( true ).Floatable( true ).MinSize( 50, 50 ).

5042

CloseButton( Config->ReadBool( wxT( "ShowPaneCloseButton" ), true, wxT( "General" ) ) ).

5043

Left().Layer( 3 ).Row( 0 ).Position( 0 ).Hide() );

5044

}

5045

PaneName = wxT( "MainShowCover" );

5046

if( m_ViewMainShowCover )

5047

m_ViewMainShowCover->Check( show );

3144

5048

break;

3145

5049

3146

5050

default :

3170

5074

// -------------------------------------------------------------------------------- //

3171

5075

void guMainFrame::UpdatedTracks( int updatedby, const guTrackArray * tracks )

3172

5076

{

5077

if( !tracks->Count() )

5078

return;

5079

3173

5080

if( updatedby != guUPDATED_TRACKS_PLAYER )

3174

5081

{

3175

5082

m_PlayerPanel->UpdatedTracks( tracks );

3180

5087

m_PlayerPlayList->UpdatedTracks( tracks );

3181

5088

}

3182

5089

3183

if( ( updatedby != guUPDATED_TRACKS_LIBRARY ) && m_LibPanel )

5090

if( updatedby != guUPDATED_TRACKS_LIBRARY )

3184

5091

{

3185

m_LibPanel->UpdatedTracks( tracks );

5092

guLibPanel * LibPanel = tracks->Item( 0 ).m_LibPanel;

5093

if( !LibPanel )

5094

LibPanel = m_LibPanel;

5095

LibPanel->UpdatedTracks( tracks );

3186

5096

}

3187

5097

3188

5098

if( ( updatedby != guUPDATED_TRACKS_PLAYLISTS ) && m_PlayListPanel )

3189

5099

{

3190

5100

m_PlayListPanel->UpdatedTracks( tracks );

3191

5101

}

5102

5103

if( m_LyricsPanel )

5104

{

5105

m_LyricsPanel->UpdatedTracks( tracks );

5106

}

3192

5107

}

3193

5108

3194

5109

// -------------------------------------------------------------------------------- //

3216

5131

}

3217

5132

3218

5133

3219

5134

// -------------------------------------------------------------------------------- //

5135

void guMainFrame::OnLibraryCoverChanged( wxCommandEvent &event )

5136

{

5137

guLibPanel * LibPanel = ( guLibPanel * ) event.GetClientData();

5138

if( m_PlayerPanel )

5139

{

5140

if( !LibPanel )

5141

LibPanel = m_LibPanel;

5142

const guCurrentTrack * CurrentTrack = m_PlayerPanel->GetCurrentTrack();

5143

if( ( CurrentTrack->m_LibPanel ? ( CurrentTrack->m_LibPanel == LibPanel ) : ( m_LibPanel == LibPanel ) ) &&

5144

CurrentTrack->m_Type == guTRACK_TYPE_DB &&

5145

CurrentTrack->m_AlbumId == event.GetInt() )

5146

{

5147

wxString CoverPath;

5148

wxImage * CoverImage = LibPanel->GetAlbumCover( event.GetInt(), CoverPath );

5149

if( CoverImage )

5150

{

5151

CoverImage->Rescale( 100, 100, wxIMAGE_QUALITY_HIGH );

5152

m_PlayerPanel->SetCurrentCoverImage( CoverImage, GU_SONGCOVER_FILE, CoverPath );

5153

//delete CoverImage;

5154

}

5155

else

5156

{

5157

m_PlayerPanel->SetCurrentCoverImage( NULL, GU_SONGCOVER_NONE, CoverPath );

5158

}

5159

}

5160

}

5161

}

5162

5163

// -------------------------------------------------------------------------------- //

5164

void guMainFrame::OnJamendoCoverDownloaded( wxCommandEvent &event )

5165

{

5166

if( m_PlayerPanel )

5167

{

5168

const guCurrentTrack * CurrentTrack = m_PlayerPanel->GetCurrentTrack();

5169

if( CurrentTrack->m_Type == guTRACK_TYPE_JAMENDO &&

5170

CurrentTrack->m_AlbumId == event.GetInt() )

5171

{

5172

wxString CoverPath;

5173

wxImage * CoverImage = m_JamendoPanel->GetAlbumCover( event.GetInt(), CoverPath );

5174

if( CoverImage )

5175

{

5176

CoverImage->Rescale( 100, 100, wxIMAGE_QUALITY_HIGH );

5177

m_PlayerPanel->SetCurrentCoverImage( CoverImage, GU_SONGCOVER_FILE, CoverPath );

5178

//delete CoverImage;

5179

}

5180

}

5181

}

5182

}

5183

5184

// -------------------------------------------------------------------------------- //

5185

void guMainFrame::OnMagnatuneCoverDownloaded( wxCommandEvent &event )

5186

{

5187

if( m_PlayerPanel )

5188

{

5189

const guCurrentTrack * CurrentTrack = m_PlayerPanel->GetCurrentTrack();

5190

if( CurrentTrack->m_Type == guTRACK_TYPE_MAGNATUNE &&

5191

CurrentTrack->m_AlbumId == event.GetInt() )

5192

{

5193

wxString CoverPath;

5194

wxImage * CoverImage = m_MagnatunePanel->GetAlbumCover( CurrentTrack->m_AlbumId,

5195

CurrentTrack->m_ArtistName, CurrentTrack->m_AlbumName, CoverPath );

5196

if( CoverImage )

5197

{

5198

CoverImage->Rescale( 100, 100, wxIMAGE_QUALITY_HIGH );

5199

m_PlayerPanel->SetCurrentCoverImage( CoverImage, GU_SONGCOVER_FILE, CoverPath );

5200

//delete CoverImage;

5201

}

5202

}

5203

}

5204

}

5205

5206

// -------------------------------------------------------------------------------- //

5207

void guMainFrame::OnPlayerPanelCoverChanged( wxCommandEvent &event )

5208

{

5209

if( m_CoverPanel )

5210

{

5211

m_CoverPanel->OnUpdatedTrack( event );

5212

}

5213

5214

if( m_MPRIS2 )

5215

{

5216

m_MPRIS2->OnPlayerTrackChange();

5217

}

5218

}

5219

5220

// -------------------------------------------------------------------------------- //

5221

void guMainFrame::CreateCopyToMenu( wxMenu * menu, const int basecmd )

5222

{

5223

int Index;

5224

int Count;

5225

wxMenuItem * MenuItem;

5226

wxMenu * SubMenu = new wxMenu();

5227

5228

guConfig * Config = ( guConfig * ) guConfig::Get();

5229

wxArrayString CopyToOptions = Config->ReadAStr( wxT( "Option" ), wxEmptyString, wxT( "CopyTo" ) );

5230

5231

if( ( Count = CopyToOptions.Count() ) )

5232

{

5233

for( Index = 0; Index < Count; Index++ )

5234

{

5235

wxArrayString CurOption = wxStringTokenize( CopyToOptions[ Index ], wxT( ":") );

5236

MenuItem = new wxMenuItem( SubMenu, basecmd + Index, unescape_configlist_str( CurOption[ 0 ] ), _( "Copy the current selected songs to a directory or device" ) );

5237

SubMenu->Append( MenuItem );

5238

}

5239

}

5240

5241

bool SeparatorAdded = false;

5242

wxArrayString DeviceNames = m_VolumeMonitor->GetMountNames();

5243

if( ( Count = DeviceNames.Count() ) )

5244

{

5245

for( Index = 0; Index < Count; Index++ )

5246

{

5247

int PanelIndex = m_VolumeMonitor->PanelActive( Index );

5248

if( PanelIndex != wxNOT_FOUND )

5249

{

5250

if( !SeparatorAdded && SubMenu->GetMenuItemCount() )

5251

{

5252

SubMenu->AppendSeparator();

5253

SeparatorAdded = true;

5254

}

5255

5256

MenuItem = new wxMenuItem( SubMenu, basecmd + 100 + PanelIndex, DeviceNames[ Index ], _( "Copy the current selected songs to a directory or device" ) );

5257

//MenuItem->SetBitmap( guImage( guIMAGE_INDEX_edit_copy ) );

5258

SubMenu->Append( MenuItem );

5259

}

5260

}

5261

}

5262

5263

if( SubMenu->GetMenuItemCount() )

5264

{

5265

menu->AppendSubMenu( SubMenu, _( "Copy To..." ), _( "Copy the selected tracks to a folder or device" ) );

5266

}

5267

else

5268

{

5269

delete SubMenu;

5270

}

5271

}

5272

5273

// -------------------------------------------------------------------------------- //

5274

void guMainFrame::CopyToThreadFinished( void )

5275

{

5276

if( m_CopyToThread )

5277

{

5278

m_CopyToThreadMutex.Lock();

5279

m_CopyToThread = NULL;

5280

m_CopyToThreadMutex.Unlock();

5281

}

5282

}

5283

5284

// -------------------------------------------------------------------------------- //

5285

void guMainFrame::OnSetForceGapless( wxCommandEvent &event )

5286

{

5287

m_PlayerPanel->SetForceGapless( event.GetInt() );

5288

}

5289

5290

// -------------------------------------------------------------------------------- //

5291

void guMainFrame::OnLyricFound( wxCommandEvent &event )

5292

{

5293

guLogMessage( wxT( "guMainFrame::OnLyricFound" ) );

5294

wxString * LyricText = ( wxString * ) event.GetClientData();

5295

if( m_LyricsPanel )

5296

{

5297

m_LyricsPanel->SetLyricText( LyricText );

5298

m_LyricsPanel->SetLastSource( event.GetInt() );

5299

}

5300

5301

if( LyricText )

5302

{

5303

delete LyricText;

5304

}

5305

}

5306

5307

// -------------------------------------------------------------------------------- //

5308

void guMainFrame::OnLyricSearchFirst( wxCommandEvent &event )

5309

{

5310

if( m_LyricSearchEngine && m_LyricSearchContext )

5311

{

5312

m_LyricSearchContext->ResetIndex();

5313

m_LyricSearchEngine->SearchStart( m_LyricSearchContext );

5314

}

5315

}

5316

5317

// -------------------------------------------------------------------------------- //

5318

void guMainFrame::OnLyricSearchNext( wxCommandEvent &event )

5319

{

5320

if( m_LyricSearchEngine && m_LyricSearchContext )

5321

{

5322

m_LyricSearchEngine->SearchStart( m_LyricSearchContext );

5323

}

5324

}

5325

5326

// -------------------------------------------------------------------------------- //

5327

void guMainFrame::OnLyricSaveChanges( wxCommandEvent &event )

5328

{

5329

if( m_LyricSearchEngine && m_LyricSearchContext )

5330

{

5331

wxString * LyricText = ( wxString * ) event.GetClientData();

5332

5333

m_LyricSearchEngine->SetLyricText( m_LyricSearchContext, * LyricText );

5334

5335

delete LyricText;

5336

}

5337

}

5338

5339

// -------------------------------------------------------------------------------- //

5340

void guMainFrame::OnLyricExecCommand( wxCommandEvent &event )

5341

{

5342

guLyricSearchThread * LyricSearchThread = ( guLyricSearchThread * ) event.GetClientObject();

5343

wxString * CommandText = ( wxString * ) event.GetClientData();

5344

guLogMessage( wxT( "OnLyricExecCommand: '%s'" ), CommandText->c_str() );

5345

5346

if( CommandText && LyricSearchThread )

5347

{

5348

guLyricExecCommandTerminate * LyricExecCommandTerminate = new guLyricExecCommandTerminate( LyricSearchThread, event.GetInt() );

5349

if( LyricExecCommandTerminate )

5350

{

5351

if( !wxExecute( * CommandText, wxEXEC_ASYNC, LyricExecCommandTerminate ) )

5352

{

5353

guLogError( wxT( "Could not execute the command '%s'" ), CommandText->c_str() );

5354

delete LyricExecCommandTerminate;

5355

5356

LyricSearchThread->FinishExecCommand( wxEmptyString );

5357

}

5358

LyricExecCommandTerminate->Redirect();

5359

}

5360

}

5361

else

5362

{

5363

guLogMessage( wxT( "Error on OnLyricExecCommand..." ) );

5364

}

5365

5366

delete CommandText;

5367

}

5368

5369

// -------------------------------------------------------------------------------- //

5370

void guMainFrame::OnConfigUpdated( wxCommandEvent &event )

5371

{

5372

if( m_LyricSearchEngine )

5373

{

5374

m_LyricSearchEngine->Load();

5375

}

5376

}

3220

5377

3221

5378

3222

5379

// -------------------------------------------------------------------------------- //

3231

5388

// -------------------------------------------------------------------------------- //

3232

5389

guUpdateCoversThread::~guUpdateCoversThread()

3233

5390

{

3234

// printf( "guUpdateCoversThread Object destroyed\n" );

5391

//guLogMessage( wxT( "guUpdateCoversThread Object destroyed" ) );

3235

5392

};

3236

5393

3237

5394

3293

5450

{

3294

5451

guCoverInfos CoverInfos = m_Db->GetEmptyCovers();

3295

5452

5453

//guLogMessage( wxT( "Trying to get the covers for %i items" ), CoverInfos.Count() );

3296

5454

3297

5455

int Count = CoverInfos.Count();

3298

5456

3299

wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_GAUGE_SETMAX );

5457

wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_STATUSBAR_GAUGE_SETMAX );

3300

5458

event.SetInt( m_GaugeId );

3301

5459

event.SetExtraLong( Count );

3302

5460

wxPostEvent( wxTheApp->GetTopWindow(), event );

3304

5462

for( int Index = 0; Index < Count; Index++ )

3305

5463

{

3306

5464

guCoverInfo * CoverInfo = &CoverInfos[ Index ];

3307

Sleep( 1000 ); // Dont hammer LastFM and wait 1 second before each LastFM query

5465

Sleep( 500 ); // Dont hammer LastFM

3308

5466

//guLogMessage( wxT( "Downloading cover for %s - %s" ), CoverInfo->m_ArtistName.c_str(), CoverInfo->m_AlbumName.c_str() );

3309

5467

FindCoverLink( m_Db, CoverInfo->m_AlbumId, CoverInfo->m_AlbumName, CoverInfo->m_ArtistName, CoverInfo->m_PathName );

3310

5468

3311

//wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_GAUGE_UPDATE );

3312

event.SetId( ID_GAUGE_UPDATE );

5469

//wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_STATUSBAR_GAUGE_UPDATE );

5470

event.SetId( ID_STATUSBAR_GAUGE_UPDATE );

3313

5471

event.SetInt( m_GaugeId );

3314

5472

event.SetExtraLong( Index );

3315

5473

wxPostEvent( wxTheApp->GetTopWindow(), event );

3317

5475

}

3318

5476

//guLogMessage( wxT( "Finalized Cover Update Thread" ) );

3319

5477

3320

//event( wxEVT_COMMAND_MENU_SELECTED, ID_GAUGE_REMOVE );

3321

event.SetId( ID_GAUGE_REMOVE );

3322

event.SetInt( m_GaugeId );

3323

wxPostEvent( wxTheApp->GetTopWindow(), event );

3324

3325

return 0;

3326

}

3327

3328

// -------------------------------------------------------------------------------- //

3329

// guCopyToDirThread

3330

// -------------------------------------------------------------------------------- //

3331

guCopyToDirThread::guCopyToDirThread( const wxChar * destdir, guTrackArray * tracks, int gaugeid ) :

3332

wxThread()

3333

{

3334

m_DestDir = wxString( destdir );

3335

m_Tracks = tracks;

3336

m_GaugeId = gaugeid;

3337

if( Create() == wxTHREAD_NO_ERROR )

3338

{

3339

SetPriority( WXTHREAD_DEFAULT_PRIORITY - 30 );

3340

Run();

3341

}

3342

}

3343

3344

// -------------------------------------------------------------------------------- //

3345

guCopyToDirThread::~guCopyToDirThread()

3346

{

3347

if( m_Tracks )

3348

delete m_Tracks;

3349

};

3350

3351

// -------------------------------------------------------------------------------- //

3352

guCopyToDirThread::ExitCode guCopyToDirThread::Entry()

3353

{

3354

int count = m_Tracks->Count();

3355

int index;

3356

wxString FileName;

3357

wxString FilePattern;

3358

guConfig * Config;

3359

bool FileOverwrite = true;

3360

3361

Config = ( guConfig * ) guConfig::Get();

3362

FilePattern = Config->ReadStr( wxT( "CopyToPattern" ), wxT( "{g}/{a}/{b}/{n} - {a} - {t}" ), wxT( "General" ) );

3363

3364

if( !m_DestDir.EndsWith( wxT( "/" ) ) )

3365

m_DestDir.Append( wxT( "/" ) );

3366

3367

3368

wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_GAUGE_SETMAX );

3369

event.SetInt( m_GaugeId );

3370

event.SetExtraLong( count );

3371

wxPostEvent( wxTheApp->GetTopWindow(), event );

3372

3373

for( index = 0; index < count; index++ )

3374

{

3375

FileName = wxEmptyString;

3376

3377

if( ( * m_Tracks )[ index ].m_Type == guTRACK_TYPE_RADIOSTATION )

3378

continue;

3379

3380

if( ( * m_Tracks )[ index ].m_Type == guTRACK_TYPE_PODCAST )

3381

{

3382

FileName = ( * m_Tracks )[ index ].m_AlbumName + wxT( "/" ) + wxFileNameFromPath( ( * m_Tracks )[ index ].m_FileName );

3383

}

3384

else

3385

{

3386

FileName = FilePattern;

3387

FileName.Replace( wxT( "{a}" ), NormalizeField( ( * m_Tracks )[ index ].m_ArtistName ) );

3388

FileName.Replace( wxT( "{aa}" ), NormalizeField( ( * m_Tracks )[ index ].m_AlbumArtist ) );

3389

FileName.Replace( wxT( "{b}" ), NormalizeField( ( * m_Tracks )[ index ].m_AlbumName ) );

3390

FileName.Replace( wxT( "{f}" ), wxFileNameFromPath( ( * m_Tracks )[ index ].m_FileName ) );

3391

FileName.Replace( wxT( "{g}" ), NormalizeField( ( * m_Tracks )[ index ].m_GenreName ) );

3392

FileName.Replace( wxT( "{n}" ), wxString::Format( wxT( "%02u" ), ( * m_Tracks )[ index ].m_Number ) );

3393

FileName.Replace( wxT( "{t}" ), NormalizeField( ( * m_Tracks )[ index ].m_SongName ) );

3394

FileName.Replace( wxT( "{y}" ), wxString::Format( wxT( "%u" ), ( * m_Tracks )[ index ].m_Year ) );

3395

FileName.Replace( wxT( "{d}" ), NormalizeField( ( * m_Tracks )[ index ].m_Disk ) );

3396

//guLogMessage( wxT( "File: '%s' " ), FileName.c_str() );

3397

3398

}

3399

3400

FileName += wxT( '.' ) + ( * m_Tracks )[ index ].m_FileName.Lower().AfterLast( wxT( '.' ) );

3401

3402

FileName = m_DestDir + FileName;

3403

3404

// Replace all the special chars < > : " / \ | ? *

3405

FileName.Replace( wxT( "<" ), wxT( "_" ) );

3406

FileName.Replace( wxT( ">" ), wxT( "_" ) );

3407

FileName.Replace( wxT( ":" ), wxT( "_" ) );

3408

FileName.Replace( wxT( "\"" ), wxT( "_" ) );

3409

FileName.Replace( wxT( "|" ), wxT( "_" ) );

3410

FileName.Replace( wxT( "?" ), wxT( "_" ) );

3411

FileName.Replace( wxT( "*" ), wxT( "_" ) );

3412

3413

guLogMessage( wxT( "Copy %s =>> %s" ), ( * m_Tracks )[ index ].m_FileName.c_str(), FileName.c_str() );

3414

if( wxFileName::Mkdir( wxPathOnly( FileName ), 0777, wxPATH_MKDIR_FULL ) )

3415

{

3416

if( !wxCopyFile( ( * m_Tracks )[ index ].m_FileName, FileName, FileOverwrite ) )

3417

{

3418

guLogError( wxT( "Could not copy the file '%s'" ), FileName.c_str() );

3419

}

3420

}

3421

else

3422

{

3423

guLogError( wxT( "Could not create path for copy the file '%s'" ), FileName.c_str() );

3424

}

3425

3426

event.SetId( ID_GAUGE_UPDATE );

3427

event.SetInt( m_GaugeId );

3428

event.SetExtraLong( index + 1 );

3429

wxPostEvent( wxTheApp->GetTopWindow(), event );

3430

}

3431

3432

3433

event.SetId( ID_GAUGE_REMOVE );

3434

event.SetInt( m_GaugeId );

3435

wxPostEvent( wxTheApp->GetTopWindow(), event );

3436

//wxMessageBox( "Copy to dir finished" );

3437

return 0;

3438

}

5478

//event( wxEVT_COMMAND_MENU_SELECTED, ID_STATUSBAR_GAUGE_REMOVE );

5479

event.SetId( ID_STATUSBAR_GAUGE_REMOVE );

5480

event.SetInt( m_GaugeId );

5481

wxPostEvent( wxTheApp->GetTopWindow(), event );

5482

5483

return 0;

5484

}

5485

5486

5487

3439

5488

3440

5489

// -------------------------------------------------------------------------------- //

3441

5490

// guUpdatePodcastsTimer

3472

5521

// -------------------------------------------------------------------------------- //

3473

5522

guUpdatePodcastsThread::~guUpdatePodcastsThread()

3474

5523

{

3475

wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_GAUGE_REMOVE );

5524

wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_STATUSBAR_GAUGE_REMOVE );

3476

5525

event.SetInt( m_GaugeId );

3477

5526

wxPostEvent( m_MainFrame, event );

3478

5527

}

3483

5532

guPodcastChannelArray PodcastChannels;

3484

5533

if( m_Db->GetPodcastChannels( &PodcastChannels ) )

3485

5534

{

3486

wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_GAUGE_SETMAX );

5535

wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_STATUSBAR_GAUGE_SETMAX );

3487

5536

event.SetInt( m_GaugeId );

3488

5537

event.SetExtraLong( PodcastChannels.Count() );

3489

5538

wxPostEvent( m_MainFrame, event );

3491

5540

unsigned int Index = 0;

3492

5541

while( !TestDestroy() && Index < PodcastChannels.Count() )

3493

5542

{

3494

event.SetId( ID_GAUGE_UPDATE );

5543

event.SetId( ID_STATUSBAR_GAUGE_UPDATE );

3495

5544

event.SetInt( m_GaugeId );

3496

5545

event.SetExtraLong( Index + 1 );

3497

5546

wxPostEvent( m_MainFrame, event );

Older »