← Back to branch summary

~ubuntu-branches/ubuntu/trusty/guayadeque/trusty

« back to all changes in this revision

Viewing changes to src/PlayListPanel.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2011-02-09 13:39:39 UTC
  • mfrom: (3.1.2 maverick)
  • Revision ID: james.westby@ubuntu.com-20110209133939-w4i25g4hvsgw4yvw
Tags: 0.2.7-3
* Upload to unstable.
* Pass -Wl,--as-needed to the linker.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/PlayListPanel.cpp
1
1
// -------------------------------------------------------------------------------- //
2
 
//      Copyright (C) 2008-2009 J.Rios
 
2
//      Copyright (C) 2008-2010 J.Rios
3
3
//      anonbeat@gmail.com
4
4
//
5
5
//    This Program is free software; you can redistribute it and/or modify
21
21
#include "PlayListPanel.h"
22
22
 
23
23
#include "AuiNotebook.h"
 
24
#include "AuiDockArt.h"
24
25
#include "Commands.h"
25
26
#include "Config.h"
26
27
#include "DbLibrary.h"
27
28
#include "DynamicPlayList.h"
 
29
#include "FieldEditor.h"
28
30
#include "Images.h"
29
31
#include "LabelEditor.h"
30
32
#include "MainFrame.h"
34
36
#include "TrackEdit.h"
35
37
#include "Utils.h"
36
38
 
 
39
#define guPLAYLIST_TIMER_TEXTSEARCH        5
 
40
#define guPLAYLIST_TIMER_TEXTSEARCH_VALUE  500
 
41
 
37
42
// -------------------------------------------------------------------------------- //
38
43
class guPLNamesData : public wxTreeItemData
39
44
{
74
79
    SetDropTarget( new guPLNamesDropTarget( this ) );
75
80
 
76
81
    Connect( wxEVT_COMMAND_TREE_ITEM_MENU, wxTreeEventHandler( guPLNamesTreeCtrl::OnContextMenu ), NULL, this );
 
82
    Connect( wxEVT_KEY_DOWN, wxKeyEventHandler( guPLNamesTreeCtrl::OnKeyDown ), NULL, this );
77
83
 
78
84
    ReloadItems();
79
85
}
82
88
guPLNamesTreeCtrl::~guPLNamesTreeCtrl()
83
89
{
84
90
    Disconnect( wxEVT_COMMAND_TREE_ITEM_MENU, wxTreeEventHandler( guPLNamesTreeCtrl::OnContextMenu ), NULL, this );
 
91
    Disconnect( wxEVT_KEY_DOWN, wxKeyEventHandler( guPLNamesTreeCtrl::OnKeyDown ), NULL, this );
85
92
}
86
93
 
87
94
// -------------------------------------------------------------------------------- //
94
101
    DeleteChildren( m_DynamicId );
95
102
 
96
103
    guListItems m_StaticItems;
97
 
    m_Db->GetPlayLists( &m_StaticItems, GUPLAYLIST_STATIC );
 
104
    m_Db->GetPlayLists( &m_StaticItems, GUPLAYLIST_STATIC, &m_TextSearchFilter );
98
105
    if( ( count = m_StaticItems.Count() ) )
99
106
    {
100
107
        for( index = 0; index < count; index++ )
101
108
        {
102
 
            AppendItem( m_StaticId, m_StaticItems[ index ].m_Name, 0, 0,
 
109
            AppendItem( m_StaticId, m_StaticItems[ index ].m_Name, -1, -1,
103
110
                                new guPLNamesData( m_StaticItems[ index ].m_Id, GUPLAYLIST_STATIC ) );
104
111
        }
105
112
    }
106
113
 
107
114
    guListItems m_DynamicItems;
108
 
    m_Db->GetPlayLists( &m_DynamicItems, GUPLAYLIST_DYNAMIC );
 
115
    m_Db->GetPlayLists( &m_DynamicItems, GUPLAYLIST_DYNAMIC, &m_TextSearchFilter );
109
116
    if( ( count = m_DynamicItems.Count() ) )
110
117
    {
111
118
        for( index = 0; index < count; index++ )
112
119
        {
113
 
            AppendItem( m_DynamicId, m_DynamicItems[ index ].m_Name, 1, 1,
 
120
            AppendItem( m_DynamicId, m_DynamicItems[ index ].m_Name, -1, -1,
114
121
                                new guPLNamesData( m_DynamicItems[ index ].m_Id, GUPLAYLIST_DYNAMIC ) );
115
122
        }
116
123
    }
134
141
        if( ItemData )
135
142
        {
136
143
            MenuItem = new wxMenuItem( &Menu, ID_PLAYLIST_PLAY, _( "Play" ), _( "Play current selected songs" ) );
137
 
            MenuItem->SetBitmap( guImage( guIMAGE_INDEX_playback_start ) );
 
144
            MenuItem->SetBitmap( guImage( guIMAGE_INDEX_player_tiny_light_play ) );
138
145
            Menu.Append( MenuItem );
139
146
 
140
147
            MenuItem = new wxMenuItem( &Menu, ID_PLAYLIST_ENQUEUE, _( "Enqueue" ), _( "Add current selected songs to the playlist" ) );
141
148
            MenuItem->SetBitmap( guImage( guIMAGE_INDEX_add ) );
142
149
            Menu.Append( MenuItem );
143
150
 
 
151
            MenuItem = new wxMenuItem( &Menu, ID_PLAYLIST_ENQUEUE_ASNEXT, _( "Enqueue Next" ), _( "Add current selected songs to the playlist as Next Tracks" ) );
 
152
            MenuItem->SetBitmap( guImage( guIMAGE_INDEX_add ) );
 
153
            Menu.Append( MenuItem );
 
154
 
144
155
            Menu.AppendSeparator();
145
156
        }
146
157
    }
169
180
            MenuItem->SetBitmap( guImage( guIMAGE_INDEX_edit ) );
170
181
            Menu.Append( MenuItem );
171
182
 
172
 
            MenuItem = new wxMenuItem( &Menu, ID_SONG_SAVEPLAYLIST, _( "Save Playlist" ), _( "Save the selected playlist as a Static Playlist" ) );
 
183
            MenuItem = new wxMenuItem( &Menu, ID_SONG_SAVEPLAYLIST, _( "Save to Playlist" ), _( "Save the selected playlist as a Static Playlist" ) );
173
184
            MenuItem->SetBitmap( guImage( guIMAGE_INDEX_doc_save ) );
174
185
            Menu.Append( MenuItem );
175
186
        }
