~ubuntu-branches/ubuntu/saucy/guayadeque/saucy

Connect( ID_GENRE_COPYTO, ID_GENRE_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnGenreCopyToClicked ), NULL, this );

375

Connect( ID_GENRE_SAVETOPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnGenreSavePlayListClicked ), NULL, this );

373

376

374

377

Connect( ID_LABEL_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnLabelPlayClicked ), NULL, this );

375

378

Connect( ID_LABEL_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnLabelQueueClicked ), NULL, this );

376

379

Connect( ID_LABEL_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnLabelQueueAsNextClicked ), NULL, this );

377

380

//Connect( ID_LABEL_CLEARSELECTION, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnLabelClearSelectClicked ) );

378

Connect( ID_LABEL_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnLabelCopyToClicked ), NULL, this );

381

Connect( ID_LABEL_COPYTO, ID_LABEL_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnLabelCopyToClicked ), NULL, this );

382

Connect( ID_LABEL_SAVETOPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnLabelSavePlayListClicked ), NULL, this );

379

383

380

384

Connect( ID_ARTIST_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistPlayClicked ), NULL, this );

381

385

Connect( ID_ARTIST_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistQueueClicked ), NULL, this );

382

386

Connect( ID_ARTIST_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistQueueAsNextClicked ), NULL, this );

383

387

Connect( ID_ARTIST_EDITLABELS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistEditLabelsClicked ), NULL, this );

384

388

Connect( ID_ARTIST_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistEditTracksClicked ), NULL, this );

385

Connect( ID_ARTIST_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistCopyToClicked ), NULL, this );

389

Connect( ID_ARTIST_COPYTO, ID_ARTIST_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistCopyToClicked ), NULL, this );

390

Connect( ID_ARTIST_SAVETOPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistSavePlayListClicked ), NULL, this );

386

391

387

392

Connect( ID_ALBUM_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumPlayClicked ), NULL, this );

388

393

Connect( ID_ALBUM_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumQueueClicked ), NULL, this );

392

397

Connect( ID_ALBUM_MANUALCOVER, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumDownloadCoverClicked ), NULL, this );

393

398

Connect( ID_ALBUM_SELECT_COVER, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumSelectCoverClicked ), NULL, this );

394

399

Connect( ID_ALBUM_COVER_DELETE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumDeleteCoverClicked ), NULL, this );

395

Connect( ID_ALBUM_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumCopyToClicked ), NULL, this );

400

Connect( ID_ALBUM_COVER_EMBED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumEmbedCoverClicked ), NULL, this );

401

Connect( ID_ALBUM_COPYTO, ID_ALBUM_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumCopyToClicked ), NULL, this );

402

Connect( ID_ALBUM_SAVETOPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumSavePlayListClicked ), NULL, this );

396

403

397

404

Connect( ID_YEAR_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnYearListPlayClicked ), NULL, this );

398

405

Connect( ID_YEAR_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnYearListQueueClicked ), NULL, this );

399

406

Connect( ID_YEAR_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnYearListQueueAsNextClicked ), NULL, this );

400

407

Connect( ID_YEAR_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnYearListEditTracksClicked ), NULL, this );

401

Connect( ID_YEAR_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnYearListCopyToClicked ), NULL, this );

408

Connect( ID_YEAR_COPYTO, ID_YEAR_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnYearListCopyToClicked ), NULL, this );

409

Connect( ID_YEAR_SAVETOPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnYearSavePlayListClicked ), NULL, this );

402

410

403

411

Connect( ID_RATING_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnRatingListPlayClicked ), NULL, this );

404

412

Connect( ID_RATING_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnRatingListQueueClicked ), NULL, this );

405

413

Connect( ID_RATING_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnRatingListQueueAsNextClicked ), NULL, this );

406

414

Connect( ID_RATING_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnRatingListEditTracksClicked ), NULL, this );

407

Connect( ID_RATING_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnRatingListCopyToClicked ), NULL, this );

415

Connect( ID_RATING_COPYTO, ID_RATING_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnRatingListCopyToClicked ), NULL, this );

416

Connect( ID_RATING_SAVETOPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistSavePlayListClicked ), NULL, this );

408

417

409

418

Connect( ID_PLAYCOUNT_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnPlayCountListPlayClicked ), NULL, this );

410

419

Connect( ID_PLAYCOUNT_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnPlayCountListQueueClicked ), NULL, this );

411

420

Connect( ID_PLAYCOUNT_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnPlayCountListQueueAsNextClicked ), NULL, this );

412

421

Connect( ID_PLAYCOUNT_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnPlayCountListEditTracksClicked ), NULL, this );

413

Connect( ID_PLAYCOUNT_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnPlayCountListCopyToClicked ), NULL, this );

422

Connect( ID_PLAYCOUNT_COPYTO, ID_PLAYCOUNT_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnPlayCountListCopyToClicked ), NULL, this );

423

Connect( ID_PLAYCOUNT_SAVETOPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnPlayCountSavePlayListClicked ), NULL, this );

414

424

415

425

Connect( ID_COMPOSER_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnComposerListPlayClicked ), NULL, this );

416

426

Connect( ID_COMPOSER_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnComposerListQueueClicked ), NULL, this );

417

427

Connect( ID_COMPOSER_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnComposerListQueueAsNextClicked ), NULL, this );

418

428

Connect( ID_COMPOSER_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnComposerListEditTracksClicked ), NULL, this );

419

Connect( ID_COMPOSER_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnComposerListCopyToClicked ), NULL, this );

429

Connect( ID_COMPOSER_COPYTO, ID_COMPOSER_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnComposerListCopyToClicked ), NULL, this );

430

Connect( ID_COMPOSER_SAVETOPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnComposerSavePlayListClicked ), NULL, this );

420

431

421

432

Connect( ID_ALBUMARTIST_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumArtistListPlayClicked ), NULL, this );

422

433

Connect( ID_ALBUMARTIST_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumArtistListQueueClicked ), NULL, this );

423

434

Connect( ID_ALBUMARTIST_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumArtistListQueueAsNextClicked ), NULL, this );

424

435

Connect( ID_ALBUMARTIST_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumArtistListEditTracksClicked ), NULL, this );

425

Connect( ID_ALBUMARTIST_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumArtistListCopyToClicked ), NULL, this );

436

Connect( ID_ALBUMARTIST_COPYTO, ID_ALBUMARTIST_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumArtistListCopyToClicked ), NULL, this );

437

Connect( ID_ALBUMARTIST_SAVETOPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumArtistSavePlayListClicked ), NULL, this );

426

438

427

439

Connect( ID_SONG_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongPlayClicked ), NULL, this );

428

440

Connect( ID_SONG_PLAYALL, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongPlayAllClicked ), NULL, this );

432

444

Connect( ID_SONG_ENQUEUEALL_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongQueueAllAsNextClicked ), NULL, this );

433

445

Connect( ID_SONG_EDITLABELS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongsEditLabelsClicked ), NULL, this );

434

446

Connect( ID_SONG_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongsEditTracksClicked ), NULL, this );

435

Connect( ID_SONG_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongCopyToClicked ), NULL, this );

436

Connect( ID_SONG_SAVEPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongSavePlayListClicked ), NULL, this );

447

Connect( ID_SONG_SAVETOPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongSavePlayListClicked ), NULL, this );

437

448

Connect( ID_SONG_SET_RATING_0, ID_SONG_SET_RATING_5, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongSetRating ), NULL, this );

438

449

Connect( ID_SONG_SET_COLUMN, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongSetField ), NULL, this );

439

450

Connect( ID_SONG_EDIT_COLUMN, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongEditField ), NULL, this );

451

Connect( ID_SONG_COPYTO, ID_SONG_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongCopyToClicked ), NULL, this );

440

452

441

453

Connect( ID_SONG_BROWSE_GENRE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongSelectGenre ), NULL, this );

442

454

Connect( ID_SONG_BROWSE_ARTIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongSelectArtist ), NULL, this );

455

467

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

456

468

if( Config )

457

469

{

458

Config->WriteNum( wxT( "LibVisiblePanels" ), m_VisiblePanels, wxT( "Positions" ) );

459

Config->WriteStr( wxT( "Library" ), m_AuiManager.SavePerspective(), wxT( "Positions" ) );

470

Config->WriteNum( m_ConfigPrefixVarName + wxT( "VisiblePanels" ), m_VisiblePanels, wxT( "Positions" ) );

471

Config->WriteStr( m_ConfigPrefixVarName + wxT( "Layout" ), m_AuiManager.SavePerspective(), wxT( "Positions" ) );

460

472

}

461

473

462

474

Disconnect( guPANEL_TIMER_SELECTION, wxEVT_TIMER, wxTimerEventHandler( guLibPanel::OnSelChangedTimer ), NULL, this );

500

512

//m_InputTextCtrl->Disconnect( wxEVT_COMMAND_SEARCHCTRL_SEARCH_BTN, wxCommandEventHandler( guLibPanel::OnSearchActivated ), NULL, this );

501

513

m_InputTextCtrl->Disconnect( wxEVT_COMMAND_SEARCHCTRL_CANCEL_BTN, wxCommandEventHandler( guLibPanel::OnSearchCancelled ), NULL, this );

502

514

515

503

516

Disconnect( ID_GENRE_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnGenrePlayClicked ), NULL, this );

504

517

Disconnect( ID_GENRE_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnGenreQueueClicked ), NULL, this );

505

518

Disconnect( ID_GENRE_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnGenreQueueAsNextClicked ), NULL, this );

506

Disconnect( ID_GENRE_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnGenreCopyToClicked ), NULL, this );

519

Disconnect( ID_GENRE_COPYTO, ID_GENRE_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnGenreCopyToClicked ), NULL, this );

507

520

508

521

Disconnect( ID_LABEL_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnLabelPlayClicked ), NULL, this );

509

522

Disconnect( ID_LABEL_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnLabelQueueClicked ), NULL, this );

510

523

Disconnect( ID_LABEL_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnLabelQueueAsNextClicked ), NULL, this );

511

524

//Disconnect( ID_LABEL_CLEARSELECTION, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnLabelClearSelectClicked ) );

512

Disconnect( ID_LABEL_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnLabelCopyToClicked ), NULL, this );

525

Disconnect( ID_LABEL_COPYTO, ID_LABEL_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnLabelCopyToClicked ), NULL, this );

513

526

514

527

Disconnect( ID_ARTIST_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistPlayClicked ), NULL, this );

515

528

Disconnect( ID_ARTIST_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistQueueClicked ), NULL, this );

516

529

Disconnect( ID_ARTIST_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistQueueAsNextClicked ), NULL, this );

517

530

Disconnect( ID_ARTIST_EDITLABELS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistEditLabelsClicked ), NULL, this );

518

531

Disconnect( ID_ARTIST_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistEditTracksClicked ), NULL, this );

519

Disconnect( ID_ARTIST_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistCopyToClicked ), NULL, this );

532

Disconnect( ID_ARTIST_COPYTO, ID_ARTIST_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnArtistCopyToClicked ), NULL, this );

520

533

521

534

Disconnect( ID_ALBUM_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumPlayClicked ), NULL, this );

522

535

Disconnect( ID_ALBUM_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumQueueClicked ), NULL, this );

526

539

Disconnect( ID_ALBUM_MANUALCOVER, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumDownloadCoverClicked ), NULL, this );

527

540

Disconnect( ID_ALBUM_SELECT_COVER, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumSelectCoverClicked ), NULL, this );

528

541

