mousegestures.cpp

Go to the documentation of this file.

/* ============================================================
* 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);
}