295
306
    m_DropIds.Clear();
296
307
}
297
308
 
 
309
// -------------------------------------------------------------------------------- //
 
310
void guPLNamesTreeCtrl::OnKeyDown( wxKeyEvent &event )
 
311
{
 
312
    if( event.GetKeyCode() == WXK_DELETE )
 
313
    {
 
314
        wxCommandEvent CmdEvent( wxEVT_COMMAND_MENU_SELECTED, ID_PLAYLIST_DELETE );
 
315
        wxPostEvent( this, CmdEvent );
 
316
        return;
 
317
    }
 
318
    event.Skip();
 
319
}
 
320
 
298
321
 
299
322
// -------------------------------------------------------------------------------- //
300
323
// guPLNamesDropFilesThread
434
457
// guPlayListPanel
435
458
// -------------------------------------------------------------------------------- //
436
459
guPlayListPanel::guPlayListPanel( wxWindow * parent, guDbLibrary * db, guPlayerPanel * playerpanel ) :
437
 
                 wxPanel( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL )
 
460
                wxPanel( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL ),
 
461
                m_TextChangedTimer( this, guPLAYLIST_TIMER_TEXTSEARCH )
 
462
 
438
463
{
439
464
    m_Db = db;
440
465
    m_PlayerPanel = playerpanel;
442
467
    guConfig * Config = ( guConfig * ) guConfig::Get();
443
468
 
444
469
    m_AuiManager.SetManagedWindow( this );
 
470
    m_AuiManager.SetArtProvider( new guAuiDockArt() );
445
471
    m_AuiManager.SetFlags( wxAUI_MGR_ALLOW_FLOATING |
446
472
                           wxAUI_MGR_TRANSPARENT_DRAG |
447
473
                           wxAUI_MGR_TRANSPARENT_HINT );
452
478
            wxSystemSettings::GetColour( wxSYS_COLOUR_CAPTIONTEXT ) );
453
479
 
454
480
    AuiDockArt->SetColour( wxAUI_DOCKART_ACTIVE_CAPTION_COLOUR,
455
 
            wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ) );
 
481
            wxSystemSettings::GetColour( wxSYS_COLOUR_ACTIVEBORDER ) );
456
482
 
457
483
    AuiDockArt->SetColour( wxAUI_DOCKART_ACTIVE_CAPTION_GRADIENT_COLOUR,
458
 
            wxAuiStepColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ), 130 ) );
 
484
            wxSystemSettings::GetColour( wxSYS_COLOUR_3DSHADOW ) );
459
485
 
460
486
    AuiDockArt->SetColour( wxAUI_DOCKART_INACTIVE_CAPTION_COLOUR,
461
 
            wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ) );
 
487
            wxSystemSettings::GetColour( wxSYS_COLOUR_INACTIVEBORDER ) );
462
488
 
463
489
    AuiDockArt->SetColour( wxAUI_DOCKART_INACTIVE_CAPTION_GRADIENT_COLOUR,
464
 
            wxAuiStepColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ), 130 ) );
 
490
            wxSystemSettings::GetColour( wxSYS_COLOUR_3DSHADOW ) );
465
491
 
466
492
    AuiDockArt->SetColour( wxAUI_DOCKART_GRADIENT_TYPE,
467
493
            wxAUI_GRADIENT_VERTICAL );
468
494
 
469
495
 
 
496
    m_VisiblePanels = Config->ReadNum( wxT( "PLVisiblePanels" ), guPANEL_PLAYLIST_VISIBLE_DEFAULT, wxT( "Positions" ) );
 
497
 
470
498
//      wxBoxSizer* MainSizer;
471
499
//      MainSizer = new wxBoxSizer( wxVERTICAL );
472
500
//
473
501
//      m_MainSplitter = new wxSplitterWindow( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSP_3D );
474
502
//    m_MainSplitter->SetMinimumPaneSize( 60 );
475
503
 
 
504
        wxBoxSizer * SearchSizer;
 
505
        SearchSizer = new wxBoxSizer( wxHORIZONTAL );
 
506
    wxPanel * SearchPanel;
 
507
        SearchPanel = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );
 
508
 
 
509
//    wxStaticText *      SearchStaticText;
 
510
//      SearchStaticText = new wxStaticText( SearchPanel, wxID_ANY, _( "Search:" ), wxDefaultPosition, wxDefaultSize, 0 );
 
511
//      SearchStaticText->Wrap( -1 );
 
512
//      SearchSizer->Add( SearchStaticText, 0, wxALIGN_CENTER|wxALL, 5 );
 
513
 
 
514
    m_InputTextCtrl = new wxSearchCtrl( SearchPanel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER );
 
515
    SearchSizer->Add( m_InputTextCtrl, 1, wxALIGN_CENTER|wxALL, 5 );
 
516
 
 
517
    SearchPanel->SetSizer( SearchSizer );
 
518
    SearchPanel->Layout();
 
519
        SearchSizer->Fit( SearchPanel );
 
520
 
 
521
    m_AuiManager.AddPane( SearchPanel,
 
522
            wxAuiPaneInfo().Name( wxT( "PlayListTextSearch" ) ).Caption( _( "Text Search" ) ).
 
523
            MinSize( 60, 28 ).MaxSize( -1, 28 ).Row( 0 ).Layer( 2 ).Position( 0 ).
 
524
            CloseButton( Config->ReadBool( wxT( "ShowPaneCloseButton" ), true, wxT( "General" ) ) ).
 
525
            Dockable( true ).Top() );
 
