File indexing completed on 2024-05-19 04:59:17

 /* ============================================================
 * Mouse Gestures plugin for Falkon
 * Copyright (C) 2013-2017 David Rosca <nowrep@gmail.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 3 of the License, or
 * (at your option) any later version.
 *
 * 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 "mousegestures.h"
 #include "webpage.h"
 #include "tabbedwebview.h"
 #include "tabwidget.h"
 #include "mainapplication.h"
 #include "browserwindow.h"
 #include "locationbar.h"
 #include "mousegesturessettingsdialog.h"
 
 #include "QjtMouseGestureFilter.h"
 #include "QjtMouseGesture.h"
 
 #include <QMouseEvent>
 #include <QWebEngineHistory>
 #include <QSettings>
 
 MouseGestures::MouseGestures(const QString &settingsPath, QObject* parent)
     : QObject(parent)
     , m_filter(nullptr)
     , m_settingsFile(settingsPath + QL1S("/extensions.ini"))
     , m_button(Qt::MiddleButton)
 {
     loadSettings();
 }
 
 void MouseGestures::initFilter()
 {
     if (m_filter) {
         m_filter->clearGestures(true);
         delete m_filter;
     }
 
     m_filter = new QjtMouseGestureFilter(false, m_button, 20);
 
     auto* upGesture = new QjtMouseGesture(DirectionList() << Up, m_filter);
     connect(upGesture, &QjtMouseGesture::gestured, this, &MouseGestures::upGestured);
 
     auto* downGesture = new QjtMouseGesture(DirectionList() << Down, m_filter);
     connect(downGesture, &QjtMouseGesture::gestured, this, &MouseGestures::downGestured);
 
     auto* leftGesture = new QjtMouseGesture(DirectionList() << Left, m_filter);
     connect(leftGesture, &QjtMouseGesture::gestured, this, &MouseGestures::leftGestured);
 
     auto* rightGesture = new QjtMouseGesture(DirectionList() << Right, m_filter);
     connect(rightGesture, &QjtMouseGesture::gestured, this, &MouseGestures::rightGestured);
 
     auto* downRightGesture = new QjtMouseGesture(DirectionList() << Down << Right, m_filter);
     connect(downRightGesture, &QjtMouseGesture::gestured, this, &MouseGestures::downRightGestured);
 
     auto* downLeftGesture = new QjtMouseGesture(DirectionList() << Down << Left, m_filter);
     connect(downLeftGesture, &QjtMouseGesture::gestured, this, &MouseGestures::downLeftGestured);
 
     auto* downUpGesture = new QjtMouseGesture(DirectionList() << Down << Up, m_filter);
     connect(downUpGesture, &QjtMouseGesture::gestured, this, &MouseGestures::downUpGestured);
 
     auto* upDownGesture = new QjtMouseGesture(DirectionList() << Up << Down, m_filter);
     connect(upDownGesture, &QjtMouseGesture::gestured, this, &MouseGestures::upDownGestured);
 
     auto* upLeftGesture = new QjtMouseGesture(DirectionList() << Up << Left, m_filter);
     connect(upLeftGesture, &QjtMouseGesture::gestured, this, &MouseGestures::upLeftGestured);
 
     auto* upRightGesture = new QjtMouseGesture(DirectionList() << Up << Right, m_filter);
     connect(upRightGesture, &QjtMouseGesture::gestured, this, &MouseGestures::upRightGestured);
 
     m_filter->addGesture(upGesture);
     m_filter->addGesture(downGesture);
     m_filter->addGesture(leftGesture);
     m_filter->addGesture(rightGesture);
 
     m_filter->addGesture(downRightGesture);
     m_filter->addGesture(downLeftGesture);
     m_filter->addGesture(downUpGesture);
     m_filter->addGesture(upDownGesture);
     m_filter->addGesture(upLeftGesture);
     m_filter->addGesture(upRightGesture);
 }
 
 bool MouseGestures::mousePress(QObject* obj, QMouseEvent* event)
 {
     m_view = qobject_cast<WebView*>(obj);
 
     if (m_enableRockerNavigation && event->buttons() == (Qt::RightButton | Qt::LeftButton)) {
         bool accepted = false;
 
         if (event->button() == Qt::LeftButton && m_view.data()->history()->canGoBack()) {
             m_view.data()->back();
             accepted = true;
         }
         else if (event->button() == Qt::RightButton && m_view.data()->history()->canGoForward()) {
             m_view.data()->forward();
             accepted = true;
         }
 
         if (accepted) {
             m_blockNextLeftMouseRelease = true;
             m_blockNextRightMouseRelease = true;
             return true;
         }
     }
 
     m_filter->mouseButtonPressEvent(event);
 
     return false;
 }
 
 bool MouseGestures::mouseRelease(QObject* obj, QMouseEvent* event)
 {
     Q_UNUSED(obj)
 
     if (m_blockNextRightMouseRelease && event->button() == Qt::RightButton) {
         m_blockNextRightMouseRelease = false;
         return true;
     }
 
     if (m_blockNextLeftMouseRelease && event->button() == Qt::LeftButton) {
         m_blockNextLeftMouseRelease = false;
         return true;
     }
 
     return m_filter->mouseButtonReleaseEvent(event);
 }
 
 bool MouseGestures::mouseMove(QObject* obj, QMouseEvent* event)
 {
     Q_UNUSED(obj)
 
     m_filter->mouseMoveEvent(event);
 
     return false;
 }
 
 void MouseGestures::showSettings(QWidget* parent)
 {
     if (!m_settings) {
         m_settings = new MouseGesturesSettingsDialog(this, parent);
     }
 
     m_settings.data()->show();
     m_settings.data()->raise();
 }
 
 void MouseGestures::unloadPlugin()
 {
     delete m_settings.data();
 }
 
 void MouseGestures::upGestured()
 {
     if (!m_view) {
         return;
     }
 
     m_view.data()->stop();
 }
 
 void MouseGestures::downGestured()
 {
     auto* view = qobject_cast<TabbedWebView*>(m_view.data());
     if (!view)
         return;
 
     BrowserWindow* window = view->browserWindow();
     if (!window)
         return;
 
     TabWidget* tabWidget = window->tabWidget();
     tabWidget->addView(QUrl(), Qz::NT_SelectedNewEmptyTab, true);
     tabWidget->setCurrentTabFresh(true);
 
     if (window->isFullScreen())
         window->showNavigationWithFullScreen();
 }
 
 void MouseGestures::leftGestured()
 {
     if (!m_view) {
         return;
     }
 
     if (QApplication::isRightToLeft()) {
         m_view.data()->forward();
     }
     else {
         m_view.data()->back();
     }
 }
 
 void MouseGestures::rightGestured()
 {
     if (!m_view) {
         return;
     }
 
     if (QApplication::isRightToLeft()) {
         m_view.data()->back();
     }
     else {
         m_view.data()->forward();
     }
 }
 
 void MouseGestures::downRightGestured()
 {
     auto *view = qobject_cast<TabbedWebView*>(m_view.data());
     if (!view)
         return;
 
     BrowserWindow *window = view->browserWindow();
     if (!window)
         return;
 
     TabWidget *tabWidget = window->tabWidget();
     if (!m_view) {
         return;
     }
 
     tabWidget->requestCloseTab(view->tabIndex());
 }
 
 void MouseGestures::downLeftGestured()
 {
     if (!m_view) {
         return;
     }
 
     m_view.data()->load(mApp->getWindow()->homepageUrl());
 }
 
 void MouseGestures::downUpGestured()
 {
     auto* view = qobject_cast<TabbedWebView*>(m_view.data());
     if (!view)
         return;
 
     BrowserWindow* window = view->browserWindow();
     if (!window)
         return;
 
     TabWidget* tabWidget = window->tabWidget();
     tabWidget->duplicateTab(tabWidget->currentIndex());
 }
 
 void MouseGestures::upDownGestured()
 {
     if (!m_view) {
         return;
     }
 
     m_view.data()->reload();
 }
 
 void MouseGestures::upLeftGestured()
 {
     auto* view = qobject_cast<TabbedWebView*>(m_view.data());
     if (!view)
         return;
 
     BrowserWindow* window = view->browserWindow();
     if (!window)
         return;
 
     if (QApplication::isRightToLeft())
         window->tabWidget()->nextTab();
     else
         window->tabWidget()->previousTab();
 }
 
 void MouseGestures::upRightGestured()
 {
     auto* view = qobject_cast<TabbedWebView*>(m_view.data());
     if (!view)
         return;
 
     BrowserWindow* window = view->browserWindow();
     if (!window)
         return;
 
     if (QApplication::isRightToLeft())
         window->tabWidget()->previousTab();
     else
         window->tabWidget()->nextTab();
 }
 
 void MouseGestures::init()
 {
     initFilter();
 
     // We need to override right mouse button events
     m_oldWebViewForceContextMenuOnRelease = WebView::forceContextMenuOnMouseRelease();
     WebView::setForceContextMenuOnMouseRelease(m_button == Qt::RightButton || m_enableRockerNavigation);
 }
 
 void MouseGestures::setGestureButton(Qt::MouseButton button)
 {
     m_button = button;
     init();
 }
 
 void MouseGestures::setGestureButtonByIndex(int index)
 {
     switch (index) {
     case 0:
         m_button = Qt::MiddleButton;
         break;
 
     case 1:
         m_button = Qt::RightButton;
         break;
 
     default:
         m_button = Qt::NoButton;
     }
 
     setGestureButton(m_button);
 }
 
 Qt::MouseButton MouseGestures::gestureButton() const
 {
     return m_button;
 }
 
 int MouseGestures::buttonToIndex() const
 {
     switch (m_button) {
     case Qt::MiddleButton:
         return 0;
 
     case Qt::RightButton:
         return 1;
 
     default:
         return 2;
     }
 }
 
 bool MouseGestures::rockerNavigationEnabled() const
 {
     return m_enableRockerNavigation;
 }
 
 void MouseGestures::setRockerNavigationEnabled(bool enable)
 {
     m_enableRockerNavigation = enable;
     init();
 }
 
 void MouseGestures::loadSettings()
 {
     QSettings settings(m_settingsFile, QSettings::IniFormat);
 
     settings.beginGroup("MouseGestures");
     setGestureButtonByIndex(settings.value("Button", 0).toInt());
     m_enableRockerNavigation = settings.value("RockerNavigation", true).toBool();
     settings.endGroup();
 
     init();
 }
 
 void MouseGestures::saveSettings()
 {
     QSettings settings(m_settingsFile, QSettings::IniFormat);
 
     settings.beginGroup("MouseGestures");
     settings.setValue("Button", buttonToIndex());
     settings.setValue("RockerNavigation", m_enableRockerNavigation);
     settings.endGroup();
 }
 
 MouseGestures::~MouseGestures()
 {
     m_filter->clearGestures(true);
     delete m_filter;
 
     // Restore original value
     WebView::setForceContextMenuOnMouseRelease(m_oldWebViewForceContextMenuOnRelease);
 }