stationlistwidget.cpp

Go to the documentation of this file.

/*
    Copyright (C) 2008-2010  Lukas Sommer < SommerLuk at gmail dot com >

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of
    the License or (at your option) version 3 or any later version
    accepted by the membership of KDE e.V. (or its successor approved
    by the membership of KDE e.V.), which shall act as a proxy
    defined in Section 14 of version 3 of the license.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "stationlistwidget.h"

#include <QApplication>
#include <QClipboard>
#include <QContextMenuEvent>
#include <QScrollBar>
#include <QStringList>
#include <QTimer>
#include <KAction>
#include <KLocale>
#include <KStandardAction>
#include "settings_general.h"
#define AND  &&
#define OR  ||
#define NOT  !
#define EQUAL  ==

stationlistWidget::stationlistWidget(KActionCollection *actionCollection,
                                     QWidget *parent,
                                     QWidget *mainWindow)
  : QTreeView(parent)
{

  // variables
  QPointer<CustomizableHeaderView> theHorizontalHeader;
  int i;
  Qt::SortOrder order;

  // code
  theHorizontalHeader = new CustomizableHeaderView(Qt::Horizontal);
  // this also deletes automatically the previously used (standard) QHeaderView object:
  setHeader(theHorizontalHeader);
  theHorizontalHeader->setContextMenuTitle(
    i18nc("@title:menu Title of the context menu where you can change visibility of columns",
          "Columns"));
  if (settings_general::sortingAscendingly()) {
    order = Qt::AscendingOrder;
  } else {
    order = Qt::DescendingOrder;
  };
  theHorizontalHeader->setSortIndicator(settings_general::sortByColumn(), order);
  theHorizontalHeader->setSortIndicatorShown(true);
  theHorizontalHeader->setClickable(true);
  /* We have to save the width of a column _befor_ it is hidden (after hiding,
  *  we wouln't be able to get the width anymore). */
  connect(theHorizontalHeader,
          SIGNAL(sectionAboutToBeHidden(int, Qt::Orientation)),
          this,
          SLOT(saveColumnSize(int)));

  setSelectionBehavior(QAbstractItemView::SelectRows);  // don't change this.
  // Much code relys on the assumption that only hole rows can be selected.

  m_stationlistModel = new stationlistModel(this, mainWindow);

  // restore column width
  for (i=0; i < m_stationlistModel->columnCount(); ++i) {
    setColumnHidden(
      i,
      !m_stationlistModel->columnInfo(stationlistModel::columnVisibility, i).toBool());
    setColumnWidth(
      i,
      m_stationlistModel->columnInfo(stationlistModel::columnWidth, i).toLongLong());
  };

  // various settings
  setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
  setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
  setDragDropMode(QAbstractItemView::DropOnly);
  setDragDropOverwriteMode(false); // don't override items, but insert new ones!
  setAcceptDrops(true);
  setSortingEnabled(true);
  setItemsExpandable(true);
  setAutoExpandDelay(1);
  setAnimated(true);
  setSelectionMode(QAbstractItemView::ExtendedSelection);
  setDropIndicatorShown(true);
  setAutoScroll(true);
  setAutoExpandDelay(500);
  setupActions(actionCollection);
}

stationlistWidget::~stationlistWidget()
{
}

void stationlistWidget::saveAllColumnSizes()
{
  // variables
  int i;

  // code
  for (i=0; i < m_stationlistModel->columnCount(); i++) {
    if (NOT isColumnHidden(i)) {
      saveColumnSize(i);
    };
    m_stationlistModel->columnInfo(stationlistModel::setColumnVisibility,
                                   i,
                                   0,
                                   NOT isColumnHidden(i));
  };
}

void stationlistWidget::saveColumnSize(const int column)
{
  m_stationlistModel->columnInfo(stationlistModel::setColumnWidth,
                                 column,
                                 0,
                                 columnWidth(column));
}

void stationlistWidget::recalculateActionsStatus()
{
  const QModelIndexList list = selectionModel()->selectedRows();
  const int number_of_selected_items = list.size();
  switch (number_of_selected_items) {
    case 0:
      emit noneSelected(true);
      deleteAction->setEnabled(false);
      deleteAction->setData(false);
      newStreamAction->setData(true);
      newFolderAction->setData(true);
      pasteAction->setData(true);
      streamSettingsAction->setEnabled(false);
      streamSettingsAction->setData(false);
      break;
    case 1:
      emit oneSelected(true);
      deleteAction->setEnabled(true);
      deleteAction->setData(true);
      streamSettingsAction->setEnabled(true);
      streamSettingsAction->setData(true);
      if (static_cast<stationlistItem *>(list.at(0).internalPointer())->type() ==
            stationlistItem::folder) {
        newStreamAction->setData(true);
        newFolderAction->setData(true);
        pasteAction->setData(true);
      } else {
        newStreamAction->setData(false);
        newFolderAction->setData(false);
        pasteAction->setData(false);
      };
      break;
    default:
      emit multipleSelected(true);
      deleteAction->setEnabled(true);
      deleteAction->setData(true);
      newStreamAction->setData(false);
      newFolderAction->setData(false);
      pasteAction->setData(false);
      streamSettingsAction->setEnabled(false);
      streamSettingsAction->setData(false);
      break;
  };
}