526
 
476
527
    wxPanel * NamesPanel;
477
528
        NamesPanel = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );
478
529
        wxBoxSizer * NameSizer;
482
533
//    m_NameStaticText = new wxStaticText( NamesPanel, wxID_ANY, _( "Play lists:" ) );
483
534
//    NameSizer->Add( m_NameStaticText, 0, wxLEFT|wxRIGHT|wxTOP|wxEXPAND, 5 );
484
535
        m_NamesTreeCtrl = new guPLNamesTreeCtrl( NamesPanel, m_Db );
 
536
        m_NamesTreeCtrl->ExpandAll();
485
537
        NameSizer->Add( m_NamesTreeCtrl, 1, wxEXPAND, 5 );
486
538
 
487
539
        NamesPanel->SetSizer( NameSizer );
513
565
 
514
566
    wxString PlayListLayout = Config->ReadStr( wxT( "PlayLists" ), wxEmptyString, wxT( "Positions" ) );
515
567
    if( Config->GetIgnoreLayouts() || PlayListLayout.IsEmpty() )
 
568
    {
516
569
        m_AuiManager.Update();
 
570
        m_VisiblePanels = guPANEL_PLAYLIST_VISIBLE_DEFAULT;
 
571
    }
517
572
    else
518
573
        m_AuiManager.LoadPerspective( PlayListLayout, true );
519
574
 
529
584
        Connect( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, wxTreeEventHandler( guPlayListPanel::OnPLNamesActivated ), NULL, this );
530
585
    Connect( ID_PLAYLIST_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLNamesPlay ) );
531
586
    Connect( ID_PLAYLIST_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLNamesEnqueue ) );
 
587
    Connect( ID_PLAYLIST_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLNamesEnqueueAsNext ) );
532
588
    Connect( ID_PLAYLIST_NEWPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLNamesNewPlaylist ) );
533
589
    Connect( ID_PLAYLIST_EDIT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLNamesEditPlaylist ) );
534
590
    Connect( ID_PLAYLIST_RENAME, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLNamesRenamePlaylist ) );
540
596
 
541
597
    m_PLTracksListBox->Connect( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, wxListEventHandler( guPlayListPanel::OnPLTracksActivated ), NULL, this );
542
598
    Connect( ID_SONG_DELETE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksDeleteClicked ) );
 
599
    Connect( ID_SONG_DELETE_LIBRARY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksDeleteLibrary ) );
 
600
    Connect( ID_SONG_DELETE_DRIVE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksDeleteDrive ) );
543
601
    Connect( ID_SONG_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksPlayClicked ) );
544
602
    Connect( ID_SONG_PLAYALL, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksPlayAllClicked ) );
545
603
    Connect( ID_SONG_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksQueueClicked ) );
 
604
    Connect( ID_SONG_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksQueueAsNextClicked ) );
546
605
    Connect( ID_SONG_ENQUEUEALL, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksQueueAllClicked ) );
 
606
    Connect( ID_SONG_ENQUEUEALL_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksQueueAllAsNextClicked ) );
547
607
    Connect( ID_SONG_EDITLABELS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksEditLabelsClicked ) );
548
608
    Connect( ID_SONG_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksEditTracksClicked ) );
549
609
    Connect( ID_SONG_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksCopyToClicked ) );
550
610
    Connect( ID_SONG_SAVEPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksSavePlayListClicked ) );
 
611
    Connect( ID_SONG_SET_RATING_0, ID_SONG_SET_RATING_5, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksSetRating ), NULL, this );
 
612
    Connect( ID_SONG_SET_COLUMN, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksSetField ), NULL, this );
 
613
    Connect( ID_SONG_EDIT_COLUMN, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksEditField ), NULL, this );
551
614
 
552
615
    Connect( ID_SONG_BROWSE_GENRE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksSelectGenre ) );
553
616
    Connect( ID_SONG_BROWSE_ARTIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksSelectArtist ) );
 
617
    Connect( ID_SONG_BROWSE_ALBUMARTIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksSelectAlbumArtist ) );
554
618
    Connect( ID_SONG_BROWSE_ALBUM, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksSelectAlbum ) );
555
619
 
 
620
    //m_InputTextCtrl->Connect( wxEVT_COMMAND_TEXT_ENTER, wxCommandEventHandler( guPlayListPanel::OnSearchSelected ), NULL, this );
 
621
    m_InputTextCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( guPlayListPanel::OnSearchActivated ), NULL, this );
 
622
    m_InputTextCtrl->Connect( wxEVT_COMMAND_SEARCHCTRL_CANCEL_BTN, wxCommandEventHandler( guPlayListPanel::OnSearchCancelled ), NULL, this );
 
623
 
 
624
        Connect( guPLAYLIST_TIMER_TEXTSEARCH, wxEVT_TIMER, wxTimerEventHandler( guPlayListPanel::OnTextChangedTimer ), NULL, this );
 
625
 
 
626
    m_AuiManager.Connect( wxEVT_AUI_PANE_CLOSE, wxAuiManagerEventHandler( guPlayListPanel::OnPaneClose ), NULL, this );
556
627
}
557
628
 
558
629
// -------------------------------------------------------------------------------- //
562
633
    guConfig * Config = ( guConfig * ) guConfig::Get();
563
634
    if( Config )
564
635
    {
565
 
//        Config->WriteNum( wxT( "PlayListSashPos" ), m_MainSplitter->GetSashPosition(), wxT( "Positions" ) );
 
636
        Config->WriteNum( wxT( "PLVisiblePanels" ), m_VisiblePanels, wxT( "Positions" ) );
566
637
        Config->WriteStr( wxT( "PlayLists" ), m_AuiManager.SavePerspective(), wxT( "Positions" ) );
567
638
    }
568
639
 
570
641
        Disconnect( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, wxTreeEventHandler( guPlayListPanel::OnPLNamesActivated ), NULL, this );
