mainwindow.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 "mainwindow.h"

#include <QList>
#include <QTreeView>
#include <KApplication>
#include <KActionCollection>
#include <KLocale>
#include <KMessageBox>
#include <KTipDialog>
#include <KStatusBar>
#include <KStandardDirs>
#include <KWindowSystem>
#include "importkradiorippersettings.h"
#include "settings_general.h"
#include "settings_general_dialog.h"

MainWindow::MainWindow(QWidget *parent) : KXmlGuiWindow(parent)
{
  //initialise central widget
  m_streamlistwidget = new stationlistWidget(actionCollection(), this);
  setCentralWidget(m_streamlistwidget);

  //setup
  setupStreamDirectory();  // Must be done before setupActions(), because setupActions()
                           // refers to the stream directory widget
  setupActions();
  setupGUI();  // creates also some further actions automatically
  // Makes invisible the entry "Manual" or "Handbook" from the "Help" menu
  // that was generated automatically by setupGUI()
  QAction *helpContentsAction = actionCollection()->action("help_contents");
  if (!(helpContentsAction == 0)) {
    helpContentsAction->setVisible(false);
  };
  connect(KApplication::kApplication(),
          SIGNAL(aboutToQuit()),
          this,
          SLOT(prepareForExitingApp()));
  setupSystrayAndStatusbar();
  importKradioripperSettings::askForImport(true);
  KTipDialog::showTip(this, "kstreamripper/tips");  // shows tips only if user hasn't disabled it
}

MainWindow::~MainWindow()
{
  // Don't enter here anything. See documentation for details!
}

void MainWindow::closeEvent(QCloseEvent *event)
{
  if (QSystemTrayIcon::isSystemTrayAvailable() && systray.isVisible() && !kapp->sessionSaving()) {
    KMessageBox::information(
      this,
      i18nc("@info",
            "Closing the main window will keep KStreamRipper running in the "
              "system tray. Use 'Quit' from the 'File' menu to quit the application."),
      i18nc("@title:window", "Docking in System Tray"),
      "hideOnCloseInfo");
    toggleVisibility();
    event->ignore();
  } else {
    event->accept();
  };
}

void MainWindow::setupSystrayAndStatusbar()
{
  systray.setIcon(QApplication::windowIcon());
  if (KDE::versionMajor() >= 4 && KDE::versionMinor() >= 4) {
    systray.show();
  } else {
    systray.hide();
  };
  connect(&systray,
          SIGNAL(activated(QSystemTrayIcon::ActivationReason)),
          this,
          SLOT(toggleVisibility(const QSystemTrayIcon::ActivationReason)));
  statusBar()->insertPermanentItem(QString(), 0);
  statusBar()->insertPermanentItem(QString(), 1);
  connect(m_streamlistwidget->stationlistmodel(),
          SIGNAL(bandwidthChanged()),
          this,
          SLOT(actualize_systray_and_statusbar()));
  connect(m_streamlistwidget->stationlistmodel(),
          SIGNAL(numberOfActiveStreamsChanged()),
          this,
          SLOT(actualize_systray_and_statusbar()));
  actualize_systray_and_statusbar();  // initialization
}

void MainWindow::setupStreamDirectory()
{
  m_streamDirectory = new streamdirectoryDockwidget(this);
  addDockWidget(Qt::LeftDockWidgetArea, m_streamDirectory);
}

void MainWindow::setVisible(bool visible)
{
  // Doing this first because showStreamdirectory() relays on the visibility of MainWindow.
  KXmlGuiWindow::setVisible(visible);
  showStreamdirectory(showStreamdirectoryAction->isChecked());
}

void MainWindow::toggleVisibility(const QSystemTrayIcon::ActivationReason reason)
{
  if (reason == QSystemTrayIcon::Trigger || reason == QSystemTrayIcon::DoubleClick) {
    if (KWindowSystem::windowInfo(winId(), NET::WMDesktop).
          isOnDesktop(KWindowSystem::currentDesktop())) {
      if (isMinimized()) {
        KWindowSystem::unminimizeWindow(winId());
      } else {
        setVisible(!isVisible());
      };
    } else {
      KWindowSystem::setOnDesktop(winId(), KWindowSystem::currentDesktop());
      show();
      KWindowSystem::unminimizeWindow(winId());
      KWindowSystem::activateWindow(winId());
    };
  };
}

