#include "MainWindow.h"
#include "spacer.h"
-#include "Constants.h"
+#include "constants.h"
#include "iconloader/qticonloader.h"
#include "global.h"
#include "videodefinition.h"
+#include "fontutils.h"
+#include "globalshortcuts.h"
+#ifdef Q_WS_X11
+#include "gnomeglobalshortcutbackend.h"
+#endif
+#ifdef Q_WS_MAC
+#include "mac_startup.h"
+#include "macfullscreen.h"
+#include "macsupport.h"
+#endif
+#ifndef Q_WS_X11
+#include "extra.h"
+#endif
+#include "downloadmanager.h"
+#include "youtubesuggest.h"
+#include "updatechecker.h"
+#ifdef APP_DEMO
+#include "demostartupview.h"
+#endif
+#include "temporary.h"
MainWindow::MainWindow() :
+ aboutView(0),
+ downloadView(0),
mediaObject(0),
audioOutput(0),
- aboutView(0),
- m_fullscreen(false) {
+ m_fullscreen(false),
+ updateChecker(0) {
// views mechanism
history = new QStack<QWidget*>();
views = new QStackedWidget(this);
+ setCentralWidget(views);
// views
searchView = new SearchView(this);
- connect(searchView, SIGNAL(search(QString)), this, SLOT(showMedia(QString)));
+ connect(searchView, SIGNAL(search(SearchParams*)), this, SLOT(showMedia(SearchParams*)));
views->addWidget(searchView);
mediaView = new MediaView(this);
views->addWidget(mediaView);
toolbarSearch = new SearchLineEdit(this);
- toolbarSearch->setFont(qApp->font());
toolbarSearch->setMinimumWidth(toolbarSearch->fontInfo().pixelSize()*15);
- connect(toolbarSearch, SIGNAL(search(const QString&)), searchView, SLOT(watch(const QString&)));
+ toolbarSearch->setSuggester(new YouTubeSuggest(this));
+ connect(toolbarSearch, SIGNAL(search(const QString&)), this, SLOT(startToolbarSearch(const QString&)));
// build ui
createActions();
createStatusBar();
initPhonon();
+ // mediaView->setSlider(slider);
mediaView->setMediaObject(mediaObject);
// remove that useless menu/toolbar context menu
// mediaView init stuff thats needs actions
mediaView->initialize();
+ // event filter to block ugly toolbar tooltips
+ qApp->installEventFilter(this);
+
// restore window position
readSettings();
- // cool toolbar on the Mac
- // this is too buggy to be enabled
- // setUnifiedTitleAndToolBarOnMac(true);
+ // show the initial view
+#ifdef APP_DEMO
+ QWidget *demoStartupView = new DemoStartupView(this);
+ views->addWidget(demoStartupView);
+ showWidget(demoStartupView);
+#else
+ showSearch();
+#endif
- // event filter to block ugly toolbar tooltips
- qApp->installEventFilter(this);
+ // Global shortcuts
+ GlobalShortcuts &shortcuts = GlobalShortcuts::instance();
+#ifdef Q_WS_X11
+ if (GnomeGlobalShortcutBackend::IsGsdAvailable())
+ shortcuts.setBackend(new GnomeGlobalShortcutBackend(&shortcuts));
+#endif
+#ifdef Q_WS_MAC
+ mac::MacSetup();
+#endif
+ connect(&shortcuts, SIGNAL(PlayPause()), pauseAct, SLOT(trigger()));
+ connect(&shortcuts, SIGNAL(Stop()), this, SLOT(stop()));
+ connect(&shortcuts, SIGNAL(Next()), skipAct, SLOT(trigger()));
- // show the initial view
- showWidget(searchView);
+ connect(DownloadManager::instance(), SIGNAL(statusMessageChanged(QString)),
+ SLOT(updateDownloadMessage(QString)));
+ connect(DownloadManager::instance(), SIGNAL(finished()),
+ SLOT(downloadsFinished()));
+
+ setAcceptDrops(true);
+
+ QTimer::singleShot(0, this, SLOT(checkForUpdate()));
- setCentralWidget(views);
}
MainWindow::~MainWindow() {
}
bool MainWindow::eventFilter(QObject *obj, QEvent *event) {
+#ifdef Q_WS_X11
+ if (event->type() == QEvent::MouseMove && this->m_fullscreen) {
+ QMouseEvent *mouseEvent = static_cast<QMouseEvent*> (event);
+ int x = mouseEvent->pos().x();
+ int y = mouseEvent->pos().y();
+
+ if (y < 0 && (obj == this->mainToolBar || !(y <= 10-this->mainToolBar->height() && y >= 0-this->mainToolBar->height() )))
+ this->mainToolBar->setVisible(false);
+ if (x < 0)
+ this->mediaView->setPlaylistVisible(false);
+ }
+#endif
+
if (event->type() == QEvent::ToolTip) {
// kill tooltips
return true;
- } else {
- // standard event processing
- return QObject::eventFilter(obj, event);
}
+ // standard event processing
+ return QObject::eventFilter(obj, event);
}
void MainWindow::createActions() {
QMap<QString, QAction*> *actions = The::globalActions();
- stopAct = new QAction(QtIconLoader::icon("media-playback-stop", QIcon(":/images/media-playback-stop.png")), tr("&Stop"), this);
+ stopAct = new QAction(QtIconLoader::icon("media-playback-stop"), tr("&Stop"), this);
stopAct->setStatusTip(tr("Stop playback and go back to the search view"));
stopAct->setShortcuts(QList<QKeySequence>() << QKeySequence(Qt::Key_Escape) << QKeySequence(Qt::Key_MediaStop));
+ stopAct->setEnabled(false);
actions->insert("stop", stopAct);
connect(stopAct, SIGNAL(triggered()), this, SLOT(stop()));
- skipAct = new QAction(QtIconLoader::icon("media-skip-forward", QIcon(":/images/media-skip-forward.png")), tr("S&kip"), this);
+ skipAct = new QAction(QtIconLoader::icon("media-skip-forward"), tr("S&kip"), this);
skipAct->setStatusTip(tr("Skip to the next video"));
skipAct->setShortcuts(QList<QKeySequence>() << QKeySequence(Qt::CTRL + Qt::Key_Right) << QKeySequence(Qt::Key_MediaNext));
skipAct->setEnabled(false);
actions->insert("skip", skipAct);
connect(skipAct, SIGNAL(triggered()), mediaView, SLOT(skip()));
- pauseAct = new QAction(QtIconLoader::icon("media-playback-pause", QIcon(":/images/media-playback-pause.png")), tr("&Pause"), this);
+ pauseAct = new QAction(QtIconLoader::icon("media-playback-pause"), tr("&Pause"), this);
pauseAct->setStatusTip(tr("Pause playback"));
pauseAct->setShortcuts(QList<QKeySequence>() << QKeySequence(Qt::Key_Space) << QKeySequence(Qt::Key_MediaPlay));
pauseAct->setEnabled(false);
actions->insert("pause", pauseAct);
connect(pauseAct, SIGNAL(triggered()), mediaView, SLOT(pause()));
- fullscreenAct = new QAction(QtIconLoader::icon("view-fullscreen", QIcon(":/images/view-fullscreen.png")), tr("&Full Screen"), this);
+ fullscreenAct = new QAction(QtIconLoader::icon("view-fullscreen"), tr("&Full Screen"), this);
fullscreenAct->setStatusTip(tr("Go full screen"));
- fullscreenAct->setShortcut(QKeySequence(Qt::ALT + Qt::Key_Return));
+ QList<QKeySequence> fsShortcuts;
+#ifdef APP_MAC
+ fsShortcuts << QKeySequence(Qt::CTRL + Qt::META + Qt::Key_F);
+#else
+ fsShortcuts << QKeySequence(Qt::Key_F11);
+#endif
+ fullscreenAct->setShortcuts(fsShortcuts);
fullscreenAct->setShortcutContext(Qt::ApplicationShortcut);
+#if QT_VERSION >= 0x040600
+ fullscreenAct->setPriority(QAction::LowPriority);
+#endif
actions->insert("fullscreen", fullscreenAct);
connect(fullscreenAct, SIGNAL(triggered()), this, SLOT(fullscreen()));
compactViewAct = new QAction(tr("&Compact mode"), this);
compactViewAct->setStatusTip(tr("Hide the playlist and the toolbar"));
- compactViewAct->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Return));
+#ifdef APP_MAC
+ compactViewAct->setShortcut(QKeySequence(Qt::CTRL + Qt::META + Qt::Key_C));
+#else
+ compactViewAct->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_C));
+#endif
compactViewAct->setCheckable(true);
compactViewAct->setChecked(false);
compactViewAct->setEnabled(false);
actions->insert("videolink", copyLinkAct);
connect(copyLinkAct, SIGNAL(triggered()), mediaView, SLOT(copyVideoLink()));
+ findVideoPartsAct = new QAction(tr("Find video &parts"), this);
+ findVideoPartsAct->setStatusTip(tr("Find other video parts hopefully in the right order"));
+ findVideoPartsAct->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_P));
+ findVideoPartsAct->setEnabled(false);
+ connect(findVideoPartsAct, SIGNAL(triggered()), mediaView, SLOT(findVideoParts()));
+ actions->insert("findVideoParts", findVideoPartsAct);
+
removeAct = new QAction(tr("&Remove"), this);
removeAct->setStatusTip(tr("Remove the selected videos from the playlist"));
removeAct->setShortcuts(QList<QKeySequence>() << QKeySequence("Del") << QKeySequence("Backspace"));
actions->insert("moveDown", moveDownAct);
connect(moveDownAct, SIGNAL(triggered()), mediaView, SLOT(moveDownSelected()));
- clearAct = new QAction(tr("&Clear recent keywords"), this);
+ clearAct = new QAction(tr("&Clear recent searches"), this);
clearAct->setMenuRole(QAction::ApplicationSpecificRole);
clearAct->setShortcuts(QList<QKeySequence>()
<< QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Delete)
quitAct->setShortcuts(QList<QKeySequence>() << QKeySequence(tr("Ctrl+Q")) << QKeySequence(Qt::CTRL + Qt::Key_W));
quitAct->setStatusTip(tr("Bye"));
actions->insert("quit", quitAct);
- connect(quitAct, SIGNAL(triggered()), this, SLOT(quit()));
+ connect(quitAct, SIGNAL(triggered()), this, SLOT(close()));
siteAct = new QAction(tr("&Website"), this);
siteAct->setShortcut(QKeySequence::HelpContents);
- siteAct->setStatusTip(tr("%1 on the Web").arg(Constants::APP_NAME));
+ siteAct->setStatusTip(tr("%1 on the Web").arg(Constants::NAME));
actions->insert("site", siteAct);
connect(siteAct, SIGNAL(triggered()), this, SLOT(visitSite()));
+#if !defined(APP_MAC) && !defined(APP_WIN)
donateAct = new QAction(tr("Make a &donation"), this);
- donateAct->setStatusTip(tr("Please support the continued development of %1").arg(Constants::APP_NAME));
+ donateAct->setStatusTip(tr("Please support the continued development of %1").arg(Constants::NAME));
actions->insert("donate", donateAct);
connect(donateAct, SIGNAL(triggered()), this, SLOT(donate()));
+#endif
aboutAct = new QAction(tr("&About"), this);
aboutAct->setMenuRole(QAction::AboutRole);
- aboutAct->setStatusTip(tr("Info about %1").arg(Constants::APP_NAME));
+ aboutAct->setStatusTip(tr("Info about %1").arg(Constants::NAME));
actions->insert("about", aboutAct);
connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));
addAction(volumeDownAct);
volumeMuteAct = new QAction(this);
+ volumeMuteAct->setIcon(QtIconLoader::icon("audio-volume-high"));
volumeMuteAct->setStatusTip(tr("Mute volume"));
- volumeMuteAct->setShortcuts(QList<QKeySequence>() << QKeySequence(tr("Ctrl+M")) << QKeySequence(Qt::Key_VolumeMute));
+ volumeMuteAct->setShortcuts(QList<QKeySequence>()
+ << QKeySequence(tr("Ctrl+M"))
+ << QKeySequence(Qt::Key_VolumeMute));
actions->insert("volume-mute", volumeMuteAct);
- connect(volumeMuteAct, SIGNAL(triggered()), this, SLOT(volumeMute()));
+ connect(volumeMuteAct, SIGNAL(triggered()), SLOT(volumeMute()));
addAction(volumeMuteAct);
QAction *definitionAct = new QAction(this);
+ definitionAct->setIcon(QtIconLoader::icon("video-display"));
definitionAct->setShortcuts(QList<QKeySequence>() << QKeySequence(Qt::CTRL + Qt::Key_D));
/*
QMenu *definitionMenu = new QMenu(this);
connect(definitionAct, SIGNAL(triggered()), SLOT(toggleDefinitionMode()));
addAction(definitionAct);
+ QAction *action;
+
+ /*
+ action = new QAction(tr("&Autoplay"), this);
+ action->setStatusTip(tr("Automatically start playing videos"));
+ action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_P));
+ action->setCheckable(true);
+ connect(action, SIGNAL(toggled(bool)), SLOT(setAutoplay(bool)));
+ actions->insert("autoplay", action);
+ */
+
+ action = new QAction(tr("&Downloads"), this);
+ action->setStatusTip(tr("Show details about video downloads"));
+ action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_J));
+ action->setCheckable(true);
+ action->setIcon(QtIconLoader::icon("go-down"));
+ action->setVisible(false);
+ connect(action, SIGNAL(toggled(bool)), SLOT(toggleDownloads(bool)));
+ actions->insert("downloads", action);
+
+ action = new QAction(tr("&Download"), this);
+ action->setStatusTip(tr("Download the current video"));
+#ifndef APP_NO_DOWNLOADS
+ action->setShortcut(QKeySequence::Save);
+#endif
+ action->setIcon(QtIconLoader::icon("go-down"));
+ action->setEnabled(false);
+#if QT_VERSION >= 0x040600
+ action->setPriority(QAction::LowPriority);
+#endif
+ connect(action, SIGNAL(triggered()), mediaView, SLOT(downloadVideo()));
+ actions->insert("download", action);
+
+ QString shareTip = tr("Share the current video using %1");
+
+ action = new QAction("&Twitter", this);
+ action->setStatusTip(shareTip.arg("Twitter"));
+ actions->insert("twitter", action);
+ connect(action, SIGNAL(triggered()), mediaView, SLOT(shareViaTwitter()));
+
+ action = new QAction("&Facebook", this);
+ action->setStatusTip(shareTip.arg("Facebook"));
+ actions->insert("facebook", action);
+ connect(action, SIGNAL(triggered()), mediaView, SLOT(shareViaFacebook()));
+
+ action = new QAction(tr("&Email"), this);
+ action->setStatusTip(shareTip.arg(tr("Email")));
+ actions->insert("email", action);
+ connect(action, SIGNAL(triggered()), mediaView, SLOT(shareViaEmail()));
+
// common action properties
foreach (QAction *action, actions->values()) {
fileMenu = menuBar()->addMenu(tr("&Application"));
// menus->insert("file", fileMenu);
fileMenu->addAction(clearAct);
-#ifndef Q_WS_MAC
+#ifndef APP_MAC
fileMenu->addSeparator();
#endif
fileMenu->addAction(quitAct);
+ QMenu* playbackMenu = menuBar()->addMenu(tr("&Playback"));
+ menus->insert("playback", playbackMenu);
+ playbackMenu->addAction(stopAct);
+ playbackMenu->addAction(pauseAct);
+ playbackMenu->addAction(skipAct);
+#ifdef APP_MAC
+ MacSupport::dockMenu(playbackMenu);
+#endif
+
playlistMenu = menuBar()->addMenu(tr("&Playlist"));
menus->insert("playlist", playlistMenu);
playlistMenu->addAction(removeAct);
playlistMenu->addAction(moveUpAct);
playlistMenu->addAction(moveDownAct);
- viewMenu = menuBar()->addMenu(tr("&Video"));
- menus->insert("video", viewMenu);
- viewMenu->addAction(stopAct);
- viewMenu->addAction(pauseAct);
- viewMenu->addAction(skipAct);
- viewMenu->addSeparator();
- viewMenu->addAction(webPageAct);
- viewMenu->addAction(copyPageAct);
- viewMenu->addAction(copyLinkAct);
- viewMenu->addSeparator();
- viewMenu->addAction(compactViewAct);
+ QMenu* videoMenu = menuBar()->addMenu(tr("&Video"));
+ menus->insert("video", videoMenu);
+ videoMenu->addAction(findVideoPartsAct);
+ videoMenu->addSeparator();
+ videoMenu->addAction(webPageAct);
+#ifndef APP_NO_DOWNLOADS
+ videoMenu->addSeparator();
+ videoMenu->addAction(The::globalActions()->value("download"));
+ videoMenu->addAction(copyLinkAct);
+#endif
+
+ QMenu* viewMenu = menuBar()->addMenu(tr("&View"));
+ menus->insert("view", viewMenu);
viewMenu->addAction(fullscreenAct);
+ viewMenu->addAction(compactViewAct);
+
+ QMenu* shareMenu = menuBar()->addMenu(tr("&Share"));
+ menus->insert("share", shareMenu);
+ shareMenu->addAction(copyPageAct);
+ shareMenu->addSeparator();
+ shareMenu->addAction(The::globalActions()->value("twitter"));
+ shareMenu->addAction(The::globalActions()->value("facebook"));
+ shareMenu->addAction(The::globalActions()->value("email"));
helpMenu = menuBar()->addMenu(tr("&Help"));
helpMenu->addAction(siteAct);
+#if !defined(APP_MAC) && !defined(APP_WIN)
helpMenu->addAction(donateAct);
+#endif
helpMenu->addAction(aboutAct);
}
void MainWindow::createToolBars() {
+ setUnifiedTitleAndToolBarOnMac(true);
+
mainToolBar = new QToolBar(this);
-#if QT_VERSION < 0x040600 || defined(Q_WS_MAC)
- mainToolBar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
+#if QT_VERSION < 0x040600 | defined(APP_MAC)
+ mainToolBar->setToolButtonStyle(Qt::ToolButtonIconOnly);
#else
mainToolBar->setToolButtonStyle(Qt::ToolButtonFollowStyle);
#endif
mainToolBar->setFloatable(false);
mainToolBar->setMovable(false);
- QFont smallerFont;
- smallerFont.setPointSize(smallerFont.pointSize()*.85);
- QFontInfo fontInfo(smallerFont);
- if (fontInfo.pixelSize() < 10) {
- smallerFont.setPixelSize(10);
- }
- mainToolBar->setFont(smallerFont);
-
-#ifdef Q_WS_MAC
+#if defined(APP_MAC) | defined(APP_WIN)
mainToolBar->setIconSize(QSize(32, 32));
#endif
mainToolBar->addAction(stopAct);
mainToolBar->addAction(pauseAct);
mainToolBar->addAction(skipAct);
- mainToolBar->addAction(fullscreenAct);
+
+ bool addFullScreenAct = true;
+#ifdef Q_WS_MAC
+ addFullScreenAct = !mac::CanGoFullScreen(winId());
+#endif
+ if (addFullScreenAct) mainToolBar->addAction(fullscreenAct);
+
+#ifndef APP_NO_DOWNLOADS
+ mainToolBar->addAction(The::globalActions()->value("download"));
+#endif
+
+ mainToolBar->addWidget(new Spacer());
+
+ QFont smallerFont = FontUtils::small();
+ currentTime = new QLabel(mainToolBar);
+ currentTime->setFont(smallerFont);
+ mainToolBar->addWidget(currentTime);
+
+ mainToolBar->addWidget(new Spacer());
seekSlider = new Phonon::SeekSlider(this);
seekSlider->setIconVisible(false);
- Spacer *seekSliderSpacer = new Spacer(mainToolBar, seekSlider);
- seekSliderSpacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
- mainToolBar->addWidget(seekSliderSpacer);
+ seekSlider->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
+ mainToolBar->addWidget(seekSlider);
+
+/*
+ mainToolBar->addWidget(new Spacer());
+ slider = new QSlider(this);
+ slider->setOrientation(Qt::Horizontal);
+ slider->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
+ mainToolBar->addWidget(slider);
+*/
+
+ mainToolBar->addWidget(new Spacer());
+
+ totalTime = new QLabel(mainToolBar);
+ totalTime->setFont(smallerFont);
+ mainToolBar->addWidget(totalTime);
+
+ mainToolBar->addWidget(new Spacer());
+
+ mainToolBar->addAction(volumeMuteAct);
volumeSlider = new Phonon::VolumeSlider(this);
+ volumeSlider->setMuteVisible(false);
// qDebug() << volumeSlider->children();
// status tip for the volume slider
QSlider* volumeQSlider = volumeSlider->findChild<QSlider*>();
if (volumeQSlider)
volumeQSlider->setStatusTip(tr("Press %1 to raise the volume, %2 to lower it").arg(
volumeUpAct->shortcut().toString(QKeySequence::NativeText), volumeDownAct->shortcut().toString(QKeySequence::NativeText)));
- // status tip for the mute button
- QToolButton* muteToolButton = volumeSlider->findChild<QToolButton*>();
- if (muteToolButton)
- muteToolButton->setStatusTip(volumeMuteAct->statusTip());
// this makes the volume slider smaller
volumeSlider->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
- mainToolBar->addWidget(new Spacer(mainToolBar, volumeSlider));
+ mainToolBar->addWidget(volumeSlider);
+
+ mainToolBar->addWidget(new Spacer());
toolbarSearch->setStatusTip(searchFocusAct->statusTip());
- mainToolBar->addWidget(new Spacer(mainToolBar, toolbarSearch));
+ mainToolBar->addWidget(toolbarSearch);
+
+ mainToolBar->addWidget(new Spacer());
addToolBar(mainToolBar);
}
void MainWindow::createStatusBar() {
-
- // remove ugly borders on OSX
- // also remove excessive spacing
- statusBar()->setStyleSheet("::item{border:0 solid} QToolBar {padding:0;spacing:0;margin:0}");
-
- currentTime = new QLabel(this);
- statusBar()->addPermanentWidget(currentTime);
-
- totalTime = new QLabel(this);
- statusBar()->addPermanentWidget(totalTime);
-
QToolBar *toolBar = new QToolBar(this);
- toolBar->setToolButtonStyle(Qt::ToolButtonTextOnly);
+ toolBar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
+ toolBar->setIconSize(QSize(16, 16));
+ toolBar->addAction(The::globalActions()->value("downloads"));
+ // toolBar->addAction(The::globalActions()->value("autoplay"));
toolBar->addAction(The::globalActions()->value("definition"));
statusBar()->addPermanentWidget(toolBar);
-
statusBar()->show();
}
void MainWindow::readSettings() {
QSettings settings;
restoreGeometry(settings.value("geometry").toByteArray());
+#ifdef APP_MAC
+ MacSupport::fixGeometry(this);
+#endif
setDefinitionMode(settings.value("definition", VideoDefinition::getDefinitionNames().first()).toString());
audioOutput->setVolume(settings.value("volume", 1).toDouble());
audioOutput->setMuted(settings.value("volumeMute").toBool());
}
void MainWindow::writeSettings() {
- // do not save geometry when in full screen
- if (m_fullscreen)
- return;
+
QSettings settings;
- settings.setValue("geometry", saveGeometry());
+
+ // do not save geometry when in full screen
+ if (!m_fullscreen) {
+ settings.setValue("geometry", saveGeometry());
+ }
+
settings.setValue("volume", audioOutput->volume());
settings.setValue("volumeMute", audioOutput->isMuted());
mediaView->saveSplitterState();
QString windowTitle = metadata.value("title").toString();
if (windowTitle.length())
windowTitle += " - ";
- setWindowTitle(windowTitle + Constants::APP_NAME);
+ setWindowTitle(windowTitle + Constants::NAME);
statusBar()->showMessage((metadata.value("description").toString()));
}
stopAct->setEnabled(widget == mediaView);
- fullscreenAct->setEnabled(widget == mediaView);
compactViewAct->setEnabled(widget == mediaView);
webPageAct->setEnabled(widget == mediaView);
copyPageAct->setEnabled(widget == mediaView);
copyLinkAct->setEnabled(widget == mediaView);
+ findVideoPartsAct->setEnabled(widget == mediaView);
+ toolbarSearch->setEnabled(widget == searchView || widget == mediaView || widget == downloadView);
+
+ The::globalActions()->value("twitter")->setEnabled(widget == mediaView);
+ The::globalActions()->value("facebook")->setEnabled(widget == mediaView);
+ The::globalActions()->value("email")->setEnabled(widget == mediaView);
+
aboutAct->setEnabled(widget != aboutView);
+ The::globalActions()->value("download")->setEnabled(widget == mediaView);
+ The::globalActions()->value("downloads")->setChecked(widget == downloadView);
// toolbar only for the mediaView
- mainToolBar->setVisible(widget == mediaView && !compactViewAct->isChecked());
+ /* mainToolBar->setVisible(
+ (widget == mediaView && !compactViewAct->isChecked())
+ || widget == downloadView
+ ); */
setUpdatesEnabled(true);
QWidget *oldWidget = views->currentWidget();
views->setCurrentWidget(widget);
-#ifdef Q_WS_MAC
- // crossfade only on OSX
- // where we can be sure of video performance
- fadeInWidget(oldWidget, widget);
+#ifndef Q_WS_X11
+ Extra::fadeInWidget(oldWidget, widget);
#endif
history->push(widget);
}
-void MainWindow::fadeInWidget(QWidget *oldWidget, QWidget *newWidget) {
- if (faderWidget) faderWidget->close();
- if (!oldWidget || !newWidget) {
- // qDebug() << "no widgets";
- return;
- }
- faderWidget = new FaderWidget(newWidget);
- faderWidget->start(QPixmap::grabWidget(oldWidget));
-}
-
void MainWindow::about() {
if (!aboutView) {
aboutView = new AboutView(this);
void MainWindow::quit() {
writeSettings();
+ Temporary::deleteAll();
qApp->quit();
}
void MainWindow::closeEvent(QCloseEvent *event) {
+ if (DownloadManager::instance()->activeItems() > 0) {
+ QMessageBox msgBox;
+ msgBox.setIconPixmap(QPixmap(":/images/app.png").scaled(64, 64, Qt::KeepAspectRatio, Qt::SmoothTransformation));
+ msgBox.setText(tr("Do you want to exit %1 with a download in progress?").arg(Constants::NAME));
+ msgBox.setInformativeText(tr("If you close %1 now, this download will be cancelled.").arg(Constants::NAME));
+ msgBox.setModal(true);
+
+ msgBox.addButton(tr("Close and cancel download"), QMessageBox::RejectRole);
+ QPushButton *waitButton = msgBox.addButton(tr("Wait for download to finish"), QMessageBox::ActionRole);
+
+ msgBox.exec();
+
+ if (msgBox.clickedButton() == waitButton) {
+ event->ignore();
+ return;
+ }
+
+ }
quit();
QWidget::closeEvent(event);
}
-/*
-void MainWindow::showSettings() {
- if (!settingsView) {
- settingsView = new SettingsView(this);
- views->addWidget(settingsView);
- }
- showWidget(settingsView);
-}*/
-
void MainWindow::showSearch() {
showWidget(searchView);
currentTime->clear();
totalTime->clear();
}
-void MainWindow::showMedia(QString query) {
- SearchParams *searchParams = new SearchParams();
- searchParams->setKeywords(query);
+void MainWindow::showMedia(SearchParams *searchParams) {
+ if (toolbarSearch->text().isEmpty() && !searchParams->keywords().isEmpty()) {
+ toolbarSearch->lineEdit()->setText(searchParams->keywords());
+ }
mediaView->search(searchParams);
showWidget(mediaView);
}
case Phonon::ErrorState:
if (mediaObject->errorType() == Phonon::FatalError) {
- statusBar()->showMessage(tr("Fatal error: %1").arg(mediaObject->errorString()));
+ // Do not display because we try to play incomplete video files and sometimes trigger this
+ // We retry automatically (in MediaView) so no need to show it
+ // statusBar()->showMessage(tr("Fatal error: %1").arg(mediaObject->errorString()));
} else {
statusBar()->showMessage(tr("Error: %1").arg(mediaObject->errorString()));
}
case Phonon::PlayingState:
pauseAct->setEnabled(true);
- pauseAct->setIcon(QtIconLoader::icon("media-playback-pause", QIcon(":/images/media-playback-pause.png")));
+ pauseAct->setIcon(QtIconLoader::icon("media-playback-pause"));
pauseAct->setText(tr("&Pause"));
pauseAct->setStatusTip(tr("Pause playback") + " (" + pauseAct->shortcut().toString(QKeySequence::NativeText) + ")");
skipAct->setEnabled(true);
+ // stopAct->setEnabled(true);
break;
case Phonon::StoppedState:
pauseAct->setEnabled(false);
skipAct->setEnabled(false);
+ // stopAct->setEnabled(false);
break;
case Phonon::PausedState:
skipAct->setEnabled(true);
pauseAct->setEnabled(true);
- pauseAct->setIcon(QtIconLoader::icon("media-playback-start", QIcon(":/images/media-playback-start.png")));
+ pauseAct->setIcon(QtIconLoader::icon("media-playback-start"));
pauseAct->setText(tr("&Play"));
pauseAct->setStatusTip(tr("Resume playback") + " (" + pauseAct->shortcut().toString(QKeySequence::NativeText) + ")");
+ // stopAct->setEnabled(true);
break;
case Phonon::BufferingState:
pauseAct->setEnabled(false);
currentTime->clear();
totalTime->clear();
+ // stopAct->setEnabled(true);
break;
default:
showSearch();
}
-void MainWindow::fullscreen() {
-
- setUpdatesEnabled(false);
+void MainWindow::resizeEvent(QResizeEvent*) {
+#ifdef Q_WS_MAC
+ if (mac::CanGoFullScreen(winId())) {
+ bool isFullscreen = mac::IsFullScreen(winId());
+ if (isFullscreen != m_fullscreen) {
+ m_fullscreen = isFullscreen;
+ updateUIForFullscreen();
+ }
+ }
+#endif
+}
- // No compact view action when in full screen
- compactViewAct->setVisible(m_fullscreen);
- compactViewAct->setChecked(false);
+void MainWindow::fullscreen() {
- // Also no Youtube action since it opens a new window
- webPageAct->setVisible(m_fullscreen);
- copyPageAct->setVisible(m_fullscreen);
- copyLinkAct->setVisible(m_fullscreen);
+#ifdef Q_WS_MAC
+ WId handle = winId();
+ if (mac::CanGoFullScreen(handle)) {
+ mac::ToggleFullScreen(handle);
+ return;
+ }
+#endif
- stopAct->setVisible(m_fullscreen);
+ m_fullscreen = !m_fullscreen;
- // workaround: prevent focus on the search bar
- // it steals the Space key needed for Play/Pause
- mainToolBar->setEnabled(m_fullscreen);
+ if (m_fullscreen) {
+ // Enter full screen
- // Hide anything but the video
- mediaView->setPlaylistVisible(m_fullscreen);
- statusBar()->setVisible(m_fullscreen);
+ m_maximized = isMaximized();
-#ifndef Q_WS_MAC
- menuBar()->setVisible(m_fullscreen);
-#endif
+ // save geometry now, if the user quits when in full screen
+ // geometry won't be saved
+ writeSettings();
#ifdef Q_WS_MAC
- // make the actions work when video is fullscreen (on the Mac)
- QMap<QString, QAction*> *actions = The::globalActions();
- foreach (QAction *action, actions->values()) {
- if (m_fullscreen) {
- action->setShortcutContext(Qt::WindowShortcut);
- } else {
- action->setShortcutContext(Qt::ApplicationShortcut);
- }
- }
+ MacSupport::enterFullScreen(this, views);
+#else
+ mainToolBar->hide();
+ showFullScreen();
#endif
- if (m_fullscreen) {
- // use setShortucs instead of setShortcut
- // the latter seems not to work
- fullscreenAct->setShortcuts(QList<QKeySequence>() << QKeySequence(Qt::ALT + Qt::Key_Return));
- fullscreenAct->setText(tr("&Full Screen"));
- stopAct->setShortcuts(QList<QKeySequence>() << QKeySequence(Qt::Key_Escape) << QKeySequence(Qt::Key_MediaStop));
+ } else {
+ // Exit full screen
+#ifdef Q_WS_MAC
+ MacSupport::exitFullScreen(this, views);
+#else
mainToolBar->show();
if (m_maximized) showMaximized();
else showNormal();
+#endif
- // Make sure the window has focus (Mac)
+ // Make sure the window has focus
activateWindow();
+ }
+
+ updateUIForFullscreen();
+
+}
+
+void MainWindow::updateUIForFullscreen() {
+ static QList<QKeySequence> fsShortcuts;
+ static QString fsText;
+
+ if (m_fullscreen) {
+ fsShortcuts = fullscreenAct->shortcuts();
+ fsText = fullscreenAct->text();
+ fullscreenAct->setShortcuts(QList<QKeySequence>(fsShortcuts)
+ << QKeySequence(Qt::Key_Escape));
+ fullscreenAct->setText(tr("Leave &Full Screen"));
} else {
- stopAct->setShortcuts(QList<QKeySequence>() << QKeySequence(Qt::Key_MediaStop));
- fullscreenAct->setShortcuts(QList<QKeySequence>() << QKeySequence(Qt::Key_Escape) << QKeySequence(Qt::ALT + Qt::Key_Return));
- fullscreenAct->setText(tr("Exit &Full Screen"));
- m_maximized = isMaximized();
+ fullscreenAct->setShortcuts(fsShortcuts);
+ fullscreenAct->setText(fsText);
+ }
- // save geometry now, if the user quits when in full screen
- // geometry won't be saved
- writeSettings();
+ // No compact view action when in full screen
+ compactViewAct->setVisible(!m_fullscreen);
+ compactViewAct->setChecked(false);
- mainToolBar->hide();
- showFullScreen();
+ // Hide anything but the video
+ mediaView->setPlaylistVisible(!m_fullscreen);
+ statusBar()->setVisible(!m_fullscreen);
+
+#ifndef APP_MAC
+ menuBar()->setVisible(!m_fullscreen);
+#endif
+
+ if (m_fullscreen) {
+ stopAct->setShortcuts(QList<QKeySequence>() << QKeySequence(Qt::Key_MediaStop));
+ } else {
+ stopAct->setShortcuts(QList<QKeySequence>() << QKeySequence(Qt::Key_Escape) << QKeySequence(Qt::Key_MediaStop));
}
- m_fullscreen = !m_fullscreen;
+#ifdef Q_WS_MAC
+ MacSupport::fullScreenActions(The::globalActions()->values(), m_fullscreen);
+#endif
- setUpdatesEnabled(true);
+ if (views->currentWidget() == mediaView)
+ mediaView->setFocus();
}
void MainWindow::compactView(bool enable) {
- setUpdatesEnabled(false);
+ static QList<QKeySequence> compactShortcuts;
+ static QList<QKeySequence> stopShortcuts;
- mainToolBar->setVisible(!enable);
- mainToolBar->setEnabled(!enable);
- mediaView->setPlaylistVisible(!enable);
- statusBar()->setVisible(!enable);
+ /*
+ const static QString key = "compactGeometry";
+ QSettings settings;
+ */
-#ifndef Q_WS_MAC
+#ifndef APP_MAC
menuBar()->setVisible(!enable);
#endif
- // ensure focus does not end up to the search box
- // as it would steal the Space shortcut
- // toolbarSearch->setEnabled(!enable);
-
if (enable) {
- stopAct->setShortcut(QString(""));
- QList<QKeySequence> shortcuts;
- // for some reason it is important that ESC comes first
- shortcuts << QKeySequence(Qt::CTRL + Qt::Key_Return) << QKeySequence(Qt::Key_Escape);
- compactViewAct->setShortcuts(shortcuts);
+ /*
+ writeSettings();
+ restoreGeometry(settings.value(key).toByteArray());
+ */
+
+ compactShortcuts = compactViewAct->shortcuts();
+ stopShortcuts = stopAct->shortcuts();
+
+ QList<QKeySequence> newStopShortcuts(stopShortcuts);
+ newStopShortcuts.removeAll(QKeySequence(Qt::Key_Escape));
+ stopAct->setShortcuts(newStopShortcuts);
+ compactViewAct->setShortcuts(QList<QKeySequence>(compactShortcuts) << QKeySequence(Qt::Key_Escape));
+
+ // ensure focus does not end up to the search box
+ // as it would steal the Space shortcut
+ mediaView->setFocus();
} else {
- compactViewAct->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Return));
- stopAct->setShortcut(QKeySequence(Qt::Key_Escape));
+ /*
+ settings.setValue(key, saveGeometry());
+ readSettings();
+ */
+
+ compactViewAct->setShortcuts(compactShortcuts);
+ stopAct->setShortcuts(stopShortcuts);
}
- setUpdatesEnabled(true);
+ mainToolBar->setVisible(!enable);
+ mediaView->setPlaylistVisible(!enable);
+ statusBar()->setVisible(!enable);
+
}
void MainWindow::searchFocus() {
QWidget *view = views->currentWidget();
- if (view == mediaView) {
- toolbarSearch->selectAll();
- toolbarSearch->setFocus();
- }
+ toolbarSearch->selectAll();
+ toolbarSearch->setFocus();
}
void MainWindow::initPhonon() {
void MainWindow::tick(qint64 time) {
if (time <= 0) {
- currentTime->clear();
+ // the "if" is important because tick is continually called
+ // and we don't want to paint the toolbar every 100ms
+ if (!currentTime->text().isEmpty()) currentTime->clear();
return;
}
const qint64 remainingTime = mediaObject->remainingTime();
currentTime->setStatusTip(tr("Remaining time: %1").arg(formatTime(remainingTime)));
+ /*
+ slider->blockSignals(true);
+ slider->setValue(time/1000);
+ slider->blockSignals(false);
+ */
}
void MainWindow::totalTimeChanged(qint64 time) {
totalTime->clear();
return;
}
- totalTime->setText("/ " + formatTime(time));
+ totalTime->setText(formatTime(time));
+
+ /*
+ slider->blockSignals(true);
+ slider->setMaximum(time/1000);
+ slider->blockSignals(false);
+ */
+
}
QString MainWindow::formatTime(qint64 time) {
// automatically unmute when volume changes
if (volumeSlider->audioOutput()->isMuted())
volumeSlider->audioOutput()->setMuted(false);
- statusBar()->showMessage(tr("Volume at %1%").arg(newVolume*100));
+ statusBar()->showMessage(tr("Volume at %1%").arg((int)(newVolume*100)));
}
void MainWindow::volumeMutedChanged(bool muted) {
- if (muted)
+ if (muted) {
+ volumeMuteAct->setIcon(QtIconLoader::icon("audio-volume-muted"));
statusBar()->showMessage(tr("Volume is muted"));
- else
+ } else {
+ volumeMuteAct->setIcon(QtIconLoader::icon("audio-volume-high"));
statusBar()->showMessage(tr("Volume is unmuted"));
+ }
}
void MainWindow::setDefinitionMode(QString definitionName) {
void MainWindow::showFullscreenToolbar(bool show) {
if (!m_fullscreen) return;
-
- if (show) {
- mainToolBar->show();
- } else {
- mainToolBar->hide();
- }
- mainToolBar->setEnabled(show);
+ mainToolBar->setVisible(show);
}
void MainWindow::showFullscreenPlaylist(bool show) {
void MainWindow::clearRecentKeywords() {
QSettings settings;
settings.remove("recentKeywords");
+ settings.remove("recentChannels");
searchView->updateRecentKeywords();
+ searchView->updateRecentChannels();
statusBar()->showMessage(tr("Your privacy is now safe"));
}
+
+/*
+ void MainWindow::setAutoplay(bool enabled) {
+ QSettings settings;
+ settings.setValue("autoplay", QVariant::fromValue(enabled));
+ }
+ */
+
+void MainWindow::updateDownloadMessage(QString message) {
+ The::globalActions()->value("downloads")->setText(message);
+}
+
+void MainWindow::downloadsFinished() {
+ The::globalActions()->value("downloads")->setText(tr("&Downloads"));
+ statusBar()->showMessage(tr("Downloads complete"));
+}
+
+void MainWindow::toggleDownloads(bool show) {
+
+ if (show) {
+ stopAct->setShortcuts(QList<QKeySequence>() << QKeySequence(Qt::Key_MediaStop));
+ The::globalActions()->value("downloads")->setShortcuts(
+ QList<QKeySequence>() << QKeySequence(Qt::CTRL + Qt::Key_J)
+ << QKeySequence(Qt::Key_Escape));
+ } else {
+ The::globalActions()->value("downloads")->setShortcuts(
+ QList<QKeySequence>() << QKeySequence(Qt::CTRL + Qt::Key_J));
+ stopAct->setShortcuts(QList<QKeySequence>() << QKeySequence(Qt::Key_Escape) << QKeySequence(Qt::Key_MediaStop));
+ }
+
+ if (!downloadView) {
+ downloadView = new DownloadView(this);
+ views->addWidget(downloadView);
+ }
+ if (show) showWidget(downloadView);
+ else goBack();
+}
+
+void MainWindow::startToolbarSearch(QString query) {
+
+ query = query.trimmed();
+
+ // check for empty query
+ if (query.length() == 0) {
+ return;
+ }
+
+ SearchParams *searchParams = new SearchParams();
+ searchParams->setKeywords(query);
+
+ // go!
+ showMedia(searchParams);
+}
+
+void MainWindow::dragEnterEvent(QDragEnterEvent *event) {
+ if (event->mimeData()->hasFormat("text/uri-list")) {
+ QList<QUrl> urls = event->mimeData()->urls();
+ if (urls.isEmpty())
+ return;
+ QUrl url = urls.first();
+ QString videoId = YouTubeSearch::videoIdFromUrl(url.toString());
+ if (!videoId.isNull())
+ event->acceptProposedAction();
+ }
+}
+
+void MainWindow::dropEvent(QDropEvent *event) {
+ QList<QUrl> urls = event->mimeData()->urls();
+ if (urls.isEmpty())
+ return;
+ QUrl url = urls.first();
+ QString videoId = YouTubeSearch::videoIdFromUrl(url.toString());
+ if (!videoId.isNull()) {
+ setWindowTitle(url.toString());
+ SearchParams *searchParams = new SearchParams();
+ searchParams->setKeywords(videoId);
+ showMedia(searchParams);
+ }
+}
+
+void MainWindow::checkForUpdate() {
+ static const QString updateCheckKey = "updateCheck";
+
+ // check every 24h
+ QSettings settings;
+ uint unixTime = QDateTime::currentDateTime().toTime_t();
+ int lastCheck = settings.value(updateCheckKey).toInt();
+ int secondsSinceLastCheck = unixTime - lastCheck;
+ // qDebug() << "secondsSinceLastCheck" << unixTime << lastCheck << secondsSinceLastCheck;
+ if (secondsSinceLastCheck < 86400) return;
+
+ // check it out
+ if (updateChecker) delete updateChecker;
+ updateChecker = new UpdateChecker();
+ connect(updateChecker, SIGNAL(newVersion(QString)),
+ this, SLOT(gotNewVersion(QString)));
+ updateChecker->checkForUpdate();
+ settings.setValue(updateCheckKey, unixTime);
+
+}
+
+void MainWindow::gotNewVersion(QString version) {
+ if (updateChecker) {
+ delete updateChecker;
+ updateChecker = 0;
+ }
+
+#if defined(APP_DEMO) || defined(APP_MAC_STORE)
+ return;
+#endif
+
+ QSettings settings;
+ QString checkedVersion = settings.value("checkedVersion").toString();
+ if (checkedVersion == version) return;
+
+ QMessageBox msgBox(this);
+ msgBox.setIconPixmap(QPixmap(":/images/app.png").scaled(64, 64, Qt::KeepAspectRatio, Qt::SmoothTransformation));
+ msgBox.setText(tr("%1 version %2 is now available.").arg(Constants::NAME, version));
+
+ msgBox.setModal(true);
+ // make it a "sheet" on the Mac
+ msgBox.setWindowModality(Qt::WindowModal);
+
+ QPushButton* laterButton = 0;
+ QPushButton* updateButton = 0;
+
+#if defined(APP_MAC) || defined(APP_WIN)
+ msgBox.setInformativeText(
+ tr("To get the updated version, download %1 again from the link you received via email and reinstall.")
+ .arg(Constants::NAME)
+ );
+ laterButton = msgBox.addButton(tr("Remind me later"), QMessageBox::RejectRole);
+ msgBox.addButton(QMessageBox::Ok);
+#else
+ msgBox.addButton(QMessageBox::Close);
+ updateButton = msgBox.addButton(tr("Update"), QMessageBox::AcceptRole);
+#endif
+
+ msgBox.exec();
+
+ if (msgBox.clickedButton() != laterButton) {
+ settings.setValue("checkedVersion", version);
+ }
+
+ if (updateButton && msgBox.clickedButton() == updateButton) {
+ QDesktopServices::openUrl(QUrl(QLatin1String(Constants::WEBSITE) + "#download"));
+ }
+
+}
projects / minitube / blobdiff