571
642
    Disconnect( ID_PLAYLIST_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLNamesPlay ) );
572
643
    Disconnect( ID_PLAYLIST_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLNamesEnqueue ) );
 
644
    Disconnect( ID_PLAYLIST_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLNamesEnqueueAsNext ) );
573
645
    Disconnect( ID_PLAYLIST_NEWPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLNamesNewPlaylist ) );
574
646
    Disconnect( ID_PLAYLIST_EDIT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLNamesEditPlaylist ) );
575
647
    Disconnect( ID_PLAYLIST_RENAME, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLNamesRenamePlaylist ) );
581
653
 
582
654
    m_PLTracksListBox->Disconnect( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, wxListEventHandler( guPlayListPanel::OnPLTracksActivated ), NULL, this );
583
655
    Disconnect( ID_SONG_DELETE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksDeleteClicked ) );
 
656
    Disconnect( ID_SONG_DELETE_LIBRARY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksDeleteLibrary ) );
 
657
    Disconnect( ID_SONG_DELETE_DRIVE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksDeleteDrive ) );
584
658
    Disconnect( ID_SONG_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksPlayClicked ) );
585
659
    Disconnect( ID_SONG_PLAYALL, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksPlayAllClicked ) );
586
660
    Disconnect( ID_SONG_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksQueueClicked ) );
 
661
    Disconnect( ID_SONG_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksQueueAsNextClicked ) );
587
662
    Disconnect( ID_SONG_ENQUEUEALL, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksQueueAllClicked ) );
 
663
    Disconnect( ID_SONG_ENQUEUEALL_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksQueueAllAsNextClicked ) );
588
664
    Disconnect( ID_SONG_EDITLABELS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksEditLabelsClicked ) );
589
665
    Disconnect( ID_SONG_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksEditTracksClicked ) );
590
666
    Disconnect( ID_SONG_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksCopyToClicked ) );
592
668
 
593
669
    Disconnect( ID_SONG_BROWSE_GENRE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksSelectGenre ) );
594
670
    Disconnect( ID_SONG_BROWSE_ARTIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksSelectArtist ) );
 
671
    Disconnect( ID_SONG_BROWSE_ALBUMARTIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksSelectAlbumArtist ) );
595
672
    Disconnect( ID_SONG_BROWSE_ALBUM, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guPlayListPanel::OnPLTracksSelectAlbum ) );
596
673
 
 
674
    //m_InputTextCtrl->Disconnect( wxEVT_COMMAND_TEXT_ENTER, wxCommandEventHandler( guPlayListPanel::OnSearchSelected ), NULL, this );
 
675
    m_InputTextCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( guPlayListPanel::OnSearchActivated ), NULL, this );
 
676
    m_InputTextCtrl->Disconnect( wxEVT_COMMAND_SEARCHCTRL_CANCEL_BTN, wxCommandEventHandler( guPlayListPanel::OnSearchCancelled ), NULL, this );
 
677
 
 
678
        Disconnect( guPLAYLIST_TIMER_TEXTSEARCH, wxEVT_TIMER, wxTimerEventHandler( guPlayListPanel::OnTextChangedTimer ), NULL, this );
 
679
 
 
680
    m_AuiManager.Disconnect( wxEVT_AUI_PANE_CLOSE, wxAuiManagerEventHandler( guPlayListPanel::OnPaneClose ), NULL, this );
 
681
 
597
682
    m_AuiManager.UnInit();
598
683
}
599
684
 
600
685
// -------------------------------------------------------------------------------- //
 
686
void guPlayListPanel::OnSearchActivated( wxCommandEvent& event )
 
687
{
 
688
    if( m_TextChangedTimer.IsRunning() )
 
689
        m_TextChangedTimer.Stop();
 
690
    m_TextChangedTimer.Start( guPLAYLIST_TIMER_TEXTSEARCH_VALUE, wxTIMER_ONE_SHOT );
 
691
}
 
692
 
 
693
//// -------------------------------------------------------------------------------- //
 
694
//void guPlayListPanel::OnSearchSelected( wxCommandEvent& event )
 
695
//{
 
696
//    guConfig * Config = ( guConfig * ) guConfig::Get();
 
697
//    OnSelectStations( Config->ReadBool( wxT( "DefaultActionEnqueue" ), false, wxT( "General" ) ) );
 
698
//}
 
699
 
 
700
// -------------------------------------------------------------------------------- //
 
701
void guPlayListPanel::OnSearchCancelled( wxCommandEvent &event ) // CLEAN SEARCH STR
 
702
{
 
703
    m_InputTextCtrl->Clear();
 
704
}
 
705
 
 
706
// -------------------------------------------------------------------------------- //
 
707
void guPlayListPanel::OnTextChangedTimer( wxTimerEvent &event )
 
708
{
 
709
    wxString SearchString = m_InputTextCtrl->GetLineText( 0 );
 
710
    if( !SearchString.IsEmpty() )
 
711
    {
 
712
        if( SearchString.Length() > 1 )
 
713
        {
 
714
            m_NamesTreeCtrl->m_TextSearchFilter = guSplitWords( SearchString );
 
715
            m_NamesTreeCtrl->ExpandAll();
 
716
            m_NamesTreeCtrl->ReloadItems();
 
717
        }
 
718
        m_InputTextCtrl->ShowCancelButton( true );
 
719
    }
 
720
    else
 
721
    {
 
722
        m_NamesTreeCtrl->m_TextSearchFilter.Clear();
 
723
        m_NamesTreeCtrl->ExpandAll();
 
724
        m_NamesTreeCtrl->ReloadItems();
 
725
        m_InputTextCtrl->ShowCancelButton( false );
 
726
    }
 
727
}
 
728
 
 
729
// -------------------------------------------------------------------------------- //
601
730
void guPlayListPanel::OnPLNamesSelected( wxTreeEvent& event )
602
731
{
603
732
    guPLNamesData * ItemData = ( guPLNamesData * ) m_NamesTreeCtrl->GetItemData( event.GetItem() );
663
792
}
664
793
 