Disconnect( ID_ALBUM_COVER_DELETE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumDeleteCoverClicked ), NULL, this );

529

Disconnect( ID_ALBUM_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumCopyToClicked ), NULL, this );

542

Disconnect( ID_ALBUM_COVER_EMBED, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumEmbedCoverClicked ), NULL, this );

543

Disconnect( ID_ALBUM_COPYTO, ID_ALBUM_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumCopyToClicked ), NULL, this );

530

544

531

545

Disconnect( ID_YEAR_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnYearListPlayClicked ), NULL, this );

532

546

Disconnect( ID_YEAR_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnYearListQueueClicked ), NULL, this );

533

547

Disconnect( ID_YEAR_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnYearListQueueAsNextClicked ), NULL, this );

534

548

Disconnect( ID_YEAR_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnYearListEditTracksClicked ), NULL, this );

535

Disconnect( ID_YEAR_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnYearListCopyToClicked ), NULL, this );

549

Disconnect( ID_YEAR_COPYTO, ID_YEAR_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnYearListCopyToClicked ), NULL, this );

536

550

537

551

Disconnect( ID_RATING_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnRatingListPlayClicked ), NULL, this );

538

552

Disconnect( ID_RATING_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnRatingListQueueClicked ), NULL, this );

539

553

Disconnect( ID_RATING_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnRatingListQueueAsNextClicked ), NULL, this );

540

554

Disconnect( ID_RATING_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnRatingListEditTracksClicked ), NULL, this );

541

Disconnect( ID_RATING_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnRatingListCopyToClicked ), NULL, this );

555

Disconnect( ID_RATING_COPYTO, ID_RATING_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnRatingListCopyToClicked ), NULL, this );

542

556

543

557

Disconnect( ID_PLAYCOUNT_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnPlayCountListPlayClicked ), NULL, this );

544

558

Disconnect( ID_PLAYCOUNT_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnPlayCountListQueueClicked ), NULL, this );

545

559

Disconnect( ID_PLAYCOUNT_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnPlayCountListQueueAsNextClicked ), NULL, this );

546

560

Disconnect( ID_PLAYCOUNT_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnPlayCountListEditTracksClicked ), NULL, this );

547

Disconnect( ID_PLAYCOUNT_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnPlayCountListCopyToClicked ), NULL, this );

561

Disconnect( ID_PLAYCOUNT_COPYTO, ID_PLAYCOUNT_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnPlayCountListCopyToClicked ), NULL, this );

548

562

549

563

Disconnect( ID_COMPOSER_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnComposerListPlayClicked ), NULL, this );

550

564

Disconnect( ID_COMPOSER_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnComposerListQueueClicked ), NULL, this );

551

565

Disconnect( ID_COMPOSER_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnComposerListQueueAsNextClicked ), NULL, this );

552

566

Disconnect( ID_COMPOSER_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnComposerListEditTracksClicked ), NULL, this );

553

Disconnect( ID_COMPOSER_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnComposerListCopyToClicked ), NULL, this );

567

Disconnect( ID_COMPOSER_COPYTO, ID_COMPOSER_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnComposerListCopyToClicked ), NULL, this );

554

568

555

569

Disconnect( ID_ALBUMARTIST_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumArtistListPlayClicked ), NULL, this );

556

570

Disconnect( ID_ALBUMARTIST_ENQUEUE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumArtistListQueueClicked ), NULL, this );

557

571

Disconnect( ID_ALBUMARTIST_ENQUEUE_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumArtistListQueueAsNextClicked ), NULL, this );

558

572

Disconnect( ID_ALBUMARTIST_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumArtistListEditTracksClicked ), NULL, this );

559

Disconnect( ID_ALBUMARTIST_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumArtistListCopyToClicked ), NULL, this );

573

Disconnect( ID_ALBUMARTIST_COPYTO, ID_ALBUMARTIST_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnAlbumArtistListCopyToClicked ), NULL, this );

560

574

561

575

Disconnect( ID_SONG_PLAY, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongPlayClicked ), NULL, this );

562

576

Disconnect( ID_SONG_PLAYALL, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongPlayAllClicked ), NULL, this );

566

580

Disconnect( ID_SONG_ENQUEUEALL_ASNEXT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongQueueAllAsNextClicked ), NULL, this );

567

581

Disconnect( ID_SONG_EDITLABELS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongsEditLabelsClicked ), NULL, this );

568

582

Disconnect( ID_SONG_EDITTRACKS, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongsEditTracksClicked ), NULL, this );

569

Disconnect( ID_SONG_COPYTO, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongCopyToClicked ), NULL, this );

570

Disconnect( ID_SONG_SAVEPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongSavePlayListClicked ), NULL, this );

583

Disconnect( ID_SONG_SAVETOPLAYLIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongSavePlayListClicked ), NULL, this );

584

Disconnect( ID_SONG_SET_RATING_0, ID_SONG_SET_RATING_5, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongSetRating ), NULL, this );

585

Disconnect( ID_SONG_SET_COLUMN, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongSetField ), NULL, this );

586

Disconnect( ID_SONG_EDIT_COLUMN, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongEditField ), NULL, this );

587

Disconnect( ID_SONG_COPYTO, ID_SONG_COPYTO + 199, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongCopyToClicked ), NULL, this );

571

588

572

589

Disconnect( ID_SONG_BROWSE_GENRE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongSelectGenre ), NULL, this );

573

590

Disconnect( ID_SONG_BROWSE_ARTIST, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( guLibPanel::OnSongSelectArtist ), NULL, this );

582

599

}

583

600

584

601

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

585

void guLibPanel::ReloadControls( wxCommandEvent &event )

602

void guLibPanel::ReloadControls( void )

586

603

{

587

//guLogMessage( wxT( "ReloadControls..." ) );

604

guLogMessage( wxT( "ReloadControls...%08X" ), m_VisiblePanels );

588

605

//m_Db->LoadCache();

589

606

m_UpdateLock = true;

590

m_LabelsListCtrl->ReloadItems( false );

591

m_GenreListCtrl->ReloadItems( false );

592

m_AlbumArtistListCtrl->ReloadItems( false );

593

m_ArtistListCtrl->ReloadItems( false );

594

m_ComposerListCtrl->ReloadItems( false );

595

m_AlbumListCtrl->ReloadItems( false );

596

m_YearListCtrl->ReloadItems( false );

597

m_RatingListCtrl->ReloadItems( false );

598

m_PlayCountListCtrl->ReloadItems( false );

599

m_SongListCtrl->ReloadItems( false );

607

ReloadLabels( false );

608

ReloadGenres( false );

609

ReloadAlbumArtists( false );

610

ReloadArtists( false );

611

ReloadComposers( false );

612

ReloadAlbums( false );

613

ReloadYears( false );

614

ReloadRatings( false );

615

ReloadPlayCounts( false );

616

ReloadSongs( false );

600

617

m_UpdateLock = false;

601

618

}

602

619

627

644

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

628

645

void guLibPanel::OnSearchSelected( wxCommandEvent& event )

629

646

{

647

// perform text search immediately

648

649

if( m_TextChangedTimer.IsRunning() )

650

m_TextChangedTimer.Stop();

651

652

if( !DoTextSearch() )

653

return;

654

655

// if text search was successful, possibly enqueue results

656

630

657

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

631

658

if( Config )

632

659

{

633

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

634

{

635

OnSongQueueAllClicked( event );

636

}

637

else

638

{

639

OnSongPlayAllClicked( event );

660

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

661

{

662

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

663

{

664

OnSongQueueAllClicked( event );

665

}

666

else

667

{

668

OnSongPlayAllClicked( event );

669

}

640

670

}

641

671

}

642

672

}

650

680

}

651

681

652

682

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

683

void guLibPanel::OnTextChangedTimer( wxTimerEvent &event )

684

{

685

DoTextSearch();

686

}

687

688

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

689

bool guLibPanel::DoTextSearch( void )

690

{

691

wxString SearchString = m_InputTextCtrl->GetLineText( 0 );

692

if( !SearchString.IsEmpty() )

693

{

694

if( SearchString.Length() > 1 )

695

{

696

wxArrayString Words = guSplitWords( SearchString );

697

698

m_Db->SetTeFilters( Words, m_UpdateLock );

699

if( !m_UpdateLock )

700

{

701

m_UpdateLock = true;

702

ReloadLabels();

703

ReloadGenres();

704

ReloadAlbumArtists();

705

ReloadArtists();

706

ReloadComposers();

707

ReloadAlbums();

708

ReloadYears();

709

ReloadRatings();

710

ReloadPlayCounts();

711

ReloadSongs();

712

m_UpdateLock = false;

713

}

714

m_InputTextCtrl->ShowCancelButton( true );

715

}

716

717

return true;

718

}

719

else

720

{

721

wxArrayString Words;

722

//guLogMessage( wxT( "guLibPanel::SearchCancelled" ) );

723

//m_InputTextCtrl->Clear();

724

m_Db->SetTeFilters( Words, m_UpdateLock );

725

m_UpdateLock = true;

726

// if( !m_UpdateLock )

727

// {

728

ReloadLabels( false );

729

ReloadGenres( false );

730

ReloadAlbumArtists();

731

ReloadArtists( false );

732

ReloadComposers( false );

733

ReloadAlbums( false );

734

ReloadYears( false );

735

ReloadRatings( false );

736

ReloadPlayCounts( false );

737

ReloadSongs( false );

738

m_UpdateLock = false;

739

// }

740

m_InputTextCtrl->ShowCancelButton( false );

741

742

return false;

743

}

744

}

745

746

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

653

747

// GenreListBox Events

654

748

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

655

749

662

756

if( m_SelChangedTimer.IsRunning() )

663

757

m_SelChangedTimer.Stop();

664

758

m_SelChangedTimer.Start( guPANEL_TIMER_SELCHANGED, wxTIMER_ONE_SHOT );

665

// //wxLongLong time = wxGetLocalTimeMillis();

666

// m_Db->SetGeFilters( m_GenreListCtrl->GetSelectedItems(), m_UpdateLock );

667

668

// if( !m_UpdateLock )

669

// {

670

// m_UpdateLock = true;

671

// m_ArtistListCtrl->ReloadItems();

672

// m_AlbumListCtrl->ReloadItems();

673

// m_YearListCtrl->ReloadItems();

674

// m_RatingListCtrl->ReloadItems( false );

675

// m_SongListCtrl->ReloadItems();

676

// m_UpdateLock = false;

677

// }

678

// //time = wxGetLocalTimeMillis() - time;;

679

// //guLogWarning( wxT( "Genre Time : %u ms" ), time.GetLo() );

680

759

}

681

760

682

761

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

731

810

guTrackArray * Tracks = new guTrackArray();

732

811

m_GenreListCtrl->GetSelectedSongs( Tracks );

733

812

734

event.SetId( ID_MAINFRAME_COPYTO );

813

int Index = event.GetId() - ID_GENRE_COPYTO;

814

if( Index > 99 )

815

{

816

Index -= 100;

817

event.SetId( ID_MAINFRAME_COPYTODEVICE_TRACKS );

818

}

819

else

820

{

821

event.SetId( ID_MAINFRAME_COPYTO );

822

}

823

event.SetInt( Index );

735

824

event.SetClientData( ( void * ) Tracks );

736

825

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

737

826

}

738

827

739

828

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

829

void guLibPanel::OnGenreSavePlayListClicked( wxCommandEvent &event )

830

