git.maemo.org Git - someplayer/blob - src/libraryform.cpp

   1 /*
   2  * SomePlayer - An alternate music player for Maemo 5
   3  * Copyright (C) 2010 Nikolay (somebody) Tischenko <niktischenko@gmail.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #include "libraryform.h"
  21 #include "ui_libraryform.h"
  22 #include "library.h"
  23 #include <QStandardItemModel>
  24 #include <QStandardItem>
  25 #include <QModelIndex>
  26 #include <QModelIndexList>
  27 #include "track.h"
  28 #include "playlist.h"
  29 #include <QTime>
  30 #include <QTimer>
  31 #include <QQueue>
  32 #include <QMessageBox>
  33 #include "config.h"
  34 #include <QSpacerItem>
  35 #include <QDebug>
  36
  37 using namespace SomePlayer::DataObjects;
  38 using namespace SomePlayer::Storage;
  39
  40 inline QString __format_track_string(TrackMetadata meta) {
  41         int minutes = meta.length() / 60;
  42         int seconds = meta.length() % 60;
  43         QTime time(0, minutes, seconds);
  44         return QString("[%1] %2").arg(time.toString("mm:ss")).arg(meta.title());
  45
  46 }
  47
  48 inline void __fill_model(QStandardItemModel *model, QList<QString> data, QString icons_theme) {
  49         model->clear();
  50         int count = data.count();
  51         model->setRowCount(count);
  52         for (int i = 0; i < count; i++) {
  53                 model->setItem(i, 0, new QStandardItem(QIcon(":/icons/"+icons_theme+"/deselect_all.png"), ""));
  54                 model->setItem(i, 1, new QStandardItem(data.at(i)));
  55         }
  56 }
  57
  58 inline void __fill_model_album(QStandardItemModel *model, QMap<QString, int> data, QString icons_theme) {
  59         model->clear();
  60         int count = data.count();
  61         model->setRowCount(count);
  62         int i = 0;
  63         Config config;
  64         if (config.getValue("ui/albumsorting").toString() == "date") {
  65                 QMap<int, QList<QString> > years;
  66                 foreach (QString name, data.keys()) {
  67                         years[data[name]].append(name);
  68                 }
  69                 QList<int> keys = years.keys();
  70                 qSort(keys);
  71
  72                 foreach (int year, keys) {
  73                         foreach (QString name, years[year]) {
  74                                 model->setItem(i, 0, new QStandardItem(QIcon(":/icons/"+icons_theme+"/deselect_all.png"), ""));
  75                                 model->setItem(i, 1, new QStandardItem(QString("[%1] %2").arg(year).arg(name)));
  76                                 i++;
  77                         }
  78                 }
  79         } else {
  80                 QList<QString> names = data.keys();
  81                 foreach (QString name, names) {
  82                         model->setItem(i, 0, new QStandardItem(QIcon(":/icons/"+icons_theme+"/deselect_all.png"), ""));
  83                         model->setItem(i, 1, new QStandardItem(QString("[%1] %2").arg(data[name]).arg(name)));
  84                         i++;
  85                 }
  86         }
  87 }
  88
  89 inline void __fill_model_tracks (QStandardItemModel *model, QList<Track> tracks, QString icons_theme) {
  90         int count = tracks.count();
  91         model->setRowCount(count);
  92         Config config;
  93         bool show_lenght = (config.getValue("ui/showtracklenght").toString() != "no");
  94         for (int i = 0; i < count; i++) {
  95                 TrackMetadata meta = tracks.at(i).metadata();
  96                 if (show_lenght) {
  97                         model->setItem(i, 0, new QStandardItem(QIcon(":/icons/"+icons_theme+"/deselect_all.png"), ""));
  98                         model->setItem(i, 1, new QStandardItem(__format_track_string(meta)));
  99                 } else {
 100                         model->setItem(i, 0, new QStandardItem(QIcon(":/icons/"+icons_theme+"/deselect_all.png"), ""));
 101                         model->setItem(i, 1, new QStandardItem(meta.title()));
 102                 }
 103         }
 104 }
 105
 106 LibraryForm::LibraryForm(Library *lib, QWidget *parent) :
 107     QWidget(parent),
 108     ui(new Ui::LibraryForm)
 109 {
 110         _lib = lib;
 111         Config config;
 112         _icons_theme = config.getValue("ui/iconstheme").toString();
 113         _model = new QStandardItemModel(this);
 114         _model->setColumnCount(2);
 115         _state = STATE_NONE;
 116         _tools_widget = new ToolsWidget(this);
 117         _search_in_library_button = new QPushButton(QIcon(":/icons/"+_icons_theme+"/search.png"), "", _tools_widget);
 118         _search_in_library_button->setFlat(true);
 119         _search_in_library_button->setCheckable(true);
 120         _tools_widget->layout()->addItem(new QSpacerItem(20, 20));
 121         _tools_widget->layout()->addWidget(_search_in_library_button);
 122         ui->setupUi(this);
 123         ui->listView->setModel(_model);
 124         ui->listView->setColumnWidth(0, 70);
 125         ui->toolsLayout->addWidget(_tools_widget);
 126         _tools_widget->hideFSButton();
 127         _tools_widget->hide();
 128         connect(ui->viewButton, SIGNAL(clicked()), this, SLOT(_view_button()));
 129         connect(ui->playlistsButton, SIGNAL(clicked()), this, SLOT(_playlists_button()));
 130         connect(ui->dynamicButton, SIGNAL(clicked()), this, SLOT(_dynamic_button()));
 131         connect(ui->listView, SIGNAL(clicked(QModelIndex)), this, SLOT(_process_list_click(QModelIndex)));
 132         connect(ui->listView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(_process_dblclick(QModelIndex)));
 133         connect(ui->listView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
 134                 this, SLOT(_process_selection(QItemSelection,QItemSelection)));
 135         connect(ui->addButton, SIGNAL(clicked()), this, SLOT(_add_button()));
 136         connect(ui->selectAllButton, SIGNAL(clicked()), this, SLOT(_toggle_select_all_button()));
 137         connect(ui->backButton, SIGNAL(clicked()), this, SLOT(_back_button()));
 138         connect(ui->deleteButton, SIGNAL(clicked()), this, SLOT(_delete_button()));
 139         connect(ui->useButton, SIGNAL(clicked()), this, SLOT(_use_button()));
 140         connect(_tools_widget, SIGNAL(search(QString)), this, SLOT(search(QString)));
 141         connect(_tools_widget, SIGNAL(nextSearch()), this, SLOT(nextItem()));
 142         connect(_tools_widget, SIGNAL(prevSearch()), this, SLOT(prevItem()));
 143         connect(ui->moreButton, SIGNAL(clicked()), this, SLOT(_more_button()));
 144         connect(_search_in_library_button, SIGNAL(toggled(bool)), this, SLOT(_search_button(bool)));
 145         connect(ui->playerButton, SIGNAL(clicked()), this, SLOT(hide()));
 146         _view_button();
 147         _top_gradient = ui->topWidget->styleSheet();
 148         _bottom_gradient = ui->bottomWidget->styleSheet();
 149         _is_dynamic = false;
 150         setAttribute(Qt::WA_Maemo5StackedWindow);
 151         setWindowFlags(Qt::Window | windowFlags());
 152         ui->addButton->setEnabled(false);
 153         ui->addButton->setIcon(QIcon());
 154         ui->deleteButton->setEnabled(false);
 155         ui->deleteButton->setIcon(QIcon());
 156 }
 157
 158 LibraryForm::~LibraryForm()
 159 {
 160         delete ui;
 161 }
 162
 163 void LibraryForm::_view_button() {
 164         QList<QString> artitst = _lib->getArtists();
 165         __fill_model(_model, artitst, _icons_theme);
 166         ui->listView->setColumnWidth(0, 70);
 167         _state = STATE_ARTIST;
 168         ui->backButton->setEnabled(false);
 169         ui->backButton->setIcon(QIcon());
 170         ui->listLabel->setText("Artists");
 171         ui->useButton->setEnabled(false);
 172         ui->useButton->setIcon(QIcon());
 173         ui->addButton->setEnabled(false);
 174         ui->addButton->setIcon(QIcon());
 175         ui->deleteButton->setEnabled(false);
 176         ui->deleteButton->setIcon(QIcon());
 177 }
 178
 179 void LibraryForm::_dynamic_button() {
 180         ui->useButton->setEnabled(false);
 181         ui->useButton->setIcon(QIcon());
 182         ui->backButton->setEnabled(false);
 183         ui->backButton->setIcon(QIcon());
 184         ui->deleteButton->setEnabled(false);
 185         ui->deleteButton->setIcon(QIcon());
 186         _model->clear();
 187         _model->setRowCount(4);
 188         _model->setItem(0, 0, new QStandardItem(QIcon(":/icons/"+_icons_theme+"/deselect_all.png"), ""));
 189         _model->setItem(0, 1, new QStandardItem("Favorites"));
 190         _model->setItem(1, 0, new QStandardItem(QIcon(":/icons/"+_icons_theme+"/deselect_all.png"), ""));
 191         _model->setItem(1, 1, new QStandardItem("Most played"));
 192         _model->setItem(2, 0, new QStandardItem(QIcon(":/icons/"+_icons_theme+"/deselect_all.png"), ""));
 193         _model->setItem(2, 1, new QStandardItem("Never played"));
 194         _model->setItem(3, 0, new QStandardItem(QIcon(":/icons/"+_icons_theme+"/deselect_all.png"), ""));
 195         _model->setItem(3, 1, new QStandardItem("Recently added"));
 196         ui->listView->setColumnWidth(0, 70);
 197         ui->listLabel->setText("Dynamic playlists");
 198         _state = STATE_DYNAMIC;
 199         ui->addButton->setEnabled(false);
 200         ui->addButton->setIcon(QIcon());
 201         ui->deleteButton->setEnabled(false);
 202         ui->deleteButton->setIcon(QIcon());
 203 }
 204
 205 void LibraryForm::_process_list_click(QModelIndex index) {
 206         if (index.column() == 0) {
 207                 return;
 208         }
 209         if (_state == STATE_NONE) return;
 210         QString data = index.data().toString();
 211         QRegExp regexp("\\[\\d+\\]\\ (.*)");
 212         switch (_state) {
 213         case STATE_ARTIST:
 214                 __fill_model_album(_model, _lib->getAlbumsForArtist(data), _icons_theme);
 215                 ui->listView->setColumnWidth(0, 70);
 216                 ui->listView->scrollToTop();
 217                 _current_artist = data;
 218                 _state = STATE_ALBUM;
 219                 ui->backButton->setEnabled(true);
 220                 ui->backButton->setIcon(QIcon(":/icons/"+_icons_theme+"/back.png"));
 221                 ui->listLabel->setText(QString("Albums by \"%1\"").arg(_current_artist));
 222                 break;
 223         case STATE_ALBUM:
 224                 if (regexp.indexIn(data) != -1) {
 225                         _current_album = regexp.cap(1).trimmed();
 226                         _current_tracks = _lib->getTracksForAlbum(_current_album, _current_artist);
 227                         __fill_model_tracks(_model, _current_tracks, _icons_theme);
 228                         ui->listView->setColumnWidth(0, 70);
 229                         ui->listView->scrollToTop();
 230                         _state = STATE_TRACK;
 231                         ui->backButton->setEnabled(true);
 232                         ui->backButton->setIcon(QIcon(":/icons/"+_icons_theme+"/back.png"));
 233                         ui->listLabel->setText(QString("Tracks from \"%1\" by \"%2\"").arg(_current_album).arg(_current_artist));
 234                 }
 235                 break;
 236         case STATE_PLAYLIST:
 237                 {
 238                         _current_playlist = _lib->getPlaylist(data);
 239                         _current_tracks = _current_playlist.tracks();
 240                         __fill_model_tracks(_model, _current_tracks, _icons_theme);
 241                         ui->listView->setColumnWidth(0, 70);
 242                         ui->listView->scrollToTop();
 243                         _state = STATE_PLAYLIST_TRACK;
 244                         _is_dynamic = false;
 245                         ui->backButton->setEnabled(true);
 246                         ui->backButton->setIcon(QIcon(":/icons/"+_icons_theme+"/back.png"));
 247                         ui->useButton->setEnabled(true);
 248                         ui->useButton->setIcon(QIcon(":/icons/"+_icons_theme+"/use.png"));
 249                         ui->listLabel->setText(QString("Tracks in playlist \"%1\"").arg(data));
 250                 }
 251                 break;
 252         case STATE_DYNAMIC:
 253                 {
 254                         switch(index.row()) {
 255                         case 0: //favorites
 256                                 _current_playlist = _lib->getFavorites();
 257                                 break;
 258                         case 1: //most played
 259                                 _current_playlist = _lib->getMostPlayed();
 260                                 break;
 261                         case 2: //never played
 262                                 _current_playlist = _lib->getNeverPlayed();
 263                         case 3: //recently added
 264                                 _current_playlist = _lib->getRecentlyAdded();
 265                                 break;
 266                         default:
 267                                 return;
 268                         }
 269                         _current_tracks = _current_playlist.tracks();
 270                         __fill_model_tracks(_model, _current_tracks, _icons_theme);
 271                         ui->listView->setColumnWidth(0, 70);
 272                         ui->listView->scrollToTop();
 273                         _state = STATE_PLAYLIST_TRACK;
 274                         _is_dynamic = true;
 275                         ui->backButton->setEnabled(true);
 276                         ui->backButton->setIcon(QIcon(":/icons/"+_icons_theme+"/back.png"));
 277                         ui->useButton->setEnabled(true);
 278                         ui->useButton->setIcon(QIcon(":/icons/"+_icons_theme+"/use.png"));
 279                         ui->listLabel->setText(_current_playlist.name());
 280                 }
 281         default:
 282                 return;
 283         }
 284         ui->addButton->setEnabled(false);
 285         ui->addButton->setIcon(QIcon());
 286         ui->deleteButton->setEnabled(false);
 287         ui->deleteButton->setIcon(QIcon());
 288         QTimer::singleShot(100, ui->listView, SLOT(clearSelection())); // workaround
 289 }
 290
 291 void LibraryForm::_add_button() {
 292         if (_state == STATE_NONE) return;
 293         QModelIndexList selected = ui->listView->selectionModel()->selectedIndexes();
 294         ui->listView->selectionModel()->clearSelection();
 295         Playlist cur = _lib->getCurrentPlaylist();
 296         QRegExp regexp("\\[\\d+\\]\\ (.*)");
 297         switch (_state) {
 298         case STATE_ARTIST:
 299                 foreach (QModelIndex id, selected) {
 300                         _add_artist(&cur, id.data().toString());
 301                 }
 302                 _lib->saveCurrentPlaylist(cur);
 303                 emit refreshPlayer();
 304                 break;
 305         case STATE_ALBUM:
 306                 foreach (QModelIndex id, selected) {
 307                         if (regexp.indexIn(id.data().toString()) != -1) {
 308                                 _add_album(&cur, _current_artist, regexp.cap(1).trimmed());
 309                         }
 310                 }
 311                 _lib->saveCurrentPlaylist(cur);
 312                 emit refreshPlayer();
 313                 break;
 314         case STATE_TRACK:
 315                 foreach (QModelIndex id, selected) {
 316                         _add_track(&cur, _current_tracks.at(id.row()));
 317                 }
 318                 _lib->saveCurrentPlaylist(cur);
 319                 emit refreshPlayer();
 320                 break;
 321         case STATE_PLAYLIST:
 322                 foreach (QModelIndex id, selected) {
 323                         _add_playlist(&cur, id.data().toString());
 324                 }
 325                 _lib->saveCurrentPlaylist(cur);
 326                 emit refreshPlayer();
 327                 break;
 328         case STATE_PLAYLIST_TRACK:
 329                 foreach (QModelIndex id, selected) {
 330                         _add_track(&cur, _current_tracks.at(id.row()));
 331                 }
 332                 _lib->saveCurrentPlaylist(cur);
 333                 emit refreshPlayer();
 334                 break;
 335         case STATE_SEARCH:
 336                 foreach (QModelIndex id, selected) {
 337                         _add_track(&cur, _current_tracks.at(id.row()));
 338                 }
 339                 _lib->saveCurrentPlaylist(cur);
 340                 emit refreshPlayer();
 341                 break;
 342         default:
 343                 return;
 344         }
 345 }
 346
 347
 348 void LibraryForm::_add_artist(Playlist *cur, QString artist) {
 349         QMap<QString, int> albums = _lib->getAlbumsForArtist(artist);
 350         foreach(QString album, albums.keys()) {
 351                 _add_album(cur, artist, album);
 352         }
 353 }
 354
 355 void LibraryForm::_add_album(Playlist *cur, QString artist, QString album) {
 356         QList<Track> tracks = _lib->getTracksForAlbum(album, artist);
 357         foreach(Track track, tracks) {
 358                 _add_track(cur, track);
 359         }
 360 }
 361
 362 void LibraryForm::_add_track(Playlist *cur, Track track) {
 363         cur->addTrack(track);
 364 }
 365
 366 void LibraryForm::_add_playlist(Playlist *cur, QString name) {
 367         Playlist playlist = _lib->getPlaylist(name);
 368         QList<Track> tracks = playlist.tracks();
 369         foreach (Track track, tracks) {
 370                 _add_track(cur, track);
 371         }
 372 }
 373
 374 void LibraryForm::_back_button() {
 375         switch (_state) {
 376         case STATE_ALBUM:
 377                 _view_button();
 378                 ui->listView->scrollToTop();
 379                 break;
 380         case STATE_TRACK:
 381                 __fill_model_album(_model, _lib->getAlbumsForArtist(_current_artist), _icons_theme);
 382                 ui->listView->setColumnWidth(0, 70);
 383                 ui->listView->scrollToTop();
 384                 _state = STATE_ALBUM;
 385                 ui->listLabel->setText(QString("Albums by \"%1\"").arg(_current_artist));
 386                 break;
 387         case STATE_PLAYLIST_TRACK:
 388                 if (_is_dynamic) {
 389                         _dynamic_button();
 390                         _is_dynamic = false;
 391                 } else {
 392                         _playlists_button();
 393                 }
 394                 ui->listView->scrollToTop();
 395         default:
 396                 return;
 397         }
 398 }
 399
 400 void LibraryForm::_playlists_button() {
 401         QList<QString> playlists = _lib->getPlaylistsNames();
 402         __fill_model(_model, playlists, _icons_theme);
 403         ui->listView->setColumnWidth(0, 70);
 404         _state = STATE_PLAYLIST;
 405         ui->backButton->setEnabled(false);
 406         ui->backButton->setIcon(QIcon());
 407         ui->listLabel->setText("Playlists");
 408         ui->useButton->setEnabled(false);
 409         ui->useButton->setIcon(QIcon());
 410         ui->addButton->setEnabled(false);
 411         ui->addButton->setIcon(QIcon());
 412         ui->deleteButton->setEnabled(false);
 413         ui->deleteButton->setIcon(QIcon());
 414 }
 415
 416 void LibraryForm::_delete_button() {
 417         if (_state == STATE_PLAYLIST_TRACK) {
 418                 QModelIndexList selected = ui->listView->selectionModel()->selectedIndexes();
 419                 ui->listView->selectionModel()->clearSelection();
 420                 QQueue<int> to_delete;
 421                 foreach (QModelIndex id, selected) {
 422                         if (!to_delete.contains(id.row()))
 423                                 to_delete.append(id.row());
 424                 }
 425                 qSort(to_delete);
 426                 int count = to_delete.count();
 427                 for (int i = count-1; i >= 0; i--) {
 428                         _current_playlist.removeTrackAt(to_delete.at(i));
 429                 }
 430                 _current_tracks = _current_playlist.tracks();
 431                 _lib->savePlaylist(_current_playlist);
 432                 emit refreshPlayer();
 433                 __fill_model_tracks(_model, _current_tracks, _icons_theme);
 434                 ui->listView->setColumnWidth(0, 70);
 435         } else if (_state == STATE_PLAYLIST) {
 436                 QModelIndexList selected = ui->listView->selectionModel()->selectedIndexes();
 437                 QQueue<int> to_delete;
 438                 foreach (QModelIndex id, selected) {
 439                         if (!to_delete.contains(id.row()))
 440                                 to_delete.append(id.row());
 441                 }
 442                 qSort(to_delete);
 443                 int count = to_delete.count();
 444                 for (int i = count-1; i >= 0; i--) {
 445                         QString name = _model->item(to_delete.at(i), 1)->text();
 446                         if (name != _CURRENT_PLAYLIST_SUBST_) {
 447                                 _lib->removePlaylist(name);
 448                                 _model->removeRow(to_delete.at(i));
 449                         }
 450                 }
 451         }
 452 }
 453
 454 void LibraryForm::_delete_track(Track track) {
 455         Playlist current = _lib->getCurrentPlaylist();
 456         current.removeTrack(track);
 457         _lib->saveCurrentPlaylist(current);
 458         emit refreshPlayer();
 459 }
 460
 461 void LibraryForm::_use_button() {
 462         _lib->saveCurrentPlaylist(_current_playlist);
 463         emit refreshPlayer();
 464         _current_playlist = _lib->getCurrentPlaylist();
 465 }
 466
 467 void LibraryForm::search(QString pattern) {
 468         _search_pattern = pattern;
 469         _search_current_id = -1;
 470         nextItem();
 471 }
 472
 473 void LibraryForm::nextItem() {
 474         QString data = _model->index(_search_current_id, 0).data().toString();
 475         for (int i = _search_current_id+1; i < _model->rowCount(); i++) {
 476                 data = _model->index(i, 1).data().toString();
 477                 if (data.contains(_search_pattern, Qt::CaseInsensitive)) {
 478                         _search_current_id = i;
 479                         break;
 480                 }
 481         }
 482         QModelIndex id = _model->index(_search_current_id, 1);
 483         ui->listView->selectionModel()->clearSelection();
 484         ui->listView->selectRow(id.row());
 485         ui->listView->scrollTo(id);
 486 }
 487
 488 void LibraryForm::prevItem() {
 489         QString data = _model->index(_search_current_id, 0).data().toString();
 490         for (int i = _search_current_id-1; i >= 0; i--) {
 491                 data = _model->index(i, 1).data().toString();
 492                 if (data.contains(_search_pattern, Qt::CaseInsensitive)) {
 493                         _search_current_id = i;
 494                         break;
 495                 }
 496         }
 497         QModelIndex id = _model->index(_search_current_id, 1);
 498         ui->listView->selectionModel()->clearSelection();
 499         ui->listView->selectRow(id.row());
 500         ui->listView->scrollTo(id);
 501 }
 502
 503 void LibraryForm::cancelSearch() {
 504         _search_pattern = "";
 505         ui->listView->selectionModel()->clearSelection();
 506 }
 507
 508 void LibraryForm::refresh() {
 509         switch (_state) {
 510         case STATE_ARTIST:
 511                 _view_button();
 512                 break;
 513         case STATE_ALBUM:
 514                 __fill_model_album(_model, _lib->getAlbumsForArtist(_current_artist), _icons_theme);
 515                 ui->listView->setColumnWidth(0, 70);
 516                 break;
 517         case STATE_PLAYLIST:
 518                 _playlists_button();
 519                 break;
 520         case STATE_DYNAMIC:
 521                 _dynamic_button();
 522                 break;
 523         case STATE_PLAYLIST_TRACK:
 524                 _current_playlist = _lib->getPlaylist(_current_playlist.name());
 525                 _current_tracks = _current_playlist.tracks();
 526                 __fill_model_tracks(_model, _current_tracks, _icons_theme);
 527                 ui->listView->setColumnWidth(0, 70);
 528                 break;
 529         case STATE_TRACK:
 530                 _current_tracks = _lib->getTracksForAlbum(_current_album, _current_artist);
 531                 __fill_model_tracks(_model, _current_tracks, _icons_theme);
 532                 break;
 533         default:
 534                 return;
 535         }
 536 }
 537
 538 void LibraryForm::_toggle_select_all_button() {
 539         if (ui->listView->selectionModel()->selectedIndexes().count() == _model->rowCount() * _model->columnCount()) {
 540                 ui->listView->selectionModel()->clearSelection();
 541                 ui->selectAllButton->setIcon(QIcon(":/icons/"+_icons_theme+"/select_all.png"));
 542         } else {
 543                 disconnect(ui->listView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
 544                            this, SLOT(_process_selection(QItemSelection,QItemSelection)));
 545                 ui->listView->selectAll();
 546                 int cnt = _model->rowCount();
 547                 for (int i = 0; i < cnt; i++) {
 548                         _model->item(i)->setIcon(QIcon(":/icons/"+_icons_theme+"/select_all.png"));
 549                 }
 550                 connect(ui->listView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
 551                            this, SLOT(_process_selection(QItemSelection,QItemSelection)));
 552                 ui->selectAllButton->setIcon(QIcon(":/icons/"+_icons_theme+"/deselect_all.png"));
 553                 ui->addButton->setIcon(QIcon(":/icons/"+_icons_theme+"/add.png"));
 554                 ui->addButton->setEnabled(true);
 555         }
 556 }
 557
 558 void LibraryForm::landscapeMode() {
 559         landscape = true;
 560         ui->topWidget->hide();
 561         ui->bottomWidget->hide();
 562
 563         ui->lverticalLayout->removeItem(ui->lverticalSpacer_0);
 564         ui->lverticalLayout->removeItem(ui->lverticalSpacer_1);
 565         ui->lverticalLayout->removeItem(ui->lverticalSpacer_2);
 566         ui->lverticalLayout->removeItem(ui->lverticalSpacer_3);
 567         ui->lverticalLayout->addWidget(ui->backButton);
 568         ui->lverticalLayout->addItem(ui->lverticalSpacer_0);
 569         ui->lverticalLayout->addWidget(ui->addButton);
 570         ui->lverticalLayout->addItem(ui->lverticalSpacer_1);
 571         ui->lverticalLayout->addWidget(ui->deleteButton);
 572         ui->lverticalLayout->addItem(ui->lverticalSpacer_2);
 573         ui->lverticalLayout->addWidget(ui->useButton);
 574         ui->lverticalLayout->addItem(ui->lverticalSpacer_3);
 575         ui->lverticalLayout->addWidget(ui->playerButton);
 576
 577         ui->rverticalLayout->removeItem(ui->rverticalSpacer_0);
 578         ui->rverticalLayout->removeItem(ui->rverticalSpacer_1);
 579         ui->rverticalLayout->removeItem(ui->rverticalSpacer_2);
 580         ui->rverticalLayout->removeItem(ui->rverticalSpacer_3);
 581         ui->rverticalLayout->addWidget(ui->moreButton);
 582         ui->rverticalLayout->addItem(ui->rverticalSpacer_0);
 583         ui->rverticalLayout->addWidget(ui->selectAllButton);
 584         ui->rverticalLayout->addItem(ui->rverticalSpacer_1);
 585         ui->rverticalLayout->addWidget(ui->viewButton);
 586         ui->rverticalLayout->addItem(ui->rverticalSpacer_2);
 587         ui->rverticalLayout->addWidget(ui->dynamicButton);
 588         ui->rverticalLayout->addItem(ui->rverticalSpacer_3);
 589         ui->rverticalLayout->addWidget(ui->playlistsButton);
 590
 591         if (_tools_widget->isVisible()) {
 592                 ui->moreButton->setIcon(QIcon(":/icons/"+_icons_theme+"/more_l.png"));
 593         } else {
 594                 ui->moreButton->setIcon(QIcon(":/icons/"+_icons_theme+"/unmore_l.png"));
 595         }
 596 }
 597
 598 void LibraryForm::portraitMode() {
 599         landscape = false;
 600
 601         ui->topWidget->show();
 602         ui->bottomWidget->show();
 603
 604         ui->lverticalLayout->removeItem(ui->lverticalSpacer_0);
 605         ui->lverticalLayout->removeItem(ui->lverticalSpacer_1);
 606         ui->lverticalLayout->removeItem(ui->lverticalSpacer_2);
 607         ui->lverticalLayout->removeItem(ui->lverticalSpacer_3);
 608
 609         ui->rverticalLayout->removeItem(ui->rverticalSpacer_0);
 610         ui->rverticalLayout->removeItem(ui->rverticalSpacer_1);
 611         ui->rverticalLayout->removeItem(ui->rverticalSpacer_2);
 612         ui->rverticalLayout->removeItem(ui->rverticalSpacer_3);
 613
 614         ui->topWidget->layout()->removeItem(ui->thorizontalSpacer_0);
 615         ui->topWidget->layout()->removeItem(ui->thorizontalSpacer_1);
 616         ui->topWidget->layout()->removeItem(ui->thorizontalSpacer_2);
 617         ui->topWidget->layout()->removeItem(ui->thorizontalSpacer_3);
 618         ui->topWidget->layout()->removeItem(ui->thorizontalSpacer_4);
 619         ui->topWidget->layout()->addWidget(ui->backButton);
 620         ui->topWidget->layout()->addItem(ui->thorizontalSpacer_0);
 621         ui->topWidget->layout()->addWidget(ui->deleteButton);
 622         ui->topWidget->layout()->addItem(ui->thorizontalSpacer_1);
 623         ui->topWidget->layout()->addWidget(ui->addButton);
 624         ui->topWidget->layout()->addItem(ui->thorizontalSpacer_2);
 625         ui->topWidget->layout()->addWidget(ui->useButton);
 626         ui->topWidget->layout()->addItem(ui->thorizontalSpacer_3);
 627         ui->topWidget->layout()->addWidget(ui->selectAllButton);
 628         ui->topWidget->layout()->addItem(ui->thorizontalSpacer_4);
 629         ui->topWidget->layout()->addWidget(ui->moreButton);
 630
 631         ui->bottomWidget->layout()->removeItem(ui->bhorizontalSpacer_0);
 632         ui->bottomWidget->layout()->removeItem(ui->bhorizontalSpacer_1);
 633         ui->bottomWidget->layout()->removeItem(ui->bhorizontalSpacer_2);
 634         ui->bottomWidget->layout()->addWidget(ui->playerButton);
 635         ui->bottomWidget->layout()->addItem(ui->bhorizontalSpacer_0);
 636         ui->bottomWidget->layout()->addWidget(ui->viewButton);
 637         ui->bottomWidget->layout()->addItem(ui->bhorizontalSpacer_1);
 638         ui->bottomWidget->layout()->addWidget(ui->dynamicButton);
 639         ui->bottomWidget->layout()->addItem(ui->bhorizontalSpacer_2);
 640         ui->bottomWidget->layout()->addWidget(ui->playlistsButton);
 641
 642         if (_tools_widget->isVisible()) {
 643                 ui->moreButton->setIcon(QIcon(":/icons/"+_icons_theme+"/unmore.png"));
 644         } else {
 645                 ui->moreButton->setIcon(QIcon(":/icons/"+_icons_theme+"/more.png"));
 646         }
 647 }
 648
 649 void LibraryForm::_more_button() {
 650         if (_tools_widget->isVisible()) {
 651                 ui->moreButton->setIcon(QIcon(landscape ? ":/icons/"+_icons_theme+"/unmore_l.png" : ":/icons/"+_icons_theme+"/more.png"));
 652                 _tools_widget->hide();
 653                 _tools_widget->reset();
 654                 cancelSearch();
 655         } else {
 656                 ui->moreButton->setIcon(QIcon(landscape ? ":/icons/"+_icons_theme+"/more_l.png" : ":/icons/"+_icons_theme+"/unmore.png"));
 657                 _tools_widget->show();
 658                 _tools_widget->setFocus();
 659         }
 660 }
 661
 662
 663 void LibraryForm::updateIcons() {
 664         Config config;
 665         _icons_theme = config.getValue("ui/iconstheme").toString();
 666         _tools_widget->updateIcons();
 667         if (!ui->addButton->icon().isNull()) {
 668                 ui->addButton->setIcon(QIcon(":/icons/"+_icons_theme+"/add.png"));
 669         }
 670         if (!ui->deleteButton->icon().isNull()) {
 671                 ui->deleteButton->setIcon(QIcon(":/icons/"+_icons_theme+"/delete.png"));
 672         }
 673         if (!ui->useButton->icon().isNull()) {
 674                 ui->useButton->setIcon(QIcon(":/icons/"+_icons_theme+"/use.png"));
 675         }
 676         if (!ui->backButton->icon().isNull()) {
 677                 ui->backButton->setIcon(QIcon(":/icons/"+_icons_theme+"/back.png"));
 678         }
 679         if (!ui->dynamicButton->icon().isNull()) {
 680                 ui->dynamicButton->setIcon(QIcon(":/icons/"+_icons_theme+"/dynamic.png"));
 681         }
 682         if (_tools_widget->isVisible()) {
 683                 ui->moreButton->setIcon(QIcon(landscape ? ":/icons/"+_icons_theme+"/more_l.png" : ":/icons/"+_icons_theme+"/unmore.png"));
 684         } else {
 685                 ui->moreButton->setIcon(QIcon(landscape ? ":/icons/"+_icons_theme+"/unmore_l.png" : ":/icons/"+_icons_theme+"/more.png"));
 686         }
 687         if (!ui->playlistsButton->icon().isNull()) {
 688                 ui->playlistsButton->setIcon(QIcon(":/icons/"+_icons_theme+"/playlists.png"));
 689         }
 690         ui->playerButton->setIcon(QIcon(":/icons/"+_icons_theme+"/player.png"));
 691         if (!ui->viewButton->icon().isNull()) {
 692                 ui->viewButton->setIcon(QIcon(":/icons/"+_icons_theme+"/artists.png"));
 693         }
 694         if (ui->listView->selectionModel()->selectedRows().count() == _model->rowCount()) {
 695                 ui->selectAllButton->setIcon(QIcon(":/icons/"+_icons_theme+"/deselect_all.png"));
 696         } else {
 697                 ui->selectAllButton->setIcon(QIcon(":/icons/"+_icons_theme+"/select_all.png"));
 698         }
 699         _search_in_library_button->setIcon(QIcon(":/icons/"+_icons_theme+"/search.png"));
 700         refresh();
 701 }
 702
 703 void LibraryForm::checkGradient() {
 704         Config config;
 705         if (config.getValue("ui/gradient").toString() == "yes") {
 706                 ui->bottomWidget->setStyleSheet(_bottom_gradient);
 707                 ui->topWidget->setStyleSheet(_top_gradient);
 708         } else {
 709                 ui->topWidget->setStyleSheet("");
 710                 ui->bottomWidget->setStyleSheet("");
 711         }
 712 }
 713
 714 void LibraryForm::_process_selection(QItemSelection selected, QItemSelection deselected) {
 715         foreach (QModelIndex id, selected.indexes()) {
 716                 if (id.column() == 0) {
 717                         _model->item(id.row())->setIcon(QIcon(":/icons/"+_icons_theme+"/select_all.png"));
 718                 }
 719                 ui->listView->selectionModel()->select(id, QItemSelectionModel::Select);
 720         }
 721         foreach (QModelIndex id, deselected.indexes()) {
 722                 if (id.column() == 0) {
 723                         _model->item(id.row())->setIcon(QIcon(":/icons/"+_icons_theme+"/deselect_all.png"));
 724                 }
 725                 ui->listView->selectionModel()->select(id, QItemSelectionModel::Deselect);
 726         }
 727         if (ui->listView->selectionModel()->selectedRows().count() > 0) {
 728                 ui->addButton->setEnabled(true);
 729                 ui->addButton->setIcon(QIcon(":/icons/"+_icons_theme+"/add.png"));
 730                 if (_state == STATE_PLAYLIST || (_state == STATE_PLAYLIST_TRACK && !_is_dynamic)) {
 731                         ui->deleteButton->setEnabled(true);
 732                         ui->deleteButton->setIcon(QIcon(":/icons/"+_icons_theme+"/delete.png"));
 733                 }
 734         } else {
 735                 ui->addButton->setEnabled(false);
 736                 ui->addButton->setIcon(QIcon());
 737                 ui->deleteButton->setEnabled(false);
 738                 ui->deleteButton->setIcon(QIcon());
 739         }
 740 }
 741
 742 void LibraryForm::_process_dblclick(QModelIndex id) {
 743         if (id.column() == 0)
 744                 return;
 745         if (_state == STATE_TRACK || _state == STATE_PLAYLIST_TRACK || _state == STATE_SEARCH) {
 746                 Playlist cur = _lib->getCurrentPlaylist();
 747                 Track track = _current_tracks.at(id.row());
 748                 cur.addTrack(track);
 749                 _lib->saveCurrentPlaylist(cur);
 750                 emit refreshPlayer();
 751                 emit addAndPlay(track);
 752                 ui->listView->clearSelection();
 753         }
 754 }
 755
 756 void LibraryForm::_search_button(bool state) {
 757         ui->moreButton->setEnabled(!state);
 758         _tools_widget->toggleArrows(!state);
 759         ui->backButton->setEnabled(!state);
 760         ui->backButton->setIcon(state ? QIcon() : QIcon(":/icons/"+_icons_theme+"/back.png"));
 761         _tools_widget->setFocus();
 762         _tools_widget->reset();
 763         if (state) {
 764                 ui->listLabel->setText("Search in library");
 765                 ui->deleteButton->setIcon(QIcon());
 766                 ui->deleteButton->setEnabled(false);
 767                 ui->useButton->setIcon(QIcon());
 768                 ui->useButton->setEnabled(false);
 769                 ui->viewButton->setIcon(QIcon());
 770                 ui->viewButton->setEnabled(false);
 771                 ui->dynamicButton->setIcon(QIcon());
 772                 ui->dynamicButton->setEnabled(false);
 773                 ui->playlistsButton->setIcon(QIcon());
 774                 ui->playlistsButton->setEnabled(false);
 775                 disconnect(_tools_widget, SIGNAL(search(QString)), this, SLOT(search(QString)));
 776                 connect(_tools_widget, SIGNAL(search(QString)), this, SLOT(_search_in_library(QString)));
 777                 _model->clear();
 778                 _state = STATE_SEARCH;
 779         } else {
 780                 ui->viewButton->setIcon(QIcon(":/icons/"+_icons_theme+"/artists.png"));
 781                 ui->viewButton->setEnabled(true);
 782                 ui->dynamicButton->setIcon(QIcon(":/icons/"+_icons_theme+"/dynamic.png"));
 783                 ui->dynamicButton->setEnabled(true);
 784                 ui->playlistsButton->setIcon(QIcon(":/icons/"+_icons_theme+"/playlists.png"));
 785                 ui->playlistsButton->setEnabled(true);
 786                 _view_button();
 787                 connect(_tools_widget, SIGNAL(search(QString)), this, SLOT(search(QString)));
 788                 disconnect(_tools_widget, SIGNAL(search(QString)), this, SLOT(_search_in_library(QString)));
 789         }
 790 }
 791
 792 void LibraryForm::_search_in_library(QString pattern) {
 793         pattern = pattern.trimmed();
 794         if (pattern.isEmpty()) {
 795                 _model->clear();
 796                 return;
 797         }
 798         _current_tracks = _lib->search(pattern);
 799         __fill_model_tracks(_model, _current_tracks, _icons_theme);
 800         ui->listView->setColumnWidth(0, 70);
 801         ui->listView->scrollToTop();
 802 }