665
794
// -------------------------------------------------------------------------------- //
 
795
void guPlayListPanel::OnPLNamesEnqueueAsNext( wxCommandEvent &event )
 
796
{
 
797
    wxTreeItemId ItemId = m_NamesTreeCtrl->GetSelection();
 
798
    if( ItemId.IsOk() )
 
799
    {
 
800
        guTrackArray Tracks;
 
801
        m_PLTracksListBox->GetAllSongs( &Tracks );
 
802
        m_PlayerPanel->AddToPlayList( Tracks, true, true );
 
803
    }
 
804
}
 
805
 
 
806
// -------------------------------------------------------------------------------- //
666
807
void guPlayListPanel::OnPLNamesNewPlaylist( wxCommandEvent &event )
667
808
{
668
809
    guDynPlayList DynPlayList;
727
868
}
728
869
 
729
870
// -------------------------------------------------------------------------------- //
 
871
void guPlayListPanel::DeleteCurrentPlayList( void )
 
872
{
 
873
    wxTreeItemId ItemId = m_NamesTreeCtrl->GetSelection();
 
874
    if( ItemId.IsOk() )
 
875
    {
 
876
        guPLNamesData * ItemData = ( guPLNamesData * ) m_NamesTreeCtrl->GetItemData( ItemId );
 
877
        if( ItemData )
 
878
        {
 
879
            m_Db->DeletePlayList( ItemData->GetData() );
 
880
            //m_NamesTreeCtrl->Delete( ItemId );
 
881
            wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED, ID_PLAYLIST_UPDATED );
 
882
            wxPostEvent( wxTheApp->GetTopWindow(), evt );
 
883
        }
 
884
    }
 
885
}
 
886
 
 
887
// -------------------------------------------------------------------------------- //
730
888
void guPlayListPanel::OnPLNamesDeletePlaylist( wxCommandEvent &event )
731
889
{
732
890
    if( wxMessageBox( _( "Are you sure to delete the selected Playlist?" ),
736
894
        wxTreeItemId ItemId = m_NamesTreeCtrl->GetSelection();
737
895
        if( ItemId.IsOk() )
738
896
        {
739
 
            guPLNamesData * ItemData = ( guPLNamesData * ) m_NamesTreeCtrl->GetItemData( ItemId );
740
 
            wxASSERT( ItemData );
741
 
            m_Db->DeletePlayList( ItemData->GetData() );
742
 
            //m_NamesTreeCtrl->Delete( ItemId );
743
 
            wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED, ID_PLAYLIST_UPDATED );
744
 
            wxPostEvent( wxTheApp->GetTopWindow(), evt );
 
897
            DeleteCurrentPlayList();
745
898
        }
746
899
    }
747
900
}
804
957
                    wxString FileName = Uri.BuildUnescapedURI();
805
958
                    if( FileName.StartsWith( wxT( "file:" ) ) )
806
959
                        FileName = FileName.Mid( 5 );
807
 
                    //guLogMessage( wxT( "Trying to add file '%s'" ), FileName.c_str() );
 
960
                    guLogMessage( wxT( "Trying to add file '%s'" ), FileName.c_str() );
808
961
                    int SongId = m_Db->FindTrackFile( FileName, NULL );
809
962
                    if( SongId )
810
963
                    {
811
964
                        Songs.Add( SongId );
812
 
                    //    guLogMessage( wxT( "Found it!" ) );
 
965
                        guLogMessage( wxT( "Found it!" ) );
813
966
                    }
814
 
                    //else
815
 
                    //    guLogMessage( wxT( "Not Found it!" ) );
 
967
                    else
 
968
                        guLogMessage( wxT( "Not Found it!" ) );
816
969
                }
817
970
 
818
971
                if( Songs.Count() )
945
1098
}
946
1099
 
947
1100
// -------------------------------------------------------------------------------- //
 
1101
void guPlayListPanel::OnPLTracksQueueAsNextClicked( wxCommandEvent &event )
 
1102
{
 
1103
    guTrackArray Tracks;
 
1104
    m_PLTracksListBox->GetSelectedSongs( &Tracks );
 
1105
    if( !Tracks.Count() )
 
1106
        m_PLTracksListBox->GetAllSongs( &Tracks );
 
1107
    m_PlayerPanel->AddToPlayList( Tracks, true, true );
 
1108
}
 
1109
 
 
1110
// -------------------------------------------------------------------------------- //
948
1111
void guPlayListPanel::OnPLTracksQueueAllClicked( wxCommandEvent &event )
949
1112
{
950
1113
    guTrackArray Tracks;
953
1116
}
954
1117
 
955
1118
// -------------------------------------------------------------------------------- //
 
1119
void guPlayListPanel::OnPLTracksQueueAllAsNextClicked( wxCommandEvent &event )
 
1120
{
 
1121
    guTrackArray Tracks;
 
1122
    m_PLTracksListBox->GetAllSongs( &Tracks );
 
1123
    m_PlayerPanel->AddToPlayList( Tracks, true, true );
 
1124
}
 