void MainWindow::actualize_systray_and_statusbar()
{
  statusBar()->changeItem(
    i18ncp("@info:status",
            "Recording %1 stream.",
            "Recording %1 streams.",
            m_streamlistwidget->stationlistmodel()->numberOfActiveStreams()),
    0);
  statusBar()->changeItem(
    i18ncp("@info:status The unit is kbit (=1000 bit) instead of Kibit (=1024 bit). "
              "See http://en.wikipedia.org/wiki/Binary_prefix for details.",
            "%1 kbit/s",
            "%1 kbit/s",
            m_streamlistwidget->stationlistmodel()->bandwidth()),
    1);
  systray.setToolTip(statusBar()->itemText(0) + ' ' + statusBar()->itemText(1));
}

bool MainWindow::queryClose()
{
  return m_streamlistwidget->queryClose();
}

void MainWindow::saveProperties(KConfigGroup & m_configGroup)
{
  m_configGroup.writeEntry("isHiddenInSystray", !isVisible());
  // No need to save the changes with sync() - KMainWindow and friends take care of this.
  m_streamlistwidget->saveProperties(m_configGroup);
}

void MainWindow::readProperties(const KConfigGroup & m_configGroup)
{
  setVisible(!m_configGroup.readEntry("isHiddenInSystray", false));
  m_streamlistwidget->readProperties(m_configGroup);
}

void MainWindow::display_global_settings_dialog()
{
  // if the dialog object yet exists, we can display it directly and return.
  if (KConfigDialog::showDialog("settings_general_dialog")) {
    return;
  };

  // else we have to construct and configure it before displaying it and return
  settings_general_dialog *dialog = new settings_general_dialog(this,
                                                                "settings_general_dialog");
  dialog->show();
}

void MainWindow::displayTipOfDay()
{
  KTipDialog::showTip(this, "kstreamripper/tips", true);
}

void MainWindow::prepareForExitingApp()
{
  queryClose();
  QObjectList childrenList = children();
  foreach (QObject *child, childrenList) {
    delete child;
  };
}

void MainWindow::showStreamdirectory(bool visible)
{
  if (isVisible() && visible) {
    m_streamDirectory->setVisible(true);
  } else {
    m_streamDirectory->setVisible(false);
  };
  settings_general::setShowStreamdirectory(visible);
  settings_general::self()->writeConfig();
}

void MainWindow::hideStreamdirectory()
{
  showStreamdirectory(false);
}

void MainWindow::setupActions()
{

  KStandardAction::preferences(this, SLOT(display_global_settings_dialog()),
                                actionCollection());

  KStandardAction::quit(kapp, SLOT(quit()), actionCollection());

  showStreamdirectoryAction = new KToggleAction(this);
  showStreamdirectoryAction->setText(m_streamDirectory->windowTitle());
  QList<QKeySequence> showStreamdirectoryAction_tempShortcutList;
  //showStreamdirectoryAction_tempShortcutList.append(Qt::Key_S);
  //showStreamdirectoryAction_tempShortcutList.append(Qt::Key_MediaRecord);
  //showStreamdirectoryAction_tempShortcutList.append(Qt::CTRL + Qt::Key_S);
  //showStreamdirectoryAction_tempShortcutList.append(Qt::META + Qt::Key_V);
  showStreamdirectoryAction->setShortcuts(showStreamdirectoryAction_tempShortcutList);
  connect(showStreamdirectoryAction, SIGNAL(toggled(bool)),
          this, SLOT(showStreamdirectory(bool)));
  connect(m_streamDirectory, SIGNAL(willAcceptCloseEventFromWindowSystem(bool)),
          showStreamdirectoryAction, SLOT(setChecked(bool)));
  actionCollection()->addAction("showStreamdirectory", showStreamdirectoryAction);
  showStreamdirectoryAction->setChecked(settings_general::showStreamdirectory());

  KAction *importKradioripperSettingsAction = new KAction(this);
  importKradioripperSettingsAction->setText(
    i18nc("@action:inmenu", "Import KRadioRipper settings"));
  connect(importKradioripperSettingsAction, SIGNAL(triggered(bool)),
          this, SLOT(askForKradioripperImport()));
  actionCollection()->addAction("importKradioripperSettings", importKradioripperSettingsAction);

  KStandardAction::tipOfDay(this, SLOT(displayTipOfDay()), actionCollection());
}

void MainWindow::askForKradioripperImport()
{
  importKradioripperSettings::askForImport();
}