void stationlistWidget::deleteStation()
{
  // variables
  QModelIndexList m_list;

  // code
  // initialized with a list of the selected rows (for column 0):
  m_list = selectionModel()->selectedRows();
  while (m_list.size() > 0) {
    m_stationlistModel->removeRow(m_list.at(0).row(), m_list.at(0).parent());
    m_list = selectionModel()->selectedRows();
  };
}

void stationlistWidget::contextMenuEvent(QContextMenuEvent * e)
{
  contextMenu.clear();

  if (recordAction->data().toBool()) {
    contextMenu.addAction(recordAction);
  };
  if (stopRecordAction->data().toBool()) {
    contextMenu.addAction(stopRecordAction);
  };
  if (startListenInAction->data().toBool()) {
    contextMenu.addAction(startListenInAction);
  };
  if (stopListenInAction->data().toBool()) {
    contextMenu.addAction(stopListenInAction);
  };
  if (newStreamAction->data().toBool()) {
    contextMenu.addAction(newStreamAction);
  };
  // change default behaviour that was set up by setupActions
  disconnect(newStreamAction, 0, 0, 0);
  connect(newStreamAction, SIGNAL(triggered(bool)),
          m_stationlistModel, SLOT(addNewStationInFolder()));
  if (newFolderAction->data().toBool()) {
    contextMenu.addAction(newFolderAction);
  };
  disconnect(newFolderAction, 0, 0, 0);
  connect(newFolderAction, SIGNAL(triggered(bool)),
          m_stationlistModel, SLOT(addNewFolderInFolder()));
  if (deleteAction->data().toBool()) {
    contextMenu.addAction(deleteAction);
  };
  if (pasteAction->data().toBool()) {
    contextMenu.addAction(pasteAction);
  };
  contextMenu.addAction(selectAllAction);
  if (streamSettingsAction->data().toBool()) {
    contextMenu.addAction(streamSettingsAction);
  };

  contextMenu.exec(e->globalPos());

  // restore default behaviour of setupActions
  disconnect(newStreamAction, 0, 0, 0);
  connect(newStreamAction, SIGNAL(triggered(bool)),
          m_stationlistModel, SLOT(addNewStation()));
  disconnect(newFolderAction, 0, 0, 0);
  connect(newFolderAction, SIGNAL(triggered(bool)),
          m_stationlistModel, SLOT(addNewFolder()));
}

QPointer<stationlistModel> stationlistWidget::stationlistmodel()
{
  return m_stationlistModel;
}

bool stationlistWidget::queryClose()
{
  saveAllColumnSizes();
  return stationlistmodel()->queryClose();
}

void stationlistWidget::saveProperties(KConfigGroup & m_configGroup)
{
  saveAllColumnSizes();
  stationlistmodel()->saveProperties(m_configGroup);
}

void stationlistWidget::readProperties(const KConfigGroup & m_configGroup)
{
  stationlistmodel()->readProperties(m_configGroup);
}

void stationlistWidget::mousePressEvent(QMouseEvent *event)
{
  if (event->button() == Qt::MidButton) {
    stationlistmodel()->pasteSelection(indexAt(viewport()->mapFromGlobal(event->globalPos())));
  } else {
    // pass on other buttons to base class
    QTreeView::mousePressEvent(event);
  };
}

void stationlistWidget::scrollToRow(const QModelIndex & index)
{
  int temp = horizontalScrollBar()->sliderPosition();
  scrollTo(index);
  horizontalScrollBar()->setSliderPosition(temp);
}

void stationlistWidget::reloadStatusOfPasteAction()
{
  bool isAccepted = false;
  const QStringList clipboardFormats = QApplication::clipboard()->mimeData()->formats();
  const QStringList acceptedFormats = stationlistmodel()->mimeTypes();
  const int numberOfAcceptedFormats = acceptedFormats.size();
  int i = 0;
  while ((!isAccepted) && (i < numberOfAcceptedFormats)) {
    isAccepted = clipboardFormats.contains(acceptedFormats.at(i));
    ++i;
  };
  pasteAction->setEnabled(isAccepted);
}