1125
 
 
1126
// -------------------------------------------------------------------------------- //
956
1127
void guPlayListPanel::OnPLTracksEditLabelsClicked( wxCommandEvent &event )
957
1128
{
958
 
    guListItems Labels;
959
 
    wxArrayInt SongIds;
960
 
 
961
 
    m_Db->GetLabels( &Labels, true );
962
 
 
963
 
    SongIds = m_PLTracksListBox->GetSelectedItems();
964
 
 
965
 
    guLabelEditor * LabelEditor = new guLabelEditor( this, m_Db, _( "Songs Labels Editor" ), false,
966
 
                         Labels, m_Db->GetSongsLabels( SongIds ) );
967
 
    if( LabelEditor )
 
1129
    guListItems Tracks;
 
1130
    m_PLTracksListBox->GetSelectedItems( &Tracks );
 
1131
    if( Tracks.Count() )
968
1132
    {
969
 
        if( LabelEditor->ShowModal() == wxID_OK )
 
1133
        guArrayListItems LabelSets = m_Db->GetSongsLabels( m_PLTracksListBox->GetSelectedItems() );
 
1134
 
 
1135
        guLabelEditor * LabelEditor = new guLabelEditor( this, m_Db, _( "Tracks Labels Editor" ), false, &Tracks, &LabelSets );
 
1136
        if( LabelEditor )
970
1137
        {
971
 
            m_Db->UpdateSongsLabels( SongIds, LabelEditor->GetCheckedIds() );
 
1138
            if( LabelEditor->ShowModal() == wxID_OK )
 
1139
            {
 
1140
                // Update the labels in the files
 
1141
                m_Db->UpdateSongsLabels( LabelSets );
 
1142
            }
 
1143
            LabelEditor->Destroy();
 
1144
            m_PLTracksListBox->ReloadItems( false );
972
1145
        }
973
 
        LabelEditor->Destroy();
974
 
        m_PLTracksListBox->ReloadItems();
975
1146
    }
 
1147
 
976
1148
}
977
1149
 
978
1150
// -------------------------------------------------------------------------------- //
998
1170
            // Update the track in database, playlist, etc
999
1171
            ( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_PLAYLISTS, &Tracks );
1000
1172
        }
 
1173
        guImagePtrArrayClean( &Images );
1001
1174
        TrackEditor->Destroy();
1002
1175
    }
1003
1176
}
1042
1215
    if( NewSongs.Count() );
1043
1216
    {
1044
1217
        guListItems PlayLists;
1045
 
        m_Db->GetPlayLists( &PlayLists,GUPLAYLIST_STATIC );
 
1218
        m_Db->GetPlayLists( &PlayLists, GUPLAYLIST_STATIC );
1046
1219
 
1047
1220
        guPlayListAppend * PlayListAppendDlg = new guPlayListAppend( wxTheApp->GetTopWindow(), m_Db, &NewSongs, &PlayLists );
1048
1221
 
1081
1254
}
1082
1255
 
1083
1256
// -------------------------------------------------------------------------------- //
 
1257
void guPlayListPanel::OnPLTracksSetRating( wxCommandEvent &event )
 
1258
{
 
1259
    int Rating = event.GetId() - ID_SONG_SET_RATING_0;
 
1260
 
 
1261
    guTrackArray Tracks;
 
1262
    m_PLTracksListBox->GetSelectedSongs( &Tracks );
 
1263
 
 
1264
    m_Db->SetTracksRating( &Tracks, Rating );
 
1265
    int Index;
 
1266
    int Count = Tracks.Count();
 
1267
    for( Index = 0; Index < Count; Index++ )
 
1268
    {
 
1269
        Tracks[ Index ].m_Rating = Rating;
 
1270
    }
 
1271
 
 
1272
    ( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_NONE, &Tracks );
 
1273
}
 
1274
 
 
1275
// -------------------------------------------------------------------------------- //
 
1276
void guPlayListPanel::OnPLTracksSetField( wxCommandEvent &event )
 
1277
{
 
1278
    int ColumnId = m_PLTracksListBox->GetColumnId( m_PLTracksListBox->GetLastColumnClicked() );
 
1279
    //guLogMessage( wxT( "guPlayListPanel::OnSongSetField %i" ), ColumnId );
 
1280
 
 
1281
    guTrackArray Tracks;
 
1282
    m_PLTracksListBox->GetSelectedSongs( &Tracks );
 
1283
 
 
1284
    wxVariant NewData = m_PLTracksListBox->GetLastDataClicked();
 
1285
 
 
1286
    //guLogMessage( wxT( "Setting Data to : %s" ), NewData.GetString().c_str() );
 
1287
 
 
1288
    // This should be done in a thread for huge selections of tracks...
 
1289
    int Index;
 
1290
    int Count = Tracks.Count();
 
1291
    for( Index = 0; Index < Count; Index++ )
 
1292
    {
 
1293
        guTrack * Track = &Tracks[ Index ];
 
1294
        switch( ColumnId )
 
1295
        {
 
1296
            case guSONGS_COLUMN_NUMBER :
 
1297
                Track->m_Number = NewData.GetLong();
 
1298
                break;
 
1299
 
 
1300
            case guSONGS_COLUMN_TITLE :
 
1301
                Track->m_SongName = NewData.GetString();
 
1302
                break;
 
1303
 
 
1304
            case guSONGS_COLUMN_ARTIST :
 
1305
                Track->m_ArtistName = NewData.GetString();
 
1306
                break;
 
1307
 
 
1308
            case guSONGS_COLUMN_ALBUMARTIST :
 
1309
                Track->m_AlbumArtist = NewData.GetString();
 
1310
                break;
 
1311
 
 
1312
            case guSONGS_COLUMN_ALBUM :
 
1313
                Track->m_AlbumName = NewData.GetString();
 
1314
                break;
 
1315
 
 
1316
            case guSONGS_COLUMN_GENRE :
 
1317
                Track->m_GenreName = NewData.GetString();
 
1318
                break;
 
1319
 
 
1320
            case guSONGS_COLUMN_COMPOSER :
 
1321
                Track->m_Composer = NewData.GetString();
 
1322
                break;
 
1323
 
 
1324
            case guSONGS_COLUMN_DISK :
 
1325
                Track->m_Disk = NewData.GetString();
 
1326
                break;
 
1327
 
 
1328
            case guSONGS_COLUMN_YEAR :
 
1329
                Track->m_Year = NewData.GetLong();
 
1330
                break;
 
1331
 
 
1332
        }
 
1333
    }
 
1334
 
 
1335
    m_Db->UpdateSongs( &Tracks );
 
1336
}
 
1337
 
 
1338
// -------------------------------------------------------------------------------- //
 
1339
void guPlayListPanel::OnPLTracksEditField( wxCommandEvent &event )
 