{

831

int index;

832

int count;

833

wxArrayInt NewSongs;

834

guTrackArray Tracks;

835

m_GenreListCtrl->GetSelectedSongs( &Tracks );

836

837

count = Tracks.Count();

838

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

839

{

840

NewSongs.Add( Tracks[ index ].m_SongId );

841

}

842

843

SaveToPlayList( NewSongs );

844

}

845

846

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

740

847

// LabelsListBox Events

741

848

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

742

849

753

860

// if( !m_UpdateLock )

754

861

// {

755

862

// m_UpdateLock = true;

756

// m_GenreListCtrl->ReloadItems();

757

// m_ArtistListCtrl->ReloadItems();

758

// m_AlbumListCtrl->ReloadItems();

759

// m_YearListCtrl->ReloadItems();

760

// m_RatingListCtrl->ReloadItems( false );

761

// m_SongListCtrl->ReloadItems();

863

// ReloadGenres();

864

// ReloadArtists();

865

// ReloadAlbums();

866

// ReloadYears();

867

// ReloadRatings( false );

868

// ReloadSongs();

762

869

// //

763

870

// //

764

871

// m_UpdateLock = false;

823

930

guTrackArray * Tracks = new guTrackArray();

824

931

m_LabelsListCtrl->GetSelectedSongs( Tracks );

825

932

826

event.SetId( ID_MAINFRAME_COPYTO );

933

int Index = event.GetId() - ID_LABEL_COPYTO;

934

if( Index > 99 )

935

{

936

Index -= 100;

937

event.SetId( ID_MAINFRAME_COPYTODEVICE_TRACKS );

938

}

939

else

940

{

941

event.SetId( ID_MAINFRAME_COPYTO );

942

}

943

event.SetInt( Index );

827

944

event.SetClientData( ( void * ) Tracks );

828

945

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

829

946

}

832

949

void guLibPanel::UpdateLabels( void )

833

950

{

834

951

m_UpdateLock = true;

835

m_LabelsListCtrl->ReloadItems( false );

836

m_GenreListCtrl->ReloadItems( false );

837

m_AlbumArtistListCtrl->ReloadItems( false );

838

m_ArtistListCtrl->ReloadItems( false );

839

m_ComposerListCtrl->ReloadItems( false );

840

m_AlbumListCtrl->ReloadItems( false );

841

m_RatingListCtrl->ReloadItems( false );

842

m_YearListCtrl->ReloadItems( false );

843

m_PlayCountListCtrl->ReloadItems( false );

844

m_SongListCtrl->ReloadItems( false );

952

ReloadLabels( false );

953

ReloadGenres( false );

954

ReloadAlbumArtists( false );

955

ReloadArtists( false );

956

ReloadComposers( false );

957

ReloadAlbums( false );

958

ReloadRatings( false );

959

ReloadYears( false );

960

ReloadPlayCounts( false );

961

ReloadSongs( false );

845

962

m_UpdateLock = false;

846

963

}

847

964

848

965

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

966

void guLibPanel::OnLabelSavePlayListClicked( wxCommandEvent &event )

967

{

968

int index;

969

int count;

970

wxArrayInt NewSongs;

971

guTrackArray Tracks;

972

m_LabelsListCtrl->GetSelectedSongs( &Tracks );

973

974

count = Tracks.Count();

975

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

976

{

977

NewSongs.Add( Tracks[ index ].m_SongId );

978

}

979

980

SaveToPlayList( NewSongs );

981

}

982

983

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

849

984

// ArtistListBox Events

850

985

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

851

986

862

997

// if( !m_UpdateLock )

863

998

// {

864

999

// m_UpdateLock = true;

865

// m_AlbumListCtrl->ReloadItems();

866

// m_YearListCtrl->ReloadItems();

867

// m_RatingListCtrl->ReloadItems( false );

868

// m_SongListCtrl->ReloadItems();

1000

// ReloadAlbums();

1001

// ReloadYears();

1002

// ReloadRatings( false );

1003

// ReloadSongs();

869

1004

// m_UpdateLock = false;

870

1005

// }

871

1006

}

942

1077

}

943

1078

944

1079

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

1080

void guLibPanel::DoEditTracks( guTrackArray &tracks, guImagePtrArray &images, wxArrayString &lyrics )

1081

{

1082

guTrackEditor * TrackEditor = new guTrackEditor( this, m_Db, &tracks, &images, &lyrics );

1083

if( TrackEditor )

1084

{

1085

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

1086

{

1087

UpdateTracks( tracks );

1088

UpdateTracksImages( tracks, images );

1089

UpdateTracksLyrics( tracks, lyrics );

1090

1091

// Update the track in database, playlist, etc

1092

( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_NONE, &tracks );

1093

}

1094

guImagePtrArrayClean( &images );

1095

TrackEditor->Destroy();

1096

}

1097

}

1098

1099

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

1100

void guLibPanel::UpdateTracks( const guTrackArray &tracks )

1101

{

1102

m_Db->UpdateSongs( &tracks );

1103

}

1104

1105

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

1106

void guLibPanel::UpdateTracksImages( const guTrackArray &tracks, const guImagePtrArray &images )

1107

{

1108

guUpdateImages( tracks, images );

1109

}

1110

1111

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

1112

void guLibPanel::UpdateTracksLyrics( const guTrackArray &tracks, const wxArrayString &lyrics )

1113

{

1114

guUpdateLyrics( tracks, lyrics );

1115

}

1116

1117

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

945

1118

void guLibPanel::OnArtistEditTracksClicked( wxCommandEvent &event )

946

1119

{

947

1120

guTrackArray Tracks;

951

1124

if( !Tracks.Count() )

952

1125

return;

953

1126

954

guTrackEditor * TrackEditor = new guTrackEditor( this, m_Db, &Tracks, &Images, &Lyrics );

955

if( TrackEditor )

956

{

957

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

958

{

959

m_Db->UpdateSongs( &Tracks );

960

UpdateImages( Tracks, Images );

961

UpdateLyrics( Tracks, Lyrics );

962

963

// Update the track in database, playlist, etc

964

( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_NONE, &Tracks );

965

}

966

guImagePtrArrayClean( &Images );

967

TrackEditor->Destroy();

968

}

1127

DoEditTracks( Tracks, Images, Lyrics );

969

1128

}

970

1129

971

1130

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

974

1133

guTrackArray * Tracks = new guTrackArray();

975

1134

m_ArtistListCtrl->GetSelectedSongs( Tracks );

976

1135

977

event.SetId( ID_MAINFRAME_COPYTO );

1136

int Index = event.GetId() - ID_ARTIST_COPYTO;

1137

if( Index > 99 )

1138

{

1139

Index -= 100;

1140

event.SetId( ID_MAINFRAME_COPYTODEVICE_TRACKS );

1141

}

1142

else

1143

{

1144

event.SetId( ID_MAINFRAME_COPYTO );

1145

}

1146

event.SetInt( Index );

978

1147

event.SetClientData( ( void * ) Tracks );

979

1148

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

980

1149

}

981

1150

1151

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

1152

void guLibPanel::OnArtistSavePlayListClicked( wxCommandEvent &event )

1153

{

1154

int index;

1155

int count;

1156

wxArrayInt NewSongs;

1157

guTrackArray Tracks;

1158

m_ArtistListCtrl->GetSelectedSongs( &Tracks );

1159

1160

count = Tracks.Count();

1161

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

1162

{

1163

NewSongs.Add( Tracks[ index ].m_SongId );

1164

}

1165

1166

SaveToPlayList( NewSongs );

1167

}

1168

982

1169

// -------------------------------------------------------------s------------------- //

983

1170

// AlbumListBox Events

984

1171

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

992

1179

if( m_SelChangedTimer.IsRunning() )

993

1180

m_SelChangedTimer.Stop();

994

1181

m_SelChangedTimer.Start( guPANEL_TIMER_SELCHANGED, wxTIMER_ONE_SHOT );

995

// m_Db->SetAlFilters( m_AlbumListCtrl->GetSelectedItems(), m_UpdateLock );

996

// if( !m_UpdateLock )

997

// {

998

// m_UpdateLock = true;

999

// m_YearListCtrl->ReloadItems();

1000

// m_RatingListCtrl->ReloadItems( false );

1001

// m_SongListCtrl->ReloadItems();

1002

// m_UpdateLock = false;

1003

// }

1004

1182

}

1005

1183

1006

1184

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

1083

1261

m_Db->GetAlbumsSongs( m_AlbumListCtrl->GetSelectedItems(), &Tracks, true );

1084

1262

if( !Tracks.Count() )

1085

1263

return;

1086

guTrackEditor * TrackEditor = new guTrackEditor( this, m_Db, &Tracks, &Images, &Lyrics );

1087

if( TrackEditor )

1088

{

1089

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

1090

{

1091

m_Db->UpdateSongs( &Tracks );

1092

UpdateImages( Tracks, Images );

1093

UpdateLyrics( Tracks, Lyrics );

1094

1095

// Update the track in database, playlist, etc

1096

( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_NONE, &Tracks );

1097

}

1098

guImagePtrArrayClean( &Images );

1099

TrackEditor->Destroy();

1100

}

1264

1265

DoEditTracks( Tracks, Images, Lyrics );

1266

}

1267

1268

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

1269

wxString guLibPanel::GetCoverName( void )

1270

{

1271

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

1272

wxArrayString SearchCovers = Config->ReadAStr( wxT( "Word" ), wxEmptyString, wxT( "CoverSearch" ) );

1273

return ( SearchCovers.Count() ? SearchCovers[ 0 ] : wxT( "cover" ) ) + wxT( ".jpg" );

1274

}

1275

1276

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

1277

bool guLibPanel::SetAlbumCover( const int albumid, const wxString &albumpath, wxImage * coverimg )

1278

{

1279

wxString CoverName = albumpath + GetCoverName();

1280

1281

int MaxSize = GetCoverMaxSize();

1282

if( MaxSize != wxNOT_FOUND )

1283

{

1284

coverimg->Rescale( MaxSize, MaxSize, wxIMAGE_QUALITY_HIGH );

1285

}

1286

1287

if( coverimg->SaveFile( CoverName, GetCoverType() ) )

1288

{

1289

m_Db->SetAlbumCover( albumid, CoverName );

1290

1291

wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED, ID_ALBUM_COVER_CHANGED );

1292

evt.SetInt( albumid );

1293

evt.SetClientData( this );

1294

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

1295

return true;

1296

}

1297

return false;

1298

}

1299

1300

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

1301

bool guLibPanel::SetAlbumCover( const int albumid, const wxString &albumpath, wxString &coverpath )

1302

{

1303

wxString CoverName = albumpath + GetCoverName();

1304

int MaxSize = GetCoverMaxSize();

1305

1306

wxURI Uri( coverpath );

1307

if( Uri.IsReference() )

1308

{

1309

wxImage CoverImage( coverpath );

1310

if( CoverImage.IsOk() )

1311

{

1312

if( MaxSize != wxNOT_FOUND )

1313

{

1314

CoverImage.Rescale( MaxSize, MaxSize, wxIMAGE_QUALITY_HIGH );

1315

}

1316

1317

if( ( coverpath == CoverName ) || CoverImage.SaveFile( CoverName, GetCoverType() ) )

1318

{

1319

m_Db->SetAlbumCover( albumid, CoverName );

1320

1321

wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED, ID_ALBUM_COVER_CHANGED );

1322

evt.SetInt( albumid );

1323

evt.SetClientData( this );

1324

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

1325

return true;

1326

}

1327

}

1328

else

1329

{

1330

guLogError( wxT( "Could not load the imate '%s'" ), coverpath.c_str() );

1331

}

1332

}

1333

else

1334