void stationlistWidget::reloadStatusOfListenInAction()
{
  const QModelIndexList list = selectionModel()->selectedRows();
  const int number_of_selected_items = list.size();
  switch (number_of_selected_items) {
    case 0:
      startListenInAction->setEnabled(false);
      startListenInAction->setData(false);
      break;
    case 1:
      startListenInAction->setData(true);
      startListenInAction->setEnabled(false);
      if (static_cast<stationlistItem *>(list.at(0).internalPointer())->type() ==
            stationlistItem::stream) {
        if (static_cast<stationlistItem *>(list.at(0).internalPointer())->
            streamObject()->relayPort().type == PropertyValue::value) {
          startListenInAction->setEnabled(true);
        };
      };
      break;
    default:
      startListenInAction->setEnabled(false);
      startListenInAction->setData(false);
      break;
  };
}

void stationlistWidget::setupActions(KActionCollection *actionCollection)
{
  // record
  recordAction = new KAction(this);
  recordAction->setText(i18nc("@action", "&Record"));
  recordAction->setIcon(KIcon("media-record"));
  QList<QKeySequence> recordAction_tempShortcutList;
  recordAction_tempShortcutList.append(Qt::Key_R);
  recordAction_tempShortcutList.append(Qt::Key_MediaRecord);
  recordAction_tempShortcutList.append(Qt::CTRL + Qt::Key_R);
  recordAction->setShortcuts(recordAction_tempShortcutList);
  recordAction->setEnabled(false);
  connect(recordAction, SIGNAL(triggered(bool)),
          stationlistmodel(), SLOT(record()));
  actionCollection->addAction("record", recordAction);

  // stopRecord
  stopRecordAction = new KAction(this);
  stopRecordAction->setText(i18nc("@action", "&Stop"));
  stopRecordAction->setIcon(KIcon("media-playback-stop"));
  QList<QKeySequence> stopRecordAction_tempShortcutList;
  stopRecordAction_tempShortcutList.append(Qt::Key_S);
  stopRecordAction_tempShortcutList.append(Qt::Key_MediaStop);
  stopRecordAction_tempShortcutList.append(Qt::CTRL + Qt::Key_S);
  stopRecordAction_tempShortcutList.append(Qt::META + Qt::Key_V);
  stopRecordAction->setShortcuts(stopRecordAction_tempShortcutList);
  stopRecordAction->setEnabled(false);
  connect(stopRecordAction, SIGNAL(triggered(bool)),
          stationlistmodel(), SLOT(stopRecording()));
  actionCollection->addAction("stopRecord", stopRecordAction);

  connect(stationlistmodel(), SIGNAL(selectedStreamsChanged()),
          this, SLOT(reloadStatusOfStartAndStopActions()));
  connect(stationlistmodel(), SIGNAL(statusChanged()),
          this, SLOT(reloadStatusOfStartAndStopActions()));

  // startListenIn
  startListenInAction = new KAction(this);

  startListenInAction->setText(
    i18nc("@action listening in the stream that is actually recorded (and has been selected)",
          "&Listen in"));
  startListenInAction->setIcon(KIcon("audio-volume-high"));
  /*QList<QKeySequence> startListenInAction_tempShortcutList; TODO
  startListenInAction_tempShortcutList.append(Qt::Key_S);
  startListenInAction_tempShortcutList.append(Qt::Key_MediaRecord);
  startListenInAction_tempShortcutList.append(Qt::CTRL + Qt::Key_S);
  startListenInAction_tempShortcutList.append(Qt::META + Qt::Key_V);
  startListenInAction->setShortcuts(startListenInAction_tempShortcutList);*/
  startListenInAction->setEnabled(false);
  connect(startListenInAction, SIGNAL(triggered(bool)),
          stationlistmodel(), SLOT(enableListeningIn()));
  actionCollection->addAction("startListenIn", startListenInAction);
  connect(selectionModel(),
          SIGNAL(selectionChanged(const QItemSelection &,const QItemSelection &)),
          this,
          SLOT(reloadStatusOfListenInAction()));
  connect(stationlistmodel(),
          SIGNAL(relayportChanged()),
          this,
          SLOT(reloadStatusOfListenInAction()));

  // stopListenIn
  stopListenInAction = new KAction(this);
  stopListenInAction->setText(
    i18nc("@action listening in the stream that is actually recorded", "&Mute"));
  stopListenInAction->setIcon(KIcon("audio-volume-muted"));
  /*QList<QKeySequence> stopListenInAction_tempShortcutList; TODO
  stopListenInAction_tempShortcutList.append(Qt::Key_S);
  stopListenInAction_tempShortcutList.append(Qt::Key_MediaRecord);
  stopListenInAction_tempShortcutList.append(Qt::CTRL + Qt::Key_S);
  stopListenInAction_tempShortcutList.append(Qt::META + Qt::Key_V);
  stopListenInAction->setShortcuts(stopListenInAction_tempShortcutList);*/
  stopListenInAction->setEnabled(false);
  stopListenInAction->setData(true);
  connect(stopListenInAction, SIGNAL(triggered(bool)),
          stationlistmodel(), SLOT(disableListeningIn()));
  connect(&(stationlistmodel()->listen), SIGNAL(isPlayingChanged(bool)),
          this, SLOT(enableStopListenInAction(bool)));
  actionCollection->addAction("stopListenIn", stopListenInAction);

  // newStream
  // slot will be temporaly changed by contextMenuEvent
  newStreamAction = KStandardAction::openNew(
    m_stationlistModel,
    SLOT(addNewStation()),
    this);
  newStreamAction->setText(i18nc("@action", "&New stream"));
  newStreamAction->setData(true);
  actionCollection->addAction("newStream", newStreamAction);

  // newFolder
  newFolderAction = new KAction(this);
  newFolderAction->setText(i18nc("@action", "New &Folder"));
  newFolderAction->setIcon(KIcon("folder-new"));
  //newFolderAction->setShortcut(); TODO
  newFolderAction->setData(true);
  // slot will be temporaly changed by contextMenuEvent
  connect(newFolderAction, SIGNAL(triggered(bool)),
          m_stationlistModel, SLOT(addNewFolder()));
  actionCollection->addAction("newFolder", newFolderAction);

  // delete
  deleteAction = new KAction(this);
  deleteAction->setText(i18nc("@action", "&Delete"));
  deleteAction->setIcon(KIcon("edit-delete"));
  deleteAction->setShortcut(Qt::SHIFT + Qt::Key_Delete);
  deleteAction->setEnabled(false);
  connect(deleteAction, SIGNAL(triggered(bool)),
          this, SLOT(deleteStation()));
  actionCollection->addAction("deleteStream", deleteAction);

  // paste
  pasteAction = KStandardAction::paste(stationlistmodel(), SLOT(paste()), this);
  pasteAction->setData(true);
  actionCollection->addAction("paste", pasteAction);
  connect(QApplication::clipboard(), SIGNAL(dataChanged()),
          this, SLOT(reloadStatusOfPasteAction()));
  reloadStatusOfPasteAction();

  // selectAll
  selectAllAction = KStandardAction::selectAll(this, SLOT(selectAll()), actionCollection);
  selectAllAction->setData(true);

  // streamSettings
  streamSettingsAction = new KAction(this);
  streamSettingsAction->setText(i18nc("@action properties of a stream)", "&Properties"));
  streamSettingsAction->setIcon(KIcon("document-properties"));
  QList<QKeySequence> streamSettingsAction_tempShortcutList;
  streamSettingsAction_tempShortcutList.append(Qt::ALT + Qt::Key_Return);
  streamSettingsAction->setShortcuts(streamSettingsAction_tempShortcutList);
  streamSettingsAction->setEnabled(false);
  connect(streamSettingsAction, SIGNAL(triggered(bool)),
          m_stationlistModel, SLOT(showConfigDialog()));
  actionCollection->addAction("streamSettings", streamSettingsAction);

  connect(selectionModel(),
          SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
          this,
          SLOT(recalculateActionsStatus()));
  recalculateActionsStatus();  // reload status of the actions
}

void stationlistWidget::reloadStatusOfStartAndStopActions()
{
  // variables
  const QList<radioStation *> selectedStreams = stationlistmodel()->selectedStreams();
  bool start = false;
  bool stop = false;

  // code
  if (selectionModel()->selectedRows().size() == 0) {
    recordAction->setEnabled(false);
    recordAction->setData(false);
    stopRecordAction->setEnabled(false);
    stopRecordAction->setData(false);
  } else {
    foreach (const radioStation *stream, selectedStreams) {
      if (!start) {
        start = !stream->isRunning();
      };
      if (!stop) {
        stop = stream->doesTheUserWantsThatTheStreamIsRipping();
      };
      if (start && stop) {
        break;
      };
    };
    recordAction->setEnabled(start);
    stopRecordAction->setEnabled(stop);
    recordAction->setData(true);
    stopRecordAction->setData(true);
  };
}

void stationlistWidget::enableStopListenInAction(bool enabled)
{
  stopListenInAction->setEnabled(enabled);
}