1340
{
 
1341
    int ColumnId = m_PLTracksListBox->GetColumnId( m_PLTracksListBox->GetLastColumnClicked() );
 
1342
    //guLogMessage( wxT( "guLibPanel::OnSongSetField %i" ), ColumnId );
 
1343
 
 
1344
    guTrackArray Tracks;
 
1345
    m_PLTracksListBox->GetSelectedSongs( &Tracks );
 
1346
 
 
1347
    wxString Label = m_PLTracksListBox->GetColumnNames()[ ColumnId ];
 
1348
    wxVariant DefValue = m_PLTracksListBox->GetLastDataClicked();
 
1349
 
 
1350
    wxArrayString Items;
 
1351
 
 
1352
    int Index;
 
1353
    int Count = Tracks.Count();
 
1354
    for( Index = 0; Index < Count; Index++ )
 
1355
    {
 
1356
        wxVariant Value;
 
1357
        guTrack * Track = &Tracks[ Index ];
 
1358
 
 
1359
        switch( ColumnId )
 
1360
        {
 
1361
            case guSONGS_COLUMN_NUMBER :
 
1362
                Value = ( long ) Track->m_Number;
 
1363
                break;
 
1364
 
 
1365
            case guSONGS_COLUMN_TITLE :
 
1366
                Value = Track->m_SongName;
 
1367
                break;
 
1368
 
 
1369
            case guSONGS_COLUMN_ARTIST :
 
1370
                Value = Track->m_ArtistName;
 
1371
                break;
 
1372
 
 
1373
            case guSONGS_COLUMN_ALBUMARTIST :
 
1374
                Value = Track->m_AlbumArtist;
 
1375
                break;
 
1376
 
 
1377
            case guSONGS_COLUMN_ALBUM :
 
1378
                Value = Track->m_AlbumName;
 
1379
                break;
 
1380
 
 
1381
            case guSONGS_COLUMN_GENRE :
 
1382
                Value = Track->m_GenreName;
 
1383
                break;
 
1384
 
 
1385
            case guSONGS_COLUMN_COMPOSER :
 
1386
                Value = Track->m_Composer;
 
1387
                break;
 
1388
 
 
1389
            case guSONGS_COLUMN_DISK :
 
1390
                Value = Track->m_Disk;
 
1391
                break;
 
1392
 
 
1393
            case guSONGS_COLUMN_YEAR :
 
1394
                Value = ( long ) Track->m_Year;
 
1395
                break;
 
1396
        }
 
1397
        if( Items.Index( Value.GetString() ) == wxNOT_FOUND )
 
1398
            Items.Add( Value.GetString() );
 
1399
    }
 
1400
 
 
1401
    guFieldEditor * FieldEditor = new guFieldEditor( this, Label, DefValue.GetString(), Items );
 
1402
 
 
1403
    if( FieldEditor )
 
1404
    {
 
1405
        if( FieldEditor->ShowModal() == wxID_OK )
 
1406
        {
 
1407
            DefValue = FieldEditor->GetData();
 
1408
 
 
1409
            //guLogMessage( wxT( "Setting Data to : %s" ), DefValue.GetString().c_str() );
 
1410
 
 
1411
            // This should be done in a thread for huge selections of tracks...
 
1412
            int Index;
 
1413
            int Count = Tracks.Count();
 
1414
            for( Index = 0; Index < Count; Index++ )
 
1415
            {
 
1416
                guTrack * Track = &Tracks[ Index ];
 
1417
                switch( ColumnId )
 
1418
                {
 
1419
                    case guSONGS_COLUMN_NUMBER :
 
1420
                        Track->m_Number = DefValue.GetLong();
 
1421
                        break;
 
1422
 
 
1423
                    case guSONGS_COLUMN_TITLE :
 
1424
                        Track->m_SongName = DefValue.GetString();
 
1425
                        break;
 
1426
 
 
1427
                    case guSONGS_COLUMN_ARTIST :
 
1428
                        Track->m_ArtistName = DefValue.GetString();
 
1429
                        break;
 
1430
 
 
1431
                    case guSONGS_COLUMN_ALBUMARTIST :
 
1432
                        Track->m_AlbumArtist = DefValue.GetString();
 
1433
                        break;
 
1434
 
 
1435
                    case guSONGS_COLUMN_ALBUM :
 
1436
                        Track->m_AlbumName = DefValue.GetString();
 
1437
                        break;
 
1438
 
 
1439
                    case guSONGS_COLUMN_GENRE :
 
1440
                        Track->m_GenreName = DefValue.GetString();
 
1441
                        break;
 
1442
 
 
1443
                    case guSONGS_COLUMN_COMPOSER :
 
1444
                        Track->m_Composer = DefValue.GetString();
 
1445
                        break;
 
1446
 
 
1447
                    case guSONGS_COLUMN_DISK :
 
1448
                        Track->m_Disk = DefValue.GetString();
 
1449
                        break;
 
1450
 
 
1451
                    case guSONGS_COLUMN_YEAR :
 
1452
                        Track->m_Year = DefValue.GetLong();
 
1453
                        break;
 
1454
                }
 
1455
            }
 
1456
 
 
1457
            m_Db->UpdateSongs( &Tracks );
 
1458
        }
 
1459
        FieldEditor->Destroy();
 
1460
    }
 
1461
}
 
1462
 
 
1463
// -------------------------------------------------------------------------------- //
1084
1464
void guPlayListPanel::PlayListUpdated( void )
1085
1465
{
1086
1466
    m_NamesTreeCtrl->ReloadItems();
1128
1508
}
1129
1509
 
1130
1510
// -------------------------------------------------------------------------------- //
 
1511
void guPlayListPanel::OnPLTracksSelectAlbumArtist( wxCommandEvent &event )
 