{

1335

if( DownloadImage( coverpath, CoverName, GetCoverType(), MaxSize, MaxSize ) )

1336

{

1337

m_Db->SetAlbumCover( albumid, CoverName );

1338

1339

wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED, ID_ALBUM_COVER_CHANGED );

1340

evt.SetInt( albumid );

1341

evt.SetClientData( this );

1342

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

1343

return true;

1344

}

1345

else

1346

{

1347

guLogError( wxT( "Failed to download file '%s'" ), coverpath.c_str() );

1348

}

1349

}

1350

return false;

1351

}

1352

1353

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

1354

wxImage * guLibPanel::GetAlbumCover( const int albumid, wxString &coverpath )

1355

{

1356

int CoverId = m_Db->GetAlbumCoverId( albumid );

1357

if( CoverId != wxNOT_FOUND )

1358

{

1359

coverpath = m_Db->GetCoverPath( CoverId );

1360

if( !coverpath.IsEmpty() )

1361

{

1362

wxImage * CoverImage = new wxImage( coverpath, wxBITMAP_TYPE_ANY );

1363

if( CoverImage )

1364

{

1365

if( CoverImage->IsOk() )

1366

{

1367

return CoverImage;

1368

}

1369

delete CoverImage;

1370

}

1371

}

1372

}

1373

return NULL;

1101

1374

}

1102

1375

1103

1376

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

1127

1400

wxImage * CoverImage = CoverEditor->GetSelectedCoverImage();

1128

1401

if( CoverImage )

1129

1402

{

1130

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

1131

wxArrayString SearchCovers = Config->ReadAStr( wxT( "Word" ), wxEmptyString, wxT( "CoverSearch" ) );

1132

wxString CoverName = AlbumPath + ( SearchCovers.Count() ? SearchCovers[ 0 ] : wxT( "cover" ) ) + wxT( ".jpg" );

1133

CoverImage->SaveFile( CoverName, wxBITMAP_TYPE_JPEG );

1134

m_Db->SetAlbumCover( Albums[ 0 ], CoverName );

1135

//AlbumListCtrl->ClearSelection();

1136

//Db->SetAlFilters( wxArrayInt() );

1137

m_AlbumListCtrl->ReloadItems( false );

1138

//guLogMessage( wxT( "Cover downloaded ok\n" ) );

1403

if( SetAlbumCover( Albums[ 0 ], AlbumPath, CoverImage ) )

1404

{

1405

//AlbumListCtrl->ClearSelection();

1406

//Db->SetAlFilters( wxArrayInt() );

1407

ReloadAlbums( false );

1408

//guLogMessage( wxT( "Cover downloaded ok\n" ) );

1409

if( CoverEditor->EmbedToFiles() )

1410

{

1411

OnAlbumEmbedCoverClicked( event );

1412

}

1413

}

1139

1414

}

1140

1415

}

1141

1416

CoverEditor->Destroy();

1157

1432

wxString CoverFile = SelCoverFile->GetSelFile();

1158

1433

if( !CoverFile.IsEmpty() )

1159

1434

{

1160

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

1161

wxArrayString SearchCovers = Config->ReadAStr( wxT( "Word" ), wxEmptyString, wxT( "CoverSearch" ) );

1162

wxString CoverName = SelCoverFile->GetAlbumPath() + ( SearchCovers.Count() ? SearchCovers[ 0 ] : wxT( "cover" ) ) + wxT( ".jpg" );

1435

if( SetAlbumCover( Albums[ 0 ], SelCoverFile->GetAlbumPath(), CoverFile ) )

1436

{

1437

ReloadAlbums( false );

1163

1438

1164

wxURI Uri( CoverFile );

1165

if( Uri.IsReference() )

1166

{

1167

wxImage CoverImage( CoverFile );

1168

if( CoverImage.IsOk() )

1169

{

1170

if( ( CoverFile == CoverName ) || CoverImage.SaveFile( CoverName, wxBITMAP_TYPE_JPEG ) )

1171

{

1172

m_Db->SetAlbumCover( Albums[ 0 ], CoverName );

1173

m_AlbumListCtrl->ReloadItems( false );

1174

}

1175

}

1176

else

1177

{

1178

guLogError( wxT( "Could not load the imate '%s'" ), CoverFile.c_str() );

1179

}

1180

}

1181

else

1182

{

1183

if( DownloadImage( CoverFile, CoverName ) )

1184

{

1185

m_Db->SetAlbumCover( Albums[ 0 ], CoverName );

1186

m_AlbumListCtrl->ReloadItems( false );

1187

}

1188

else

1189

{

1190

guLogError( wxT( "Failed to download file '%s'" ), CoverFile.c_str() );

1439

if( SelCoverFile->EmbedToFiles() )

1440

{

1441

OnAlbumEmbedCoverClicked( event );

1191

1442

}

1192

1443

}

1193

1444

}

1194

1445

}

1195

delete SelCoverFile;

1196

}

1197

}

1198

}

1199

1446

SelCoverFile->Destroy();

1447

}

1448

}

1449

}

1450

1451

1452

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

1453

void guLibPanel::DoDeleteAlbumCover( const int albumid )

1454

{

1455

int CoverId = m_Db->GetAlbumCoverId( albumid );

1456

if( CoverId > 0 )

1457

{

1458

wxString CoverPath = m_Db->GetCoverPath( CoverId );

1459

if( !CoverPath.IsEmpty() )

1460

{

1461

if( !wxRemoveFile( CoverPath ) )

1462

{

1463

guLogError( wxT( "Could not remove the cover file '%s'" ), CoverPath.c_str() );

1464

}

1465

}

1466

}

1467

m_Db->SetAlbumCover( albumid, wxEmptyString );

1468

1469

wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED, ID_ALBUM_COVER_CHANGED );

1470

evt.SetInt( albumid );

1471

evt.SetClientData( this );

1472

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

1473

}

1200

1474

1201

1475

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

1202

1476

void guLibPanel::OnAlbumDeleteCoverClicked( wxCommandEvent &event )

1208

1482

_( "Confirm" ),

1209

1483

wxICON_QUESTION | wxYES_NO | wxCANCEL, this ) == wxYES )

1210

1484

{

1211

int CoverId = m_Db->GetAlbumCoverId( Albums[ 0 ] );

1485

DoDeleteAlbumCover( Albums[ 0 ] );

1486

1487

ReloadAlbums( false );

1488

}

1489

}

1490

}

1491

1492

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

1493

void guLibPanel::OnAlbumEmbedCoverClicked( wxCommandEvent &event )

1494

{

1495

int SelIndex;

1496

int SelCount;

1497

wxArrayInt SelectedAlbums = m_AlbumListCtrl->GetSelectedItems();

1498

if( ( SelCount = SelectedAlbums.Count() ) )

1499

{

1500

for( SelIndex = 0; SelIndex < SelCount; SelIndex++ )

1501

{

1502

wxImage * CoverImage = NULL;

1503

int CoverId = m_Db->GetAlbumCoverId( SelectedAlbums[ SelIndex ] );

1212

1504

if( CoverId > 0 )

1213

1505

{

1214

1506

wxString CoverPath = m_Db->GetCoverPath( CoverId );

1215

wxASSERT( !CoverPath.IsEmpty() );

1216

if( !wxRemoveFile( CoverPath ) )

1217

{

1218

guLogError( wxT( "Could not remove the cover file '%s'" ), CoverPath.c_str() );

1219

}

1220

}

1221

m_Db->SetAlbumCover( Albums[ 0 ], wxEmptyString );

1222

m_AlbumListCtrl->ReloadItems( false );

1223

//bool guDbLibrary::GetAlbumInfo( const int AlbumId, wxString * AlbumName, wxString * ArtistName, wxString * AlbumPath )

1507

1508

CoverImage = new wxImage( CoverPath, wxBITMAP_TYPE_ANY );

1509

if( CoverImage )

1510

{

1511

if( !CoverImage->IsOk() )

1512

{

1513

delete CoverImage;

1514

continue;

1515

}

1516

1517

guImageResize( CoverImage, 600 );

1518

}

1519

else

1520

continue;

1521

}

1522

1523

guTrackArray AlbumTracks;

1524

wxArrayInt Albums;

1525

Albums.Add( SelectedAlbums[ SelIndex ] );

1526

m_Db->GetAlbumsSongs( Albums, &AlbumTracks );

1527

1528

int TrackIndex;

1529

int TrackCount;

1530

if( ( TrackCount = AlbumTracks.Count() ) )

1531

{

1532

for( TrackIndex = 0; TrackIndex < TrackCount; TrackIndex++ )

1533

{

1534

guTagSetPicture( AlbumTracks[ TrackIndex ].m_FileName, CoverImage );

1535

}

1536

}

1537

1538

if( CoverImage )

1539

delete CoverImage;

1224

1540

}

1225

1541

}

1226

1542

}

1228

1544

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

1229

1545

void guLibPanel::OnAlbumCopyToClicked( wxCommandEvent &event )

1230

1546

{

1547

guLogMessage( wxT( "guLibPanel::OnAlbumCopyToClicked %i" ), event.GetId() );

1231

1548

guTrackArray * Tracks = new guTrackArray();

1232

1549

m_AlbumListCtrl->GetSelectedSongs( Tracks );

1233

1550

1234

event.SetId( ID_MAINFRAME_COPYTO );

1551

int Index = event.GetId() - ID_ALBUM_COPYTO;

1552

guLogMessage( wxT( "Index: %i" ), Index );

1553

if( Index > 99 )

1554

{

1555

Index -= 100;

1556

event.SetId( ID_MAINFRAME_COPYTODEVICE_TRACKS );

1557

}

1558

else

1559

{

1560

event.SetId( ID_MAINFRAME_COPYTO );

1561

}

1562

event.SetInt( Index );

1235

1563

event.SetClientData( ( void * ) Tracks );

1236

1564

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

1237

1565

}

1238

1566

1239

1567

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

1568

void guLibPanel::OnAlbumSavePlayListClicked( wxCommandEvent &event )

1569

{

1570

int index;

1571

int count;

1572

wxArrayInt NewSongs;

1573

guTrackArray Tracks;

1574

m_AlbumListCtrl->GetSelectedSongs( &Tracks );

1575

1576

count = Tracks.Count();

1577

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

1578

{

1579

NewSongs.Add( Tracks[ index ].m_SongId );

1580

}

1581

1582

SaveToPlayList( NewSongs );

1583

}

1584

1585

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

1240

1586

// SongListBox Events

1241

1587

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

1242

1588

1356

1702

wxArrayString Lyrics;

1357

1703

if( !Tracks.Count() )

1358

1704

return;

1359

guTrackEditor * TrackEditor = new guTrackEditor( this, m_Db, &Tracks, &Images, &Lyrics );

1360

if( TrackEditor )

1361

{

1362

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

1363

{

1364

m_Db->UpdateSongs( &Tracks );

1365

UpdateImages( Tracks, Images );

1366

UpdateLyrics( Tracks, Lyrics );

1367

1705

1368

// Update the track in database, playlist, etc

1369

( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_NONE, &Tracks );

1370

}

1371

guImagePtrArrayClean( &Images );

1372

TrackEditor->Destroy();

1373

}

1706

DoEditTracks( Tracks, Images, Lyrics );

1374

1707

}

1375

1708

1376

1709

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

1384

1717

1385

1718

if( Tracks.Count() )

1386

1719

{

1387

event.SetId( ID_MAINFRAME_COPYTO );

1720

int Index = event.GetId() - ID_SONG_COPYTO;

1721

if( Index > 99 )

1722

{

1723

Index -= 100;

1724

event.SetId( ID_MAINFRAME_COPYTODEVICE_TRACKS );

1725

}

1726

else

1727

{

1728

event.SetId( ID_MAINFRAME_COPYTO );

1729

}

1730

event.SetInt( Index );

1388

1731

event.SetClientData( ( void * ) new guTrackArray( Tracks ) );

1389

1732

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

1390

1733

}

1391

1734

}

1392

1735

1393

1736

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

1394

void guLibPanel::OnSongSavePlayListClicked( wxCommandEvent &event )

1737

void guLibPanel::SaveToPlayList( const wxArrayInt &tracks )

1395

1738

{

1396

int index;

1397

int count;

1398

wxArrayInt NewSongs;

1399

guTrackArray Tracks;

1400

m_SongListCtrl->GetSelectedSongs( &Tracks );

1401

1402

if( ( count = Tracks.Count() ) )

1403

{

1404

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

1405

{

1406

NewSongs.Add( Tracks[ index ].m_SongId );

1407

}

1408

}

1409

else

1410

{

1411

m_SongListCtrl->GetAllSongs( &Tracks );

1412

count = Tracks.Count();

1413

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

1414

{

1415

NewSongs.Add( Tracks[ index ].m_SongId );

1416

}

1417

}

1418

1419

if( NewSongs.Count() );

1739

if( tracks.Count() );

1420

1740

{

1421

1741

guListItems PlayLists;

1422

m_Db->GetPlayLists( &PlayLists,GUPLAYLIST_STATIC );

1742

m_Db->GetPlayLists( &PlayLists, guPLAYLIST_TYPE_STATIC );

1423

1743

1424

guPlayListAppend * PlayListAppendDlg = new guPlayListAppend( wxTheApp->GetTopWindow(), m_Db, &NewSongs, &PlayLists );

1744

guPlayListAppend * PlayListAppendDlg = new guPlayListAppend( wxTheApp->GetTopWindow(), m_Db, &tracks, &PlayLists );

1425

1745

1426

1746

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

1427

1747

{

1433

1753

{

1434

1754

PLName = _( "UnNamed" );

1435

1755

}

1436

m_Db->CreateStaticPlayList( PLName, NewSongs );

1756

m_Db->CreateStaticPlayList( PLName, tracks );

1437

1757

}

1438

1758

else

1439

1759

{

1442

1762

m_Db->GetPlayListSongIds( PLId, &OldSongs );

1443

1763

if( PlayListAppendDlg->GetSelectedPosition() == 0 ) // BEGIN

1444

1764

{

1445

m_Db->UpdateStaticPlayList( PLId, NewSongs );

1765

m_Db->UpdateStaticPlayList( PLId, tracks );

1446

1766

m_Db->AppendStaticPlayList( PLId, OldSongs );

1447

1767

}

1448

1768

else // END

1449

1769

{

1450

m_Db->AppendStaticPlayList( PLId, NewSongs );

1770

m_Db->AppendStaticPlayList( PLId, tracks );

1451

1771

}

1452

1772

}

1453

wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED, ID_PLAYLIST_UPDATED );

1454

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

1773

UpdatePlaylists();

1455

1774

}

1456

1775

PlayListAppendDlg->Destroy();

1457

1776

}

1458

1777

}

1459

1778

1460

1779

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

1780

void guLibPanel::OnSongSavePlayListClicked( wxCommandEvent &event )

1781

{

1782

int index;

1783

int count;

1784

wxArrayInt NewSongs;

1785

guTrackArray Tracks;

1786

m_SongListCtrl->GetSelectedSongs( &Tracks );

1787

1788

if( ( count = Tracks.Count() ) )

1789

{

1790

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

1791

{

1792

NewSongs.Add( Tracks[ index ].m_SongId );

1793

}

1794

}

1795

else

1796

{

1797

m_SongListCtrl->GetAllSongs( &Tracks );

1798

count = Tracks.Count();

1799

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

1800

{

1801

NewSongs.Add( Tracks[ index ].m_SongId );

1802

}

1803

}

1804

1805

SaveToPlayList( NewSongs );

1806

}

1807

1808

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

1809

void guLibPanel::UpdatePlaylists( void )

1810

{

1811

wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED, ID_PLAYLIST_UPDATED );

1812

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

1813

}

1814

1815

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

1461

1816

void guLibPanel::OnSongSetRating( wxCommandEvent &event )

1462

1817

{

1463

1818

//guLogMessage( wxT( "guLibPanel::OnSongSetRating %i" ), event.GetId() - ID_SONG_SET_RATING_0 );

1475

1830

Tracks[ Index ].m_Rating = Rating;

1476

1831

}

1477

1832

1478

( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_NONE, &Tracks );

1833

UpdatedTracks( &Tracks );

1834

( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_LIBRARY, &Tracks );

1479

1835

}

1480

1836

1481

1837

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

1538

1894

}

1539

1895

}

1540

1896

1541

m_Db->UpdateSongs( &Tracks );

1897

UpdateTracks( Tracks );

1898

1899

( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_NONE, &Tracks );

1542

1900

}

1543

1901

1544

1902

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

1660

2018

}

1661

2019

}

1662

2020

1663

m_Db->UpdateSongs( &Tracks );

2021

UpdateTracks( Tracks );

2022

2023

( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_NONE, &Tracks );

1664

2024

}

1665

2025

FieldEditor->Destroy();

1666

2026

}

1684

2044

ColumnNames[ CurColId ] + ( ( ColId == CurColId ) ? ( m_Db->GetSongsOrderDesc() ? wxT( " ▼" ) : wxT( " ▲" ) ) : wxEmptyString ) );

1685

2045

}

1686

2046

1687

m_SongListCtrl->ReloadItems();

2047

ReloadSongs();

1688

2048

}

1689

2049

1690

2050

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

1771

2131

m_UpdateLock = true;

1772

2132

m_Db->SetTeFilters( Words, false );

1773

2133

ClearSearchText();

1774

m_LabelsListCtrl->ReloadItems();

1775

m_GenreListCtrl->ReloadItems();

1776

m_AlbumArtistListCtrl->ReloadItems();

1777

m_ArtistListCtrl->ReloadItems();

1778

m_ComposerListCtrl->ReloadItems();

1779

m_AlbumListCtrl->ReloadItems();

2134

ReloadLabels();

2135

ReloadGenres();

2136

ReloadAlbumArtists();

2137

ReloadArtists();

2138

ReloadComposers();

2139

ReloadAlbums();

1780

2140

m_UpdateLock = false;

1781

m_SongListCtrl->ReloadItems();

2141

ReloadSongs();

1782

2142

m_SongListCtrl->SetSelection( m_Db->GetTrackIndex( trackid ) );

1783

2143

}

1784

2144

1789

2149

m_UpdateLock = true;

1790

2150

m_Db->SetTeFilters( Words, false );

1791

2151

ClearSearchText();

1792

m_LabelsListCtrl->ReloadItems();

1793

m_GenreListCtrl->ReloadItems();

1794

m_AlbumArtistListCtrl->ReloadItems();

1795

m_ArtistListCtrl->ReloadItems();

1796

m_ComposerListCtrl->ReloadItems();

1797

m_AlbumListCtrl->ReloadItems();

2152

ReloadLabels();

2153

ReloadGenres();

2154

ReloadAlbumArtists();

2155

ReloadArtists();

2156

ReloadComposers();

2157

ReloadAlbums();

1798

2158

m_UpdateLock = false;

1799

2159

m_AlbumListCtrl->SetSelection( m_AlbumListCtrl->FindAlbum( albumid ) );

1800

2160

}

1806

2166

m_UpdateLock = true;

1807

2167

m_Db->SetTeFilters( Words, false );

1808

2168

ClearSearchText();

1809

m_LabelsListCtrl->ReloadItems();

1810

m_GenreListCtrl->ReloadItems();

1811

m_AlbumArtistListCtrl->ReloadItems();

1812

m_ArtistListCtrl->ReloadItems();

1813

m_ComposerListCtrl->ReloadItems();

2169

ReloadLabels();

2170

ReloadGenres();

2171

ReloadAlbumArtists();

2172

ReloadArtists();

2173

ReloadComposers();

1814

2174

m_UpdateLock = false;

1815

2175

m_ArtistListCtrl->SetSelection( m_ArtistListCtrl->FindArtist( artistid ) );

1816

2176

}

1822

2182

m_UpdateLock = true;

1823

2183

m_Db->SetTeFilters( Words, false );

1824

2184

ClearSearchText();

1825

m_LabelsListCtrl->ReloadItems();

1826

m_GenreListCtrl->ReloadItems();

1827

m_AlbumArtistListCtrl->ReloadItems();

1828

m_ArtistListCtrl->ReloadItems();

1829

m_ComposerListCtrl->ReloadItems();

1830

m_YearListCtrl->ReloadItems();

2185

ReloadLabels();

2186

ReloadGenres();

2187

ReloadAlbumArtists();

2188

ReloadArtists();

2189

ReloadComposers();

2190

ReloadYears();

1831

2191

m_UpdateLock = false;

1832

2192

m_YearListCtrl->SetSelection( m_YearListCtrl->FindYear( year ) );

1833

2193

}

1839

2199

m_UpdateLock = true;

1840

2200

m_Db->SetTeFilters( Words, false );

1841

2201

ClearSearchText();

1842

m_LabelsListCtrl->ReloadItems();

1843

m_GenreListCtrl->ReloadItems();

1844

m_AlbumArtistListCtrl->ReloadItems();

1845

m_ArtistListCtrl->ReloadItems();

1846

m_ComposerListCtrl->ReloadItems();

1847

m_AlbumListCtrl->ReloadItems();

2202

ReloadLabels();

2203

ReloadGenres();

2204

ReloadAlbumArtists();

2205

ReloadArtists();

2206

ReloadComposers();

2207

ReloadAlbums();

1848

2208

m_UpdateLock = false;

1849

2209

m_AlbumListCtrl->SelectAlbumName( album );

1850

2210

}

1856

2216

m_UpdateLock = true;

1857

2217

m_Db->SetTeFilters( Words, false );

1858

2218

ClearSearchText();

1859

m_LabelsListCtrl->ReloadItems();

1860

m_GenreListCtrl->ReloadItems();

1861

m_AlbumArtistListCtrl->ReloadItems();

1862

m_ArtistListCtrl->ReloadItems();

1863

m_ComposerListCtrl->ReloadItems();

2219

ReloadLabels();

2220

ReloadGenres();

2221

ReloadAlbumArtists();

2222

ReloadArtists();

2223

ReloadComposers();

1864

2224

m_UpdateLock = false;

1865

2225

m_ArtistListCtrl->SelectArtistName( artist );

1866

2226

}

1872

2232

m_UpdateLock = true;

1873

2233

m_Db->SetTeFilters( Words, false );

1874

2234

ClearSearchText();

1875

m_LabelsListCtrl->ReloadItems();

1876

m_GenreListCtrl->ReloadItems();

2235

ReloadLabels();

2236

ReloadGenres();

1877

2237

m_UpdateLock = false;

1878

2238

m_GenreListCtrl->SetSelectedItems( * genres );

1879

2239

}

1885

2245

m_UpdateLock = true;

1886

2246

m_Db->SetTeFilters( Words, false );

1887

2247

ClearSearchText();

1888

m_LabelsListCtrl->ReloadItems();

1889

m_GenreListCtrl->ReloadItems();

1890

m_AlbumArtistListCtrl->ReloadItems();

1891

m_ArtistListCtrl->ReloadItems();