1512
{
 
1513
    guTrackArray Tracks;
 
1514
    m_PLTracksListBox->GetSelectedSongs( &Tracks );
 
1515
    wxArrayInt * Ids = new wxArrayInt();
 
1516
    int index;
 
1517
    int count = Tracks.Count();
 
1518
    for( index = 0; index < count; index++ )
 
1519
    {
 
1520
        if( Ids->Index( Tracks[ index ].m_AlbumArtistId ) == wxNOT_FOUND )
 
1521
        {
 
1522
            Ids->Add( Tracks[ index ].m_AlbumArtistId );
 
1523
        }
 
1524
    }
 
1525
    event.SetId( ID_ALBUMARTIST_SETSELECTION );
 
1526
    event.SetClientData( ( void * ) Ids );
 
1527
    wxPostEvent( wxTheApp->GetTopWindow(), event );
 
1528
}
 
1529
 
 
1530
// -------------------------------------------------------------------------------- //
1131
1531
void guPlayListPanel::OnPLTracksSelectAlbum( wxCommandEvent &event )
1132
1532
{
1133
1533
    guTrackArray Tracks;
1166
1566
}
1167
1567
 
1168
1568
// -------------------------------------------------------------------------------- //
 
1569
bool guPlayListPanel::IsPanelShown( const int panelid ) const
 
1570
{
 
1571
    return ( m_VisiblePanels & panelid );
 
1572
}
 
1573
 
 
1574
// -------------------------------------------------------------------------------- //
 
1575
void guPlayListPanel::ShowPanel( const int panelid, bool show )
 
1576
{
 
1577
    wxString PaneName;
 
1578
 
 
1579
    switch( panelid )
 
1580
    {
 
1581
        case guPANEL_PLAYLIST_TEXTSEARCH :
 
1582
            PaneName = wxT( "PlayListTextSearch" );
 
1583
            break;
 
1584
 
 
1585
        default :
 
1586
            return;
 
1587
 
 
1588
    }
 
1589
 
 
1590
    wxAuiPaneInfo &PaneInfo = m_AuiManager.GetPane( PaneName );
 
1591
    if( PaneInfo.IsOk() )
 
1592
    {
 
1593
        if( show )
 
1594
            PaneInfo.Show();
 
1595
        else
 
1596
            PaneInfo.Hide();
 
1597
 
 
1598
        m_AuiManager.Update();
 
1599
    }
 
1600
 
 
1601
    if( show )
 
1602
        m_VisiblePanels |= panelid;
 
1603
    else
 
1604
        m_VisiblePanels ^= panelid;
 
1605
 
 
1606
    guLogMessage( wxT( "Id: %i Pane: %s Show:%i  Flags:%08X" ), panelid, PaneName.c_str(), show, m_VisiblePanels );
 
1607
}
 
1608
 
 
1609
// -------------------------------------------------------------------------------- //
 
1610
void guPlayListPanel::OnPaneClose( wxAuiManagerEvent &event )
 
1611
{
 
1612
    wxAuiPaneInfo * PaneInfo = event.GetPane();
 
1613
    wxString PaneName = PaneInfo->name;
 
1614
    int CmdId = 0;
 
1615
 
 
1616
    if( PaneName == wxT( "PlayListTextSearch" ) )
 
1617
    {
 
1618
        CmdId = ID_MENU_VIEW_PL_TEXTSEARCH;
 
1619
    }
 
1620
 
 
1621
    guLogMessage( wxT( "OnPaneClose: %s  %i" ), PaneName.c_str(), CmdId );
 
1622
    if( CmdId )
 
1623
    {
 
1624
        wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED, CmdId );
 
1625
        AddPendingEvent( evt );
 
1626
    }
 
1627
 
 
1628
    event.Veto();
 
1629
}
 
1630
 
 
1631
// -------------------------------------------------------------------------------- //
 
1632
void guPlayListPanel::OnPLTracksDeleteLibrary( wxCommandEvent &event )
 
1633
{
 
1634
    if( m_PLTracksListBox->GetSelectedCount() )
 
1635
    {
 
1636
        if( wxMessageBox( wxT( "Are you sure to remove the selected tracks from your library?" ),
 
1637
            wxT( "Remove tracks from library" ), wxICON_QUESTION | wxYES | wxNO | wxCANCEL | wxNO_DEFAULT ) == wxYES )
 
1638
        {
 
1639
            guTrackArray Tracks;
 
1640
            m_PLTracksListBox->GetSelectedSongs( &Tracks );
 
1641
            //
 
1642
            m_Db->DeleteLibraryTracks( &Tracks, true );
 
1643
 
 
1644
            m_PLTracksListBox->ReloadItems();
 
1645
        }
 
1646
    }
 
1647
}
 
1648
 
 
1649
// -------------------------------------------------------------------------------- //
 
1650
void guPlayListPanel::OnPLTracksDeleteDrive( wxCommandEvent &event )
 
1651
{
 
1652
    if( m_PLTracksListBox->GetSelectedCount() )
 
1653
    {
 
1654
        if( wxMessageBox( wxT( "Are you sure to delete the selected tracks from your drive?\nThis will permanently erase the selected tracks." ),
 
1655
            wxT( "Remove tracks from drive" ), wxICON_QUESTION | wxYES | wxNO | wxCANCEL | wxNO_DEFAULT ) == wxYES )
 
1656
        {
 
1657
            guTrackArray Tracks;
 
1658
            m_PLTracksListBox->GetSelectedSongs( &Tracks );
 
1659
            //
 
1660
            m_Db->DeleteLibraryTracks( &Tracks, false );
 
1661
            //
 
1662
            int Index;
 
1663
            int Count = Tracks.Count();
 
1664
            for( Index = 0; Index < Count; Index++ )
 
1665
            {
 
1666
                if( !wxRemoveFile( Tracks[ Index ].m_FileName ) )
 
1667
                {
 
1668
                    guLogMessage( wxT( "Error deleting '%s'" ), Tracks[ Index ].m_FileName.c_str() );
 
1669
                }
 
1670
            }
 
1671
 
 
1672
            m_PLTracksListBox->ReloadItems();
 
1673
        }
 
1674
    }
 
1675
}
 
1676
 
 
1677
// -------------------------------------------------------------------------------- //