1892

m_ComposerListCtrl->ReloadItems();

2248

ReloadLabels();

2249

ReloadGenres();

2250

ReloadAlbumArtists();

2251

ReloadArtists();

2252

ReloadComposers();

1893

2253

m_UpdateLock = false;

1894

2254

m_ArtistListCtrl->SetSelectedItems( * artists );

1895

2255

}

1901

2261

m_UpdateLock = true;

1902

2262

m_Db->SetTeFilters( Words, false );

1903

2263

ClearSearchText();

1904

m_LabelsListCtrl->ReloadItems();

1905

m_GenreListCtrl->ReloadItems();

1906

m_ComposerListCtrl->ReloadItems();

1907

m_AlbumArtistListCtrl->ReloadItems();

1908

// m_ArtistListCtrl->ReloadItems();

2264

ReloadLabels();

2265

ReloadGenres();

2266

ReloadComposers();

2267

ReloadAlbumArtists();

2268

// ReloadArtists();

1909

2269

m_UpdateLock = false;

1910

2270

m_AlbumArtistListCtrl->SetSelectedItems( * ids );

1911

2271

}

1917

2277

m_UpdateLock = true;

1918

2278

m_Db->SetTeFilters( Words, false );

1919

2279

ClearSearchText();

1920

m_LabelsListCtrl->ReloadItems();

1921

m_GenreListCtrl->ReloadItems();

1922

m_AlbumArtistListCtrl->ReloadItems();

1923

m_ArtistListCtrl->ReloadItems();

1924

m_ComposerListCtrl->ReloadItems();

1925

m_AlbumListCtrl->ReloadItems();

2280

ReloadLabels();

2281

ReloadGenres();

2282

ReloadAlbumArtists();

2283

ReloadArtists();

2284

ReloadComposers();

2285

ReloadAlbums();

1926

2286

m_UpdateLock = false;

1927

2287

m_AlbumListCtrl->SetSelectedItems( * albums );

1928

2288

}

1940

2300

// if( !m_UpdateLock )

1941

2301

// {

1942

2302

// m_UpdateLock = true;

1943

// m_SongListCtrl->ReloadItems();

2303

// ReloadSongs();

1944

2304

// m_UpdateLock = false;

1945

2305

// }

1946

2306

}

2001

2361

if( !Tracks.Count() )

2002

2362

return;

2003

2363

2004

guTrackEditor * TrackEditor = new guTrackEditor( this, m_Db, &Tracks, &Images, &Lyrics );

2005

if( TrackEditor )

2006

{

2007

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

2008

{

2009

m_Db->UpdateSongs( &Tracks );

2010

UpdateImages( Tracks, Images );

2011

UpdateLyrics( Tracks, Lyrics );

2012

2013

// Update the track in database, playlist, etc

2014

( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_NONE, &Tracks );

2015

}

2016

guImagePtrArrayClean( &Images );

2017

TrackEditor->Destroy();

2018

}

2364

DoEditTracks( Tracks, Images, Lyrics );

2019

2365

}

2020

2366

2021

2367

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

2024

2370

guTrackArray * Tracks = new guTrackArray();

2025

2371

m_YearListCtrl->GetSelectedSongs( Tracks );

2026

2372

2027

event.SetId( ID_MAINFRAME_COPYTO );

2373

int Index = event.GetId() - ID_YEAR_COPYTO;

2374

if( Index > 99 )

2375

{

2376

Index -= 100;

2377

event.SetId( ID_MAINFRAME_COPYTODEVICE_TRACKS );

2378

}

2379

else

2380

{

2381

event.SetId( ID_MAINFRAME_COPYTO );

2382

}

2383

event.SetInt( Index );

2028

2384

event.SetClientData( ( void * ) Tracks );

2029

2385

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

2030

2386

}

2031

2387

2032

2388

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

2389

void guLibPanel::OnYearSavePlayListClicked( wxCommandEvent &event )

2390

{

2391

int index;

2392

int count;

2393

wxArrayInt NewSongs;

2394

guTrackArray Tracks;

2395

m_YearListCtrl->GetSelectedSongs( &Tracks );

2396

2397

count = Tracks.Count();

2398

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

2399

{

2400

NewSongs.Add( Tracks[ index ].m_SongId );

2401

}

2402

2403

SaveToPlayList( NewSongs );

2404

}

2405

2406

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

2033

2407

// Rating List Box

2034

2408

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

2035

2409

void guLibPanel::OnRatingListSelected( wxListEvent &event )

2044

2418

// if( !m_UpdateLock )

2045

2419

// {

2046

2420

// m_UpdateLock = true;

2047

// m_SongListCtrl->ReloadItems();

2421

// ReloadSongs();

2048

2422

// m_UpdateLock = false;

2049

2423

// }

2050

2424

}

2105

2479

if( !Tracks.Count() )

2106

2480

return;

2107

2481

2108

guTrackEditor * TrackEditor = new guTrackEditor( this, m_Db, &Tracks, &Images, &Lyrics );

2109

if( TrackEditor )

2110

{

2111

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

2112

{

2113

m_Db->UpdateSongs( &Tracks );

2114

UpdateImages( Tracks, Images );

2115

UpdateLyrics( Tracks, Lyrics );

2116

2117

// Update the track in database, playlist, etc

2118

( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_NONE, &Tracks );

2119

}

2120

guImagePtrArrayClean( &Images );

2121

TrackEditor->Destroy();

2122

}

2482

DoEditTracks( Tracks, Images, Lyrics );

2123

2483

}

2124

2484

2125

2485

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

2128

2488

guTrackArray * Tracks = new guTrackArray();

2129

2489

m_RatingListCtrl->GetSelectedSongs( Tracks );

2130

2490

2131

event.SetId( ID_MAINFRAME_COPYTO );

2491

int Index = event.GetId() - ID_RATING_COPYTO;

2492

if( Index > 99 )

2493

{

2494

Index -= 100;

2495

event.SetId( ID_MAINFRAME_COPYTODEVICE_TRACKS );

2496

}

2497

else

2498

{

2499

event.SetId( ID_MAINFRAME_COPYTO );

2500

}

2501

event.SetInt( Index );

2132

2502

event.SetClientData( ( void * ) Tracks );

2133

2503

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

2134

2504

}

2135

2505

2136

2506

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

2507

void guLibPanel::OnRatingSavePlayListClicked( wxCommandEvent &event )

2508

{

2509

int index;

2510

int count;

2511

wxArrayInt NewSongs;

2512

guTrackArray Tracks;

2513

m_RatingListCtrl->GetSelectedSongs( &Tracks );

2514

2515

count = Tracks.Count();

2516

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

2517

{

2518

NewSongs.Add( Tracks[ index ].m_SongId );

2519

}

2520

2521

SaveToPlayList( NewSongs );

2522

}

2523

2524

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

2137

2525

// PlayCount List Box

2138

2526

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

2139

2527

void guLibPanel::OnPlayCountListSelected( wxListEvent &event )

2148

2536

// if( !m_UpdateLock )

2149

2537

// {

2150

2538

// m_UpdateLock = true;

2151

// m_SongListCtrl->ReloadItems();

2539

// ReloadSongs();

2152

2540

// m_UpdateLock = false;

2153

2541

// }

2154

2542

}

2209

2597

if( !Tracks.Count() )

2210

2598

return;

2211

2599

2212

guTrackEditor * TrackEditor = new guTrackEditor( this, m_Db, &Tracks, &Images, &Lyrics );

2213

if( TrackEditor )

2214

{

2215

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

2216

{

2217

m_Db->UpdateSongs( &Tracks );

2218

UpdateImages( Tracks, Images );

2219

UpdateLyrics( Tracks, Lyrics );

2220

2221

// Update the track in database, playlist, etc

2222

( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_NONE, &Tracks );

2223

}

2224

guImagePtrArrayClean( &Images );

2225

TrackEditor->Destroy();

2226

}

2600

DoEditTracks( Tracks, Images, Lyrics );

2227

2601

}

2228

2602

2229

2603

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

2232

2606

guTrackArray * Tracks = new guTrackArray();

2233

2607

m_PlayCountListCtrl->GetSelectedSongs( Tracks );

2234

2608

2235

event.SetId( ID_MAINFRAME_COPYTO );

2609

int Index = event.GetId() - ID_PLAYCOUNT_COPYTO;

2610

if( Index > 99 )

2611

{

2612

Index -= 100;

2613

event.SetId( ID_MAINFRAME_COPYTODEVICE_TRACKS );

2614

}

2615

else

2616

{

2617

event.SetId( ID_MAINFRAME_COPYTO );

2618

}

2619

event.SetInt( Index );

2236

2620

event.SetClientData( ( void * ) Tracks );

2237

2621

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

2238

2622

}

2239

2623

2240

2624

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

2625

void guLibPanel::OnPlayCountSavePlayListClicked( wxCommandEvent &event )

2626

{

2627

int index;

2628

int count;

2629

wxArrayInt NewSongs;

2630

guTrackArray Tracks;

2631

m_PlayCountListCtrl->GetSelectedSongs( &Tracks );

2632

2633

count = Tracks.Count();

2634

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

2635

{

2636

NewSongs.Add( Tracks[ index ].m_SongId );

2637

}

2638

2639

SaveToPlayList( NewSongs );

2640

}

2641

2642

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

2241

2643

// Composers List Box

2242

2644

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

2243

2645

void guLibPanel::OnComposerListSelected( wxListEvent &event )

2252

2654

// if( !m_UpdateLock )

2253

2655

// {

2254

2656

// m_UpdateLock = true;

2255

// m_SongListCtrl->ReloadItems();

2657

// ReloadSongs();

2256

2658

// m_UpdateLock = false;

2257

2659

// }

2258

2660

}

2284

2686

{

2285

2687

guTrackArray Songs;

2286

2688

m_ComposerListCtrl->GetSelectedSongs( &Songs );

2689

2287

2690

m_PlayerPanel->SetPlayList( Songs );

2288

2691

}

2289

2692

2292

2695

{

2293

2696

guTrackArray Songs;

2294

2697

m_ComposerListCtrl->GetSelectedSongs( &Songs );

2698

2295

2699

m_PlayerPanel->AddToPlayList( Songs );

2296

2700

}

2297

2701

2300

2704

{

2301

2705

guTrackArray Songs;

2302

2706

m_ComposerListCtrl->GetSelectedSongs( &Songs );

2707

2303

2708

m_PlayerPanel->AddToPlayList( Songs, true, true );

2304

2709

}

2305

2710

2313

2718

if( !Tracks.Count() )

2314

2719

return;

2315

2720

2316

guTrackEditor * TrackEditor = new guTrackEditor( this, m_Db, &Tracks, &Images, &Lyrics );

2317

if( TrackEditor )

2318

{

2319

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

2320

{

2321

m_Db->UpdateSongs( &Tracks );

2322

UpdateImages( Tracks, Images );

2323

UpdateLyrics( Tracks, Lyrics );

2324

2325

// Update the track in database, playlist, etc

2326

( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_NONE, &Tracks );

2327

}

2328

guImagePtrArrayClean( &Images );

2329

TrackEditor->Destroy();

2330

}

2721

DoEditTracks( Tracks, Images, Lyrics );

2331

2722

}

2332

2723

2333

2724

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

2336

2727

guTrackArray * Tracks = new guTrackArray();

2337

2728

m_ComposerListCtrl->GetSelectedSongs( Tracks );

2338

2729

2339

event.SetId( ID_MAINFRAME_COPYTO );

2730

int Index = event.GetId() - ID_COMPOSER_COPYTO;

2731

if( Index > 99 )

2732

{

2733

Index -= 100;

2734

event.SetId( ID_MAINFRAME_COPYTODEVICE_TRACKS );

2735

}

2736

else

2737

{

2738

event.SetId( ID_MAINFRAME_COPYTO );

2739

}

2740

event.SetInt( Index );

2340

2741

event.SetClientData( ( void * ) Tracks );

2341

2742

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

2342

2743

}

2343

2744

2344

2745

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

2746

void guLibPanel::OnComposerSavePlayListClicked( wxCommandEvent &event )

2747

{

2748

int index;

2749

int count;

2750

wxArrayInt NewSongs;

2751

guTrackArray Tracks;

2752

m_ComposerListCtrl->GetSelectedSongs( &Tracks );

2753

2754

count = Tracks.Count();

2755

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

2756

{

2757

NewSongs.Add( Tracks[ index ].m_SongId );

2758

}

2759

2760

SaveToPlayList( NewSongs );

2761

}

2762

2763

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

2345

2764

// Album Artists List Box

2346

2765

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

2347

2766

void guLibPanel::OnAlbumArtistListSelected( wxListEvent &event )

2381

2800

{

2382

2801

guTrackArray Songs;

2383

2802

m_AlbumArtistListCtrl->GetSelectedSongs( &Songs );

2803

2384

2804

m_PlayerPanel->SetPlayList( Songs );

2385

2805

}

2386

2806

2389

2809

{

2390

2810

guTrackArray Songs;

2391

2811

m_AlbumArtistListCtrl->GetSelectedSongs( &Songs );

2812

2392

2813

m_PlayerPanel->AddToPlayList( Songs );

2393

2814

}

2394

2815

2397

2818

{

2398

2819

guTrackArray Songs;

2399

2820

m_AlbumArtistListCtrl->GetSelectedSongs( &Songs );

2821

2400

2822

m_PlayerPanel->AddToPlayList( Songs, true, true );

2401

2823

}

2402

2824

2410

2832

if( !Tracks.Count() )

2411

2833

return;

2412

2834

2413

guTrackEditor * TrackEditor = new guTrackEditor( this, m_Db, &Tracks, &Images, &Lyrics );

2414

if( TrackEditor )

2415

{

2416

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

2417

{

2418

m_Db->UpdateSongs( &Tracks );

2419

UpdateImages( Tracks, Images );

2420

UpdateLyrics( Tracks, Lyrics );

2421

2422

// Update the track in database, playlist, etc

2423

( ( guMainFrame * ) wxTheApp->GetTopWindow() )->UpdatedTracks( guUPDATED_TRACKS_NONE, &Tracks );

2424

}

2425

guImagePtrArrayClean( &Images );

2426

TrackEditor->Destroy();

2427

}

2835

DoEditTracks( Tracks, Images, Lyrics );

2428

2836

}

2429

2837

2430

2838

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

2433

2841

guTrackArray * Tracks = new guTrackArray();

2434

2842

m_AlbumArtistListCtrl->GetSelectedSongs( Tracks );

2435

2843

2436

event.SetId( ID_MAINFRAME_COPYTO );

2844

int Index = event.GetId() - ID_ALBUMARTIST_COPYTO;

2845

if( Index > 99 )

2846

{

2847

Index -= 100;

2848

event.SetId( ID_MAINFRAME_COPYTODEVICE_TRACKS );

2849

}

2850

else

2851

{

2852

event.SetId( ID_MAINFRAME_COPYTO );

2853

}

2854

event.SetInt( Index );

2437

2855

event.SetClientData( ( void * ) Tracks );

2438

2856

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

2439

2857

}

2440

2858

2859

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

2860

void guLibPanel::OnAlbumArtistSavePlayListClicked( wxCommandEvent &event )

2861

{

2862

int index;

2863

int count;

2864

wxArrayInt NewSongs;

2865

guTrackArray Tracks;

2866

m_AlbumArtistListCtrl->GetSelectedSongs( &Tracks );

2867

2868

count = Tracks.Count();

2869

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

2870

{

2871

NewSongs.Add( Tracks[ index ].m_SongId );

2872

}

2873

2874

SaveToPlayList( NewSongs );

2875

}

2876

2877

2441

2878

2442

2879

2443

2880

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

2526

2963

2527

2964

if( PaneName == wxT( "TextSearch" ) )

2528

2965

{

2529

CmdId = ID_MENU_VIEW_LIB_TEXTSEARCH;

2966

CmdId = guLIBRARY_ELEMENT_TEXTSEARCH;

2530

2967

}

2531

2968

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

2532

2969

{

2533

CmdId = ID_MENU_VIEW_LIB_LABELS;

2970

CmdId = guLIBRARY_ELEMENT_LABELS;

2534

2971

}

2535

2972

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

2536

2973

{

2537

CmdId = ID_MENU_VIEW_LIB_GENRES;

2974

CmdId = guLIBRARY_ELEMENT_GENRES;

2538

2975

}

2539

2976

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

2540

2977

{

2541

CmdId = ID_MENU_VIEW_LIB_ARTISTS;

2978

CmdId = guLIBRARY_ELEMENT_ARTISTS;

2542

2979

}

2543

2980

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

2544

2981

{

2545

CmdId = ID_MENU_VIEW_LIB_COMPOSERS;

2982

CmdId = guLIBRARY_ELEMENT_COMPOSERS;

2546

2983

}

2547

2984

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

2548

2985

{

2549

CmdId = ID_MENU_VIEW_LIB_ALBUMARTISTS;

2986

CmdId = guLIBRARY_ELEMENT_ALBUMARTISTS;

2550

2987

}

2551

2988

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

2552

2989

{

2553

CmdId = ID_MENU_VIEW_LIB_ALBUMS;

2990

CmdId = guLIBRARY_ELEMENT_ALBUMS;

2554

2991

}

2555

2992

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

2556

2993

{

2557

CmdId = ID_MENU_VIEW_LIB_YEARS;

2994

CmdId = guLIBRARY_ELEMENT_YEARS;

2558

2995

}

2559

2996

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

2560

2997

{

2561

CmdId = ID_MENU_VIEW_LIB_RATINGS;

2998

CmdId = guLIBRARY_ELEMENT_RATINGS;

2562

2999

}

2563

3000

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

2564

3001

{

2565

CmdId = ID_MENU_VIEW_LIB_PLAYCOUNT;

3002

CmdId = guLIBRARY_ELEMENT_PLAYCOUNT;

2566

3003

}

2567

3004

2568

3005

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

2569

3006

if( CmdId )

2570

3007

{

2571

wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED, CmdId );

3008

wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED, m_BaseCommand + CmdId );

2572

3009

AddPendingEvent( evt );

2573

3010

}

2574

3011

2583

3020

}

2584

3021

2585

3022

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

2586

void guLibPanel::OnTextChangedTimer( wxTimerEvent &event )

2587

{

2588

wxString SearchString = m_InputTextCtrl->GetLineText( 0 );

2589

if( !SearchString.IsEmpty() )

2590

{

2591

if( SearchString.Length() > 1 )

2592

{

2593

wxArrayString Words = guSplitWords( SearchString );

2594

2595

m_Db->SetTeFilters( Words, m_UpdateLock );

2596

if( !m_UpdateLock )

2597

{

2598

m_UpdateLock = true;

2599

m_LabelsListCtrl->ReloadItems();

2600

m_GenreListCtrl->ReloadItems();

2601

m_AlbumArtistListCtrl->ReloadItems();

2602

m_ArtistListCtrl->ReloadItems();

2603

m_ComposerListCtrl->ReloadItems();

2604

m_AlbumListCtrl->ReloadItems();

2605

m_YearListCtrl->ReloadItems();

2606

m_RatingListCtrl->ReloadItems();

2607

m_PlayCountListCtrl->ReloadItems();

2608

m_SongListCtrl->ReloadItems();

2609

m_UpdateLock = false;

2610

}

2611

m_InputTextCtrl->ShowCancelButton( true );

2612

}

2613

}

2614

else

2615

{

2616

wxArrayString Words;

2617

//guLogMessage( wxT( "guLibPanel::SearchCancelled" ) );

2618

//m_InputTextCtrl->Clear();

2619

m_Db->SetTeFilters( Words, m_UpdateLock );

2620

m_UpdateLock = true;

2621

// if( !m_UpdateLock )

2622

// {

2623

m_LabelsListCtrl->ReloadItems( false );

2624

m_GenreListCtrl->ReloadItems( false );

2625

m_AlbumArtistListCtrl->ReloadItems();

2626

m_ArtistListCtrl->ReloadItems( false );

2627

m_ComposerListCtrl->ReloadItems( false );

2628

m_AlbumListCtrl->ReloadItems( false );

2629

m_YearListCtrl->ReloadItems( false );

2630

m_RatingListCtrl->ReloadItems( false );

2631

m_PlayCountListCtrl->ReloadItems( false );

2632

m_SongListCtrl->ReloadItems( false );

2633

m_UpdateLock = false;

2634

// }

2635

m_InputTextCtrl->ShowCancelButton( false );

2636

}

2637

}

2638

2639

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

2640

3023

void guLibPanel::DoSelectionChanged( void )

2641

3024

{

2642

3025

switch( m_SelChangedObject )

2652

3035

if( !m_UpdateLock )

2653

3036

{

2654

3037

m_UpdateLock = true;

2655

m_GenreListCtrl->ReloadItems();

2656

m_ComposerListCtrl->ReloadItems();

2657

m_AlbumArtistListCtrl->ReloadItems();

2658

m_ArtistListCtrl->ReloadItems();

2659

m_AlbumListCtrl->ReloadItems();

2660

m_YearListCtrl->ReloadItems();

2661

m_RatingListCtrl->ReloadItems();

2662

m_PlayCountListCtrl->ReloadItems();

2663

m_SongListCtrl->ReloadItems();

3038

ReloadGenres();

3039

ReloadComposers();

3040

ReloadAlbumArtists();

3041

ReloadArtists();

3042

ReloadAlbums();

3043

ReloadYears();

3044

ReloadRatings();

3045

ReloadPlayCounts();

3046

ReloadSongs();

2664

3047

2665

3048

2666

3049

m_UpdateLock = false;

2676

3059

if( !m_UpdateLock )

2677

3060

{

2678

3061

m_UpdateLock = true;

2679

m_ComposerListCtrl->ReloadItems();

2680

m_AlbumArtistListCtrl->ReloadItems();

2681

m_ArtistListCtrl->ReloadItems();

2682

m_YearListCtrl->ReloadItems();

2683

m_AlbumListCtrl->ReloadItems();

2684

m_RatingListCtrl->ReloadItems();

2685

m_PlayCountListCtrl->ReloadItems();

2686

m_SongListCtrl->ReloadItems();

3062

ReloadComposers();

3063

ReloadAlbumArtists();

3064

ReloadArtists();

3065

ReloadYears();

3066

ReloadAlbums();

3067

ReloadRatings();

3068

ReloadPlayCounts();

3069

ReloadSongs();

2687

3070

m_UpdateLock = false;

2688

3071

}

2689

3072

//time = wxGetLocalTimeMillis() - time;;

2697

3080

if( !m_UpdateLock )

2698

3081

{

2699

3082

m_UpdateLock = true;

2700

m_AlbumListCtrl->ReloadItems();

2701

m_YearListCtrl->ReloadItems();

2702

m_RatingListCtrl->ReloadItems();

2703

m_PlayCountListCtrl->ReloadItems();

2704

m_SongListCtrl->ReloadItems();

3083

ReloadAlbums();

3084

ReloadYears();

3085

ReloadRatings();

3086

ReloadPlayCounts();

3087

ReloadSongs();

2705

3088

m_UpdateLock = false;

2706

3089

}

2707

3090

break;

2713

3096

if( !m_UpdateLock )

2714

3097

{

2715

3098

m_UpdateLock = true;

2716

m_AlbumListCtrl->ReloadItems();

2717

m_RatingListCtrl->ReloadItems();

2718

m_PlayCountListCtrl->ReloadItems();

2719

m_SongListCtrl->ReloadItems();

3099

ReloadAlbums();

3100

ReloadRatings();

3101

ReloadPlayCounts();

3102

ReloadSongs();

2720

3103

m_UpdateLock = false;

2721

3104

}

2722

3105

break;

2728

3111

if( !m_UpdateLock )

2729

3112

{

2730

3113

m_UpdateLock = true;

2731

m_RatingListCtrl->ReloadItems();

2732

m_PlayCountListCtrl->ReloadItems();

2733

m_SongListCtrl->ReloadItems();

3114

ReloadRatings();

3115

ReloadPlayCounts();

3116

ReloadSongs();

2734

3117

m_UpdateLock = false;

2735

3118

}

2736

3119

break;

2742

3125

if( !m_UpdateLock )

2743

3126

{

2744

3127

m_UpdateLock = true;

2745

m_SongListCtrl->ReloadItems();

3128

ReloadSongs();

2746

3129

m_UpdateLock = false;

2747

3130

}

2748

3131

break;

2754

3137

if( !m_UpdateLock )

2755

3138

{

2756

3139

m_UpdateLock = true;

2757

m_SongListCtrl->ReloadItems();

3140

ReloadSongs();

2758

3141

m_UpdateLock = false;

2759

3142

}

2760

3143

break;

2766

3149

if( !m_UpdateLock )

2767

3150

{

2768

3151

m_UpdateLock = true;

2769

m_AlbumArtistListCtrl->ReloadItems();

2770

m_ArtistListCtrl->ReloadItems();

2771

m_YearListCtrl->ReloadItems();

2772

m_AlbumListCtrl->ReloadItems();

2773

m_RatingListCtrl->ReloadItems();

2774

m_PlayCountListCtrl->ReloadItems();

2775

m_SongListCtrl->ReloadItems();

3152

ReloadAlbumArtists();

3153

ReloadArtists();

3154

ReloadYears();

3155

ReloadAlbums();

3156

ReloadRatings();

3157

ReloadPlayCounts();

3158

ReloadSongs();

2776

3159

m_UpdateLock = false;

2777

3160

}

2778

3161

break;

2784

3167

if( !m_UpdateLock )

2785

3168

{

2786

3169

m_UpdateLock = true;

2787

m_ComposerListCtrl->ReloadItems();

2788

m_ArtistListCtrl->ReloadItems();

2789

m_YearListCtrl->ReloadItems();

2790

m_AlbumListCtrl->ReloadItems();

2791

m_RatingListCtrl->ReloadItems();

2792

m_PlayCountListCtrl->ReloadItems();

2793

m_SongListCtrl->ReloadItems();

3170

ReloadComposers();

3171

ReloadArtists();

3172

ReloadYears();

3173

ReloadAlbums();

3174

ReloadRatings();

3175

ReloadPlayCounts();

3176

ReloadSongs();

2794

3177

m_UpdateLock = false;

2795

3178

}

2796

3179

break;

2811

3194

2812

3195

m_Db->DeleteLibraryTracks( &Tracks, true );

2813

3196

2814

ReloadControls( event );

3197

ReloadControls();

3198

}

3199

}

3200

}

3201

3202

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

3203

bool guIsDirectoryEmpty( const wxString &path )

3204

{

3205

wxString FileName;

3206

wxString Path= path;

3207

wxDir Dir;

3208

3209

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

3210

Path += wxT( "/" );

3211

3212

Dir.Open( Path );

3213

3214

if( Dir.IsOpened() )

3215

{

3216

if( Dir.GetFirst( &FileName, wxEmptyString, wxDIR_FILES | wxDIR_DIRS ) )

3217

{

3218

do {

3219

if( FileName[ 0 ] == '.' )

3220

continue;

3221

if( Dir.Exists( Path + FileName ) )

3222

{

3223

if( !guIsDirectoryEmpty( Path + FileName ) )

3224

return false;

3225

}

3226

else

3227

{

3228

if( guIsValidAudioFile( FileName.Lower() ) )

3229

return false;

3230

}

3231

} while( Dir.GetNext( &FileName ) );

3232

}

3233

}

3234

3235

return true;

3236

}

3237

3238

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

3239

bool guRmDirRecursive( const wxString &path )

3240

{

3241

wxString FileName;

3242

wxString Path= path;

3243

wxDir Dir;

3244

3245

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

3246

Path += wxT( "/" );

3247

3248

Dir.Open( Path );

3249

3250

if( Dir.IsOpened() )

3251

{

3252

if( Dir.GetFirst( &FileName, wxEmptyString, wxDIR_FILES | wxDIR_DIRS ) )

3253

{

3254

do {

3255

if( FileName[ 0 ] == '.' )

3256

continue;

3257

if( Dir.Exists( Path + FileName ) )

3258

{

3259

if( !guRmDirRecursive( Path + FileName ) )

3260

return false;

3261

}

3262

else

3263

{

3264

if( !wxRemoveFile( Path + FileName ) )

3265

return false;

3266

}

3267

} while( Dir.GetNext( &FileName ) );

3268

}

3269

}

3270

3271

if( !wxRmdir( Path ) )

3272

{

3273

guLogMessage( wxT( "Could not delete the dir %s" ), Path.c_str() );

3274

return false;

3275

}

3276

3277

return true;

3278

}

3279

3280

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

3281

void guLibPanel::DeleteTracks( guTrackArray * tracks )

3282

{

3283

m_Db->DeleteLibraryTracks( tracks, false );

3284

3285

wxArrayString DeletePaths;

3286

int Index;

3287

int Count = tracks->Count();

3288

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

3289

{

3290

guTrack &CurTrack = tracks->Item( Index );

3291

if( DeletePaths.Index( wxPathOnly( CurTrack.m_FileName ) ) == wxNOT_FOUND )

3292

{

3293

DeletePaths.Add( wxPathOnly( CurTrack.m_FileName ) );

3294

}

3295

3296

if( !wxRemoveFile( CurTrack.m_FileName ) )

3297

{

3298

guLogMessage( wxT( "Error deleting '%s'" ), CurTrack.m_FileName.c_str() );

3299

}

3300

guLogMessage( wxT( "Deleted '%s'" ), CurTrack.m_FileName.c_str() );

3301

}

3302

3303

if( ( Count = DeletePaths.Count() ) )

3304

{

3305

wxArrayString LibPaths = GetLibraryPaths();

3306

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

3307

{

3308

guLogMessage( wxT( "Libath: %s"), LibPaths[ Index ].c_str() );

3309

}

3310

3311

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

3312

{

3313

wxString CurPath = DeletePaths[ Index ];

3314

while( !CurPath.IsEmpty() && LibPaths.Index( CurPath + wxT( "/" ) ) == wxNOT_FOUND )

3315

{

3316

guLogMessage( wxT( "Deleting '%s'" ), CurPath.c_str() );

3317

if( guIsDirectoryEmpty( CurPath ) )

3318

{

3319

if( !guRmDirRecursive( CurPath ) )

3320

{

3321

guLogMessage( wxT( "Error removing dir '%s'" ), DeletePaths[ Index ].c_str() );

3322

break;

3323

}

3324

}

3325

else

3326

{

3327

break;

3328

}

3329

CurPath = CurPath.BeforeLast( wxT( '/' ) );

3330

}

2815

3331

}

2816

3332

}

2817

3333

}

2821

3337

{

2822

3338

if( m_SongListCtrl->GetSelectedCount() )

2823

3339

{

2824

if( wxMessageBox( wxT( "Are you sure to delete the selected tracks from your drive?\nThis will permanently erase the selected tracks." ),

2825

wxT( "Remove tracks from drive" ), wxICON_QUESTION | wxYES | wxNO | wxCANCEL | wxNO_DEFAULT ) == wxYES )

3340

if( wxMessageBox( _( "Are you sure to delete the selected tracks from your drive?\nThis will permanently erase the selected tracks." ),

3341

_( "Remove tracks from drive" ), wxICON_QUESTION | wxYES | wxNO | wxCANCEL | wxNO_DEFAULT ) == wxYES )

2826

3342

{

2827

3343

guTrackArray Tracks;

2828

3344

m_SongListCtrl->GetSelectedSongs( &Tracks );

2829

3345

2830

m_Db->DeleteLibraryTracks( &Tracks, false );

2831

2832

int Index;

2833

int Count = Tracks.Count();

2834

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

2835

{

2836

if( !wxRemoveFile( Tracks[ Index ].m_FileName ) )

2837

{

2838

guLogMessage( wxT( "Error deleting '%s'" ), Tracks[ Index ].m_FileName.c_str() );

2839

}

2840

}

3346

DeleteTracks( &Tracks );

2841

3347

2842

ReloadControls( event );

3348

ReloadControls();

2843

3349

}

2844

3350

}

2845

3351

}

2846

3352

2847

3353

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

3354

void guLibPanel::CreateContextMenu( wxMenu * menu, const int windowid )

3355

{

3356

}

3357

3358

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

3359

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

3360

{

3361

guMainFrame * MainFrame = ( guMainFrame * ) wxTheApp->GetTopWindow();

3362

MainFrame->CreateCopyToMenu( menu, basecmd );

3363

}

3364

3365

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

3366

wxString guLibPanel::GetName( void )

3367

{

3368

return _( "Library" );

3369

}

3370

3371

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

3372

wxArrayString guLibPanel::GetLibraryPaths( void )

3373

{

3374

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

3375

return Config->ReadAStr( wxT( "LibPath" ), wxEmptyString, wxT( "LibPaths" ) );

3376

}

3377

3378

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

3379

int guLibPanel::LastUpdate( void )

3380

{

3381

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

3382

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

3383

}

3384

3385

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

3386

void guLibPanel::SetLastUpdate( int lastupdate )

3387

{

3388

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

3389

if( lastupdate == wxNOT_FOUND )

3390

{

3391

wxDateTime Now = wxDateTime::Now();

3392

lastupdate = Now.GetTicks();

3393

}

3394

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

3395

Config->Flush();

3396

}

3397

3398

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

3399

wxArrayString guLibPanel::GetCoverSearchWords( void )

3400

{

3401

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

3402

return Config->ReadAStr( wxT( "Word" ), wxEmptyString, wxT( "CoverSearch" ) );

3403

}

3404

3405

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

3406

bool guLibPanel::OnDropFiles( const wxArrayString &filenames )

3407

{

3408

return false;

3409

}

3410

3411

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

3412

// guLibPanelDropTarget

3413

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

3414

guLibPanelDropTarget::guLibPanelDropTarget( guLibPanel * libpanel ) : wxFileDropTarget()

3415

{

3416

m_LibPanel = libpanel;

3417

}

3418

3419

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

3420

guLibPanelDropTarget::~guLibPanelDropTarget()

3421

{

3422

}

3423

3424

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

3425

bool guLibPanelDropTarget::OnDropFiles( wxCoord x, wxCoord y, const wxArrayString &filenames )

3426

{

3427

return m_LibPanel->OnDropFiles( filenames );

3428

}

3429

3430

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

Older »