id
int64 0
755k
| file_name
stringlengths 3
109
| file_path
stringlengths 13
185
| content
stringlengths 31
9.38M
| size
int64 31
9.38M
| language
stringclasses 1
value | extension
stringclasses 11
values | total_lines
int64 1
340k
| avg_line_length
float64 2.18
149k
| max_line_length
int64 7
2.22M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 6
65
| repo_stars
int64 100
47.3k
| repo_forks
int64 0
12k
| repo_open_issues
int64 0
3.4k
| repo_license
stringclasses 9
values | repo_extraction_date
stringclasses 92
values | exact_duplicates_redpajama
bool 2
classes | near_duplicates_redpajama
bool 2
classes | exact_duplicates_githubcode
bool 2
classes | exact_duplicates_stackv2
bool 1
class | exact_duplicates_stackv1
bool 2
classes | near_duplicates_githubcode
bool 2
classes | near_duplicates_stackv1
bool 2
classes | near_duplicates_stackv2
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
18,194
|
winplatformclipboard.cpp
|
hluk_CopyQ/src/platform/win/winplatformclipboard.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "winplatformclipboard.h"
#include <QClipboard>
#include <QMimeData>
#include <QTimer>
namespace {
bool contains(const QStringList &formats, const QMimeData &data, const QString &format, const QByteArray &value)
{
return formats.contains(format) && data.data(format) == value;
}
} // namespace
void WinPlatformClipboard::startMonitoring(const QStringList &formats)
{
m_lastClipboardSequenceNumber = GetClipboardSequenceNumber();
/* Clipboard needs to be checked in intervals since
* the QClipboard::changed() signal is not emitted in some cases on Windows.
*/
QTimer *timer = new QTimer(this);
timer->setInterval(500);
connect( timer, &QTimer::timeout, this, [this](){
onClipboardChanged(QClipboard::Clipboard);
});
timer->start();
DummyClipboard::startMonitoring(formats);
}
bool WinPlatformClipboard::isHidden(const QMimeData &data) const
{
static const QByteArray zeroDWord(4, '\0');
// QMimeData::hasFormat does not seem to work in this case (in Qt 5.15.2).
const QStringList formats = data.formats();
return formats.contains(
QLatin1String("application/x-qt-windows-mime;value=\"Clipboard Viewer Ignore\""))
// https://learn.microsoft.com/en-us/windows/win32/dataxchg/clipboard-formats#cloud-clipboard-and-clipboard-history-formats
|| formats.contains(
QLatin1String("application/x-qt-windows-mime;value=\"ExcludeClipboardContentFromMonitorProcessing\""))
|| contains(formats, data,
QStringLiteral("application/x-qt-windows-mime;value=\"CanIncludeInClipboardHistory\""), zeroDWord)
|| contains(formats, data,
QStringLiteral("application/x-qt-windows-mime;value=\"CanUploadToCloudClipboard\""), zeroDWord)
// This is set by some Qt apps
|| contains(formats, data,
QStringLiteral("ExcludeClipboardContentFromMonitorProcessing"), QByteArrayLiteral("1"));
}
void WinPlatformClipboard::onChanged(int)
{
const DWORD newClipboardSequenceNumber = GetClipboardSequenceNumber();
if (newClipboardSequenceNumber == m_lastClipboardSequenceNumber)
return;
m_lastClipboardSequenceNumber = newClipboardSequenceNumber;
emit changed(ClipboardMode::Clipboard);
}
| 2,320
|
C++
|
.cpp
| 51
| 40.215686
| 131
| 0.736352
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,195
|
clipboardmonitor.cpp
|
hluk_CopyQ/src/app/clipboardmonitor.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "clipboardmonitor.h"
#include "common/action.h"
#include "common/appconfig.h"
#include "common/common.h"
#include "common/log.h"
#include "common/mimetypes.h"
#include "common/textdata.h"
#include "item/serialize.h"
#include "platform/platformclipboard.h"
#include <QApplication>
#include <QClipboard>
namespace {
bool hasSameData(const QVariantMap &data, const QVariantMap &lastData)
{
for (auto it = lastData.constBegin(); it != lastData.constEnd(); ++it) {
const auto &format = it.key();
if ( !data.contains(format) )
return false;
}
for (auto it = data.constBegin(); it != data.constEnd(); ++it) {
const auto &format = it.key();
if ( !data[format].toByteArray().isEmpty()
&& data[format] != lastData.value(format) )
{
return false;
}
}
return true;
}
bool isClipboardDataHidden(const QVariantMap &data)
{
return data.value(mimeHidden).toByteArray() == "1";
}
bool isClipboardDataSecret(const QVariantMap &data)
{
return data.value(mimeSecret).toByteArray() == "1";
}
} // namespace
ClipboardMonitor::ClipboardMonitor(const QStringList &formats)
: m_clipboard(platformNativeInterface()->clipboard())
, m_formats(formats)
, m_ownerMonitor(this)
{
const AppConfig config;
m_storeClipboard = config.option<Config::check_clipboard>();
m_clipboardTab = config.option<Config::clipboard_tab>();
const int ownerUpdateInterval = config.option<Config::update_clipboard_owner_delay_ms>();
m_ownerMonitor.setUpdateInterval(std::max(ownerUpdateInterval, 0));
m_formats.append({mimeOwner, mimeWindowTitle, mimeItemNotes, mimeHidden, mimeSecret});
m_formats.removeDuplicates();
connect( m_clipboard.get(), &PlatformClipboard::changed,
this, &ClipboardMonitor::onClipboardChanged );
#ifdef HAS_MOUSE_SELECTIONS
m_storeSelection = config.option<Config::check_selection>();
m_runSelection = config.option<Config::run_selection>();
m_clipboardToSelection = config.option<Config::copy_clipboard>()
&& m_clipboard->isSelectionSupported();
m_selectionToClipboard = config.option<Config::copy_selection>();
if (!m_storeSelection && !m_runSelection && !m_selectionToClipboard) {
COPYQ_LOG("Disabling selection monitoring");
m_clipboard->setMonitoringEnabled(ClipboardMode::Selection, false);
}
#endif
}
void ClipboardMonitor::startMonitoring()
{
setClipboardOwner(currentClipboardOwner());
connect(QGuiApplication::clipboard(), &QClipboard::changed,
this, [this](){ m_ownerMonitor.update(); });
m_clipboard->startMonitoring(m_formats);
}
QString ClipboardMonitor::currentClipboardOwner()
{
QString owner;
emit fetchCurrentClipboardOwner(&owner);
return owner;
}
void ClipboardMonitor::setClipboardOwner(const QString &owner)
{
if (m_clipboardOwner != owner) {
m_clipboardOwner = owner;
m_clipboard->setClipboardOwner(m_clipboardOwner);
COPYQ_LOG(QStringLiteral("Clipboard owner: %1").arg(owner));
}
}
void ClipboardMonitor::onClipboardChanged(ClipboardMode mode)
{
m_ownerMonitor.update();
QVariantMap data = m_clipboard->data(mode, m_formats);
auto clipboardData = mode == ClipboardMode::Clipboard
? &m_clipboardData : &m_selectionData;
const bool isDataUnchanged = hasSameData(data, *clipboardData);
if (!isDataUnchanged) {
*clipboardData = data;
#ifdef HAS_MOUSE_SELECTIONS
} else if (isDataUnchanged && !m_runSelection && mode == ClipboardMode::Selection) {
return;
#endif
}
if ( !data.contains(mimeOwner)
&& !data.contains(mimeWindowTitle)
&& !m_clipboardOwner.isEmpty() )
{
data.insert(mimeWindowTitle, m_clipboardOwner.toUtf8());
}
COPYQ_LOG( QStringLiteral("%1 changed, owner is: %2")
.arg(QLatin1String(mode == ClipboardMode::Clipboard ? "Clipboard" : "Selection"),
getTextData(data, mimeOwner)) );
const auto defaultTab = m_clipboardTab.isEmpty() ? defaultClipboardTabName() : m_clipboardTab;
setTextData(&data, defaultTab, mimeCurrentTab);
#ifdef HAS_MOUSE_SELECTIONS
if (mode == ClipboardMode::Selection)
data.insert(mimeClipboardMode, QByteArrayLiteral("selection"));
if (mode == ClipboardMode::Clipboard ? m_storeClipboard : m_storeSelection) {
#else
if (m_storeClipboard) {
#endif
setTextData(&data, m_clipboardTab, mimeOutputTab);
}
if (isDataUnchanged) {
emit clipboardUnchanged(data);
return;
}
#ifdef HAS_MOUSE_SELECTIONS
if ( (mode == ClipboardMode::Clipboard ? m_clipboardToSelection : m_selectionToClipboard)
&& !data.contains(mimeOwner) )
{
const auto text = getTextData(data);
if ( !text.isEmpty() ) {
const auto targetMode = mode == ClipboardMode::Clipboard
? ClipboardMode::Selection
: ClipboardMode::Clipboard;
const QVariantMap targetData = m_clipboard->data(targetMode, {mimeText});
const uint targetTextHash = qHash( targetData.value(mimeText).toByteArray() );
const uint sourceTextHash = qHash( data.value(mimeText).toByteArray() );
emit synchronizeSelection(mode, sourceTextHash, targetTextHash);
}
}
// omit running run automatic commands when disabled
if ( !m_runSelection && mode == ClipboardMode::Selection ) {
if ( m_storeSelection && !m_clipboardTab.isEmpty() && !isClipboardDataSecret(data) )
emit saveData(data);
return;
}
#endif
// run script callbacks
if ( isClipboardDataSecret(data) ) {
emit secretClipboardChanged(data);
} else if ( isClipboardDataHidden(data) ) {
emit hiddenClipboardChanged(data);
} else if ( anySessionOwnsClipboardData(data) ) {
emit ownClipboardChanged(data);
} else {
emit clipboardChanged(data);
}
}
| 6,052
|
C++
|
.cpp
| 157
| 32.770701
| 98
| 0.687649
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,196
|
app.cpp
|
hluk_CopyQ/src/app/app.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "app.h"
#include "common/command.h"
#include "common/commandstore.h"
#include "common/log.h"
#include "common/settings.h"
#include "common/textdata.h"
#include "item/serialize.h"
#include "platform/platformnativeinterface.h"
#ifdef Q_OS_UNIX
# include "platform/unix/unixsignalhandler.h"
#endif
#include <QCoreApplication>
#include <QDir>
#include <QLibraryInfo>
#include <QLocale>
#include <QStandardPaths>
#include <QTranslator>
#include <QVariant>
#include <memory>
namespace {
#ifdef HAS_TESTS
/**
* Return true only this session was started from tests.
*/
bool isTesting()
{
return !qEnvironmentVariableIsEmpty("COPYQ_TEST_ID");
}
/**
* Change application name for tests and set "CopyQ_test_id" property of application
* to current test ID. The ID is "CORE" for core tests and ItemLoaderInterface::id() for plugins.
*
* This function does nothing if isTesting() returns false.
*/
void initTests()
{
if ( !isTesting() )
return;
const QString session = QStringLiteral("copyq.test");
QCoreApplication::setOrganizationName(session);
QCoreApplication::setApplicationName(session);
const QString testId = getTextData( qgetenv("COPYQ_TEST_ID") );
qApp->setProperty("CopyQ_test_id", testId);
}
#endif // HAS_TESTS
void installTranslator(const QString &filename, const QString &directory)
{
std::unique_ptr<QTranslator> translator( new QTranslator(qApp) );
if ( translator->load(filename, directory) )
QCoreApplication::installTranslator(translator.release());
}
void installTranslator()
{
QString locale = QString::fromUtf8( qgetenv("COPYQ_LOCALE") );
if (locale.isEmpty()) {
locale = QSettings().value(QStringLiteral("Options/language")).toString();
if (locale.isEmpty())
locale = QLocale::system().name();
qputenv("COPYQ_LOCALE", locale.toUtf8());
}
#ifdef COPYQ_TRANSLATION_PREFIX
const QString translationPrefix = COPYQ_TRANSLATION_PREFIX;
#else
const QString translationPrefix = platformNativeInterface()->translationPrefix();
#endif
QStringList translationDirectories;
translationDirectories.prepend(translationPrefix);
// 1. Qt translations
installTranslator(QLatin1String("qt_") + locale, translationPrefix);
installTranslator(QLatin1String("qt_") + locale, QLibraryInfo::location(QLibraryInfo::TranslationsPath));
// 2. installed translations
installTranslator(QLatin1String("copyq_") + locale, translationPrefix);
// 3. custom translations
const QByteArray customPath = qgetenv("COPYQ_TRANSLATION_PREFIX");
if ( !customPath.isEmpty() ) {
const QString customDir = QDir::fromNativeSeparators( getTextData(customPath) );
installTranslator(QLatin1String("copyq_") + locale, customDir);
translationDirectories.prepend(customDir);
}
// 4. compiled, non-installed translations in debug builds
#ifdef COPYQ_DEBUG
const QString compiledTranslations = QCoreApplication::applicationDirPath() + QLatin1String("/src");
installTranslator(QLatin1String("copyq_") + locale, compiledTranslations);
translationDirectories.prepend(compiledTranslations);
#endif
qApp->setProperty("CopyQ_translation_directories", translationDirectories);
#ifdef HAS_TESTS
// Keep texts and shortcuts untranslated for tests.
if ( isTesting() )
return;
#endif
QLocale::setDefault(QLocale(locale));
}
} // namespace
App::App(QCoreApplication *application,
const QString &sessionName)
: m_app(application)
, m_exitCode(0)
, m_started(false)
, m_closed(false)
{
registerDataFileConverter();
QObject::connect(m_app, &QCoreApplication::aboutToQuit, [this]() { exit(); });
#ifdef Q_OS_UNIX
startUnixSignalHandler();
#endif
QString session("copyq");
if ( !sessionName.isEmpty() )
session += "-" + sessionName;
m_app->setProperty( "CopyQ_session_name", QVariant(sessionName) );
qputenv("COPYQ_SESSION_NAME", sessionName.toUtf8());
qputenv("COPYQ", QCoreApplication::applicationFilePath().toUtf8());
const auto settingsPath = qgetenv("COPYQ_SETTINGS_PATH");
if ( !settingsPath.isEmpty() ) {
const auto path = QString::fromUtf8(settingsPath);
QSettings::setPath(QSettings::IniFormat, QSettings::UserScope, path);
// Setting the NativeFormat paths on Windows, macOS, and iOS has no effect.
QSettings::setDefaultFormat(QSettings::IniFormat);
}
QCoreApplication::setOrganizationName(session);
QCoreApplication::setApplicationName(session);
if ( qEnvironmentVariableIsEmpty("COPYQ_ITEM_DATA_PATH") ) {
if ( !m_app->property("CopyQ_item_data_path").isValid() ) {
m_app->setProperty(
"CopyQ_item_data_path",
QStandardPaths::writableLocation(QStandardPaths::AppDataLocation)
+ QLatin1String("/items"));
}
} else {
m_app->setProperty(
"CopyQ_item_data_path",
#if QT_VERSION >= QT_VERSION_CHECK(5,10,0)
qEnvironmentVariable("COPYQ_ITEM_DATA_PATH")
#else
QString::fromLocal8bit(qgetenv("COPYQ_ITEM_DATA_PATH"))
#endif
);
}
#ifdef HAS_TESTS
initTests();
#endif
initLogging();
}
App::~App()
{
QCoreApplication::processEvents();
App::exit();
delete m_app;
}
void App::installTranslator()
{
::installTranslator();
}
int App::exec()
{
if ( wasClosed() ) {
m_app->processEvents();
return m_exitCode;
}
m_started = true;
return m_app->exec();
}
void App::exit(int exitCode)
{
if ( wasClosed() )
return;
if (!m_started)
::exit(exitCode);
m_exitCode = exitCode;
m_closed = true;
QCoreApplication::exit(exitCode);
}
bool App::wasClosed() const
{
return m_closed;
}
| 5,876
|
C++
|
.cpp
| 177
| 28.717514
| 109
| 0.705196
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,197
|
clipboardserver.cpp
|
hluk_CopyQ/src/app/clipboardserver.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "clipboardserver.h"
#include "common/action.h"
#include "common/appconfig.h"
#include "common/clientsocket.h"
#include "common/client_server.h"
#include "common/commandstatus.h"
#include "common/config.h"
#include "common/display.h"
#include "common/log.h"
#include "common/mimetypes.h"
#include "common/shortcuts.h"
#include "common/sleeptimer.h"
#include "common/timer.h"
#include "common/textdata.h"
#include "gui/actionhandler.h"
#include "gui/clipboardbrowser.h"
#include "gui/commanddialog.h"
#include "gui/iconfactory.h"
#include "gui/mainwindow.h"
#include "gui/notificationbutton.h"
#include "gui/notificationdaemon.h"
#include "item/itemfactory.h"
#include "item/itemstore.h"
#include "item/serialize.h"
#include "scriptable/scriptableproxy.h"
#include <QAction>
#include <QApplication>
#include <QApplicationStateChangeEvent>
#include <QFile>
#include <QKeyEvent>
#include <QMenu>
#include <QMessageBox>
#include <QMimeData>
#include <QPushButton>
#include <QSessionManager>
#include <QStyleFactory>
#include <QTextEdit>
#ifdef COPYQ_GLOBAL_SHORTCUTS
#include "../qxt/qxtglobalshortcut.h"
#else
class QxtGlobalShortcut final {};
#endif
#include <memory>
namespace {
uint monitorCommandStateHash(const QVector<Command> &commands)
{
uint seed = 0;
QtPrivate::QHashCombine hash;
for (const auto &command : commands) {
if (command.type() == CommandType::Script)
seed = hash(seed, command.cmd);
else if (command.type() == CommandType::Automatic && !command.input.isEmpty())
seed = hash(seed, command.input);
}
return seed;
}
void setTabWidth(QTextEdit *editor, int spaces)
{
const QLatin1Char space(' ');
const QFontMetricsF metrics(editor->fontMetrics());
#if QT_VERSION >= QT_VERSION_CHECK(5,11,0)
const qreal width = metrics.horizontalAdvance(QString(spaces, space));
#else
const qreal width = metrics.width(space) * spaces;
#endif
#if QT_VERSION >= QT_VERSION_CHECK(5,10,0)
editor->setTabStopDistance(width);
#else
editor->setTabStopWidth(width);
#endif
}
} // namespace
ClipboardServer::ClipboardServer(QApplication *app, const QString &sessionName)
: QObject()
, App(app, sessionName)
, m_wnd(nullptr)
, m_shortcutActions()
, m_ignoreKeysTimer()
{
setLogLabel("Server");
m_server = new Server(clipboardServerName(), this);
if ( m_server->isListening() ) {
App::installTranslator();
qApp->setLayoutDirection(QLocale().textDirection());
} else {
App::installTranslator();
if ( canUseStandardOutput() ) {
log( tr("CopyQ server is already running."), LogWarning );
}
exit(0);
return;
}
if ( sessionName.isEmpty() ) {
QGuiApplication::setApplicationDisplayName(QStringLiteral("CopyQ"));
} else {
QGuiApplication::setApplicationDisplayName(
QStringLiteral("CopyQ-%1").arg(sessionName));
}
QGuiApplication::setDesktopFileName(QStringLiteral("com.github.hluk.copyq"));
#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps, true);
#endif
QApplication::setQuitOnLastWindowClosed(false);
ensureSettingsDirectoryExists();
m_sharedData = std::make_shared<ClipboardBrowserShared>();
m_sharedData->itemFactory = new ItemFactory(this);
m_sharedData->notifications = new NotificationDaemon(this);
m_sharedData->actions = new ActionHandler(m_sharedData->notifications, this);
m_wnd = new MainWindow(m_sharedData);
connect( m_sharedData->notifications, &NotificationDaemon::notificationButtonClicked,
this, &ClipboardServer::onNotificationButtonClicked );
m_sharedData->itemFactory->loadPlugins();
if ( !m_sharedData->itemFactory->hasLoaders() )
log("No plugins loaded", LogNote);
connect( m_server, &Server::newConnection,
this, &ClipboardServer::onClientNewConnection );
connect( qApp, &QCoreApplication::aboutToQuit,
this, &ClipboardServer::onAboutToQuit );
connect( qApp, &QGuiApplication::commitDataRequest, this, &ClipboardServer::onCommitData );
connect( qApp, &QGuiApplication::saveStateRequest, this, &ClipboardServer::onSaveState );
#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
qApp->setFallbackSessionManagementEnabled(false);
#endif
connect( m_wnd, &MainWindow::requestExit,
this, &ClipboardServer::maybeQuit );
connect( m_wnd, &MainWindow::disableClipboardStoringRequest,
this, &ClipboardServer::onDisableClipboardStoringRequest );
connect( m_wnd, &MainWindow::sendActionData,
this, &ClipboardServer::sendActionData );
// notify window if configuration changes
connect( m_wnd, &MainWindow::configurationChanged,
this, &ClipboardServer::loadSettings );
connect( m_wnd, &MainWindow::commandsSaved,
this, &ClipboardServer::onCommandsSaved );
m_server->start();
{
AppConfig appConfig;
loadSettings(&appConfig);
}
m_wnd->setCurrentTab(0);
m_wnd->enterBrowseMode();
qApp->installEventFilter(this);
// Ignore global shortcut key presses in any widget.
m_ignoreKeysTimer.setInterval(100);
m_ignoreKeysTimer.setSingleShot(true);
initSingleShotTimer(&m_timerClearUnsentActionData, 2000, this, [&]() {
m_actionDataToSend.clear();
});
initSingleShotTimer(&m_timerCleanItemFiles, 120000, this, &ClipboardServer::cleanDataFiles);
initSingleShotTimer(&m_updateThemeTimer, 1000, this, [this](){
AppConfig appConfig;
loadSettings(&appConfig);
});
setClipboardMonitorRunning(false);
startMonitoring();
callback(QStringLiteral("onStart"));
}
ClipboardServer::~ClipboardServer()
{
removeGlobalShortcuts();
delete m_wnd;
m_wnd = nullptr;
delete m_sharedData->actions;
m_sharedData->actions = nullptr;
delete m_sharedData->notifications;
m_sharedData->notifications = nullptr;
delete m_sharedData->itemFactory;
m_sharedData->itemFactory = nullptr;
}
void ClipboardServer::stopMonitoring()
{
if (!m_monitor)
return;
COPYQ_LOG("Terminating monitor");
setClipboardMonitorRunning(false);
const auto client = findClient(m_monitor->id());
if (client)
client->sendMessage(QByteArray(), CommandStop);
}
void ClipboardServer::startMonitoring()
{
if (m_monitor || m_ignoreNewConnections || !m_wnd->isMonitoringEnabled())
return;
COPYQ_LOG("Starting monitor");
m_monitor = new Action();
m_monitor->setCommand(QStringLiteral("copyq --clipboard-access monitorClipboard"));
connect( m_monitor.data(), &QObject::destroyed,
this, &ClipboardServer::onMonitorFinished );
m_sharedData->actions->internalAction(m_monitor);
}
void ClipboardServer::removeGlobalShortcuts()
{
for (auto it = m_shortcutActions.constBegin(); it != m_shortcutActions.constEnd(); ++it)
delete it.key();
m_shortcutActions.clear();
}
void ClipboardServer::onCommandsSaved(const QVector<Command> &commands)
{
#ifdef COPYQ_GLOBAL_SHORTCUTS
removeGlobalShortcuts();
QList<QKeySequence> usedShortcuts;
for (const auto &command : commands) {
if (command.type() & CommandType::GlobalShortcut) {
for (const auto &shortcutText : command.globalShortcuts) {
QKeySequence shortcut(shortcutText, QKeySequence::PortableText);
if ( !shortcut.isEmpty() && !usedShortcuts.contains(shortcut) ) {
usedShortcuts.append(shortcut);
createGlobalShortcut(shortcut, command);
}
}
}
}
#endif
const auto hash = monitorCommandStateHash(commands);
if ( m_monitor && hash != m_monitorCommandsStateHash ) {
m_monitorCommandsStateHash = hash;
stopMonitoring();
startMonitoring();
}
}
void ClipboardServer::onAboutToQuit()
{
COPYQ_LOG("Closing server.");
// Avoid calling onExit multiple times.
// (QCoreApplication::aboutToQuit() signal can be emitted multiple times
// when system is shutting down.)
if (m_exitting)
return;
m_exitting = true;
callback(QStringLiteral("onExit"));
waitForCallbackToFinish();
m_ignoreNewConnections = true;
terminateClients(10000);
m_server->close(); // No new connections can be open.
terminateClients(5000);
m_wnd->saveTabs();
cleanDataFiles();
}
void ClipboardServer::onCommitData(QSessionManager &sessionManager)
{
COPYQ_LOG("Got commit data request from session manager.");
const bool cancel = sessionManager.allowsInteraction() && !askToQuit();
sessionManager.release();
if (cancel) {
sessionManager.cancel();
startMonitoring();
} else {
m_wnd->saveTabs();
// WORKAROUND: This is required to exit application from
// installer, otherwise main window is only
// minimized after this when tray is disabled.
m_wnd->hide();
exit();
}
}
void ClipboardServer::onSaveState(QSessionManager &sessionManager)
{
COPYQ_LOG("Got save state request from session manager.");
QSettings settings(QSettings::IniFormat, QSettings::UserScope, "copyq", "copyq_no_session");
const auto sessionNameKey = "session_" + sessionManager.sessionId();
const auto sessionName = qApp->property("CopyQ_session_name").toString();
settings.setValue(sessionNameKey, sessionName);
const QString lastSessionIdPrefix = "last_session_id_for_";
const auto lastSessionIdKey = lastSessionIdPrefix + sessionName;
settings.setValue(lastSessionIdKey, sessionNameKey);
// Remove no longer valid sessions from configuration.
QSet<QString> validSessions;
for (const QString &key : settings.childKeys()) {
if ( key.startsWith(lastSessionIdPrefix) )
validSessions.insert( settings.value(key).toString() );
}
for (const QString &key : settings.childKeys()) {
if ( !key.startsWith(lastSessionIdPrefix) && !validSessions.contains(key) )
settings.remove(key);
}
}
void ClipboardServer::onDisableClipboardStoringRequest(bool disabled)
{
stopMonitoring();
if (!disabled)
startMonitoring();
}
void ClipboardServer::maybeQuit()
{
if ( askToQuit() )
exit();
}
bool ClipboardServer::askToQuit()
{
if ( !m_wnd->maybeCloseCommandDialog() )
return false;
if ( hasRunningCommands() ) {
QMessageBox messageBox( QMessageBox::Warning, tr("Cancel Active Commands"),
tr("Cancel active commands and exit?"), QMessageBox::NoButton,
m_wnd );
messageBox.addButton(tr("Cancel Exiting"), QMessageBox::RejectRole);
QAbstractButton *exitButton = messageBox.addButton(tr("Exit Anyway"), QMessageBox::AcceptRole);
// Close the message box automatically after all running commands finish.
QTimer timerCheckRunningCommands;
timerCheckRunningCommands.setInterval(1000);
connect( &timerCheckRunningCommands, &QTimer::timeout,
exitButton, [&]() {
if ( !hasRunningCommands() )
exitButton->click();
});
timerCheckRunningCommands.start();
messageBox.exec();
return exitButton == messageBox.clickedButton();
}
return true;
}
bool ClipboardServer::hasRunningCommands() const
{
if (!m_sharedData->actions)
return false;
if ( m_sharedData->actions->runningActionCount() > 0 )
return true;
for (auto it = m_clients.constBegin(); it != m_clients.constEnd(); ++it) {
const auto actionId = it.value().proxy->actionId();
if ( !m_sharedData->actions->isInternalActionId(actionId) )
return true;
}
return false;
}
void ClipboardServer::terminateClients(int waitMs)
{
for (auto it = m_clients.constBegin(); it != m_clients.constEnd(); ++it) {
const auto &clientData = it.value();
if (clientData.isValid())
clientData.client->sendMessage(QByteArray(), CommandStop);
}
waitForClientsToFinish(waitMs);
emit closeClients();
waitForClientsToFinish(waitMs / 2);
}
void ClipboardServer::waitForClientsToFinish(int waitMs)
{
SleepTimer t(waitMs);
while ( !m_clients.isEmpty() && t.sleep() ) {}
}
void ClipboardServer::waitForCallbackToFinish()
{
if (m_callback) {
COPYQ_LOG("Waiting for callback to finish");
m_callback->waitForFinished();
COPYQ_LOG("Callback finished");
}
}
void ClipboardServer::callback(const QString &scriptFunction)
{
if (!m_sharedData->actions)
return;
waitForCallbackToFinish();
COPYQ_LOG( QStringLiteral("Starting callback: %1").arg(scriptFunction) );
m_callback = new Action();
m_callback->setCommand(QStringList() << "copyq" << scriptFunction);
m_sharedData->actions->internalAction(m_callback);
}
ClientSocketPtr ClipboardServer::findClient(int actionId)
{
for (auto it = m_clients.constBegin(); it != m_clients.constEnd(); ++it) {
const auto &clientData = it.value();
if ( clientData.isValid() && clientData.proxy->actionId() == actionId )
return clientData.client;
}
return nullptr;
}
void ClipboardServer::sendActionData(int actionId, const QByteArray &bytes)
{
const auto client = findClient(actionId);
if (client) {
client->sendMessage(bytes, CommandData);
} else {
m_actionDataToSend[actionId] = bytes;
m_timerClearUnsentActionData.start();
}
}
void ClipboardServer::cleanDataFiles()
{
COPYQ_LOG("Cleaning unused item files");
::cleanDataFiles( m_wnd->tabs() );
}
void ClipboardServer::onClientNewConnection(const ClientSocketPtr &client)
{
auto proxy = new ScriptableProxy(m_wnd);
connect( client.get(), &ClientSocket::destroyed,
proxy, &ScriptableProxy::safeDeleteLater );
connect( proxy, &ScriptableProxy::sendMessage,
client.get(), &ClientSocket::sendMessage );
m_clients.insert( client->id(), ClientData(client, proxy) );
connect( this, &ClipboardServer::closeClients,
client.get(), &ClientSocket::close );
connect( client.get(), &ClientSocket::messageReceived,
this, &ClipboardServer::onClientMessageReceived );
connect( client.get(), &ClientSocket::disconnected,
this, &ClipboardServer::onClientDisconnected );
connect( client.get(), &ClientSocket::disconnected,
proxy, &ScriptableProxy::clientDisconnected );
connect( client.get(), &ClientSocket::connectionFailed,
this, &ClipboardServer::onClientConnectionFailed );
client->start();
if (m_ignoreNewConnections) {
COPYQ_LOG("Ignoring new client while exiting");
client->sendMessage(QByteArray(), CommandStop);
}
}
void ClipboardServer::onClientMessageReceived(
const QByteArray &message, int messageCode, ClientSocketId clientId)
{
switch (messageCode) {
case CommandFunctionCall: {
const auto &clientData = m_clients.value(clientId);
if (!clientData.isValid())
return;
clientData.proxy->callFunction(message);
break;
}
case CommandReceiveData: {
const auto &clientData = m_clients.value(clientId);
if (!clientData.isValid())
return;
const int actionId = clientData.proxy->actionId();
const QByteArray bytes = m_actionDataToSend.take(actionId);
clientData.client->sendMessage(bytes, CommandData);
break;
}
default:
log(QStringLiteral("Unhandled command status: %1").arg(messageCode));
break;
}
}
void ClipboardServer::onClientDisconnected(ClientSocketId clientId)
{
m_clients.remove(clientId);
}
void ClipboardServer::onClientConnectionFailed(ClientSocketId clientId)
{
log("Client connection failed", LogWarning);
m_clients.remove(clientId);
}
void ClipboardServer::onMonitorFinished()
{
COPYQ_LOG("Monitor finished");
if (!m_monitor)
setClipboardMonitorRunning(false);
stopMonitoring();
startMonitoring();
}
void ClipboardServer::onNotificationButtonClicked(const NotificationButton &button)
{
if (!m_sharedData->actions)
return;
const QString mimeNotificationData = COPYQ_MIME_PREFIX "notification-data";
QVariantMap data;
data.insert(mimeNotificationData, button.data);
auto act = new Action();
act->setCommand( button.script, QStringList(getTextData(data)) );
act->setInputWithFormat(data, mimeNotificationData);
act->setData(data);
m_sharedData->actions->action(act);
}
void ClipboardServer::createGlobalShortcut(const QKeySequence &shortcut, const Command &command)
{
#ifndef COPYQ_GLOBAL_SHORTCUTS
Q_UNUSED(shortcut)
Q_UNUSED(command)
#else
auto s = new QxtGlobalShortcut(shortcut, this);
if (!s->isValid()) {
log(QStringLiteral("Failed to set global shortcut \"%1\" for command \"%2\".")
.arg(shortcut.toString(),
command.name),
LogWarning);
delete s;
return;
}
connect( s, &QxtGlobalShortcut::activated,
this, &ClipboardServer::shortcutActivated );
m_shortcutActions[s] = command;
#endif
}
bool ClipboardServer::eventFilter(QObject *object, QEvent *ev)
{
const QEvent::Type type = ev->type();
if ( type == QEvent::KeyPress
|| type == QEvent::Shortcut
|| type == QEvent::ShortcutOverride )
{
if ( m_ignoreKeysTimer.isActive() ) {
ev->accept();
return true;
}
m_wnd->updateShortcuts();
// Close menu on Escape key and give focus back to search edit or browser.
if (type == QEvent::KeyPress) {
QKeyEvent *keyevent = static_cast<QKeyEvent *>(ev);
QMenu *menu = qobject_cast<QMenu*>(object);
if (menu && keyevent->key() == Qt::Key_Escape) {
menu->close();
if (m_wnd->browseMode())
m_wnd->enterBrowseMode();
else
m_wnd->enterSearchMode();
}
// Omit overriding arrow keys in text editors.
} else if ( type == QEvent::ShortcutOverride &&
(object->metaObject()->className() == QLatin1String("QLineEdit")
|| object->property("textInteractionFlags")
.value<Qt::TextInteractionFlags>()
.testFlag(Qt::TextSelectableByKeyboard)) )
{
QKeyEvent *keyevent = static_cast<QKeyEvent *>(ev);
if ( keyevent->key() == Qt::Key_Left
|| keyevent->key() == Qt::Key_Right
|| keyevent->key() == Qt::Key_Up
|| keyevent->key() == Qt::Key_Down)
{
ev->accept();
return true;
}
}
} else if (type == QEvent::Paint) {
setActivePaintDevice(object);
} else if (type == QEvent::FontChange) {
QTextEdit *editor = qobject_cast<QTextEdit*>(object);
if (editor)
setTabWidth(editor, m_textTabSize);
} else if ( type == QEvent::ApplicationStateChange && m_saveOnDeactivate ) {
const auto stateChangeEvent = static_cast<QApplicationStateChangeEvent*>(ev);
const auto state = stateChangeEvent->applicationState();
if (state != Qt::ApplicationActive) {
COPYQ_LOG( QStringLiteral("Saving items on application state change (%1)").arg(state) );
m_wnd->saveTabs();
m_timerCleanItemFiles.start();
}
} else if (type == QEvent::ThemeChange) {
if ( !m_updateThemeTimer.isActive() )
COPYQ_LOG("Got theme change event");
m_updateThemeTimer.start();
}
return false;
}
void ClipboardServer::loadSettings(AppConfig *appConfig)
{
if (!m_sharedData->itemFactory)
return;
COPYQ_LOG("Loading configuration");
QSettings &settings = appConfig->settings();
m_sharedData->itemFactory->loadItemFactorySettings(&settings);
const QString styleName = appConfig->option<Config::style>();
if ( !styleName.isEmpty() ) {
log( QStringLiteral("Style: %1").arg(styleName) );
QStyle *style = QStyleFactory::create(styleName);
if (style) {
QApplication::setStyle(style);
} else {
const QString styles = QStyleFactory::keys().join(QLatin1String(", "));
log( QStringLiteral("Failed to set style, valid are: %1").arg(styles), LogWarning );
}
}
settings.beginGroup(QStringLiteral("Theme"));
m_sharedData->theme.loadTheme(settings);
settings.endGroup();
m_sharedData->editor = appConfig->option<Config::editor>();
m_sharedData->maxItems = appConfig->option<Config::maxitems>();
m_sharedData->textWrap = appConfig->option<Config::text_wrap>();
m_sharedData->navigationStyle = appConfig->option<Config::navigation_style>();
m_sharedData->saveOnReturnKey = !appConfig->option<Config::edit_ctrl_return>();
m_sharedData->moveItemOnReturnKey = appConfig->option<Config::move>();
m_sharedData->showSimpleItems = appConfig->option<Config::show_simple_items>();
m_sharedData->numberSearch = appConfig->option<Config::number_search>();
m_sharedData->minutesToExpire = appConfig->option<Config::expire_tab>();
m_sharedData->saveDelayMsOnItemAdded = appConfig->option<Config::save_delay_ms_on_item_added>();
m_sharedData->saveDelayMsOnItemModified = appConfig->option<Config::save_delay_ms_on_item_modified>();
m_sharedData->saveDelayMsOnItemRemoved = appConfig->option<Config::save_delay_ms_on_item_removed>();
m_sharedData->saveDelayMsOnItemMoved = appConfig->option<Config::save_delay_ms_on_item_moved>();
m_sharedData->saveDelayMsOnItemEdited = appConfig->option<Config::save_delay_ms_on_item_edited>();
m_sharedData->rowIndexFromOne = appConfig->option<Config::row_index_from_one>();
m_sharedData->actions->setMaxRowCount(appConfig->option<Config::max_process_manager_rows>());
m_wnd->loadSettings(settings, appConfig);
m_textTabSize = appConfig->option<Config::text_tab_width>();
m_saveOnDeactivate = appConfig->option<Config::save_on_app_deactivated>();
if (m_monitor) {
stopMonitoring();
startMonitoring();
}
m_sharedData->notifications->setNativeNotificationsEnabled(
appConfig->option<Config::native_notifications>() );
m_sharedData->notifications->setNotificationOpacity(
m_sharedData->theme.color(QStringLiteral("notification_bg")).alphaF() );
m_sharedData->notifications->setNotificationStyleSheet(
m_sharedData->theme.getNotificationStyleSheet() );
int id = appConfig->option<Config::notification_position>();
NotificationDaemon::Position position;
switch (id) {
case 0: position = NotificationDaemon::Top; break;
case 1: position = NotificationDaemon::Bottom; break;
case 2: position = NotificationDaemon::TopRight; break;
case 3: position = NotificationDaemon::BottomRight; break;
case 4: position = NotificationDaemon::BottomLeft; break;
default: position = NotificationDaemon::TopLeft; break;
}
m_sharedData->notifications->setPosition(position);
const int x = appConfig->option<Config::notification_horizontal_offset>();
const int y = appConfig->option<Config::notification_vertical_offset>();
m_sharedData->notifications->setOffset(x, y);
const int w = appConfig->option<Config::notification_maximum_width>();
const int h = appConfig->option<Config::notification_maximum_height>();
m_sharedData->notifications->setMaximumSize(w, h);
m_sharedData->notifications->updateNotificationWidgets();
m_updateThemeTimer.stop();
COPYQ_LOG("Configuration loaded");
}
void ClipboardServer::shortcutActivated(QxtGlobalShortcut *shortcut)
{
#ifndef COPYQ_GLOBAL_SHORTCUTS
Q_UNUSED(shortcut)
#else
m_ignoreKeysTimer.start();
const QMap<QxtGlobalShortcut*, Command>::const_iterator it =
m_shortcutActions.constFind(shortcut);
if ( it != m_shortcutActions.constEnd() ) {
const QString shortcutText = portableShortcutText(shortcut->shortcut());
const Command &command = it.value();
// If global shortcut for a menu command is triggered when the main window
// is active, the command will be executed as if it has been trigger from
// menu - i.e. with item selection and item data available.
if ( command.inMenu && m_wnd->isActiveWindow() && m_wnd->triggerMenuCommand(command, shortcutText) ) {
COPYQ_LOG("Global shortcut command triggered as a menu command");
} else {
QVariantMap data;
data.insert(mimeShortcut, shortcutText.toUtf8());
m_wnd->action(data, command, QModelIndex());
}
}
#endif
}
| 25,158
|
C++
|
.cpp
| 638
| 33.095611
| 110
| 0.680664
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,198
|
clipboardclient.cpp
|
hluk_CopyQ/src/app/clipboardclient.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "clipboardclient.h"
#include "common/client_server.h"
#include "common/clientsocket.h"
#include "common/commandstatus.h"
#include "common/commandstore.h"
#include "common/common.h"
#include "common/log.h"
#include "common/textdata.h"
#include "item/itemfactory.h"
#include "platform/platformnativeinterface.h"
#include "scriptable/scriptable.h"
#include "scriptable/scriptableproxy.h"
#include <QApplication>
#include <QFile>
#include <QJSEngine>
#include <QThread>
#include <QTimer>
namespace {
QString messageCodeToString(int code)
{
switch (code) {
case CommandFunctionCallReturnValue:
return QStringLiteral("CommandFunctionCallReturnValue");
case CommandInputDialogFinished:
return QStringLiteral("CommandInputDialogFinished");
case CommandStop:
return QStringLiteral("CommandStop");
case CommandData:
return QStringLiteral("CommandData");
default:
return QStringLiteral("Unknown(%1)").arg(code);
}
}
QCoreApplication *createClientApplication(int &argc, char **argv, const QStringList &arguments)
{
// Clipboard access requires QApplication.
if ( arguments.size() > 1 && arguments[0] == QLatin1String("--clipboard-access") ) {
const auto app = platformNativeInterface()
->createClipboardProviderApplication(argc, argv);
setLogLabel(arguments[1].toUtf8());
return app;
}
const auto app = platformNativeInterface()->createClientApplication(argc, argv);
setLogLabel("Client");
return app;
}
} // namespace
ClipboardClient::ClipboardClient(int &argc, char **argv, const QStringList &arguments, const QString &sessionName)
: App(createClientApplication(argc, argv, arguments), sessionName)
{
App::installTranslator();
// Start script after QCoreApplication::exec().
QTimer::singleShot(0, this, [&]() { start(arguments); });
}
void ClipboardClient::onMessageReceived(const QByteArray &data, int messageCode)
{
COPYQ_LOG_VERBOSE( QLatin1String("Message received: ") + messageCodeToString(messageCode) );
switch (messageCode) {
case CommandFunctionCallReturnValue:
emit functionCallResultReceived(data);
break;
case CommandInputDialogFinished: {
emit inputDialogFinished(data);
break;
}
case CommandStop: {
exit(0);
break;
}
case CommandData:
emit dataReceived(data);
break;
default:
log( QLatin1String("Unhandled message: ") + messageCodeToString(messageCode), LogError );
break;
}
}
void ClipboardClient::onDisconnected()
{
if ( wasClosed() )
return;
log( tr("Connection lost!"), LogError );
exit(1);
}
void ClipboardClient::onConnectionFailed()
{
log( tr("Cannot connect to server! Start CopyQ server first."), LogError );
exit(1);
}
void ClipboardClient::start(const QStringList &arguments)
{
ItemFactory itemFactory;
itemFactory.loadPlugins();
QSettings settings;
itemFactory.loadItemFactorySettings(&settings);
QJSEngine engine;
ScriptableProxy scriptableProxy(nullptr, nullptr);
Scriptable scriptable(&engine, &scriptableProxy, &itemFactory);
const auto serverName = clipboardServerName();
ClientSocket socket(serverName);
connect( &socket, &ClientSocket::messageReceived,
this, &ClipboardClient::onMessageReceived );
connect( &socket, &ClientSocket::disconnected,
this, &ClipboardClient::onDisconnected );
connect( &socket, &ClientSocket::connectionFailed,
this, &ClipboardClient::onConnectionFailed );
connect( &scriptableProxy, &ScriptableProxy::sendMessage,
&socket, &ClientSocket::sendMessage );
connect( this, &ClipboardClient::functionCallResultReceived,
&scriptableProxy, &ScriptableProxy::setFunctionCallReturnValue );
connect( this, &ClipboardClient::inputDialogFinished,
&scriptableProxy, &ScriptableProxy::setInputDialogResult );
connect( &socket, &ClientSocket::disconnected,
&scriptable, &Scriptable::abort );
connect( &socket, &ClientSocket::disconnected,
&scriptableProxy, &ScriptableProxy::clientDisconnected );
connect( this, &ClipboardClient::dataReceived,
&scriptable, &Scriptable::dataReceived, Qt::QueuedConnection );
connect( &scriptable, &Scriptable::receiveData,
&socket, [&]() {
socket.sendMessage(QByteArray(), CommandReceiveData);
});
bool hasActionId;
auto actionId = qEnvironmentVariableIntValue("COPYQ_ACTION_ID", &hasActionId);
const auto actionName = getTextData( qgetenv("COPYQ_ACTION_NAME") );
if ( socket.start() ) {
if (hasActionId)
scriptable.setActionId(actionId);
scriptable.setActionName(actionName);
const int exitCode = scriptable.executeArguments(arguments);
socket.disconnect(&scriptable);
exit(exitCode);
}
}
| 5,046
|
C++
|
.cpp
| 135
| 31.681481
| 114
| 0.710656
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,199
|
applicationexceptionhandler.cpp
|
hluk_CopyQ/src/app/applicationexceptionhandler.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "applicationexceptionhandler.h"
#include "common/log.h"
#include <QCoreApplication>
#include <QFile>
#include <QMetaObject>
void logException(const char *what)
{
if ( canUseStandardOutput() ) {
QFile f;
f.open(stderr, QIODevice::WriteOnly);
f.write(what ? what : "Unknown exception");
f.write("\n");
f.close();
}
log( QString("Exception: ") + what, LogError );
}
void detail::ApplicationExceptionHandlerBase::exit(int exitCode)
{
QMetaObject::invokeMethod(this, "exitSlot", Q_ARG(int, exitCode));
}
void detail::ApplicationExceptionHandlerBase::exitSlot(int exitCode)
{
qApp->exit(exitCode);
}
| 715
|
C++
|
.cpp
| 25
| 24.92
| 70
| 0.702782
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,200
|
clipboardownermonitor.cpp
|
hluk_CopyQ/src/app/clipboardownermonitor.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "clipboardownermonitor.h"
#include "app/clipboardmonitor.h"
#include "common/log.h"
#include <QCoreApplication>
constexpr int updateAfterEventIntervalMs = 20;
ClipboardOwnerMonitor::ClipboardOwnerMonitor(ClipboardMonitor *monitor)
: m_monitor(monitor)
{
qApp->installNativeEventFilter(this);
m_timerSetOwner.setSingleShot(true);
m_timerUpdateAfterEvent.setSingleShot(true);
m_timerUpdateAfterEvent.setInterval(updateAfterEventIntervalMs);
QObject::connect(
&m_timerSetOwner, &QTimer::timeout,
[this]() {
if (!m_nextClipboardOwners.isEmpty()) {
m_monitor->setClipboardOwner(m_nextClipboardOwners.takeFirst());
if (!m_nextClipboardOwners.isEmpty())
m_timerSetOwner.start();
}
});
QObject::connect( &m_timerUpdateAfterEvent, &QTimer::timeout, [this]() {
const QString title = m_monitor->currentClipboardOwner();
if (m_lastClipboardOwner != title) {
m_lastClipboardOwner = title;
if ( m_timerSetOwner.interval() == 0 )
m_nextClipboardOwners = QStringList{m_lastClipboardOwner};
else
m_nextClipboardOwners.append(m_lastClipboardOwner);
if (!m_timerSetOwner.isActive())
m_timerSetOwner.start();
COPYQ_LOG(QStringLiteral("Next clipboard owner: %1").arg(title));
}
});
}
ClipboardOwnerMonitor::~ClipboardOwnerMonitor()
{
qApp->removeNativeEventFilter(this);
}
void ClipboardOwnerMonitor::update()
{
if ( m_timerSetOwner.interval() == 0 ) {
m_lastClipboardOwner = m_monitor->currentClipboardOwner();
m_nextClipboardOwners.clear();
m_monitor->setClipboardOwner(m_lastClipboardOwner);
} else if ( !m_timerUpdateAfterEvent.isActive() ) {
m_timerUpdateAfterEvent.start();
}
}
bool ClipboardOwnerMonitor::nativeEventFilter(const QByteArray &, void *, NativeEventResult *)
{
if ( !m_timerUpdateAfterEvent.isActive() )
m_timerUpdateAfterEvent.start();
return false;
}
| 2,149
|
C++
|
.cpp
| 56
| 31.25
| 94
| 0.677575
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,201
|
tabpropertieswidget.cpp
|
hluk_CopyQ/src/gui/tabpropertieswidget.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "gui/tabpropertieswidget.h"
#include "ui_tabpropertieswidget.h"
TabPropertiesWidget::TabPropertiesWidget(QWidget *parent) :
QWidget(parent),
ui(new Ui::TabPropertiesWidget)
{
ui->setupUi(this);
connect( ui->iconButton, &IconSelectButton::currentIconChanged,
this, &TabPropertiesWidget::iconNameChanged );
connect( ui->maxItems, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged),
this, &TabPropertiesWidget::maxItemCountChanged );
connect( ui->storeItems, &QCheckBox::toggled,
this, &TabPropertiesWidget::storeItemsChanged );
}
TabPropertiesWidget::~TabPropertiesWidget()
{
delete ui;
}
void TabPropertiesWidget::setTabName(const QString &name)
{
ui->tabName->setText(name);
}
void TabPropertiesWidget::setIconName(const QString &iconName)
{
ui->iconButton->setCurrentIcon(iconName);
}
void TabPropertiesWidget::setMaxItemCount(int maxItemCount)
{
ui->maxItems->setValue(maxItemCount);
}
void TabPropertiesWidget::setStoreItems(bool storeItems)
{
ui->storeItems->setChecked(storeItems);
}
| 1,145
|
C++
|
.cpp
| 35
| 29.114286
| 89
| 0.755898
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,202
|
actiondialog.cpp
|
hluk_CopyQ/src/gui/actiondialog.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "actiondialog.h"
#include "ui_actiondialog.h"
#include "common/appconfig.h"
#include "common/command.h"
#include "common/config.h"
#include "common/mimetypes.h"
#include "common/textdata.h"
#include "item/serialize.h"
#include <QAbstractButton>
#include <QFile>
#include <QMessageBox>
#include <QShortcut>
#include <memory>
namespace {
void initFormatComboBox(QComboBox *combo, const QStringList &additionalFormats = QStringList())
{
QStringList formats = QStringList() << QString() << QString(mimeText) << additionalFormats;
formats.removeDuplicates();
combo->clear();
combo->addItems(formats);
}
bool wasChangedByUser(QObject *object)
{
return object->property("UserChanged").toBool();
}
void setChangedByUser(QWidget *object)
{
object->setProperty("UserChanged", object->hasFocus());
}
QString commandToLabel(const QString &command)
{
QString label = command.size() > 48 ? command.left(48) + "..." : command;
label.replace('\n', " ");
label.replace(QRegularExpression("\\s\\+"), " ");
return label;
}
} // namespace
ActionDialog::ActionDialog(QWidget *parent)
: QDialog(parent)
, ui(new Ui::ActionDialog)
, m_data()
, m_currentCommandIndex(-1)
{
ui->setupUi(this);
// WORKAROUND for broken initial focus in Qt 6.6 (QTBUG-121514)
ui->comboBoxCommands->setFocus();
auto shortcut = new QShortcut(QKeySequence(Qt::ControlModifier | Qt::Key_P), this);
connect(shortcut, &QShortcut::activated, this, &ActionDialog::previousCommand);
shortcut = new QShortcut(QKeySequence(Qt::ControlModifier | Qt::Key_N), this);
connect(shortcut, &QShortcut::activated, this, &ActionDialog::nextCommand);
connect(ui->buttonBox, &QDialogButtonBox::clicked,
this, &ActionDialog::onButtonBoxClicked);
connect(ui->comboBoxCommands, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &ActionDialog::onComboBoxCommandsCurrentIndexChanged);
connect(ui->comboBoxInputFormat, &QComboBox::currentTextChanged,
this, &ActionDialog::onComboBoxInputFormatCurrentTextChanged);
connect(ui->comboBoxOutputFormat, &QComboBox::editTextChanged,
this, &ActionDialog::onComboBoxOutputFormatEditTextchanged);
connect(ui->comboBoxOutputTab, &QComboBox::editTextChanged,
this, &ActionDialog::onComboBoxOutputTabEditTextChanged);
connect(ui->separatorEdit, &QLineEdit::textEdited,
this, &ActionDialog::onSeparatorEditTextEdited);
onComboBoxInputFormatCurrentTextChanged(QString());
onComboBoxOutputFormatEditTextchanged(QString());
loadSettings();
}
ActionDialog::~ActionDialog()
{
delete ui;
}
void ActionDialog::setInputData(const QVariantMap &data)
{
m_data = data;
QString defaultFormat = ui->comboBoxInputFormat->currentText();
initFormatComboBox(ui->comboBoxInputFormat, data.keys());
const int index = qMax(0, ui->comboBoxInputFormat->findText(defaultFormat));
ui->comboBoxInputFormat->setCurrentIndex(index);
}
void ActionDialog::restoreHistory()
{
const int maxCount = AppConfig().option<Config::command_history_size>();
ui->comboBoxCommands->setMaxCount(maxCount + 1);
QFile file( dataFilename() );
file.open(QIODevice::ReadOnly);
QDataStream in(&file);
QVariant v;
ui->comboBoxCommands->clear();
ui->comboBoxCommands->addItem(QString());
while( !in.atEnd() && ui->comboBoxCommands->count() <= maxCount ) {
in >> v;
const QVariantMap values = v.value<QVariantMap>();
const QString cmd = values.value("cmd").toString();
ui->comboBoxCommands->addItem( commandToLabel(cmd), v );
}
ui->comboBoxCommands->setCurrentIndex(0);
}
const QString ActionDialog::dataFilename() const
{
return getConfigurationFilePath("_cmds.dat");
}
void ActionDialog::saveHistory()
{
QFile file( dataFilename() );
file.open(QIODevice::WriteOnly);
QDataStream out(&file);
for (int i = 1; i < ui->comboBoxCommands->count(); ++i) {
const QVariant itemData = ui->comboBoxCommands->itemData(i);
out << itemData;
}
}
void ActionDialog::setCommand(const Command &cmd)
{
ui->comboBoxCommands->setCurrentIndex(0);
ui->commandEdit->setCommand(cmd.cmd);
ui->separatorEdit->setText(cmd.sep);
int index = ui->comboBoxInputFormat->findText(cmd.input);
if (index == -1) {
ui->comboBoxInputFormat->insertItem(0, cmd.input);
index = 0;
}
ui->comboBoxInputFormat->setCurrentIndex(index);
ui->comboBoxOutputFormat->setEditText(cmd.output);
}
void ActionDialog::setOutputTabs(const QStringList &tabs)
{
QComboBox *w = ui->comboBoxOutputTab;
w->clear();
w->addItem("");
w->addItems(tabs);
}
void ActionDialog::setCurrentTab(const QString ¤tTabName)
{
ui->comboBoxOutputTab->setEditText(currentTabName);
}
void ActionDialog::loadSettings()
{
initFormatComboBox(ui->comboBoxInputFormat);
initFormatComboBox(ui->comboBoxOutputFormat);
restoreHistory();
}
Command ActionDialog::command() const
{
Command cmd;
cmd.cmd = ui->commandEdit->command();
cmd.name = commandToLabel(cmd.cmd);
cmd.input = ui->comboBoxInputFormat->currentText();
cmd.output = ui->comboBoxOutputFormat->currentText();
cmd.sep = ui->separatorEdit->text();
cmd.outputTab = ui->comboBoxOutputTab->currentText();
return cmd;
}
void ActionDialog::onButtonBoxClicked(QAbstractButton* button)
{
switch ( ui->buttonBox->standardButton(button) ) {
case QDialogButtonBox::Ok:
acceptCommand();
saveCurrentCommandToHistory();
close();
break;
case QDialogButtonBox::Apply:
acceptCommand();
saveCurrentCommandToHistory();
break;
case QDialogButtonBox::Cancel:
close();
break;
default:
break;
}
}
void ActionDialog::onComboBoxCommandsCurrentIndexChanged(int index)
{
if ( m_currentCommandIndex >= 0 && m_currentCommandIndex < ui->comboBoxCommands->count() ) {
QVariant itemData = createCurrentItemData();
if (itemData != ui->comboBoxCommands->itemData(m_currentCommandIndex))
ui->comboBoxCommands->setItemData(m_currentCommandIndex, itemData);
}
m_currentCommandIndex = index;
// Restore values from history.
QVariant v = ui->comboBoxCommands->itemData(index);
QVariantMap values = v.value<QVariantMap>();
ui->commandEdit->setCommand(values.value("cmd").toString());
// Don't automatically change values if they were edited by user.
if ( !wasChangedByUser(ui->comboBoxInputFormat) ) {
int i = ui->comboBoxInputFormat->findText(values.value("input").toString());
if (i != -1)
ui->comboBoxInputFormat->setCurrentIndex(i);
}
if ( !wasChangedByUser(ui->comboBoxOutputFormat) )
ui->comboBoxOutputFormat->setEditText(values.value("output").toString());
if ( !wasChangedByUser(ui->separatorEdit) )
ui->separatorEdit->setText(values.value("sep").toString());
const auto outputTab = values.value("outputTab").toString();
if ( !wasChangedByUser(ui->comboBoxOutputTab) && !outputTab.isEmpty() )
ui->comboBoxOutputTab->setEditText(values.value(outputTab).toString());
}
void ActionDialog::onComboBoxInputFormatCurrentTextChanged(const QString &format)
{
setChangedByUser(ui->comboBoxInputFormat);
const bool show = format.startsWith("text", Qt::CaseInsensitive);
ui->inputText->setVisible(show);
QString text;
if ((show || format.isEmpty()) && !m_data.isEmpty() )
text = getTextData( m_data, format.isEmpty() ? mimeText : format );
ui->inputText->setPlainText(text);
}
void ActionDialog::onComboBoxOutputFormatEditTextchanged(const QString &text)
{
setChangedByUser(ui->comboBoxOutputFormat);
const bool showSeparator = text.startsWith("text", Qt::CaseInsensitive);
ui->separatorLabel->setVisible(showSeparator);
ui->separatorEdit->setVisible(showSeparator);
const bool showOutputTab = !text.isEmpty();
ui->labelOutputTab->setVisible(showOutputTab);
ui->comboBoxOutputTab->setVisible(showOutputTab);
}
void ActionDialog::onComboBoxOutputTabEditTextChanged(const QString &)
{
setChangedByUser(ui->comboBoxOutputTab);
}
void ActionDialog::onSeparatorEditTextEdited(const QString &)
{
setChangedByUser(ui->separatorEdit);
}
void ActionDialog::nextCommand()
{
const int index = ui->comboBoxCommands->currentIndex();
ui->comboBoxCommands->setCurrentIndex(index - 1);
}
void ActionDialog::previousCommand()
{
const int index = ui->comboBoxCommands->currentIndex();
ui->comboBoxCommands->setCurrentIndex(index + 1);
}
void ActionDialog::acceptCommand()
{
const auto command = this->command();
auto re = command.re;
const QString text = getTextData(m_data);
const auto m = re.match(text);
auto capturedTexts = m.capturedTexts();
if ( capturedTexts.isEmpty() )
capturedTexts.append(QString());
capturedTexts[0] = text;
if ( ui->inputText->isVisible() )
m_data[mimeText] = ui->inputText->toPlainText();
emit commandAccepted(command, capturedTexts, m_data);
}
QVariant ActionDialog::createCurrentItemData()
{
QVariantMap values;
values["cmd"] = ui->commandEdit->command();
values["input"] = ui->comboBoxInputFormat->currentText();
values["output"] = ui->comboBoxOutputFormat->currentText();
values["sep"] = ui->separatorEdit->text();
values["outputTab"] = ui->comboBoxOutputTab->currentText();
return values;
}
void ActionDialog::saveCurrentCommandToHistory()
{
const QString cmd = ui->commandEdit->command();
const QVariant itemData = createCurrentItemData();
ui->comboBoxCommands->setCurrentIndex(0);
for (int i = ui->comboBoxCommands->count() - 1; i >= 1; --i) {
const QVariant itemData2 = ui->comboBoxCommands->itemData(i);
const QString cmd2 = itemData2.toMap().value("cmd").toString();
if (cmd2.isEmpty() || cmd == cmd2)
ui->comboBoxCommands->removeItem(i);
}
if ( cmd.isEmpty() ) {
ui->comboBoxCommands->setItemData(0, itemData);
} else {
ui->comboBoxCommands->insertItem(1, commandToLabel(cmd), itemData);
ui->comboBoxCommands->setCurrentIndex(1);
}
saveHistory();
}
| 10,415
|
C++
|
.cpp
| 278
| 32.834532
| 105
| 0.713761
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,203
|
notificationbasic.cpp
|
hluk_CopyQ/src/gui/notificationbasic.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "gui/notificationbasic.h"
#include "gui/notification.h"
#include "common/common.h"
#include "common/display.h"
#include "common/textdata.h"
#include "common/timer.h"
#include "gui/iconfactory.h"
#include "gui/icons.h"
#include "gui/pixelratio.h"
#include <QApplication>
#include <QDialog>
#include <QDialogButtonBox>
#include <QGridLayout>
#include <QHBoxLayout>
#include <QIcon>
#include <QLabel>
#include <QMap>
#include <QMouseEvent>
#include <QPainter>
#include <QPushButton>
#include <QTextEdit>
#include <memory>
namespace {
class NotificationButtonWidget final : public QPushButton
{
Q_OBJECT
public:
NotificationButtonWidget(const NotificationButton &button, QWidget *parent)
: QPushButton(button.name, parent)
, m_button(button)
{
connect( this, &NotificationButtonWidget::clicked,
this, &NotificationButtonWidget::onClicked );
}
signals:
void clickedButton(const NotificationButton &button);
private:
void onClicked()
{
emit clickedButton(m_button);
}
NotificationButton m_button;
};
class NotificationBasic;
class NotificationBasicWidget final : public QWidget
{
Q_OBJECT
public:
NotificationBasicWidget(NotificationBasic *parent);
void setTitle(const QString &title);
void setMessage(const QString &msg, Qt::TextFormat format = Qt::AutoText);
void setPixmap(const QPixmap &pixmap);
void setIcon(const QString &icon);
void setIcon(ushort icon);
void setInterval(int msec);
void setOpacity(qreal opacity);
void setButtons(const NotificationButtons &buttons);
void updateIcon();
void adjust();
void mousePressEvent(QMouseEvent *event) override;
#if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
void enterEvent(QEnterEvent *event) override;
#else
void enterEvent(QEvent *event) override;
#endif
void leaveEvent(QEvent *event) override;
void paintEvent(QPaintEvent *event) override;
void showEvent(QShowEvent *event) override;
void hideEvent(QHideEvent *event) override;
private:
void onTimeout();
void onButtonClicked(const NotificationButton &button);
NotificationBasic *m_parent;
QGridLayout *m_layout = nullptr;
QHBoxLayout *m_buttonLayout = nullptr;
QLabel *m_titleLabel = nullptr;
QLabel *m_iconLabel = nullptr;
QLabel *m_msgLabel = nullptr;
QTimer m_timer;
bool m_autoclose = false;
qreal m_opacity = 1.0;
QString m_icon;
};
class NotificationBasic final : public Notification
{
Q_OBJECT
friend class NotificationBasicWidget;
public:
NotificationBasic(QObject *parent)
: Notification(parent)
, m_widget(this)
{
m_widget.setObjectName("Notification");
}
void setTitle(const QString &title) override {
m_widget.setTitle(title);
}
void setMessage(const QString &msg, Qt::TextFormat format = Qt::AutoText) override {
m_widget.setMessage(msg, format);
}
void setPixmap(const QPixmap &pixmap) override {
m_widget.setPixmap(pixmap);
}
void setIcon(const QString &icon) override {
m_widget.setIcon(icon);
}
void setIcon(ushort icon) override {
m_widget.setIcon(icon);
}
void setInterval(int msec) override {
m_widget.setInterval(msec);
}
void setOpacity(qreal opacity) override {
m_widget.setOpacity(opacity);
}
void setButtons(const NotificationButtons &buttons) override {
m_widget.setButtons(buttons);
}
void adjust() override {
m_widget.updateIcon();
m_widget.adjust();
}
QWidget *widget() override {
m_widget.updateIcon();
m_widget.adjust();
return &m_widget;
}
void show() override {
m_widget.show();
}
void close() override {
m_widget.close();
}
private:
NotificationBasicWidget m_widget;
};
} // namespace
NotificationBasicWidget::NotificationBasicWidget(NotificationBasic *parent)
: m_parent(parent)
{
m_layout = new QGridLayout(this);
m_layout->setContentsMargins({8,8,8,8});
m_iconLabel = new QLabel(this);
m_iconLabel->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
m_msgLabel = new QLabel(this);
m_msgLabel->setAlignment(Qt::AlignTop | Qt::AlignAbsolute);
setTitle(QString());
setWindowFlags(Qt::ToolTip);
setWindowOpacity(m_opacity);
setAttribute(Qt::WA_ShowWithoutActivating);
initSingleShotTimer( &m_timer, 0, this, &NotificationBasicWidget::onTimeout );
}
void NotificationBasicWidget::setTitle(const QString &title)
{
if ( !title.isEmpty() ) {
if (!m_titleLabel)
m_titleLabel = new QLabel(this);
m_titleLabel->setObjectName("NotificationTitle");
m_titleLabel->setTextFormat(Qt::PlainText);
m_titleLabel->setText(title);
m_layout->addWidget(m_iconLabel, 0, 0);
m_layout->addWidget(m_titleLabel, 0, 1, Qt::AlignCenter);
m_layout->addWidget(m_msgLabel, 1, 0, 1, 2);
} else {
if (m_titleLabel) {
m_titleLabel->deleteLater();
m_titleLabel = nullptr;
}
m_layout->addWidget(m_iconLabel, 0, 0, Qt::AlignTop);
m_layout->addWidget(m_msgLabel, 0, 1);
}
}
void NotificationBasicWidget::setMessage(const QString &msg, Qt::TextFormat format)
{
m_msgLabel->setTextFormat(format);
m_msgLabel->setText(msg);
m_msgLabel->setVisible( !msg.isEmpty() );
}
void NotificationBasicWidget::setPixmap(const QPixmap &pixmap)
{
m_msgLabel->setPixmap(pixmap);
}
void NotificationBasicWidget::setIcon(const QString &icon)
{
m_icon = icon;
}
void NotificationBasicWidget::setIcon(ushort icon)
{
m_icon = QString(QChar(icon));
}
void NotificationBasicWidget::setInterval(int msec)
{
if (msec >= 0) {
m_autoclose = true;
m_timer.setInterval(msec);
if (isVisible())
m_timer.start();
} else {
m_autoclose = false;
}
}
void NotificationBasicWidget::setOpacity(qreal opacity)
{
m_opacity = opacity;
setWindowOpacity(m_opacity);
}
void NotificationBasicWidget::setButtons(const NotificationButtons &buttons)
{
for (const auto &buttonWidget : findChildren<NotificationButtonWidget*>())
buttonWidget->deleteLater();
if ( !buttons.isEmpty() ) {
if (!m_buttonLayout)
m_buttonLayout = new QHBoxLayout();
m_buttonLayout->addStretch();
m_layout->addLayout(m_buttonLayout, 2, 0, 1, 2);
for (const auto &button : buttons) {
const auto buttonWidget = new NotificationButtonWidget(button, this);
connect( buttonWidget, &NotificationButtonWidget::clickedButton,
this, &NotificationBasicWidget::onButtonClicked );
m_buttonLayout->addWidget(buttonWidget);
}
} else if (m_buttonLayout) {
m_buttonLayout->deleteLater();
m_buttonLayout = nullptr;
}
}
void NotificationBasicWidget::updateIcon()
{
const QColor color = getDefaultIconColor(*this);
const auto height = static_cast<int>( m_msgLabel->fontMetrics().lineSpacing() * 1.2 );
const auto iconId = toIconId(m_icon);
const auto ratio = pixelRatio(this);
auto pixmap = iconId == 0
? QPixmap(m_icon)
: createPixmap(iconId, color, static_cast<int>(height * ratio));
pixmap.setDevicePixelRatio(ratio);
m_iconLabel->setPixmap(pixmap);
m_iconLabel->resize(pixmap.size());
}
void NotificationBasicWidget::adjust()
{
m_msgLabel->setMaximumSize(maximumSize());
if ( !m_msgLabel->isVisible() && m_msgLabel->sizeHint().width() > maximumWidth() ) {
m_msgLabel->setWordWrap(true);
m_msgLabel->adjustSize();
}
adjustSize();
}
void NotificationBasicWidget::mousePressEvent(QMouseEvent *)
{
m_timer.stop();
emit m_parent->closeNotification(m_parent);
}
#if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
void NotificationBasicWidget::enterEvent(QEnterEvent *event)
#else
void NotificationBasicWidget::enterEvent(QEvent *event)
#endif
{
setWindowOpacity(1.0);
m_timer.stop();
QWidget::enterEvent(event);
}
void NotificationBasicWidget::leaveEvent(QEvent *event)
{
setWindowOpacity(m_opacity);
m_timer.start();
QWidget::leaveEvent(event);
}
void NotificationBasicWidget::paintEvent(QPaintEvent *event)
{
QWidget::paintEvent(event);
QPainter p(this);
// black outer border
p.setPen(Qt::black);
p.drawRect(rect().adjusted(0, 0, -1, -1));
// light inner border
p.setPen( palette().color(QPalette::Window).lighter(300) );
p.drawRect(rect().adjusted(1, 1, -2, -2));
}
void NotificationBasicWidget::showEvent(QShowEvent *event)
{
m_timer.start();
QWidget::showEvent(event);
}
void NotificationBasicWidget::hideEvent(QHideEvent *event)
{
QWidget::hideEvent(event);
emit m_parent->closeNotification(m_parent);
}
void NotificationBasicWidget::onTimeout()
{
if (m_autoclose)
emit m_parent->closeNotification(m_parent);
}
void NotificationBasicWidget::onButtonClicked(const NotificationButton &button)
{
emit m_parent->buttonClicked(button);
emit m_parent->closeNotification(m_parent);
}
Notification *createNotificationBasic(QObject *parent)
{
return new NotificationBasic(parent);
}
#include "notificationbasic.moc"
| 9,416
|
C++
|
.cpp
| 306
| 25.996732
| 90
| 0.698927
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,204
|
clipboardbrowserplaceholder.cpp
|
hluk_CopyQ/src/gui/clipboardbrowserplaceholder.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "clipboardbrowserplaceholder.h"
#include "common/common.h"
#include "common/log.h"
#include "common/timer.h"
#include "item/itemstore.h"
#include "gui/clipboardbrowser.h"
#include "gui/iconfactory.h"
#include "gui/icons.h"
#include <QPushButton>
#include <QVBoxLayout>
#include <QWidget>
#include <memory>
ClipboardBrowserPlaceholder::ClipboardBrowserPlaceholder(
const QString &tabName, const ClipboardBrowserSharedPtr &shared, QWidget *parent)
: QWidget(parent)
, m_tabName(tabName)
, m_sharedData(shared)
{
auto layout = new QVBoxLayout(this);
layout->setContentsMargins(0, 0, 0, 0);
initSingleShotTimer( &m_timerExpire, 0, this, &ClipboardBrowserPlaceholder::expire );
}
ClipboardBrowser *ClipboardBrowserPlaceholder::createBrowser()
{
if (m_browser)
return m_browser;
if (m_loadButton)
return nullptr;
std::unique_ptr<ClipboardBrowser> c( new ClipboardBrowser(m_tabName, m_sharedData, this) );
c->setStoreItems(m_storeItems);
c->setMaxItemCount(m_maxItemCount);
if ( !c->loadItems() ) {
createLoadButton();
return nullptr;
}
connect( c.get(), &ClipboardBrowser::itemSelectionChanged,
this, &ClipboardBrowserPlaceholder::restartExpiring);
connect( c.get(), &ClipboardBrowser::itemsChanged,
this, &ClipboardBrowserPlaceholder::restartExpiring);
m_browser = c.release();
emit browserCreated(m_browser);
if (!m_browser)
return nullptr;
setActiveWidget(m_browser);
restartExpiring();
emit browserLoaded(m_browser);
return m_browser;
}
bool ClipboardBrowserPlaceholder::setTabName(const QString &tabName)
{
if ( isEditorOpen() ) {
if ( !m_browser->setTabName(tabName) )
return false;
reloadBrowser();
} else {
unloadBrowser();
if ( !moveItems(m_tabName, tabName) ) {
if ( isVisible() )
createBrowser();
return false;
}
}
::removeItems(m_tabName);
m_tabName = tabName;
if ( isVisible() )
createBrowser();
return true;
}
void ClipboardBrowserPlaceholder::setMaxItemCount(int count)
{
m_maxItemCount = count;
if (m_browser)
m_browser->setMaxItemCount(count);
}
void ClipboardBrowserPlaceholder::setStoreItems(bool store)
{
m_storeItems = store;
if (m_browser)
m_browser->setStoreItems(store);
}
void ClipboardBrowserPlaceholder::removeItems()
{
unloadBrowser();
::removeItems(m_tabName);
}
bool ClipboardBrowserPlaceholder::isDataLoaded() const
{
return m_browser != nullptr;
}
ClipboardBrowser *ClipboardBrowserPlaceholder::createBrowserAgain()
{
delete m_loadButton;
m_loadButton = nullptr;
return createBrowser();
}
void ClipboardBrowserPlaceholder::reloadBrowser()
{
if ( isEditorOpen() ) {
connect( m_browser, &ClipboardBrowser::editingFinished,
this, &ClipboardBrowserPlaceholder::reloadBrowser, Qt::UniqueConnection );
} else {
unloadBrowser();
if ( isVisible() )
createBrowser();
}
}
void ClipboardBrowserPlaceholder::showEvent(QShowEvent *event)
{
QWidget::showEvent(event);
QTimer::singleShot(0, this, [this](){
if ( isVisible() )
createBrowser();
});
}
void ClipboardBrowserPlaceholder::hideEvent(QHideEvent *event)
{
restartExpiring();
QWidget::hideEvent(event);
}
bool ClipboardBrowserPlaceholder::expire()
{
if (!m_browser)
return true;
if (canExpire()) {
COPYQ_LOG( QString("Tab \"%1\": Expired").arg(m_tabName) );
unloadBrowser();
return true;
}
restartExpiring();
return false;
}
void ClipboardBrowserPlaceholder::setActiveWidget(QWidget *widget)
{
layout()->addWidget(widget);
setFocusProxy(widget);
widget->show();
if (isVisible())
widget->setFocus();
}
void ClipboardBrowserPlaceholder::createLoadButton()
{
if (m_loadButton)
return;
m_loadButton = new QPushButton(this);
m_loadButton->setObjectName("ClipboardBrowserRefreshButton");
m_loadButton->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
m_loadButton->setFlat(true);
const QIcon icon( getIcon("", IconRotateRight) );
m_loadButton->setIconSize( QSize(64, 64) );
m_loadButton->setIcon(icon);
connect( m_loadButton, &QAbstractButton::clicked,
this, &ClipboardBrowserPlaceholder::createBrowserAgain );
setActiveWidget(m_loadButton);
}
void ClipboardBrowserPlaceholder::unloadBrowser()
{
if (!m_browser)
return;
COPYQ_LOG( QString("Tab \"%1\": Unloading").arg(m_tabName) );
// WORKAROUND: This is needed on macOS, to fix refocusing correct widget later.
m_browser->clearFocus();
m_browser->hide();
m_browser->saveUnsavedItems();
m_browser->deleteLater();
m_browser = nullptr;
emit browserDestroyed();
}
bool ClipboardBrowserPlaceholder::canExpire() const
{
return m_browser
&& m_storeItems
&& !m_browser->isVisible()
&& !isEditorOpen();
}
void ClipboardBrowserPlaceholder::restartExpiring()
{
const int expireTimeoutMs = 60000 * m_sharedData->minutesToExpire;
if (expireTimeoutMs > 0)
m_timerExpire.start(expireTimeoutMs);
}
bool ClipboardBrowserPlaceholder::isEditorOpen() const
{
return m_browser && (
m_browser->isInternalEditorOpen()
|| m_browser->isExternalEditorOpen() );
}
| 5,589
|
C++
|
.cpp
| 187
| 24.764706
| 95
| 0.688329
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,205
|
clipboardbrowser.cpp
|
hluk_CopyQ/src/gui/clipboardbrowser.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "clipboardbrowser.h"
#include "common/common.h"
#include "common/contenttype.h"
#include "common/log.h"
#include "common/mimetypes.h"
#include "common/temporaryfile.h"
#include "common/textdata.h"
#include "common/timer.h"
#include "gui/pixelratio.h"
#include "gui/theme.h"
#include "item/itemeditor.h"
#include "item/itemeditorwidget.h"
#include "item/itemfactory.h"
#include "item/itemstore.h"
#include "item/itemwidget.h"
#include "item/persistentdisplayitem.h"
#include <QApplication>
#include <QDrag>
#include <QElapsedTimer>
#include <QKeyEvent>
#include <QMimeData>
#include <QProgressBar>
#include <QMenu>
#include <QMessageBox>
#include <QPainter>
#include <QScrollBar>
#include <QTemporaryFile>
#include <QUrl>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <memory>
namespace {
enum class MoveType {
Absolute,
Relative
};
/// Save drag'n'drop image data in temporary file (required by some applications).
class TemporaryDragAndDropImage final : public QObject {
public:
/// Return temporary image file for data or nullptr if file cannot be created.
static TemporaryDragAndDropImage *create(QMimeData *mimeData, QObject *parent)
{
if ( !mimeData->hasImage() || mimeData->hasFormat(mimeUriList) )
return nullptr;
return new TemporaryDragAndDropImage(mimeData, parent);
}
/// Remove temporary image file after an interval (allows target application to read all data).
void drop()
{
m_timerRemove.start();
}
~TemporaryDragAndDropImage()
{
if ( m_filePath.isEmpty() )
QFile::remove(m_filePath);
}
private:
TemporaryDragAndDropImage(QMimeData *mimeData, QObject *parent)
: QObject(parent)
{
// Save image as PNG.
const QImage image = mimeData->imageData().value<QImage>();
QTemporaryFile imageFile;
openTemporaryFile(&imageFile, ".png");
image.save(&imageFile, "PNG");
m_filePath = imageFile.fileName();
imageFile.setAutoRemove(false);
imageFile.close();
// Add URI to temporary file to drag'n'drop data.
const QUrl url = QUrl::fromLocalFile(m_filePath);
const QByteArray localUrl = url.toString().toUtf8();
mimeData->setData( mimeUriList, localUrl );
// Set interval to wait before removing temporary file after data were dropped.
const int transferRateBytesPerSecond = 100000;
const int removeAfterDropSeconds = 5 + static_cast<int>(imageFile.size()) / transferRateBytesPerSecond;
initSingleShotTimer( &m_timerRemove, removeAfterDropSeconds * 1000, this, &TemporaryDragAndDropImage::deleteLater );
}
QTimer m_timerRemove;
QString m_filePath;
};
bool alphaSort(const QModelIndex &lhs, const QModelIndex &rhs)
{
const QString lhsText = lhs.data(contentType::text).toString();
const QString rhsText = rhs.data(contentType::text).toString();
return lhsText.localeAwareCompare(rhsText) < 0;
}
bool reverseSort(const QModelIndex &lhs, const QModelIndex &rhs)
{
return lhs.row() > rhs.row();
}
QModelIndex indexNear(const QListView *view, int offset)
{
const int s = view->spacing();
QModelIndex ind = view->indexAt( QPoint(s, offset) );
if ( !ind.isValid() )
ind = view->indexAt( QPoint(s, offset + 2 * s) );
return ind;
}
void appendTextData(const QVariantMap &data, const QString &mime, QByteArray *lines)
{
const QString text = getTextData(data, mime);
if (text.isEmpty())
return;
if ( !lines->isEmpty() )
lines->append('\n');
lines->append(text.toUtf8());
}
QList<QPersistentModelIndex> toPersistentModelIndexList(const QList<QModelIndex> &indexes)
{
QList<QPersistentModelIndex> result;
result.reserve( indexes.size() );
for (const auto &index : indexes) {
if ( index.isValid() )
result.append(index);
}
return result;
}
void moveIndexes(QList<QPersistentModelIndex> &indexesToMove, int targetRow, ClipboardModel *model, MoveType moveType)
{
if ( indexesToMove.isEmpty() )
return;
const auto minMaxPair = std::minmax_element( std::begin(indexesToMove), std::end(indexesToMove) );
const auto start = minMaxPair.first->row();
const auto end = minMaxPair.second->row();
if (moveType == MoveType::Relative) {
if (targetRow < 0 && start == 0)
targetRow = model->rowCount();
else if (targetRow > 0 && end == model->rowCount() - 1)
targetRow = 0;
else if (targetRow < 0)
targetRow += start;
else
targetRow += end + 1;
}
if (start < targetRow)
std::sort( std::begin(indexesToMove), std::end(indexesToMove) );
else if (targetRow < end)
std::sort( std::begin(indexesToMove), std::end(indexesToMove),
[](const QModelIndex &lhs, const QModelIndex &rhs) {
return lhs.row() >= rhs.row();
});
else
return;
// Move ranges of rows instead of a single rows.
for (auto it = std::begin(indexesToMove); it != std::end(indexesToMove); ) {
if ( it->isValid() ) {
const auto row = it->row();
auto rowCount = 0;
for ( ++it, ++rowCount; it != std::end(indexesToMove)
&& it->isValid()
&& std::abs(it->row() - row) == rowCount; ++it, ++rowCount ) {}
if (row < targetRow)
model->moveRows(QModelIndex(), row, rowCount, QModelIndex(), targetRow);
else
model->moveRows(QModelIndex(), row - rowCount + 1, rowCount, QModelIndex(), targetRow);
} else {
++it;
}
}
}
void moveIndexes(const QModelIndexList &indexesToMove, int targetRow, ClipboardModel *model, MoveType moveType)
{
auto indexesToMove2 = toPersistentModelIndexList(indexesToMove);
moveIndexes(indexesToMove2, targetRow, model, moveType);
}
} // namespace
ClipboardBrowser::ClipboardBrowser(
const QString &tabName,
const ClipboardBrowserSharedPtr &sharedData,
QWidget *parent)
: QListView(parent)
, m_itemSaver(nullptr)
, m_tabName(tabName)
, m_maxItemCount(sharedData->maxItems)
, m(this)
, d(this, sharedData)
, m_editor(nullptr)
, m_sharedData(sharedData)
, m_dragTargetRow(-1)
, m_dragStartPosition()
{
setObjectName("ClipboardBrowser");
setLayoutMode(QListView::Batched);
setBatchSize(1);
setFrameShape(QFrame::NoFrame);
setTabKeyNavigation(false);
setSelectionMode(QAbstractItemView::ExtendedSelection);
setWrapping(false);
setLayoutMode(QListView::SinglePass);
setEditTriggers(QAbstractItemView::NoEditTriggers);
setAlternatingRowColors(true);
initSingleShotTimer( &m_timerSave, 0, this, &ClipboardBrowser::saveItems );
initSingleShotTimer( &m_timerEmitItemCount, 0, this, &ClipboardBrowser::emitItemCount );
initSingleShotTimer( &m_timerUpdateSizes, 0, this, &ClipboardBrowser::updateSizes );
initSingleShotTimer( &m_timerUpdateCurrent, 0, this, &ClipboardBrowser::updateCurrent );
initSingleShotTimer( &m_timerPreload, 0, this, &ClipboardBrowser::preloadCurrentPage );
m_timerDragDropScroll.setInterval(20);
connect( &m_timerDragDropScroll, &QTimer::timeout,
this, &ClipboardBrowser::dragDropScroll );
// ScrollPerItem doesn't work well with hidden items
setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
setAttribute(Qt::WA_MacShowFocusRect, false);
setAcceptDrops(true);
connectModelAndDelegate();
m_sharedData->theme.decorateBrowser(this);
updateItemMaximumSize();
}
ClipboardBrowser::~ClipboardBrowser()
{
delete m_editor.data();
saveUnsavedItems();
}
bool ClipboardBrowser::moveToTop(uint itemHash)
{
const int row = m.findItem(itemHash);
if (row < 0)
return false;
moveToTop( index(row) );
return true;
}
void ClipboardBrowser::closeExternalEditor(QObject *editor, const QModelIndex &index)
{
editor->disconnect(this);
disconnect(editor);
editor->deleteLater();
Q_ASSERT(m_externalEditorsOpen > 0);
--m_externalEditorsOpen;
if ( index.isValid() && !isInternalEditorOpen() ) {
selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
emit requestShow(this);
}
maybeEmitEditingFinished();
}
void ClipboardBrowser::emitItemCount()
{
if (isLoaded())
emit itemCountChanged( tabName(), length() );
}
bool ClipboardBrowser::eventFilter(QObject *obj, QEvent *event)
{
#if QT_VERSION < QT_VERSION_CHECK(5,12,0)
// WORKAROUND: Update drag'n'drop when modifiers are pressed/released (QTBUG-57168).
if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
const auto kev = static_cast<QKeyEvent*>(event);
const auto key = kev->key();
if (key == Qt::Key_Control || key == Qt::Key_Shift) {
const auto screenPos = QCursor::pos();
const auto localPos = mapFromGlobal(screenPos);
QMouseEvent mouseMove(
QEvent::MouseMove, localPos, screenPos, Qt::NoButton,
QApplication::mouseButtons(), QApplication::queryKeyboardModifiers() );
QCoreApplication::sendEvent(this, &mouseMove);
}
}
#endif
return QListView::eventFilter(obj, event);
}
bool ClipboardBrowser::isFiltered(int row) const
{
const auto filter = d.itemFilter();
if ( !filter || filter->matchesAll() || !m_itemSaver)
return false;
if ( filter->matchesNone() )
return true;
const QModelIndex ind = m.index(row);
return m_filterRow != row
&& m_sharedData->itemFactory
&& !m_sharedData->itemFactory->matches(ind, *filter);
}
bool ClipboardBrowser::hideFiltered(int row)
{
const bool hide = isFiltered(row);
setRowHidden(row, hide);
return hide;
}
bool ClipboardBrowser::startEditor(QObject *editor)
{
connect( editor, SIGNAL(fileModified(QByteArray,QString,QModelIndex)),
this, SLOT(itemModified(QByteArray,QString,QModelIndex)) );
connect( editor, SIGNAL(closed(QObject*,QModelIndex)),
this, SLOT(closeExternalEditor(QObject*,QModelIndex)) );
connect( editor, SIGNAL(error(QString)),
this, SIGNAL(error(QString)) );
connect( this, &ClipboardBrowser::closeExternalEditors,
editor, &QObject::deleteLater );
bool retVal = false;
bool result = QMetaObject::invokeMethod( editor, "start", Qt::DirectConnection,
Q_RETURN_ARG(bool, retVal) );
if (!retVal || !result) {
closeExternalEditor(editor, QModelIndex());
return false;
}
++m_externalEditorsOpen;
return true;
}
void ClipboardBrowser::setEditorWidget(ItemEditorWidget *editor, bool changeClipboard)
{
bool active = editor != nullptr;
if (m_editor != editor) {
if (m_editor) {
focusEditedIndex();
m_editor->hide();
m_editor->deleteLater();
}
m_editor = editor;
if (active) {
emit searchHideRequest();
connect( editor, &ItemEditorWidget::save,
this, &ClipboardBrowser::onEditorSave );
if (changeClipboard) {
connect( editor, &ItemEditorWidget::save,
this, &ClipboardBrowser::setClipboardFromEditor );
}
connect( editor, &ItemEditorWidget::cancel,
this, &ClipboardBrowser::onEditorCancel );
connect( editor, &ItemEditorWidget::invalidate,
this, &ClipboardBrowser::onEditorInvalidate );
connect( editor, &ItemEditorWidget::searchRequest,
this, &ClipboardBrowser::searchRequest );
updateEditorGeometry();
editor->show();
editor->setFocus();
} else {
setFocus();
maybeEmitEditingFinished();
const auto filter = d.itemFilter();
if ( !filter || filter->matchesAll() )
emit searchHideRequest();
else
emit searchShowRequest(filter->searchString());
}
emit internalEditorStateChanged(this);
}
clearFocus();
setFocusProxy(m_editor);
setFocus();
setAcceptDrops(!active);
// Hide scrollbars while editing.
const auto scrollbarPolicy = active
? Qt::ScrollBarAlwaysOff
: m_sharedData->theme.scrollbarPolicy();
setVerticalScrollBarPolicy(scrollbarPolicy);
setHorizontalScrollBarPolicy(scrollbarPolicy);
}
void ClipboardBrowser::editItem(
const QModelIndex &index, const QString &format, bool changeClipboard)
{
if (!index.isValid())
return;
ItemEditorWidget *editor = d.createCustomEditor(this, index, format);
if (editor != nullptr && editor->isValid() ) {
setEditorWidget(editor, changeClipboard);
} else {
delete editor;
openEditor(index, format);
}
}
void ClipboardBrowser::updateEditorGeometry()
{
if ( isInternalEditorOpen() ) {
const QRect contents = viewport()->contentsRect();
const QMargins margins = contentsMargins();
m_editor->parentWidget()->setGeometry( contents.translated(margins.left(), margins.top()) );
}
}
void ClipboardBrowser::updateCurrentItem()
{
const QModelIndex current = currentIndex();
if ( !current.isValid() )
return;
d.setCurrentRow( current.row(), hasFocus() );
}
QModelIndex ClipboardBrowser::indexNear(int offset) const
{
return ::indexNear(this, offset);
}
int ClipboardBrowser::getDropRow(QPoint position)
{
const QModelIndex index = indexNear( position.y() );
return index.isValid() ? index.row() : length();
}
void ClipboardBrowser::connectModelAndDelegate()
{
Q_ASSERT(&m != model());
// set new model
QAbstractItemModel *oldModel = model();
setModel(&m);
delete oldModel;
// delegate for rendering and editing items
setItemDelegate(&d);
// Delegate receives model signals first to update internal item list.
connect( &m, &QAbstractItemModel::rowsInserted,
&d, &ItemDelegate::rowsInserted );
connect( &m, &QAbstractItemModel::rowsAboutToBeRemoved,
&d, &ItemDelegate::rowsRemoved );
connect( &m, &QAbstractItemModel::rowsAboutToBeMoved,
&d, &ItemDelegate::rowsMoved );
connect( &m, &QAbstractItemModel::dataChanged,
&d, &ItemDelegate::dataChanged );
connect( &m, &QAbstractItemModel::rowsInserted,
this, &ClipboardBrowser::onRowsInserted);
// Item count change
connect( &m, &QAbstractItemModel::rowsInserted,
this, &ClipboardBrowser::onItemCountChanged );
connect( &m, &QAbstractItemModel::rowsRemoved,
this, &ClipboardBrowser::onItemCountChanged );
// Save on change
connect( &m, &QAbstractItemModel::rowsInserted,
this, [this]() { delayedSaveItems(m_sharedData->saveDelayMsOnItemAdded); } );
connect( &m, &QAbstractItemModel::rowsRemoved,
this, [this]() { delayedSaveItems(m_sharedData->saveDelayMsOnItemRemoved); } );
connect( &m, &QAbstractItemModel::rowsMoved,
this, [this]() { delayedSaveItems(m_sharedData->saveDelayMsOnItemMoved); } );
connect( &m, &QAbstractItemModel::dataChanged,
this, [this]() { delayedSaveItems(m_sharedData->saveDelayMsOnItemModified); } );
connect( &d, &ItemDelegate::itemWidgetCreated,
this, &ClipboardBrowser::itemWidgetCreated );
connect( &d, &ItemDelegate::sizeHintChanged,
this, [this](){ m_timerPreload.start(); } );
}
void ClipboardBrowser::updateItemMaximumSize()
{
const int viewWidth = viewport()->contentsRect().width();
if (viewWidth > 0)
d.setItemSizes(m_sharedData->textWrap ? viewWidth : 2048, viewWidth);
}
void ClipboardBrowser::processDragAndDropEvent(QDropEvent *event)
{
acceptDrag(event);
m_dragTargetRow = getDropRow(event->pos());
dragDropScroll();
}
void ClipboardBrowser::dropIndexes(const QModelIndexList &indexes)
{
auto toRemove = toPersistentModelIndexList(indexes);
std::sort( std::begin(toRemove), std::end(toRemove) );
dropIndexes(toRemove);
}
void ClipboardBrowser::dropIndexes(const QList<QPersistentModelIndex> &indexes)
{
const QPersistentModelIndex current = currentIndex();
const int first = indexes.value(0).row();
// Remove ranges of rows instead of a single rows.
for (auto it1 = std::begin(indexes); it1 != std::end(indexes); ) {
if ( it1->isValid() ) {
const auto firstRow = it1->row();
auto rowCount = 0;
for ( ++it1, ++rowCount; it1 != std::end(indexes)
&& it1->isValid()
&& it1->row() == firstRow + rowCount; ++it1, ++rowCount ) {}
m.removeRows(firstRow, rowCount);
} else {
++it1;
}
}
// If current item was removed, select next visible.
if ( !current.isValid() )
setCurrent( findVisibleRowFrom(first) );
}
void ClipboardBrowser::focusEditedIndex()
{
if ( !isInternalEditorOpen() )
return;
const auto index = m_editor->index();
if ( index.isValid() )
selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
}
int ClipboardBrowser::findNextVisibleRow(int row)
{
while ( row < length() && isRowHidden(row) ) { ++row; }
return row < length() ? row : -1;
}
int ClipboardBrowser::findPreviousVisibleRow(int row)
{
while ( row >= 0 && isRowHidden(row) ) { --row; }
return row >= 0 ? row : -1;
}
int ClipboardBrowser::findVisibleRowFrom(int row)
{
const int visibleRow = findNextVisibleRow(row);
if (visibleRow != -1)
return visibleRow;
return findPreviousVisibleRow(row);
}
void ClipboardBrowser::preloadCurrentPage()
{
if ( !viewport()->isVisible() )
return;
if ( m_timerUpdateSizes.isActive() )
updateSizes();
executeDelayedItemsLayout();
m_timerPreload.stop();
const QRect rect = viewport()->contentsRect();
const int top = rect.top();
const auto firstVisibleIndex = indexNear(top);
preload(rect.height(), 1, firstVisibleIndex);
}
void ClipboardBrowser::preload(int pixels, int direction, const QModelIndex &start)
{
if ( !start.isValid() )
return;
const int s = spacing();
int y = -d.sizeHint(start).height();
for ( QModelIndex ind = start;
ind.isValid() && y < pixels;
ind = index(ind.row() + direction) )
{
if ( isIndexHidden(ind) )
continue;
d.createItemWidget(ind);
y += d.sizeHint(ind).height() + 2 * s;
}
}
void ClipboardBrowser::moveToTop(const QModelIndex &index)
{
if ( !index.isValid() || !isLoaded() )
return;
if ( m_itemSaver->canMoveItems(QList<QModelIndex>() << index) )
m.moveRow(QModelIndex(), index.row(), QModelIndex(), 0);
}
void ClipboardBrowser::maybeEmitEditingFinished()
{
if ( !isInternalEditorOpen() && !isExternalEditorOpen() )
emit editingFinished();
}
QModelIndex ClipboardBrowser::firstUnpinnedIndex() const
{
if (!m_itemSaver)
return QModelIndex();
auto indexes = QModelIndexList() << QModelIndex();
for (int row = 0; row < length(); ++row) {
indexes[0] = index(row);
if ( m_itemSaver->canMoveItems(indexes) )
return indexes[0];
}
return QModelIndex();
}
void ClipboardBrowser::dragDropScroll()
{
if (m_dragTargetRow == -1) {
m_timerDragDropScroll.stop();
return;
}
if (!m_timerDragDropScroll.isActive()) {
m_timerDragDropScroll.start();
return;
}
const auto y = mapFromGlobal(QCursor::pos()).y();
const auto h = viewport()->contentsRect().height();
const auto diff = h / 4;
const auto scrollAmount =
(h < y + diff) ? (y + diff - h) / 4
: (y < diff) ? -(diff - y) / 4
: 0;
if (scrollAmount != 0) {
QScrollBar *v = verticalScrollBar();
v->setValue(v->value() + scrollAmount);
} else {
m_timerDragDropScroll.stop();
}
}
QVariantMap ClipboardBrowser::copyIndex(const QModelIndex &index) const
{
auto data = index.data(contentType::data).toMap();
return m_itemSaver ? m_itemSaver->copyItem(m, data) : data;
}
QVariantMap ClipboardBrowser::copyIndexes(const QModelIndexList &indexes) const
{
if (indexes.size() == 1)
return copyIndex( indexes.first() );
QByteArray bytes;
QByteArray text;
QByteArray uriList;
QVariantMap data;
QSet<QString> usedFormats;
{
QDataStream stream(&bytes, QIODevice::WriteOnly);
for (const auto &index : indexes) {
auto itemData = index.data(contentType::data).toMap();
itemData = m_itemSaver ? m_itemSaver->copyItem(m, itemData) : itemData;
stream << itemData;
appendTextData(itemData, mimeText, &text);
appendTextData(itemData, mimeUriList, &uriList);
for (auto it = itemData.constBegin(); it != itemData.constEnd(); ++it) {
const auto &format = it.key();
if ( usedFormats.contains(format) ) {
if ( format.startsWith(COPYQ_MIME_PREFIX) )
data[format].clear();
else
data.remove(format);
} else {
data[format] = it.value();
usedFormats.insert(format);
}
}
}
}
data.insert(mimeItems, bytes);
if ( !text.isNull() ) {
data.insert(mimeText, text);
data.remove(mimeHtml);
}
if ( !uriList.isNull() )
data.insert(mimeUriList, uriList);
return data;
}
void ClipboardBrowser::removeIndexes(const QModelIndexList &indexes, QString *error)
{
Q_ASSERT(m_itemSaver);
if ( indexes.isEmpty() ) {
if (error)
*error = "No valid rows specified";
}
if ( !canRemoveItems(indexes, error) )
return;
auto toRemove = toPersistentModelIndexList(indexes);
std::sort( std::begin(toRemove), std::end(toRemove) );
QPointer<QObject> self(this);
bool canRemove = true;
emit runOnRemoveItemsHandler(toRemove, &canRemove);
if (!canRemove) {
COPYQ_LOG("Item removal cancelled from script");
return;
}
if (!self)
return;
m_itemSaver->itemsRemovedByUser(toRemove);
dropIndexes(toRemove);
}
bool ClipboardBrowser::canRemoveItems(const QModelIndexList &indexes, QString *error)
{
Q_ASSERT(m_itemSaver);
return m_itemSaver->canRemoveItems(indexes, error);
}
QPixmap ClipboardBrowser::renderItemPreview(const QModelIndexList &indexes, int maxWidth, int maxHeight)
{
int h = 0;
const int s = spacing();
for (const auto &index : indexes) {
if ( !isIndexHidden(index) )
h += visualRect(index).height() + s;
}
if (h == 0)
return QPixmap();
const auto ratio = pixelRatio(this);
const int frameLineWidth = static_cast<int>( std::ceil(2 * ratio) );
const auto height = qMin(maxHeight, h + s + 2 * frameLineWidth);
const auto width = qMin(maxWidth, viewport()->contentsRect().width() + 2 * frameLineWidth);
const QSize size(width, height);
QPixmap pix(size * ratio);
pix.setDevicePixelRatio(ratio);
QPainter p(&pix);
h = frameLineWidth;
const QPoint pos = viewport()->pos();
for (const auto &index : indexes) {
if ( isIndexHidden(index) )
continue;
const QPoint position(frameLineWidth, h);
const auto rect = visualRect(index).translated(pos).adjusted(-s, -s, 2 * s, 2 * s);
render(&p, position, rect);
h += visualRect(index).height() + s;
if ( h > height )
break;
}
p.setBrush(Qt::NoBrush);
const auto x = frameLineWidth / 2;
const QRect rect(x / 2, x / 2, width - x, height - x);
QPen pen(Qt::black, x, Qt::SolidLine, Qt::SquareCap, Qt::MiterJoin);
p.setPen(pen);
p.drawRect(rect);
pen.setColor(Qt::white);
p.setPen(pen);
p.drawRect( rect.adjusted(x, x, -x, -x) );
return pix;
}
void ClipboardBrowser::onRowsInserted(const QModelIndex &, int first, int last)
{
QModelIndex current;
QItemSelection selection;
// Select new items only if explicitly asked for
// or select new top item when not actively using the item list.
const bool select = m_selectNewItems
|| !currentIndex().isValid()
|| (first == 0
&& !isInternalEditorOpen()
&& (currentIndex().row() == last + 1
|| !isVisible()
|| !isActiveWindow()));
// Avoid selecting multiple items if not requested.
if (!m_selectNewItems)
last = first;
for (int row = first; row <= last; ++row) {
if ( !hideFiltered(row) ) {
const auto newIndex = index(row);
if ( !current.isValid() )
current = newIndex;
if (select)
selection.select(newIndex, newIndex);
}
}
if ( !selection.isEmpty() ) {
setCurrentIndex(current);
selectionModel()->select(selection, QItemSelectionModel::ClearAndSelect);
}
}
void ClipboardBrowser::onItemCountChanged()
{
if (!m_timerEmitItemCount.isActive())
m_timerEmitItemCount.start();
}
void ClipboardBrowser::onEditorSave()
{
Q_ASSERT(!m_editor.isNull());
if ( m_editor && m_editor->hasChanges() ) {
const QVariantMap data = m_editor->data();
if ( m_sharedData->itemFactory->setData(data, m_editor->index(), &m) )
m_editor->setHasChanges(false);
}
focusEditedIndex();
delayedSaveItems(m_sharedData->saveDelayMsOnItemEdited);
}
void ClipboardBrowser::onEditorCancel()
{
if ( isInternalEditorOpen() && m_editor->hasFocus() ) {
maybeCloseEditors();
} else {
emit searchHideRequest();
}
}
void ClipboardBrowser::onEditorInvalidate()
{
setEditorWidget(nullptr);
}
void ClipboardBrowser::setClipboardFromEditor()
{
QModelIndex index = m_editor->index();
if (index.isValid())
emit changeClipboard( copyIndex(index) );
}
void ClipboardBrowser::onEditorNeedsChangeClipboard(const QByteArray &bytes, const QString &mime)
{
emit changeClipboard(createDataMap(mime, bytes));
}
void ClipboardBrowser::contextMenuEvent(QContextMenuEvent *event)
{
if ( isInternalEditorOpen() || selectedIndexes().isEmpty() )
return;
QPoint pos = event->globalPos();
emit showContextMenu(pos);
}
void ClipboardBrowser::resizeEvent(QResizeEvent *event)
{
// WORKAROUND: Omit calling resizeEvent() recursively.
if (!m_resizeEvent) {
m_resizeEvent = true;
QListView::resizeEvent(event);
m_resizeEvent = false;
}
m_timerUpdateSizes.start();
m_timerPreload.start();
}
void ClipboardBrowser::showEvent(QShowEvent *event)
{
preloadCurrentPage();
QListView::showEvent(event);
}
void ClipboardBrowser::currentChanged(const QModelIndex ¤t, const QModelIndex &previous)
{
QListView::currentChanged(current, previous);
if (previous.isValid())
d.setItemWidgetCurrent(previous, false);
m_timerUpdateCurrent.start();
}
void ClipboardBrowser::selectionChanged(const QItemSelection &selected,
const QItemSelection &deselected)
{
QListView::selectionChanged(selected, deselected);
for ( auto index : selected.indexes() )
d.setItemWidgetSelected(index, true);
for ( auto index : deselected.indexes() )
d.setItemWidgetSelected(index, false);
emit itemSelectionChanged(this);
}
void ClipboardBrowser::focusInEvent(QFocusEvent *event)
{
// Always focus active editor instead of list.
if (isInternalEditorOpen()) {
focusNextChild();
} else {
if ( !currentIndex().isValid() )
setCurrent(0);
QListView::focusInEvent(event);
updateCurrentItem();
}
if (m_itemSaver)
m_itemSaver->setFocus(true);
}
void ClipboardBrowser::focusOutEvent(QFocusEvent *event)
{
QListView::focusOutEvent(event);
if (m_itemSaver)
m_itemSaver->setFocus(false);
}
void ClipboardBrowser::dragEnterEvent(QDragEnterEvent *event)
{
dragMoveEvent(event);
#if QT_VERSION < QT_VERSION_CHECK(5,12,0)
// WORKAROUND: Update drag'n'drop when modifiers are pressed/released (QTBUG-57168).
qApp->installEventFilter(this);
#endif
}
void ClipboardBrowser::dragLeaveEvent(QDragLeaveEvent *event)
{
QListView::dragLeaveEvent(event);
m_dragTargetRow = -1;
update();
}
void ClipboardBrowser::dragMoveEvent(QDragMoveEvent *event)
{
// Ignore unknown data from Qt widgets.
const QStringList formats = event->mimeData()->formats();
if ( formats.size() == 1 && formats[0].startsWith("application/x-q") )
return;
processDragAndDropEvent(event);
update();
}
void ClipboardBrowser::dropEvent(QDropEvent *event)
{
processDragAndDropEvent(event);
if (event->dropAction() == Qt::MoveAction && event->source() == this)
return; // handled in mouseMoveEvent()
const QVariantMap data = cloneData( *event->mimeData() );
addAndSelect(data, m_dragTargetRow);
m_dragTargetRow = -1;
}
void ClipboardBrowser::paintEvent(QPaintEvent *e)
{
QListView::paintEvent(e);
// If dragging an item into list, draw indicator for dropping items.
if (m_dragTargetRow != -1) {
const int s = spacing();
QModelIndex pointedIndex = index(m_dragTargetRow);
QRect rect;
if ( pointedIndex.isValid() ) {
rect = visualRect(pointedIndex);
rect.translate(0, -s);
} else if ( length() > 0 ){
rect = visualRect( index(length() - 1) );
rect.translate(0, rect.height() + s);
} else {
rect = viewport()->rect();
rect.translate(0, s);
}
rect.adjust(8, 0, -8, 0);
QPainter p(viewport());
p.setPen( QPen(QColor(255, 255, 255, 150), s) );
p.setCompositionMode(QPainter::CompositionMode_Difference);
p.drawLine( rect.topLeft(), rect.topRight() );
}
}
void ClipboardBrowser::mousePressEvent(QMouseEvent *event)
{
if ( event->button() == Qt::LeftButton
&& (event->modifiers() & (Qt::ShiftModifier | Qt::ControlModifier)) == 0
&& indexNear( event->pos().y() ).isValid() )
{
m_dragStartPosition = event->pos();
}
QListView::mousePressEvent(event);
}
void ClipboardBrowser::mouseReleaseEvent(QMouseEvent *event)
{
m_dragStartPosition = QPoint();
QListView::mouseReleaseEvent(event);
}
void ClipboardBrowser::mouseMoveEvent(QMouseEvent *event)
{
if ( m_dragStartPosition.isNull() ) {
// WORKAROUND: After double-click, if window is hidden while mouse button is pressed,
// release button event is received after window is show which can result
// in items being selected.
if (m_ignoreMouseMoveWithButtonPressed) {
if ( QApplication::mouseButtons() & Qt::LeftButton )
return;
m_ignoreMouseMoveWithButtonPressed = false;
}
QListView::mouseMoveEvent(event);
return;
}
if ( (event->pos() - m_dragStartPosition).manhattanLength() < QApplication::startDragDistance() )
return;
QModelIndex targetIndex = indexNear( m_dragStartPosition.y() );
if ( !targetIndex.isValid() )
return;
QModelIndexList selected = selectedIndexes();
if ( !selected.contains(targetIndex) ) {
setCurrentIndex(targetIndex);
selected.clear();
selected.append(targetIndex);
}
QVariantMap data = copyIndexes(selected);
m_dragStartPosition = QPoint();
auto drag = new QDrag(this);
drag->setMimeData( createMimeData(data) );
drag->setPixmap( renderItemPreview(selected, 150, 150) );
TemporaryDragAndDropImage *temporaryImage =
TemporaryDragAndDropImage::create(drag->mimeData(), this);
// Save persistent indexes so after the items are dropped (and added) these indexes remain valid.
auto indexesToRemove = toPersistentModelIndexList(selected);
// Start dragging (doesn't block event loop).
// Default action is "copy" which works for most apps,
// "move" action is used only in item list by default.
Qt::DropAction dropAction = drag->exec(Qt::CopyAction | Qt::MoveAction, Qt::CopyAction);
#if QT_VERSION < QT_VERSION_CHECK(5,12,0)
qApp->removeEventFilter(this);
#endif
if (dropAction == Qt::MoveAction) {
selected.clear();
for (const auto &index : indexesToRemove)
selected.append(index);
QWidget *target = qobject_cast<QWidget*>(drag->target());
QPointer<QObject> self(this);
// Move items only if target is this app.
if (target == this || target == viewport()) {
moveIndexes(indexesToRemove, m_dragTargetRow, &m, MoveType::Absolute);
} else if ( target && target->window() == window()
&& m_itemSaver->canRemoveItems(selected, nullptr) )
{
removeIndexes(selected);
}
if (!self)
return;
}
// Clear drag indicator.
m_dragTargetRow = -1;
update();
event->accept();
if (temporaryImage)
temporaryImage->drop();
}
#if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
void ClipboardBrowser::enterEvent(QEnterEvent *event)
#else
void ClipboardBrowser::enterEvent(QEvent *event)
#endif
{
m_ignoreMouseMoveWithButtonPressed = true;
QListView::enterEvent(event);
}
void ClipboardBrowser::scrollContentsBy(int dx, int dy)
{
QListView::scrollContentsBy(dx, dy);
if ( !m_timerPreload.isActive() )
preloadCurrentPage();
}
void ClipboardBrowser::doItemsLayout()
{
// Keep visible current item (or the first one visible)
// on the same position visually after relayout.
// FIXME: Virtual method QListView::doItemsLayout() is undocumented
// so other way should be used instead.
m_timerPreload.start();
const auto current = currentIndex();
const auto currentRect = visualRect(current);
const auto viewRect = viewport()->contentsRect();
const bool currentIsNotVisible =
viewRect.bottom() < currentRect.top()
|| currentRect.bottom() < viewRect.top();
const auto index = currentIsNotVisible ? indexNear(0) : current;
const auto rectBefore = visualRect(index);
QListView::doItemsLayout();
const auto rectAfter = visualRect(index);
const auto offset = rectAfter.top() - rectBefore.top();
if (offset != 0) {
QScrollBar *v = verticalScrollBar();
v->setValue(v->value() + offset);
d.updateAllRows();
}
}
bool ClipboardBrowser::openEditor()
{
const QModelIndexList selected = selectionModel()->selectedRows();
return (selected.size() == 1) ? openEditor( selected.first(), mimeText )
: openEditor( {}, mimeText, selectedText().toUtf8() );
}
bool ClipboardBrowser::openEditor(
const QModelIndex &index, const QString &format, const QByteArray &content, bool changeClipboard)
{
if ( !isLoaded() )
return false;
if ( m_sharedData->editor.isEmpty() )
return false;
auto editor = new ItemEditor(content, format, m_sharedData->editor, this);
editor->setIndex(index);
if ( !startEditor(editor) )
return false;
if (changeClipboard) {
connect( editor, SIGNAL(fileModified(QByteArray,QString,QModelIndex)),
this, SLOT(onEditorNeedsChangeClipboard(QByteArray,QString)) );
}
return true;
}
bool ClipboardBrowser::openEditor(const QModelIndex &index, const QString &format)
{
if ( !isLoaded() )
return false;
const auto data = m_sharedData->itemFactory->data(index);
if ( data.isEmpty() )
return false;
QObject *editor = m_sharedData->itemFactory->createExternalEditor(index, data, this);
if ( editor != nullptr && startEditor(editor) )
return true;
if ( !m_sharedData->editor.trimmed().isEmpty() ) {
const QString text = getTextData(data);
if ( !text.isNull() ) {
auto itemEditor = new ItemEditor( text.toUtf8(), format, m_sharedData->editor, this );
itemEditor->setIndex(index);
if ( startEditor(itemEditor) )
return true;
}
}
return false;
}
void ClipboardBrowser::editNotes()
{
QModelIndex ind = currentIndex();
if ( !ind.isValid() )
return;
scrollTo(ind, PositionAtTop);
emit requestShow(this);
editItem(ind, mimeItemNotes);
}
void ClipboardBrowser::itemModified(const QByteArray &bytes, const QString &mime, const QModelIndex &index)
{
// add new item
if ( !bytes.isEmpty() ) {
const QVariantMap dataMap = createDataMap(mime, bytes);
if (index.isValid())
m_sharedData->itemFactory->setData(dataMap, index, &m);
else
add(dataMap);
}
}
void ClipboardBrowser::filterItems(const ItemFilterPtr &filter)
{
// Search in editor if open.
if ( isInternalEditorOpen() ) {
m_editor->search(filter);
return;
}
// Do nothing if same regexp was already set.
// FIXME: Compare other options.
const auto oldFilter = d.itemFilter();
const auto oldSearch = oldFilter ? oldFilter->searchString() : QString();
const auto newSearch = filter ? filter->searchString() : QString();
if (oldSearch == newSearch)
return;
d.setItemFilter(filter);
// If search string is a number, highlight item in that row.
bool filterByRowNumber = !m_sharedData->numberSearch;
if (filterByRowNumber) {
m_filterRow = newSearch.toInt(&filterByRowNumber);
if (m_filterRow > 0 && m_sharedData->rowIndexFromOne)
--m_filterRow;
}
if (!filterByRowNumber)
m_filterRow = -1;
int row = 0;
if ( !filter || filter->matchesAll() ) {
for ( ; row < length(); ++row )
hideFiltered(row);
scrollTo(currentIndex(), PositionAtCenter);
} else {
for ( ; row < length() && hideFiltered(row); ++row ) {}
setCurrent(row);
for ( ; row < length(); ++row )
hideFiltered(row);
if ( filterByRowNumber && m_filterRow >= 0 && m_filterRow < m.rowCount() )
setCurrent(m_filterRow);
}
d.updateAllRows();
}
void ClipboardBrowser::moveToClipboard(const QModelIndex &ind)
{
if ( ind.isValid() )
moveToClipboard(QModelIndexList() << ind);
}
void ClipboardBrowser::moveToClipboard(const QModelIndexList &indexes)
{
const auto data = copyIndexes(indexes);
if ( m_sharedData->moveItemOnReturnKey
&& m_itemSaver && m_itemSaver->canMoveItems(indexes) )
{
moveIndexes(indexes, 0, &m, MoveType::Absolute);
scrollTo( currentIndex() );
}
emit changeClipboard(data);
}
void ClipboardBrowser::editNew(const QString &format, const QByteArray &content, bool changeClipboard)
{
if ( !isLoaded() )
return;
emit searchHideRequest();
filterItems(nullptr);
m_selectNewItems = true;
const bool added = add( createDataMap(format, content) );
m_selectNewItems = false;
if (added)
editItem(currentIndex(), format, changeClipboard);
}
void ClipboardBrowser::keyPressEvent(QKeyEvent *event)
{
// ignore any input if editing an item
if ( isInternalEditorOpen() )
return;
// translate keys for vi mode
if (m_sharedData->navigationStyle == NavigationStyle::Vi && handleViKey(event, this)) {
d.updateIfNeeded();
return;
}
// translate keys for emacs mode
if (m_sharedData->navigationStyle == NavigationStyle::Emacs && handleEmacsKey(event, this))
return;
const Qt::KeyboardModifiers mods = event->modifiers();
if (mods == Qt::AltModifier)
return; // Handled by filter completion popup.
const int key = event->key();
// WORKAROUND: Avoid triggering search with Ctrl+Space toggle selection action.
if (mods.testFlag(Qt::ControlModifier) && key == Qt::Key_Space) {
const QModelIndex current = currentIndex();
if (!edit(current, AnyKeyPressed, event)) {
selectionModel()->select(current, selectionCommand(current, event));
event->accept();
return;
}
}
// This fixes few issues with default navigation and item selections.
switch (key) {
case Qt::Key_Up:
case Qt::Key_Down:
case Qt::Key_Home:
case Qt::Key_End:
case Qt::Key_PageDown:
case Qt::Key_PageUp: {
event->accept();
const QModelIndex current = currentIndex();
const int h = viewport()->contentsRect().height();
const int s = spacing();
const int space = 2 * s + 1;
const int direction =
(key == Qt::Key_Down || key == Qt::Key_PageDown || key == Qt::Key_End) ? 1 : -1;
int row = current.row();
if (key == Qt::Key_PageDown || key == Qt::Key_PageUp) {
const int offset = verticalOffset();
const QRect currentRect = rectForIndex(current);
if (currentRect.bottom() < offset || currentRect.top() > offset + h
|| (key == Qt::Key_PageDown
? currentRect.bottom() > offset + h
: currentRect.top() < offset))
{
QScrollBar *v = verticalScrollBar();
v->setValue( v->value() + direction * v->pageStep() );
break;
}
QModelIndex ind = indexNear(s + 1);
row = ind.row();
int y;
if (key == Qt::Key_PageDown)
y = rectForIndex(ind).top() - offset - h;
else
y = offset - rectForIndex(ind).top() + s - h;
for ( ; ind.isValid(); row += direction, ind = index(row) ) {
if ( isIndexHidden(ind) )
continue;
d.createItemWidget(ind);
y += d.sizeHint(ind).height() + 2 * s;
if (y > space)
break;
}
if (row == current.row())
row += direction;
else if (row != current.row() + direction)
row -= direction;
} else if (key == Qt::Key_Up || key == Qt::Key_Down) {
preload(space, direction, current);
row += direction;
} else {
row = (key == Qt::Key_Home) ? 0 : model()->rowCount() - 1;
preload(h, -direction, index(row));
for ( ; row != current.row() && hideFiltered(row); row -= direction ) {}
}
executeDelayedItemsLayout();
const QItemSelectionModel::SelectionFlags flags = selectionCommand(index(row), event);
const bool setCurrentOnly = flags.testFlag(QItemSelectionModel::NoUpdate);
const bool keepSelection = setCurrentOnly || flags.testFlag(QItemSelectionModel::SelectCurrent);
setCurrent(row, keepSelection, setCurrentOnly);
if (key == Qt::Key_PageDown || key == Qt::Key_PageUp)
scrollTo(index(row), PositionAtTop);
break;
}
default:
// allow user defined shortcuts
QListView::keyPressEvent(event);
// search
event->ignore();
break;
}
d.updateIfNeeded();
}
void ClipboardBrowser::setCurrent(int row, bool keepSelection, bool setCurrentOnly)
{
if ( m.rowCount() == 0 )
return;
QModelIndex prev = currentIndex();
int cur = prev.row();
const int direction = cur <= row ? 1 : -1;
// select first visible
int toSelect = std::clamp(row, 0, m.rowCount() - 1);
toSelect = direction == 1
? findNextVisibleRow(toSelect)
: findPreviousVisibleRow(toSelect);
if (toSelect == -1)
return;
if (keepSelection) {
auto sel = selectionModel();
const bool currentSelected = sel->isSelected(prev);
for ( int j = prev.row(); j != toSelect + direction; j += direction ) {
const auto ind = index(j);
if ( !ind.isValid() )
break;
if ( isRowHidden(j) )
continue;
if (!setCurrentOnly) {
if ( currentIndex() != ind && sel->isSelected(ind) && sel->isSelected(prev) )
sel->setCurrentIndex(currentIndex(), QItemSelectionModel::Deselect);
sel->setCurrentIndex(ind, QItemSelectionModel::Select);
}
prev = ind;
}
if (setCurrentOnly)
sel->setCurrentIndex(prev, QItemSelectionModel::NoUpdate);
else if (!currentSelected)
sel->setCurrentIndex(prev, QItemSelectionModel::Deselect);
} else {
setCurrentIndex( index(toSelect) );
}
}
void ClipboardBrowser::editSelected()
{
if ( selectedIndexes().size() > 1 ) {
editNew( mimeText, selectedText().toUtf8() );
} else {
QModelIndex ind = currentIndex();
if ( ind.isValid() ) {
emit requestShow(this);
editItem(ind, mimeText);
}
}
}
void ClipboardBrowser::remove()
{
const QModelIndexList toRemove = selectedIndexes();
removeIndexes(toRemove);
}
void ClipboardBrowser::sortItems(const QModelIndexList &indexes)
{
m.sortItems(indexes, &alphaSort);
}
void ClipboardBrowser::sortItems(const QList<QPersistentModelIndex> &sorted)
{
m.sortItems(sorted);
}
void ClipboardBrowser::reverseItems(const QModelIndexList &indexes)
{
m.sortItems(indexes, &reverseSort);
}
bool ClipboardBrowser::allocateSpaceForNewItems(int newItemCount)
{
const auto targetRowCount = m_maxItemCount - newItemCount;
const auto toRemove = m.rowCount() - targetRowCount;
if (toRemove <= 0)
return true;
QModelIndexList indexesToRemove;
for (int row = m.rowCount() - 1; row >= 0 && indexesToRemove.size() < toRemove; --row) {
const auto index = m.index(row);
if ( m_itemSaver->canDropItem(index) )
indexesToRemove.append(index);
}
if (indexesToRemove.size() < toRemove) {
log( QString("Cannot add new items. Tab \"%1\" reached the maximum number of items.")
.arg(m_tabName), LogWarning );
emit error(
tr("Cannot add new items to tab %1. Please remove items manually to make space.")
.arg(quoteString(m_tabName)) );
return false;
}
dropIndexes(indexesToRemove);
return true;
}
bool ClipboardBrowser::add(const QString &txt, int row)
{
return add( createDataMap(mimeText, txt), row );
}
bool ClipboardBrowser::add(const QVariantMap &data, int row)
{
if ( !isLoaded() )
return false;
const int newRow = row < 0 ? m.rowCount() : qMin(row, m.rowCount());
if ( data.contains(mimeItems) ) {
const QByteArray bytes = data[mimeItems].toByteArray();
QDataStream stream(bytes);
QVector<QVariantMap> dataList;
while ( !stream.atEnd() ) {
QVariantMap dataMap;
stream >> dataMap;
dataList.append(dataMap);
}
if ( !allocateSpaceForNewItems(dataList.size()) )
return false;
m.insertItems(dataList, newRow);
} else {
if ( !allocateSpaceForNewItems(1) )
return false;
m.insertItem(data, newRow);
}
return true;
}
bool ClipboardBrowser::addReversed(const QVector<QVariantMap> &dataList, int row)
{
if ( !isLoaded() )
return false;
const int newRow = row < 0 ? m.rowCount() : qMin(row, m.rowCount());
QVector<QVariantMap> items;
items.reserve(dataList.size());
for (auto it = std::rbegin(dataList); it != std::rend(dataList); ++it) {
if ( it->contains(mimeItems) ) {
const QByteArray bytes = (*it)[mimeItems].toByteArray();
QDataStream stream(bytes);
while ( !stream.atEnd() ) {
QVariantMap dataMap;
stream >> dataMap;
items.append(dataMap);
}
} else {
items.append(*it);
}
}
if ( !allocateSpaceForNewItems(items.size()) )
return false;
m.insertItems(items, newRow);
return true;
}
bool ClipboardBrowser::addAndSelect(const QVariantMap &data, int row)
{
m_selectNewItems = true;
bool added = add(data, row);
m_selectNewItems = false;
return added;
}
void ClipboardBrowser::addUnique(const QVariantMap &data, ClipboardMode mode)
{
if ( moveToTop(hash(data)) ) {
COPYQ_LOG("New item: Moving existing to top");
return;
}
// When selecting text under X11, clipboard data may change whenever selection changes.
// Instead of adding item for each selection change, this updates previously added item.
// Also update previous item if the same selected text is copied to clipboard afterwards.
if ( data.contains(mimeText) ) {
const auto firstIndex = firstUnpinnedIndex();
const QVariantMap previousData = firstIndex.data(contentType::data).toMap();
if ( firstIndex.isValid()
&& previousData.contains(mimeText)
// Don't update edited item.
&& (!isInternalEditorOpen() || currentIndex() != firstIndex) )
{
const auto newText = getTextData(data);
const auto oldText = getTextData(previousData);
if ( (mode == ClipboardMode::Clipboard)
? (newText == oldText)
: (newText.startsWith(oldText) || newText.endsWith(oldText)) )
{
COPYQ_LOG("New item: Merging with top item");
auto newData = previousData;
for (auto it = data.constBegin(); it != data.constEnd(); ++it)
newData.insert(it.key(), it.value());
m.setData(firstIndex, newData, contentType::data);
return;
}
}
}
COPYQ_LOG("New item: Adding");
add(data);
}
void ClipboardBrowser::setItemsData(const QMap<QPersistentModelIndex, QVariantMap> &itemsData)
{
if ( isLoaded() )
m.setItemsData(itemsData);
}
bool ClipboardBrowser::loadItems()
{
if ( isLoaded() )
return true;
m_timerSave.stop();
m.blockSignals(true);
m_itemSaver = ::loadItems(m_tabName, m, m_sharedData->itemFactory, m_maxItemCount);
m.blockSignals(false);
if ( !isLoaded() )
return false;
d.rowsInserted(QModelIndex(), 0, m.rowCount());
if ( hasFocus() )
setCurrent(0);
onItemCountChanged();
return true;
}
bool ClipboardBrowser::saveItems()
{
m_timerSave.stop();
if ( !isLoaded() || m_tabName.isEmpty() )
return false;
if (!m_storeItems)
return true;
return ::saveItems(m_tabName, m, m_itemSaver);
}
void ClipboardBrowser::moveToClipboard()
{
moveToClipboard( selectionModel()->selectedIndexes() );
}
void ClipboardBrowser::delayedSaveItems(int ms)
{
if ( !isLoaded() || tabName().isEmpty() || ms < 0 )
return;
if ( !m_timerSave.isActive() || ms < m_timerSave.remainingTime() )
m_timerSave.start(ms);
emit itemsChanged(this);
}
void ClipboardBrowser::updateSizes()
{
if (m_resizing) {
m_timerUpdateSizes.start();
return;
}
m_timerUpdateSizes.stop();
m_resizing = true;
updateItemMaximumSize();
updateEditorGeometry();
m_resizing = false;
}
void ClipboardBrowser::updateCurrent()
{
if ( !updatesEnabled() ) {
m_timerUpdateCurrent.start();
return;
}
const auto current = currentIndex();
if ( current.isValid() )
d.setItemWidgetCurrent(current, true);
}
void ClipboardBrowser::saveUnsavedItems()
{
if ( m_timerSave.isActive() )
saveItems();
}
const QString ClipboardBrowser::selectedText() const
{
QString result;
for ( const auto &ind : selectionModel()->selectedIndexes() )
result += ind.data(Qt::EditRole).toString() + QString('\n');
result.chop(1);
return result;
}
bool ClipboardBrowser::setTabName(const QString &tabName)
{
const QString oldTabName = m_tabName;
m_tabName = tabName;
if ( saveItems() )
return true;
m_tabName = oldTabName;
return false;
}
void ClipboardBrowser::setMaxItemCount(int count)
{
m_maxItemCount = count;
}
void ClipboardBrowser::setStoreItems(bool store)
{
m_storeItems = store;
if (!m_storeItems)
::removeItems(m_tabName);
}
void ClipboardBrowser::editRow(int row, const QString &format)
{
editItem( index(row), format );
}
void ClipboardBrowser::move(int key)
{
if (key == Qt::Key_Home)
moveIndexes( selectedIndexes(), 0, &m, MoveType::Absolute );
else if (key == Qt::Key_End)
moveIndexes( selectedIndexes(), m.rowCount(), &m, MoveType::Absolute );
else if (key == Qt::Key_Down)
moveIndexes( selectedIndexes(), 1, &m, MoveType::Relative );
else if (key == Qt::Key_Up)
moveIndexes( selectedIndexes(), -1, &m, MoveType::Relative );
scrollTo( currentIndex() );
}
void ClipboardBrowser::move(const QModelIndexList &indexes, int targetRow)
{
moveIndexes( indexes, targetRow, &m, MoveType::Absolute );
}
QWidget *ClipboardBrowser::currentItemPreview(QWidget *parent)
{
if (!isLoaded())
return nullptr;
const QModelIndex index = currentIndex();
const auto data = index.data(contentType::data).toMap();
return d.createPreview(data, parent);
}
void ClipboardBrowser::findNext()
{
if (isInternalEditorOpen())
m_editor->findNext();
}
void ClipboardBrowser::findPrevious()
{
if (isInternalEditorOpen())
m_editor->findPrevious();
}
bool ClipboardBrowser::isInternalEditorOpen() const
{
return !m_editor.isNull();
}
bool ClipboardBrowser::isExternalEditorOpen() const
{
return m_externalEditorsOpen > 0;
}
bool ClipboardBrowser::isLoaded() const
{
return !m_sharedData->itemFactory || m_itemSaver || tabName().isEmpty();
}
bool ClipboardBrowser::maybeCloseEditors()
{
if ( (isInternalEditorOpen() && m_editor->hasChanges())
|| isExternalEditorOpen() )
{
const int answer = QMessageBox::question( this,
tr("Discard Changes?"),
tr("Do you really want to <strong>discard changes</strong>?"),
QMessageBox::No | QMessageBox::Yes,
QMessageBox::No );
if (answer == QMessageBox::No)
return false;
}
setEditorWidget(nullptr);
emit closeExternalEditors();
return true;
}
void ClipboardBrowser::keyboardSearch(const QString &text)
{
emit searchShowRequest(text);
}
| 55,328
|
C++
|
.cpp
| 1,564
| 28.737212
| 124
| 0.642903
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,206
|
traymenu.cpp
|
hluk_CopyQ/src/gui/traymenu.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "traymenu.h"
#include "common/contenttype.h"
#include "common/common.h"
#include "common/display.h"
#include "common/mimetypes.h"
#include "common/textdata.h"
#include "common/timer.h"
#include "gui/icons.h"
#include "gui/iconfactory.h"
#include <QAction>
#include <QApplication>
#include <QKeyEvent>
#include <QModelIndex>
#include <QPixmap>
#include <QRegularExpression>
namespace {
const char propertyTextFormat[] = "CopyQ_text_format";
const QIcon iconClipboard() { return getIcon("clipboard", IconPaste); }
bool canActivate(const QAction &action)
{
return !action.isSeparator() && action.isEnabled();
}
QAction *firstEnabledAction(QMenu *menu)
{
// First action is active when menu pops up.
for (auto action : menu->actions()) {
if ( canActivate(*action) )
return action;
}
return nullptr;
}
QAction *lastEnabledAction(QMenu *menu)
{
// First action is active when menu pops up.
QList<QAction *> actions = menu->actions();
for (int i = actions.size() - 1; i >= 0; --i) {
if ( canActivate(*actions[i]) )
return actions[i];
}
return nullptr;
}
} // namespace
TrayMenu::TrayMenu(QWidget *parent)
: QMenu(parent)
, m_clipboardItemActionCount(0)
, m_omitPaste(false)
, m_numberSearch(false)
{
m_clipboardItemActionsSeparator = addSeparator();
m_customActionsSeparator = addSeparator();
initSingleShotTimer( &m_timerUpdateActiveAction, 0, this, &TrayMenu::doUpdateActiveAction );
setAttribute(Qt::WA_InputMethodEnabled);
}
void TrayMenu::updateTextFromData(QAction *act, const QVariantMap &data)
{
const QString format = act->property(propertyTextFormat).toString();
const QString label = textLabelForData( data, act->font(), format, true );
act->setText(label);
}
bool TrayMenu::updateIconFromData(QAction *act, const QVariantMap &data)
{
if ( !act->parentWidget() )
return false;
const QString icon = data.value(mimeIcon).toString();
const QString tag = data.value(COPYQ_MIME_PREFIX "item-tag").toString();
if ( icon.isEmpty() && tag.isEmpty() ) {
const QString colorName = data.value(mimeColor).toString();
if ( colorName.isEmpty() )
return false;
const QColor color(colorName);
if ( !color.isValid() )
return false;
QPixmap pix(16, 16);
pix.fill(color);
act->setIcon(pix);
return true;
}
const QColor color = getDefaultIconColor(*act->parentWidget());
act->setIcon( iconFromFile(icon, tag, color) );
return true;
}
QAction *TrayMenu::addClipboardItemAction(const QVariantMap &data, bool showImages)
{
// Show search text at top of the menu.
if ( m_clipboardItemActionCount == 0 && m_searchText.isEmpty() ) {
if (m_navigationStyle == NavigationStyle::Vi) {
setSearchMenuItem( tr("Press '/' to search") );
} else {
setSearchMenuItem( tr("Type to search") );
}
}
QAction *act = addAction(QString());
m_clipboardActions.append(act);
act->setData(data);
insertAction(m_clipboardItemActionsSeparator, act);
QString format;
// Add number key hint.
const int rowNumber = m_clipboardItemActionCount + static_cast<int>(m_rowIndexFromOne);
if (rowNumber < 10) {
format = tr("&%1. %2",
"Key hint (number shortcut) for items in tray menu (%1 is number, %2 is item label)")
.arg(rowNumber);
act->setProperty(propertyTextFormat, format);
}
m_clipboardItemActionCount++;
updateTextFromData(act, data);
// Menu item icon from image.
if (!updateIconFromData(act, data) && showImages) {
const QStringList formats = data.keys();
static const QRegularExpression reImage("^image/.*");
const int imageIndex = formats.indexOf(reImage);
if (imageIndex != -1) {
const auto &mime = formats[imageIndex];
QPixmap pix;
pix.loadFromData( data.value(mime).toByteArray(), mime.toLatin1().data() );
const int iconSize = smallIconSize();
int x = 0;
int y = 0;
if (pix.width() > pix.height()) {
pix = pix.scaledToHeight(iconSize);
x = (pix.width() - iconSize) / 2;
} else {
pix = pix.scaledToWidth(iconSize);
y = (pix.height() - iconSize) / 2;
}
pix = pix.copy(x, y, iconSize, iconSize);
act->setIcon(pix);
}
}
connect(act, &QAction::triggered, this, &TrayMenu::onClipboardItemActionTriggered);
return act;
}
void TrayMenu::clearClipboardItems()
{
const auto actions = m_clipboardActions;
m_clipboardActions = {};
for (QAction *action : actions) {
removeAction(action);
action->setVisible(false);
action->setDisabled(true);
action->setShortcuts({});
action->deleteLater();
}
m_clipboardItemActionCount = 0;
// Show search text at top of the menu.
if ( !m_searchText.isEmpty() )
setSearchMenuItem(m_searchText);
}
void TrayMenu::clearCustomActions()
{
const auto actions = m_customActions;
m_customActions = {};
for (QAction *action : actions) {
removeAction(action);
action->setVisible(false);
action->setDisabled(true);
action->setShortcuts({});
action->deleteLater();
}
}
void TrayMenu::setCustomActions(QList<QAction*> actions)
{
clearCustomActions();
m_customActions = actions;
insertActions(m_customActionsSeparator, actions);
}
void TrayMenu::clearAllActions()
{
m_clipboardActions = {};
m_customActions = {};
clear();
m_clipboardItemActionCount = 0;
m_searchText.clear();
}
void TrayMenu::setNavigationStyle(NavigationStyle style)
{
m_navigationStyle = style;
}
void TrayMenu::setNumberSearchEnabled(bool enabled)
{
m_numberSearch = enabled;
}
void TrayMenu::keyPressEvent(QKeyEvent *event)
{
const int key = event->key();
m_omitPaste = false;
bool not_searching = m_searchText.isEmpty();
if ( not_searching && m_navigationStyle == NavigationStyle::Vi && handleViKey(event, this) ) {
return;
} else if ( not_searching && m_navigationStyle == NavigationStyle::Emacs && handleEmacsKey(event, this) ) {
return;
} else {
// Movement in tray menu.
switch (key) {
case Qt::Key_PageDown:
case Qt::Key_End: {
QAction *action = lastEnabledAction(this);
if (action != nullptr)
setActiveAction(action);
break;
}
case Qt::Key_PageUp:
case Qt::Key_Home: {
QAction *action = firstEnabledAction(this);
if (action != nullptr)
setActiveAction(action);
break;
}
case Qt::Key_Escape:
close();
break;
case Qt::Key_Backspace:
search( m_searchText.left(m_searchText.size() - 1) );
break;
case Qt::Key_Delete:
search(QString());
break;
case Qt::Key_Alt:
return;
default:
// Type text for search.
if ( (m_clipboardItemActionCount > 0 || !m_searchText.isEmpty())
&& (m_navigationStyle != NavigationStyle::Vi || !m_searchText.isEmpty() || key == Qt::Key_Slash)
&& !event->modifiers().testFlag(Qt::AltModifier)
&& !event->modifiers().testFlag(Qt::ControlModifier) )
{
const QString txt = event->text();
if ( !txt.isEmpty() && txt[0].isPrint() ) {
// Activate item at row when number is entered.
if ( !m_numberSearch && m_searchText.isEmpty() ) {
bool ok;
const int row = txt.toInt(&ok);
const int start = static_cast<int>(m_rowIndexFromOne);
if (ok && start <= row && row < start + m_clipboardItemActionCount) {
// Allow keypad digit to activate appropriate item in context menu.
if (event->modifiers() == Qt::KeypadModifier)
event->setModifiers(Qt::NoModifier);
break;
}
}
search(m_searchText + txt);
return;
}
}
break;
}
}
QMenu::keyPressEvent(event);
}
void TrayMenu::mousePressEvent(QMouseEvent *event)
{
m_omitPaste = (event->button() == Qt::RightButton);
QMenu::mousePressEvent(event);
}
void TrayMenu::showEvent(QShowEvent *event)
{
search(QString());
// If appmenu is used to handle the menu, most events won't be received
// so search won't work.
// This shows the search menu item only if show event is received.
if ( !m_searchAction.isNull() )
m_searchAction->setVisible(true);
if ( m_timerUpdateActiveAction.isActive() )
doUpdateActiveAction();
QMenu::showEvent(event);
}
void TrayMenu::hideEvent(QHideEvent *event)
{
QMenu::hideEvent(event);
if ( !m_searchAction.isNull() )
m_searchAction->setVisible(false);
}
void TrayMenu::actionEvent(QActionEvent *event)
{
delayedUpdateActiveAction();
QMenu::actionEvent(event);
}
void TrayMenu::leaveEvent(QEvent *event)
{
// Omit clearing active action if menu is resizes and mouse pointer leaves menu.
auto action = activeAction();
QMenu::leaveEvent(event);
setActiveAction(action);
}
void TrayMenu::inputMethodEvent(QInputMethodEvent *event)
{
if (!event->commitString().isEmpty())
search(m_searchText + event->commitString());
event->ignore();
}
void TrayMenu::search(const QString &text)
{
if (m_searchText == text)
return;
m_searchText = text;
emit searchRequest((m_navigationStyle == NavigationStyle::Vi) ? m_searchText.mid(1) : m_searchText);
}
void TrayMenu::markItemInClipboard(const QVariantMap &clipboardData)
{
const auto text = getTextData(clipboardData);
for ( auto action : actions() ) {
const auto actionData = action->data().toMap();
const auto itemText = getTextData(actionData);
if ( !itemText.isEmpty() ) {
const auto hideIcon = itemText != text;
const auto isIconHidden = action->icon().isNull();
if ( isIconHidden != hideIcon )
action->setIcon(hideIcon ? QIcon() : iconClipboard());
}
}
}
void TrayMenu::setSearchMenuItem(const QString &text)
{
if ( m_searchAction.isNull() ) {
const QIcon icon = getIcon("edit-find", IconMagnifyingGlass);
m_searchAction = new QAction(icon, text, this);
m_searchAction->setEnabled(false);
// Search menu item is hidden by default, see showEvent().
m_searchAction->setVisible( isVisible() );
insertAction( actions().value(0), m_searchAction );
} else {
m_searchAction->setText(text);
}
}
void TrayMenu::onClipboardItemActionTriggered()
{
QAction *act = qobject_cast<QAction *>(sender());
Q_ASSERT(act != nullptr);
const auto actionData = act->data().toMap();
emit clipboardItemActionTriggered(actionData, m_omitPaste);
close();
}
void TrayMenu::delayedUpdateActiveAction()
{
if ( !isVisible() || activeAction() == nullptr )
m_timerUpdateActiveAction.start();
}
void TrayMenu::doUpdateActiveAction()
{
m_timerUpdateActiveAction.stop();
const auto action = firstEnabledAction(this);
if (action != nullptr)
setActiveAction(action);
}
| 11,825
|
C++
|
.cpp
| 345
| 27.231884
| 113
| 0.624453
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,207
|
menuitems.cpp
|
hluk_CopyQ/src/gui/menuitems.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "menuitems.h"
#include "common/shortcuts.h"
#include "gui/icons.h"
#include <QStringList>
#include <QVector>
namespace {
void addMenuItem(
MenuItems &items, Actions::Id id, const QString &text, const QString &settingsKey,
const QKeySequence &shortcut, const QString &iconName, ushort iconId = 0)
{
Q_ASSERT(items[id].text.isEmpty() && "Menu item index must be same as its ID.");
Q_UNUSED(id)
MenuItem &item = items[id];
item.text = text;
item.settingsKey = settingsKey;
item.defaultShortcut = shortcut;
item.shortcuts = QList<QKeySequence>() << shortcut;
item.iconName = iconName;
item.iconId = iconId;
}
void addMenuItem(
MenuItems &items, Actions::Id id, const QString &text, const QString &settingsKey,
const QString &shortcutText, const QString &iconName, ushort iconId = 0)
{
const QKeySequence shortcut = QKeySequence(shortcutText, QKeySequence::NativeText);
addMenuItem(items, id, text, settingsKey, shortcut, iconName, iconId);
}
} // namespace
MenuItems menuItems()
{
MenuItems items;
addMenuItem( items, Actions::File_New, QObject::tr("&New Item"), QStringLiteral("new"), QKeySequence::New,
QStringLiteral("document-new"), IconFileLines );
addMenuItem( items, Actions::File_Import, QObject::tr("&Import..."), QStringLiteral("import"), QObject::tr("Ctrl+I"),
QStringLiteral("document-open"), IconFolderOpen );
addMenuItem( items, Actions::File_Export, QObject::tr("&Export..."), QStringLiteral("export"), QKeySequence::Save,
QStringLiteral("document-save"), IconFloppyDisk );
addMenuItem( items, Actions::File_Preferences, QObject::tr("&Preferences..."), QStringLiteral("preferences"), QObject::tr("Ctrl+P"),
QStringLiteral("preferences-other"), IconWrench );
addMenuItem( items, Actions::File_Commands,
QObject::tr("C&ommands..."),
QStringLiteral("commands"), QObject::tr("F6"), QStringLiteral("system-run"), IconGear );
addMenuItem( items, Actions::File_ShowClipboardContent, QObject::tr("Show &Clipboard Content"),
QStringLiteral("show_clipboard_content"), QObject::tr("Ctrl+Shift+C"), QStringLiteral("dialog-information"), IconPaste );
addMenuItem( items, Actions::File_ShowPreview, QObject::tr("&Show Preview"),
QStringLiteral("show_item_preview"), QObject::tr("F7"), QStringLiteral("document-print-preview"), IconEye );
addMenuItem( items, Actions::File_ToggleClipboardStoring, QObject::tr("&Toggle Clipboard Storing"),
QStringLiteral("toggle_clipboard_storing"), QObject::tr("Ctrl+Shift+X"), QStringLiteral(""), IconBan );
addMenuItem( items, Actions::File_ProcessManager, QObject::tr("P&rocess Manager"),
QStringLiteral("process_manager"), QObject::tr("Ctrl+Shift+Z"), QStringLiteral("system-search"), IconGears );
addMenuItem( items, Actions::File_Exit, QObject::tr("E&xit"), QStringLiteral("exit"), QObject::tr("Ctrl+Q"),
QStringLiteral("application-exit"), IconPowerOff );
addMenuItem( items, Actions::Edit_SortSelectedItems, QObject::tr("&Sort Selected Items"),
QStringLiteral("sort_selected_items"), QObject::tr("Ctrl+Shift+S"),
QStringLiteral("view-sort-ascending"), IconArrowDownAZ );
addMenuItem( items, Actions::Edit_ReverseSelectedItems, QObject::tr("&Reverse Selected Items"),
QStringLiteral("reverse_selected_items"), QObject::tr("Ctrl+Shift+R"),
QStringLiteral("view-sort-descending"), IconArrowUpAZ );
addMenuItem( items, Actions::Edit_PasteItems, QObject::tr("&Paste Items"),
QStringLiteral("paste_selected_items"), QKeySequence::Paste, QStringLiteral("edit-paste"), IconPaste );
addMenuItem( items, Actions::Edit_CopySelectedItems, QObject::tr("&Copy Selected Items"),
QStringLiteral("copy_selected_items"), QKeySequence::Copy, QStringLiteral("edit-copy"), IconCopy );
addMenuItem( items, Actions::Edit_FindItems, QObject::tr("&Find"),
QStringLiteral("find_items"), QKeySequence::FindNext, QStringLiteral("edit-find"), IconMagnifyingGlass );
addMenuItem(items, Actions::Editor_Save, QObject::tr("Save Item"),
QStringLiteral("editor_save"), QObject::tr("F2", "Shortcut to save item editor changes"), QStringLiteral("document-save"), IconFloppyDisk);
addMenuItem(items, Actions::Editor_Cancel, QObject::tr("Cancel Editing"),
QStringLiteral("editor_cancel"), QObject::tr("Escape", "Shortcut to revert item editor changes"), QStringLiteral("document-revert"), IconTrash);
addMenuItem(items, Actions::Editor_Undo, QObject::tr("Undo"),
QStringLiteral("editor_undo"), QKeySequence::Undo, QStringLiteral("edit-undo"), IconRotateLeft);
addMenuItem(items, Actions::Editor_Redo, QObject::tr("Redo"),
QStringLiteral("editor_redo"), QKeySequence::Redo, QStringLiteral("edit-redo"), IconRotateRight);
addMenuItem(items, Actions::Editor_Font, QObject::tr("Font"),
QStringLiteral("editor_font"), QKeySequence(), QStringLiteral("preferences-desktop-font"), IconFont);
addMenuItem(items, Actions::Editor_Bold, QObject::tr("Bold"),
QStringLiteral("editor_bold"), QKeySequence::Bold, QStringLiteral("format-text-bold"), IconBold);
addMenuItem(items, Actions::Editor_Italic, QObject::tr("Italic"),
QStringLiteral("editor_italic"), QKeySequence::Italic, QStringLiteral("format-text-italic"), IconItalic);
addMenuItem(items, Actions::Editor_Underline, QObject::tr("Underline"),
QStringLiteral("editor_underline"), QKeySequence::Underline, QStringLiteral("format-text-underline"), IconUnderline);
addMenuItem(items, Actions::Editor_Strikethrough, QObject::tr("Strikethrough"),
QStringLiteral("editor_strikethrough"), QKeySequence(), QStringLiteral("format-text-strikethrough"), IconStrikethrough);
addMenuItem(items, Actions::Editor_Foreground, QObject::tr("Foreground"),
QStringLiteral("editor_foreground"), QKeySequence(), QStringLiteral(""), IconPaintbrush);
addMenuItem(items, Actions::Editor_Background, QObject::tr("Background"),
QStringLiteral("editor_background"), QKeySequence(), QStringLiteral(""), IconSquare);
addMenuItem(items, Actions::Editor_EraseStyle, QObject::tr("Erase Style"),
QStringLiteral("editor_erase_style"), QKeySequence(), QStringLiteral(""), IconEraser);
addMenuItem(items, Actions::Editor_Search, QObject::tr("Search"),
QStringLiteral("editor_search"), QKeySequence::Find, QStringLiteral("edit-find"), IconMagnifyingGlass);
addMenuItem( items, Actions::Item_MoveToClipboard,
QObject::tr("A&ctivate Items",
"copies selected items to clipboard and moves them to top (depending on settings)"),
QStringLiteral("move_to_clipboard"), QKeySequence(), QStringLiteral("clipboard"), IconPaste );
addMenuItem( items, Actions::Item_ShowContent, QObject::tr("&Show Content..."),
QStringLiteral("show_item_content"), QObject::tr("F4"), QStringLiteral("dialog-information"), IconCircleInfo );
addMenuItem( items, Actions::Item_Remove, QObject::tr("&Remove"),
QStringLiteral("delete_item"), shortcutToRemove(), QStringLiteral("list-remove"), IconTrash );
addMenuItem( items, Actions::Item_Edit, QObject::tr("&Edit"), QStringLiteral("edit"), QObject::tr("F2"),
QStringLiteral("accessories-text-editor"), IconPenToSquare );
addMenuItem( items, Actions::Item_EditNotes, QObject::tr("Edit &Notes"),
QStringLiteral("edit_notes"), QObject::tr("Shift+F2"), QStringLiteral("accessories-text-editor"), IconPenToSquare );
addMenuItem( items, Actions::Item_EditWithEditor, QObject::tr("E&dit with Editor"),
QStringLiteral("editor"), QObject::tr("Ctrl+E"), QStringLiteral("accessories-text-editor"), IconPencil );
addMenuItem( items, Actions::Item_Action, QObject::tr("&Action..."), QStringLiteral("system-run"), QObject::tr("F5"),
QStringLiteral("action"), IconBolt );
addMenuItem( items, Actions::Item_MoveUp, QObject::tr("Move Up"),
QStringLiteral("move_up"), QObject::tr("Ctrl+Up"), QStringLiteral("go-up"), IconAngleUp );
addMenuItem( items, Actions::Item_MoveDown, QObject::tr("Move Down"),
QStringLiteral("move_down"), QObject::tr("Ctrl+Down"), QStringLiteral("go-down"), IconAngleDown );
addMenuItem( items, Actions::Item_MoveToTop, QObject::tr("Move to Top"),
QStringLiteral("move_to_top"), QObject::tr("Ctrl+Home"), QStringLiteral("go-top"), IconAnglesUp );
addMenuItem( items, Actions::Item_MoveToBottom, QObject::tr("Move to Bottom"),
QStringLiteral("move_to_bottom"), QObject::tr("Ctrl+End"), QStringLiteral("go-bottom"), IconAnglesDown );
addMenuItem( items, Actions::Tabs_NewTab, QObject::tr("&New Tab"),
QStringLiteral("new_tab"), QObject::tr("Ctrl+T"), QStringLiteral(":/images/tab_new") );
addMenuItem( items, Actions::Tabs_RenameTab, QObject::tr("R&ename Tab"),
QStringLiteral("rename_tab"), QObject::tr("Ctrl+F2"), QStringLiteral(":/images/tab_rename") );
addMenuItem( items, Actions::Tabs_RemoveTab, QObject::tr("Re&move Tab"),
QStringLiteral("remove_tab"), QObject::tr("Ctrl+W"), QStringLiteral(":/images/tab_remove") );
addMenuItem( items, Actions::Tabs_ChangeTabIcon, QObject::tr("&Change Tab Icon"),
QStringLiteral("change_tab_icon"), QObject::tr("Ctrl+Shift+T"), QStringLiteral(":/images/tab_icon") );
addMenuItem( items, Actions::Tabs_NextTab, QObject::tr("Ne&xt Tab"),
QStringLiteral("next_tab"), QObject::tr("Right", "Default shortcut to focus next tab"),
QStringLiteral("go-next"), IconArrowRight );
addMenuItem( items, Actions::Tabs_PreviousTab, QObject::tr("&Previous Tab"),
QStringLiteral("previous_tab"), QObject::tr("Left", "Default shortcut to focus previous tab"),
QStringLiteral("go-previous"), IconArrowLeft );
addMenuItem( items, Actions::Help_Help, QObject::tr("&Help"), QStringLiteral("help"), QKeySequence::HelpContents,
QStringLiteral("help-contents"), IconCircleQuestion );
addMenuItem( items, Actions::Help_ShowLog, QObject::tr("&Show Log"), QStringLiteral("show-log"), QObject::tr("F12"),
QStringLiteral("help-about"), IconCircleExclamation );
addMenuItem( items, Actions::Help_About, QObject::tr("&About"), QStringLiteral("about"), QKeySequence::WhatsThis,
QStringLiteral("help-about"), IconCircleInfo );
addMenuItem( items, Actions::ItemMenu, QObject::tr("Open Item Context Menu"), QStringLiteral("item-menu"),
QObject::tr("Shift+F10", "Default shortcut to open item context menu"),
QStringLiteral(""), IconRectangleList );
return items;
}
void loadShortcuts(MenuItems *items, const QSettings &settings)
{
for (auto &item : *items) {
if ( !item.settingsKey.isEmpty() ) {
const QVariant shortcutNames = settings.value(item.settingsKey);
if ( shortcutNames.isValid() ) {
item.shortcuts.clear();
for ( const auto &shortcut : shortcutNames.toStringList() )
item.shortcuts.append(shortcut);
}
}
}
}
| 11,733
|
C++
|
.cpp
| 153
| 66.405229
| 160
| 0.671568
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,208
|
tabwidget.cpp
|
hluk_CopyQ/src/gui/tabwidget.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "tabwidget.h"
#include "tabbar.h"
#include "tabtree.h"
#include "common/config.h"
#include <QAction>
#include <QBoxLayout>
#include <QEvent>
#include <QMainWindow>
#include <QMimeData>
#include <QPoint>
#include <QSettings>
#include <QStackedWidget>
#include <QToolBar>
namespace {
QString getTabWidgetConfigurationFilePath()
{
return getConfigurationFilePath("_tabs.ini");
}
template <typename Receiver, typename Slot>
void addTabAction(QWidget *widget, const QKeySequence &shortcut,
Receiver *receiver, Slot slot,
Qt::ShortcutContext context = Qt::WindowShortcut)
{
auto act = new QAction(widget);
act->setShortcut(shortcut);
act->setShortcutContext(context);
QObject::connect(act, &QAction::triggered, receiver, slot);
widget->addAction(act);
}
} // namespace
TabWidget::TabWidget(QWidget *parent)
: QWidget(parent)
, m_toolBar(new QToolBar(this))
, m_toolBarTree(new QToolBar(this))
, m_stackedWidget(nullptr)
, m_hideTabBar(false)
, m_showTabItemCount(false)
{
// Set object name for tool bars so they can be saved with QMainWindow::saveState().
m_toolBar->setObjectName("toolBarTabBar");
m_toolBarTree->setObjectName("toolBarTabTree");
m_toolBar->setContextMenuPolicy(Qt::NoContextMenu);
m_toolBarTree->setContextMenuPolicy(Qt::NoContextMenu);
m_toolBar->installEventFilter(this);
connect( m_toolBar, &QToolBar::orientationChanged,
this, &TabWidget::onToolBarOrientationChanged );
auto layout = new QBoxLayout(QBoxLayout::TopToBottom, this);
setLayout(layout);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
m_stackedWidget = new QStackedWidget(this);
layout->addWidget(m_stackedWidget);
createTabBar();
addTabAction(this, QKeySequence::PreviousChild, this, &TabWidget::previousTab);
addTabAction(this, QKeySequence::NextChild, this, &TabWidget::nextTab);
loadTabInfo();
}
QString TabWidget::getCurrentTabPath() const
{
return m_tabs->getCurrentTabPath();
}
bool TabWidget::isTabGroup(const QString &tab) const
{
return m_tabs->isTabGroup(tab);
}
bool TabWidget::isTabGroupSelected() const
{
QWidget *w = currentWidget();
return w != nullptr && w->isHidden();
}
int TabWidget::currentIndex() const
{
return m_stackedWidget->currentIndex();
}
QWidget *TabWidget::widget(int tabIndex) const
{
return m_stackedWidget->widget(tabIndex);
}
int TabWidget::count() const
{
return m_stackedWidget->count();
}
QString TabWidget::tabName(int tabIndex) const
{
return m_tabs->tabName(tabIndex);
}
void TabWidget::setTabName(int tabIndex, const QString &tabName)
{
const QString oldTabName = this->tabName(tabIndex);
if ( m_tabItemCounters.contains(oldTabName) )
m_tabItemCounters.insert( tabName, m_tabItemCounters.take(oldTabName) );
m_tabs->setTabName(tabIndex, tabName);
m_tabs->adjustSize();
}
void TabWidget::setTabItemCountVisible(bool visible)
{
m_showTabItemCount = visible;
for (int i = 0; i < count(); ++i)
updateTabItemCount( tabName(i) );
m_tabs->adjustSize();
}
void TabWidget::setTabIcon(const QString &tabName, const QString &icon)
{
m_tabs->setTabIcon(tabName, icon);
}
void TabWidget::insertTab(int tabIndex, QWidget *widget, const QString &tabName)
{
const bool firstTab = count() == 0;
m_stackedWidget->insertWidget(tabIndex, widget);
m_tabs->insertTab(tabIndex, tabName);
m_toolBarCurrent->layout()->setSizeConstraint(QLayout::SetMinAndMaxSize);
if (firstTab)
emit currentChanged(0, -1);
updateTabItemCount(tabName);
updateToolBar();
}
void TabWidget::removeTab(int tabIndex)
{
if (tabIndex == currentIndex())
setCurrentIndex(tabIndex == 0 ? 1 : 0);
const QString tabName = this->tabName(tabIndex);
m_tabItemCounters.remove(tabName);
// Item count must be updated If tab is removed but tab group remains.
m_tabs->setTabItemCount(tabName, QString());
QWidget *w = m_stackedWidget->widget(tabIndex);
m_stackedWidget->removeWidget(w);
delete w;
m_tabs->removeTab(tabIndex);
updateToolBar();
}
QStringList TabWidget::tabs() const
{
QStringList tabs;
tabs.reserve( count() );
for( int i = 0; i < count(); ++i )
tabs.append( tabName(i) );
return tabs;
}
void TabWidget::addToolBars(QMainWindow *mainWindow)
{
mainWindow->addToolBar(Qt::TopToolBarArea, m_toolBar);
mainWindow->addToolBar(Qt::LeftToolBarArea, m_toolBarTree);
}
void TabWidget::saveTabInfo()
{
QStringList tabs;
tabs.reserve( count() );
for ( int i = 0; i < count(); ++i )
tabs.append( tabName(i) );
QSettings settings(getTabWidgetConfigurationFilePath(), QSettings::IniFormat);
m_tabs->updateCollapsedTabs(&m_collapsedTabs);
settings.setValue("TabWidget/collapsed_tabs", m_collapsedTabs);
QVariantMap tabItemCounters;
for (const auto &key : tabs) {
const int count = m_tabItemCounters.value(key, -1);
if (count >= 0)
tabItemCounters[key] = count;
}
settings.setValue("TabWidget/tab_item_counters", tabItemCounters);
}
void TabWidget::loadTabInfo()
{
QSettings settings(getTabWidgetConfigurationFilePath(), QSettings::IniFormat);
m_collapsedTabs = settings.value("TabWidget/collapsed_tabs").toStringList();
QVariantMap tabItemCounters = settings.value("TabWidget/tab_item_counters").toMap();
m_tabItemCounters.clear();
for (auto it = tabItemCounters.constBegin(); it != tabItemCounters.constEnd(); ++it)
m_tabItemCounters[it.key()] = it.value().toInt();
}
void TabWidget::updateTabs(QSettings &settings)
{
m_tabs->setCollapsedTabs(m_collapsedTabs);
QHash<QString, QString> tabIcons;
const int size = settings.beginReadArray(QStringLiteral("Tabs"));
for(int i = 0; i < size; ++i) {
settings.setArrayIndex(i);
const QString name = settings.value(QStringLiteral("name")).toString();
const QString icon = settings.value(QStringLiteral("icon")).toString();
tabIcons[name] = icon;
}
settings.endArray();
m_tabs->updateTabIcons(tabIcons);
}
void TabWidget::setCurrentIndex(int tabIndex)
{
if (m_ignoreCurrentTabChanges)
return;
QWidget *w = currentWidget();
const int current = isTabGroupSelected() ? -1 : currentIndex();
if (tabIndex == current)
return;
if (tabIndex != -1) {
m_stackedWidget->setCurrentIndex(tabIndex);
w = currentWidget();
if (w == nullptr)
return;
w->show();
if (m_toolBarCurrent->hasFocus())
w->setFocus();
m_tabs->setCurrentTab(tabIndex);
} else if (w != nullptr) {
if (w->hasFocus())
m_toolBarCurrent->setFocus();
w->hide();
}
emit currentChanged(tabIndex, current);
}
void TabWidget::nextTab()
{
m_tabs->nextTab();
}
void TabWidget::previousTab()
{
m_tabs->previousTab();
}
void TabWidget::setTabBarHidden(bool hidden)
{
m_hideTabBar = hidden;
updateToolBar();
}
void TabWidget::setTreeModeEnabled(bool enabled)
{
setTreeModeEnabled(enabled, this->tabs());
}
void TabWidget::setTabItemCount(const QString &tabName, int itemCount)
{
if ( m_tabItemCounters.value(tabName, -1) == itemCount)
return;
m_tabItemCounters[tabName] = itemCount;
updateTabItemCount(tabName);
}
void TabWidget::setTabsOrder(const QStringList &tabs)
{
QStringList currentTabs = this->tabs();
if (tabs == currentTabs)
return;
m_ignoreCurrentTabChanges = true;
for (int i = 0; i < tabs.size(); ++i) {
const int tabIndex = currentTabs.indexOf(tabs[i]);
if (tabIndex != -1 && tabIndex != i) {
QWidget *widget = m_stackedWidget->widget(tabIndex);
m_stackedWidget->removeWidget(widget);
m_stackedWidget->insertWidget(i, widget);
currentTabs.move(tabIndex, i);
}
}
m_stackedWidget->setCurrentIndex( currentIndex() );
setTreeModeEnabled(m_toolBarCurrent == m_toolBarTree, currentTabs);
m_ignoreCurrentTabChanges = false;
}
bool TabWidget::eventFilter(QObject *, QEvent *event)
{
if (event->type() == QEvent::Move)
updateToolBar();
return false;
}
void TabWidget::onTabMoved(int from, int to)
{
m_stackedWidget->insertWidget(to, m_stackedWidget->widget(from));
emit tabMoved(from, to);
}
void TabWidget::onTabsMoved(const QString &oldPrefix, const QString &newPrefix, const QList<int> &indexes)
{
const int newCurrentIndex = indexes.indexOf(currentIndex());
Q_ASSERT(newCurrentIndex != -1);
m_stackedWidget->hide();
QVector<QWidget*> widgets;
widgets.reserve(m_stackedWidget->count());
while ( m_stackedWidget->count() > 0 ) {
QWidget *w = m_stackedWidget->widget(0);
widgets.append(w);
m_stackedWidget->removeWidget(w);
}
for (int index : indexes) {
Q_ASSERT(index >= 0);
Q_ASSERT(index < widgets.count());
m_stackedWidget->insertWidget(-1, widgets[index]);
}
m_stackedWidget->setCurrentIndex(newCurrentIndex);
m_stackedWidget->show();
emit tabsMoved(oldPrefix, newPrefix);
}
void TabWidget::onToolBarOrientationChanged(Qt::Orientation orientation)
{
if (m_tabBar) {
if (orientation == Qt::Vertical)
m_tabBar->setShape(QTabBar::RoundedWest);
else
m_tabBar->setShape(QTabBar::RoundedNorth);
}
}
void TabWidget::onTreeItemClicked()
{
auto w = currentWidget();
if (w)
w->setFocus(Qt::MouseFocusReason);
}
void TabWidget::createTabBar()
{
auto tabBar = new TabBar(this);
tabBar->setObjectName("tab_bar");
tabBar->setExpanding(false);
tabBar->setMovable(true);
connect( tabBar, &TabBar::tabBarMenuRequested,
this, &TabWidget::tabBarMenuRequested );
connect( tabBar, &TabBar::tabRenamed,
this, &TabWidget::tabRenamed );
connect( tabBar, &QTabBar::tabCloseRequested,
this, &TabWidget::tabCloseRequested );
connect( tabBar, &TabBar::dropItems,
this, &TabWidget::dropItems );
connect( tabBar, &QTabBar::currentChanged,
this, &TabWidget::setCurrentIndex );
connect( tabBar, &QTabBar::tabMoved,
this, &TabWidget::onTabMoved );
delete m_tabs;
m_tabs = tabBar;
m_tabBar = tabBar;
m_toolBarCurrent = m_toolBar;
m_toolBarCurrent->addWidget(tabBar);
}
void TabWidget::createTabTree()
{
auto tabTree = new TabTree(this);
tabTree->setObjectName("tab_tree");
connect( tabTree, &TabTree::tabTreeMenuRequested,
this, &TabWidget::tabTreeMenuRequested );
connect( tabTree, &TabTree::tabsMoved,
this, &TabWidget::onTabsMoved );
connect( tabTree, &TabTree::dropItems,
this, &TabWidget::dropItems );
connect( tabTree, &TabTree::currentTabChanged,
this, &TabWidget::setCurrentIndex );
connect( tabTree, &QTreeWidget::itemClicked,
this, &TabWidget::onTreeItemClicked );
delete m_tabs;
m_tabs = tabTree;
m_tabBar = nullptr;
m_toolBarCurrent = m_toolBarTree;
m_toolBarCurrent->addWidget(tabTree);
}
void TabWidget::updateToolBar()
{
bool forceHide = count() == 1;
m_toolBar->setVisible(!forceHide && !m_hideTabBar && m_toolBarCurrent == m_toolBar);
m_toolBarTree->setVisible(!forceHide && !m_hideTabBar && m_toolBarCurrent == m_toolBarTree);
if (m_tabBar) {
QMainWindow *mainWindow = qobject_cast<QMainWindow*>(m_toolBar->window());
if (mainWindow) {
Qt::ToolBarArea area = mainWindow->toolBarArea(m_toolBar);
if (area == Qt::LeftToolBarArea)
m_tabBar->setShape(QTabBar::RoundedWest);
else if (area == Qt::RightToolBarArea)
m_tabBar->setShape(QTabBar::RoundedEast);
else if (area == Qt::TopToolBarArea)
m_tabBar->setShape(QTabBar::RoundedNorth);
else if (area == Qt::BottomToolBarArea)
m_tabBar->setShape(QTabBar::RoundedSouth);
}
}
m_tabs->adjustSize();
}
void TabWidget::updateTabItemCount(const QString &name)
{
m_tabs->setTabItemCount(name, itemCountLabel(name));
m_tabs->adjustSize();
}
QString TabWidget::itemCountLabel(const QString &name)
{
if (!m_showTabItemCount)
return QString();
const int count = m_tabItemCounters.value(name, -1);
return count > 0 ? QString::number(count) : count == 0 ? QString() : QLatin1String("?");
}
void TabWidget::setTreeModeEnabled(bool enabled, const QStringList &tabs)
{
if (enabled)
createTabTree();
else
createTabBar();
m_ignoreCurrentTabChanges = true;
for (int i = 0; i < tabs.size(); ++i) {
const QString &tabName = tabs[i];
m_tabs->insertTab(i, tabName);
m_tabs->setTabItemCount(tabName, itemCountLabel(tabName));
}
m_tabs->setCurrentTab( currentIndex() );
m_ignoreCurrentTabChanges = false;
updateToolBar();
}
| 13,185
|
C++
|
.cpp
| 391
| 28.542199
| 106
| 0.683423
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,209
|
windowgeometryguard.cpp
|
hluk_CopyQ/src/gui/windowgeometryguard.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "windowgeometryguard.h"
#include "common/appconfig.h"
#include "common/config.h"
#include "common/log.h"
#include "common/timer.h"
#include "gui/screen.h"
#include "platform/platformnativeinterface.h"
#include "platform/platformwindow.h"
#include <QApplication>
#include <QEvent>
#include <QMoveEvent>
#include <QScreen>
#include <QVariant>
#include <QWidget>
#include <QWindow>
namespace {
bool openOnCurrentScreen()
{
return AppConfig().option<Config::open_windows_on_current_screen>();
}
bool isRestoreGeometryEnabled()
{
return AppConfig().option<Config::restore_geometry>();
}
bool isMousePositionSupported()
{
// On Wayland, getting mouse position can return
// the last known mouse position in an own Qt application window.
static const bool supported = !QCursor::pos().isNull();
return supported;
}
QScreen *currentScreen()
{
if (!isMousePositionSupported())
return nullptr;
const int i = screenNumberAt(QCursor::pos());
const auto screens = QGuiApplication::screens();
if (0 <= i && i < screens.size())
return screens[i];
return nullptr;
}
} // namespace
void raiseWindow(QWidget *window)
{
window->raise();
if (qApp->applicationState() == Qt::ApplicationActive)
return;
window->activateWindow();
QApplication::setActiveWindow(window);
QTimer::singleShot(0, window, [window]{
const auto wid = window->winId();
const auto platformWindow = platformNativeInterface()->getWindow(wid);
if (platformWindow)
platformWindow->raise();
});
}
void WindowGeometryGuard::create(QWidget *window)
{
static const bool enabled = isRestoreGeometryEnabled();
if (enabled)
new WindowGeometryGuard(window);
}
bool WindowGeometryGuard::eventFilter(QObject *, QEvent *event)
{
const QEvent::Type type = event->type();
switch (type) {
case QEvent::Show: {
m_timerSaveGeometry.stop();
QWindow *window = m_window->windowHandle();
if (window) {
connect( window, &QWindow::screenChanged,
this, &WindowGeometryGuard::onScreenChanged, Qt::UniqueConnection );
if ( !isWindowGeometryLocked() && openOnCurrentScreen() && isMousePositionSupported() ) {
QScreen *screen = currentScreen();
if (screen && window->screen() != screen) {
COPYQ_LOG(QStringLiteral("Geometry: Moving to screen: %1").arg(screen->name()));
m_window->move(screen->availableGeometry().topLeft());
}
}
}
break;
}
case QEvent::Move:
case QEvent::Resize:
if ( !isWindowGeometryLocked() && m_window->isVisible() )
m_timerSaveGeometry.start();
break;
case QEvent::Hide:
if ( isGeometryGuardBlockedUntilHidden(m_window) )
setGeometryGuardBlockedUntilHidden(m_window, false);
break;
default:
break;
}
return false;
}
WindowGeometryGuard::WindowGeometryGuard(QWidget *window)
: QObject(window)
, m_window(window)
{
initSingleShotTimer(&m_timerSaveGeometry, 250, this, &WindowGeometryGuard::saveWindowGeometry);
initSingleShotTimer(&m_timerRestoreGeometry, 0, this, &WindowGeometryGuard::restoreWindowGeometry);
initSingleShotTimer(&m_timerUnlockGeometry, 250, this, &WindowGeometryGuard::unlockWindowGeometry);
m_window->installEventFilter(this);
restoreWindowGeometry();
}
bool WindowGeometryGuard::isWindowGeometryLocked() const
{
return m_timerUnlockGeometry.isActive() || isGeometryGuardBlockedUntilHidden(m_window);
}
bool WindowGeometryGuard::lockWindowGeometry()
{
if ( isWindowGeometryLocked() )
return false;
m_timerUnlockGeometry.start();
return true;
}
void WindowGeometryGuard::saveWindowGeometry()
{
if ( !lockWindowGeometry() )
return;
::saveWindowGeometry(m_window, openOnCurrentScreen());
unlockWindowGeometry();
}
void WindowGeometryGuard::restoreWindowGeometry()
{
if ( !lockWindowGeometry() )
return;
::restoreWindowGeometry(m_window, openOnCurrentScreen());
}
void WindowGeometryGuard::unlockWindowGeometry()
{
m_timerUnlockGeometry.stop();
}
void WindowGeometryGuard::onScreenChanged()
{
if (!openOnCurrentScreen())
return;
if ( !lockWindowGeometry() )
return;
QWindow *window = m_window->windowHandle();
if (!window)
return;
QScreen *screen = window->screen();
if (!screen)
return;
COPYQ_LOG(QStringLiteral("Geometry: Screen changed: %1").arg(screen->name()));
const bool isMousePositionSupported = ::isMousePositionSupported();
if ( window && isMousePositionSupported && screen != currentScreen() ) {
COPYQ_LOG(QStringLiteral("Geometry: Avoiding geometry-restore on incorrect screen"));
return;
}
if (isMousePositionSupported || m_window->isModal()) {
::restoreWindowGeometry(m_window, true);
} else if ( m_window->isVisible() ) {
// WORKAROUND: Center window position on Sway window compositor which
// does not support changing window position.
m_window->hide();
::restoreWindowGeometry(m_window, true);
m_window->show();
} else {
::restoreWindowGeometry(m_window, true);
}
}
| 5,418
|
C++
|
.cpp
| 165
| 27.442424
| 103
| 0.686169
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,210
|
iconwidget.cpp
|
hluk_CopyQ/src/gui/iconwidget.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "iconwidget.h"
#include "gui/icons.h"
#include "gui/iconfont.h"
#include <QPainter>
#include <QPaintEvent>
#include <QString>
IconWidget::IconWidget(int icon, QWidget *parent)
: QWidget(parent)
, m_icon()
{
QFontMetrics fm(iconFont());
QChar c(icon);
if ( fm.inFont(c) )
m_icon = QString(c);
setFixedSize(sizeHint());
}
IconWidget::IconWidget(const QString &icon, QWidget *parent)
: QWidget(parent)
, m_icon(icon)
{
setFixedSize(sizeHint());
}
QSize IconWidget::sizeHint() const
{
if ( m_icon.isEmpty() )
return QSize(0, 0);
const int side = iconFontSizePixels() + 4;
return QSize(side, side);
}
void IconWidget::paintEvent(QPaintEvent *)
{
if (m_icon.isEmpty())
return;
QPainter p(this);
if (m_icon.size() == 1) {
p.setFont(iconFont());
p.setRenderHint(QPainter::TextAntialiasing, true);
if (parentWidget())
p.setPen( parentWidget()->palette().color(QPalette::Text) );
p.drawText( rect(), Qt::AlignCenter, m_icon);
} else {
QPixmap pix(m_icon);
p.drawPixmap( 0, 0, pix.scaled(size(), Qt::KeepAspectRatio) );
}
}
| 1,231
|
C++
|
.cpp
| 46
| 22.195652
| 72
| 0.640239
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,211
|
commandcompleter.cpp
|
hluk_CopyQ/src/gui/commandcompleter.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "commandcompleter.h"
#include "commandsyntaxhighlighter.h"
#include "commandcompleterdocumentation.h"
#include "common/appconfig.h"
#include "common/timer.h"
#include <QAbstractItemView>
#include <QCompleter>
#include <QCoreApplication>
#include <QHash>
#include <QHeaderView>
#include <QKeyEvent>
#include <QTableView>
#include <QTimer>
#include <QPlainTextEdit>
#include <QScrollBar>
#include <QStringListModel>
#include <QShortcut>
namespace {
const QLatin1String tagObject("obj");
const QLatin1String tagType("type");
const QLatin1String tagProperty("prop");
const QLatin1String tagFunction("fn");
const QLatin1String tagKeyword("kw");
class CommandCompleterModel final : public QStringListModel {
public:
explicit CommandCompleterModel(QObject *parent)
: QStringListModel(parent)
{
for (const QString &name : scriptableObjects()) {
if (name.size() > 1 && name[0].isUpper() && name[1].isLower())
m_doc[name].tag = tagType;
else
m_doc[name].tag = tagObject;
}
for (const auto &name : scriptableProperties())
m_doc[name].tag = tagProperty;
for (const auto &name : scriptableFunctions())
m_doc[name].tag = tagFunction;
for (const auto &name : scriptableKeywords())
m_doc[name].tag = tagKeyword;
addDocumentation();
QStringList completionItems = m_doc.keys();
std::sort(std::begin(completionItems), std::end(completionItems));
setStringList(completionItems);
}
int columnCount(const QModelIndex &) const override
{
return 3;
}
QVariant data(const QModelIndex &index, int role) const override
{
const int row = index.row();
if (index.column() == 1) {
if (role == Qt::DisplayRole || role == Qt::EditRole)
return documentationForRow(row).tag;
if (role == Qt::ForegroundRole)
return QColor(Qt::gray);
return QVariant();
}
if (index.column() == 2) {
if (role == Qt::DisplayRole || role == Qt::EditRole)
return documentationForRow(row).doc;
return QVariant();
}
if (role == Qt::ToolTipRole)
return typeForRow(row);
return QStringListModel::data(index, role);
}
private:
struct ScriptableDocumentation {
QString tag;
QString doc;
};
void addDocumentation()
{
::addDocumentation(
[this](const QString &name, const QString &api, const QString &documentation) {
auto &doc = m_doc[name].doc;
if (!doc.isEmpty())
doc.append("\n");
doc.append(api + "\n " + documentation);
});
}
ScriptableDocumentation documentationForRow(int row) const
{
const auto index2 = this->index(row, 0);
const auto text = QStringListModel::data(index2, Qt::EditRole).toString();
return m_doc.value(text);
}
QString typeForRow(int row) const
{
const auto tagText = documentationForRow(row).tag;
if (tagText == tagObject)
return QStringLiteral("object");
if (tagText == tagType)
return QStringLiteral("type");
if (tagText == tagProperty)
return QStringLiteral("property");
if (tagText == tagFunction)
return QStringLiteral("function");
if (tagText == tagKeyword)
return QStringLiteral("keyword");
return tagText;
}
QHash<QString, ScriptableDocumentation> m_doc;
};
void setUpHeader(QHeaderView *header)
{
header->hide();
header->setSectionResizeMode(QHeaderView::ResizeToContents);
}
class CommandCompleterPopup final : public QTableView {
public:
explicit CommandCompleterPopup(QWidget *parent)
: QTableView(parent)
{
setUpHeader(horizontalHeader());
setUpHeader(verticalHeader());
setShowGrid(false);
setContentsMargins(0, 0, 0, 0);
setSelectionBehavior(QAbstractItemView::SelectRows);
setAlternatingRowColors(true);
initSingleShotTimer(&m_timerResize, 10, this, &CommandCompleterPopup::updateSize);
}
protected:
void showEvent(QShowEvent *event) override
{
QTableView::showEvent(event);
m_timerResize.start();
}
private:
void updateSize()
{
if (!model())
return;
const auto margins = contentsMargins();
const int w = columnsWidth()
+ (verticalScrollBar()->isVisible() ? verticalScrollBar()->width() : 0)
+ margins.left() + margins.right();
const int h = rowsHeight(8)
+ (horizontalScrollBar()->isVisible() ? verticalScrollBar()->height() : 0)
+ margins.top() + margins.bottom();
resize(w, h);
}
int columnsWidth() const
{
int width = 0;
for ( int column = 0; column < model()->columnCount(); ++column )
width += columnWidth(column);
return width;
}
int rowsHeight(int maxRows) const
{
int height = 0;
for ( int row = 0; row < qMin(maxRows, model()->rowCount()); ++row )
height += rowHeight(row);
return height;
}
QTimer m_timerResize;
};
} // namespace
CommandCompleter::CommandCompleter(QPlainTextEdit *editor)
: QObject(editor)
, m_editor(editor)
, m_completer(new QCompleter(new CommandCompleterModel(this), this))
{
setObjectName("CommandCompleter");
m_completer->setWidget(m_editor);
m_completer->setCompletionMode(QCompleter::PopupCompletion);
m_completer->setCaseSensitivity(Qt::CaseInsensitive);
m_completer->setPopup(new CommandCompleterPopup(m_editor));
m_completer->popup()->installEventFilter(this);
connect( m_completer, static_cast<void (QCompleter::*)(const QString&)>(&QCompleter::activated),
this, &CommandCompleter::insertCompletion );
connect( m_editor, &QPlainTextEdit::textChanged,
this, &CommandCompleter::onTextChanged );
connect( m_editor, &QPlainTextEdit::cursorPositionChanged,
m_completer->popup(), &QWidget::hide );
auto shortcut = new QShortcut(tr("Ctrl+Space", "Shortcut to show completion menu"), editor);
connect( shortcut, &QShortcut::activated,
this, &CommandCompleter::showCompletion );
}
bool CommandCompleter::eventFilter(QObject *, QEvent *event)
{
if (event->type() != QEvent::KeyPress)
return false;
QKeyEvent *e = static_cast<QKeyEvent*>(event);
QAbstractItemView *popup = m_completer->popup();
switch (e->key()) {
case Qt::Key_Enter:
case Qt::Key_Return:
case Qt::Key_Tab:
case Qt::Key_Backtab:
m_completer->setCurrentRow( popup->currentIndex().row() );
insertCompletion( m_completer->currentCompletion() );
popup->hide();
return true;
case Qt::Key_Escape:
popup->hide();
return true;
default:
return false;
}
}
QWidget *CommandCompleter::popup() const
{
return m_completer->popup();
}
void CommandCompleter::onTextChanged()
{
updateCompletion(false);
}
void CommandCompleter::updateCompletion(bool forceShow)
{
const QString completionPrefix = textUnderCursor();
QAbstractItemView *popup = m_completer->popup();
if ( !forceShow && completionPrefix.length() < 3 ) {
popup->hide();
} else {
// Don't auto-complete if it's disabled in configuration.
if ( !forceShow && !AppConfig().option<Config::autocompletion>() )
return;
if (completionPrefix != m_completer->completionPrefix()) {
m_completer->setCompletionPrefix(completionPrefix);
popup->setCurrentIndex(m_completer->completionModel()->index(0, 0));
}
const auto rect = m_editor->cursorRect();
m_completer->complete(rect);
}
}
void CommandCompleter::insertCompletion(const QString &completion)
{
QTextCursor tc = m_editor->textCursor();
tc.movePosition(QTextCursor::Left);
tc.movePosition(QTextCursor::StartOfWord);
tc.movePosition(QTextCursor::EndOfWord, QTextCursor::KeepAnchor);
tc.insertText(completion);
m_editor->setTextCursor(tc);
}
void CommandCompleter::showCompletion()
{
updateCompletion(true);
}
QString CommandCompleter::textUnderCursor() const
{
auto tc = m_editor->textCursor();
tc.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor);
tc.select(QTextCursor::WordUnderCursor);
const auto text = tc.selectedText();
return text;
}
| 8,741
|
C++
|
.cpp
| 252
| 27.829365
| 100
| 0.646745
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,212
|
aboutdialog.cpp
|
hluk_CopyQ/src/gui/aboutdialog.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "aboutdialog.h"
#include "ui_aboutdialog.h"
#include "common/textdata.h"
#include "common/version.h"
#include "gui/icons.h"
#include "gui/iconfont.h"
namespace {
QString helpUrl(const char *url)
{
return QString::fromLatin1("<a href='%1'>%1</a>").arg(url);
}
QString helpMail(const char *url)
{
return QString::fromLatin1("<a href='mailto:%1'>%1</a>").arg(url);
}
QString helpLink(const QString &name, const QString &link, ushort icon)
{
return "<tr>"
"<td class='info'>" + name + "</td>"
"<td valign='middle' align='center' class='help-icon icon'>"
+ QString("&#%1;").arg(icon) + "</td>"
"<td>" + link + "</td>"
"</tr>";
}
QString helpLib(const char *name, const QString ©right, const char *url)
{
return QString("<p><span class='library'>%1</span>"
" <br />"
"<span class='copyright'>%2</span><br />"
"%3</p>")
.arg( name, copyright, helpUrl(url) );
}
} // namespace
AboutDialog::AboutDialog(QWidget *parent)
: QDialog(parent)
, ui(new Ui::AboutDialog)
{
ui->setupUi(this);
ui->textBrowser->setText( aboutPage() );
}
AboutDialog::~AboutDialog()
{
delete ui;
}
QString AboutDialog::aboutPage()
{
return
"<html>"
"<head><style type='text/css'>"
"body{font-size:10pt;background:white;color:#333;margin:1.0em}"
"p,li{margin-left:4ex;white-space:pre-wrap;margin-left:1ex}"
"a{text-decoration:none;color:#4f9a6b}"
"table{border:0}"
"td{padding:0.1em}"
"#title{font-size:26pt;color:#666;white-space:pre;margin-bottom:0.2em}"
"#subtitle{font-size:16pt;color:#4f9a6b;white-space:pre;margin-bottom:0.2em}"
"#version{font-size:12pt}"
".copyright{font-size:9pt;color:#666}"
".icon{font-family: \"" + iconFontFamily() + "\"}"
".help-icon{color:#5faa7b;padding-left:1em;padding-right:1em}"
".library{font-size:12pt}"
".info{color:#666}"
"</style></head>"
"<body>"
"<table><tr valign='middle'>"
"<td><img src=':/images/logo.png' width='128' /></td>"
"<td>"
"<div id='title'>CopyQ</div>"
"<div id='subtitle'>" + escapeHtml(tr("Clipboard Manager")) + "</div>"
"<div id='version'>" + versionString + "</div>"
"</td>"
"</tr></table>"
"<p>"
"<table class='links'>"
+ helpLink( tr("Author"), QString::fromUtf8("Lukáš Holeček"), IconUser )
+ helpLink( tr("E-mail"), helpMail("copyq@googlegroups.com"), IconEnvelope )
+ helpLink( tr("Web"), helpUrl("https://hluk.github.io/CopyQ/"), IconHouse )
+ helpLink( tr("Donate"), helpUrl("https://liberapay.com/CopyQ/"), IconGift )
+
"</table>"
"</p>"
"<p class='copyright'>Copyright (c) 2009 - 2024</p>"
"<p></p>"
+ "<p>"
+ helpUrl("https://github.com/hluk/CopyQ/graphs/contributors")
+
"</p>"
+ helpLib("Qt Toolkit",
"Copyright (c) The Qt Company Ltd. and other contributors",
"https://www.qt.io/")
+ helpLib("KDE Frameworks",
"Copyright (c) KDE Community",
"https://develop.kde.org/products/frameworks/")
+ helpLib("Snoretoast",
"Copyright (c) Hannah von Reth",
"https://invent.kde.org/libraries/snoretoast")
+ helpLib("Weblate",
"Copyright (c) Michal Čihař", "https://weblate.org")
+ helpLib("Font Awesome",
"Copyright (c) Fonticons, Inc.", "https://fontawesome.com")
+ helpLib("LibQxt",
"Copyright (c), the LibQxt project", "http://libqxt.org")
+ helpLib("Solarized",
"Copyright (c) Ethan Schoonover", "https://ethanschoonover.com/solarized")
+ "<p></p>"
"</body></html>";
}
| 4,141
|
C++
|
.cpp
| 108
| 29.416667
| 96
| 0.545024
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,213
|
iconfont.cpp
|
hluk_CopyQ/src/gui/iconfont.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "iconfont.h"
#include <QApplication>
#include <QFont>
#include <QFontDatabase>
#include <QFontMetrics>
#include <QStyle>
#include <algorithm>
#include <vector>
namespace {
const int iconFontMaxHeight = 128;
const int iconFontMaxWidth = 160;
int iconFontId()
{
static const auto fontId =
QFontDatabase::addApplicationFont(":/images/fontawesome.ttf");
return fontId;
}
std::vector<int> smoothSizes()
{
const auto smoothSizes = QFontDatabase().smoothSizes(iconFontFamily(), QString());
return std::vector<int>(std::begin(smoothSizes), std::end(smoothSizes));
}
int iconFontSmoothPixelSize(int pixelSize)
{
static const auto smoothSizes = ::smoothSizes();
const auto it = std::upper_bound(
std::begin(smoothSizes), std::end(smoothSizes), pixelSize);
if ( it == std::begin(smoothSizes) )
return pixelSize;
return *(it - 1);
}
QString createIconFontFamily()
{
const QString iconFontFamily =
QFontDatabase::applicationFontFamilies(iconFontId()).value(0);
Q_ASSERT(iconFontFamily.endsWith("(CopyQ)"));
return iconFontFamily;
}
} // namespace
const QString &iconFontFamily()
{
static const QString fontFamily = createIconFontFamily();
return fontFamily;
}
bool loadIconFont()
{
return iconFontId() != -1;
}
QFont iconFont()
{
static QFont font(iconFontFamily());
font.setPixelSize( iconFontSizePixels() );
return font;
}
int iconFontSizePixels()
{
return QApplication::style()->pixelMetric(QStyle::PM_SmallIconSize);
}
QFont iconFontFitSize(int w, int h)
{
QFont font = iconFont();
const auto pixelSize = w < h
? w * iconFontMaxWidth / iconFontMaxHeight
: h * iconFontMaxHeight / iconFontMaxWidth;
const auto smoothPixelSize = iconFontSmoothPixelSize(pixelSize);
font.setPixelSize(smoothPixelSize);
return font;
}
| 1,918
|
C++
|
.cpp
| 69
| 24.507246
| 86
| 0.730748
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,214
|
theme.cpp
|
hluk_CopyQ/src/gui/theme.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "theme.h"
#include "ui_configtabappearance.h"
#include "common/config.h"
#include "common/log.h"
#include "gui/iconfont.h"
#include "platform/platformnativeinterface.h"
#include <QApplication>
#include <QDir>
#include <QFile>
#include <QListView>
#include <QScreen>
#include <QSettings>
#include <QStyleFactory>
#include <cmath>
namespace {
const QLatin1String defaultColorVarBase("default_bg");
const QLatin1String defaultColorVarText("default_text");
const QLatin1String defaultColorVarPlaceholderText("default_placeholder_text");
const QLatin1String defaultColorVarAlternateBase("default_alt_bg");
const QLatin1String defaultColorVarHighlight("default_highlight_bg");
const QLatin1String defaultColorVarHighlightText("default_highlight_text");
const QLatin1String defaultColorVarToolTipBase("default_tooltip_bg");
const QLatin1String defaultColorVarToolTipText("default_tooltip_text");
const QLatin1String defaultColorVarWindow("default_window");
const QLatin1String defaultColorVarWindowText("default_window_text");
const QLatin1String defaultColorVarButton("default_button");
const QLatin1String defaultColorVarButtonText("default_button_text");
const QLatin1String defaultColorVarBrightText("default_bright_text");
const QLatin1String defaultColorVarLight("default_light");
const QLatin1String defaultColorVarMidlight("default_midlight");
const QLatin1String defaultColorVarDark("default_dark");
const QLatin1String defaultColorVarMid("default_mid");
const QLatin1String defaultColorVarShadow("default_shadow");
const QLatin1String defaultColorLink("default_link");
const QLatin1String defaultColorLinkVisited("default_link_visited");
QPalette::ColorRole defaultColorVarToRole(const QString &varName)
{
static QHash<QString, QPalette::ColorRole> map = {
{defaultColorVarBase, QPalette::Base},
{defaultColorVarText, QPalette::Text},
#if QT_VERSION >= QT_VERSION_CHECK(5,12,0)
{defaultColorVarPlaceholderText, QPalette::PlaceholderText},
#else
{defaultColorVarPlaceholderText, QPalette::AlternateBase},
#endif
{defaultColorVarAlternateBase, QPalette::AlternateBase},
{defaultColorVarHighlight, QPalette::Highlight},
{defaultColorVarHighlightText, QPalette::HighlightedText},
{defaultColorVarToolTipBase, QPalette::ToolTipBase},
{defaultColorVarToolTipText, QPalette::ToolTipText},
{defaultColorVarWindow, QPalette::Window},
{defaultColorVarWindowText, QPalette::WindowText},
{defaultColorVarButton, QPalette::Button},
{defaultColorVarButtonText, QPalette::ButtonText},
{defaultColorVarBrightText, QPalette::BrightText},
{defaultColorVarLight, QPalette::Light},
{defaultColorVarMidlight, QPalette::Midlight},
{defaultColorVarDark, QPalette::Dark},
{defaultColorVarMid, QPalette::Mid},
{defaultColorVarShadow, QPalette::Shadow},
{defaultColorLink, QPalette::Link},
{defaultColorLinkVisited, QPalette::LinkVisited},
};
const auto it = map.find(varName);
return (it == std::end(map)) ? QPalette::NoRole : it.value();
}
double normalizeFactor(double value)
{
return qBound( 0.0, value, 1.0 );
}
int normalizeColorValue(int value)
{
return qBound(0, value, 255);
}
/// Add RGB components properly.
int addColor(int c1, float multiply, int c2)
{
const float f1 = static_cast<float>(c1);
const float f2 = static_cast<float>(c2);
return multiply > 0.0f
? static_cast<int>( std::sqrt(f1*f1 + multiply * f2*f2) )
: c1 + static_cast<int>(multiply * f2);
}
void addColor(
const QString &color, float multiply, int *r, int *g, int *b, int *a,
const Theme &theme, const Values &values, int maxRecursion)
{
if (color.isEmpty())
return;
QColor toAdd;
float x = multiply;
if (color.at(0).isDigit()) {
bool ok;
x = multiply * color.toFloat(&ok);
if (!ok)
return;
toAdd = QColor(1, 1, 1);
} else if ( color.startsWith('#') || color.startsWith("rgba(") ) {
toAdd = deserializeColor(color);
if ( !toAdd.isValid() )
toAdd = QColor(Qt::black);
} else if ( color.startsWith(QStringLiteral("default_")) ) {
const QPalette::ColorRole role = defaultColorVarToRole(color);
toAdd = QPalette().color(role);
} else if (maxRecursion > 0) {
const QVariant v = values.contains(color)
? values.value(color) : theme.value(color);
toAdd = evalColor(v.toString(), theme, values, maxRecursion - 1);
}
*r = normalizeColorValue( addColor(*r, x, toAdd.red()) );
*g = normalizeColorValue( addColor(*g, x, toAdd.green()) );
*b = normalizeColorValue( addColor(*b, x, toAdd.blue()) );
if (multiply > 0.0f) {
const float fa = static_cast<float>(*a);
const float fad = static_cast<float>(toAdd.alpha());
*a = normalizeColorValue( static_cast<int>(fa + x * fad) );
}
}
int fitFontWeight(int weight, int low, int high, int highCss)
{
const int diffCss = 100;
const int lowCss = highCss - diffCss;
if (weight == low)
return lowCss;
const int diff = high - low;
return lowCss + diffCss * weight / diff;
}
int getFontWeightForStyleSheet(int weight)
{
if (weight < QFont::ExtraLight)
return fitFontWeight(weight, QFont::Thin, QFont::ExtraLight, 200);
if (weight < QFont::Light)
return fitFontWeight(weight, QFont::ExtraLight, QFont::Light, 300);
if (weight < QFont::Normal)
return fitFontWeight(weight, QFont::Light, QFont::Normal, 400);
if (weight < QFont::Medium)
return fitFontWeight(weight, QFont::Normal, QFont::Medium, 500);
if (weight < QFont::DemiBold)
return fitFontWeight(weight, QFont::Medium, QFont::DemiBold, 600);
if (weight < QFont::Bold)
return fitFontWeight(weight, QFont::DemiBold, QFont::Bold, 700);
if (weight < QFont::ExtraBold)
return fitFontWeight(weight, QFont::Bold, QFont::ExtraBold, 800);
if (weight < QFont::Black)
return fitFontWeight(weight, QFont::ExtraBold, QFont::Black, 900);
return 900;
}
QString getFontStyleSheet(const QString &fontString, double scale = 1.0)
{
QFont font;
if (!fontString.isEmpty())
font.fromString(fontString);
qreal size = font.pointSizeF() * scale;
QString sizeUnits = "pt";
if (size < 0.0) {
size = font.pixelSize() * scale;
sizeUnits = "px";
}
size = qBound(0.1, size, 50.0);
QString result;
result.append( QString::fromLatin1(";font-family: \"%1\"").arg(font.family()) );
result.append( QString::fromLatin1(";font:%1 %2 %3%4")
.arg(font.style() == QFont::StyleItalic
? "italic" : font.style() == QFont::StyleOblique ? "oblique" : "normal",
font.bold() ? "bold" : "")
.arg(size)
.arg(sizeUnits)
);
result.append( QString::fromLatin1(";text-decoration:%1 %2 %3")
.arg(font.strikeOut() ? "line-through" : "",
font.underline() ? "underline" : "",
font.overline() ? "overline" : "")
);
const int w = getFontWeightForStyleSheet( font.weight() );
result.append( QString::fromLatin1(";font-weight:%1").arg(w) );
result.append(";");
return result;
}
QString themePrefix()
{
#ifdef COPYQ_THEME_PREFIX
return COPYQ_THEME_PREFIX;
#else
return platformNativeInterface()->themePrefix();
#endif
}
double getFactor(const QString &name, const QHash<QString, QVariant> &values)
{
bool ok;
const double scale = values.value(name).toDouble(&ok);
return ok ? scale : 1.0;
}
} // namespace
Theme::Theme(const QSettings &settings)
{
loadTheme(settings);
}
Theme::Theme(Ui::ConfigTabAppearance *ui)
: ui(ui)
{
}
void Theme::loadTheme(const QSettings &settings)
{
resetTheme();
for ( auto key = m_theme.keyBegin(); key != m_theme.keyEnd(); ++key ) {
const auto value = settings.value(*key);
if ( value.isValid() )
m_theme[*key].setValue(value);
}
updateTheme();
}
void Theme::saveTheme(QSettings *settings) const
{
QStringList keys = m_theme.keys();
keys.sort();
for (const auto &key : keys)
settings->setValue( key, value(key) );
}
QVariant Theme::value(const QString &name) const
{
return m_theme.value(name).value();
}
QColor Theme::color(const QString &name) const
{
return evalColor( value(name).toString(), *this );
}
QFont Theme::font(const QString &name) const
{
return themeFontFromString( value(name).toString() );
}
QColor Theme::evalColorExpression(const QString &expr) const
{
return evalColor( expr, *this );
}
void Theme::decorateBrowser(QListView *c) const
{
QAbstractScrollArea *c2 = c;
decorateBrowser(c2);
bool ok;
const int itemSpacing = value("item_spacing").toInt(&ok);
c->setSpacing( ok ? itemSpacing : c->fontMetrics().lineSpacing() / 6 );
}
void Theme::decorateMainWindow(QWidget *mainWindow) const
{
QPalette palette = QApplication::palette();
// This seems to properly reset icon colors.
mainWindow->setStyleSheet(QString());
mainWindow->setPalette(palette);
if ( !isMainWindowThemeEnabled() ) {
const QString cssTemplate = QStringLiteral("main_window_simple");
mainWindow->setStyleSheet(getStyleSheet(cssTemplate));
return;
}
const auto bg = color("bg");
const auto fg = color("fg");
palette.setColor( QPalette::Base, bg );
palette.setColor( QPalette::AlternateBase, color("alt_bg") );
palette.setColor( QPalette::Text, fg );
palette.setColor( QPalette::Window, bg );
palette.setColor( QPalette::WindowText, fg );
palette.setColor( QPalette::Button, bg );
palette.setColor( QPalette::ButtonText, fg );
palette.setColor( QPalette::Highlight, color("sel_bg") );
palette.setColor( QPalette::HighlightedText, color("sel_fg") );
mainWindow->setPalette(palette);
const QString cssTemplate = value("css_template_main_window").toString();
mainWindow->setStyleSheet(getStyleSheet(cssTemplate));
}
void Theme::decorateScrollArea(QAbstractScrollArea *scrollArea) const
{
const auto scrollbarPolicy = this->scrollbarPolicy();
scrollArea->setVerticalScrollBarPolicy(scrollbarPolicy);
scrollArea->setHorizontalScrollBarPolicy(scrollbarPolicy);
}
void Theme::decorateItemPreview(QAbstractScrollArea *itemPreview) const
{
decorateBrowser(itemPreview);
}
QString Theme::getMenuStyleSheet() const
{
const QString cssTemplate = value("css_template_menu").toString();
return getStyleSheet(cssTemplate);
}
QString Theme::getNotificationStyleSheet() const
{
const QString cssTemplate = value("css_template_notification").toString();
return getStyleSheet(cssTemplate);
}
Qt::ScrollBarPolicy Theme::scrollbarPolicy() const
{
return value("show_scrollbars").toBool()
? Qt::ScrollBarAsNeeded
: Qt::ScrollBarAlwaysOff;
}
bool Theme::useSystemIcons() const
{
return value("use_system_icons").toBool();
}
QFont Theme::themeFontFromString(const QString &fontString) const
{
QFont font;
if ( !fontString.isEmpty() )
font.fromString(fontString);
if ( !isAntialiasingEnabled() )
font.setStyleStrategy(QFont::NoAntialias);
return font;
}
bool Theme::isAntialiasingEnabled() const
{
return m_antialiasing;
}
void Theme::resetTheme()
{
m_theme["bg"] = Option(defaultColorVarBase, "VALUE", ui ? ui->pushButtonColorBg : nullptr);
m_theme["edit_bg"] = Option(defaultColorVarBase, "VALUE", ui ? ui->pushButtonColorEditorBg : nullptr);
m_theme["fg"] = Option(defaultColorVarText, "VALUE", ui ? ui->pushButtonColorFg : nullptr);
m_theme["edit_fg"] = Option(defaultColorVarText, "VALUE", ui ? ui->pushButtonColorEditorFg : nullptr);
m_theme["num_fg"] = Option(defaultColorVarPlaceholderText, "VALUE", ui ? ui->pushButtonColorNumberFg : nullptr);
m_theme["alt_bg"] = Option(defaultColorVarAlternateBase, "VALUE", ui ? ui->pushButtonColorAltBg : nullptr);
m_theme["sel_bg"] = Option(defaultColorVarHighlight, "VALUE", ui ? ui->pushButtonColorSelBg : nullptr);
m_theme["sel_fg"] = Option(defaultColorVarHighlightText, "VALUE", ui ? ui->pushButtonColorSelFg : nullptr);
m_theme["find_bg"] = Option("#ff0", "VALUE", ui ? ui->pushButtonColorFoundBg : nullptr);
m_theme["find_fg"] = Option("#000", "VALUE", ui ? ui->pushButtonColorFoundFg : nullptr);
m_theme["notes_bg"] = Option(defaultColorVarToolTipBase, "VALUE", ui ? ui->pushButtonColorNotesBg : nullptr);
m_theme["notes_fg"] = Option(defaultColorVarToolTipText, "VALUE", ui ? ui->pushButtonColorNotesFg : nullptr);
m_theme["notification_bg"] = Option("#333", "VALUE", ui ? ui->pushButtonColorNotificationBg : nullptr);
m_theme["notification_fg"] = Option("#ddd", "VALUE", ui ? ui->pushButtonColorNotificationFg : nullptr);
m_theme["font"] = Option("", "VALUE", ui ? ui->pushButtonFont : nullptr);
m_theme["edit_font"] = Option("", "VALUE", ui ? ui->pushButtonEditorFont : nullptr);
m_theme["find_font"] = Option("", "VALUE", ui ? ui->pushButtonFoundFont : nullptr);
m_theme["num_font"] = Option("", "VALUE", ui ? ui->pushButtonNumberFont : nullptr);
m_theme["notes_font"] = Option("", "VALUE", ui ? ui->pushButtonNotesFont : nullptr);
m_theme["notification_font"] = Option("", "VALUE", ui ? ui->pushButtonNotificationFont : nullptr);
m_theme["show_number"] = Option(true, "checked", ui ? ui->checkBoxShowNumber : nullptr);
m_theme["show_scrollbars"] = Option(true, "checked", ui ? ui->checkBoxScrollbars : nullptr);
m_theme["css"] = Option("");
m_theme["menu_css"] = Option(
"\n ;border: 1px solid ${sel_bg}"
"\n ;background: ${bg}"
"\n ;color: ${fg}"
);
m_theme["menu_bar_css"] = Option(
"\n ;background: ${bg}"
"\n ;color: ${fg}"
);
m_theme["menu_bar_selected_css"] = Option(
"\n ;background: ${sel_bg}"
"\n ;color: ${sel_fg}"
);
m_theme["menu_bar_disabled_css"] = Option(
"\n ;color: ${bg - #666}"
);
m_theme["item_css"] = Option("");
m_theme["alt_item_css"] = Option("");
m_theme["sel_item_css"] = Option("");
m_theme["hover_item_css"] = Option("");
m_theme["cur_item_css"] = Option(
"\n ;border: 0.1em solid ${sel_bg}"
);
m_theme["item_spacing"] = Option("");
m_theme["notes_css"] = Option("");
m_theme["tab_bar_css"] = Option(
"\n ;background: ${bg - #222}"
);
m_theme["tab_bar_tab_selected_css"] = Option(
"\n ;padding: 0.5em"
"\n ;background: ${bg}"
"\n ;border: 0.05em solid ${bg}"
"\n ;color: ${fg}"
);
m_theme["tab_bar_tab_unselected_css"] = Option(
"\n ;border: 0.05em solid ${bg}"
"\n ;padding: 0.5em"
"\n ;background: ${bg - #222}"
"\n ;color: ${fg - #333}"
);
m_theme["tab_bar_scroll_buttons_css"] = Option(
"\n ;background: ${bg - #222}"
"\n ;color: ${fg}"
"\n ;border: 0"
);
m_theme["tab_bar_item_counter"] = Option(
"\n ;color: ${fg - #044 + #400}"
"\n ;font-size: 6pt"
);
m_theme["tab_bar_sel_item_counter"] = Option(
"\n ;color: ${sel_bg - #044 + #400}"
);
m_theme["tab_tree_css"] = Option(
"\n ;color: ${fg}"
"\n ;background-color: ${bg}"
);
m_theme["tab_tree_sel_item_css"] = Option(
"\n ;color: ${sel_fg}"
"\n ;background-color: ${sel_bg}"
"\n ;border-radius: 2px"
);
m_theme["tab_tree_item_counter"] = Option(
"\n ;color: ${fg - #044 + #400}"
"\n ;font-size: 6pt"
);
m_theme["tab_tree_sel_item_counter"] = Option(
"\n ;color: ${sel_fg - #044 + #400}"
);
m_theme["tool_bar_css"] = Option(
"\n ;color: ${fg}"
"\n ;background-color: ${bg}"
"\n ;border: 0"
);
m_theme["tool_button_css"] = Option(
"\n ;color: ${fg}"
"\n ;background: ${bg}"
"\n ;border: 0"
"\n ;border-radius: 2px"
);
m_theme["tool_button_selected_css"] = Option(
"\n ;background: ${sel_bg - #222}"
"\n ;color: ${sel_fg}"
"\n ;border: 1px solid ${sel_bg}"
);
m_theme["tool_button_pressed_css"] = Option(
"\n ;background: ${sel_bg}"
);
m_theme["search_bar"] = Option(
"\n ;background: ${edit_bg}"
"\n ;color: ${edit_fg}"
"\n ;border: 1px solid ${alt_bg}"
"\n ;margin: 2px"
);
m_theme["search_bar_focused"] = Option(
"\n ;border: 1px solid ${sel_bg}"
);
m_theme["use_system_icons"] = Option(false, "checked", ui ? ui->checkBoxSystemIcons : nullptr);
m_theme["font_antialiasing"] = Option(true, "checked", ui ? ui->checkBoxAntialias : nullptr);
m_theme["style_main_window"] = Option(false, "checked", ui ? ui->checkBoxStyleMainWindow : nullptr);
const int iconSize = iconFontSizePixels();
m_theme["icon_size"] = Option( QString::number(iconSize) );
m_theme["css_template_items"] = Option("items");
m_theme["css_template_main_window"] = Option("main_window");
m_theme["css_template_notification"] = Option("notification");
m_theme["css_template_menu"] = Option("menu");
m_theme["num_margin"] = Option(2);
m_theme["num_sel_fg"] = Option(QString());
}
void Theme::updateTheme()
{
m_margins = QSize(2, 2);
// search style
m_searchPalette.setColor(QPalette::Base, color("find_bg"));
m_searchPalette.setColor(QPalette::Text, color("find_fg"));
m_searchFont = font("find_font");
// editor style
m_editorPalette.setColor(QPalette::Base, color("edit_bg"));
m_editorPalette.setColor(QPalette::Text, color("edit_fg"));
m_editorFont = font("edit_font");
// number style
m_showRowNumber = value("show_number").toBool();
m_rowNumberPalette.setColor(QPalette::Text, color("num_fg"));
const QString numSelFgValue = value("num_sel_fg").toString();
const QColor numSelFg =
numSelFgValue.isEmpty() ? color("sel_fg") : evalColor(numSelFgValue, *this);
m_rowNumberPalette.setColor(QPalette::HighlightedText, numSelFg);
m_rowNumberFont = font("num_font");
m_rowNumberFontMetrics = QFontMetrics(m_rowNumberFont);
const QVariant rowNumberMargin = value("num_margin");
m_rowNumberMargin = rowNumberMargin.canConvert<int>() ? rowNumberMargin.toInt() : 2;
m_antialiasing = value("font_antialiasing").toBool();
}
QSize Theme::rowNumberSize(int n) const
{
if (!m_showRowNumber)
return QSize(0, 0);
const QString number = QString::number(n + m_rowIndexFromOne);
return m_rowNumberFontMetrics.boundingRect(number).size()
+ m_margins + QSize(m_rowNumberMargin, 0);
}
void Theme::decorateBrowser(QAbstractScrollArea *c) const
{
decorateScrollArea(c);
const QString cssTemplate = value("css_template_items").toString();
c->setStyleSheet(getStyleSheet(cssTemplate));
}
bool Theme::isMainWindowThemeEnabled() const
{
return m_theme.value("style_main_window").value().toBool();
}
QString Theme::themeColorString(const QString &name) const
{
return serializeColor( color(name) );
}
QString Theme::getStyleSheet(const QString &name, Values values, int maxRecursion) const
{
const QString fileName = findThemeFile(name + ".css");
if ( fileName.isEmpty() )
return QString();
QFile file(fileName);
if ( !file.open(QIODevice::ReadOnly) ) {
log( QString("Failed to open stylesheet \"%1\": %2")
.arg(fileName, file.errorString()), LogError );
return QString();
}
const QString css = QString::fromUtf8( file.readAll() );
return parseStyleSheet(css, values, maxRecursion - 1);
}
QString Theme::parseStyleSheet(const QString &css, Values values, int maxRecursion) const
{
QString output;
const QString variableBegin("${");
const QString variableEnd("}");
for ( int i = 0; i < css.size(); ++i ) {
const int a = css.indexOf(variableBegin, i);
if (a == -1) {
output.append(css.mid(i));
break;
}
const int b = css.indexOf(variableEnd, a + variableBegin.size());
if (b == -1) {
output.append(css.mid(i));
break;
}
output.append(css.mid(i, a - i));
i = b + variableEnd.size() - 1;
const QString name = css
.mid(a + variableBegin.size(), b - a - variableBegin.size())
.trimmed();
const QString result = parsePlaceholder(name, &values, maxRecursion);
output.append(result);
}
return output;
}
QString Theme::parsePlaceholder(const QString &name, Values *values, int maxRecursion) const
{
if (maxRecursion < 0) {
log("Max recursion reached when parsing style sheet", LogError);
return QString();
}
if ( name.contains("=") ) {
const int i = name.indexOf('=');
const QString k = name.mid(0, i).trimmed();
const QString v = name.mid(i + 1).trimmed();
if (k == "scale")
(*values)[k] = 1.0;
(*values)[k] = parsePlaceholder(v, values, maxRecursion - 1);
return QString();
}
if ( name.startsWith("css:") )
return getStyleSheet(name.mid(4), *values, maxRecursion - 1);
const double scale = getFactor("scale", *values);
const QString value = this->value(name).toString();
if (name.contains("font"))
return getFontStyleSheet(value, scale);
if (name.contains("css") || value.contains(":"))
return parseStyleSheet(value, *values, maxRecursion - 1);
{
bool ok;
const double v = name.toDouble(&ok);
if (ok)
return QString::number(v * scale);
}
{
bool ok;
const double v = value.toDouble(&ok);
if (ok)
return QString::number(v * scale);
}
QColor color = evalColor(name, *this, *values);
const double saturationF = getFactor("hsv_saturation_factor", *values);
const double valueF = getFactor("hsv_value_factor", *values);
if ( !qFuzzyCompare(saturationF, 1.0) || !qFuzzyCompare(valueF, 1.0) ) {
color.setHsvF(
color.hueF(),
normalizeFactor(color.saturationF() * saturationF),
normalizeFactor(color.valueF() * valueF),
color.alphaF()
);
}
return serializeColor(color);
}
QString serializeColor(const QColor &color)
{
if (color.alpha() == 255)
return color.name();
return QString::fromLatin1("rgba(%1,%2,%3,%4)")
.arg(color.red())
.arg(color.green())
.arg(color.blue())
.arg(color.alpha());
}
QColor deserializeColor(const QString &colorName)
{
QColor color;
if ( colorName.startsWith(QStringLiteral("rgba(")) ) {
QStringList list = colorName.mid(5, colorName.indexOf(')') - 5).split(',');
int r = list.value(0).toInt();
int g = list.value(1).toInt();
int b = list.value(2).toInt();
int a = static_cast<int>( list.value(3).toDouble() * 255 );
color = QColor(r, g, b, a > 255 ? a / 255 : a);
} else if ( colorName.startsWith(QStringLiteral("default_")) ) {
const QPalette::ColorRole role = defaultColorVarToRole(colorName);
color = QPalette().color(role);
} else {
color = QColor(colorName);
}
if ( !color.isValid() )
log( QString("Failed to deserialize color \"%1\"").arg(colorName) );
return color;
}
QColor evalColor(const QString &expression, const Theme &theme, const Values &values, int maxRecursion)
{
int r = 0;
int g = 0;
int b = 0;
int a = 0;
QStringList addList = QString(expression).remove(' ').split('+');
for (const auto &add : addList) {
QStringList subList = add.split('-');
float multiply = 1;
for (const auto &sub : subList) {
addColor(sub, multiply, &r, &g, &b, &a, theme, values, maxRecursion);
multiply = -1;
}
}
return QColor(r, g, b, a);
}
QString defaultUserThemePath()
{
return QDir::cleanPath(settingsDirectoryPath() + "/themes");
}
QStringList themePaths()
{
QStringList paths;
const QByteArray customThemsPath = qgetenv("COPYQ_THEME_PREFIX");
if ( !customThemsPath.isEmpty() )
paths.append(QString::fromLocal8Bit(customThemsPath));
const QString userThemesPath = defaultUserThemePath();
QDir themesDir(userThemesPath);
if ( themesDir.mkpath(".") )
paths.append(userThemesPath);
const QString themesPath = themePrefix();
if ( !themesPath.isEmpty() )
paths.append(themesPath);
return paths;
}
QString findThemeFile(const QString &fileName)
{
for (const QString &path : themePaths()) {
const QDir dir(path);
if ( dir.exists(fileName) )
return dir.absoluteFilePath(fileName);
}
return QString();
}
| 26,030
|
C++
|
.cpp
| 654
| 33.097859
| 119
| 0.626836
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,215
|
logdialog.cpp
|
hluk_CopyQ/src/gui/logdialog.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "gui/logdialog.h"
#include "ui_logdialog.h"
#include "common/common.h"
#include "common/log.h"
#include "common/timer.h"
#include <QCheckBox>
#include <QElapsedTimer>
#include <QRegularExpression>
#include <QTextBlock>
#include <QTextCharFormat>
#include <QTextBlockFormat>
#include <QTextCursor>
#include <QTimer>
namespace {
const int maxDisplayLogSize = 128 * 1024;
const auto logLinePrefix = "CopyQ ";
void removeLogLines(QByteArray *content, LogLevel level)
{
const QByteArray label = logLinePrefix + logLevelLabel(level);
if ( content->startsWith(label) ) {
const int i = content->indexOf('\n');
if (i == -1) {
content->clear();
return;
}
content->remove(0, i);
}
const QByteArray labelLine = '\n' + label;
for (;;) {
const int i = content->indexOf(labelLine);
if (i == -1)
break;
const int j = content->indexOf('\n', i + 1);
if (j == -1) {
content->remove(i, content->size());
break;
}
content->remove(i, j - i);
}
}
} // namespace
/// Decorates document in batches so it doesn't block UI.
class Decorator : public QObject
{
public:
Decorator(const QRegularExpression &re, QObject *parent)
: QObject(parent)
, m_re(re)
{
initSingleShotTimer(&m_timerDecorate, 0, this, &Decorator::decorateBatch);
}
/// Start decorating.
void decorate(QTextDocument *document)
{
m_tc = QTextCursor(document);
m_tc.movePosition(QTextCursor::End);
decorateBatch();
}
private:
void decorateBatch()
{
if (m_tc.isNull())
return;
QElapsedTimer t;
t.start();
do {
m_tc = m_tc.document()->find(m_re, m_tc, QTextDocument::FindBackward);
if (m_tc.isNull())
return;
decorate(&m_tc);
} while ( t.elapsed() < 20 );
m_timerDecorate.start();
}
virtual void decorate(QTextCursor *tc) = 0;
QTimer m_timerDecorate;
QTextCursor m_tc;
QRegularExpression m_re;
};
namespace {
class LogDecorator final : public Decorator
{
public:
LogDecorator(const QFont &font, QObject *parent)
: Decorator(QRegularExpression("^[^\\]]*\\]"), parent)
, m_labelNote(logLevelLabel(LogNote))
, m_labelError(logLevelLabel(LogError))
, m_labelWarning(logLevelLabel(LogWarning))
, m_labelDebug(logLevelLabel(LogDebug))
, m_labelTrace(logLevelLabel(LogTrace))
{
QFont boldFont = font;
boldFont.setBold(true);
QTextCharFormat normalFormat;
normalFormat.setFont(boldFont);
normalFormat.setBackground(Qt::white);
normalFormat.setForeground(Qt::black);
m_noteLogLevelFormat = normalFormat;
m_errorLogLevelFormat = normalFormat;
m_errorLogLevelFormat.setForeground(Qt::red);
m_warningLogLevelFormat = normalFormat;
m_warningLogLevelFormat.setForeground(Qt::darkRed);
m_debugLogLevelFormat = normalFormat;
m_debugLogLevelFormat.setForeground(QColor(100, 100, 200));
m_traceLogLevelFormat = normalFormat;
m_traceLogLevelFormat.setForeground(QColor(200, 150, 100));
}
private:
void decorate(QTextCursor *tc) override
{
const QString text = tc->selectedText();
if ( text.startsWith(m_labelNote) )
tc->setCharFormat(m_noteLogLevelFormat);
else if ( text.startsWith(m_labelError) )
tc->setCharFormat(m_errorLogLevelFormat);
else if ( text.startsWith(m_labelWarning) )
tc->setCharFormat(m_warningLogLevelFormat);
else if ( text.startsWith(m_labelDebug) )
tc->setCharFormat(m_debugLogLevelFormat);
else if ( text.startsWith(m_labelTrace) )
tc->setCharFormat(m_traceLogLevelFormat);
}
QString m_labelNote;
QString m_labelError;
QString m_labelWarning;
QString m_labelDebug;
QString m_labelTrace;
QTextCharFormat m_noteLogLevelFormat;
QTextCharFormat m_errorLogLevelFormat;
QTextCharFormat m_warningLogLevelFormat;
QTextCharFormat m_debugLogLevelFormat;
QTextCharFormat m_traceLogLevelFormat;
};
class StringDecorator final : public Decorator
{
public:
explicit StringDecorator(QObject *parent)
: Decorator(QRegularExpression("\"[^\"]*\"|'[^']*'"), parent)
{
m_stringFormat.setForeground(Qt::darkGreen);
}
private:
void decorate(QTextCursor *tc) override
{
tc->setCharFormat(m_stringFormat);
}
QTextCharFormat m_stringFormat;
};
class ThreadNameDecorator final : public Decorator
{
public:
explicit ThreadNameDecorator(const QFont &font, QObject *parent)
: Decorator(QRegularExpression("<[A-Za-z]+-[0-9-]+>"), parent)
{
QFont boldFont = font;
boldFont.setBold(true);
m_format.setFont(boldFont);
}
private:
void decorate(QTextCursor *tc) override
{
// Colorize thread label.
const auto text = tc->selectedText();
const auto hash = qHash(text);
const int h = hash % 360;
m_format.setForeground( QColor::fromHsv(h, 150, 100) );
const auto bg =
text.startsWith("<Server-") ? QColor::fromRgb(255, 255, 200)
: text.startsWith("<monitor") ? QColor::fromRgb(220, 240, 255)
: text.startsWith("<provide") ? QColor::fromRgb(220, 255, 220)
: text.startsWith("<synchronize") ? QColor::fromRgb(220, 255, 240)
: QColor(Qt::white);
m_format.setBackground(bg);
tc->setCharFormat(m_format);
}
QTextCharFormat m_format;
};
} // namespace
LogDialog::LogDialog(QWidget *parent)
: QDialog(parent)
, ui(new Ui::LogDialog)
, m_showError(true)
, m_showWarning(true)
, m_showNote(true)
, m_showDebug(true)
, m_showTrace(true)
{
ui->setupUi(this);
auto font = ui->textBrowserLog->font();
font.setFamily("Monospace");
ui->textBrowserLog->setFont(font);
m_logDecorator = new LogDecorator(font, this);
m_stringDecorator = new StringDecorator(this);
m_threadNameDecorator = new ThreadNameDecorator(font, this);
ui->labelLogFileName->setText(logFileName());
addFilterCheckBox(LogError, &LogDialog::showError);
addFilterCheckBox(LogWarning, &LogDialog::showWarning);
addFilterCheckBox(LogNote, &LogDialog::showNote);
addFilterCheckBox(LogDebug, &LogDialog::showDebug);
addFilterCheckBox(LogTrace, &LogDialog::showTrace);
ui->layoutFilters->addStretch(1);
updateLog();
}
LogDialog::~LogDialog()
{
delete ui;
}
void LogDialog::updateLog()
{
QByteArray content = readLogFile(maxDisplayLogSize);
// Remove first line if incomplete.
if ( !content.startsWith(logLinePrefix) ) {
const int i = content.indexOf('\n');
content.remove(0, i + 1);
}
if(!m_showTrace)
removeLogLines(&content, LogTrace);
if(!m_showDebug)
removeLogLines(&content, LogDebug);
if(!m_showNote)
removeLogLines(&content, LogNote);
if(!m_showWarning)
removeLogLines(&content, LogWarning);
if(!m_showError)
removeLogLines(&content, LogError);
// Remove common prefix.
const QByteArray prefix = logLinePrefix;
if ( content.startsWith(prefix) )
content.remove( 0, prefix.size() );
content.replace('\n' + prefix, "\n");
ui->textBrowserLog->setPlainText(QString::fromUtf8(content));
ui->textBrowserLog->moveCursor(QTextCursor::End);
QTextDocument *doc = ui->textBrowserLog->document();
m_logDecorator->decorate(doc);
m_stringDecorator->decorate(doc);
m_threadNameDecorator->decorate(doc);
}
void LogDialog::showError(bool show)
{
m_showError = show;
updateLog();
}
void LogDialog::showWarning(bool show)
{
m_showWarning = show;
updateLog();
}
void LogDialog::showNote(bool show)
{
m_showNote = show;
updateLog();
}
void LogDialog::showDebug(bool show)
{
m_showDebug = show;
updateLog();
}
void LogDialog::showTrace(bool show)
{
m_showTrace = show;
updateLog();
}
void LogDialog::addFilterCheckBox(LogLevel level, FilterCheckBoxSlot slot)
{
auto checkBox = new QCheckBox(this);
checkBox->setText(logLevelLabel(level));
checkBox->setChecked(true);
QObject::connect(checkBox, &QCheckBox::toggled, this, slot);
ui->layoutFilters->addWidget(checkBox);
}
| 8,575
|
C++
|
.cpp
| 270
| 25.874074
| 82
| 0.662018
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,216
|
importexportdialog.cpp
|
hluk_CopyQ/src/gui/importexportdialog.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "gui/importexportdialog.h"
#include "ui_importexportdialog.h"
#include "gui/tabicons.h"
#include <QPushButton>
ImportExportDialog::ImportExportDialog(QWidget *parent)
: QDialog(parent)
, ui(new Ui::ImportExportDialog)
{
ui->setupUi(this);
connect(ui->checkBoxAll, &QCheckBox::clicked,
this, &ImportExportDialog::onCheckBoxAllClicked);
connect( ui->listTabs, &QListWidget::itemSelectionChanged,
this, &ImportExportDialog::update );
connect( ui->checkBoxConfiguration, &QCheckBox::stateChanged,
this, &ImportExportDialog::update );
connect( ui->checkBoxCommands, &QCheckBox::stateChanged,
this, &ImportExportDialog::update );
}
ImportExportDialog::~ImportExportDialog()
{
delete ui;
}
void ImportExportDialog::setTabs(const QStringList &tabs)
{
ui->listTabs->clear();
ui->listTabs->addItems(tabs);
ui->listTabs->selectAll();
const auto items = ui->listTabs->selectedItems();
for (const auto item : items)
item->setIcon( getIconForTabName(item->text()) );
const bool showTabs = ui->listTabs->count() > 0;
ui->listTabs->setVisible(showTabs);
ui->labelTabs->setVisible(showTabs);
}
void ImportExportDialog::setCurrentTab(const QString &tabName)
{
const auto items = ui->listTabs->findItems(tabName, Qt::MatchExactly);
if ( !items.isEmpty() )
ui->listTabs->setCurrentItem( items.first() );
}
void ImportExportDialog::setHasConfiguration(bool hasConfiguration)
{
ui->checkBoxConfiguration->setVisible(hasConfiguration);
}
void ImportExportDialog::setHasCommands(bool hasCommands)
{
ui->checkBoxCommands->setVisible(hasCommands);
}
void ImportExportDialog::setConfigurationEnabled(bool enabled)
{
ui->checkBoxConfiguration->setChecked(enabled);
}
void ImportExportDialog::setCommandsEnabled(bool enabled)
{
ui->checkBoxCommands->setChecked(enabled);
}
QStringList ImportExportDialog::selectedTabs() const
{
const auto items = ui->listTabs->selectedItems();
QStringList result;
result.reserve( items.size() );
for (const auto item : items)
result.append( item->text() );
return result;
}
bool ImportExportDialog::isConfigurationEnabled() const
{
return ui->checkBoxConfiguration->isChecked()
&& !ui->checkBoxConfiguration->isHidden();
}
bool ImportExportDialog::isCommandsEnabled() const
{
return ui->checkBoxCommands->isChecked()
&& !ui->checkBoxCommands->isHidden();
}
void ImportExportDialog::onCheckBoxAllClicked(bool checked)
{
ui->checkBoxConfiguration->setChecked(checked);
ui->checkBoxCommands->setChecked(checked);
if (checked)
ui->listTabs->selectAll();
else
ui->listTabs->clearSelection();
}
void ImportExportDialog::update()
{
const bool ok = canAccept();
auto button = ui->buttonBox->button(QDialogButtonBox::Ok);
if (button)
button->setEnabled(ok);
if (!ok) {
ui->checkBoxAll->setCheckState(Qt::Unchecked);
} else if ( ui->listTabs->selectedItems().count() == ui->listTabs->count()
&& (ui->checkBoxConfiguration->isChecked() || ui->checkBoxConfiguration->isHidden())
&& (ui->checkBoxCommands->isChecked() || ui->checkBoxCommands->isHidden()) )
{
ui->checkBoxAll->setCheckState(Qt::Checked);
} else {
ui->checkBoxAll->setCheckState(Qt::PartiallyChecked);
}
}
bool ImportExportDialog::canAccept() const
{
return ui->listTabs->selectionModel()->hasSelection()
|| isConfigurationEnabled()
|| isCommandsEnabled();
}
| 3,664
|
C++
|
.cpp
| 108
| 29.277778
| 100
| 0.710444
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,217
|
notificationdaemon.cpp
|
hluk_CopyQ/src/gui/notificationdaemon.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "gui/notificationdaemon.h"
#include "common/common.h"
#include "common/display.h"
#include "common/timer.h"
#include "gui/notification.h"
#include "gui/notificationbasic.h"
#include "gui/screen.h"
#ifdef WITH_NATIVE_NOTIFICATIONS
# include "gui/notificationnative/notificationnative.h"
# include <QSysInfo>
#endif
#include <QApplication>
#include <QPixmap>
#include <QPoint>
#include <QVariant>
#include <QWidget>
namespace {
const int notificationMarginPoints = 10;
int notificationMargin()
{
return pointsToPixels(notificationMarginPoints);
}
#ifdef WITH_NATIVE_NOTIFICATIONS
bool hasNativeNotifications()
{
#ifdef Q_OS_WIN
static const bool supportsNotifications =
!QSysInfo::productVersion().startsWith(QLatin1String("7"));
return supportsNotifications;
#else
return true;
#endif
}
#endif
} // namespace
NotificationDaemon::NotificationDaemon(QObject *parent)
: QObject(parent)
, m_position(BottomRight)
, m_notifications()
, m_opacity(1.0)
, m_horizontalOffsetPoints(0)
, m_verticalOffsetPoints(0)
, m_maximumWidthPoints(300)
, m_maximumHeightPoints(100)
{
initSingleShotTimer( &m_timerUpdate, 100, this, &NotificationDaemon::doUpdateNotificationWidgets );
}
NotificationDaemon::~NotificationDaemon() = default;
void NotificationDaemon::setPosition(NotificationDaemon::Position position)
{
m_position = position;
}
void NotificationDaemon::setOffset(int horizontalPoints, int verticalPoints)
{
m_horizontalOffsetPoints = horizontalPoints;
m_verticalOffsetPoints = verticalPoints;
}
void NotificationDaemon::setMaximumSize(int maximumWidthPoints, int maximumHeightPoints)
{
m_maximumWidthPoints = maximumWidthPoints;
m_maximumHeightPoints = maximumHeightPoints;
}
void NotificationDaemon::updateNotificationWidgets()
{
if ( !m_timerUpdate.isActive() )
m_timerUpdate.start();
}
void NotificationDaemon::setNotificationOpacity(qreal opacity)
{
m_opacity = opacity;
}
void NotificationDaemon::setNotificationStyleSheet(const QString &styleSheet)
{
m_styleSheet = styleSheet;
}
void NotificationDaemon::setIconColor(const QColor &color)
{
m_iconColor = color;
}
void NotificationDaemon::removeNotification(const QString &id)
{
Notification *notification = findNotification(id);
if (notification)
onNotificationClose(notification);
}
void NotificationDaemon::onNotificationClose(Notification *notification)
{
for (auto it = std::begin(m_notifications); it != std::end(m_notifications); ++it) {
if (it->notification == notification) {
m_notifications.erase(it);
break;
}
}
if (notification->widget() != nullptr)
updateNotificationWidgets();
notification->deleteLater();
}
void NotificationDaemon::doUpdateNotificationWidgets()
{
const QPoint cursor = QCursor::pos();
// Postpone update if mouse cursor is over a notification.
for (auto ¬ificationData : m_notifications) {
auto notification = notificationData.notification;
QWidget *w = notification->widget();
if ( w != nullptr && w->isVisible() && w->geometry().contains(cursor) ) {
m_timerUpdate.start();
return;
}
}
const QRect screen = screenGeometry(0);
int y = (m_position & Top) ? offsetY() : screen.bottom() - offsetY();
for (auto ¬ificationData : m_notifications) {
auto notification = notificationData.notification;
QWidget *w = notification->widget();
if (w == nullptr)
continue;
notification->setOpacity(m_opacity);
w->setStyleSheet(m_styleSheet);
w->setMaximumSize( pointsToPixels(m_maximumWidthPoints), pointsToPixels(m_maximumHeightPoints) );
notification->adjust();
// Avoid positioning a notification under mouse cursor.
QRect rect = w->geometry();
do {
int x;
if (m_position & Left)
x = offsetX();
else if (m_position & Right)
x = screen.right() - rect.width() - offsetX();
else
x = screen.right() / 2 - rect.width() / 2;
if (m_position & Bottom)
y -= rect.height();
if (m_position & Top)
y += rect.height() + notificationMargin();
else
y -= notificationMargin();
rect.moveTo(x, y);
} while( rect.contains(cursor) );
w->move(rect.topLeft());
notification->show();
}
}
Notification *NotificationDaemon::findNotification(const QString &id)
{
for (auto ¬ificationData : m_notifications) {
if (notificationData.id == id)
return notificationData.notification;
}
return nullptr;
}
Notification *NotificationDaemon::createNotification(const QString &id)
{
Notification *notification = nullptr;
if ( !id.isEmpty() )
notification = findNotification(id);
if (notification == nullptr) {
#ifdef WITH_NATIVE_NOTIFICATIONS
if (m_nativeNotificationsEnabled && hasNativeNotifications())
notification = createNotificationNative(m_iconColor, this);
else
notification = createNotificationBasic(this);
#else
notification = createNotificationBasic(this);
#endif
connect(this, &QObject::destroyed, notification, &QObject::deleteLater);
connect( notification, &Notification::closeNotification,
this, &NotificationDaemon::onNotificationClose );
connect( notification, &Notification::buttonClicked,
this, &NotificationDaemon::notificationButtonClicked );
m_notifications.append(NotificationData{id, notification});
}
if (notification->widget() != nullptr)
updateNotificationWidgets();
else
QTimer::singleShot(0, notification, &Notification::show);
return notification;
}
int NotificationDaemon::offsetX() const
{
return pointsToPixels(m_horizontalOffsetPoints);
}
int NotificationDaemon::offsetY() const
{
return pointsToPixels(m_verticalOffsetPoints);
}
| 6,192
|
C++
|
.cpp
| 186
| 27.833333
| 105
| 0.696462
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,218
|
actionhandlerdialog.cpp
|
hluk_CopyQ/src/gui/actionhandlerdialog.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "gui/actionhandlerdialog.h"
#include "ui_actionhandlerdialog.h"
#include "common/actionhandlerenums.h"
#include "gui/actionhandler.h"
#include <QSortFilterProxyModel>
#include <QSet>
namespace {
void terminateSelectedActions(QItemSelectionModel *selectionModel, ActionHandler *actionHandler)
{
QSet<int> ids;
for ( const auto &index : selectionModel->selectedIndexes() ) {
const int actionId = index.data(ActionHandlerRole::id).toInt();
ids.insert(actionId);
}
for (const int id : ids)
actionHandler->terminateAction(id);
}
void updateTerminateButton(QItemSelectionModel *selectionModel, QAbstractItemModel *model, QPushButton *button)
{
for ( const auto &index : selectionModel->selectedIndexes() ) {
const int row = index.row();
const auto statusIndex = model->index(row, 0);
const auto state = static_cast<ActionState>(statusIndex.data(ActionHandlerRole::status).toInt());
if (state == ActionState::Running || state == ActionState::Starting) {
button->setEnabled(true);
return;
}
}
button->setEnabled(false);
}
} // namespace
ActionHandlerDialog::ActionHandlerDialog(ActionHandler *actionHandler, QAbstractItemModel *model, QWidget *parent)
: QDialog(parent)
, ui(new Ui::ActionHandlerDialog)
{
ui->setupUi(this);
auto proxyModel = new QSortFilterProxyModel(this);
proxyModel->setSourceModel(model);
proxyModel->setDynamicSortFilter(true);
proxyModel->setSortRole(ActionHandlerRole::sort);
proxyModel->setFilterKeyColumn(ActionHandlerColumn::name);
ui->tableView->setModel(proxyModel);
ui->tableView->resizeColumnsToContents();
ui->tableView->sortByColumn(ActionHandlerColumn::status, Qt::DescendingOrder);
connect( ui->filterLineEdit, &QLineEdit::textChanged, proxyModel,
[proxyModel](const QString &pattern) {
#if QT_VERSION >= QT_VERSION_CHECK(5,12,0)
const QRegularExpression re(pattern, QRegularExpression::CaseInsensitiveOption);
proxyModel->setFilterRegularExpression(re);
#else
const QRegExp re(pattern, Qt::CaseInsensitive);
proxyModel->setFilterRegExp(re);
#endif
} );
const auto selectionModel = ui->tableView->selectionModel();
connect( ui->terminateButton, &QPushButton::clicked, this,
[selectionModel, actionHandler]() {
terminateSelectedActions(selectionModel, actionHandler);
} );
const auto updateTerminateButtonSlot =
[this, selectionModel, proxyModel]() {
updateTerminateButton(selectionModel, proxyModel, ui->terminateButton);
};
connect( model, &QAbstractItemModel::dataChanged, this, updateTerminateButtonSlot );
connect( selectionModel, &QItemSelectionModel::selectionChanged, this, updateTerminateButtonSlot );
}
ActionHandlerDialog::~ActionHandlerDialog()
{
delete ui;
}
| 3,040
|
C++
|
.cpp
| 71
| 36.366197
| 114
| 0.711382
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,219
|
configtabappearance.cpp
|
hluk_CopyQ/src/gui/configtabappearance.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "gui/configtabappearance.h"
#include "ui_configtabappearance.h"
#include "common/contenttype.h"
#include "common/display.h"
#include "common/mimetypes.h"
#include "common/option.h"
#include "common/temporarysettings.h"
#include "common/temporaryfile.h"
#include "common/textdata.h"
#include "common/timer.h"
#include "gui/clipboardbrowser.h"
#include "gui/clipboardbrowsershared.h"
#include "gui/iconfont.h"
#include "gui/pixelratio.h"
#include "gui/theme.h"
#include "item/itemdelegate.h"
#include "item/itemeditor.h"
#include "item/itemfilter.h"
#include <QAbstractScrollArea>
#include <QAction>
#include <QColorDialog>
#include <QFileDialog>
#include <QFontDialog>
#include <QMessageBox>
#include <QPainter>
#include <QScrollBar>
#include <QSettings>
#include <QTextCursor>
#include <QTextDocument>
#include <QTextEdit>
#include <QTemporaryFile>
#include <memory>
namespace {
class ItemFilterSimple final : public ItemFilter {
public:
explicit ItemFilterSimple(const QString &text) noexcept
: m_text(text)
{
}
QString searchString() const override { return m_text; }
bool matchesAll() const override { return false; }
bool matchesNone() const override { return false; }
bool matches(const QString &) const override { return true; }
bool matchesIndex(const QModelIndex &) const override { return true; }
void highlight(QTextEdit *edit, const QTextCharFormat &format) const override
{
QTextCursor cur = edit->document()->find(m_text);
if ( !cur.hasSelection() )
return;
QTextEdit::ExtraSelection selection{cur, format};
edit->setExtraSelections({selection});
edit->update();
}
void search(QTextEdit *, bool) const override {}
private:
QString m_text;
};
} // namespace
ConfigTabAppearance::ConfigTabAppearance(QWidget *parent)
: QWidget(parent)
, ui(new Ui::ConfigTabAppearance)
, m_theme(ui)
, m_editor()
{
ui->setupUi(this);
connect(ui->pushButtonLoadTheme, &QPushButton::clicked,
this, &ConfigTabAppearance::onPushButtonLoadThemeClicked);
connect(ui->pushButtonSaveTheme, &QPushButton::clicked,
this, &ConfigTabAppearance::onPushButtonSaveThemeClicked);
connect(ui->pushButtonResetTheme, &QPushButton::clicked,
this, &ConfigTabAppearance::onPushButtonResetThemeClicked);
connect(ui->pushButtonEditTheme, &QPushButton::clicked,
this, &ConfigTabAppearance::onPushButtonEditThemeClicked);
connect(ui->checkBoxShowNumber, &QCheckBox::stateChanged,
this, &ConfigTabAppearance::onCheckBoxShowNumberStateChanged);
connect(ui->checkBoxScrollbars, &QCheckBox::stateChanged,
this, &ConfigTabAppearance::onCheckBoxScrollbarsStateChanged);
connect(ui->checkBoxAntialias, &QCheckBox::stateChanged,
this, &ConfigTabAppearance::onCheckBoxAntialiasStateChanged);
#if QT_VERSION >= QT_VERSION_CHECK(5,14,0)
connect(ui->comboBoxThemes, &QComboBox::textActivated,
#else
connect(ui->comboBoxThemes, static_cast<void (QComboBox::*)(const QString&)>(&QComboBox::activated),
#endif
this, &ConfigTabAppearance::onComboBoxThemesActivated);
initSingleShotTimer(&m_timerPreview, 0, this, &ConfigTabAppearance::decoratePreviewNow);
// Connect signals from theme buttons.
for (auto button : ui->scrollAreaTheme->findChildren<QPushButton *>()) {
if (button->objectName().endsWith("Font"))
connect(button, &QPushButton::clicked, this, &ConfigTabAppearance::onFontButtonClicked);
else if (button->objectName().startsWith("pushButtonColor"))
connect(button, &QPushButton::clicked, this, &ConfigTabAppearance::onColorButtonClicked);
}
m_theme.resetTheme();
}
void ConfigTabAppearance::showEvent(QShowEvent *event)
{
updateThemes();
updateStyle();
ui->scrollAreaTheme->setMinimumWidth( ui->scrollAreaThemeContents->minimumSizeHint().width()
+ ui->scrollAreaTheme->verticalScrollBar()->width() + 8);
QWidget::showEvent(event);
}
ConfigTabAppearance::~ConfigTabAppearance()
{
delete ui;
}
void ConfigTabAppearance::loadTheme(const QSettings &settings)
{
m_theme.loadTheme(settings);
updateStyle();
}
void ConfigTabAppearance::saveTheme(QSettings *settings)
{
m_theme.saveTheme(settings);
settings->sync();
updateThemes();
}
void ConfigTabAppearance::createPreview(ItemFactory *itemFactory)
{
m_itemFactory = itemFactory;
decoratePreview();
}
void ConfigTabAppearance::onFontButtonClicked()
{
Q_ASSERT(sender() != nullptr);
fontButtonClicked(sender());
}
void ConfigTabAppearance::onColorButtonClicked()
{
Q_ASSERT(sender() != nullptr);
colorButtonClicked(sender());
}
void ConfigTabAppearance::onPushButtonLoadThemeClicked()
{
const QString filename = QFileDialog::getOpenFileName(this, tr("Open Theme File"),
defaultUserThemePath(), QLatin1String("*.ini"));
if ( !filename.isNull() ) {
QSettings settings(filename, QSettings::IniFormat);
loadTheme(settings);
}
}
void ConfigTabAppearance::onPushButtonSaveThemeClicked()
{
QString filename = QFileDialog::getSaveFileName(this, tr("Save Theme File As"),
defaultUserThemePath(), QLatin1String("*.ini"));
if ( !filename.isNull() ) {
if ( !filename.endsWith(".ini") )
filename.append(".ini");
QSettings settings(filename, QSettings::IniFormat);
saveTheme(&settings);
}
}
void ConfigTabAppearance::onPushButtonResetThemeClicked()
{
m_theme.resetTheme();
updateStyle();
}
void ConfigTabAppearance::onPushButtonEditThemeClicked()
{
if (m_editor.isEmpty()) {
QMessageBox::warning( this, tr("No External Editor"),
tr("Set external editor command first!") );
return;
}
TemporarySettings settings;
saveTheme(settings.settings());
QByteArray data = settings.content();
// keep ini file user friendly
data.replace("\\n",
#ifdef Q_OS_WIN
"\r\n"
#else
"\n"
#endif
);
ItemEditor *editor = new ItemEditor(data, COPYQ_MIME_PREFIX "theme", m_editor, this);
connect( editor, &ItemEditor::fileModified,
this, &ConfigTabAppearance::onThemeModified );
connect( editor, &ItemEditor::closed,
editor, &QObject::deleteLater );
if ( !editor->start() )
delete editor;
}
void ConfigTabAppearance::onCheckBoxShowNumberStateChanged(int)
{
decoratePreview();
}
void ConfigTabAppearance::onCheckBoxScrollbarsStateChanged(int)
{
decoratePreview();
}
void ConfigTabAppearance::onCheckBoxAntialiasStateChanged(int)
{
updateFontButtons();
decoratePreview();
}
void ConfigTabAppearance::onComboBoxThemesActivated(const QString &text)
{
if ( text.isEmpty() )
return;
const QString fileName = findThemeFile(text + ".ini");
QSettings settings(fileName, QSettings::IniFormat);
loadTheme(settings);
}
void ConfigTabAppearance::onThemeModified(const QByteArray &bytes)
{
QTemporaryFile tmpfile;
if ( !openTemporaryFile(&tmpfile, ".ini") )
return;
tmpfile.write(bytes);
tmpfile.flush();
QSettings settings(tmpfile.fileName(), QSettings::IniFormat);
loadTheme(settings);
}
void ConfigTabAppearance::updateThemes()
{
// Add themes in combo box.
ui->comboBoxThemes->clear();
ui->comboBoxThemes->addItem(QString());
for (const QString &path : themePaths())
addThemes(path);
}
void ConfigTabAppearance::addThemes(const QString &path)
{
const QDir::Filters filters = QDir::Files | QDir::Readable;
const QStringList nameFilters("*.ini");
QDir dir(path);
for ( const auto &fileInfo :
dir.entryInfoList(nameFilters, filters, QDir::Name) )
{
const QString name = fileInfo.baseName();
if ( ui->comboBoxThemes->findText(name) == -1 ) {
const QIcon icon = createThemeIcon( dir.absoluteFilePath(fileInfo.fileName()) );
ui->comboBoxThemes->addItem(icon, name);
}
}
}
void ConfigTabAppearance::updateStyle()
{
if ( !isVisible() )
return;
updateColorButtons();
updateFontButtons();
decoratePreview();
}
void ConfigTabAppearance::fontButtonClicked(QObject *button)
{
QFont font = m_theme.themeFontFromString( button->property("VALUE").toString() );
QFontDialog dialog(this);
dialog.setOption(QFontDialog::DontUseNativeDialog);
// WORKAROUND: DontUseNativeDialog must be set before current font (QTBUG-79637).
dialog.setCurrentFont(font);
if ( dialog.exec() == QDialog::Accepted ) {
font = dialog.selectedFont();
button->setProperty( "VALUE", font.toString() );
decoratePreview();
updateFontButtons();
}
}
void ConfigTabAppearance::colorButtonClicked(QObject *button)
{
QColor color = evalColor( button->property("VALUE").toString(), m_theme );
QColorDialog dialog(this);
dialog.setOptions(dialog.options() | QColorDialog::ShowAlphaChannel | QColorDialog::DontUseNativeDialog);
dialog.setCurrentColor(color);
if ( dialog.exec() == QDialog::Accepted ) {
color = dialog.selectedColor();
button->setProperty( "VALUE", serializeColor(color) );
decoratePreview();
const QSize iconSize = button->property("iconSize").toSize();
QPixmap pix(iconSize);
pix.fill(color);
button->setProperty("icon", QIcon(pix));
updateFontButtons();
}
}
void ConfigTabAppearance::updateColorButtons()
{
if ( !isVisible() )
return;
/* color indicating icons for color buttons */
const QSize iconSize = ui->pushButtonColorFg->iconSize();
QPixmap pix(iconSize);
QList<QPushButton *> buttons =
ui->scrollAreaTheme->findChildren<QPushButton *>(QRegularExpression("^pushButtonColor"));
for (auto button : buttons) {
QColor color = evalColor( button->property("VALUE").toString(), m_theme );
pix.fill(color);
button->setIcon(pix);
button->setIconSize(pix.size());
}
}
void ConfigTabAppearance::updateFontButtons()
{
if ( !isVisible() )
return;
const int iconExtent = pointsToPixels(12, this);
const QSize iconSize(iconExtent * 2, iconExtent);
const auto ratio = pixelRatio(ui->scrollAreaTheme);
QPixmap pix(iconSize * ratio);
pix.setDevicePixelRatio(ratio);
const QRect textRect( QPoint(0, 0), iconSize );
const QRegularExpression re("^pushButton(.*)Font$");
QList<QPushButton *> buttons = ui->scrollAreaTheme->findChildren<QPushButton *>(re);
for (auto button : buttons) {
const auto m = re.match(button->objectName());
Q_ASSERT(m.hasMatch());
const QString colorButtonName = "pushButtonColor" + m.captured(1);
QPushButton *buttonFg = ui->scrollAreaTheme->findChild<QPushButton *>(colorButtonName + "Fg");
QColor colorFg = (buttonFg == nullptr) ? m_theme.color("fg")
: evalColor( buttonFg->property("VALUE").toString(), m_theme );
QPushButton *buttonBg = ui->scrollAreaTheme->findChild<QPushButton *>(colorButtonName + "Bg");
QColor colorBg = (buttonBg == nullptr) ? m_theme.color("bg")
: evalColor( buttonBg->property("VALUE").toString(), m_theme );
pix.fill(colorBg);
QPainter painter(&pix);
painter.setPen(colorFg);
QFont font = m_theme.themeFontFromString( button->property("VALUE").toString() );
painter.setFont(font);
painter.drawText( textRect, Qt::AlignCenter,
tr("Abc", "Preview text for font settings in appearance dialog") );
button->setIcon(pix);
button->setIconSize(iconSize);
}
}
QIcon ConfigTabAppearance::createThemeIcon(const QString &fileName)
{
QSettings settings(fileName, QSettings::IniFormat);
Theme theme(settings);
QPixmap pix(16, 16);
pix.fill(Qt::black);
QPainter p(&pix);
QRect rect(1, 1, 14, 5);
p.setPen(Qt::NoPen);
p.setBrush( theme.color("sel_bg") );
p.drawRect(rect);
rect.translate(0, 5);
p.setBrush( theme.color("bg") );
p.drawRect(rect);
rect.translate(0, 5);
p.setBrush( theme.color("alt_bg") );
p.drawRect(rect);
QLine line;
line = QLine(2, 3, 14, 3);
QPen pen;
p.setOpacity(0.6);
pen.setColor( theme.color("sel_fg") );
pen.setDashPattern(QVector<qreal>() << 2 << 1 << 1 << 1 << 3 << 1 << 2 << 10);
p.setPen(pen);
p.drawLine(line);
line.translate(0, 5);
pen.setColor( theme.color("fg") );
pen.setDashPattern(QVector<qreal>() << 2 << 1 << 4 << 10);
p.setPen(pen);
p.drawLine(line);
line.translate(0, 5);
pen.setDashPattern(QVector<qreal>() << 3 << 1 << 2 << 1);
p.setPen(pen);
p.drawLine(line);
return pix;
}
void ConfigTabAppearance::decoratePreview()
{
m_timerPreview.start();
}
void ConfigTabAppearance::decoratePreviewNow()
{
if ( !m_itemFactory || !isVisible() )
return;
if (m_preview) {
delete m_preview;
m_preview = nullptr;
}
m_theme.updateTheme();
const auto sharedData = std::make_shared<ClipboardBrowserShared>();
sharedData->itemFactory = m_itemFactory;
sharedData->theme = m_theme;
auto c = new ClipboardBrowser(QString(), sharedData, this);
m_preview = c;
m_theme.decorateBrowser(c);
ui->browserParentLayout->addWidget(c);
const QString searchFor = tr("item", "Search expression in preview in Appearance tab.");
c->add( tr("Search string is %1.").arg(quoteString(searchFor)) );
c->add( tr("Select an item and\npress F2 to edit.") );
for (int i = 1; i <= 20; ++i)
c->add( tr("Example item %1").arg(i), -1 );
QAbstractItemModel *model = c->model();
QModelIndex index = model->index(0, 0);
QVariantMap dataMap;
dataMap.insert( mimeItemNotes, tr("Some random notes (Shift+F2 to edit)").toUtf8() );
model->setData(index, dataMap, contentType::updateData);
// Highlight found text but don't filter out any items.
c->filterItems(std::make_shared<ItemFilterSimple>(searchFor));
QAction *act;
act = new QAction(c);
act->setShortcut( QKeySequence(QLatin1String("Shift+F2")) );
connect(act, &QAction::triggered, c, &ClipboardBrowser::editNotes);
c->addAction(act);
act = new QAction(c);
act->setShortcut( QKeySequence(QLatin1String("F2")) );
connect(act, &QAction::triggered, c, &ClipboardBrowser::editSelected);
c->addAction(act);
}
| 14,855
|
C++
|
.cpp
| 405
| 30.965432
| 109
| 0.680602
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,220
|
configtabtabs.cpp
|
hluk_CopyQ/src/gui/configtabtabs.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "configtabtabs.h"
#include "common/appconfig.h"
#include "common/tabs.h"
#include "gui/iconfactory.h"
#include "gui/itemorderlist.h"
#include "gui/tabicons.h"
#include "gui/tabpropertieswidget.h"
#include <QSettings>
#include <QVBoxLayout>
Q_DECLARE_METATYPE(TabProperties)
namespace {
class TabItem final : public ItemOrderList::Item {
public:
TabItem(const TabProperties &tab, ItemOrderList *parentList)
: m_tabProperties(tab)
, m_parentList(parentList)
{
}
QVariant data() const override
{
return QVariant::fromValue(m_tabProperties);
}
private:
QWidget *createWidget(QWidget *parent) override
{
auto widget = new TabPropertiesWidget(parent);
widget->setTabName(m_tabProperties.name);
widget->setIconName(m_tabProperties.iconName);
widget->setMaxItemCount(m_tabProperties.maxItemCount);
widget->setStoreItems(m_tabProperties.storeItems);
QObject::connect( widget, &TabPropertiesWidget::iconNameChanged,
[&](const QString &icon) { m_tabProperties.iconName = icon; } );
QObject::connect( widget, &TabPropertiesWidget::maxItemCountChanged,
[&](int count) { m_tabProperties.maxItemCount = count; } );
QObject::connect( widget, &TabPropertiesWidget::storeItemsChanged,
[&](bool store) { m_tabProperties.storeItems = store; } );
QObject::connect(
widget, &TabPropertiesWidget::iconNameChanged,
m_parentList, [&] (const QString &iconName) {
const auto row = m_parentList->currentRow();
const auto icon = iconName.isEmpty() ? QIcon() : iconFromFile(iconName);
m_parentList->setItemIcon(row, icon);
}
);
return widget;
}
TabProperties m_tabProperties;
ItemOrderList *m_parentList;
};
} // namespace
ConfigTabTabs::ConfigTabTabs(QWidget *parent)
: QWidget(parent)
, m_list(new ItemOrderList(this))
{
m_list->setItemsMovable(true);
auto layout = new QVBoxLayout(this);
layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(m_list);
const Tabs tabs;
for (const auto &name : AppConfig().option<Config::tabs>()) {
const auto icon = getIconForTabName(name);
ItemOrderList::ItemPtr item(new TabItem(tabs.tabProperties(name), m_list));
m_list->appendItem(name, icon, item);
}
}
void ConfigTabTabs::saveTabs(QSettings *settings)
{
Tabs tabs;
QStringList tabList;
for (int row = 0; row < m_list->itemCount(); ++row) {
const auto name = m_list->itemLabel(row);
if (name.isEmpty())
continue;
tabList.append(name);
tabs.setTabProperties( m_list->data(row).value<TabProperties>() );
}
tabs.save(settings, tabList);
AppConfig().setOption("tabs", tabList);
}
| 2,962
|
C++
|
.cpp
| 80
| 30.1875
| 90
| 0.65921
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,221
|
commandwidget.cpp
|
hluk_CopyQ/src/gui/commandwidget.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "commandwidget.h"
#include "ui_commandwidget.h"
#include "common/appconfig.h"
#include "common/command.h"
#include "common/mimetypes.h"
#include "common/shortcuts.h"
#include "gui/iconfactory.h"
#include "gui/icons.h"
#include "gui/shortcutdialog.h"
#include "gui/tabicons.h"
#include "item/itemfactory.h"
#include "platform/platformnativeinterface.h"
#include <QAction>
#include <QFontMetrics>
#include <QMenu>
namespace {
const QIcon iconClipboard() { return getIcon("", IconClipboard); }
const QIcon iconMenu() { return getIcon("", IconBars); }
const QIcon iconScript() { return getIcon("", IconGear); }
const QIcon iconDisplay() { return getIcon("", IconEye); }
#ifdef COPYQ_GLOBAL_SHORTCUTS
const QIcon iconShortcut() { return getIcon("", IconKeyboard); }
#endif
QStringList serializeShortcuts(const QList<QKeySequence> &shortcuts)
{
if ( shortcuts.isEmpty() )
return QStringList();
QStringList shortcutTexts;
shortcutTexts.reserve( shortcuts.size() );
for (const auto &shortcut : shortcuts)
shortcutTexts.append(portableShortcutText(shortcut));
return shortcutTexts;
}
void deserializeShortcuts(
const QStringList &serializedShortcuts, ShortcutButton *shortcutButton)
{
shortcutButton->resetShortcuts();
for (const auto &shortcutText : serializedShortcuts)
shortcutButton->addShortcut(shortcutText);
}
} // namespace
CommandWidget::CommandWidget(QWidget *parent)
: QWidget(parent)
, ui(new Ui::CommandWidget)
{
ui->setupUi(this);
connect(ui->lineEditName, &QLineEdit::textChanged,
this, &CommandWidget::onLineEditNameTextChanged);
connect(ui->buttonIcon, &IconSelectButton::currentIconChanged,
this, &CommandWidget::onButtonIconCurrentIconChanged);
connect(ui->checkBoxShowAdvanced, &QCheckBox::stateChanged,
this, &CommandWidget::onCheckBoxShowAdvancedStateChanged);
for (auto checkBox : findChildren<QCheckBox *>()) {
connect(checkBox, &QCheckBox::stateChanged,
this, &CommandWidget::updateWidgets);
}
for (auto button : findChildren<QToolButton *>()) {
connect(button, &QToolButton::toggled,
this, &CommandWidget::updateWidgets);
}
for (auto lineEdit : findChildren<QLineEdit *>()) {
connect(lineEdit, &QLineEdit::textEdited,
this, &CommandWidget::updateWidgets);
}
connect(ui->shortcutButtonGlobalShortcut, &ShortcutButton::shortcutAdded,
this, &CommandWidget::updateWidgets);
connect(ui->shortcutButtonGlobalShortcut, &ShortcutButton::shortcutRemoved,
this, &CommandWidget::updateWidgets);
connect(ui->commandEdit, &CommandEdit::changed,
this, &CommandWidget::updateWidgets);
connect(ui->commandEdit, &CommandEdit::commandTextChanged,
this, &CommandWidget::onCommandEditCommandTextChanged);
updateWidgets();
#ifdef COPYQ_GLOBAL_SHORTCUTS
ui->toolButtonGlobalShortcut->setIcon(iconShortcut());
#else
ui->toolButtonGlobalShortcut->hide();
ui->shortcutButtonGlobalShortcut->hide();
#endif
ui->toolButtonAutomatic->setIcon(iconClipboard());
ui->toolButtonInMenu->setIcon(iconMenu());
ui->toolButtonIsScript->setIcon(iconScript());
ui->toolButtonDisplay->setIcon(iconDisplay());
// Add tab names to combo boxes.
initTabComboBox(ui->comboBoxCopyToTab);
initTabComboBox(ui->comboBoxOutputTab);
if ( !platformNativeInterface()->canGetWindowTitle() )
ui->lineEditWindow->hide();
}
CommandWidget::~CommandWidget()
{
delete ui;
}
Command CommandWidget::command() const
{
Command c;
c.name = ui->lineEditName->text();
c.re = QRegularExpression( ui->lineEditMatch->text() );
c.wndre = QRegularExpression( ui->lineEditWindow->text() );
c.matchCmd = ui->lineEditMatchCmd->command();
c.cmd = ui->commandEdit->command();
c.sep = ui->lineEditSeparator->text();
c.input = ui->comboBoxInputFormat->currentText();
c.output = ui->comboBoxOutputFormat->currentText();
c.wait = ui->checkBoxWait->isChecked();
c.automatic = ui->toolButtonAutomatic->isChecked();
c.display = ui->toolButtonDisplay->isChecked();
c.inMenu = ui->toolButtonInMenu->isChecked();
c.isGlobalShortcut = ui->toolButtonGlobalShortcut->isChecked();
c.isScript = ui->toolButtonIsScript->isChecked();
c.transform = ui->checkBoxTransform->isChecked();
c.remove = ui->checkBoxIgnore->isChecked();
c.hideWindow = ui->checkBoxHideWindow->isChecked();
c.enable = true;
c.icon = ui->buttonIcon->currentIcon();
c.shortcuts = serializeShortcuts( ui->shortcutButton->shortcuts() );
c.globalShortcuts = serializeShortcuts( ui->shortcutButtonGlobalShortcut->shortcuts() );
c.tab = ui->comboBoxCopyToTab->currentText();
c.outputTab = ui->comboBoxOutputTab->currentText();
c.internalId = m_internalId;
return c;
}
void CommandWidget::setCommand(const Command &c)
{
m_internalId = c.internalId;
const bool isEditable = !m_internalId.startsWith(QLatin1String("copyq_"));
ui->scrollAreaWidgetContents->setEnabled(isEditable);
ui->commandEdit->setReadOnly(!isEditable);
ui->lineEditName->setReadOnly(!isEditable);
ui->lineEditName->setText(c.name);
ui->lineEditMatch->setText( c.re.pattern() );
ui->lineEditWindow->setText( c.wndre.pattern() );
ui->lineEditMatchCmd->setCommand(c.matchCmd);
ui->commandEdit->setCommand(c.cmd);
ui->lineEditSeparator->setText(c.sep);
ui->comboBoxInputFormat->setEditText(c.input);
ui->comboBoxOutputFormat->setEditText(c.output);
ui->checkBoxWait->setChecked(c.wait);
ui->toolButtonAutomatic->setChecked(c.automatic);
ui->toolButtonDisplay->setChecked(c.display);
ui->toolButtonInMenu->setChecked(c.inMenu);
ui->toolButtonGlobalShortcut->setChecked(c.isGlobalShortcut);
ui->toolButtonIsScript->setChecked(c.isScript);
ui->checkBoxTransform->setChecked(c.transform);
ui->checkBoxIgnore->setChecked(c.remove);
ui->checkBoxHideWindow->setChecked(c.hideWindow);
ui->buttonIcon->setCurrentIcon(c.icon);
deserializeShortcuts(c.shortcuts, ui->shortcutButton);
deserializeShortcuts(
c.globalShortcuts,
ui->shortcutButtonGlobalShortcut);
ui->comboBoxCopyToTab->setEditText(c.tab);
ui->comboBoxOutputTab->setEditText(c.outputTab);
if (c.cmd.isEmpty())
ui->tabWidget->setCurrentWidget(ui->tabAdvanced);
}
void CommandWidget::setFormats(const QStringList &formats)
{
setComboBoxItems(ui->comboBoxInputFormat, formats);
setComboBoxItems(ui->comboBoxOutputFormat, formats);
}
void CommandWidget::showEvent(QShowEvent *event)
{
const AppConfig appConfig;
const bool showAdvanced = appConfig.option<Config::show_advanced_command_settings>();
ui->checkBoxShowAdvanced->setChecked(showAdvanced);
QWidget::showEvent(event);
}
void CommandWidget::onLineEditNameTextChanged(const QString &text)
{
emit nameChanged(text);
}
void CommandWidget::onButtonIconCurrentIconChanged()
{
emitIconChanged();
}
void CommandWidget::onCheckBoxShowAdvancedStateChanged(int state)
{
setShowAdvanced(state == Qt::Checked);
}
void CommandWidget::onCommandEditCommandTextChanged(const QString &command)
{
emit commandTextChanged(command);
}
void CommandWidget::updateWidgets()
{
const bool isScript = ui->toolButtonIsScript->isChecked();
const bool isAutomatic = !isScript
&& (ui->toolButtonAutomatic->isChecked() || ui->toolButtonDisplay->isChecked());
const bool inMenu = !isScript && ui->toolButtonInMenu->isChecked();
const bool isGlobalShortcut = !isScript && ui->toolButtonGlobalShortcut->isChecked();
const bool copyOrExecute = inMenu || isAutomatic;
ui->toolButtonAutomatic->setVisible(!isScript);
ui->toolButtonDisplay->setVisible(!isScript);
ui->toolButtonInMenu->setVisible(!isScript);
ui->toolButtonGlobalShortcut->setVisible(!isScript);
ui->toolButtonIsScript->setVisible(!isAutomatic && !inMenu && !isGlobalShortcut);
ui->widgetGlobalShortcut->setVisible(isGlobalShortcut);
ui->widgetMenuShortcut->setVisible(inMenu);
ui->groupBoxMatchItems->setVisible(copyOrExecute);
ui->groupBoxAction->setVisible(copyOrExecute);
ui->groupBoxInMenu->setVisible(inMenu);
ui->groupBoxCommandOptions->setHidden(!copyOrExecute || ui->commandEdit->isEmpty());
ui->labelDescription->setText(description());
updateShowAdvanced();
emitIconChanged();
}
void CommandWidget::updateShowAdvanced()
{
ui->widgetCommandType->setVisible(m_showAdvanced);
ui->tabWidget->setVisible(m_showAdvanced);
ui->labelDescription->setVisible(m_showAdvanced);
// Hide the Advanced tab if there are no visible widgets.
const auto advancedTabWidgets = ui->tabAdvanced->findChildren<QGroupBox*>();
const auto showAdvancedTab = std::any_of(
std::begin(advancedTabWidgets), std::end(advancedTabWidgets), [](const QGroupBox *w) {
return !w->isHidden();
});
ui->tabWidget->setTabEnabled(1, showAdvancedTab);
}
void CommandWidget::setShowAdvanced(bool showAdvanced)
{
if (m_showAdvanced == showAdvanced)
return;
m_showAdvanced = showAdvanced;
AppConfig appConfig;
appConfig.setOption(Config::show_advanced_command_settings::name(), showAdvanced);
updateShowAdvanced();
}
void CommandWidget::emitIconChanged()
{
emit iconChanged();
}
QString CommandWidget::description() const
{
const Command cmd = command();
if (cmd.type() & CommandType::Script)
return "<b>Extends scripting</b> or command line.";
if (cmd.type() & CommandType::Display)
return "Changes <b>visual</b> item representation.";
QString description("<table><tr><td>");
if (cmd.type() & CommandType::Automatic) {
description.append("On <b>clipboard change</b>");
} else if (cmd.type() & CommandType::GlobalShortcut) {
description.append("On <b>global shortcut</b>");
} else if (cmd.type() & CommandType::Menu) {
description.append("On <b>menu item or application shortcut</b>");
}
if ( !(cmd.type() & CommandType::GlobalShortcut) ) {
if (cmd.input.isEmpty() || cmd.input == mimeText)
description.append( QLatin1String("<div><b>input format:</b> text</div>") );
else if (cmd.input == "!OUTPUT")
description.append( QString::fromLatin1("<div><b>input format NOT:</b> %1</div>").arg(cmd.output) );
else
description.append( QString::fromLatin1("<div><b>input format:</b> %1</div>").arg(cmd.input) );
}
description.append("</td><td width=15></td><td>");
const bool isAutomaticOrMenu = cmd.type() & (CommandType::Automatic | CommandType::Menu);
if ( !cmd.re.pattern().isEmpty() && isAutomaticOrMenu ) {
description.append(
QString::fromLatin1("<div>if text matches <b>/%1/</b></div>").arg(cmd.re.pattern()) );
}
if ( !cmd.wndre.pattern().isEmpty() && cmd.type() & CommandType::Automatic ) {
description.append(
QString::fromLatin1("<div>if current window title matches <b>/%1/</b></div>").arg(cmd.wndre.pattern()) );
}
if ( !cmd.matchCmd.isEmpty() && isAutomaticOrMenu )
description.append("<div>if <b>filter</b> command succeeds</div>");
description.append("</td><td width=15></td><td>");
if (cmd.wait) {
description.append("<div><b>shows action dialog</b></div>");
} else if ( !cmd.cmd.isEmpty() && isAutomaticOrMenu ) {
if ( !cmd.output.isEmpty() )
description.append( QString::fromLatin1("<div><b>output format:</b> %1</div>").arg(cmd.output) );
if ( !cmd.outputTab.isEmpty() )
description.append( QString::fromLatin1("<div><b>output tab:</b> %1</div>").arg(cmd.outputTab) );
}
if ( !cmd.tab.isEmpty() && cmd.type() & CommandType::Automatic )
description.append( QString::fromLatin1("<div>saves clipboard in tab <b>%1</b></div>").arg(cmd.tab) );
if (cmd.remove) {
if ( cmd.type() & CommandType::Automatic )
description.append("<div><b>ignores clipboard</b></div>");
else if ( cmd.type() & CommandType::Menu )
description.append("<div><b>removes</b> items</div>");
} else if (cmd.transform) {
if ( cmd.type() & CommandType::Automatic )
description.append("<div><b>replaces data</b></div>");
else if ( cmd.type() & CommandType::Menu )
description.append("<div><b>replaces selected items</b></div>");
}
if (cmd.hideWindow && cmd.type() & CommandType::Menu )
description.append("<br/><b>closes</b> main window");
description.append("</td></tr></table>");
return description;
}
| 12,886
|
C++
|
.cpp
| 296
| 38.199324
| 117
| 0.700631
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,222
|
screen.cpp
|
hluk_CopyQ/src/gui/screen.cpp
|
#include "screen.h"
#include <QApplication>
#include <QScreen>
#include <QWidget>
#include <QWindow>
#if QT_VERSION < QT_VERSION_CHECK(5,11,0)
# include <QDesktopWidget>
#endif
namespace {
QScreen *screenFromNumber(int i)
{
const auto screens = QGuiApplication::screens();
if (i < 0 || i >= screens.size())
return nullptr;
return screens[i];
}
} // namespace
int screenCount()
{
return QGuiApplication::screens().size();
}
int screenNumberAt(const QPoint &pos)
{
#if QT_VERSION >= QT_VERSION_CHECK(5,11,0)
auto screen = QGuiApplication::screenAt(pos);
if (screen == nullptr)
screen = QGuiApplication::primaryScreen();
return QGuiApplication::screens().indexOf(screen);
#else
return QApplication::desktop()->screenNumber(pos);
#endif
}
QRect screenGeometry(int i)
{
#if QT_VERSION >= QT_VERSION_CHECK(5,11,0)
auto screen = screenFromNumber(i);
return screen ? screen->availableGeometry() : QRect();
#else
return QApplication::desktop()->screenGeometry(i);
#endif
}
QRect screenAvailableGeometry(const QWidget &w)
{
#if QT_VERSION >= QT_VERSION_CHECK(5,11,0)
auto screen = QGuiApplication::screenAt(w.pos());
return screen ? screen->availableGeometry() : screenGeometry(0);
#else
return QApplication::desktop()->availableGeometry(w.pos());
#endif
}
| 1,330
|
C++
|
.cpp
| 50
| 23.98
| 68
| 0.721479
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,223
|
actionhandler.cpp
|
hluk_CopyQ/src/gui/actionhandler.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "actionhandler.h"
#include "common/appconfig.h"
#include "common/action.h"
#include "common/actiontablemodel.h"
#include "common/common.h"
#include "common/contenttype.h"
#include "common/display.h"
#include "common/log.h"
#include "common/mimetypes.h"
#include "common/textdata.h"
#include "gui/actionhandlerdialog.h"
#include "gui/icons.h"
#include "gui/notification.h"
#include "gui/notificationdaemon.h"
#include "gui/clipboardbrowser.h"
#include "gui/mainwindow.h"
#include "item/serialize.h"
#include <QDialog>
#include <cmath>
namespace {
QString actionDescription(const Action &action)
{
const auto name = action.name();
if ( !name.isEmpty() )
return QStringLiteral("Command \"%1\"").arg(name);
return action.commandLine();
}
} // namespace
ActionHandler::ActionHandler(NotificationDaemon *notificationDaemon, QObject *parent)
: QObject(parent)
, m_notificationDaemon(notificationDaemon)
, m_actionModel(new ActionTableModel(parent))
{
}
void ActionHandler::setMaxRowCount(uint rows)
{
m_actionModel->setMaxRowCount(rows);
}
void ActionHandler::showProcessManagerDialog(QWidget *parent)
{
auto dialog = new ActionHandlerDialog(this, m_actionModel, parent);
dialog->setAttribute(Qt::WA_DeleteOnClose, true);
dialog->show();
}
void ActionHandler::addFinishedAction(const QString &name)
{
m_actionModel->actionFinished(name);
}
QVariantMap ActionHandler::actionData(int id) const
{
const auto action = m_actions.value(id);
return action ? action->data() : QVariantMap();
}
void ActionHandler::setActionData(int id, const QVariantMap &data)
{
const auto action = m_actions.value(id);
if (action)
action->setData(data);
}
void ActionHandler::internalAction(Action *action)
{
this->action(action);
if ( m_actions.contains(action->id()) )
m_internalActions.insert(action->id());
}
bool ActionHandler::isInternalActionId(int id) const
{
return m_internalActions.contains(id);
}
void ActionHandler::action(Action *action)
{
action->setParent(this);
connect( action, &Action::actionStarted,
m_actionModel, &ActionTableModel::actionStarted );
connect( action, &Action::actionFinished,
this, &ActionHandler::closeAction );
const int id = m_actionModel->actionAboutToStart(action);
action->setId(id);
m_actions.insert(id, action);
COPYQ_LOG( QStringLiteral("Executing: %1").arg(actionDescription(*action)) );
action->start();
}
void ActionHandler::terminateAction(int id)
{
Action *action = m_actions.value(id);
if (action)
action->terminate();
}
void ActionHandler::closeAction(Action *action)
{
m_actions.remove(action->id());
m_internalActions.remove(action->id());
if ( action->actionFailed() ) {
const auto msg = tr("Error: %1").arg(action->errorString());
showActionErrors(action, msg, IconCircleExclamation);
#ifdef Q_OS_WIN
// FIXME: Ignore specific exit code for clipboard monitor on Windows when logging out.
} else if ( action->exitCode() == 1073807364 ) {
COPYQ_LOG( QStringLiteral("Exit code %1 (on logout?) with command: %2")
.arg(action->exitCode())
.arg(action->commandLine()) );
#endif
} else if ( action->exitCode() != 0 ) {
const auto msg = tr("Exit code: %1").arg(action->exitCode());
showActionErrors(action, msg, IconCircleXmark);
}
m_actionModel->actionFinished(action);
Q_ASSERT(runningActionCount() >= 0);
action->deleteLater();
}
void ActionHandler::showActionErrors(Action *action, const QString &message, ushort icon)
{
m_actionModel->actionFailed(action, message);
QtPrivate::QHashCombine hash;
const auto notificationId = QString::number( hash(hash(0, action->commandLine()), message) );
if ( m_notificationDaemon->findNotification(notificationId) )
return;
auto msg = message;
if ( !action->errorOutput().isEmpty() )
msg.append( "\n" + action->errorOutput() );
const int maxWidthPoints =
AppConfig().option<Config::notification_maximum_width>();
const QString command = action->commandLine()
.replace(QLatin1String("copyq eval --"), QLatin1String("copyq:"));
const QString name = action->name().isEmpty()
? QString(command).replace('\n', QLatin1String(" "))
: action->name();
const QString format = tr("Command %1").arg(quoteString("%1"));
const QString title = elideText(name, QFont(), format, pointsToPixels(maxWidthPoints));
// Print command with line numbers.
int lineNumber = 0;
const auto lines = command.split("\n");
const auto lineNumberWidth = static_cast<int>(std::log10(lines.size())) + 1;
for (const auto &line : lines)
msg.append(QStringLiteral("\n%1. %2").arg(++lineNumber, lineNumberWidth).arg(line));
log(QStringLiteral("%1\n%2").arg(title, msg));
auto notification = m_notificationDaemon->createNotification(notificationId);
notification->setTitle(title);
notification->setMessage(msg, Qt::PlainText);
notification->setIcon(icon);
}
| 5,206
|
C++
|
.cpp
| 142
| 32.309859
| 97
| 0.702703
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,224
|
commandhelpbutton.cpp
|
hluk_CopyQ/src/gui/commandhelpbutton.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "commandhelpbutton.h"
#include "common/display.h"
#include "common/textdata.h"
#include "gui/iconfactory.h"
#include "gui/icons.h"
#include "gui/windowgeometryguard.h"
#include "scriptable/commandhelp.h"
#include <QDialog>
#include <QDialogButtonBox>
#include <QPalette>
#include <QTextBrowser>
#include <QTextDocument>
#include <QToolButton>
#include <QVBoxLayout>
namespace {
const auto htmlTemplate = R"(
<html>
<head>
<style type="text/css">
.args{font-family:monospace}
.example{font-family:monospace; margin:1em}
.example-box{background:#777; padding-right:1em}
.example-margin{padding-right:.5em}
.description{margin: 0 2em 0 2em}
</style>
</head>
<body>
%1
</body>
</html>)";
const auto htmlExampleTemplate = R"(
<table class="example"><tr>
<td class="example-box"></td>
<td class="example-margin"></td>
<td>%1</td>
</tr></table>
)";
QString example(const QString &content)
{
return QString(htmlExampleTemplate)
.arg( escapeHtml(content) );
}
QString help()
{
auto help = QString()
+ "<p>"
+ escapeHtml( CommandHelpButton::tr(
"Command contains list of programs with arguments which will be executed. For example:") )
+ example("copyq add \"1 + 2 = 3\"; copyq show\ncopyq popup \"1 + 2\" \"= 3\"")
+ " "
+ escapeHtml( CommandHelpButton::tr(
"Program argument %1 will be substituted for item text.") )
+ "</p>"
+ "<p>"
+ escapeHtml( CommandHelpButton::tr(
"Character %1 can be used to pass standard output to the next program.") )
.arg("<b>|</b>")
+ "</p>"
+ "<p>"
+ escapeHtml( CommandHelpButton::tr(
"Following syntax can be used to pass rest of the command as single parameter.") )
+ example("perl:\nprint(\"1 + 2 = \", 1 + 2);\nprint(\"; 3 * 4 = \", 3 * 4);")
+ escapeHtml( CommandHelpButton::tr(
"This gives same output as %1 but is more useful for longer commands.") )
.arg( example("perl -e 'print(\"1 + 2 = \", 1 + 2); print(\"; 3 * 4 = \", 3 * 4);'") )
+ "</p>"
;
help.append( "<p>" + escapeHtml(
CommandHelpButton::tr("Functions listed below can be used as in following commands.")) + "</p>" );
const QString tabName = CommandHelpButton::tr("&clipboard", "Example tab name");
help.append( example("copyq show '" + tabName + "'") );
help.append( example("copyq eval 'show(\"" + tabName + "\")'") );
help.append( example("copyq: show('" + tabName + "')") );
for (const auto &hlp : commandHelp()) {
if ( !hlp.cmd.isNull() ) {
help.append( QString("<p><b>%1</b>"
" <span class='args'>%2</span>"
"<div class='description'>%3</div></p>").arg(
escapeHtml(hlp.cmd),
escapeHtml(hlp.args),
escapeHtml(hlp.desc.trimmed())) );
}
}
return QString(htmlTemplate).arg(help);
}
QVBoxLayout *createLayout(QWidget *parent)
{
auto layout = new QVBoxLayout(parent);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
return layout;
}
} // namespace
CommandHelpButton::CommandHelpButton(QWidget *parent)
: QWidget(parent)
, m_button(new QToolButton(this))
, m_help(nullptr)
{
m_button->setToolTip( tr("Show command help (F1)") );
m_button->setShortcut(QKeySequence(Qt::Key_F1));
const int x = smallIconSize();
m_button->setIconSize(QSize(x, x));
m_button->setIcon( getIcon("help-faq", IconCircleInfo) );
connect( m_button, &QAbstractButton::clicked,
this, &CommandHelpButton::showHelp );
QVBoxLayout *layout = createLayout(this);
layout->addWidget(m_button);
}
void CommandHelpButton::showHelp()
{
if (!m_help) {
m_help = new QDialog(this);
m_help->setObjectName("commandHelpDialog");
WindowGeometryGuard::create(m_help);
auto browser = new QTextBrowser(this);
QVBoxLayout *layout = createLayout(m_help);
layout->addWidget(browser);
QDialogButtonBox *buttonBox = new QDialogButtonBox(
QDialogButtonBox::Close, Qt::Horizontal, m_help);
layout->addWidget(buttonBox);
QObject::connect(buttonBox, &QDialogButtonBox::rejected, m_help, &QWidget::hide);
browser->setText(help());
}
m_help->show();
}
| 4,775
|
C++
|
.cpp
| 126
| 29.626984
| 120
| 0.578902
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,225
|
mainwindow.cpp
|
hluk_CopyQ/src/gui/mainwindow.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "common/action.h"
#include "common/actionoutput.h"
#include "common/appconfig.h"
#include "common/common.h"
#include "common/command.h"
#include "common/commandstore.h"
#include "common/config.h"
#include "common/contenttype.h"
#include "common/display.h"
#include "common/globalshortcutcommands.h"
#include "common/log.h"
#include "common/mimetypes.h"
#include "common/shortcuts.h"
#include "common/tabs.h"
#include "common/textdata.h"
#include "common/timer.h"
#include "gui/aboutdialog.h"
#include "gui/actiondialog.h"
#include "gui/actionhandler.h"
#include "gui/clipboardbrowser.h"
#include "gui/clipboardbrowserplaceholder.h"
#include "gui/clipboardbrowsershared.h"
#include "gui/clipboarddialog.h"
#include "gui/commandaction.h"
#include "gui/commanddialog.h"
#include "gui/configurationmanager.h"
#include "gui/importexportdialog.h"
#include "gui/iconfactory.h"
#include "gui/iconfactory.h"
#include "gui/iconselectdialog.h"
#include "gui/icons.h"
#include "gui/logdialog.h"
#include "gui/notification.h"
#include "gui/notificationdaemon.h"
#include "gui/selectiondata.h"
#include "gui/tabdialog.h"
#include "gui/tabicons.h"
#include "gui/tabwidget.h"
#include "gui/theme.h"
#include "gui/traymenu.h"
#include "gui/windowgeometryguard.h"
#include "item/itemfactory.h"
#include "item/serialize.h"
#include "platform/platformclipboard.h"
#include "platform/platformnativeinterface.h"
#include "platform/platformwindow.h"
#include "scriptable/scriptoverrides.h"
#ifdef Q_OS_MAC
# include "platform/mac/foregroundbackgroundfilter.h"
#endif
#ifdef WITH_NATIVE_NOTIFICATIONS
#include <KStatusNotifierItem>
#endif
#include <QAction>
#include <QCloseEvent>
#include <QDesktopServices>
#include <QFile>
#include <QFileDialog>
#include <QFlags>
#include <QMenu>
#include <QMenuBar>
#include <QMessageBox>
#include <QMimeData>
#include <QModelIndex>
#include <QPushButton>
#include <QShortcut>
#include <QSystemTrayIcon>
#include <QTemporaryFile>
#include <QTimer>
#include <QToolBar>
#include <QUrl>
#include <QVector>
#include <algorithm>
#include <memory>
namespace {
const int contextMenuUpdateIntervalMsec = 100;
const int itemPreviewUpdateIntervalMsec = 100;
const QLatin1String menuItemKeyColor("color");
const QLatin1String menuItemKeyIcon("icon");
const QLatin1String menuItemKeyTag("tag");
const QIcon iconClipboard() { return getIcon("clipboard", IconPaste); }
const QIcon iconTabIcon() { return getIconFromResources("tab_icon"); }
const QIcon iconTabNew() { return getIconFromResources("tab_new"); }
const QIcon iconTabRemove() { return getIconFromResources("tab_remove"); }
const QIcon iconTabRename() { return getIconFromResources("tab_rename"); }
const char propertyWidgetSizeGuarded[] = "CopyQ_widget_size_guarded";
const char propertyActionFilterCommandFailed[] = "CopyQ_action_filter_command_failed";
/// Omit size changes of a widget.
class WidgetSizeGuard final : public QObject {
public:
explicit WidgetSizeGuard(QWidget *guardedObject)
: m_guarded(guardedObject)
{
if ( m_guarded->property(propertyWidgetSizeGuarded).toBool() ) {
m_guarded = nullptr;
} else {
m_guarded->setProperty(propertyWidgetSizeGuarded, true);
m_guarded->setFixedSize( m_guarded->size() );
}
}
~WidgetSizeGuard()
{
if (m_guarded) {
m_guarded->setFixedSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
m_guarded->adjustSize();
m_guarded->resize( m_guarded->sizeHint() );
m_guarded->setProperty(propertyWidgetSizeGuarded, false);
}
}
private:
QWidget *m_guarded;
};
bool canPaste()
{
return !QApplication::queryKeyboardModifiers().testFlag(Qt::ControlModifier);
}
bool matchData(const QRegularExpression &re, const QVariantMap &data, const QString &format)
{
if ( re.pattern().isEmpty() )
return true;
const QString text = getTextData(data, format);
return text.contains(re);
}
bool canExecuteCommand(const Command &command, const QVariantMap &data, const QString &sourceTabName)
{
// Verify that an action is provided.
if ( command.cmd.isEmpty()
&& (command.tab.isEmpty() || command.tab == sourceTabName) )
{
return false;
}
// Verify that data for given MIME is available.
if ( !command.input.isEmpty() ) {
if (command.input == mimeItems || command.input == "!OUTPUT") {
// Disallow applying action that takes serialized item more times.
if ( data.contains(command.output) )
return false;
} else if ( !data.contains(command.input) ) {
return false;
}
}
// Verify that and text matches given regexp.
if ( !matchData(command.re, data, mimeText) )
return false;
// Verify that window title matches given regexp.
if ( !matchData(command.wndre, data, mimeWindowTitle) )
return false;
return true;
}
template <typename WidgetOrAction>
void disableActionWhenTabGroupSelected(WidgetOrAction *action, MainWindow *window)
{
QObject::connect( window, &MainWindow::tabGroupSelected,
action, &WidgetOrAction::setDisabled );
}
QMenu *findSubMenu(const QString &name, const QMenu &menu)
{
for (auto action : menu.actions()) {
QMenu *subMenu = action->menu();
if (subMenu && subMenu->title() == name)
return subMenu;
}
return nullptr;
}
std::pair<QMenu*, QMenu*> createSubMenus(QString *name, QMenu *menu)
{
QStringList path = name->split('|');
if (path.size() == 1)
return {nullptr, menu};
*name = path.takeLast();
QMenu *parentMenu = menu;
QMenu *rootMenu = nullptr;
for (const auto &subMenuName : path) {
QMenu *subMenu = findSubMenu(subMenuName, *parentMenu);
if (!subMenu) {
subMenu = new QMenu(subMenuName, parentMenu);
parentMenu->addMenu(subMenu);
}
if (parentMenu == menu)
rootMenu = subMenu;
parentMenu = subMenu;
}
return {rootMenu, parentMenu};
}
// WORKAROUND: setWindowFlags() hides the window.
// See: https://doc.qt.io/qt-5/qwidget.html#windowFlags-prop
void setWindowFlag(QPointer<QWidget> window, Qt::WindowType flag, bool enable)
{
if (!window)
return;
const Qt::WindowFlags flags = window->windowFlags();
const bool wasEnabled = flags.testFlag(flag);
if (wasEnabled == enable)
return;
const bool wasVisible = window->isVisible();
const bool wasActive = window->isActiveWindow();
window->setWindowFlags(flags ^ flag);
if (wasVisible) {
if (wasActive) {
window->show();
window->activateWindow();
QApplication::setActiveWindow(window);
raiseWindow(window);
} else {
const bool showWithoutActivating = window->testAttribute(Qt::WA_ShowWithoutActivating);
window->setAttribute(Qt::WA_ShowWithoutActivating);
window->show();
window->setAttribute(Qt::WA_ShowWithoutActivating, showWithoutActivating);
}
}
}
void setAlwaysOnTop(QWidget *window, bool alwaysOnTop)
{
setWindowFlag(window, Qt::WindowStaysOnTopHint, alwaysOnTop);
}
void setHideInTaskBar(QWidget *window, bool hideInTaskBar)
{
setWindowFlag(window, Qt::Tool, hideInTaskBar);
}
template<typename Dialog, typename ...Ts>
Dialog *openDialog(Ts... arguments)
{
std::unique_ptr<Dialog> dialog( new Dialog(arguments...) );
WindowGeometryGuard::create( dialog.get() );
dialog->setAttribute(Qt::WA_DeleteOnClose, true);
dialog->setWindowIcon(appIcon());
dialog->activateWindow();
dialog->show();
return dialog.release();
}
bool isItemActivationShortcut(const QKeySequence &shortcut)
{
return (shortcut.matches(Qt::Key_Return) || shortcut.matches(Qt::Key_Enter))
&& shortcut[1] == 0
&& shortcut[2] == 0
&& shortcut[3] == 0;
}
QString importExportFileDialogFilter()
{
return MainWindow::tr("CopyQ Items (*.cpq)");
}
/**
* Returns QVariant value that can be serialized and deserialized with QDataStream.
*
* WORKAROUND: Invalid QVariant() can be serialized but deserialization fails.
*/
QVariant serializableValue(const QSettings &settings, const QString &key)
{
const auto value = settings.value(key);
if ( value.isValid() )
return value;
return QString();
}
bool isAnyApplicationWindowActive()
{
if ( qApp->activeWindow() )
return true;
const auto platform = platformNativeInterface();
const auto currentWindow = platform->getCurrentWindow();
if (!currentWindow)
return false;
const auto currentWindowTitle = currentWindow->getTitle();
if ( currentWindowTitle.isEmpty() )
return false;
for ( auto window : qApp->topLevelWidgets() ) {
const auto ownWindow = platform->getWindow( window->winId() );
if ( ownWindow && currentWindowTitle == ownWindow->getTitle() )
return true;
}
return false;
}
bool hasDialogOpen(QWidget *parent)
{
for ( auto window : qApp->topLevelWidgets() ) {
if ( window->isVisible() && window->parentWidget() == parent )
return true;
}
return false;
}
void deleteSubMenus(QObject *parent)
{
for (auto subMenu : parent->findChildren<QMenu*>()) {
if (subMenu->parent() == parent)
delete subMenu;
}
}
void clearActions(QMenu *menu)
{
for (QAction *action : menu->actions()) {
action->setVisible(false);
action->setDisabled(true);
action->setShortcuts({});
action->deleteLater();
menu->removeAction(action);
}
deleteSubMenus(menu);
menu->clear();
}
void clearActions(QToolBar *toolBar)
{
for (QAction *action : toolBar->actions()) {
// Omit removing action from other menus.
if (action->parent() == toolBar) {
action->setVisible(false);
action->setDisabled(true);
action->setShortcuts({});
action->deleteLater();
}
}
deleteSubMenus(toolBar);
toolBar->clear();
}
bool hasCommandFuzzy(const QVector<Command> &commands, const Command &command)
{
return std::any_of(std::begin(commands), std::end(commands), [&command](const Command &cmd){
return command.name == cmd.name || command.cmd == cmd.cmd;
});
}
bool syncInternalCommandChanges(const Command &command, QVector<Command> *allCommands)
{
Q_ASSERT( !command.internalId.isEmpty() );
if ( command.internalId.isEmpty() )
return false;
const auto found = std::find_if(std::begin(*allCommands), std::end(*allCommands), [&command](const Command &cmd){
return command.internalId == cmd.internalId;
});
if ( found == std::end(*allCommands) )
return false;
// Synchronize internal/plugin commands attributes
// except the ones user can change.
Command command2 = *found;
command2.icon = command.icon;
command2.enable = command.enable;
command2.shortcuts = command.shortcuts;
command2.globalShortcuts = command.globalShortcuts;
if (command2 == command)
return false;
const auto icon = found->icon;
const auto enable = found->enable;
const auto shortcuts = found->shortcuts;
const auto globalShortcuts = found->globalShortcuts;
*found = command;
found->icon = icon;
found->enable = enable;
found->shortcuts = shortcuts;
found->globalShortcuts = globalShortcuts;
return true;
}
bool menuItemMatches(const QModelIndex &index, const QString &searchText)
{
for (const int type : {contentType::text, contentType::notes}) {
const QString itemText = index.data(type).toString().toLower();
if ( itemText.contains(searchText.toLower()) )
return true;
}
return false;
}
QList<QKeySequence> getUniqueShortcuts(const QStringList &shortcuts, QList<QKeySequence> *usedShortcuts)
{
QList<QKeySequence> uniqueShortcuts;
for (const auto &shortcutText : shortcuts) {
const QKeySequence shortcut(shortcutText, QKeySequence::PortableText);
if ( !shortcut.isEmpty() && !usedShortcuts->contains(shortcut) ) {
usedShortcuts->append(shortcut);
uniqueShortcuts.append(shortcut);
}
}
return uniqueShortcuts;
}
} // namespace
#ifdef WITH_NATIVE_NOTIFICATIONS
class SystemTrayIcon final : public KStatusNotifierItem {
Q_OBJECT
public:
explicit SystemTrayIcon(QWidget *parent = nullptr)
: KStatusNotifierItem(QCoreApplication::applicationName())
{
setIcon(appIcon());
// Parent is not passed to the KStatusNotifierItem constructor because
// it calls KStatusNotifierItem::setAssociatedWidget() which breaks
// setting main window position.
setParent(parent);
setStandardActionsEnabled(false);
setTitle(QGuiApplication::applicationDisplayName());
setToolTipTitle(QGuiApplication::applicationDisplayName());
setCategory(KStatusNotifierItem::ApplicationStatus);
}
void setIcon(const QIcon &icon) { setIconByPixmap(icon); }
void setToolTip(const QString &text)
{
#if defined(Q_OS_WIN)
// Only the tooltip title seems to be supported on Windows.
KStatusNotifierItem::setToolTipTitle(text);
#else
KStatusNotifierItem::setToolTipSubTitle(text);
#endif
}
bool isVisible() const
{
return status() != KStatusNotifierItem::Passive;
}
void show() { setStatus(KStatusNotifierItem::Active); }
void hide() { setStatus(KStatusNotifierItem::Passive); }
void activate(const QPoint &) override
{
emit activated(QSystemTrayIcon::Trigger);
}
signals:
void activated(QSystemTrayIcon::ActivationReason reason);
};
#else
class SystemTrayIcon final : public QSystemTrayIcon {
public:
explicit SystemTrayIcon(QWidget *parent = nullptr)
: QSystemTrayIcon(parent)
{
setIcon(appIcon());
}
};
#endif
class ToolBar final : public QToolBar {
public:
explicit ToolBar(QWidget *parent)
: QToolBar(parent)
{
setObjectName("toolBar");
setContextMenuPolicy(Qt::PreventContextMenu);
initSingleShotTimer( &m_timerUnfreeze, 50, this, &ToolBar::unfreeze );
}
void setFrozen(bool frozen) {
if (frozen) {
m_frozen = true;
setUpdatesEnabled(false);
setEnabled(false);
m_timerUnfreeze.stop();
} else {
m_timerUnfreeze.start();
}
}
protected:
void paintEvent(QPaintEvent *ev) override
{
if (m_frozen)
return;
QToolBar::paintEvent(ev);
}
private:
void unfreeze()
{
m_frozen = false;
setEnabled(true);
setUpdatesEnabled(true);
update();
}
bool m_frozen = false;
QTimer m_timerUnfreeze;
};
MainWindow::MainWindow(const ClipboardBrowserSharedPtr &sharedData, QWidget *parent)
: QMainWindow(parent)
, cm(nullptr)
, ui(new Ui::MainWindow)
, m_menuItem(nullptr)
, m_trayMenu( new TrayMenu(this) )
, m_tray(nullptr)
, m_toolBar(new ToolBar(this))
, m_sharedData(sharedData)
, m_menu( new TrayMenu(this) )
, m_menuMaxItemCount(-1)
, m_commandDialog(nullptr)
, m_clipboard(platformNativeInterface()->clipboard())
{
ui->setupUi(this);
m_sharedData->menuItems = menuItems();
#if defined(Q_OS_MAC) && QT_VERSION < QT_VERSION_CHECK(6,0,0)
// Open above fullscreen windows on macOS and Qt 5.
setWindowModality(Qt::WindowModal);
setWindowFlag(Qt::Sheet);
#endif
setWindowRole(QStringLiteral("main"));
menuBar()->setObjectName("menu_bar");
createMenu();
ui->tabWidget->addToolBars(this);
addToolBar(Qt::RightToolBarArea, m_toolBar);
ui->dockWidgetItemPreview->setFocusProxy(ui->scrollAreaItemPreview);
ui->dockWidgetItemPreview->hide();
WindowGeometryGuard::create(this);
restoreState( mainWindowState(objectName()) );
// NOTE: QWidget::isVisible() returns false if parent is not visible.
m_showItemPreview = !ui->dockWidgetItemPreview->isHidden();
// Disable the show-preview option when the preview dock is closed.
connect( ui->dockWidgetItemPreview, &QDockWidget::visibilityChanged,
this, [this]() {
if ( ui->dockWidgetItemPreview->isHidden() )
setItemPreviewVisible(false);
} );
updateIcon();
updateFocusWindows();
connect( m_trayMenu, &QMenu::aboutToShow,
this, &MainWindow::updateFocusWindows );
connect( m_trayMenu, &QMenu::aboutToShow,
this, &MainWindow::updateTrayMenuItemsTimeout );
connect( m_trayMenu, &QMenu::aboutToHide,
this, [this](){ m_timerRaiseLastWindowAfterMenuClosed.start(); } );
connect( m_trayMenu, &TrayMenu::searchRequest,
this, &MainWindow::filterTrayMenuItems );
connect( m_trayMenu, &TrayMenu::clipboardItemActionTriggered,
this, &MainWindow::onTrayActionTriggered );
connect( m_menu, &QMenu::aboutToShow,
this, &MainWindow::updateFocusWindows );
connect( m_menu, &QMenu::aboutToHide,
this, [this](){ m_timerRaiseLastWindowAfterMenuClosed.start(); } );
connect( m_menu, &TrayMenu::searchRequest,
this, &MainWindow::filterMenuItems );
connect( m_menu, &TrayMenu::clipboardItemActionTriggered,
this, &MainWindow::onMenuActionTriggered );
connect( ui->tabWidget, &TabWidget::currentChanged,
this, &MainWindow::tabChanged );
connect( ui->tabWidget, &TabWidget::tabMoved,
this, &MainWindow::saveTabPositions );
connect( ui->tabWidget, &TabWidget::tabsMoved,
this, &MainWindow::tabsMoved );
connect( ui->tabWidget, &TabWidget::tabBarMenuRequested,
this, &MainWindow::tabBarMenuRequested );
connect( ui->tabWidget, &TabWidget::tabTreeMenuRequested,
this, &MainWindow::tabTreeMenuRequested );
connect( ui->tabWidget, &TabWidget::tabRenamed,
this, &MainWindow::renameTab );
connect( ui->tabWidget, &TabWidget::tabCloseRequested,
this, &MainWindow::tabCloseRequested );
connect( ui->tabWidget, &TabWidget::dropItems,
this, &MainWindow::onTabWidgetDropItems);
connect( ui->searchBar, &Utils::FilterLineEdit::filterChanged,
this, &MainWindow::onFilterChanged );
connect( qApp, &QCoreApplication::aboutToQuit,
this, &MainWindow::onAboutToQuit );
connect(m_sharedData->itemFactory, &ItemFactory::error,
this, &MainWindow::showError);
connect(m_sharedData->itemFactory, &ItemFactory::addCommands,
this, &MainWindow::addCommands);
initSingleShotTimer( &m_timerUpdateFocusWindows, 100, this, &MainWindow::updateFocusWindows );
initSingleShotTimer( &m_timerUpdateContextMenu, 0, this, &MainWindow::updateContextMenuTimeout );
initSingleShotTimer( &m_timerUpdatePreview, 0, this, &MainWindow::updateItemPreviewTimeout );
initSingleShotTimer( &m_timerSaveTabPositions, 1000, this, &MainWindow::onSaveTabPositionsTimer );
initSingleShotTimer( &m_timerRaiseLastWindowAfterMenuClosed, 50, this, &MainWindow::raiseLastWindowAfterMenuClosed);
enableHideWindowOnUnfocus();
m_trayMenu->setObjectName("TrayMenu");
m_menu->setObjectName("Menu");
auto act = m_trayMenu->addAction( appIcon(), tr("&Show/Hide") );
connect(act, &QAction::triggered, this, &MainWindow::toggleVisible);
m_trayMenu->setDefaultAction(act);
addTrayAction(Actions::File_Preferences);
addTrayAction(Actions::File_ToggleClipboardStoring);
m_trayMenu->addSeparator();
addTrayAction(Actions::File_Exit);
// Initialize tray menu even if it's not visible to ensure
// the initial size is correct in native tray menus.
QTimer::singleShot(0, this, [this](){
if (m_trayMenuDirty)
initTrayMenuItems();
});
}
bool MainWindow::browseMode() const
{
return ui->searchBar->isHidden();
}
void MainWindow::exit()
{
// Check if not editing in any tab (show and try to close editors).
for ( int i = 0; i < ui->tabWidget->count(); ++i ) {
auto c = getPlaceholder(i)->browser();
if ( c && (c->isInternalEditorOpen() || c->isExternalEditorOpen()) ) {
setCurrentTab(i);
if ( !c->maybeCloseEditors() )
return;
}
}
int answer = QMessageBox::Yes;
if (m_options.confirmExit) {
showWindow();
answer = QMessageBox::question(
this,
tr("Exit?"),
tr("Do you want to <strong>exit</strong> CopyQ?"),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::Yes);
}
if (answer == QMessageBox::Yes)
emit requestExit();
}
void MainWindow::closeEvent(QCloseEvent *event)
{
hideWindow();
#if QT_VERSION >= QT_VERSION_CHECK(5,15,0)
event->accept();
#else
// This is needed in older versions of Qt (tested in Qt 5.12.8),
// otherwise focusing is somewhat broken (test pasteFromMainWindow()).
event->ignore();
#endif
COPYQ_LOG("Got main window close event.");
}
bool MainWindow::focusNextPrevChild(bool next)
{
auto c = browser();
if (!c)
return false;
if ( next && ui->searchBar->hasFocus() ) {
c->setFocus();
return true;
}
if ( !next && c->hasFocus() && !browseMode() ) {
ui->searchBar->setFocus();
return true;
}
// Focus floating preview dock.
if ( next && m_showItemPreview && ui->dockWidgetItemPreview->isFloating() ) {
QWidget *w = ui->scrollAreaItemPreview->widget();
if (w && c->isActiveWindow() && c->hasFocus()) {
ui->dockWidgetItemPreview->raise();
ui->dockWidgetItemPreview->activateWindow();
w->setFocus(Qt::TabFocusReason);
return true;
}
}
return QMainWindow::focusNextPrevChild(next);
}
void MainWindow::createMenu()
{
QMenuBar *menubar = menuBar();
QMenu *menu;
QAction *act;
// Some action should not be triggered from tab widget or preview dock.
QWidget *actionParent = ui->tabWidget;
menubar->clear();
// File
menu = menubar->addMenu( tr("&File") );
// - new
act = createAction( Actions::File_New, &MainWindow::editNewItem, menu );
disableActionWhenTabGroupSelected(act, this);
// - import
createAction( Actions::File_Import, &MainWindow::importData, menu );
// - export
createAction( Actions::File_Export, &MainWindow::exportData, menu );
// - separator
menu->addSeparator();
// - preferences
createAction( Actions::File_Preferences, &MainWindow::openPreferences, menu );
// - commands
createAction( Actions::File_Commands, &MainWindow::openCommands, menu );
// - separator
menu->addSeparator();
// - show clipboard content
createAction( Actions::File_ShowClipboardContent, &MainWindow::showClipboardContent, menu );
// - show preview
QAction *togglePreviewAction =
createAction( Actions::File_ShowPreview, &MainWindow::toggleItemPreviewVisible, menu );
togglePreviewAction->setCheckable(true);
togglePreviewAction->setChecked(m_showItemPreview);
// - active commands
createAction( Actions::File_ProcessManager, &MainWindow::showProcessManagerDialog, menu );
// - enable/disable
createAction( Actions::File_ToggleClipboardStoring, &MainWindow::toggleClipboardStoring, menu );
// - separator
menu->addSeparator();
// - exit
createAction( Actions::File_Exit, &MainWindow::exit, menu );
// Edit
menu = menubar->addMenu( tr("&Edit") );
// - find
createAction( Actions::Edit_FindItems, &MainWindow::findNextOrPrevious, menu, actionParent );
// - separator
menu->addSeparator();
// - sort
createAction( Actions::Edit_SortSelectedItems, &MainWindow::sortSelectedItems, menu, actionParent );
// - reverse order
createAction( Actions::Edit_ReverseSelectedItems, &MainWindow::reverseSelectedItems, menu, actionParent );
// - separator
menu->addSeparator();
// - paste items
createAction( Actions::Edit_PasteItems, &MainWindow::pasteItems, menu, actionParent );
// - copy items
createAction( Actions::Edit_CopySelectedItems, &MainWindow::copyItems, menu, actionParent );
// Items
m_menuItem = menubar->addMenu( tr("&Item") );
disableActionWhenTabGroupSelected(m_menuItem, this);
// Tabs
menu = menubar->addMenu(tr("&Tabs"));
// - new tab
createAction( Actions::Tabs_NewTab, &MainWindow::openNewTabDialog, menu );
// - rename tab
act = createAction( Actions::Tabs_RenameTab, &MainWindow::openRenameTabDialog, menu );
disableActionWhenTabGroupSelected(act, this);
// - remove tab
act = createAction( Actions::Tabs_RemoveTab, &MainWindow::removeTab, menu );
disableActionWhenTabGroupSelected(act, this);
createAction( Actions::Tabs_ChangeTabIcon, &MainWindow::setTabIcon, menu );
// - separator
menu->addSeparator();
// - next tab
createAction( Actions::Tabs_NextTab, &MainWindow::nextTab, menu );
// - previous tab
createAction( Actions::Tabs_PreviousTab, &MainWindow::previousTab, menu );
// Help
menu = menubar->addMenu(tr("&Help"));
createAction( Actions::Help_Help, &MainWindow::openHelp, menu );
createAction( Actions::Help_ShowLog, &MainWindow::openLogDialog, menu );
createAction( Actions::Help_About, &MainWindow::openAboutDialog, menu );
// Open Item Menu
createAction( Actions::ItemMenu, &MainWindow::showContextMenu, nullptr );
for (auto subMenu : menuBar()->findChildren<QMenu*>()) {
connect( subMenu, &QMenu::aboutToShow,
this, &MainWindow::disableHideWindowOnUnfocus );
connect( subMenu, &QMenu::aboutToHide,
this, &MainWindow::enableHideWindowOnUnfocus );
}
}
void MainWindow::popupTabBarMenu(QPoint pos, const QString &tab)
{
QMenu menu(ui->tabWidget);
const int tabIndex = ui->tabWidget->tabs().indexOf(tab);
bool hasTab = tabIndex != -1;
bool isGroup = ui->tabWidget->isTabGroup(tab);
const QString quotedTab = quoteString(tab);
QAction *actNew = menu.addAction( iconTabNew(), tr("&New Tab") );
QAction *actRenameGroup =
isGroup ? menu.addAction( iconTabRename(), tr("Rename &Group %1").arg(quotedTab) ) : nullptr;
QAction *actRename =
hasTab ? menu.addAction( iconTabRename(), tr("Re&name Tab %1").arg(quotedTab) ) : nullptr;
QAction *actRemove =
hasTab ? menu.addAction( iconTabRemove(), tr("Re&move Tab %1").arg(quotedTab) ) : nullptr;
QAction *actRemoveGroup =
isGroup ? menu.addAction( iconTabRemove(), tr("Remove Group %1").arg(quotedTab) ) : nullptr;
QAction *actIcon = menu.addAction( iconTabIcon(), tr("&Change Tab Icon") );
QAction *act = menu.exec(pos);
if (act != nullptr) {
if (act == actNew)
openNewTabDialog(tab);
else if (act == actRenameGroup)
openRenameTabGroupDialog(tab);
else if (act == actRename)
openRenameTabDialog(tabIndex);
else if (act == actRemove)
removeTab(true, tabIndex);
else if (act == actRemoveGroup)
removeTabGroup(tab);
else if (act == actIcon)
setTabIcon(tab);
}
}
void MainWindow::updateContextMenu(int intervalMsec)
{
interruptMenuCommandFilters(&m_itemMenuMatchCommands);
// Omit tool bar flickering.
m_toolBar->setFrozen(true);
clearActions(m_menuItem);
m_timerUpdateContextMenu.start(intervalMsec);
}
void MainWindow::updateTrayMenuItems()
{
m_trayMenuDirty = true;
}
void MainWindow::updateTrayMenuCommands()
{
m_trayMenu->clearCustomActions();
if (!m_options.trayCommands)
return;
const QString format = tr("&Clipboard: %1", "Tray menu clipboard item format");
const auto font = m_trayMenu->font();
const auto clipboardLabel = textLabelForData(m_clipboardData, font, format, true);
QAction *clipboardAction = m_trayMenu->addAction( iconClipboard(), clipboardLabel );
connect(clipboardAction, &QAction::triggered,
this, &MainWindow::showClipboardContent);
m_trayMenu->markItemInClipboard(m_clipboardData);
QList<QAction*> customActions;
customActions.append(clipboardAction);
addCommandsToTrayMenu(m_clipboardData, &customActions);
m_trayMenu->setCustomActions(customActions);
}
void MainWindow::updateIcon()
{
const QIcon icon = appIcon();
setWindowIcon(icon);
if (m_tray)
m_tray->setIcon(icon);
}
void MainWindow::updateContextMenuTimeout()
{
auto c = browserOrNull();
if ( ui->tabWidget->isTabGroupSelected() || !c || c->isInternalEditorOpen()) {
clearActions(m_toolBar);
m_toolBar->setFrozen(false);
return;
}
addCommandsToItemMenu(c);
m_menuItem->addSeparator();
addItemAction( Actions::Item_MoveToClipboard, c, &ClipboardBrowser::moveToClipboard );
addItemAction( Actions::Item_ShowContent, this, &MainWindow::showItemContent );
addItemAction( Actions::Item_Remove, c, &ClipboardBrowser::remove );
addItemAction( Actions::Item_Edit, c, &ClipboardBrowser::editSelected );
addItemAction( Actions::Item_EditNotes, c, &ClipboardBrowser::editNotes );
addItemAction( Actions::Item_EditWithEditor, c, &ClipboardBrowser::openEditor );
addItemAction( Actions::Item_Action, this, &MainWindow::openActionDialog );
m_menuItem->addSeparator();
addItemAction( Actions::Item_MoveUp, this, &MainWindow::moveUp );
addItemAction( Actions::Item_MoveDown, this, &MainWindow::moveDown );
addItemAction( Actions::Item_MoveToTop, this, &MainWindow::moveToTop );
addItemAction( Actions::Item_MoveToBottom, this, &MainWindow::moveToBottom );
updateToolBar();
updateActionShortcuts();
}
void MainWindow::updateItemPreviewAfterMs(int ms)
{
m_timerUpdatePreview.start(ms);
}
void MainWindow::updateItemPreviewTimeout()
{
const bool showPreview = m_showItemPreview;
auto c = browserOrNull();
if (c && c->length() > 0) {
ui->dockWidgetItemPreview->setVisible(m_showItemPreview && !c->isInternalEditorOpen());
QWidget *w = ui->dockWidgetItemPreview->isVisible() && !ui->tabWidget->isTabGroupSelected()
? c->currentItemPreview(ui->scrollAreaItemPreview)
: nullptr;
ui->scrollAreaItemPreview->setVisible(w != nullptr);
ui->scrollAreaItemPreview->setWidget(w);
if (w) {
ui->dockWidgetItemPreview->setStyleSheet( c->styleSheet() );
w->show();
// Focus from floating preview dock back to the main window on Esc/Tab.
if ( ui->dockWidgetItemPreview->isFloating() ) {
const auto keys = {
Qt::Key_Backtab,
Qt::Key_Escape,
Qt::Key_Tab,
};
for (auto key : keys) {
const auto shortcut = new QShortcut(key, w);
connect(shortcut, &QShortcut::activated, this, &MainWindow::showWindow);
}
}
}
} else {
ui->dockWidgetItemPreview->hide();
}
m_showItemPreview = showPreview;
m_timerUpdatePreview.stop();
}
void MainWindow::toggleItemPreviewVisible()
{
setItemPreviewVisible(!m_showItemPreview);
}
void MainWindow::setItemPreviewVisible(bool visible)
{
if (m_showItemPreview == visible)
return;
m_showItemPreview = visible;
updateItemPreviewAfterMs(0);
}
bool MainWindow::isItemPreviewVisible() const
{
return m_showItemPreview;
}
void MainWindow::setScriptOverrides(const QVector<int> &overrides, int actionId)
{
if (!m_actionCollectOverrides || m_actionCollectOverrides->id() != actionId)
return;
m_overrides = overrides;
std::sort(m_overrides.begin(), m_overrides.end());
}
bool MainWindow::isScriptOverridden(int id) const
{
return
// Assume everything is overridden until collectOverrides() finishes
(m_actionCollectOverrides && m_actionCollectOverrides->isRunning() && m_overrides.isEmpty())
|| std::binary_search(m_overrides.begin(), m_overrides.end(), id);
}
void MainWindow::onAboutToQuit()
{
if (cm)
cm->disconnect();
saveMainWindowState( objectName(), saveState() );
hideWindow();
if (m_tray)
m_tray->hide();
stopMenuCommandFilters(&m_itemMenuMatchCommands);
stopMenuCommandFilters(&m_trayMenuMatchCommands);
terminateAction(&m_displayActionId);
}
void MainWindow::onItemCommandActionTriggered(CommandAction *commandAction, const QString &triggeredShortcut)
{
COPYQ_LOG( QString("Trigger: %1").arg(commandAction->text()) );
auto c = getPlaceholder()->createBrowser();
if (!c)
return;
const QModelIndexList selected = c->selectionModel()->selectedIndexes();
const auto command = commandAction->command();
if ( !command.cmd.isEmpty() ) {
if (command.transform) {
for (const auto &index : selected) {
auto actionData = selectionData(*c, index, {index});
if ( !triggeredShortcut.isEmpty() )
actionData.insert(mimeShortcut, triggeredShortcut);
action(actionData, command, index);
}
} else {
auto actionData = selectionData(*c);
if ( !triggeredShortcut.isEmpty() )
actionData.insert(mimeShortcut, triggeredShortcut);
action(actionData, command, QModelIndex());
}
}
if ( !command.tab.isEmpty() && command.tab != c->tabName() ) {
auto c2 = tab(command.tab);
if (c2) {
for (int i = selected.size() - 1; i >= 0; --i) {
const auto data = c->copyIndex(selected[i]);
if ( !data.isEmpty() )
c2->addUnique(data, ClipboardMode::Clipboard);
}
}
}
if ( command.remove && (command.tab.isEmpty() || command.tab != c->tabName()) )
c->removeIndexes(selected);
if (command.hideWindow)
hideWindow();
}
void MainWindow::onClipboardCommandActionTriggered(CommandAction *commandAction, const QString &triggeredShortcut)
{
const QMimeData *data = m_clipboard->mimeData(ClipboardMode::Clipboard);
if (data == nullptr)
return;
auto actionData = cloneData(*data);
if ( !triggeredShortcut.isEmpty() )
actionData.insert(mimeShortcut, triggeredShortcut);
auto command = commandAction->command();
action( actionData, command, QModelIndex() );
}
void MainWindow::onTabWidgetDropItems(const QString &tabName, const QMimeData *data)
{
auto browser = tab(tabName);
if (browser) {
const QVariantMap dataMap = data->hasFormat(mimeItems)
? cloneData(*data, QStringList() << mimeItems) : cloneData(*data);
browser->addAndSelect(dataMap, 0);
}
}
void MainWindow::showContextMenuAt(QPoint position)
{
// Restrict menu position to central widget.
const auto localRect = centralWidget()->rect();
const auto rect = QRect(
centralWidget()->mapToGlobal(localRect.topLeft()),
centralWidget()->mapToGlobal(localRect.bottomRight())
);
const QPoint positionInCentralWidget(
qBound(rect.left(), position.x(), rect.right()),
qBound(rect.top(), position.y(), rect.bottom())
);
m_menuItem->exec(positionInCentralWidget);
}
void MainWindow::showContextMenu()
{
auto c = browser();
if (!c)
return;
const auto index = c->currentIndex();
if ( !index.isValid() )
return;
const auto itemRect = c->visualRect(index);
const auto viewportPosition = itemRect.center();
const auto position = c->mapToGlobal(viewportPosition);
showContextMenuAt(position);
}
void MainWindow::moveUp()
{
auto c = browser();
if (c)
c->move(Qt::Key_Up);
}
void MainWindow::moveDown()
{
auto c = browser();
if (c)
c->move(Qt::Key_Down);
}
void MainWindow::moveToTop()
{
auto c = browser();
if (c)
c->move(Qt::Key_Home);
}
void MainWindow::moveToBottom()
{
auto c = browser();
if (c)
c->move(Qt::Key_End);
}
void MainWindow::onBrowserCreated(ClipboardBrowser *browser)
{
connect( browser, &ClipboardBrowser::changeClipboard,
this, &MainWindow::setClipboardAndSelection );
connect( browser, &ClipboardBrowser::requestShow,
this, &MainWindow::showBrowser );
connect( browser, &ClipboardBrowser::error,
this, &MainWindow::showError );
connect( browser, &QAbstractItemView::clicked,
this, &MainWindow::onItemClicked );
connect( browser, &QAbstractItemView::doubleClicked,
this, &MainWindow::onItemDoubleClicked );
connect( browser, &ClipboardBrowser::itemCountChanged,
ui->tabWidget, &TabWidget::setTabItemCount );
connect( browser, &ClipboardBrowser::showContextMenu,
this, &MainWindow::showContextMenuAt );
connect( browser, &ClipboardBrowser::itemSelectionChanged,
this, &MainWindow::onItemSelectionChanged );
connect( browser, &ClipboardBrowser::itemsChanged,
this, &MainWindow::onItemsChanged );
connect( browser, &ClipboardBrowser::internalEditorStateChanged,
this, &MainWindow::onInternalEditorStateChanged );
connect( browser, &ClipboardBrowser::searchRequest,
this, &MainWindow::findNextOrPrevious );
connect( browser, &ClipboardBrowser::searchHideRequest,
ui->searchBar, &Utils::FilterLineEdit::hide );
connect( browser, &ClipboardBrowser::searchShowRequest,
this, &MainWindow::onSearchShowRequest );
connect( browser, &ClipboardBrowser::itemWidgetCreated,
this, &MainWindow::onItemWidgetCreated );
connect( browser, &ClipboardBrowser::runOnRemoveItemsHandler,
browser, [this, browser](const QList<QPersistentModelIndex> &indexes, bool *canRemove) {
if (isScriptOverridden(ScriptOverrides::OnItemsRemoved)) {
QVariantMap data = createDataMap(mimeCurrentTab, browser->tabName());
addSelectionData(&data, indexes);
*canRemove = runEventHandlerScript(QStringLiteral("onItemsRemoved()"), data);
}
} );
connect( browser->model(), &QAbstractItemModel::rowsInserted,
browser, [this, browser](const QModelIndex &, int first, int last) {
if (isScriptOverridden(ScriptOverrides::OnItemsAdded))
runItemHandlerScript(QStringLiteral("onItemsAdded()"), browser, first, last);
} );
connect( browser->model(), &QAbstractItemModel::dataChanged,
browser, [this, browser](const QModelIndex &topLeft, const QModelIndex &bottomRight) {
if (isScriptOverridden(ScriptOverrides::OnItemsChanged)) {
runItemHandlerScript(
QStringLiteral("onItemsChanged()"),
browser, topLeft.row(), bottomRight.row());
}
} );
}
void MainWindow::onBrowserLoaded(ClipboardBrowser *browser)
{
if (isScriptOverridden(ScriptOverrides::OnItemsLoaded)) {
runScript(
QStringLiteral("onItemsLoaded()"),
createDataMap(mimeCurrentTab, browser->tabName()));
}
if (browserOrNull() == browser) {
const int index = ui->tabWidget->currentIndex();
tabChanged(index, index);
}
}
void MainWindow::onBrowserDestroyed(ClipboardBrowserPlaceholder *placeholder)
{
if (placeholder == getPlaceholder()) {
updateContextMenu(0);
updateItemPreviewAfterMs(0);
}
}
void MainWindow::onItemSelectionChanged(const ClipboardBrowser *browser)
{
if (browser == browserOrNull()) {
updateContextMenu(0);
updateItemPreviewAfterMs(0);
}
}
void MainWindow::onItemsChanged(const ClipboardBrowser *browser)
{
if (browser == browserOrNull()) {
updateContextMenu(contextMenuUpdateIntervalMsec);
updateItemPreviewAfterMs(itemPreviewUpdateIntervalMsec);
}
const ClipboardBrowserPlaceholder *placeholder = getPlaceholderForTrayMenu();
if (placeholder && placeholder->browser() == browser)
updateTrayMenuItems();
}
void MainWindow::onInternalEditorStateChanged(const ClipboardBrowser *browser)
{
if (browser == browserOrNull()) {
updateContextMenu(0);
updateItemPreviewAfterMs(0);
}
}
void MainWindow::onItemWidgetCreated(const PersistentDisplayItem &item)
{
if ( m_displayCommands.isEmpty() )
return;
m_displayItemList.append(item);
runDisplayCommands();
}
void MainWindow::onActionDialogAccepted(const Command &command, const QStringList &arguments, const QVariantMap &data)
{
auto act = new Action();
act->setCommand(command.cmd, arguments);
act->setInputWithFormat(data, command.input);
act->setName(command.name);
act->setData(data);
if ( !command.output.isEmpty() ) {
if ( !command.sep.isEmpty() )
actionOutput(this, act, command.output, command.outputTab, QRegularExpression(command.sep));
else
actionOutput(this, act, command.output, command.outputTab);
}
m_sharedData->actions->action(act);
}
void MainWindow::onSearchShowRequest(const QString &text)
{
if (m_enteringSearchMode)
return;
m_enteringSearchMode = true;
enterSearchMode();
if (m_options.navigationStyle != NavigationStyle::Vi || text != "/") {
ui->searchBar->setText(text);
ui->searchBar->end(false);
}
m_enteringSearchMode = false;
}
void MainWindow::runDisplayCommands()
{
if ( m_displayItemList.isEmpty() )
return;
if ( !isInternalActionId(m_displayActionId) ) {
m_currentDisplayItem = m_displayItemList.takeFirst();
const auto action = runScript(QStringLiteral("runDisplayCommands()"), m_currentDisplayItem.data());
m_displayActionId = action->id();
}
emit sendActionData(m_displayActionId, QByteArray());
}
void MainWindow::clearHiddenDisplayData()
{
for (int i = m_displayItemList.size() - 1; i >= 0; --i) {
auto &item = m_displayItemList[i];
if ( !item.isValid() )
m_displayItemList.removeAt(i);
}
}
void MainWindow::reloadBrowsers()
{
for( int i = 0; i < ui->tabWidget->count(); ++i )
getPlaceholder(i)->reloadBrowser();
}
int MainWindow::findTabIndexExactMatch(const QString &name)
{
TabWidget *w = ui->tabWidget;
for( int i = 0; i < w->count(); ++i ) {
if ( name == w->tabName(i) )
return i;
}
return -1;
}
void MainWindow::setClipboardData(const QVariantMap &data)
{
m_clipboardData = data;
updateContextMenu(contextMenuUpdateIntervalMsec);
updateTrayMenuCommands();
}
void MainWindow::setFilter(const QString &text)
{
if ( text.isEmpty() ) {
enterBrowseMode();
} else {
enterSearchMode(text);
getPlaceholder()->setFocus();
}
}
QString MainWindow::filter() const
{
return ui->searchBar->isVisible() ? ui->searchBar->text() : QString();
}
void MainWindow::updateWindowTransparency(bool mouseOver)
{
int opacity = 100 - (mouseOver || isActiveWindow() ? m_options.transparencyFocused : m_options.transparency);
setWindowOpacity(opacity / 100.0);
}
ClipboardBrowserPlaceholder *MainWindow::getPlaceholder(int index) const
{
return qobject_cast<ClipboardBrowserPlaceholder*>( ui->tabWidget->widget(index) );
}
ClipboardBrowserPlaceholder *MainWindow::getPlaceholder(const QString &tabName) const
{
for (auto placeholder : findChildren<ClipboardBrowserPlaceholder*>()) {
if ( placeholder->tabName() == tabName )
return placeholder;
}
return nullptr;
}
ClipboardBrowserPlaceholder *MainWindow::getPlaceholder() const
{
return qobject_cast<ClipboardBrowserPlaceholder*>( ui->tabWidget->currentWidget() );
}
void MainWindow::delayedUpdateForeignFocusWindows()
{
if ( isActiveWindow() || m_trayMenu->isActiveWindow() || m_menu->isActiveWindow() )
m_timerUpdateFocusWindows.stop();
else
m_timerUpdateFocusWindows.start();
}
void MainWindow::setHideTabs(bool hide)
{
ui->tabWidget->setTabBarHidden(hide);
}
bool MainWindow::closeMinimizes() const
{
return !m_options.hideMainWindow
&& (!m_tray || !m_tray->isVisible() || !QSystemTrayIcon::isSystemTrayAvailable());
}
ClipboardBrowserPlaceholder *MainWindow::createTab(const QString &name, TabNameMatching nameMatch, const Tabs &tabs)
{
if ( name.isEmpty() )
return nullptr;
const int i = nameMatch == MatchExactTabName
? findTabIndexExactMatch(name)
: findTabIndex(name);
ClipboardBrowserPlaceholder *placeholder = nullptr;
if (i != -1) {
placeholder = getPlaceholder(i);
} else {
placeholder = new ClipboardBrowserPlaceholder(name, m_sharedData, this);
connect( placeholder, &ClipboardBrowserPlaceholder::browserCreated,
this, &MainWindow::onBrowserCreated );
connect( placeholder, &ClipboardBrowserPlaceholder::browserLoaded,
this, &MainWindow::onBrowserLoaded );
connect( placeholder, &ClipboardBrowserPlaceholder::browserDestroyed,
this, [this, placeholder]() { onBrowserDestroyed(placeholder); } );
ui->tabWidget->addTab(placeholder, name);
saveTabPositions();
}
const TabProperties tab = tabs.tabProperties(name);
placeholder->setStoreItems(tab.storeItems);
int maxItemCount = tab.maxItemCount;
if (maxItemCount <= 0)
maxItemCount = m_sharedData->maxItems;
else if (maxItemCount > Config::maxItems)
maxItemCount = Config::maxItems;
placeholder->setMaxItemCount(maxItemCount);
return placeholder;
}
template <typename SlotReturnType>
QAction *MainWindow::createAction(Actions::Id id, MainWindowActionSlot<SlotReturnType> slot, QMenu *menu, QWidget *parent)
{
QAction *act = parent
? actionForMenuItem(id, parent, Qt::WidgetWithChildrenShortcut)
: actionForMenuItem(id, this, Qt::WindowShortcut);
connect(act, &QAction::triggered, this, slot, Qt::UniqueConnection);
if (menu)
menu->addAction(act);
return act;
}
QAction *MainWindow::addTrayAction(Actions::Id id)
{
QAction *act = actionForMenuItem(id, m_trayMenu, Qt::WindowShortcut);
m_trayMenu->addAction(act);
return act;
}
void MainWindow::updateTabIcon(const QString &newName, const QString &oldName)
{
const QString icon = getIconNameForTabName(oldName);
if ( !icon.isEmpty() )
setIconNameForTabName(newName, icon);
}
template <typename Receiver, typename ReturnType>
QAction *MainWindow::addItemAction(Actions::Id id, Receiver *receiver, ReturnType (Receiver::* slot)())
{
QAction *act = actionForMenuItem(id, getPlaceholder(), Qt::WidgetWithChildrenShortcut);
connect( act, &QAction::triggered, receiver, slot, Qt::UniqueConnection );
m_menuItem->addAction(act);
return act;
}
QVector<Command> MainWindow::commandsForMenu(const QVariantMap &data, const QString &tabName, const QVector<Command> &allCommands)
{
QVector<Command> commands;
for (const auto &command : allCommands) {
if ( canExecuteCommand(command, data, tabName) ) {
Command cmd = command;
if ( cmd.outputTab.isEmpty() )
cmd.outputTab = tabName;
commands.append(cmd);
}
}
return commands;
}
void MainWindow::addCommandsToItemMenu(ClipboardBrowser *c)
{
if ( m_menuCommands.isEmpty() ) {
interruptMenuCommandFilters(&m_itemMenuMatchCommands);
return;
}
auto data = selectionData(*c);
const auto commands = commandsForMenu(data, c->tabName(), m_menuCommands);
for (const auto &command : commands) {
QString name = command.name;
QMenu *_rootMenu, *currentMenu;
std::tie(_rootMenu, currentMenu) = createSubMenus(&name, m_menuItem);
auto act = new CommandAction(command, name, currentMenu);
c->addAction(act);
addMenuMatchCommand(&m_itemMenuMatchCommands, command.matchCmd, act);
connect(act, &CommandAction::triggerCommand,
this, &MainWindow::onItemCommandActionTriggered);
}
runMenuCommandFilters(&m_itemMenuMatchCommands, data);
}
void MainWindow::addCommandsToTrayMenu(const QVariantMap &clipboardData, QList<QAction*> *actions)
{
if ( m_trayMenuCommands.isEmpty() ) {
interruptMenuCommandFilters(&m_trayMenuMatchCommands);
return;
}
ClipboardBrowserPlaceholder *placeholder = getPlaceholderForTrayMenu();
if (!placeholder)
return;
// Pass current window title to commands in tray menu.
auto data = clipboardData;
if (m_windowForMenuPaste)
data.insert( mimeWindowTitle, m_windowForMenuPaste->getTitle() );
const auto commands = commandsForMenu(data, placeholder->tabName(), m_trayMenuCommands);
QList<QKeySequence> usedShortcuts;
for (const auto &command : commands) {
QString name = command.name;
QMenu *rootMenu, *currentMenu;
std::tie(rootMenu, currentMenu) = createSubMenus(&name, m_trayMenu);
auto act = new CommandAction(command, name, currentMenu);
const QList<QKeySequence> uniqueShortcuts = getUniqueShortcuts(
command.globalShortcuts, &usedShortcuts);
act->setShortcuts(uniqueShortcuts);
if (rootMenu)
actions->append(rootMenu->menuAction());
else
actions->append(act);
addMenuMatchCommand(&m_trayMenuMatchCommands, command.matchCmd, act);
connect(act, &CommandAction::triggerCommand,
this, &MainWindow::onClipboardCommandActionTriggered);
}
runMenuCommandFilters(&m_trayMenuMatchCommands, data);
}
void MainWindow::addMenuMatchCommand(MenuMatchCommands *menuMatchCommands, const QString &matchCommand, QAction *act)
{
if ( !matchCommand.isEmpty() ) {
act->setDisabled(true);
menuMatchCommands->matchCommands.append(matchCommand);
menuMatchCommands->actions.append(act);
}
}
void MainWindow::runMenuCommandFilters(MenuMatchCommands *menuMatchCommands, QVariantMap &data)
{
if ( menuMatchCommands->actions.isEmpty() ) {
interruptMenuCommandFilters(menuMatchCommands);
return;
}
data[COPYQ_MIME_PREFIX "match-commands"] = menuMatchCommands->matchCommands;
const bool isRunning = isInternalActionId(menuMatchCommands->actionId);
if (isRunning) {
m_sharedData->actions->setActionData(menuMatchCommands->actionId, data);
} else {
const auto act = runScript(QStringLiteral("runMenuCommandFilters()"), data);
menuMatchCommands->actionId = act->id();
}
const int currentRun = ++menuMatchCommands->currentRun;
emit sendActionData(menuMatchCommands->actionId, QByteArray::number(currentRun));
}
void MainWindow::interruptMenuCommandFilters(MainWindow::MenuMatchCommands *menuMatchCommands)
{
++menuMatchCommands->currentRun;
menuMatchCommands->matchCommands.clear();
menuMatchCommands->actions.clear();
const bool isRunning = isInternalActionId(menuMatchCommands->actionId);
if (isRunning)
emit sendActionData(menuMatchCommands->actionId, QByteArray());
}
void MainWindow::stopMenuCommandFilters(MainWindow::MenuMatchCommands *menuMatchCommands)
{
++menuMatchCommands->currentRun;
menuMatchCommands->matchCommands.clear();
menuMatchCommands->actions.clear();
terminateAction(&menuMatchCommands->actionId);
}
void MainWindow::terminateAction(int *actionId)
{
if (*actionId == -1)
return;
const int id = *actionId;
*actionId = -1;
emit sendActionData(id, "ABORT");
}
bool MainWindow::isItemMenuDefaultActionValid() const
{
const auto defaultAction = m_menuItem->defaultAction();
return defaultAction != nullptr && defaultAction->isEnabled();
}
void MainWindow::updateToolBar()
{
clearActions(m_toolBar);
if ( m_toolBar->isHidden() )
return;
QAction *act = actionForMenuItem(Actions::File_New, this, Qt::WindowShortcut);
m_toolBar->addAction(act);
for ( auto action : m_menuItem->actions() ) {
if ( action->isSeparator() ) {
m_toolBar->addSeparator();
} else if ( !action->icon().isNull() ) {
act = m_toolBar->addAction(QString());
const auto update = [=]() {
const QIcon icon = action->icon();
act->setIcon(icon);
const QString text = action->text().remove("&");
const QString shortcut = action->shortcut().toString(QKeySequence::NativeText);
const QString label = text + (shortcut.isEmpty() ? QString() : "\n[" + shortcut + "]");
act->setText(label);
const QString tooltip = "<center>" + escapeHtml(text)
+ (shortcut.isEmpty() ? QString() : "<br /><b>" + escapeHtml(shortcut) + "</b>") + "</center>";
act->setToolTip(tooltip);
act->setEnabled(action->isEnabled());
if ( action->isCheckable() ) {
act->setCheckable(true);
act->setChecked(action->isChecked());
}
};
connect(act, &QAction::triggered, action, &QAction::triggered);
connect(action, &QAction::changed, act, update);
update();
}
}
m_toolBar->setFrozen(false);
}
void MainWindow::setTrayEnabled(bool enable)
{
if (enable) {
if (m_tray == nullptr) {
m_tray = new SystemTrayIcon(this);
} else {
disconnect( m_tray, &SystemTrayIcon::activated,
this, &MainWindow::trayActivated );
}
if (m_options.nativeTrayMenu) {
m_tray->setContextMenu(m_trayMenu);
} else {
#ifndef Q_OS_MAC
m_tray->setContextMenu(m_trayMenu);
#endif
connect( m_tray, &SystemTrayIcon::activated,
this, &MainWindow::trayActivated );
}
m_tray->show();
if ( isMinimized() )
hideWindow();
} else {
if (m_tray != nullptr)
m_tray->hide();
if ( isHidden() && !isMinimized() )
minimizeWindow();
}
}
bool MainWindow::isWindowVisible() const
{
return !isMinimized() && isVisible() && m_isActiveWindow;
}
void MainWindow::onEscape()
{
if ( browseMode() ) {
auto c = browser();
if (c && !c->hasFocus()) {
enterBrowseMode();
return;
}
hideWindow();
if (c)
c->setCurrent(0);
} else {
enterBrowseMode();
}
}
void MainWindow::updateActionShortcuts()
{
QList<QKeySequence> usedShortcuts;
for (auto act : m_menuItem->findChildren<CommandAction*>()) {
if (!act->isEnabled() && !act->isVisible())
continue;
if ( act->property(propertyActionFilterCommandFailed).toBool() )
continue;
const Command &command = act->command();
const QList<QKeySequence> uniqueShortcuts = getUniqueShortcuts(
command.shortcuts + command.globalShortcuts, &usedShortcuts);
for (const auto &shortcut : uniqueShortcuts) {
if ( !isItemMenuDefaultActionValid() && isItemActivationShortcut(shortcut) ) {
m_menuItem->setDefaultAction(act);
break;
}
}
act->setShortcuts(uniqueShortcuts);
}
for (int id = 0; id < m_actions.size(); ++id) {
QAction *action = m_actions[id];
if (!action)
continue;
QList<QKeySequence> shortcuts = m_sharedData->menuItems[id].shortcuts;
for (const auto &shortcut : usedShortcuts)
shortcuts.removeAll(shortcut);
action->setShortcuts(shortcuts);
}
}
QAction *MainWindow::actionForMenuItem(Actions::Id id, QWidget *parent, Qt::ShortcutContext context)
{
Q_ASSERT(id < m_sharedData->menuItems.size());
m_actions.resize(m_sharedData->menuItems.size());
QPointer<QAction> &action = m_actions[id];
if (action && !action->isEnabled() && !action->isVisible()) {
action->deleteLater();
action = nullptr;
}
const MenuItem &item = m_sharedData->menuItems[id];
if (!action) {
action = new QAction(item.text, parent);
action->setShortcutContext(context);
parent->addAction(action);
}
action->setIcon( getIcon(item.iconName, item.iconId) );
return action;
}
void MainWindow::addMenuItems(TrayMenu *menu, ClipboardBrowserPlaceholder *placeholder, int maxItemCount, const QString &searchText)
{
WidgetSizeGuard sizeGuard(menu);
menu->clearClipboardItems();
if (maxItemCount <= 0)
return;
if (!placeholder)
return;
const ClipboardBrowser *c = placeholder->createBrowser();
if (!c)
return;
int itemCount = 0;
for ( int i = 0; i < c->length() && itemCount < maxItemCount; ++i ) {
const QModelIndex index = c->model()->index(i, 0);
if ( !searchText.isEmpty() && !menuItemMatches(index, searchText) )
continue;
QVariantMap data = index.data(contentType::data).toMap();
QAction *act = menu->addClipboardItemAction(data, m_options.trayImages);
if ( !m_displayCommands.isEmpty() ) {
data.insert(mimeCurrentTab, c->tabName());
data.insert(mimeDisplayItemInMenu, QByteArrayLiteral("1"));
PersistentDisplayItem item(act, data);
onItemWidgetCreated(item);
}
++itemCount;
}
}
void MainWindow::activateMenuItem(ClipboardBrowserPlaceholder *placeholder, const QVariantMap &data, bool omitPaste)
{
if ( m_sharedData->moveItemOnReturnKey ) {
const auto itemHash = ::hash(data);
if (placeholder) {
ClipboardBrowser *c = placeholder->createBrowser();
if (c)
c->moveToTop(itemHash);
}
}
if ( QGuiApplication::queryKeyboardModifiers().testFlag(Qt::ShiftModifier) )
setClipboard( createDataMap(mimeText, data.value(mimeText) ) );
else
setClipboard(data);
if (!m_windowForMenuPaste)
updateFocusWindows();
PlatformWindowPtr lastWindow = m_windowForMenuPaste;
if ( m_options.trayItemPaste && !omitPaste && canPaste() ) {
if (isScriptOverridden(ScriptOverrides::Paste)) {
COPYQ_LOG("Pasting item with paste()");
runScript(QStringLiteral("paste()"));
} else if (lastWindow) {
COPYQ_LOG( QStringLiteral("Pasting item from tray menu to: %1")
.arg(lastWindow->getTitle()) );
lastWindow->pasteClipboard();
}
}
}
bool MainWindow::toggleMenu(TrayMenu *menu, QPoint pos)
{
if ( menu->isVisible() ) {
menu->close();
return false;
}
menu->popup( toScreen(pos, menu) );
raiseWindow(menu);
return true;
}
bool MainWindow::toggleMenu(TrayMenu *menu)
{
return toggleMenu(menu, QCursor::pos());
}
bool MainWindow::exportDataFrom(const QString &fileName, const QStringList &tabs, bool exportConfiguration, bool exportCommands)
{
QTemporaryFile file(fileName + ".XXXXXX.part");
if ( !file.open() ) {
log( QString("Failed to open temporary file: %1")
.arg(file.errorString()), LogError );
return false;
}
QDataStream out(&file);
if ( !exportDataV4(&out, tabs, exportConfiguration, exportCommands) )
return false;
if ( !file.flush() ) {
log( QString("Failed to flush temporary file %1: %2")
.arg(file.fileName(), file.errorString()), LogError );
return false;
}
QFile originalFile(fileName);
if ( originalFile.exists() && !originalFile.remove(fileName) ) {
log( QString("Failed to remove original file %1: %2")
.arg(fileName, originalFile.errorString()), LogError );
return false;
}
file.setAutoRemove(false);
if ( !file.rename(fileName) ) {
log( QString("Failed to move temporary file %1: %2")
.arg(file.fileName(), file.errorString()), LogError );
return false;
}
return true;
}
bool MainWindow::exportDataV4(QDataStream *out, const QStringList &tabs, bool exportConfiguration, bool exportCommands)
{
out->setVersion(QDataStream::Qt_4_7);
(*out) << QByteArray("CopyQ v4");
QVariantMap settingsMap;
if (exportConfiguration) {
const QSettings settings;
for (const auto &key : settings.allKeys()) {
if ( !key.startsWith("Commands/") )
settingsMap[key] = serializableValue(settings, key);
}
}
QVariantList commandsList;
if (exportCommands) {
Settings settings(getConfigurationFilePath("-commands.ini"));
const int commandCount = settings.beginReadArray("Commands");
commandsList.reserve(commandCount);
for (int i = 0; i < commandCount; ++i) {
settings.setArrayIndex(i);
QVariantMap commandMap;
for ( const auto &key : settings.allKeys() )
commandMap[key] = serializableValue(settings, key);
commandsList.append(commandMap);
}
settings.endArray();
}
QVariantMap data;
if ( !tabs.isEmpty() )
data["tabs"] = tabs;
if ( !settingsMap.isEmpty() )
data["settings"] = settingsMap;
if ( !commandsList.isEmpty() )
data["commands"] = commandsList;
(*out) << data;
for (const auto &tab : tabs) {
const auto i = findTabIndex(tab);
if (i == -1)
continue;
auto placeholder = getPlaceholder(i);
const bool wasLoaded = placeholder->isDataLoaded();
auto c = placeholder->createBrowserAgain();
if (!c) {
log(QString("Failed to open tab \"%1\" for export").arg(tab), LogError);
return false;
}
const auto &tabName = c->tabName();
bool saved = false;
QByteArray tabBytes;
{
QDataStream tabOut(&tabBytes, QIODevice::WriteOnly);
tabOut.setVersion(QDataStream::Qt_4_7);
saved = serializeData(*c->model(), &tabOut);
}
if (!wasLoaded)
placeholder->expire();
if (!saved) {
log(QString("Failed to export tab \"%1\"").arg(tab), LogError);
return false;
}
const auto iconName = getIconNameForTabName(tabName);
QVariantMap tabMap;
tabMap["name"] = tabName;
tabMap["data"] = tabBytes;
if ( !iconName.isEmpty() )
tabMap["icon"] = iconName;
(*out) << tabMap;
}
return out->status() == QDataStream::Ok;
}
bool MainWindow::importDataV3(QDataStream *in, ImportOptions options)
{
QByteArray header;
(*in) >> header;
if ( !header.startsWith("CopyQ v3") )
return false;
QVariantMap data;
(*in) >> data;
if ( in->status() != QDataStream::Ok )
return false;
const auto tabsList = data.value("tabs").toList();
QStringList tabs;
tabs.reserve( tabsList.size() );
for (const auto &tabMapValue : tabsList) {
const auto tabMap = tabMapValue.toMap();
const auto oldTabName = tabMap["name"].toString();
tabs.append(oldTabName);
}
const auto settingsMap = data.value("settings").toMap();
const auto commandsList = data.value("commands").toList();
bool importConfiguration = true;
bool importCommands = true;
if (options == ImportOptions::Select) {
ImportExportDialog importDialog(this);
importDialog.setWindowTitle( tr("Options for Import") );
importDialog.setTabs(tabs);
importDialog.setHasConfiguration( !settingsMap.isEmpty() );
importDialog.setHasCommands( !commandsList.isEmpty() );
importDialog.setConfigurationEnabled(true);
importDialog.setCommandsEnabled(true);
if ( importDialog.exec() != QDialog::Accepted )
return true;
tabs = importDialog.selectedTabs();
importConfiguration = importDialog.isConfigurationEnabled();
importCommands = importDialog.isCommandsEnabled();
}
const Tabs tabProps;
for (const auto &tabMapValue : tabsList) {
const auto tabMap = tabMapValue.toMap();
const auto oldTabName = tabMap["name"].toString();
if ( !tabs.contains(oldTabName) )
continue;
auto tabName = oldTabName;
renameToUnique( &tabName, ui->tabWidget->tabs() );
const auto iconName = tabMap.value("icon").toString();
if ( !iconName.isEmpty() )
setIconNameForTabName(tabName, iconName);
auto c = createTab(tabName, MatchExactTabName, tabProps)->createBrowser();
if (!c) {
log(QString("Failed to create tab \"%1\" for import").arg(tabName), LogError);
return false;
}
const auto tabBytes = tabMap.value("data").toByteArray();
QDataStream tabIn(tabBytes);
tabIn.setVersion(QDataStream::Qt_4_7);
// Don't read items based on current value of "maxitems" option since
// the option can be later also imported.
if ( !deserializeData( c->model(), &tabIn, Config::maxItems ) ) {
log(QString("Failed to import tab \"%1\"").arg(tabName), LogError);
return false;
}
const auto i = findTabIndex(tabName);
if (i != -1)
getPlaceholder(i)->expire();
}
if (importConfiguration) {
// Configuration dialog shouldn't be open.
if (cm) {
log("Failed to import configuration while configuration dialog is open", LogError);
return false;
}
Settings settings;
for (auto it = settingsMap.constBegin(); it != settingsMap.constEnd(); ++it)
settings.setValue( it.key(), it.value() );
AppConfig appConfig;
emit configurationChanged(&appConfig);
}
if (importCommands) {
// Close command dialog.
if ( !maybeCloseCommandDialog() ) {
log("Failed to import command while command dialog is open", LogError);
return false;
}
// Re-create command dialog again later.
if (m_commandDialog) {
m_commandDialog->deleteLater();
m_commandDialog = nullptr;
}
Settings settings;
int i = settings.beginReadArray("Commands");
settings.endArray();
settings.beginWriteArray("Commands");
for ( const auto &commandDataValue : commandsList ) {
settings.setArrayIndex(i++);
const auto commandMap = commandDataValue.toMap();
for (auto it = commandMap.constBegin(); it != commandMap.constEnd(); ++it)
settings.setValue( it.key(), it.value() );
}
settings.endArray();
updateEnabledCommands();
}
return in->status() == QDataStream::Ok;
}
bool MainWindow::importDataV4(QDataStream *in, ImportOptions options)
{
QByteArray header;
(*in) >> header;
if ( !header.startsWith("CopyQ v4") )
return false;
QVariantMap data;
(*in) >> data;
if ( in->status() != QDataStream::Ok )
return false;
QStringList tabs = data.value("tabs").toStringList();
const auto settingsMap = data.value("settings").toMap();
const auto commandsList = data.value("commands").toList();
bool importConfiguration = true;
bool importCommands = true;
if (options == ImportOptions::Select) {
ImportExportDialog importDialog(this);
importDialog.setWindowTitle( tr("Options for Import") );
importDialog.setTabs(tabs);
importDialog.setHasConfiguration( !settingsMap.isEmpty() );
importDialog.setHasCommands( !commandsList.isEmpty() );
importDialog.setConfigurationEnabled(true);
importDialog.setCommandsEnabled(true);
if ( importDialog.exec() != QDialog::Accepted )
return true;
tabs = importDialog.selectedTabs();
importConfiguration = importDialog.isConfigurationEnabled();
importCommands = importDialog.isCommandsEnabled();
}
const Tabs tabProps;
while ( !in->atEnd() ) {
QVariantMap tabMap;
(*in) >> tabMap;
if ( in->status() != QDataStream::Ok )
return false;
const auto oldTabName = tabMap["name"].toString();
if ( !tabs.contains(oldTabName) )
continue;
auto tabName = oldTabName;
renameToUnique( &tabName, ui->tabWidget->tabs() );
const auto iconName = tabMap.value("icon").toString();
if ( !iconName.isEmpty() )
setIconNameForTabName(tabName, iconName);
auto c = createTab(tabName, MatchExactTabName, tabProps)->createBrowser();
if (!c) {
log(QString("Failed to create tab \"%1\" for import").arg(tabName), LogError);
return false;
}
const auto tabBytes = tabMap.value("data").toByteArray();
QDataStream tabIn(tabBytes);
tabIn.setVersion(QDataStream::Qt_4_7);
// Don't read items based on current value of "maxitems" option since
// the option can be later also imported.
const int maxItems = importConfiguration ? Config::maxItems : m_sharedData->maxItems;
if ( !deserializeData( c->model(), &tabIn, maxItems ) ) {
log(QString("Failed to import tab \"%1\"").arg(tabName), LogError);
return false;
}
const auto i = findTabIndex(tabName);
if (i != -1)
getPlaceholder(i)->expire();
}
if (importConfiguration) {
// Configuration dialog shouldn't be open.
if (cm) {
log("Failed to import configuration while configuration dialog is open", LogError);
return false;
}
Settings settings;
for (auto it = settingsMap.constBegin(); it != settingsMap.constEnd(); ++it)
settings.setValue( it.key(), it.value() );
AppConfig appConfig;
emit configurationChanged(&appConfig);
}
if (importCommands) {
// Close command dialog.
if ( !maybeCloseCommandDialog() ) {
log("Failed to import command while command dialog is open", LogError);
return false;
}
// Re-create command dialog again later.
if (m_commandDialog) {
m_commandDialog->deleteLater();
m_commandDialog = nullptr;
}
Settings settings(getConfigurationFilePath("-commands.ini"));
int i = settings.beginReadArray("Commands");
settings.endArray();
settings.beginWriteArray("Commands");
for ( const auto &commandDataValue : commandsList ) {
settings.setArrayIndex(i++);
const auto commandMap = commandDataValue.toMap();
for (auto it = commandMap.constBegin(); it != commandMap.constEnd(); ++it)
settings.setValue( it.key(), it.value() );
}
settings.endArray();
updateEnabledCommands();
}
return in->status() == QDataStream::Ok;
}
void MainWindow::updateEnabledCommands()
{
updateCommands(loadAllCommands(), false);
}
void MainWindow::updateCommands(QVector<Command> allCommands, bool forceSave)
{
m_overrides = {};
m_actionCollectOverrides = runScript(QStringLiteral("collectScriptOverrides()"));
m_automaticCommands.clear();
m_menuCommands.clear();
m_scriptCommands.clear();
m_trayMenuCommands.clear();
QVector<Command> displayCommands;
if ( syncInternalCommands(&allCommands) || forceSave )
saveCommands(allCommands);
const auto disabledPluginCommands = m_sharedData->itemFactory->commands(false);
Commands commands;
for (const auto &command : allCommands) {
if ( command.enable && !hasCommandFuzzy(disabledPluginCommands, command) )
commands.append(command);
}
for (const auto &command : commands) {
const auto type = command.type();
if (type & CommandType::Automatic)
m_automaticCommands.append(command);
if (type & CommandType::Display)
displayCommands.append(command);
if (type & CommandType::Menu)
m_menuCommands.append(command);
if (m_options.trayCommands && type & CommandType::GlobalShortcut)
m_trayMenuCommands.append(command);
if (type & CommandType::Script)
m_scriptCommands.append(command);
}
if (m_displayCommands != displayCommands) {
m_displayItemList.clear();
m_displayCommands = displayCommands;
reloadBrowsers();
}
updateContextMenu(contextMenuUpdateIntervalMsec);
updateTrayMenuCommands();
emit commandsSaved(commands);
}
bool MainWindow::syncInternalCommands(QVector<Command> *allCommands)
{
bool changed = false;
for ( const Command &command : globalShortcutCommands() ) {
if ( syncInternalCommandChanges(command, allCommands) )
changed = true;
}
for ( const Command &command : m_sharedData->itemFactory->commands(true) ) {
if ( syncInternalCommandChanges(command, allCommands) ) {
changed = true;
} else if ( !hasCommandFuzzy(*allCommands, command) ) {
allCommands->append(command);
changed = true;
}
}
return changed;
}
void MainWindow::disableHideWindowOnUnfocus()
{
m_timerHideWindowIfNotActive.disconnect();
}
void MainWindow::enableHideWindowOnUnfocus()
{
initSingleShotTimer(
&m_timerHideWindowIfNotActive, m_timerHideWindowIfNotActive.interval(),
this, &MainWindow::hideWindowIfNotActive );
}
void MainWindow::hideWindowIfNotActive()
{
if ( isVisible() && !hasDialogOpen(this) && !isAnyApplicationWindowActive() ) {
COPYQ_LOG("Auto-hiding unfocused main window");
hideWindow();
}
}
const Theme &MainWindow::theme() const
{
return m_sharedData->theme;
}
Action *MainWindow::runScript(const QString &script, const QVariantMap &data)
{
auto act = new Action();
act->setCommand(
{QStringLiteral("copyq"), QStringLiteral("eval"), QStringLiteral("--"), script});
act->setData(data);
runInternalAction(act);
return act;
}
bool MainWindow::runEventHandlerScript(const QString &script, const QVariantMap &data)
{
if (m_maxEventHandlerScripts == 0)
return false;
--m_maxEventHandlerScripts;
if (m_maxEventHandlerScripts == 0)
log("Event handler maximum recursion reached", LogWarning);
const auto action = runScript(script, data);
const bool hasUpdatesEnabled = updatesEnabled();
setUpdatesEnabled(false);
action->waitForFinished();
setUpdatesEnabled(hasUpdatesEnabled || updatesEnabled());
++m_maxEventHandlerScripts;
return !action->actionFailed() && action->exitCode() == 0;
}
void MainWindow::runItemHandlerScript(
const QString &script, const ClipboardBrowser *browser, int firstRow, int lastRow)
{
QList<QPersistentModelIndex> indexes;
indexes.reserve(lastRow - firstRow + 1);
for (int row = firstRow; row <= lastRow; ++row) {
const auto index = browser->model()->index(row, 0);
if (index.isValid())
indexes.append(index);
}
QVariantMap data = createDataMap(mimeCurrentTab, browser->tabName());
addSelectionData(&data, indexes);
runScript(script, data);
}
int MainWindow::findTabIndex(const QString &name)
{
TabWidget *w = ui->tabWidget;
const int found = findTabIndexExactMatch(name);
if (found != -1)
return found;
// Ignore key hints ('&').
if ( !hasKeyHint(name) ) {
for( int i = 0; i < w->count(); ++i ) {
QString tabName = w->tabName(i);
if ( name == removeKeyHint(&tabName) )
return i;
}
}
return -1;
}
ClipboardBrowser *MainWindow::tab(const QString &name)
{
return createTab(name, MatchSimilarTabName, Tabs())->createBrowser();
}
bool MainWindow::maybeCloseCommandDialog()
{
return !m_commandDialog || m_commandDialog->maybeClose(this);
}
void MainWindow::showError(const QString &msg)
{
const auto notificationId = qHash(msg);
auto notification = createNotification( QString::number(notificationId) );
notification->setTitle( tr("CopyQ Error", "Notification error message title") );
notification->setMessage(msg);
notification->setIcon(IconCircleXmark);
}
Notification *MainWindow::createNotification(const QString &id)
{
return m_sharedData->notifications->createNotification(id);
}
void MainWindow::addCommands(const QVector<Command> &commands)
{
openCommands();
if (m_commandDialog)
m_commandDialog->addCommands(commands);
}
void MainWindow::keyPressEvent(QKeyEvent *event)
{
const int key = event->key();
const Qt::KeyboardModifiers modifiers = event->modifiers();
// Search items or text in editor (search previous when Shift is pressed).
if ( key == Qt::Key_F3
|| (modifiers.testFlag(Qt::ControlModifier) && (key == Qt::Key_F || key == Qt::Key_G)) )
{
findNextOrPrevious();
return;
}
auto c = browser();
if (c && c->isInternalEditorOpen())
return;
if (m_options.hideTabs && key == Qt::Key_Alt)
setHideTabs(false);
if (m_options.navigationStyle == NavigationStyle::Vi) {
if (modifiers == Qt::ControlModifier && key == Qt::Key_BracketLeft) {
onEscape();
return;
}
if (browseMode()) {
if (c && handleViKey(event, c))
return;
switch(key) {
case Qt::Key_Slash:
enterSearchMode();
event->accept();
return;
case Qt::Key_H:
previousTab();
event->accept();
return;
case Qt::Key_L:
nextTab();
event->accept();
return;
}
}
}
if (m_options.navigationStyle == NavigationStyle::Emacs) {
if ((modifiers == Qt::ControlModifier && key == Qt::Key_G)
|| (key == Qt::Key_Escape)) {
onEscape();
return;
}
if (browseMode() && c && handleEmacsKey(event, c)) {
return;
}
}
if ( event->matches(QKeySequence::NextChild) ) {
nextTab();
return;
}
if ( event->matches(QKeySequence::PreviousChild) ) {
previousTab();
return;
}
// Ctrl/Alt+0 to Ctrl/Alt+9 to focus tabs (0 to focus the last, 1 to focus the first and so on).
if (modifiers == Qt::ControlModifier || modifiers == Qt::AltModifier) {
if (key >= Qt::Key_0 && key <= Qt::Key_9) {
const int index = (key == Qt::Key_0) ? ui->tabWidget->count() - 1
: key - Qt::Key_1;
ui->tabWidget->setCurrentIndex(index);
return;
}
}
// Allow browsing items in search mode without focusing item list.
if ( c && ui->searchBar->hasFocus() ) {
if ( event->matches(QKeySequence::Copy) && ui->searchBar->selectionLength() == 0 ) {
copyItems();
return;
}
switch(key) {
case Qt::Key_Down:
case Qt::Key_Up:
case Qt::Key_PageDown:
case Qt::Key_PageUp:
c->setFocus();
QCoreApplication::sendEvent(c, event);
ui->searchBar->setFocus();
return;
}
}
if (modifiers == Qt::ControlModifier) {
switch(key) {
case Qt::Key_Return:
case Qt::Key_Enter:
if (c)
activateCurrentItem();
return;
default:
QMainWindow::keyPressEvent(event);
break;
}
return;
}
if (modifiers == Qt::AltModifier)
return;
switch(key) {
case Qt::Key_Return:
case Qt::Key_Enter:
if (c)
activateCurrentItem();
else
getPlaceholder()->createBrowser();
break;
case Qt::Key_Tab:
QMainWindow::keyPressEvent(event);
break;
#ifndef Q_OS_MAC
case Qt::Key_Backspace:
// fallthrough
#endif // Q_OS_MAC
case Qt::Key_Escape:
onEscape();
break;
default:
QMainWindow::keyPressEvent(event);
break;
}
}
void MainWindow::keyReleaseEvent(QKeyEvent *event)
{
if (m_options.hideTabs && event->key() == Qt::Key_Alt)
setHideTabs(true);
QMainWindow::keyReleaseEvent(event);
}
bool MainWindow::event(QEvent *event)
{
QEvent::Type type = event->type();
if (type == QEvent::Enter) {
if ( !isActiveWindow() )
updateFocusWindows();
updateWindowTransparency(true);
} else if (type == QEvent::Leave) {
updateWindowTransparency(false);
setHideTabs(m_options.hideTabs);
} else if (type == QEvent::WindowActivate) {
m_isActiveWindow = true;
if ( !isActiveWindow() )
updateFocusWindows();
updateWindowTransparency();
enableHideWindowOnUnfocus();
} else if (type == QEvent::WindowDeactivate) {
updateWindowTransparency();
setHideTabs(m_options.hideTabs);
m_timerUpdateFocusWindows.start();
} else if (type == QEvent::Hide) {
m_wasMaximized = isMaximized();
}
return QMainWindow::event(event);
}
bool MainWindow::nativeEvent(
const QByteArray &eventType, void *message, NativeEventResult *result)
{
delayedUpdateForeignFocusWindows();
return QMainWindow::nativeEvent(eventType, message, result);
}
void MainWindow::loadSettings(QSettings &settings, AppConfig *appConfig)
{
stopMenuCommandFilters(&m_itemMenuMatchCommands);
stopMenuCommandFilters(&m_trayMenuMatchCommands);
terminateAction(&m_displayActionId);
theme().decorateMainWindow(this);
ui->scrollAreaItemPreview->setObjectName("ClipboardBrowser");
theme().decorateItemPreview(ui->scrollAreaItemPreview);
setUseSystemIcons( theme().useSystemIcons() );
m_options.confirmExit = appConfig->option<Config::confirm_exit>();
// always on top window hint
bool alwaysOnTop = appConfig->option<Config::always_on_top>();
setAlwaysOnTop(this, alwaysOnTop);
setAlwaysOnTop(m_commandDialog.data(), alwaysOnTop);
m_options.navigationStyle = appConfig->option<Config::navigation_style>();
m_trayMenu->setNavigationStyle(m_options.navigationStyle);
m_menu->setNavigationStyle(m_options.navigationStyle);
// Number search
m_trayMenu->setNumberSearchEnabled(m_sharedData->numberSearch);
m_menu->setNumberSearchEnabled(m_sharedData->numberSearch);
m_trayMenu->setRowIndexFromOne(m_sharedData->rowIndexFromOne);
m_menu->setRowIndexFromOne(m_sharedData->rowIndexFromOne);
m_sharedData->theme.setRowIndexFromOne(m_sharedData->rowIndexFromOne);
m_options.transparency = appConfig->option<Config::transparency>();
m_options.transparencyFocused = appConfig->option<Config::transparency_focused>();
updateWindowTransparency();
// save unsaved tab data
if ( ui->tabWidget->count() != 0 ) {
if ( m_timerSaveTabPositions.isActive() )
doSaveTabPositions(appConfig);
ui->tabWidget->saveTabInfo();
}
const QStringList tabNames = savedTabs();
// tab bar position
const bool tabTreeEnabled = appConfig->option<Config::tab_tree>();
ui->tabWidget->setTreeModeEnabled(tabTreeEnabled);
ui->tabWidget->setTabItemCountVisible(appConfig->option<Config::show_tab_item_count>());
for ( auto scrollArea : ui->tabWidget->toolBar()->findChildren<QAbstractScrollArea*>() )
theme().decorateScrollArea(scrollArea);
// create tabs
const Tabs tabs;
for (const auto &name : tabNames)
createTab(name, MatchExactTabName, tabs);
ui->tabWidget->setTabsOrder(tabNames);
m_options.hideTabs = appConfig->option<Config::hide_tabs>();
setHideTabs(m_options.hideTabs);
bool hideToolbar = appConfig->option<Config::hide_toolbar>();
clearActions(m_toolBar);
m_toolBar->setHidden(hideToolbar);
bool hideToolBarLabels = appConfig->option<Config::hide_toolbar_labels>();
m_toolBar->setToolButtonStyle(hideToolBarLabels ? Qt::ToolButtonIconOnly
: Qt::ToolButtonTextUnderIcon);
m_options.hideMainWindow = appConfig->option<Config::hide_main_window>();
m_options.closeOnUnfocus = appConfig->option<Config::close_on_unfocus>();
m_timerHideWindowIfNotActive.setInterval(
appConfig->option<Config::close_on_unfocus_delay_ms>());
const bool hideInTaskBar = appConfig->option<Config::hide_main_window_in_task_bar>();
setHideInTaskBar(this, hideInTaskBar);
Q_ASSERT( ui->tabWidget->count() > 0 );
// Save any tabs loaded from new tab files.
appConfig->setOption("tabs", tabNames);
reloadBrowsers();
ui->tabWidget->updateTabs(settings);
m_timerSaveTabPositions.stop();
updateContextMenu(contextMenuUpdateIntervalMsec);
updateItemPreviewAfterMs(itemPreviewUpdateIntervalMsec);
m_options.itemActivationCommands = ActivateNoCommand;
if ( appConfig->option<Config::activate_closes>() )
m_options.itemActivationCommands |= ActivateCloses;
if ( appConfig->option<Config::activate_focuses>() )
m_options.itemActivationCommands |= ActivateFocuses;
if ( appConfig->option<Config::activate_pastes>() )
m_options.itemActivationCommands |= ActivatePastes;
m_options.trayItems = appConfig->option<Config::tray_items>();
m_options.trayItemPaste = appConfig->option<Config::tray_item_paste>();
m_options.trayCommands = appConfig->option<Config::tray_commands>();
m_options.trayCurrentTab = appConfig->option<Config::tray_tab_is_current>();
m_options.trayTabName = appConfig->option<Config::tray_tab>();
m_options.trayImages = appConfig->option<Config::tray_images>();
m_options.trayMenuOpenOnLeftClick = appConfig->option<Config::tray_menu_open_on_left_click>();
m_options.clipboardTab = appConfig->option<Config::clipboard_tab>();
m_singleClickActivate = appConfig->option<Config::activate_item_with_single_click>();
const auto menuStyleSheet = theme().getMenuStyleSheet();
m_trayMenu->setStyleSheet(menuStyleSheet);
m_menu->setStyleSheet(menuStyleSheet);
if (m_options.nativeTrayMenu != appConfig->option<Config::native_tray_menu>())
m_options.nativeTrayMenu = appConfig->option<Config::native_tray_menu>();
setTrayEnabled( !appConfig->option<Config::disable_tray>() );
updateTrayMenuItems();
updateIcon();
menuBar()->setNativeMenuBar( appConfig->option<Config::native_menu_bar>() );
ui->searchBar->loadSettings();
settings.beginGroup("Shortcuts");
loadShortcuts(&m_sharedData->menuItems, settings);
updateActionShortcuts();
settings.endGroup();
enterBrowseMode();
updateEnabledCommands();
m_sharedData->notifications->setIconColor( theme().color("notification_fg") );
}
void MainWindow::loadTheme(const QSettings &themeSettings)
{
m_sharedData->theme.loadTheme(themeSettings);
if (themeSettings.status() != QSettings::NoError)
return;
{
Settings settings;
settings.beginGroup("Theme");
m_sharedData->theme.saveTheme(&settings);
settings.endGroup();
}
AppConfig appConfig;
emit configurationChanged(&appConfig);
}
void MainWindow::openHelp()
{
QDesktopServices::openUrl( QUrl("https://copyq.readthedocs.io") );
}
void MainWindow::showWindow()
{
if ( isWindowVisible() )
return;
m_trayMenu->close();
m_menu->close();
updateFocusWindows();
moveToCurrentWorkspace(this);
if (m_wasMaximized || isMaximized())
showMaximized();
else
showNormal();
auto c = browser();
if (c) {
if ( !c->isInternalEditorOpen() )
c->scrollTo( c->currentIndex() );
c->setFocus();
}
raiseWindow(this);
}
void MainWindow::hideWindow()
{
if ( closeMinimizes() )
minimizeWindow();
else
hide();
// It can be unexpected to have search active or random items selected when
// reopening main window. This resets search and selection after the window
// is closed.
if ( !browseMode() ) {
enterBrowseMode();
auto c = browser();
if (c)
c->setCurrent(0);
}
}
void MainWindow::minimizeWindow()
{
if (m_options.hideMainWindow)
hide();
else
showMinimized();
}
bool MainWindow::toggleVisible()
{
if ( isWindowVisible() ) {
hideWindow();
return false;
}
showWindow();
return true;
}
void MainWindow::showBrowser(const ClipboardBrowser *browser)
{
int i = 0;
for( ; i < ui->tabWidget->count() && getPlaceholder(i)->browser() != browser; ++i ) {}
setCurrentTab(i);
showWindow();
}
bool MainWindow::setCurrentTab(int index)
{
if ( index < 0 || ui->tabWidget->count() <= index )
return false;
ui->tabWidget->setCurrentIndex(index);
return true;
}
bool MainWindow::focusPrevious()
{
if ( !m_windowForMainPaste )
return false;
m_windowForMainPaste->raise();
return true;
}
void MainWindow::onMenuActionTriggered(const QVariantMap &data, bool omitPaste)
{
m_menu->close();
activateMenuItem( getPlaceholderForMenu(), data, omitPaste );
}
void MainWindow::onTrayActionTriggered(const QVariantMap &data, bool omitPaste)
{
m_trayMenu->close();
activateMenuItem( getPlaceholderForTrayMenu(), data, omitPaste );
}
void MainWindow::trayActivated(int reason)
{
#ifdef Q_OS_MAC
if (!m_options.nativeTrayMenu && reason == QSystemTrayIcon::Context) {
toggleMenu();
return;
}
#endif
if ( reason == QSystemTrayIcon::MiddleClick
|| (m_options.trayMenuOpenOnLeftClick && reason == QSystemTrayIcon::Trigger) )
{
toggleMenu();
} else if ( reason == QSystemTrayIcon::Trigger || reason == QSystemTrayIcon::DoubleClick ) {
// Like toggleVisible() but hide window if visible and not focused
// (this seems better behavior when using mouse).
if (!isMinimized() && isVisible())
hideWindow();
else
showWindow();
}
}
bool MainWindow::toggleMenu()
{
m_trayMenu->search(QString());
if ( !m_trayMenu->isVisible() )
updateTrayMenuItemsTimeout();
return toggleMenu(m_trayMenu);
}
bool MainWindow::toggleMenu(const QString &tabName, int itemCount, QPoint position)
{
// Just close the previously opened menu if parameters are the same.
if ( m_menu->isVisible()
&& (m_menuTabName == tabName && m_menuMaxItemCount == itemCount) )
{
m_menu->close();
return false;
}
WidgetSizeGuard sizeGuard(m_menu);
m_menuTabName = tabName;
m_menuMaxItemCount = itemCount;
if (m_menuMaxItemCount < 0)
m_menuMaxItemCount = m_options.trayItems > 0 ? m_options.trayItems : 10;
m_menu->clearAllActions();
filterMenuItems(QString());
if ( m_menu->isVisible() )
m_menu->close();
if ( m_menu->isEmpty() )
return false;
if (position.x() >= 0 && position.y() >= 0)
return toggleMenu(m_menu, position);
return toggleMenu(m_menu);
}
void MainWindow::tabChanged(int current, int)
{
bool currentIsTabGroup = current == -1;
emit tabGroupSelected(currentIsTabGroup);
if (!currentIsTabGroup) {
// update item menu (necessary for keyboard shortcuts to work)
auto c = browser();
if (c) {
c->filterItems( browseMode() ? nullptr : ui->searchBar->filter() );
if ( current >= 0 ) {
if( !c->currentIndex().isValid() && isVisible() ) {
c->setCurrent(0);
}
}
setTabOrder(ui->searchBar, c);
if (isScriptOverridden(ScriptOverrides::OnTabSelected)) {
runScript(
QStringLiteral("onTabSelected()"),
createDataMap(mimeCurrentTab, c->tabName()));
}
}
}
updateContextMenu(0);
updateItemPreviewAfterMs(0);
if (m_options.trayCurrentTab)
updateTrayMenuItems();
}
void MainWindow::saveTabPositions()
{
m_timerSaveTabPositions.start();
}
void MainWindow::onSaveTabPositionsTimer()
{
AppConfig appConfig;
doSaveTabPositions(&appConfig);
}
void MainWindow::doSaveTabPositions(AppConfig *appConfig)
{
m_timerSaveTabPositions.stop();
const QStringList tabs = ui->tabWidget->tabs();
appConfig->setOption("tabs", tabs);
}
void MainWindow::tabsMoved(const QString &oldPrefix, const QString &newPrefix)
{
const QStringList tabs = ui->tabWidget->tabs();
Q_ASSERT( oldPrefix == newPrefix || !tabs.contains(oldPrefix) );
Q_ASSERT( !tabs.contains(QString()) );
const QString prefix = oldPrefix + '/';
// Rename tabs if needed.
for (int i = 0 ; i < tabs.size(); ++i) {
auto placeholder = getPlaceholder(i);
const QString oldTabName = placeholder->tabName();
if ( (oldTabName == oldPrefix || oldTabName.startsWith(prefix)) && newPrefix != oldPrefix) {
const QString newName = newPrefix + oldTabName.mid(oldPrefix.size());
updateTabIcon(newName, placeholder->tabName());
if ( placeholder->setTabName(newName) ) {
auto c = placeholder->browser();
if (c)
ui->tabWidget->setTabItemCount( newName, c->length() );
}
}
}
saveTabPositions();
}
void MainWindow::tabBarMenuRequested(QPoint pos, int tab)
{
auto placeholder = getPlaceholder(tab);
if (placeholder == nullptr)
return;
const QString tabName = placeholder->tabName();
popupTabBarMenu(pos, tabName);
}
void MainWindow::tabTreeMenuRequested(QPoint pos, const QString &groupPath)
{
popupTabBarMenu(pos, groupPath);
}
void MainWindow::tabCloseRequested(int tab)
{
removeTab(true, tab);
}
QVariant MainWindow::config(const QVariantList &nameValue)
{
AppConfig appConfig;
if ( m_timerSaveTabPositions.isActive() )
doSaveTabPositions(&appConfig);
ConfigurationManager configurationManager;
QStringList unknownOptions;
const auto validOptions = configurationManager.options();
// Check if option names are valid.
for (int i = 0; i < nameValue.size(); i += 2) {
const QString name = nameValue[i].toString();
if ( !validOptions.contains(name) )
unknownOptions.append(name);
}
if ( !unknownOptions.isEmpty() )
return unknownOptions;
configurationManager.loadSettings(&appConfig);
QVariantMap result;
bool emitConfigurationChanged = false;
for (int i = 0; i < nameValue.size(); i += 2) {
const QString name = nameValue[i].toString();
const QVariant value = nameValue.value(i + 1);
if ( i + 1 < nameValue.size() && configurationManager.setOptionValue(name, value, &appConfig) )
emitConfigurationChanged = true;
result.insert( name, configurationManager.optionValue(name) );
}
if (emitConfigurationChanged) {
configurationManager.setAutostartEnable(&appConfig);
emit configurationChanged(&appConfig);
}
return result;
}
QString MainWindow::configDescription()
{
ConfigurationManager configurationManager;
QStringList options = configurationManager.options();
options.sort();
QString opts;
AppConfig appConfig;
configurationManager.loadSettings(&appConfig);
for (const auto &option : options) {
const QString description = configurationManager.optionToolTip(option).replace('\n', "\n ");
const QString value = configurationManager.optionValue(option).toString().replace('\n', "\\n");
opts.append( QStringLiteral("%1=%2\n %3\n").arg(option, value, description) );
}
return opts;
}
QVariantMap MainWindow::actionData(int id) const
{
return m_sharedData->actions->actionData(id);
}
void MainWindow::setActionData(int id, const QVariantMap &data)
{
m_sharedData->actions->setActionData(id, data);
}
void MainWindow::setCommands(const QVector<Command> &commands)
{
if ( !maybeCloseCommandDialog() )
return;
updateCommands(commands, true);
}
void MainWindow::setSessionIconColor(QColor color)
{
::setSessionIconColor(color);
updateIcon();
}
void MainWindow::setSessionIconTag(const QString &tag)
{
::setSessionIconTag(tag);
updateIcon();
}
void MainWindow::setSessionIconTagColor(QColor color)
{
::setSessionIconTagColor(color);
updateIcon();
}
QColor MainWindow::sessionIconColor() const
{
return ::sessionIconColor();
}
QString MainWindow::sessionIconTag() const
{
return ::sessionIconTag();
}
QColor MainWindow::sessionIconTagColor() const
{
return ::sessionIconTagColor();
}
void MainWindow::setTrayTooltip(const QString &tooltip)
{
if (m_tray)
m_tray->setToolTip(tooltip);
}
bool MainWindow::setMenuItemEnabled(int actionId, int currentRun, int menuItemMatchCommandIndex, const QVariantMap &menuItem)
{
if (actionId != m_trayMenuMatchCommands.actionId && actionId != m_itemMenuMatchCommands.actionId)
return false;
const auto &menuMatchCommands = actionId == m_trayMenuMatchCommands.actionId
? m_trayMenuMatchCommands
: m_itemMenuMatchCommands;
if (currentRun != menuMatchCommands.currentRun)
return false;
if (menuMatchCommands.actions.size() <= menuItemMatchCommandIndex)
return false;
auto action = menuMatchCommands.actions[menuItemMatchCommandIndex];
if (!action)
return true;
for (auto it = menuItem.constBegin(); it != menuItem.constEnd(); ++it) {
const auto &key = it.key();
if (key == menuItemKeyColor || key == menuItemKeyIcon || key == menuItemKeyTag)
continue;
const auto value = it.value();
action->setProperty(key.toLatin1(), value);
}
if ( menuItem.contains(menuItemKeyTag) || menuItem.contains(menuItemKeyIcon) ) {
QString icon = menuItem.value(menuItemKeyIcon).toString();
if (icon.isEmpty()) {
const auto commandAction = qobject_cast<CommandAction*>(action);
if (commandAction)
icon = commandAction->command().icon;
}
const QString colorName = menuItem.value(menuItemKeyColor).toString();
const QColor color = colorName.isEmpty() ? getDefaultIconColor(*this) : deserializeColor(colorName);
const QString tag = menuItem.value(menuItemKeyTag).toString();
action->setIcon( iconFromFile(icon, tag, color) );
}
const bool enabled = action->isEnabled();
action->setProperty(propertyActionFilterCommandFailed, !enabled);
const auto shortcuts = action->shortcuts();
if ( !enabled && (actionId == m_trayMenuMatchCommands.actionId || !m_menuItem->isVisible()) )
action->deleteLater();
if ( !shortcuts.isEmpty() )
updateActionShortcuts();
return true;
}
QVariantMap MainWindow::setDisplayData(int actionId, const QVariantMap &data)
{
if (m_displayActionId != actionId)
return QVariantMap();
m_currentDisplayItem.setData(data);
clearHiddenDisplayData();
if ( m_displayItemList.isEmpty() )
return QVariantMap();
m_currentDisplayItem = m_displayItemList.takeFirst();
m_sharedData->actions->setActionData(actionId, m_currentDisplayItem.data());
return m_currentDisplayItem.data();
}
void MainWindow::nextTab()
{
ui->tabWidget->nextTab();
}
void MainWindow::previousTab()
{
ui->tabWidget->previousTab();
}
void MainWindow::setClipboard(const QVariantMap &data)
{
setClipboard(data, ClipboardMode::Clipboard);
#ifdef HAS_MOUSE_SELECTIONS
setClipboard(data, ClipboardMode::Selection);
#endif
}
void MainWindow::setClipboard(const QVariantMap &data, ClipboardMode mode)
{
m_clipboard->setData(mode, data);
}
void MainWindow::setClipboardAndSelection(const QVariantMap &data)
{
setClipboard(data);
}
void MainWindow::moveToClipboard(ClipboardBrowser *c, int row)
{
const auto index = c ? c->index(row) : QModelIndex();
if ( index.isValid() )
c->moveToClipboard(index);
else
setClipboard(QVariantMap());
}
const QMimeData *MainWindow::getClipboardData(ClipboardMode mode)
{
return m_clipboard->mimeData(mode);
}
void MainWindow::activateCurrentItem()
{
// Omit activating item multiple times in quick succession.
if (m_activatingItem)
return;
m_activatingItem = true;
activateCurrentItemHelper();
m_activatingItem = false;
}
void MainWindow::activateCurrentItemHelper()
{
if ( QApplication::queryKeyboardModifiers() == Qt::NoModifier
&& isItemMenuDefaultActionValid() )
{
m_menuItem->defaultAction()->trigger();
return;
}
auto c = browser();
if (!c)
return;
// Perform custom actions on item activation.
PlatformWindowPtr lastWindow = m_windowForMainPaste;
const bool paste = m_options.activatePastes() && canPaste();
const bool activateWindow = m_options.activateFocuses();
// Copy current item or selection to clipboard.
// While clipboard is being set (in separate process)
// activate target window for pasting.
c->moveToClipboard();
if ( m_options.activateCloses() )
hideWindow();
if (lastWindow && activateWindow)
lastWindow->raise();
enterBrowseMode();
if (paste) {
if (isScriptOverridden(ScriptOverrides::Paste)) {
COPYQ_LOG("Pasting item with paste()");
runScript(QStringLiteral("paste()"));
} else if (lastWindow) {
COPYQ_LOG( QStringLiteral("Pasting item from main window to: %1")
.arg(lastWindow->getTitle()) );
lastWindow->pasteClipboard();
}
}
}
void MainWindow::onItemClicked()
{
if (m_singleClickActivate && QGuiApplication::keyboardModifiers() == Qt::NoModifier)
activateCurrentItem();
}
void MainWindow::onItemDoubleClicked()
{
if (!m_singleClickActivate)
activateCurrentItem();
}
void MainWindow::disableClipboardStoring(bool disable)
{
if (m_clipboardStoringDisabled == disable)
return;
m_clipboardStoringDisabled = disable;
emit disableClipboardStoringRequest(disable);
::setSessionIconEnabled(!disable);
updateIcon();
runScript(QStringLiteral("setTitle(); showDataNotification()"));
COPYQ_LOG( QString("Clipboard monitoring %1.")
.arg(m_clipboardStoringDisabled ? "disabled" : "enabled") );
}
bool MainWindow::isMonitoringEnabled() const
{
return !m_clipboardStoringDisabled;
}
void MainWindow::toggleClipboardStoring()
{
disableClipboardStoring(!m_clipboardStoringDisabled);
}
QStringList MainWindow::tabs() const
{
return ui->tabWidget->tabs();
}
ClipboardBrowserPlaceholder *MainWindow::getPlaceholderForMenu()
{
const auto i = findTabIndex(m_menuTabName);
return i != -1 ? getPlaceholder(i) : nullptr;
}
ClipboardBrowserPlaceholder *MainWindow::getPlaceholderForTrayMenu()
{
if (m_options.trayCurrentTab)
return getPlaceholder();
if ( m_options.trayTabName.isEmpty() )
return m_options.clipboardTab.isEmpty() ? nullptr : getPlaceholder(m_options.clipboardTab);
int i = findTabIndex(m_options.trayTabName);
return i != -1 ? getPlaceholder(i) : nullptr;
}
void MainWindow::onFilterChanged()
{
ItemFilterPtr filter = ui->searchBar->filter();
if ( filter->matchesAll() )
enterBrowseMode();
else if ( browseMode() )
enterSearchMode();
auto c = browser();
if (c)
c->filterItems(filter);
updateItemPreviewAfterMs(2 * itemPreviewUpdateIntervalMsec);
}
void MainWindow::raiseLastWindowAfterMenuClosed()
{
if ( m_windowForMenuPaste && !isAnyApplicationWindowActive() )
m_windowForMenuPaste->raise();
}
void MainWindow::updateFocusWindows()
{
m_isActiveWindow = isActiveWindow();
if ( QApplication::activePopupWidget() )
return;
auto platform = platformNativeInterface();
PlatformWindowPtr lastWindow = platform->getCurrentWindow();
if (lastWindow) {
const QWidget *activeWindow = qApp->activeWindow();
if (activeWindow) {
if (activeWindow == m_trayMenu || activeWindow == m_menu) {
COPYQ_LOG(
QStringLiteral("Focus window is \"%1\" - tray menu")
.arg(lastWindow->getTitle()) );
} else if (activeWindow == this) {
COPYQ_LOG(QStringLiteral("Focus window is the main window"));
m_windowForMenuPaste = lastWindow;
} else {
COPYQ_LOG(QStringLiteral("Focus window is \"%1\": [%2] %3").arg(
lastWindow->getTitle(),
QLatin1String(activeWindow->metaObject()->className()),
activeWindow->windowTitle()
));
m_windowForMainPaste = lastWindow;
m_windowForMenuPaste = lastWindow;
}
} else {
COPYQ_LOG( QStringLiteral("Focus window is \"%1\"").arg(lastWindow->getTitle()) );
m_windowForMainPaste = lastWindow;
m_windowForMenuPaste = lastWindow;
}
}
if (m_options.closeOnUnfocus)
m_timerHideWindowIfNotActive.start();
}
void MainWindow::updateShortcuts()
{
if ( m_timerUpdateContextMenu.isActive() ) {
m_timerUpdateContextMenu.stop();
updateContextMenuTimeout();
}
}
void MainWindow::findNextOrPrevious()
{
if (browseMode()) {
enterSearchMode();
} else {
auto c = browser();
if (!c)
return;
const bool next = !QApplication::keyboardModifiers().testFlag(Qt::ShiftModifier);
if ( c->isInternalEditorOpen() ) {
ui->searchBar->setFocus(Qt::ShortcutFocusReason);
if (next)
c->findNext();
else
c->findPrevious();
} else {
c->setFocus();
c->setCurrent( c->currentIndex().row() + (next ? 1 : -1) );
}
}
}
void MainWindow::enterBrowseMode()
{
getPlaceholder()->setFocus();
ui->searchBar->hide();
auto c = browserOrNull();
if (c)
c->filterItems(nullptr);
}
void MainWindow::enterSearchMode()
{
ui->searchBar->show();
ui->searchBar->setFocus(Qt::ShortcutFocusReason);
if ( !ui->searchBar->text().isEmpty() ) {
auto c = browserOrNull();
if (c) {
const int currentRow = c->currentIndex().row();
c->filterItems( ui->searchBar->filter() );
c->setCurrent(currentRow);
}
}
}
void MainWindow::enterSearchMode(const QString &txt)
{
const bool searchModeActivated = !ui->searchBar->isVisible();
ui->searchBar->show();
ui->searchBar->setFocus(Qt::ShortcutFocusReason);
if (searchModeActivated)
ui->searchBar->setText(txt);
else
ui->searchBar->setText( ui->searchBar->text() + txt );
auto c = browser();
if (c)
c->filterItems( ui->searchBar->filter() );
}
void MainWindow::updateTrayMenuItemsTimeout()
{
if (!m_trayMenuDirty)
return;
// Update tray only if not currently visible.
if ( m_trayMenu->isVisible() ) {
updateTrayMenuItems();
return;
}
COPYQ_LOG("Updating tray menu");
WidgetSizeGuard sizeGuard(m_trayMenu);
initTrayMenuItems();
}
void MainWindow::initTrayMenuItems()
{
m_trayMenuDirty = false;
interruptMenuCommandFilters(&m_trayMenuMatchCommands);
m_trayMenu->clearClipboardItems();
filterTrayMenuItems(QString());
}
void MainWindow::filterMenuItems(const QString &searchText)
{
addMenuItems(m_menu, getPlaceholderForMenu(), m_menuMaxItemCount, searchText);
}
void MainWindow::filterTrayMenuItems(const QString &searchText)
{
addMenuItems(m_trayMenu, getPlaceholderForTrayMenu(), m_options.trayItems, searchText);
m_trayMenu->markItemInClipboard(m_clipboardData);
}
void MainWindow::openLogDialog()
{
openDialog<LogDialog>(this);
}
void MainWindow::openAboutDialog()
{
openDialog<AboutDialog>(this);
}
void MainWindow::showClipboardContent()
{
ClipboardDialog *clipboardDialog = openDialog<ClipboardDialog>(this);
connect( clipboardDialog, &ClipboardDialog::changeClipboard,
this, &MainWindow::setClipboardAndSelection );
}
void MainWindow::showProcessManagerDialog()
{
m_sharedData->actions->showProcessManagerDialog(this);
}
ActionDialog *MainWindow::openActionDialog(const QVariantMap &data)
{
auto actionDialog = openDialog<ActionDialog>(this);
actionDialog->setInputData(data);
const auto tabs = ui->tabWidget->tabs();
actionDialog->setOutputTabs(tabs);
const int currentTabIndex = ui->tabWidget->currentIndex();
if (currentTabIndex >= 0) {
const auto currentTab = ui->tabWidget->tabName(currentTabIndex);
actionDialog->setCurrentTab(currentTab);
}
connect( actionDialog, &ActionDialog::commandAccepted,
this, &MainWindow::onActionDialogAccepted );
raiseWindow(actionDialog);
return actionDialog;
}
void MainWindow::openActionDialog()
{
auto c = browser();
const auto data = c ? selectionData(*c) : QVariantMap();
openActionDialog(data);
}
void MainWindow::showItemContent()
{
auto c = browser( ui->tabWidget->currentIndex() );
if (!c)
return;
const QModelIndex current = c->currentIndex();
if ( current.isValid() )
openDialog<ClipboardDialog>(current, c->model(), this);
}
void MainWindow::openPreferences()
{
if ( !isEnabled() )
return;
if (cm) {
cm->activateWindow();
return;
}
ConfigurationManager configurationManager(m_sharedData->itemFactory, this);
WindowGeometryGuard::create(&configurationManager);
// notify window if configuration changes
connect( &configurationManager, &ConfigurationManager::configurationChanged,
this, &MainWindow::configurationChanged );
connect( &configurationManager, &ConfigurationManager::error,
this, &MainWindow::showError );
#if QT_VERSION < QT_VERSION_CHECK(5,9,3)
// WORKAROUND: Fix drag'n'drop in list in modal dialog for Qt 5.9.2 (QTBUG-63846).
configurationManager.setWindowModality(Qt::WindowModal);
#endif
cm = &configurationManager;
configurationManager.exec();
cm = nullptr;
}
void MainWindow::openCommands()
{
if ( !isEnabled() )
return;
if (m_commandDialog) {
m_commandDialog->show();
m_commandDialog->activateWindow();
} else {
const QVector<Command> pluginCommands = m_sharedData->itemFactory->commands();
QStringList formats = m_sharedData->itemFactory->formatsToSave();
formats.prepend(mimeText);
formats.removeDuplicates();
QWidget *parent = this;
if (cm)
parent = cm;
m_commandDialog = openDialog<CommandDialog>(pluginCommands, formats, parent);
connect(this, &QObject::destroyed, m_commandDialog.data(), &QWidget::close);
connect(m_commandDialog.data(), &CommandDialog::commandsSaved, this, &MainWindow::updateEnabledCommands);
}
if (cm && cm->isVisible())
m_commandDialog->setWindowModality(Qt::ApplicationModal);
}
ClipboardBrowser *MainWindow::browser(int index)
{
return getPlaceholder(index)->createBrowser();
}
ClipboardBrowser *MainWindow::browser()
{
return browser( ui->tabWidget->currentIndex() );
}
ClipboardBrowser *MainWindow::browserOrNull()
{
const ClipboardBrowserPlaceholder *currentPlaceholder = getPlaceholder();
return currentPlaceholder ? currentPlaceholder->browser() : nullptr;
}
ClipboardBrowser *MainWindow::browserForItem(const QModelIndex &index)
{
if ( index.isValid() ) {
auto c = qobject_cast<ClipboardBrowser*>(index.model()->parent());
Q_ASSERT(c);
return c;
}
return nullptr;
}
void MainWindow::addAndFocusTab(const QString &name)
{
auto placeholder = createTab(name, MatchExactTabName, Tabs());
if (!placeholder)
return;
int i = 0;
for( ; i < ui->tabWidget->count() && getPlaceholder(i) != placeholder; ++i ) {}
setCurrentTab(i);
saveTabPositions();
}
void MainWindow::editNewItem()
{
auto c = browser( ui->tabWidget->currentIndex() );
if (!c)
return;
showWindow();
if ( !c->isInternalEditorOpen() ) {
c->setFocus();
c->editNew(mimeText, {});
}
}
void MainWindow::pasteItems()
{
const QMimeData *data = m_clipboard->mimeData(ClipboardMode::Clipboard);
if (data == nullptr)
return;
auto c = browser();
if (!c)
return;
QModelIndexList list = c->selectionModel()->selectedIndexes();
std::sort( list.begin(), list.end() );
const int row = list.isEmpty() ? 0 : list.first().row();
c->addAndSelect( cloneData(*data), row );
}
void MainWindow::copyItems()
{
auto c = browser();
if (!c)
return;
const QModelIndexList indexes = c->selectionModel()->selectedRows();
if ( indexes.isEmpty() )
return;
const auto data = c->copyIndexes(indexes);
setClipboard(data);
}
bool MainWindow::saveTab(const QString &fileName, int tabIndex)
{
QFile file(fileName);
if ( !file.open(QIODevice::WriteOnly | QIODevice::Truncate) )
return false;
QDataStream out(&file);
out.setVersion(QDataStream::Qt_4_7);
int i = tabIndex >= 0 ? tabIndex : ui->tabWidget->currentIndex();
auto c = browser(i);
if (!c)
return false;
out << QByteArray("CopyQ v2") << c->tabName();
serializeData(*c->model(), &out);
file.close();
return true;
}
bool MainWindow::exportData()
{
ImportExportDialog exportDialog(this);
exportDialog.setWindowTitle( tr("Options for Export") );
exportDialog.setTabs( ui->tabWidget->tabs() );
if ( !ui->tabWidget->isTabGroupSelected() )
exportDialog.setCurrentTab( getPlaceholder()->tabName() );
if ( exportDialog.exec() != QDialog::Accepted )
return false;
auto fileName = QFileDialog::getSaveFileName(
this, QString(), QString(), importExportFileDialogFilter() );
if ( fileName.isNull() )
return false;
if ( !fileName.endsWith(".cpq") )
fileName.append(".cpq");
const auto tabs = exportDialog.selectedTabs();
const bool exportConfiguration = exportDialog.isConfigurationEnabled();
const bool exportCommands = exportDialog.isCommandsEnabled();
if ( !exportDataFrom(fileName, tabs, exportConfiguration, exportCommands) ) {
QMessageBox::critical(
this, tr("Export Error"),
tr("Failed to export file %1!")
.arg(quoteString(fileName)) );
return false;
}
return true;
}
void MainWindow::saveTabs()
{
for( int i = 0; i < ui->tabWidget->count(); ++i ) {
auto c = getPlaceholder(i)->browser();
if (c)
c->saveUnsavedItems();
}
ui->tabWidget->saveTabInfo();
}
bool MainWindow::loadTab(const QString &fileName)
{
QFile file(fileName);
if ( !file.open(QIODevice::ReadOnly) )
return false;
QDataStream in(&file);
in.setVersion(QDataStream::Qt_4_7);
QByteArray header;
QString tabName;
in >> header >> tabName;
if ( !(header.startsWith("CopyQ v1") || header.startsWith("CopyQ v2")) || tabName.isEmpty() ) {
file.close();
return false;
}
// Find unique tab name.
renameToUnique(&tabName, ui->tabWidget->tabs());
auto c = createTab(tabName, MatchExactTabName, Tabs())->createBrowser();
if (!c)
return false;
deserializeData(c->model(), &in, m_sharedData->maxItems);
c->loadItems();
c->saveItems();
file.close();
ui->tabWidget->setCurrentIndex( ui->tabWidget->count() - 1 );
return true;
}
bool MainWindow::importDataFrom(const QString &fileName, ImportOptions options)
{
// Compatibility with v2.9.0 and earlier.
if ( loadTab(fileName) )
return true;
QFile file(fileName);
if ( !file.open(QIODevice::ReadOnly) )
return false;
QDataStream in(&file);
in.setVersion(QDataStream::Qt_4_7);
if ( importDataV4(&in, options) )
return true;
file.seek(0);
return importDataV3(&in, options);
}
bool MainWindow::exportAllData(const QString &fileName)
{
const auto tabs = ui->tabWidget->tabs();
const bool exportConfiguration = true;
const bool exportCommands = true;
return exportDataFrom(fileName, tabs, exportConfiguration, exportCommands);
}
bool MainWindow::importData()
{
const auto fileName = QFileDialog::getOpenFileName(
this, QString(), QString(), importExportFileDialogFilter() );
if ( fileName.isNull() )
return false;
if ( !importDataFrom(fileName, ImportOptions::Select) ) {
QMessageBox::critical(
this, tr("Import Error"),
tr("Failed to import file %1!")
.arg(quoteString(fileName)) );
return false;
}
return true;
}
void MainWindow::sortSelectedItems()
{
auto c = browser();
if (c)
c->sortItems( c->selectionModel()->selectedRows() );
}
void MainWindow::reverseSelectedItems()
{
auto c = browser();
if (c)
c->reverseItems( c->selectionModel()->selectedRows() );
}
Action *MainWindow::action(const QVariantMap &data, const Command &cmd, const QModelIndex &outputIndex)
{
if (cmd.wait) {
auto actionDialog = openActionDialog(data);
if ( !cmd.outputTab.isEmpty() )
actionDialog->setCurrentTab(cmd.outputTab);
actionDialog->setCommand(cmd);
} else if ( cmd.cmd.isEmpty() ) {
m_sharedData->actions->addFinishedAction(cmd.name);
} else {
auto act = new Action();
act->setCommand( cmd.cmd, QStringList(getTextData(data)) );
act->setInputWithFormat(data, cmd.input);
act->setName(cmd.name);
act->setData(data);
if ( !cmd.output.isEmpty() ) {
if ( outputIndex.isValid() )
actionOutput(this, act, cmd.output, outputIndex);
else if ( !cmd.sep.isEmpty() )
actionOutput(this, act, cmd.output, cmd.outputTab, QRegularExpression(cmd.sep));
else
actionOutput(this, act, cmd.output, cmd.outputTab);
}
m_sharedData->actions->action(act);
return act;
}
return nullptr;
}
bool MainWindow::triggerMenuCommand(const Command &command, const QString &triggeredShortcut)
{
updateShortcuts();
Command cmd = command;
for (auto act : m_menuItem->findChildren<CommandAction*>()) {
if ( !act->isEnabled() || !act->isVisible() )
continue;
const Command &menuCommand = act->command();
// Ignore outputTab value overridden in the action.
cmd.outputTab = menuCommand.outputTab;
if (cmd == menuCommand) {
onItemCommandActionTriggered(act, triggeredShortcut);
return true;
}
}
return false;
}
void MainWindow::runInternalAction(Action *action)
{
m_sharedData->actions->internalAction(action);
}
bool MainWindow::isInternalActionId(int id) const
{
return id != -1 && m_sharedData->actions->isInternalActionId(id);
}
void MainWindow::openNewTabDialog(const QString &name)
{
auto d = new TabDialog(TabDialog::TabNew, this);
d->setAttribute(Qt::WA_DeleteOnClose, true);
d->setTabs(ui->tabWidget->tabs());
d->setTabName(name);
connect( d, &TabDialog::newTabNameAccepted,
this, &MainWindow::addAndFocusTab );
d->open();
}
void MainWindow::openNewTabDialog()
{
QString tabPath = ui->tabWidget->getCurrentTabPath();
if ( ui->tabWidget->isTabGroup(tabPath) )
tabPath.append('/');
openNewTabDialog(tabPath);
}
void MainWindow::openRenameTabGroupDialog(const QString &name)
{
auto d = new TabDialog(TabDialog::TabGroupRename, this);
d->setAttribute(Qt::WA_DeleteOnClose, true);
d->setTabs(ui->tabWidget->tabs());
d->setTabGroupName(name);
connect( d, &TabDialog::treeTabNameAccepted,
this, &MainWindow::renameTabGroup );
d->open();
}
void MainWindow::renameTabGroup(const QString &newName, const QString &oldName)
{
const QStringList tabs = ui->tabWidget->tabs();
const QString tabPrefix = oldName + '/';
for ( int i = 0; i < tabs.size(); ++i ) {
const QString &tab = tabs[i];
if ( tab == oldName || tab.startsWith(tabPrefix) )
renameTab( newName + tab.mid(oldName.size()), i );
}
}
void MainWindow::openRenameTabDialog(int tabIndex)
{
auto d = new TabDialog(TabDialog::TabRename, this);
d->setAttribute(Qt::WA_DeleteOnClose, true);
d->setTabIndex(tabIndex);
d->setTabs(ui->tabWidget->tabs());
d->setTabName( getPlaceholder(tabIndex)->tabName() );
connect( d, &TabDialog::barTabNameAccepted,
this, &MainWindow::renameTab );
d->open();
}
void MainWindow::openRenameTabDialog()
{
const int tabIndex = ui->tabWidget->currentIndex();
if (tabIndex >= 0)
openRenameTabDialog(tabIndex);
}
void MainWindow::renameTab(const QString &name, int tabIndex)
{
if ( name.isEmpty() || ui->tabWidget->tabs().contains(name) )
return;
auto placeholder = getPlaceholder(tabIndex);
if (placeholder) {
const QString oldName = placeholder->tabName();
if ( placeholder->setTabName(name) ) {
updateTabIcon(name, oldName);
ui->tabWidget->setTabName(tabIndex, name);
saveTabPositions();
QVariantList optionsAndValues;
if (oldName == m_options.clipboardTab) {
optionsAndValues.append(QStringLiteral("clipboard_tab"));
optionsAndValues.append(name);
}
if (oldName == m_options.trayTabName) {
optionsAndValues.append(QStringLiteral("tray_tab"));
optionsAndValues.append(name);
}
if ( !optionsAndValues.isEmpty() )
config(optionsAndValues);
}
}
}
void MainWindow::removeTabGroup(const QString &name)
{
int answer = QMessageBox::question(
this,
tr("Remove All Tabs in Group?"),
tr("Do you want to remove <strong>all tabs</strong> in group <strong>%1</strong>?"
).arg(name),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::Yes);
if (answer == QMessageBox::Yes) {
ui->tabWidget->setCurrentIndex(0);
const QStringList tabs = ui->tabWidget->tabs();
const QString tabPrefix = name + '/';
const int currentTabIndex = ui->tabWidget->currentIndex();
for ( int i = tabs.size() - 1; i >= 0; --i ) {
const QString &tab = tabs[i];
if ( tab == name || tab.startsWith(tabPrefix) ) {
if (currentTabIndex == i)
ui->tabWidget->setCurrentIndex(0);
auto placeholder = getPlaceholder(i);
placeholder->removeItems();
placeholder->deleteLater();
ui->tabWidget->removeTab(i);
}
}
saveTabPositions();
}
}
void MainWindow::removeTab()
{
removeTab(true, ui->tabWidget->currentIndex());
}
void MainWindow::removeTab(bool ask, int tabIndex)
{
if (tabIndex < 0)
return;
TabWidget *w = ui->tabWidget;
auto placeholder = getPlaceholder(tabIndex);
if ( placeholder != nullptr && w->count() > 1 ) {
int answer = QMessageBox::Yes;
if (ask) {
answer = QMessageBox::question(
this,
tr("Remove Tab?"),
tr("Do you want to remove tab <strong>%1</strong>?"
).arg( w->tabName(tabIndex).remove('&') ),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::Yes);
}
if (answer == QMessageBox::Yes) {
placeholder->removeItems();
placeholder->deleteLater();
w->removeTab(tabIndex);
saveTabPositions();
}
}
}
void MainWindow::setTabIcon()
{
if ( ui->tabWidget->isTabGroupSelected() )
setTabIcon( ui->tabWidget->getCurrentTabPath() );
else
setTabIcon( getPlaceholder()->tabName() );
}
void MainWindow::setTabIcon(const QString &tabName)
{
IconSelectDialog dialog( getIconNameForTabName(tabName), this );
if ( dialog.exec() == QDialog::Accepted )
setTabIcon(tabName, dialog.selectedIcon());
}
void MainWindow::setTabIcon(const QString &tabName, const QString &icon)
{
if ( tabs().contains(tabName) || ui->tabWidget->isTabGroup(tabName) ) {
setIconNameForTabName(tabName, icon);
ui->tabWidget->setTabIcon(tabName, icon);
}
}
bool MainWindow::unloadTab(const QString &tabName)
{
ClipboardBrowserPlaceholder *placeholder = getPlaceholder(tabName);
return !placeholder || placeholder->expire();
}
void MainWindow::forceUnloadTab(const QString &tabName)
{
ClipboardBrowserPlaceholder *placeholder = getPlaceholder(tabName);
if (!placeholder)
return;
placeholder->unloadBrowser();
placeholder->createLoadButton();
}
MainWindow::~MainWindow()
{
delete ui;
}
#include "mainwindow.moc"
| 126,938
|
C++
|
.cpp
| 3,485
| 29.840172
| 132
| 0.659563
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,226
|
selectiondata.cpp
|
hluk_CopyQ/src/gui/selectiondata.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "selectiondata.h"
#include "common/mimetypes.h"
#include "gui/clipboardbrowser.h"
void addSelectionData(
QVariantMap *result,
const QList<QPersistentModelIndex> &selectedIndexes)
{
result->insert(mimeSelectedItems, QVariant::fromValue(selectedIndexes));
}
void addSelectionData(
QVariantMap *result,
const QModelIndexList &selectedIndexes)
{
QList<QPersistentModelIndex> selected;
selected.reserve(selectedIndexes.size());
for (const auto &index : selectedIndexes)
selected.append(index);
std::sort(selected.begin(), selected.end());
addSelectionData(result, selected);
}
/// Adds information about current tab and selection if command is triggered by user.
QVariantMap selectionData(
const ClipboardBrowser &c,
const QModelIndex ¤tIndex,
const QModelIndexList &selectedIndexes)
{
auto result = c.copyIndexes(selectedIndexes);
result.insert(mimeCurrentTab, c.tabName());
if ( currentIndex.isValid() ) {
const QPersistentModelIndex current = currentIndex;
result.insert(mimeCurrentItem, QVariant::fromValue(current));
}
if ( !selectedIndexes.isEmpty() ) {
addSelectionData(&result, selectedIndexes);
}
return result;
}
QVariantMap selectionData(const ClipboardBrowser &c)
{
const QModelIndexList selectedIndexes = c.selectionModel()->selectedIndexes();
const auto current = c.selectionModel()->currentIndex();
return selectionData(c, current, selectedIndexes);
}
| 1,583
|
C++
|
.cpp
| 44
| 31.318182
| 85
| 0.741176
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,227
|
commandsyntaxhighlighter.cpp
|
hluk_CopyQ/src/gui/commandsyntaxhighlighter.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "commandsyntaxhighlighter.h"
#include "gui/iconfactory.h"
#include "scriptable/scriptable.h"
#include <QMetaMethod>
#include <QMetaObject>
#include <QPalette>
#include <QRegularExpression>
#include <QJSEngine>
#include <QJSValue>
#include <QJSValueIterator>
#include <QStringList>
#include <QSyntaxHighlighter>
#include <QTextEdit>
#include <QPlainTextEdit>
namespace {
QString methodName(const QMetaMethod &method)
{
auto name = QString::fromLatin1(method.methodSignature());
const int index = name.indexOf('(');
if (index <= 0)
return QString();
return name.remove(index, name.length() - index);
}
QRegularExpression commandLabelRegExp()
{
return QRegularExpression(
"\\bcopyq:"
"|\\bsh:"
"|\\bbash:"
"|\\bpowershell:"
"|\\bperl:"
"|\\bpython:"
"|\\bruby:"
);
}
QRegularExpression createRegExp(const QStringList &list)
{
QRegularExpression re;
re.setPattern("\\b" + list.join("\\b|\\b") + "\\b");
return re;
}
int mixColorComponent(int a, int b)
{
return qMin(255, qMax(0, a + b));
}
QColor mixColor(const QColor &color, int r, int g, int b)
{
return QColor(
mixColorComponent(color.red(), r),
mixColorComponent(color.green(), g),
mixColorComponent(color.blue(), b),
color.alpha()
);
}
class CommandSyntaxHighlighter final : public QSyntaxHighlighter
{
public:
explicit CommandSyntaxHighlighter(QWidget *editor, QTextDocument *parent)
: QSyntaxHighlighter(parent)
, m_editor(editor)
, m_reObjects(createRegExp(scriptableObjects()))
, m_reProperties(createRegExp(scriptableProperties()))
, m_reFunctions(createRegExp(scriptableFunctions()))
, m_reKeywords(createRegExp(scriptableKeywords()))
, m_reLabels(commandLabelRegExp())
, m_reConstants(R"(\b0x[0-9A-Fa-f](?:_?[0-9A-Fa-f])*|(?:\b|%)\d(?:_?\d)*|\btrue\b|\bfalse\b)")
{
}
protected:
void highlightBlock(const QString &text) override
{
m_bgColor = getDefaultIconColor(*m_editor);
QTextCharFormat objectsFormat;
objectsFormat.setForeground(mixColor(m_bgColor, 40, -60, 40));
objectsFormat.setToolTip("Object");
highlight(text, m_reObjects, objectsFormat);
QTextCharFormat propertyFormat;
propertyFormat.setForeground(mixColor(m_bgColor, -60, 40, 40));
highlight(text, m_reProperties, propertyFormat);
QTextCharFormat functionFormat;
functionFormat.setForeground(mixColor(m_bgColor, -40, -40, 40));
highlight(text, m_reFunctions, functionFormat);
QTextCharFormat keywordFormat;
keywordFormat.setFontWeight(QFont::Bold);
highlight(text, m_reKeywords, keywordFormat);
QTextCharFormat labelsFormat;
labelsFormat.setFontWeight(QFont::Bold);
labelsFormat.setForeground(mixColor(m_bgColor, 40, 40, -40));
highlight(text, m_reLabels, labelsFormat);
QTextCharFormat constantFormat;
constantFormat.setForeground(mixColor(m_bgColor, 40, -40, -40));
highlight(text, m_reConstants, constantFormat);
highlightBlocks(text);
}
private:
enum State {
Code,
SingleQuote,
DoubleQuote,
BackTick,
RegExp,
Comment
};
void highlight(const QString &text, QRegularExpression &re, const QTextCharFormat &format)
{
auto it = re.globalMatch(text);
while (it.hasNext()) {
const auto m = it.next();
setFormat(m.capturedStart(), m.capturedLength(), format);
}
}
void format(int a, int b)
{
QTextCharFormat format;
const int state = currentBlockState();
if (state == SingleQuote || state == DoubleQuote || state == BackTick) {
format.setForeground(mixColor(m_bgColor, -40, 40, -40));
} else if (state == Comment) {
const int x = m_bgColor.lightness() > 100 ? -40 : 40;
format.setForeground( mixColor(m_bgColor, x, x, x) );
} else if (state == RegExp) {
format.setForeground(mixColor(m_bgColor, 40, -40, -40));
} else {
return;
}
setFormat(a, b - a + 1, format);
}
bool peek(const QString &text, int i, const QString &what)
{
return text.mid(i, what.size()) == what;
}
void highlightBlocks(const QString &text)
{
bool escape = false;
setCurrentBlockState(previousBlockState());
int a = 0;
for (int i = 0; i < text.size(); ++i) {
const QChar c = text[i];
if (escape) {
escape = false;
} else if (c == '\\') {
escape = true;
} else if (currentBlockState() == SingleQuote) {
if (c == '\'') {
format(a, i);
setCurrentBlockState(Code);
}
} else if (currentBlockState() == DoubleQuote) {
if (c == '"') {
format(a, i);
setCurrentBlockState(Code);
}
} else if (currentBlockState() == BackTick) {
if (c == '`') {
format(a, i);
setCurrentBlockState(Code);
}
} else if (currentBlockState() == Comment) {
if ( peek(text, i, "*/") ) {
++i;
format(a, i);
setCurrentBlockState(Code);
}
} else if (currentBlockState() == RegExp) {
if (c == '/') {
// Highlight paths outside code as regexps.
i = text.indexOf(QRegularExpression("[^a-zA-Z0-9./_-]"), i);
if (i == -1)
i = text.size();
--i;
format(a, i);
setCurrentBlockState(Code);
} else if (c == '\n' || i + 1 == text.size()) {
// The '/' was not regex start, since there is no ending
// '/' on the same line.
i = a;
setCurrentBlockState(Code);
}
} else if (c == '\\') {
escape = true;
} else if ( c == '#' || peek(text, i, "//") ) {
setCurrentBlockState(Comment);
format(i, text.size());
setCurrentBlockState(Code);
return;
} else if ( peek(text, i, "/*") ) {
a = i;
++i;
setCurrentBlockState(Comment);
} else if (c == '\'') {
a = i;
setCurrentBlockState(SingleQuote);
} else if (c == '"') {
a = i;
setCurrentBlockState(DoubleQuote);
} else if (c == '`') {
a = i;
setCurrentBlockState(BackTick);
} else if (c == '/') {
a = i;
setCurrentBlockState(RegExp);
}
}
format(a, text.size());
}
QWidget *m_editor;
QRegularExpression m_reObjects;
QRegularExpression m_reProperties;
QRegularExpression m_reFunctions;
QRegularExpression m_reKeywords;
QRegularExpression m_reLabels;
QRegularExpression m_reConstants;
QColor m_bgColor;
};
bool isPublicName(const QString &name)
{
return !name.startsWith('_');
}
QList<QString> getScriptableObjects()
{
QJSEngine engine;
Scriptable scriptable(&engine, nullptr);
QJSValue globalObject = engine.globalObject();
QJSValueIterator it(globalObject);
QList<QString> result;
while (it.hasNext()) {
it.next();
if ( isPublicName(it.name()) )
result.append(it.name());
}
return result;
}
} // namespace
QList<QString> scriptableKeywords()
{
return {
QStringLiteral("arguments"),
QStringLiteral("break"),
QStringLiteral("case"),
QStringLiteral("catch"),
QStringLiteral("const"),
QStringLiteral("continue"),
QStringLiteral("debugger"),
QStringLiteral("default"),
QStringLiteral("delete"),
QStringLiteral("do"),
QStringLiteral("else"),
QStringLiteral("finally"),
QStringLiteral("for"),
QStringLiteral("function"),
QStringLiteral("if"),
QStringLiteral("in"),
QStringLiteral("instanceof"),
QStringLiteral("let"),
QStringLiteral("new"),
QStringLiteral("of"),
QStringLiteral("return"),
QStringLiteral("switch"),
QStringLiteral("this"),
QStringLiteral("throw"),
QStringLiteral("try"),
QStringLiteral("typeof"),
QStringLiteral("var"),
QStringLiteral("void"),
QStringLiteral("while"),
QStringLiteral("with"),
};
}
QList<QString> scriptableProperties()
{
QList<QString> result;
QMetaObject scriptableMetaObject = Scriptable::staticMetaObject;
for (int i = 0; i < scriptableMetaObject.propertyCount(); ++i) {
QMetaProperty property = scriptableMetaObject.property(i);
if ( isPublicName(property.name()) )
result.append(property.name());
}
result.removeOne("objectName");
return result;
}
QList<QString> scriptableFunctions()
{
QList<QString> result;
QMetaObject scriptableMetaObject = Scriptable::staticMetaObject;
for (int i = 0; i < scriptableMetaObject.methodCount(); ++i) {
QMetaMethod method = scriptableMetaObject.method(i);
if (method.methodType() == QMetaMethod::Slot && method.access() == QMetaMethod::Public) {
const QString name = methodName(method);
if ( isPublicName(name) )
result.append(name);
}
}
result.removeOne("deleteLater");
return result;
}
QList<QString> scriptableObjects()
{
static const QList<QString> result = getScriptableObjects();
return result;
}
void installCommandSyntaxHighlighter(QTextEdit *editor)
{
new CommandSyntaxHighlighter(editor, editor->document());
}
void installCommandSyntaxHighlighter(QPlainTextEdit *editor)
{
new CommandSyntaxHighlighter(editor, editor->document());
}
| 10,474
|
C++
|
.cpp
| 309
| 25.012945
| 102
| 0.575398
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,228
|
iconselectbutton.cpp
|
hluk_CopyQ/src/gui/iconselectbutton.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "iconselectbutton.h"
#include "common/config.h"
#include "common/common.h"
#include "gui/fix_icon_id.h"
#include "gui/iconfont.h"
#include "gui/iconselectdialog.h"
#include "gui/icons.h"
#include <QApplication>
#include <QIcon>
#include <memory>
IconSelectButton::IconSelectButton(QWidget *parent)
: QPushButton(parent)
, m_currentIcon()
{
setToolTip(tr("Select Icon…"));
connect( this, &QAbstractButton::clicked, this, &IconSelectButton::onClicked );
// reset button text to "..."
m_currentIcon = "X";
setCurrentIcon(QString());
}
void IconSelectButton::setCurrentIcon(const QString &iconString)
{
if ( m_currentIcon == iconString )
return;
m_currentIcon = iconString;
setText(QString());
setIcon(QIcon());
if ( iconString.size() == 1 ) {
const QChar c = iconString[0];
const ushort id = fixIconId( c.unicode() );
m_currentIcon = QString(QChar(id));
setFont(iconFont());
setText(m_currentIcon);
} else if ( !iconString.isEmpty() ) {
const QIcon icon(iconString);
if ( icon.isNull() )
m_currentIcon = QString();
else
setIcon(icon);
}
if (m_currentIcon.isEmpty()) {
setFont(QFont());
setText( tr("...", "Select/browse icon.") );
}
emit currentIconChanged(m_currentIcon);
}
QSize IconSelectButton::sizeHint() const
{
const int h = QPushButton::sizeHint().height();
return QSize(h, h);
}
void IconSelectButton::onClicked()
{
std::unique_ptr<IconSelectDialog> dialog( new IconSelectDialog(m_currentIcon, this) );
// Set position under button.
const QPoint dialogPosition = mapToGlobal(QPoint(0, height()));
moveWindowOnScreen( dialog.get(), dialogPosition );
dialog->setAttribute(Qt::WA_DeleteOnClose, true);
connect( dialog.get(), &IconSelectDialog::iconSelected,
this, &IconSelectButton::setCurrentIcon );
dialog->open();
dialog.release();
}
| 2,047
|
C++
|
.cpp
| 64
| 27.0625
| 90
| 0.667684
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,229
|
commanddialog.cpp
|
hluk_CopyQ/src/gui/commanddialog.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "gui/commanddialog.h"
#include "ui_commanddialog.h"
#include "common/command.h"
#include "common/commandstore.h"
#include "common/common.h"
#include "common/mimetypes.h"
#include "common/settings.h"
#include "common/textdata.h"
#include "gui/addcommanddialog.h"
#include "gui/commandwidget.h"
#include "gui/iconfactory.h"
#include "gui/icons.h"
#include "platform/platformclipboard.h"
#include "platform/platformnativeinterface.h"
#include <QAction>
#include <QFileDialog>
#include <QMenu>
#include <QMessageBox>
#include <QMimeData>
#include <QPainter>
namespace {
const QIcon iconLoadCommands() { return getIcon("document-open", IconFolderOpen); }
const QIcon iconSaveCommands() { return getIcon("document-save", IconFloppyDisk); }
const QIcon iconCopyCommands() { return getIcon("edit-copy", IconCopy); }
const QIcon iconPasteCommands() { return getIcon("edit-paste", IconPaste); }
QIcon getCommandIcon(const QString &iconString, int commandType)
{
const auto icon =
commandType & CommandType::Automatic ? IconClipboard
: commandType & CommandType::GlobalShortcut ? IconKeyboard
: commandType & CommandType::Script ? IconGear
: commandType & CommandType::Display ? IconEye
: commandType & CommandType::Menu ? IconBars
: IconTriangleExclamation;
const auto color =
commandType & CommandType::Disabled ? QColor(Qt::lightGray)
: commandType & CommandType::Automatic ? QColor(240,220,200)
: commandType & CommandType::GlobalShortcut ? QColor(100,255,150)
: commandType & CommandType::Script ? QColor(255,220,100)
: commandType & CommandType::Display ? QColor(100,220,255)
: commandType & CommandType::Menu ? QColor(100,220,255)
: QColor(255,100,100);
return iconFromFile(iconString, QString(QChar(icon)), color);
}
bool hasCommandsToPaste(const QString &text)
{
return text.startsWith("[Command]") || text.startsWith("[Commands]");
}
} // namespace
class CommandItem final : public ItemOrderList::Item {
public:
CommandItem(const Command &command, const QStringList &formats, CommandDialog *cmdDialog)
: m_command(command)
, m_cmdDialog(cmdDialog)
, m_formats(formats)
{
}
QVariant data() const override { return QVariant::fromValue(m_command); }
private:
QWidget *createWidget(QWidget *parent) override
{
auto cmdWidget = new CommandWidget(parent);
cmdWidget->setFormats(m_formats);
cmdWidget->setCommand(m_command);
QObject::connect( cmdWidget, &CommandWidget::iconChanged,
m_cmdDialog, &CommandDialog::onCurrentCommandWidgetIconChanged );
QObject::connect( cmdWidget, &CommandWidget::nameChanged,
m_cmdDialog, &CommandDialog::onCurrentCommandWidgetNameChanged );
QObject::connect( cmdWidget, &CommandWidget::commandTextChanged,
m_cmdDialog, &CommandDialog::onCommandTextChanged );
return cmdWidget;
}
Command m_command;
CommandDialog *m_cmdDialog;
QStringList m_formats;
};
CommandDialog::CommandDialog(
const Commands &pluginCommands, const QStringList &formats, QWidget *parent)
: QDialog(parent)
, ui(new Ui::CommandDialog)
, m_pluginCommands(pluginCommands)
, m_formats(formats)
{
ui->setupUi(this);
connect(ui->itemOrderListCommands, &ItemOrderList::addButtonClicked,
this, &CommandDialog::onItemOrderListCommandsAddButtonClicked);
connect(ui->itemOrderListCommands, &ItemOrderList::itemSelectionChanged,
this, &CommandDialog::onItemOrderListCommandsItemSelectionChanged);
connect(ui->pushButtonLoadCommands, &QPushButton::clicked,
this, &CommandDialog::onPushButtonLoadCommandsClicked);
connect(ui->pushButtonSaveCommands, &QPushButton::clicked,
this, &CommandDialog::onPushButtonSaveCommandsClicked);
connect(ui->pushButtonCopyCommands, &QPushButton::clicked,
this, &CommandDialog::onPushButtonCopyCommandsClicked);
connect(ui->pushButtonPasteCommands, &QPushButton::clicked,
this, &CommandDialog::onPushButtonPasteCommandsClicked);
connect(ui->lineEditFilterCommands, &QLineEdit::textChanged,
this, &CommandDialog::onLineEditFilterCommandsTextChanged);
connect(ui->buttonBox, &QDialogButtonBox::clicked,
this, &CommandDialog::onButtonBoxClicked);
ui->pushButtonLoadCommands->setIcon(iconLoadCommands());
ui->pushButtonSaveCommands->setIcon(iconSaveCommands());
ui->pushButtonCopyCommands->setIcon(iconCopyCommands());
ui->pushButtonPasteCommands->setIcon(iconPasteCommands());
ui->itemOrderListCommands->setWiderIconsEnabled(true);
ui->itemOrderListCommands->setEditable(true);
ui->itemOrderListCommands->setItemsMovable(true);
addCommandsWithoutSave(loadAllCommands(), -1);
if ( ui->itemOrderListCommands->itemCount() != 0 )
ui->itemOrderListCommands->setCurrentItem(0);
auto act = new QAction(ui->itemOrderListCommands);
ui->itemOrderListCommands->addAction(act);
act->setShortcut(QKeySequence::Paste);
connect(act, &QAction::triggered, this, &CommandDialog::tryPasteCommandFromClipboard);
act = new QAction(ui->itemOrderListCommands);
ui->itemOrderListCommands->addAction(act);
act->setShortcut(QKeySequence::Copy);
connect(act, &QAction::triggered, this, &CommandDialog::copySelectedCommandsToClipboard);
ui->itemOrderListCommands->setDragAndDropValidator(QRegularExpression("\\[Commands?\\]"));
connect( ui->itemOrderListCommands, &ItemOrderList::dropped,
this, &CommandDialog::onCommandDropped );
connect( ui->itemOrderListCommands, &ItemOrderList::itemCheckStateChanged,
this, &CommandDialog::onCommandEnabledDisabled );
connect(this, &QDialog::finished, this, &CommandDialog::onFinished);
m_savedCommands = currentCommands();
}
CommandDialog::~CommandDialog()
{
delete ui;
}
void CommandDialog::addCommands(const Commands &commands)
{
addCommandsWithoutSave(commands, 0);
}
void CommandDialog::apply()
{
const auto cmds = currentCommands();
saveCommands(cmds);
m_savedCommands = cmds;
emit commandsSaved();
}
bool CommandDialog::maybeClose(QWidget *saveMessageBoxParent)
{
if ( hasUnsavedChanges() ) {
const QMessageBox::StandardButton button = QMessageBox::warning(
saveMessageBoxParent,
tr("Unsaved Changes"), tr("Command dialog has unsaved changes."),
QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);
if (button == QMessageBox::Cancel)
return false;
if (button == QMessageBox::Save)
apply();
}
QDialog::reject();
return true;
}
void CommandDialog::reject()
{
maybeClose(this);
}
void CommandDialog::tryPasteCommandFromClipboard()
{
const QString text = commandsToPaste();
if (!text.isEmpty())
onCommandDropped( text, ui->itemOrderListCommands->currentRow() );
}
void CommandDialog::copySelectedCommandsToClipboard()
{
const auto commands = serializeSelectedCommands();
auto clipboard = platformNativeInterface()->clipboard();
clipboard->setData( ClipboardMode::Clipboard, createDataMap(mimeText, commands) );
}
void CommandDialog::onCommandDropped(const QString &text, int row)
{
const auto commands = importCommandsFromText(text);
addCommandsWithoutSave(commands, row);
}
void CommandDialog::onCommandEnabledDisabled(int row)
{
updateIcon(row);
}
void CommandDialog::onCurrentCommandWidgetIconChanged()
{
const auto row = ui->itemOrderListCommands->currentRow();
updateIcon(row);
}
void CommandDialog::onCurrentCommandWidgetNameChanged(const QString &name)
{
ui->itemOrderListCommands->setCurrentItemLabel(name);
}
void CommandDialog::onFinished(int result)
{
if (result == QDialog::Accepted)
apply();
}
void CommandDialog::onItemOrderListCommandsAddButtonClicked()
{
AddCommandDialog addCommandDialog(m_pluginCommands, this);
connect(&addCommandDialog, &AddCommandDialog::addCommands, this, &CommandDialog::onAddCommands);
addCommandDialog.exec();
}
void CommandDialog::onItemOrderListCommandsItemSelectionChanged()
{
bool hasSelection = !ui->itemOrderListCommands->selectedRows().isEmpty();
ui->pushButtonSaveCommands->setEnabled(hasSelection);
ui->pushButtonCopyCommands->setEnabled(hasSelection);
}
void CommandDialog::onPushButtonLoadCommandsClicked()
{
const QStringList fileNames =
QFileDialog::getOpenFileNames(this, tr("Open Files with Commands"),
QString(), tr("Commands (*.ini);; CopyQ Configuration (copyq.conf copyq-*.conf)"));
for (const auto &fileName : fileNames) {
const auto commands = importCommandsFromFile(fileName);
addCommandsWithoutSave(commands, -1);
}
}
void CommandDialog::onPushButtonSaveCommandsClicked()
{
QString fileName =
QFileDialog::getSaveFileName(this, tr("Save Selected Commands"),
QString(), tr("Commands (*.ini)"));
if ( !fileName.isEmpty() ) {
if ( !fileName.endsWith(".ini") )
fileName.append(".ini");
QFile ini(fileName);
ini.open(QIODevice::WriteOnly);
ini.write(serializeSelectedCommands().toUtf8());
}
}
void CommandDialog::onPushButtonCopyCommandsClicked()
{
copySelectedCommandsToClipboard();
}
void CommandDialog::onPushButtonPasteCommandsClicked()
{
tryPasteCommandFromClipboard();
}
void CommandDialog::onLineEditFilterCommandsTextChanged(const QString &text)
{
// Omit pasting commands accidentally to filter text field.
if (hasCommandsToPaste(text)) {
ui->lineEditFilterCommands->clear();
onCommandDropped( text, ui->itemOrderListCommands->currentRow() );
return;
}
for (int i = 0; i < ui->itemOrderListCommands->itemCount(); ++i) {
const Command c = ui->itemOrderListCommands->data(i).value<Command>();
bool show = text.isEmpty() || QString(c.name).remove('&').contains(text, Qt::CaseInsensitive)
|| c.cmd.contains(text, Qt::CaseInsensitive);
ui->itemOrderListCommands->setItemWidgetVisible(i, show);
}
}
void CommandDialog::onButtonBoxClicked(QAbstractButton *button)
{
switch( ui->buttonBox->buttonRole(button) ) {
case QDialogButtonBox::ApplyRole:
apply();
break;
// Accept and reject roles are handled automatically.
case QDialogButtonBox::AcceptRole:
break;
case QDialogButtonBox::RejectRole:
break;
default:
break;
}
}
void CommandDialog::onAddCommands(const QVector<Command> &commands)
{
const int targetRow = qMax( 0, ui->itemOrderListCommands->currentRow() );
addCommandsWithoutSave(commands, targetRow);
}
void CommandDialog::onCommandTextChanged(const QString &command)
{
// Paste commands (starting with [Command] or [Commands]) correctly
// even if mistakenly pasted into text edit widget.
if ( hasCommandsToPaste(command) ) {
const int row = ui->itemOrderListCommands->currentRow();
ui->itemOrderListCommands->removeRow(row);
onCommandDropped(command, row);
}
}
Command CommandDialog::currentCommand(int row) const
{
Command c;
QWidget *w = ui->itemOrderListCommands->widget(row);
if (w) {
const CommandWidget *commandWidget = qobject_cast<const CommandWidget *>(w);
Q_ASSERT(commandWidget);
c = commandWidget->command();
} else {
c = ui->itemOrderListCommands->data(row).value<Command>();
}
c.enable = ui->itemOrderListCommands->isItemChecked(row);
return c;
}
Commands CommandDialog::currentCommands() const
{
Commands commands;
commands.reserve( ui->itemOrderListCommands->itemCount() );
for (int i = 0; i < ui->itemOrderListCommands->itemCount(); ++i)
commands.append( currentCommand(i) );
return commands;
}
void CommandDialog::addCommandsWithoutSave(const Commands &commands, int targetRow)
{
const int count = ui->itemOrderListCommands->rowCount();
int row = targetRow >= 0 ? targetRow : count;
QList<int> rowsToSelect;
rowsToSelect.reserve( commands.size() );
for (auto &command : commands) {
ItemOrderList::ItemPtr item(new CommandItem(command, m_formats, this));
const auto icon = getCommandIcon(command.icon, command.type());
const auto state = command.enable
? ItemOrderList::Checked
: ItemOrderList::Unchecked;
ui->itemOrderListCommands->insertItem(
command.name, icon, item, row, state);
rowsToSelect.append(row);
++row;
}
ui->itemOrderListCommands->setSelectedRows(rowsToSelect);
}
Commands CommandDialog::selectedCommands() const
{
const auto rows = ui->itemOrderListCommands->selectedRows();
const auto cmds = currentCommands();
Commands commandsToSave;
for (int row : rows) {
Q_ASSERT(row < cmds.size());
commandsToSave.append(cmds.value(row));
}
return commandsToSave;
}
QString CommandDialog::serializeSelectedCommands()
{
const Commands commands = selectedCommands();
if ( commands.isEmpty() )
return QString();
return exportCommands(commands);
}
bool CommandDialog::hasUnsavedChanges() const
{
return m_savedCommands != currentCommands();
}
void CommandDialog::updateIcon(int row)
{
const auto command = currentCommand(row);
const auto icon = getCommandIcon(command.icon, command.type());
ui->itemOrderListCommands->setItemIcon(row, icon);
}
QString CommandDialog::commandsToPaste()
{
auto clipboard = platformNativeInterface()->clipboard();
const QMimeData *data = clipboard->mimeData(ClipboardMode::Clipboard);
if (data && data->hasText()) {
const QString text = data->text().trimmed();
if (hasCommandsToPaste(text))
return text;
}
return QString();
}
| 14,211
|
C++
|
.cpp
| 364
| 33.442308
| 125
| 0.713829
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,230
|
tabbar.cpp
|
hluk_CopyQ/src/gui/tabbar.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "tabbar.h"
#include "common/common.h"
#include "common/mimetypes.h"
#include "gui/iconfactory.h"
#include "gui/tabicons.h"
#include <QIcon>
#include <QMimeData>
#include <QMouseEvent>
#include <QLabel>
#include <QStyle>
namespace {
int dropItemsTabIndex(const QDropEvent &event, const QTabBar &parent)
{
return canDropToTab(event) ? parent.tabAt( event.pos() ) : -1;
}
int tabIndex(const QString &tabName, const TabBar &parent)
{
for (int i = 0; i < parent.count(); ++i) {
if (parent.tabName(i) == tabName)
return i;
}
return -1;
}
} // namespace
TabBar::TabBar(QWidget *parent)
: QTabBar(parent)
{
setFocusPolicy(Qt::NoFocus);
setDrawBase(false);
setMinimumSize(1, 1);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
setAcceptDrops(true);
connect( this, &QTabBar::currentChanged,
this, &TabBar::onCurrentChanged );
}
QString TabBar::getCurrentTabPath() const
{
return QString();
}
QString TabBar::tabName(int tabIndex) const
{
return QTabBar::tabData(tabIndex).toString();
}
void TabBar::setTabName(int tabIndex, const QString &tabName)
{
// Use tab data to store tab name because tab text can change externally,
// e.g. Breeze theme adds missing accelerators (renames "test" to "&test).
setTabData(tabIndex, tabName);
QTabBar::setTabText(tabIndex, tabName);
}
void TabBar::setTabItemCount(const QString &tabName, const QString &itemCount)
{
const int i = tabIndex(tabName, *this);
if (i == -1)
return;
QWidget *tabCountLabel = tabButton(i, QTabBar::RightSide);
if ( itemCount.isEmpty() ) {
if (tabCountLabel) {
tabCountLabel->deleteLater();
setTabButton(i, QTabBar::RightSide, nullptr);
}
} else {
if (!tabCountLabel) {
tabCountLabel = new QLabel(this);
tabCountLabel->setObjectName("tab_item_counter");
setDefaultTabItemCounterStyle(tabCountLabel);
setTabButton(i, QTabBar::RightSide, tabCountLabel);
}
tabCountLabel->setProperty("text", itemCount);
tabCountLabel->adjustSize();
}
updateTabStyle(i);
}
void TabBar::setTabIcon(int index, const QString &icon)
{
QTabBar::setTabIcon(index, icon.isEmpty() ? QIcon() : iconFromFile(icon));
}
void TabBar::setTabIcon(const QString &tabName, const QString &icon)
{
const int i = tabIndex(tabName, *this);
if (i != -1)
setTabIcon(i, icon);
}
void TabBar::insertTab(int index, const QString &tabName)
{
const int i = QTabBar::insertTab(index, tabName);
setTabData(i, tabName);
}
void TabBar::removeTab(int index)
{
QTabBar::removeTab(index);
}
void TabBar::updateTabIcons(const QHash<QString, QString> &tabIcons)
{
for (int i = 0; i < count(); ++i) {
const QString name = tabName(i);
const QString icon = tabIcons.value(name);
setTabIcon(i, icon);
}
}
void TabBar::nextTab()
{
const int index = (currentIndex() + 1) % count();
setCurrentIndex(index);
}
void TabBar::previousTab()
{
const int index = (count() + currentIndex() - 1) % count();
setCurrentIndex(index);
}
void TabBar::setCurrentTab(int index)
{
QTabBar::setCurrentIndex(index);
}
void TabBar::adjustSize()
{
QTabBar::adjustSize();
}
void TabBar::contextMenuEvent(QContextMenuEvent *event)
{
const int tab = tabAt(event->pos());
emit tabBarMenuRequested(event->globalPos(), tab);
event->accept();
}
void TabBar::mousePressEvent(QMouseEvent *event)
{
if (event->button() == Qt::MiddleButton) {
const int tab = tabAt(event->pos());
emit tabCloseRequested(tab);
event->accept();
} else {
QTabBar::mousePressEvent(event);
}
}
void TabBar::dragEnterEvent(QDragEnterEvent *event)
{
if ( canDropToTab(*event) )
acceptDrag(event);
else
QTabBar::dragEnterEvent(event);
}
void TabBar::dragMoveEvent(QDragMoveEvent *event)
{
if ( dropItemsTabIndex(*event, *this) != -1 )
acceptDrag(event);
else
QTabBar::dragMoveEvent(event);
}
void TabBar::dropEvent(QDropEvent *event)
{
int tabIndex = dropItemsTabIndex(*event, *this);
if ( tabIndex != -1 ) {
acceptDrag(event);
emit dropItems( tabName(tabIndex), event->mimeData() );
} else {
QTabBar::dropEvent(event);
}
}
void TabBar::tabInserted(int index)
{
QTabBar::tabInserted(index);
updateTabStyle(index);
}
void TabBar::onCurrentChanged()
{
for ( int i = 0; i < count(); ++i )
updateTabStyle(i);
}
void TabBar::updateTabStyle(int index)
{
QWidget *tabCountLabel = tabButton(index, QTabBar::RightSide);
if (tabCountLabel) {
tabCountLabel->setProperty("CopyQ_selected", index == currentIndex());
style()->unpolish(tabCountLabel);
style()->polish(tabCountLabel);
}
}
| 4,954
|
C++
|
.cpp
| 178
| 23.567416
| 78
| 0.674895
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,231
|
itemorderlist.cpp
|
hluk_CopyQ/src/gui/itemorderlist.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "gui/itemorderlist.h"
#include "ui_itemorderlist.h"
#include "gui/iconfactory.h"
#include "gui/iconfont.h"
#include "gui/icons.h"
#include <QDragEnterEvent>
#include <QMenu>
#include <QMimeData>
#include <QScrollBar>
namespace {
void deleteWidget(const QPointer<QWidget> &object)
{
if (object)
object->deleteLater();
}
void setItemId(QListWidgetItem *item, int id)
{
item->setData(Qt::UserRole, id);
}
int itemId(QListWidgetItem *item)
{
return item->data(Qt::UserRole).toInt();
}
} // namespace
ItemOrderList::ItemOrderList(QWidget *parent)
: QWidget(parent)
, ui(new Ui::ItemOrderList)
{
ui->setupUi(this);
connect(ui->pushButtonUp, &QToolButton::clicked,
this, &ItemOrderList::onPushButtonUpClicked);
connect(ui->pushButtonDown, &QToolButton::clicked,
this, &ItemOrderList::onPushButtonDownClicked);
connect(ui->pushButtonTop, &QToolButton::clicked,
this, &ItemOrderList::onPushButtonTopClicked);
connect(ui->pushButtonBottom, &QToolButton::clicked,
this, &ItemOrderList::onPushButtonBottomClicked);
connect(ui->pushButtonRemove, &QToolButton::clicked,
this, &ItemOrderList::onPushButtonRemoveClicked);
connect(ui->pushButtonAdd, &QToolButton::clicked,
this, &ItemOrderList::onPushButtonAddClicked);
connect(ui->listWidgetItems, &QListWidget::currentItemChanged,
this, &ItemOrderList::onListWidgetItemsCurrentItemChanged);
connect(ui->listWidgetItems, &QListWidget::itemSelectionChanged,
this, &ItemOrderList::onListWidgetItemsItemSelectionChanged);
connect(ui->listWidgetItems, &QListWidget::itemChanged,
this, &ItemOrderList::onListWidgetItemsItemChanged);
ui->pushButtonRemove->hide();
ui->pushButtonAdd->hide();
setFocusProxy(ui->listWidgetItems);
ui->listWidgetItems->setFocus();
setCurrentItemWidget(nullptr);
setEditable(false);
setItemsMovable(false);
}
ItemOrderList::~ItemOrderList()
{
delete ui;
}
void ItemOrderList::setEditable(bool editable)
{
ui->pushButtonRemove->setVisible(editable);
ui->pushButtonAdd->setVisible(editable);
ui->listWidgetItems->setSelectionMode(
editable
? QAbstractItemView::ExtendedSelection
: QAbstractItemView::SingleSelection);
}
void ItemOrderList::setItemsMovable(bool movable)
{
ui->pushButtonUp->setVisible(movable);
ui->pushButtonDown->setVisible(movable);
ui->pushButtonTop->setVisible(movable);
ui->pushButtonBottom->setVisible(movable);
ui->listWidgetItems->setDragEnabled(movable);
}
void ItemOrderList::clearItems()
{
ui->listWidgetItems->clear();
for (const auto &pair : m_items)
deleteWidget(pair.second.widget);
m_items.clear();
}
void ItemOrderList::appendItem(
const QString &label, const QIcon &icon,
const ItemPtr &item, CheckState state)
{
insertItem(label, icon, item, -1, state);
}
void ItemOrderList::insertItem(
const QString &label, const QIcon &icon,
const ItemPtr &item, int targetRow, CheckState state)
{
QListWidget *list = ui->listWidgetItems;
auto listItem = new QListWidgetItem(icon, label);
if (state != NotCheckable)
listItem->setCheckState(state == Checked ? Qt::Checked : Qt::Unchecked);
++m_lastItemId;
setItemId(listItem, m_lastItemId);
m_items.insert({m_lastItemId, ItemWidgetPair(item, state == Checked)});
const int row = targetRow >= 0 ? qMin(list->count(), targetRow) : list->count();
list->insertItem(row, listItem);
if ( list->currentItem() == nullptr )
list->setCurrentRow(row);
}
void ItemOrderList::removeRow(int row)
{
auto item = listItem(row);
removeItem(item);
}
QWidget *ItemOrderList::widget(int row) const
{
const int id = itemId(listItem(row));
Q_ASSERT(m_items.find(id) != m_items.end());
return m_items.at(id).widget;
}
QVariant ItemOrderList::data(int row) const
{
const int id = itemId(listItem(row));
Q_ASSERT(m_items.find(id) != m_items.end());
return m_items.at(id).item->data();
}
int ItemOrderList::itemCount() const
{
return m_items.size();
}
bool ItemOrderList::isItemChecked(int row) const
{
return listItem(row)->checkState() == Qt::Checked;
}
int ItemOrderList::currentRow() const
{
return ui->listWidgetItems->currentIndex().row();
}
void ItemOrderList::setCurrentItem(int row)
{
QListWidgetItem *currentItem = listItem(row);
ui->listWidgetItems->setCurrentItem(currentItem, QItemSelectionModel::ClearAndSelect);
QWidget *widget = createWidget(currentItem);
widget->setFocus();
}
void ItemOrderList::setCurrentItemIcon(const QIcon &icon)
{
QListWidgetItem *current = ui->listWidgetItems->currentItem();
if(current != nullptr)
current->setIcon(icon);
}
void ItemOrderList::setCurrentItemLabel(const QString &label)
{
QListWidgetItem *current = ui->listWidgetItems->currentItem();
if(current != nullptr)
current->setText(label);
}
void ItemOrderList::setItemIcon(int row, const QIcon &icon)
{
QListWidgetItem *item = listItem(row);
if(item != nullptr)
item->setIcon(icon);
}
QString ItemOrderList::itemLabel(int row) const
{
return listItem(row)->text();
}
QList<int> ItemOrderList::selectedRows() const
{
QList<int> rows;
for (auto item : ui->listWidgetItems->selectedItems())
rows.append(ui->listWidgetItems->row(item));
return rows;
}
void ItemOrderList::setSelectedRows(const QList<int> &selectedRows)
{
ui->listWidgetItems->clearSelection();
ui->listWidgetItems->setCurrentItem(nullptr);
for (int row : selectedRows) {
if (row >= 0 && row < rowCount()) {
QListWidgetItem *item = ui->listWidgetItems->item(row);
if ( ui->listWidgetItems->currentItem() == nullptr )
ui->listWidgetItems->setCurrentItem(item);
else
item->setSelected(true);
}
}
}
int ItemOrderList::rowCount() const
{
return ui->listWidgetItems->count();
}
void ItemOrderList::setItemWidgetVisible(int row, bool visible)
{
QListWidgetItem *item = ui->listWidgetItems->item(row);
Q_ASSERT(item);
item->setHidden(!visible);
}
void ItemOrderList::setDragAndDropValidator(const QRegularExpression &re)
{
m_dragAndDropRe = re;
setAcceptDrops(m_dragAndDropRe.isValid());
}
void ItemOrderList::setWiderIconsEnabled(bool wider)
{
const auto height = iconFontSizePixels();
const auto width = wider ? height * 3/2 : height;
ui->listWidgetItems->setIconSize( QSize(width, height) );
}
void ItemOrderList::keyPressEvent(QKeyEvent *event)
{
if ( event->matches(QKeySequence::NextChild) ) {
nextPreviousItem(1);
event->accept();
return;
}
if ( event->matches(QKeySequence::PreviousChild) ) {
nextPreviousItem(-1);
event->accept();
return;
}
QWidget::keyPressEvent(event);
}
void ItemOrderList::dragEnterEvent(QDragEnterEvent *event)
{
const QString text = event->mimeData()->text();
if ( text.contains(m_dragAndDropRe) )
event->acceptProposedAction();
}
void ItemOrderList::dropEvent(QDropEvent *event)
{
event->accept();
QListWidget *list = ui->listWidgetItems;
const QPoint pos = list->mapFromParent(event->pos());
const int s = list->spacing();
QModelIndex index = list->indexAt(pos);
if ( !index.isValid() )
index = list->indexAt( pos + QPoint(s, - 2 * s) );
emit dropped( event->mimeData()->text(), index.row() );
}
void ItemOrderList::showEvent(QShowEvent *event)
{
if ( ui->pushButtonAdd->icon().isNull() ) {
ui->pushButtonAdd->setIcon( getIcon("list-add", IconPlus) );
ui->pushButtonRemove->setIcon( getIcon("list-remove", IconMinus) );
ui->pushButtonDown->setIcon( getIcon("go-down", IconArrowDown) );
ui->pushButtonUp->setIcon( getIcon("go-up", IconArrowUp) );
ui->pushButtonTop->setIcon( getIcon("go-top", IconAnglesUp) );
ui->pushButtonBottom->setIcon( getIcon("go-bottom", IconAnglesDown) );
}
// Resize list to minimal size.
QListWidget *list = ui->listWidgetItems;
const int w = list->sizeHintForColumn(0)
+ list->verticalScrollBar()->sizeHint().width() + 4;
const auto sizes = ui->splitter->sizes();
ui->splitter->setSizes({w, sizes[0] + sizes[1] - w});
QWidget::showEvent(event);
}
void ItemOrderList::nextPreviousItem(int d)
{
QListWidget *list = ui->listWidgetItems;
const int rowCount = list->count();
if (rowCount < 2)
return;
const int row = list->currentRow();
const int nextRow = (row + d + rowCount) % rowCount;
list->setCurrentRow(nextRow, QItemSelectionModel::ClearAndSelect);
}
void ItemOrderList::onPushButtonUpClicked()
{
const int row = ui->listWidgetItems->currentRow();
if (row >= 1)
moveTab(row, row - 1);
}
void ItemOrderList::onPushButtonDownClicked()
{
QListWidget *list = ui->listWidgetItems;
const int row = list->currentRow();
if (row >= 0 && row + 1 < list->count())
moveTab(row, row + 1);
}
void ItemOrderList::onPushButtonTopClicked()
{
const int row = ui->listWidgetItems->currentRow();
if (row >= 1)
moveTab(row, 0);
}
void ItemOrderList::onPushButtonBottomClicked()
{
QListWidget *list = ui->listWidgetItems;
const int row = ui->listWidgetItems->currentRow();
if (row >= 0 && row + 1 < list->count())
moveTab(row, list->count() - 1);
}
void ItemOrderList::onPushButtonRemoveClicked()
{
for (auto item : ui->listWidgetItems->selectedItems())
removeItem(item);
}
void ItemOrderList::onPushButtonAddClicked()
{
emit addButtonClicked();
}
void ItemOrderList::onListWidgetItemsCurrentItemChanged(QListWidgetItem *current, QListWidgetItem *)
{
setCurrentItemWidget( current ? createWidget(current) : nullptr );
}
void ItemOrderList::onListWidgetItemsItemSelectionChanged()
{
const QItemSelectionModel *sel = ui->listWidgetItems->selectionModel();
ui->pushButtonRemove->setEnabled( sel->hasSelection() );
emit itemSelectionChanged();
}
void ItemOrderList::onListWidgetItemsItemChanged(QListWidgetItem *item)
{
const int id = itemId(item);
if (id == 0)
return;
const auto row = ui->listWidgetItems->row(item);
const bool checked = item->checkState() == Qt::Checked;
Q_ASSERT(m_items.find(id) != m_items.end());
ItemWidgetPair &pair = m_items.at(id);
if ( pair.lastCheckedState != checked ) {
pair.lastCheckedState = checked;
emit itemCheckStateChanged(row, checked);
}
}
void ItemOrderList::moveTab(int row, int targetRow)
{
QListWidget *list = ui->listWidgetItems;
list->blockSignals(true);
list->insertItem(targetRow, list->takeItem(row));
list->setCurrentRow(targetRow);
list->blockSignals(false);
}
QListWidgetItem *ItemOrderList::listItem(int row) const
{
Q_ASSERT(row >= 0 && row < itemCount());
return ui->listWidgetItems->item(row);
}
void ItemOrderList::setCurrentItemWidget(QWidget *widget)
{
QLayoutItem *layoutItem = ui->widgetLayout->takeAt(0);
if (layoutItem)
layoutItem->widget()->hide();
delete layoutItem;
if (widget) {
ui->widgetLayout->addWidget(widget);
ui->widgetParent->setFocusProxy(widget);
widget->show();
}
}
QWidget *ItemOrderList::createWidget(QListWidgetItem *item)
{
const int id = itemId(item);
Q_ASSERT(m_items.find(id) != m_items.end());
ItemWidgetPair &pair = m_items.at(id);
if (!pair.widget)
pair.widget = pair.item->createWidget(this);
return pair.widget;
}
void ItemOrderList::removeItem(QListWidgetItem *item)
{
const int id = itemId(item);
Q_ASSERT(m_items.find(id) != m_items.end());
ItemWidgetPair pair = m_items.at(id);
m_items.erase(id);
deleteWidget(pair.widget);
delete item;
}
| 12,046
|
C++
|
.cpp
| 367
| 28.378747
| 100
| 0.698596
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,232
|
addcommanddialog.cpp
|
hluk_CopyQ/src/gui/addcommanddialog.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "addcommanddialog.h"
#include "ui_addcommanddialog.h"
#include "common/command.h"
#include "common/mimetypes.h"
#include "common/predefinedcommands.h"
#include "common/shortcuts.h"
#include "common/textdata.h"
#include "item/itemfactory.h"
#include "gui/iconfactory.h"
#include "gui/icons.h"
#include "gui/windowgeometryguard.h"
#include "platform/platformnativeinterface.h"
#include <QAbstractListModel>
#include <QLocale>
#include <QSortFilterProxyModel>
namespace {
class CommandModel final : public QAbstractListModel {
public:
explicit CommandModel(const QVector<Command> &commands, QObject *parent = nullptr)
: QAbstractListModel(parent)
, m_commands(commands)
{
}
int rowCount(const QModelIndex &) const override
{
return m_commands.size();
}
QVariant data(const QModelIndex &index, int role) const override
{
if (!index.isValid())
return QVariant();
if (role == Qt::DecorationRole) {
const QString &icon = m_commands[index.row()].icon;
QVariant iconOrIconId;
if (icon.size() == 1)
iconOrIconId = static_cast<uint>(icon[0].unicode());
else
iconOrIconId = QIcon(icon);
return getIcon(iconOrIconId);
}
if (role == Qt::DisplayRole)
return m_commands[index.row()].name;
if (role == Qt::UserRole)
return QVariant::fromValue(m_commands[index.row()]);
return QVariant();
}
private:
QVector<Command> m_commands;
};
} // namespace
AddCommandDialog::AddCommandDialog(const QVector<Command> &pluginCommands, QWidget *parent)
: QDialog(parent)
, ui(new Ui::AddCommandDialog)
, m_filterModel(new QSortFilterProxyModel(this))
{
ui->setupUi(this);
connect(ui->lineEditFilter, &QLineEdit::textChanged,
this, &AddCommandDialog::onLineEditFilterTextChanged);
connect(ui->listViewCommands, &QListView::activated,
this, &AddCommandDialog::onListViewCommandsActivated);
QAbstractItemModel *model = new CommandModel(predefinedCommands() + pluginCommands, m_filterModel);
m_filterModel->setSourceModel(model);
ui->listViewCommands->setModel(m_filterModel);
ui->listViewCommands->setCurrentIndex(m_filterModel->index(0, 0));
WindowGeometryGuard::create(this);
}
AddCommandDialog::~AddCommandDialog()
{
delete ui;
}
void AddCommandDialog::accept()
{
const QModelIndexList indexes =
ui->listViewCommands->selectionModel()->selectedIndexes();
if (!indexes.isEmpty()) {
QVector<Command> commands;
commands.reserve( indexes.size() );
for (const auto &index : indexes)
commands.append( index.data(Qt::UserRole).value<Command>() );
emit addCommands(commands);
}
QDialog::accept();
}
void AddCommandDialog::onLineEditFilterTextChanged(const QString &text)
{
#if QT_VERSION >= QT_VERSION_CHECK(5,12,0)
const QRegularExpression re(text, QRegularExpression::CaseInsensitiveOption);
m_filterModel->setFilterRegularExpression(re);
#else
const QRegExp re(text, Qt::CaseInsensitive);
m_filterModel->setFilterRegExp(re);
#endif
}
void AddCommandDialog::onListViewCommandsActivated()
{
accept();
}
| 3,347
|
C++
|
.cpp
| 98
| 28.77551
| 103
| 0.700062
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,233
|
shortcutdialog.cpp
|
hluk_CopyQ/src/gui/shortcutdialog.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "shortcutdialog.h"
#include "ui_shortcutdialog.h"
#include "common/log.h"
#include "common/shortcuts.h"
#include "gui/icons.h"
#include "platform/platformnativeinterface.h"
#include <QKeyEvent>
#include <QPushButton>
ShortcutDialog::ShortcutDialog(QWidget *parent)
: QDialog(parent)
, ui(new Ui::ShortcutDialog)
{
ui->setupUi(this);
QPushButton *resetButton = ui->buttonBox->button(QDialogButtonBox::Reset);
Q_ASSERT(resetButton);
resetButton->setText(tr("Remove Shortcut"));
connect(resetButton, &QAbstractButton::clicked,
this, &ShortcutDialog::onResetButtonClicked);
connect(ui->lineEditShortcut, &QKeySequenceEdit::keySequenceChanged,
this, [this](const QKeySequence &keySequence) {
if ( !keySequence.isEmpty() )
accept();
});
ui->lineEditShortcut->installEventFilter(this);
setAttribute(Qt::WA_InputMethodEnabled, false);
}
ShortcutDialog::~ShortcutDialog()
{
delete ui;
}
QKeySequence ShortcutDialog::shortcut() const
{
return ui->lineEditShortcut->keySequence();
}
bool ShortcutDialog::eventFilter(QObject *object, QEvent *event)
{
if (object != ui->lineEditShortcut)
return QDialog::eventFilter(object, event);
// WORKAROUND: Meta keyboard modifier in QKeySequenceEdit is not handled
// correctly on X11 and Wayland (QTBUG-78212, QTBUG-62102).
if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
auto keyEvent = static_cast<QKeyEvent*>(event);
const int key = keyEvent->key();
return key == Qt::Key_Meta
|| key == Qt::Key_Super_L
|| key == Qt::Key_Super_R
|| key == Qt::Key_Hyper_L
|| key == Qt::Key_Hyper_R;
}
return QDialog::eventFilter(object, event);
}
void ShortcutDialog::onResetButtonClicked()
{
ui->lineEditShortcut->setKeySequence( QKeySequence() );
accept();
}
| 2,007
|
C++
|
.cpp
| 57
| 29.894737
| 83
| 0.681302
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,234
|
iconselectdialog.cpp
|
hluk_CopyQ/src/gui/iconselectdialog.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "iconselectdialog.h"
#include "common/config.h"
#include "gui/iconfont.h"
#include "gui/icons.h"
#include "gui/icon_list.h"
#include <QDialogButtonBox>
#include <QFileDialog>
#include <QKeyEvent>
#include <QListWidget>
#include <QLineEdit>
#include <QPushButton>
#include <QVBoxLayout>
class IconListWidget final : public QListWidget {
public:
explicit IconListWidget(QWidget *parent)
: QListWidget(parent)
{
const int gridSize = iconFontSizePixels() + 8;
const QSize size(gridSize, gridSize);
setViewMode(QListView::IconMode);
setFont( iconFont() );
setGridSize(size);
setResizeMode(QListView::Adjust);
setSelectionMode(QAbstractItemView::SingleSelection);
setDragDropMode(QAbstractItemView::NoDragDrop);
addItem( QString() );
item(0)->setSizeHint(size);
}
QString addIcon(ushort unicode, bool isBrand, const QStringList &searchTerms)
{
const QString icon(unicode);
auto item = new QListWidgetItem(icon, this);
item->setSizeHint( gridSize() );
item->setToolTip( searchTerms.join(", ") );
if (isBrand)
item->setBackground( QColor(90,90,90,50) );
return icon;
}
QString icon(const QModelIndex &index) const
{
return item(index.row())->text();
}
bool isIconSelected() const
{
const QModelIndex index = currentIndex();
return index.isValid() && item(index.row())->isSelected();
}
void keyboardSearch(const QString &search) override
{
if (!m_search) {
m_search = new QLineEdit(this);
connect( m_search, &QLineEdit::textChanged,
this, &IconListWidget::onSearchTextChanged );
m_search->show();
updateSearchPosition();
}
m_search->setText( m_search->text() + search );
}
protected:
void keyPressEvent(QKeyEvent *event) override
{
if (m_search) {
if ( event->key() == Qt::Key_Escape ) {
event->accept();
stopSearch();
return;
}
if ( event->key() == Qt::Key_Backspace ) {
event->accept();
auto text = m_search->text();
text.chop(1);
m_search->setText(text);
return;
}
}
QListView::keyPressEvent(event);
}
void resizeEvent(QResizeEvent *event) override
{
QListWidget::resizeEvent(event);
if (m_search)
updateSearchPosition();
}
private:
void onSearchTextChanged(const QString &text)
{
if ( text.isEmpty() )
stopSearch();
else
search( text.toLower() );
}
void updateSearchPosition()
{
if (!m_search)
return;
const auto sizeDiff = this->size() - m_search->size();
m_search->move( sizeDiff.width(), sizeDiff.height() );
}
void search(const QString &text)
{
setCurrentItem(nullptr);
for (int row = 0; row < count(); ++row) {
auto item = this->item(row);
const bool matches = item->toolTip().contains(text);
item->setHidden(!matches);
if (matches && currentItem() == nullptr)
setCurrentItem(item);
}
}
void stopSearch()
{
if (!m_search)
return;
m_search->deleteLater();
m_search = nullptr;
search(QString());
setFocus();
}
QLineEdit *m_search = nullptr;
};
IconSelectDialog::IconSelectDialog(const QString &defaultIcon, QWidget *parent)
: QDialog(parent)
, m_iconList(new IconListWidget(this))
, m_selectedIcon(defaultIcon)
{
setWindowTitle( tr("Select Icon") );
connect( m_iconList, &QAbstractItemView::activated,
this, &IconSelectDialog::onIconListItemActivated );
addIcons();
QPushButton *browseButton = new QPushButton(tr("Browse..."), this);
if ( m_selectedIcon.size() > 2 )
browseButton->setIcon(QIcon(m_selectedIcon));
connect( browseButton, &QAbstractButton::clicked,
this, &IconSelectDialog::onBrowse );
QDialogButtonBox *buttonBox = new QDialogButtonBox(
QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, this);
connect( buttonBox, &QDialogButtonBox::rejected,
this, &QDialog::reject );
connect( buttonBox, &QDialogButtonBox::accepted,
this, &IconSelectDialog::onAcceptCurrent );
auto layout = new QVBoxLayout(this);
layout->addWidget(m_iconList);
auto buttonLayout = new QHBoxLayout;
layout->addLayout(buttonLayout);
buttonLayout->addWidget(browseButton);
buttonLayout->addWidget(buttonBox);
m_iconList->setFocus();
// Restore previous geometry.
restoreWindowGeometry(this, false);
}
void IconSelectDialog::done(int result)
{
saveWindowGeometry(this, false);
if (result == QDialog::Accepted)
emit iconSelected(m_selectedIcon);
QDialog::done(result);
}
void IconSelectDialog::onIconListItemActivated(const QModelIndex &index)
{
m_selectedIcon = m_iconList->icon(index);
accept();
}
void IconSelectDialog::onBrowse()
{
const QString fileName = QFileDialog::getOpenFileName(
this, tr("Open Icon file"), m_selectedIcon,
tr("Image Files (*.png *.jpg *.jpeg *.bmp *.ico *.svg)"));
if ( !fileName.isNull() ) {
m_selectedIcon = fileName;
accept();
}
}
void IconSelectDialog::onAcceptCurrent()
{
if ( m_iconList->isIconSelected() )
onIconListItemActivated( m_iconList->currentIndex() );
else
reject();
}
void IconSelectDialog::addIcons()
{
for (const Icon &icon : iconList) {
const auto searchTerms = QString(icon.searchTerms).split('|');
const auto iconText = m_iconList->addIcon(icon.unicode, icon.isBrand, searchTerms);
if (m_selectedIcon == iconText)
m_iconList->setCurrentRow(m_iconList->count() - 1);
}
}
| 6,167
|
C++
|
.cpp
| 189
| 25.280423
| 91
| 0.620475
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,235
|
commandedit.cpp
|
hluk_CopyQ/src/gui/commandedit.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "commandedit.h"
#include "ui_commandedit.h"
#include "gui/commandsyntaxhighlighter.h"
#include "gui/commandcompleter.h"
#include <QRegularExpression>
#include <QJSEngine>
#include <QTextBlock>
#include <QTextCursor>
#include <QTextDocument>
CommandEdit::CommandEdit(QWidget *parent)
: QWidget(parent)
, ui(new Ui::CommandEdit)
{
ui->setupUi(this);
connect(ui->plainTextEditCommand, &QPlainTextEdit::textChanged,
this, &CommandEdit::onPlainTextEditCommandTextChanged);
ui->labelErrors->hide();
auto document = ui->plainTextEditCommand->document();
QTextCursor tc(document);
const QRect cursorRect = ui->plainTextEditCommand->cursorRect(tc);
const QMargins margins = ui->plainTextEditCommand->contentsMargins();
const int minimumHeight = 3 * cursorRect.height() / 2
+ margins.top() + margins.bottom();
ui->plainTextEditCommand->setMinimumHeight(minimumHeight);
setFocusProxy(ui->plainTextEditCommand);
installCommandSyntaxHighlighter(ui->plainTextEditCommand);
new CommandCompleter(ui->plainTextEditCommand);
}
CommandEdit::~CommandEdit()
{
delete ui;
}
void CommandEdit::setCommand(const QString &command) const
{
ui->plainTextEditCommand->setPlainText(command);
}
QString CommandEdit::command() const
{
return ui->plainTextEditCommand->toPlainText();
}
bool CommandEdit::isEmpty() const
{
return ui->plainTextEditCommand->document()->characterCount() == 0;
}
void CommandEdit::setReadOnly(bool readOnly)
{
ui->plainTextEditCommand->setReadOnly(readOnly);
}
void CommandEdit::onPlainTextEditCommandTextChanged()
{
// TODO: Highlight syntax errors!
const QString command = ui->plainTextEditCommand->toPlainText();
emit changed();
emit commandTextChanged(command);
}
| 1,850
|
C++
|
.cpp
| 56
| 29.678571
| 73
| 0.762655
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,236
|
clipboarddialog.cpp
|
hluk_CopyQ/src/gui/clipboarddialog.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "clipboarddialog.h"
#include "ui_clipboarddialog.h"
#include "common/common.h"
#include "common/contenttype.h"
#include "common/mimetypes.h"
#include "common/shortcuts.h"
#include "common/timer.h"
#include "gui/iconfactory.h"
#include "gui/icons.h"
#include "gui/windowgeometryguard.h"
#include "platform/platformclipboard.h"
#include <QBuffer>
#include <QListWidgetItem>
#include <QMimeData>
#include <QMovie>
#include <QScrollBar>
#include <QUrl>
namespace {
// Limit number of characters to load at once - performance reasons.
constexpr int batchLoadCharacters = 4096;
constexpr int priorityHigh = 100;
constexpr int priorityMedium = priorityHigh / 2;
constexpr int priorityLow = priorityMedium / 2;
constexpr int priorityLower = priorityLow / 2;
constexpr int priorityLowest = 0;
int formatSortPriority(const QString &format)
{
if (format == mimeText)
return priorityHigh + 2;
if (format == mimeHtml)
return priorityHigh + 1;
if ( format.startsWith("text/") )
return priorityHigh;
if ( format.startsWith("application/") )
return priorityLow;
if ( format.contains("/x-") )
return priorityLower;
if ( format.isEmpty() || format[0].isUpper() )
return priorityLowest;
return priorityMedium;
}
} // namespace
ClipboardDialog::ClipboardDialog(QWidget *parent)
: QDialog(parent)
, m_clipboard(platformNativeInterface()->clipboard())
{
init();
const QMimeData *clipData = m_clipboard->mimeData(ClipboardMode::Clipboard);
if (clipData) {
m_dataFromClipboard = true;
for (const auto &format : clipData->formats()) {
m_data.insert(format, QVariant());
}
setData(m_data);
}
}
ClipboardDialog::ClipboardDialog(
const QPersistentModelIndex &index, QAbstractItemModel *model, QWidget *parent)
: QDialog(parent)
, m_model(model)
, m_index(index)
{
init();
setWindowTitle( tr("Item Content") );
connect( m_model.data(), &QAbstractItemModel::dataChanged,
this, &ClipboardDialog::onDataChanged );
onDataChanged(m_index, m_index);
}
ClipboardDialog::~ClipboardDialog()
{
delete ui;
}
void ClipboardDialog::onListWidgetFormatsCurrentItemChanged(
QListWidgetItem *current, QListWidgetItem *)
{
ui->actionRemove_Format->setEnabled(current != nullptr);
const QString mime = current ? current->text() : QString();
const bool hasImage = mime.startsWith(QLatin1String("image")) ;
const QByteArray animationFormat =
QString(mime).remove(QRegularExpression(QLatin1String("^image/"))).toUtf8();
const bool hasAnimation = QMovie::supportedFormats().contains(animationFormat);
ui->textEdit->clear();
ui->textEdit->setVisible(!hasImage);
ui->scrollAreaImage->setVisible(hasImage);
if (hasImage)
ui->labelContent->setBuddy(ui->scrollAreaImage);
else
ui->labelContent->setBuddy(ui->textEdit);
QVariant value = m_data.value(mime);
if ( m_dataFromClipboard && !value.isValid() ) {
const auto data = m_clipboard->mimeData(ClipboardMode::Clipboard);
value = m_data[mime] = data ? data->data(mime) : QByteArray();
}
const QByteArray bytes = value.toByteArray();
m_timerTextLoad.stop();
if (hasAnimation) {
if (m_animation)
m_animation->deleteLater();
if (m_animationBuffer)
m_animationBuffer->deleteLater();
m_animationBuffer = new QBuffer(this);
m_animationBuffer->open(QIODevice::ReadWrite);
m_animationBuffer->write(bytes);
m_animationBuffer->seek(0);
m_animation = new QMovie(this);
m_animation->setDevice(m_animationBuffer);
m_animation->setFormat(animationFormat);
ui->labelImage->setMovie(m_animation);
m_animation->start();
} else if (hasImage) {
QPixmap pix;
pix.loadFromData( bytes, mime.toLatin1() );
ui->labelImage->setPixmap(pix);
} else {
m_textToShow = dataToText(bytes, mime);
addText();
}
if (current) {
ui->labelProperties->setText(
tr("<strong>Size:</strong> %1 bytes", "Size of clipboard/item data in bytes")
.arg(bytes.size()) );
} else {
ui->labelProperties->setText(QString());
}
}
void ClipboardDialog::onActionRemoveFormatTriggered()
{
QListWidgetItem *item = ui->listWidgetFormats->currentItem();
if (item) {
const QString mimeToRemove = item->text();
m_data.remove(mimeToRemove);
delete item;
if (m_model)
m_model->setData(m_index, mimeToRemove, contentType::removeFormats);
else
emit changeClipboard(m_data);
}
}
void ClipboardDialog::onDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
{
if (m_index.isValid()
&& topLeft.row() <= m_index.row()
&& m_index.row() <= bottomRight.row())
{
setData( m_index.data(contentType::data).toMap() );
}
}
void ClipboardDialog::addText()
{
const int scrollValue = ui->textEdit->verticalScrollBar()->value();
ui->textEdit->appendPlainText( m_textToShow.left(batchLoadCharacters) );
m_textToShow.remove(0, batchLoadCharacters);
if ( !m_textToShow.isEmpty() )
m_timerTextLoad.start();
ui->textEdit->verticalScrollBar()->setValue(scrollValue);
}
void ClipboardDialog::init()
{
Q_ASSERT(!ui);
ui = new Ui::ClipboardDialog;
ui->setupUi(this);
connect(ui->listWidgetFormats, &QListWidget::currentItemChanged,
this, &ClipboardDialog::onListWidgetFormatsCurrentItemChanged);
connect(ui->actionRemove_Format, &QAction::triggered,
this, &ClipboardDialog::onActionRemoveFormatTriggered);
setWindowIcon(appIcon());
ui->horizontalLayout->setStretchFactor(1, 1);
ui->listWidgetFormats->setCurrentRow(0);
WindowGeometryGuard::create(this);
ui->actionRemove_Format->setIcon( getIcon("list-remove", IconTrash) );
ui->actionRemove_Format->setShortcut(shortcutToRemove());
ui->listWidgetFormats->addAction(ui->actionRemove_Format);
onListWidgetFormatsCurrentItemChanged(nullptr, nullptr);
}
void ClipboardDialog::setData(const QVariantMap &data)
{
const QString currentFormat = ui->listWidgetFormats->currentIndex().data().toString();
ui->listWidgetFormats->clear();
m_data = data;
QStringList formats = data.keys();
std::sort( std::begin(formats), std::end(formats), [](const QString &lhs, const QString &rhs) {
const int lhsPriority = formatSortPriority(lhs);
const int rhsPriority = formatSortPriority(rhs);
return lhsPriority == rhsPriority ? lhs < rhs : lhsPriority > rhsPriority;
} );
for (const QString &format : formats) {
ui->listWidgetFormats->addItem(format);
if (format == currentFormat) {
ui->listWidgetFormats->setCurrentRow(
ui->listWidgetFormats->count() - 1);
}
}
initSingleShotTimer(&m_timerTextLoad, 10, this, &ClipboardDialog::addText);
}
| 7,182
|
C++
|
.cpp
| 195
| 31.015385
| 99
| 0.681799
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,237
|
configurationmanager.cpp
|
hluk_CopyQ/src/gui/configurationmanager.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "configurationmanager.h"
#include "ui_configurationmanager.h"
#include "ui_configtabgeneral.h"
#include "ui_configtabhistory.h"
#include "ui_configtablayout.h"
#include "ui_configtabnotifications.h"
#include "ui_configtabtray.h"
#include "common/appconfig.h"
#include "common/command.h"
#include "common/common.h"
#include "common/config.h"
#include "common/log.h"
#include "common/mimetypes.h"
#include "common/option.h"
#include "common/settings.h"
#include "gui/configtabappearance.h"
#include "gui/configtabtabs.h"
#include "gui/iconfactory.h"
#include "gui/icons.h"
#include "gui/pluginwidget.h"
#include "gui/shortcutswidget.h"
#include "gui/tabicons.h"
#include "gui/windowgeometryguard.h"
#include "item/clipboardmodel.h"
#include "item/itemdelegate.h"
#include "item/itemfactory.h"
#include "item/itemwidget.h"
#include "platform/platformnativeinterface.h"
#include <QDir>
#include <QFile>
#include <QMessageBox>
#include <QMimeData>
#include <QScrollArea>
#include <QTranslator>
namespace {
class TabItem final : public ItemOrderList::Item {
public:
explicit TabItem(QWidget *widget) noexcept
: m_widget(widget)
{
m_widget->hide();
}
QVariant data() const override { return QVariant(); }
private:
QWidget *createWidget(QWidget *) override
{
return m_widget;
}
QWidget *m_widget;
};
template <typename Ui>
ItemOrderList::ItemPtr makeTab(std::shared_ptr<Ui> &ui, QWidget *parent)
{
Q_ASSERT(!ui);
auto widget = new QScrollArea(parent);
ui = std::make_shared<Ui>();
ui->setupUi(widget);
return std::make_shared<TabItem>(widget);
}
template <typename Widget>
ItemOrderList::ItemPtr makeTab(Widget **widget, QWidget *parent)
{
Q_ASSERT(!*widget);
*widget = new Widget(parent);
return std::make_shared<TabItem>(*widget);
}
class PluginItem final : public ItemOrderList::Item {
public:
explicit PluginItem(const ItemLoaderPtr &loader)
: m_loader(loader)
{
}
QVariant data() const override { return m_loader->id(); }
private:
QWidget *createWidget(QWidget *parent) override
{
return new PluginWidget(m_loader, parent);
}
ItemLoaderPtr m_loader;
};
QString nativeLanguageName(const QString &localeName)
{
// Traditional Chinese
if (localeName == "zh_TW")
return QString::fromUtf8("\xe6\xad\xa3\xe9\xab\x94\xe4\xb8\xad\xe6\x96\x87");
// Simplified Chinese
if (localeName == "zh_CN")
return QString::fromUtf8("\xe7\xae\x80\xe4\xbd\x93\xe4\xb8\xad\xe6\x96\x87");
return QLocale(localeName).nativeLanguageName();
}
} // namespace
ConfigurationManager::ConfigurationManager(ItemFactory *itemFactory, QWidget *parent)
: QDialog(parent)
, ui(new Ui::ConfigurationManager)
, m_options()
{
ui->setupUi(this);
initTabIcons();
connectSlots();
setWindowIcon(appIcon());
m_tabHistory->spinBoxItems->setMaximum(Config::maxItems);
if ( itemFactory && itemFactory->hasLoaders() )
initPluginWidgets(itemFactory);
initOptions();
if (itemFactory)
m_tabAppearance->createPreview(itemFactory);
AppConfig appConfig;
loadSettings(&appConfig);
if (itemFactory)
m_tabShortcuts->addCommands( itemFactory->commands() );
}
ConfigurationManager::ConfigurationManager()
: ui(new Ui::ConfigurationManager)
, m_options()
{
ui->setupUi(this);
initTabIcons();
connectSlots();
initOptions();
}
ConfigurationManager::~ConfigurationManager()
{
delete ui;
}
void ConfigurationManager::initTabIcons()
{
ItemOrderList *list = ui->itemOrderList;
list->setItemsMovable(false);
list->appendItem( tr("General"), getIcon("", IconWrench), makeTab(m_tabGeneral, this) );
list->appendItem( tr("Layout"), getIcon("", IconTableColumns), makeTab(m_tabLayout, this) );
list->appendItem( tr("History"), getIcon("", IconList), makeTab(m_tabHistory, this) );
list->appendItem( tr("Tray"), getIcon("", IconInbox), makeTab(m_tabTray, this) );
list->appendItem( tr("Notifications"), getIcon("", IconCircleInfo), makeTab(m_tabNotifications, this) );
list->appendItem( tr("Tabs"), getIconFromResources("tab_rename"), makeTab(&m_tabTabs, this) );
list->appendItem( tr("Items"), getIcon("", IconList), makeTab(&m_tabItems, this) );
list->appendItem( tr("Shortcuts"), getIcon("", IconKeyboard), makeTab(&m_tabShortcuts, this) );
list->appendItem( tr("Appearance"), getIcon("", IconImage), makeTab(&m_tabAppearance, this) );
}
void ConfigurationManager::initPluginWidgets(ItemFactory *itemFactory)
{
m_tabItems->clearItems();
m_tabItems->setItemsMovable(true);
for ( const auto &loader : itemFactory->loaders() ) {
if ( loader->name().isEmpty() )
continue;
ItemOrderList::ItemPtr pluginItem(new PluginItem(loader));
const QIcon icon = getIcon(loader->icon());
const auto state = loader->isEnabled()
? ItemOrderList::Checked
: ItemOrderList::Unchecked;
m_tabItems->appendItem( loader->name(), icon, pluginItem, state );
}
}
void ConfigurationManager::initLanguages()
{
m_tabGeneral->comboBoxLanguage->addItem("English");
m_tabGeneral->comboBoxLanguage->setItemData(0, "en");
const QString currentLocale = QLocale().name();
bool currentLocaleFound = false; // otherwise not found or partial match ("uk" partially matches locale "uk_UA")
QSet<QString> languages;
for ( const auto &path : qApp->property("CopyQ_translation_directories").toStringList() ) {
for ( const auto &item : QDir(path).entryList(QStringList("copyq_*.qm")) ) {
const int i = item.indexOf('_');
const QString locale = item.mid(i + 1, item.lastIndexOf('.') - i - 1);
const QString language = nativeLanguageName(locale);
if (!language.isEmpty()) {
languages.insert(language);
const int index = m_tabGeneral->comboBoxLanguage->count();
m_tabGeneral->comboBoxLanguage->addItem(language);
m_tabGeneral->comboBoxLanguage->setItemData(index, locale);
if (!currentLocaleFound) {
currentLocaleFound = (locale == currentLocale);
if (currentLocaleFound || currentLocale.startsWith(locale + "_"))
m_tabGeneral->comboBoxLanguage->setCurrentIndex(index);
}
}
}
}
m_tabGeneral->comboBoxLanguage->setSizeAdjustPolicy(QComboBox::AdjustToContents);
}
void ConfigurationManager::updateAutostart()
{
auto platform = platformNativeInterface();
if ( platform->canAutostart() ) {
bind<Config::autostart>(m_tabGeneral->checkBoxAutostart);
} else {
m_tabGeneral->checkBoxAutostart->hide();
}
}
void ConfigurationManager::setAutostartEnable(AppConfig *appConfig)
{
auto platform = platformNativeInterface();
platform->setAutostartEnabled( appConfig->option<Config::autostart>() );
}
void ConfigurationManager::initOptions()
{
/* general options */
bind<Config::autostart>(m_tabGeneral->checkBoxAutostart);
bind<Config::clipboard_tab>(m_tabHistory->comboBoxClipboardTab->lineEdit());
bind<Config::maxitems>(m_tabHistory->spinBoxItems);
bind<Config::expire_tab>(m_tabHistory->spinBoxExpireTab);
bind<Config::editor>(m_tabHistory->lineEditEditor);
bind<Config::item_popup_interval>(m_tabNotifications->spinBoxNotificationPopupInterval);
bind<Config::notification_position>(m_tabNotifications->comboBoxNotificationPosition);
bind<Config::clipboard_notification_lines>(m_tabNotifications->spinBoxClipboardNotificationLines);
bind<Config::notification_horizontal_offset>(m_tabNotifications->spinBoxNotificationHorizontalOffset);
bind<Config::notification_vertical_offset>(m_tabNotifications->spinBoxNotificationVerticalOffset);
bind<Config::notification_maximum_width>(m_tabNotifications->spinBoxNotificationMaximumWidth);
bind<Config::notification_maximum_height>(m_tabNotifications->spinBoxNotificationMaximumHeight);
bind<Config::native_notifications>(m_tabNotifications->checkBoxUseNativeNotifications);
bind<Config::edit_ctrl_return>(m_tabHistory->checkBoxEditCtrlReturn);
bind<Config::show_simple_items>(m_tabHistory->checkBoxShowSimpleItems);
bind<Config::number_search>(m_tabHistory->checkBoxNumberSearch);
bind<Config::move>(m_tabHistory->checkBoxMove);
bind<Config::check_clipboard>(m_tabGeneral->checkBoxClip);
bind<Config::confirm_exit>(m_tabGeneral->checkBoxConfirmExit);
bind<Config::navigation_style>(m_tabGeneral->comboBoxNavigationStyle);
bind<Config::save_filter_history>(m_tabGeneral->checkBoxSaveFilterHistory);
bind<Config::autocompletion>(m_tabGeneral->checkBoxAutocompleteCommands);
bind<Config::always_on_top>(m_tabGeneral->checkBoxAlwaysOnTop);
bind<Config::close_on_unfocus>(m_tabGeneral->checkBoxCloseOnUnfocus);
bind<Config::open_windows_on_current_screen>(m_tabGeneral->checkBoxOpenWindowsOnCurrentScreen);
bind<Config::transparency_focused>(m_tabLayout->spinBoxTransparencyFocused);
bind<Config::transparency>(m_tabLayout->spinBoxTransparencyUnfocused);
bind<Config::hide_tabs>(m_tabLayout->checkBoxHideTabs);
bind<Config::hide_toolbar>(m_tabLayout->checkBoxHideToolbar);
bind<Config::hide_toolbar_labels>(m_tabLayout->checkBoxHideToolbarLabels);
bind<Config::disable_tray>(m_tabTray->checkBoxDisableTray);
bind<Config::hide_main_window>(m_tabLayout->checkBoxHideWindow);
bind<Config::tab_tree>(m_tabLayout->checkBoxTabTree);
bind<Config::show_tab_item_count>(m_tabLayout->checkBoxShowTabItemCount);
bind<Config::text_wrap>(m_tabGeneral->checkBoxTextWrap);
bind<Config::activate_item_with_single_click>(m_tabHistory->checkBoxSingleClickActivate);
bind<Config::activate_closes>(m_tabHistory->checkBoxActivateCloses);
bind<Config::activate_focuses>(m_tabHistory->checkBoxActivateFocuses);
bind<Config::activate_pastes>(m_tabHistory->checkBoxActivatePastes);
bind<Config::tray_items>(m_tabTray->spinBoxTrayItems);
bind<Config::tray_item_paste>(m_tabTray->checkBoxPasteMenuItem);
bind<Config::tray_commands>(m_tabTray->checkBoxTrayShowCommands);
bind<Config::tray_tab_is_current>(m_tabTray->checkBoxMenuTabIsCurrent);
bind<Config::tray_images>(m_tabTray->checkBoxTrayImages);
bind<Config::tray_tab>(m_tabTray->comboBoxMenuTab->lineEdit());
/* other options */
bind<Config::item_data_threshold>();
bind<Config::command_history_size>();
#ifdef HAS_MOUSE_SELECTIONS
/* X11 clipboard selection monitoring and synchronization */
bind<Config::check_selection>(m_tabGeneral->checkBoxSel);
bind<Config::copy_clipboard>(m_tabGeneral->checkBoxCopyClip);
bind<Config::copy_selection>(m_tabGeneral->checkBoxCopySel);
bind<Config::run_selection>(m_tabGeneral->checkBoxRunSel);
#else
m_tabGeneral->checkBoxCopySel->hide();
m_tabGeneral->checkBoxSel->hide();
m_tabGeneral->checkBoxCopyClip->hide();
m_tabGeneral->checkBoxRunSel->hide();
#endif
bind<Config::hide_main_window_in_task_bar>();
bind<Config::max_process_manager_rows>();
bind<Config::show_advanced_command_settings>();
bind<Config::text_tab_width>();
bind<Config::save_delay_ms_on_item_added>();
bind<Config::save_delay_ms_on_item_modified>();
bind<Config::save_delay_ms_on_item_removed>();
bind<Config::save_delay_ms_on_item_moved>();
bind<Config::save_delay_ms_on_item_edited>();
bind<Config::save_on_app_deactivated>();
bind<Config::tray_menu_open_on_left_click>();
bind<Config::filter_regular_expression>();
bind<Config::filter_case_insensitive>();
bind<Config::native_menu_bar>();
bind<Config::native_tray_menu>();
bind<Config::script_paste_delay_ms>();
bind<Config::window_paste_with_ctrl_v_regex>();
bind<Config::window_wait_before_raise_ms>();
bind<Config::window_wait_raised_ms>();
bind<Config::window_wait_after_raised_ms>();
bind<Config::window_key_press_time_ms>();
bind<Config::window_wait_for_modifier_released_ms>();
bind<Config::update_clipboard_owner_delay_ms>();
bind<Config::style>();
bind<Config::row_index_from_one>();
bind<Config::tabs>();
bind<Config::restore_geometry>();
bind<Config::close_on_unfocus_delay_ms>();
}
template <typename Config, typename Widget>
void ConfigurationManager::bind(Widget *obj)
{
bind(Config::name(), obj, Config::defaultValue());
}
template <typename Config>
void ConfigurationManager::bind()
{
bind(Config::name(), QVariant::fromValue(Config::defaultValue()), Config::description());
}
void ConfigurationManager::bind(const QString &optionKey, QCheckBox *obj, bool defaultValue)
{
m_options[optionKey] = Option(defaultValue, "checked", obj);
}
void ConfigurationManager::bind(const QString &optionKey, QSpinBox *obj, int defaultValue)
{
m_options[optionKey] = Option(defaultValue, "value", obj);
}
void ConfigurationManager::bind(const QString &optionKey, QLineEdit *obj, const QString &defaultValue)
{
m_options[optionKey] = Option(defaultValue, "text", obj);
}
void ConfigurationManager::bind(const QString &optionKey, QComboBox *obj, int defaultValue)
{
m_options[optionKey] = Option(defaultValue, "currentIndex", obj);
}
void ConfigurationManager::bind(const QString &optionKey, QComboBox *obj, NavigationStyle defaultValue)
{
m_options[optionKey] = Option(static_cast<int>(defaultValue), "currentIndex", obj);
}
void ConfigurationManager::bind(const QString &optionKey, const QVariant &defaultValue, const char *description)
{
m_options[optionKey] = Option(defaultValue, description);
}
void ConfigurationManager::updateTabComboBoxes()
{
initTabComboBox(m_tabHistory->comboBoxClipboardTab);
initTabComboBox(m_tabTray->comboBoxMenuTab);
}
QStringList ConfigurationManager::options() const
{
QStringList options;
for (auto it = m_options.constBegin(); it != m_options.constEnd(); ++it) {
const auto &option = it.key();
if ( it.value().value().canConvert(QVariant::String) )
options.append(option);
else if ( it.value().value().canConvert(QVariant::StringList) )
options.append(option);
}
return options;
}
QVariant ConfigurationManager::optionValue(const QString &name) const
{
return m_options.value(name).value();
}
bool ConfigurationManager::setOptionValue(const QString &name, const QVariant &value, AppConfig *appConfig)
{
if ( !m_options.contains(name) )
return false;
const QString oldValue = optionValue(name).toString();
Option &option = m_options[name];
option.setValue(value);
if ( option.value() == oldValue )
return false;
appConfig->setOption(name, option.value());
option.setValue(appConfig->option(name));
return option.value() != oldValue;
}
QString ConfigurationManager::optionToolTip(const QString &name) const
{
return m_options[name].tooltip();
}
void ConfigurationManager::loadSettings(AppConfig *appConfig)
{
Settings &settings = appConfig->settings();
settings.beginGroup("Options");
for (auto it = m_options.begin(); it != m_options.end(); ++it) {
const auto &option = it.key();
auto &value = it.value();
if ( settings.contains(option) ) {
const auto newValue = settings.value(option);
if ( !newValue.isValid() || !value.setValue(newValue) )
log( tr("Invalid value for option \"%1\"").arg(option), LogWarning );
} else {
value.reset();
}
}
settings.endGroup();
settings.beginGroup("Shortcuts");
m_tabShortcuts->loadShortcuts(settings);
settings.endGroup();
settings.beginGroup("Theme");
m_tabAppearance->loadTheme(settings);
settings.endGroup();
m_tabAppearance->setEditor( appConfig->option<Config::editor>() );
onCheckBoxMenuTabIsCurrentStateChanged( m_tabTray->checkBoxMenuTabIsCurrent->checkState() );
updateTabComboBoxes();
updateAutostart();
}
void ConfigurationManager::onButtonBoxClicked(QAbstractButton* button)
{
int answer;
switch( ui->buttonBox->buttonRole(button) ) {
case QDialogButtonBox::ApplyRole: {
AppConfig appConfig;
apply(&appConfig);
emit configurationChanged(&appConfig);
break;
}
case QDialogButtonBox::AcceptRole:
accept();
break;
case QDialogButtonBox::RejectRole:
reject();
break;
case QDialogButtonBox::ResetRole:
// ask before resetting values
answer = QMessageBox::question(
this,
tr("Reset preferences?"),
tr("This action will reset all your preferences (in all tabs) to default values.<br /><br />"
"Do you really want to <strong>reset all preferences</strong>?"),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::Yes);
if (answer == QMessageBox::Yes) {
for (auto it = m_options.begin(); it != m_options.end(); ++it)
it.value().reset();
}
break;
default:
return;
}
}
void ConfigurationManager::setVisible(bool visible)
{
QDialog::setVisible(visible);
if (visible) {
initLanguages();
}
}
void ConfigurationManager::connectSlots()
{
connect(ui->buttonBox, &QDialogButtonBox::clicked,
this, &ConfigurationManager::onButtonBoxClicked);
connect(m_tabTray->checkBoxMenuTabIsCurrent, &QCheckBox::stateChanged,
this, &ConfigurationManager::onCheckBoxMenuTabIsCurrentStateChanged);
connect(m_tabTray->spinBoxTrayItems, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged),
this, &ConfigurationManager::onSpinBoxTrayItemsValueChanged);
}
void ConfigurationManager::apply(AppConfig *appConfig)
{
Settings &settings = appConfig->settings();
settings.beginGroup("Options");
for (auto it = m_options.constBegin(); it != m_options.constEnd(); ++it)
settings.setValue( it.key(), it.value().value() );
settings.endGroup();
m_tabTabs->saveTabs(&settings);
// Save configuration without command line alternatives only if option widgets are initialized
// (i.e. clicked OK or Apply in configuration dialog).
settings.beginGroup("Shortcuts");
m_tabShortcuts->saveShortcuts(&settings);
settings.endGroup();
settings.beginGroup("Theme");
m_tabAppearance->saveTheme(&settings);
settings.endGroup();
// Save settings for each plugin.
settings.beginGroup("Plugins");
QStringList pluginPriority;
pluginPriority.reserve( m_tabItems->itemCount() );
for (int i = 0; i < m_tabItems->itemCount(); ++i) {
const QString loaderId = m_tabItems->data(i).toString();
if ( loaderId.isEmpty() )
continue;
pluginPriority.append(loaderId);
settings.beginGroup(loaderId);
QWidget *w = m_tabItems->widget(i);
if (w) {
PluginWidget *pluginWidget = qobject_cast<PluginWidget *>(w);
const auto &loader = pluginWidget->loader();
loader->applySettings(settings);
}
const bool isPluginEnabled = m_tabItems->isItemChecked(i);
settings.setValue("enabled", isPluginEnabled);
settings.endGroup();
}
settings.endGroup();
if (!pluginPriority.isEmpty())
settings.setValue("plugin_priority", pluginPriority);
m_tabAppearance->setEditor( appConfig->option<Config::editor>() );
setAutostartEnable(appConfig);
// Language changes after restart.
const int newLocaleIndex = m_tabGeneral->comboBoxLanguage->currentIndex();
const QString newLocaleName = m_tabGeneral->comboBoxLanguage->itemData(newLocaleIndex).toString();
QString oldLocaleName = settings.value("Options/language").toString();
if (oldLocaleName.isEmpty())
oldLocaleName = "en";
const QLocale oldLocale;
settings.setValue("Options/language", newLocaleName);
if (QLocale(newLocaleName).name() != oldLocale.name() && newLocaleName != oldLocaleName) {
QMessageBox::information( this, tr("Restart Required"),
tr("Language will be changed after application is restarted.") );
}
}
void ConfigurationManager::done(int result)
{
if (result == QDialog::Accepted) {
AppConfig appConfig;
apply(&appConfig);
emit configurationChanged(&appConfig);
}
QDialog::done(result);
}
void ConfigurationManager::onCheckBoxMenuTabIsCurrentStateChanged(int state)
{
m_tabTray->comboBoxMenuTab->setEnabled(state == Qt::Unchecked);
}
void ConfigurationManager::onSpinBoxTrayItemsValueChanged(int value)
{
m_tabTray->checkBoxPasteMenuItem->setEnabled(value > 0);
}
| 20,992
|
C++
|
.cpp
| 507
| 36.001972
| 116
| 0.707127
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,238
|
filedialog.cpp
|
hluk_CopyQ/src/gui/filedialog.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "filedialog.h"
#include <QFileDialog>
#include <QFileInfo>
#include <QWidget>
FileDialog::FileDialog(QWidget *parent, const QString &caption, const QString &fileName)
: QObject(parent)
, m_parent(parent)
, m_caption(caption)
, m_defaultPath(QFileInfo(fileName).absoluteFilePath())
{
}
void FileDialog::exec()
{
const QString fileName =
QFileDialog::getSaveFileName(
m_parent, m_caption, m_defaultPath,
/* filter = */ QString(), /* selectedFilter = */ nullptr,
QFileDialog::DontConfirmOverwrite | QFileDialog::ReadOnly);
if (!fileName.isEmpty())
emit fileSelected(fileName);
}
| 726
|
C++
|
.cpp
| 22
| 27.636364
| 88
| 0.675714
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,239
|
iconfactory.cpp
|
hluk_CopyQ/src/gui/iconfactory.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "iconfactory.h"
#include "gui/fix_icon_id.h"
#include "gui/icons.h"
#include "gui/iconfont.h"
#include "gui/pixelratio.h"
#include <QBitmap>
#include <QCoreApplication>
#include <QFile>
#include <QFont>
#include <QFontDatabase>
#include <QFontMetrics>
#include <QIcon>
#include <QIconEngine>
#include <QPainter>
#include <QPainterPath>
#include <QPaintDevice>
#include <QPaintEngine>
#include <QPixmap>
#include <QPixmapCache>
#include <QPointer>
#include <QSvgRenderer>
#include <QVariant>
#include <QWidget>
#ifndef COPYQ_ICON_NAME
# define COPYQ_ICON_NAME "copyq"
#endif
namespace {
/// Up to this value of background lightness, icon color will be lighter.
const int lightThreshold = 100;
bool sessionIconTagEnabledFlag = true;
QPointer<QObject> &activePaintDevice() {
static QPointer<QObject> activePaintDevice;
return activePaintDevice;
}
QIcon fromTheme(const QString &name)
{
if ( qEnvironmentVariableIsEmpty("COPYQ_DEFAULT_ICON") )
return QIcon::fromTheme(name);
return QIcon();
}
bool hasNormalIconHelper()
{
// QIcon::hasThemeIcon() returns true even if icon "copyq-normal" is not available
// but "copyq" is.
const QIcon normalIcon = fromTheme(QStringLiteral(COPYQ_ICON_NAME "-normal"));
if ( normalIcon.isNull() )
return false;
const QIcon defaultIcon = fromTheme(QStringLiteral(COPYQ_ICON_NAME));
return defaultIcon.pixmap(16).toImage() != normalIcon.pixmap(16).toImage();
}
bool hasNormalIcon()
{
static const bool result = hasNormalIconHelper();
return result;
}
QString sessionName()
{
return qApp->property("CopyQ_session_name").toString();
}
QString textFromEnv(const char *envVaribleName)
{
const auto name = qgetenv(envVaribleName);
return QString::fromUtf8(name);
}
QColor colorFromEnv(const char *envVaribleName)
{
return QColor( textFromEnv(envVaribleName) );
}
QColor sessionNameToColor(const QString &name)
{
if (name.isEmpty())
return QColor();
int r = 0;
int g = 0;
int b = 0;
for (const auto &c : name) {
const ushort x = c.unicode() % 3;
if (x == 0)
r += 255;
else if (x == 1)
g += 255;
else
b += 255;
}
int max = qMax(r, qMax(g, b));
r = r * 255 / max;
g = g * 255 / max;
b = b * 255 / max;
return QColor(r, g, b);
}
QColor sessionIconColorHelper()
{
const auto color = colorFromEnv("COPYQ_SESSION_COLOR");
return color.isValid() ? color : sessionNameToColor( sessionName() );
}
QColor &sessionIconColorVariable()
{
static QColor color = sessionIconColorHelper();
return color;
}
QString &sessionIconTagVariable()
{
static QString tag = textFromEnv("COPYQ_SESSION_TAG");
return tag;
}
QColor &sessionIconTagColorVariable()
{
static QColor color = colorFromEnv("COPYQ_SESSION_TAG_COLOR");
return color;
}
QPixmap pixmapFromBitmapFile(const QString &path, QSize size)
{
return QPixmap(path)
.scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation);
}
QPixmap pixmapFromFile(const QString &path, QSize size)
{
const auto cacheKey = QStringLiteral("path:%1|%2x%3")
.arg(path)
.arg(size.width())
.arg(size.height());
{
QPixmap pixmap;
if ( QPixmapCache::find(cacheKey, &pixmap) )
return pixmap;
}
if ( !QFile::exists(path) )
return QPixmap();
if ( !path.endsWith(".svg", Qt::CaseInsensitive) )
return pixmapFromBitmapFile(path, size);
QSvgRenderer renderer(path);
if ( !renderer.isValid() )
return pixmapFromBitmapFile(path, size);
QPixmap pix(size);
pix.setDevicePixelRatio(1);
pix.fill(Qt::transparent);
QPainter painter(&pix);
renderer.render(&painter, pix.rect());
QPixmapCache::insert(cacheKey, pix);
return pix;
}
QString iconPath(const QString &iconSuffix)
{
#ifdef COPYQ_ICON_PREFIX
const QString fileName(
QStringLiteral(COPYQ_ICON_PREFIX) + iconSuffix + QStringLiteral(".svg"));
if ( QFile::exists(fileName) )
return fileName;
#else
Q_UNUSED(iconSuffix)
#endif
return QStringLiteral(":/images/icon") + iconSuffix;
}
QPixmap appPixmap(const QString &iconSuffix, QSize size)
{
if ( iconSuffix.isEmpty() && hasNormalIcon() )
return appPixmap(QStringLiteral("-normal"), size);
const auto icon = fromTheme(QStringLiteral(COPYQ_ICON_NAME) + iconSuffix);
QPixmap pix;
if ( icon.isNull() ) {
const auto path = iconPath(iconSuffix);
pix = pixmapFromFile(path, size);
} else {
pix = icon.pixmap(size)
.scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation);
}
pix.setDevicePixelRatio(1);
return pix;
}
void replaceColor(QPixmap *pix, const QColor &targetColor)
{
auto pix2 = appPixmap(QStringLiteral("_mask"), pix->size());
{
QPainter p1(&pix2);
p1.setCompositionMode(QPainter::CompositionMode_SourceAtop);
p1.fillRect(pix->rect(), targetColor);
}
QPainter p(pix);
p.setCompositionMode(QPainter::CompositionMode_SourceAtop);
p.drawPixmap(0, 0, pix2);
}
void disableIcon(QPixmap *pix)
{
QPixmap pix2(pix->size());
pix2.fill(Qt::transparent);
{
QPainter p(&pix2);
p.setOpacity(0.7);
p.drawPixmap(0, 0, *pix);
}
*pix = pix2;
}
QPixmap drawFontIcon(ushort id, int w, int h, const QColor &color)
{
const auto cacheKey = QStringLiteral("id:%1|%2x%3|%4")
.arg(id)
.arg(w)
.arg(h)
.arg(color.rgba());
{
QPixmap pixmap;
if ( QPixmapCache::find(cacheKey, &pixmap) )
return pixmap;
}
QPixmap pixmap(w, h);
pixmap.fill(Qt::transparent);
id = fixIconId(id);
QPainter painter(&pixmap);
painter.setRenderHint(QPainter::TextAntialiasing);
painter.setRenderHint(QPainter::Antialiasing);
const QFont font = iconFontFitSize(w, h);
painter.setFont(font);
// Center the icon to whole pixels so it stays sharp.
const auto flags = Qt::AlignTop | Qt::AlignLeft;
const auto iconText = QString(QChar(id));
auto boundingRect = painter.boundingRect(0, 0, w, h, flags, iconText);
const auto x = w - boundingRect.width();
// If icon is wider, assume that a tag will be rendered and align image to the right.
const auto pos = boundingRect.bottomLeft()
+ ((w > h) ? QPoint(x * 3 / 4, 0) : QPoint(x / 2, 0));
// Draw shadow.
painter.setPen(Qt::black);
painter.setOpacity(0.2);
painter.drawText(pos + QPoint(1, 1), iconText);
painter.setOpacity(1);
painter.setPen(color);
painter.drawText(pos, iconText);
QPixmapCache::insert(cacheKey, pixmap);
return pixmap;
}
QColor getDefaultIconColor(const QColor &color)
{
QColor c = color;
bool menuBackgrounIsLight = c.lightness() > lightThreshold;
c.setHsl(c.hue(),
qMax(0, qMin(255, c.saturation() + (menuBackgrounIsLight ? 30 : 10))),
qMax(0, qMin(255, c.lightness() + (menuBackgrounIsLight ? -140 : 100))));
return c;
}
void tagIcon(QPixmap *pix, const QString &tag, QColor color)
{
if ( tag.isEmpty() )
return;
const auto ratio = pixelRatio(pix);
pix->setDevicePixelRatio(1);
QPainter painter(pix);
painter.setRenderHint(QPainter::TextAntialiasing);
painter.setRenderHint(QPainter::Antialiasing);
const int h = pix->height();
const int strokeWidth = static_cast<int>(ratio + h / 16);
QFont font;
const auto pixelSize = pix->width() / 2;
if ( tag.size() == 1 ) {
font = iconFontFitSize(pixelSize, pixelSize);
} else {
font.setPixelSize(pixelSize);
font.setBold(true);
}
painter.setFont(font);
const auto rect = painter.fontMetrics().tightBoundingRect(tag);
const auto baseLineY = rect.bottom();
const auto pos = QPoint(strokeWidth, h - strokeWidth - baseLineY);
QPainterPath path;
path.addText(pos, font, tag);
const auto strokeColor = color.lightness() < 100 ? Qt::white : Qt::black;
painter.strokePath(path, QPen(strokeColor, strokeWidth));
painter.setPen(color);
painter.drawText(pos, tag);
}
QColor colorForMode(QPainter *painter, QIcon::Mode mode)
{
auto parent = painter
? dynamic_cast<QWidget*>(painter->device())
: qobject_cast<QWidget*>(activePaintDevice().data());
const bool selected = (mode == QIcon::Active || mode == QIcon::Selected);
QColor color = parent ? getDefaultIconColor(*parent, selected) : Qt::darkGray;
if (mode == QIcon::Disabled)
color.setAlphaF(0.5);
return color;
}
class BaseIconEngine : public QIconEngine
{
public:
void paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state) override
{
painter->drawPixmap( rect, createPixmap(rect.size(), mode, state, painter) );
}
QPixmap pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state) override
{
return createPixmap(size, mode, state);
}
QPixmap createPixmap(QSize size, QIcon::Mode mode, QIcon::State state, QPainter *painter = nullptr)
{
// WORKAROUND: Big icons can cause application to crash.
if ( size.width() > 256 || size.height() > 256 )
size.scale(256, 256, Qt::KeepAspectRatio);
if (painter)
size *= pixelRatio(painter->paintEngine()->paintDevice());
auto pixmap = doCreatePixmap(size, mode, state, painter);
if ( pixmap.isNull() ) {
pixmap = QPixmap(size);
pixmap.fill(Qt::transparent);
}
return taggedIcon(&pixmap);
}
QList<QSize> availableSizes(QIcon::Mode, QIcon::State)
#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
const
#endif
override
{
static const auto sizes = QList<QSize>()
<< QSize(32, 32)
<< QSize(48, 48)
<< QSize(64, 64)
<< QSize(96, 96)
<< QSize(128, 128);
return sizes;
}
protected:
BaseIconEngine(const QString &tag, QColor tagColor)
: m_tag(tag)
, m_tagColor(tagColor)
{
}
private:
virtual QPixmap doCreatePixmap(QSize size, QIcon::Mode mode, QIcon::State state, QPainter *painter) = 0;
QPixmap taggedIcon(QPixmap *pix)
{
tagIcon(pix, m_tag, m_tagColor);
return *pix;
}
QString m_tag;
QColor m_tagColor;
};
class FontIconEngine : public BaseIconEngine
{
public:
FontIconEngine(ushort iconId, const QString &tag, QColor tagColor)
: BaseIconEngine(tag, tagColor)
, m_iconId(iconId)
{
}
QIconEngine *clone() const override
{
return new FontIconEngine(*this);
}
QPixmap doCreatePixmap(QSize size, QIcon::Mode mode, QIcon::State, QPainter *painter) override
{
if (m_iconId == 0) {
QPixmap pixmap(size);
pixmap.fill(Qt::transparent);
return pixmap;
}
return drawFontIcon( m_iconId, size.width(), size.height(), colorForMode(painter, mode) );
}
private:
ushort m_iconId;
};
class ImageIconEngine final : public FontIconEngine
{
public:
ImageIconEngine(const QString &iconName, ushort fallbackIconId, const QString &tag, QColor tagColor)
: FontIconEngine(fallbackIconId, tag, tagColor)
, m_iconName(iconName)
{
}
QIconEngine *clone() const override
{
return new ImageIconEngine(*this);
}
QPixmap doCreatePixmap(QSize size, QIcon::Mode mode, QIcon::State state, QPainter *painter) override
{
if ( m_iconName.isEmpty() )
return FontIconEngine::doCreatePixmap(size, mode, state, painter);
// Tint tab icons.
if ( m_iconName.startsWith(QLatin1String(":/images/tab_")) ) {
const QPixmap pixmap = pixmapFromFile(m_iconName, size);
QPixmap pixmap2(pixmap.size());
pixmap2.fill(Qt::transparent);
QPainter painter2(&pixmap2);
painter2.setRenderHint(QPainter::SmoothPixmapTransform);
painter2.setRenderHint(QPainter::TextAntialiasing);
painter2.setRenderHint(QPainter::Antialiasing);
// Draw shadow.
const auto rect = pixmap.rect();
painter2.setOpacity(0.2);
painter2.drawPixmap(rect.translated(1, 1), pixmap);
painter2.setOpacity(1);
painter2.setCompositionMode(QPainter::CompositionMode_SourceIn);
painter2.fillRect( pixmap2.rect(), Qt::black );
painter2.setCompositionMode(QPainter::CompositionMode_SourceOver);
painter2.drawPixmap(rect, pixmap);
painter2.setCompositionMode(QPainter::CompositionMode_SourceIn);
painter2.fillRect( pixmap2.rect(), colorForMode(painter, mode) );
return pixmap2;
}
QIcon icon = pixmapFromFile(m_iconName, size);
if ( icon.isNull() )
icon = fromTheme(m_iconName);
if ( !icon.isNull() ) {
auto pixmap = icon.pixmap(size, mode, state);
if (pixmap.size() != size) {
pixmap = pixmap.scaled(size.width(), size.height(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
QPixmap pixmap2(size);
pixmap2.fill(Qt::transparent);
QPainter painter2(&pixmap2);
const int x = size.width() - pixmap.width();
const QRect rect( QPoint(x, 0), pixmap.size() );
painter2.drawPixmap(rect, pixmap);
pixmap = pixmap2;
}
return pixmap;
}
return FontIconEngine::doCreatePixmap(size, mode, state, painter);
}
private:
QString m_iconName;
};
class AppIconEngine final : public BaseIconEngine
{
public:
AppIconEngine()
: BaseIconEngine(sessionIconTagVariable(), sessionIconTagColor())
{
}
QIconEngine *clone() const override
{
return new AppIconEngine(*this);
}
QPixmap doCreatePixmap(QSize size, QIcon::Mode, QIcon::State, QPainter *) override
{
// If copyq-normal icon exist in theme, omit changing color.
const bool useColoredIcon = !hasNormalIcon();
const auto sessionColor = useColoredIcon ? sessionIconColor() : QColor();
const auto cacheKey = QStringLiteral("app:%1|%2x%3|%4")
.arg(sessionColor.name())
.arg(size.width())
.arg(size.height())
.arg(sessionIconTagEnabledFlag);
{
QPixmap pixmap;
if ( QPixmapCache::find(cacheKey, &pixmap) )
return pixmap;
}
auto pix = appPixmap(QString(), size);
if ( sessionColor.isValid() )
replaceColor(&pix, sessionColor);
if (!sessionIconTagEnabledFlag)
disableIcon(&pix);
QPixmapCache::insert(cacheKey, pix);
return pix;
}
};
class IconEngine final
{
public:
static bool useSystemIcons;
static QIcon createIcon(ushort iconId, const QString &iconName, const QString &tag = QString(), const QColor &tagColor = QColor())
{
if ( canUseFontIcon(iconId, iconName) )
return QIcon( new FontIconEngine(iconId, tag, tagColor) );
return QIcon( new ImageIconEngine(iconName, iconId, tag, tagColor) );
}
static QIcon createIcon()
{
return QIcon( new AppIconEngine() );
}
private:
static bool canUseFontIcon(ushort iconId, const QString &iconName)
{
if ( iconId == 0 || !loadIconFont() )
return false;
if ( useSystemIcons && !iconName.isEmpty() )
return false;
return true;
}
};
bool IconEngine::useSystemIcons = false;
} // namespace
QIcon getIcon(const QString &themeName, unsigned short id)
{
return loadIconFont() || !themeName.isEmpty()
? IconEngine::createIcon(loadIconFont() ? id : 0, themeName)
: QIcon();
}
QIcon getIcon(const QVariant &iconOrIconId)
{
if (iconOrIconId.canConvert(QVariant::UInt))
return getIcon( QString(), iconOrIconId.value<ushort>() );
if (iconOrIconId.canConvert(QVariant::Icon))
return iconOrIconId.value<QIcon>();
return QIcon();
}
QIcon getIconFromResources(const QString &iconName)
{
return IconEngine::createIcon(0, QStringLiteral(":/images/") + iconName);
}
QIcon iconFromFile(const QString &fileName, const QString &tag, const QColor &color)
{
if ( fileName.isEmpty() && tag.isEmpty() )
return QIcon();
const auto unicode = toIconId(fileName);
if (unicode != 0)
return loadIconFont() ? IconEngine::createIcon(unicode, "", tag, color) : QIcon();
return IconEngine::createIcon(0, fileName, tag, color);
}
QIcon iconFromFile(const QString &fileName, const QString &tag)
{
return iconFromFile(fileName, tag, {});
}
QIcon iconFromFile(const QString &fileName)
{
return iconFromFile(fileName, {}, {});
}
QPixmap createPixmap(unsigned short id, const QColor &color, int size)
{
if (loadIconFont())
return drawFontIcon(id, size, size, color);
QPixmap pixmap(size, size);
pixmap.fill(Qt::transparent);
return pixmap;
}
QIcon appIcon()
{
return IconEngine::createIcon();
}
void setActivePaintDevice(QObject *device)
{
activePaintDevice() = device;
}
QColor getDefaultIconColor(const QWidget &widget, bool selected)
{
const QWidget *parent = &widget;
while ( parent->parentWidget()
&& !parent->isTopLevel()
&& !parent->testAttribute(Qt::WA_OpaquePaintEvent) )
{
parent = parent->parentWidget();
}
QPalette::ColorRole role = selected ? QPalette::Highlight : parent->backgroundRole();
return getDefaultIconColor( parent->palette().color(QPalette::Active, role) );
}
unsigned short toIconId(const QString &fileNameOrId)
{
if ( fileNameOrId.size() != 1 )
return 0;
return fileNameOrId.at(0).unicode();
}
void setSessionIconColor(QColor color)
{
sessionIconColorVariable() = color.isValid() ? color : sessionIconColorHelper();
}
void setSessionIconTag(const QString &tag)
{
sessionIconTagVariable() = tag;
}
void setSessionIconTagColor(QColor color)
{
sessionIconTagColorVariable() = color;
}
void setSessionIconEnabled(bool enabled)
{
sessionIconTagEnabledFlag = enabled;
}
QColor sessionIconColor()
{
return ::sessionIconColorVariable();
}
QString sessionIconTag()
{
return ::sessionIconTagVariable();
}
QColor sessionIconTagColor()
{
return ::sessionIconTagColorVariable();
}
void setUseSystemIcons(bool useSystemIcons)
{
IconEngine::useSystemIcons = useSystemIcons;
}
| 18,861
|
C++
|
.cpp
| 582
| 26.568729
| 134
| 0.657661
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,240
|
filterlineedit.cpp
|
hluk_CopyQ/src/gui/filterlineedit.cpp
|
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#include "filterlineedit.h"
#include "common/appconfig.h"
#include "common/compatibility.h"
#include "common/config.h"
#include "common/contenttype.h"
#include "common/regexp.h"
#include "common/textdata.h"
#include "gui/iconfactory.h"
#include "gui/icons.h"
#include "gui/filtercompleter.h"
#include <QKeyEvent>
#include <QMenu>
#include <QModelIndex>
#include <QPainter>
#include <QRegularExpression>
#include <QSettings>
#include <QTextCursor>
#include <QTextDocument>
#include <QTextEdit>
#include <QTimer>
namespace {
const QLatin1String optionFilterHistory("filter_history");
class BaseItemFilter : public ItemFilter {
public:
explicit BaseItemFilter(const QString &searchString)
: m_searchString(searchString)
{
}
QString searchString() const override
{
return m_searchString;
}
void highlight(QTextEdit *edit, const QTextCharFormat &format) const override
{
QList<QTextEdit::ExtraSelection> selections = this->selections(edit->document(), format);
// If there are no matches, try to match document without accents/diacritics.
if (selections.isEmpty()) {
QTextDocument doc;
const auto text = edit->document()->toPlainText();
doc.setPlainText(accentsRemoved(text));
selections = this->selections(&doc, format);
for (QTextEdit::ExtraSelection &selection : selections) {
const auto pos = selection.cursor.position();
const auto anchor = selection.cursor.anchor();
selection.cursor = QTextCursor(edit->document());
selection.cursor.setPosition(pos);
selection.cursor.setPosition(anchor, QTextCursor::KeepAnchor);
}
}
edit->setExtraSelections(selections);
edit->update();
}
bool matchesAll() const override
{
return m_searchString.isEmpty();
}
bool matchesIndex(const QModelIndex &index) const override
{
// Match formats if the filter expression contains single '/'.
if ( m_searchString.count('/') != 1 )
return false;
const auto re2 = anchoredRegExp(m_searchString);
const QVariantMap data = index.data(contentType::data).toMap();
return std::any_of(data.keyBegin(), data.keyEnd(), [&re2](const QString &key) {
return key.contains(re2);
});
}
private:
virtual QList<QTextEdit::ExtraSelection> selections(QTextDocument *doc, const QTextCharFormat &format) const = 0;
QString m_searchString;
};
class ItemFilterRegExp final : public BaseItemFilter {
public:
ItemFilterRegExp(const QRegularExpression &re, const QString &searchString)
: BaseItemFilter(searchString)
, m_re(re)
{
}
bool matchesNone() const override
{
return !m_re.isValid();
}
bool matches(const QString &text) const override
{
return text.contains(m_re);
}
void search(QTextEdit *edit, bool backwards) const override
{
if ( matchesAll() )
return;
auto tc = edit->textCursor();
if ( tc.isNull() )
return;
QTextDocument::FindFlags flags;
if (backwards)
flags = QTextDocument::FindBackward;
auto tc2 = tc.document()->find(m_re, tc, flags);
if (tc2.isNull()) {
tc2 = tc;
if (backwards)
tc2.movePosition(QTextCursor::End);
else
tc2.movePosition(QTextCursor::Start);
tc2 = tc.document()->find(m_re, tc2, flags);
}
if (!tc2.isNull())
edit->setTextCursor(tc2);
}
private:
QList<QTextEdit::ExtraSelection> selections(QTextDocument *doc, const QTextCharFormat &format) const override
{
QList<QTextEdit::ExtraSelection> selections;
if ( m_re.isValid() && !matchesAll() ) {
QTextCursor cur = doc->find(m_re);
int a = cur.position();
while ( !cur.isNull() ) {
if ( cur.hasSelection() ) {
selections.append({cur, format});
} else {
cur.movePosition(QTextCursor::NextCharacter);
}
cur = doc->find(m_re, cur);
int b = cur.position();
if (a == b) {
cur.movePosition(QTextCursor::NextCharacter);
cur = doc->find(m_re, cur);
b = cur.position();
if (a == b) break;
}
a = b;
}
}
return selections;
}
QRegularExpression m_re;
};
class ItemFilterFixedStrings final : public BaseItemFilter {
public:
ItemFilterFixedStrings(const QString &searchString, Qt::CaseSensitivity caseSensitivity)
: BaseItemFilter(searchString)
, m_needles( searchString.split(QRegularExpression("\\s+"), SKIP_EMPTY_PARTS) )
, m_caseSensitivity(caseSensitivity)
{
}
bool matchesNone() const override
{
return false;
}
bool matches(const QString &text) const override
{
return std::all_of(std::begin(m_needles), std::end(m_needles),
[&text, this](const QString &needle) {
return text.contains(needle, m_caseSensitivity);
});
}
void search(QTextEdit *edit, bool backwards) const override
{
if ( matchesAll() )
return;
auto tc = edit->textCursor();
if ( tc.isNull() )
return;
QTextDocument::FindFlags flags;
if (backwards)
flags = QTextDocument::FindBackward;
if (m_caseSensitivity == Qt::CaseSensitive)
flags = QTextDocument::FindCaseSensitively;
QTextCursor tc2;
int minDistance = std::numeric_limits<int>::max();
for ( const QString &needle : m_needles ) {
int distance = 0;
auto tc3 = tc.document()->find(needle, tc, flags);
// Wrap around.
if ( tc3.isNull() ) {
tc3 = tc;
tc3.movePosition(QTextCursor::End);
const int endPos = tc3.position();
if (!backwards)
tc3.movePosition(QTextCursor::Start);
tc3 = tc.document()->find(needle, tc3, flags);
if ( tc3.isNull() )
continue;
distance = backwards
? tc.selectionStart() + (endPos - tc3.selectionEnd())
: endPos - tc.selectionStart() + tc3.selectionStart();
} else {
distance = backwards
? tc.selectionEnd() - tc3.selectionEnd()
: tc3.selectionStart() - tc.selectionStart();
}
// Find longest selection closest to the text cursor.
if ( tc2.isNull()
|| distance < minDistance
|| tc3.selectedText().size() > tc2.selectedText().size() )
{
minDistance = distance;
tc2 = tc3;
}
}
if ( !tc2.isNull() )
edit->setTextCursor(tc2);
}
private:
QList<QTextEdit::ExtraSelection> selections(QTextDocument *doc, const QTextCharFormat &format) const override
{
QList<QTextEdit::ExtraSelection> selections;
QTextDocument::FindFlags flags;
if (m_caseSensitivity == Qt::CaseSensitive)
flags = QTextDocument::FindCaseSensitively;
for ( const QString &needle : m_needles ) {
QTextCursor cur = doc->find(needle, 0, flags);
int a = cur.position();
while ( !cur.isNull() ) {
if ( cur.hasSelection() ) {
selections.append({cur, format});
} else {
cur.movePosition(QTextCursor::NextCharacter);
}
cur = doc->find(needle, cur, flags);
int b = cur.position();
if (a == b) {
cur.movePosition(QTextCursor::NextCharacter);
cur = doc->find(needle, cur, flags);
b = cur.position();
if (a == b) break;
}
a = b;
}
}
return selections;
}
QStringList m_needles;
Qt::CaseSensitivity m_caseSensitivity;
};
class FilterHistory final {
public:
FilterHistory()
: m_settings( getConfigurationFilePath("-filter.ini"), QSettings::IniFormat )
{
}
QStringList history() const
{
return m_settings.value(optionFilterHistory).toStringList();
}
void setHistory(const QStringList &history)
{
m_settings.setValue(optionFilterHistory, history);
}
private:
QSettings m_settings;
};
// Compatibility with version 2.5.0 and below
void restoreOldFilterHistory()
{
const QVariant oldHistoryValue = AppConfig().option(optionFilterHistory);
if (oldHistoryValue.isValid()) {
const QStringList oldHistory = oldHistoryValue.toStringList();
if (!oldHistory.isEmpty()) {
FilterHistory filterHistory;
QStringList newHistory = filterHistory.history() + oldHistory;
newHistory.removeDuplicates();
filterHistory.setHistory(newHistory);
}
AppConfig().removeOption(optionFilterHistory);
}
}
} // namespace
/*!
The FilterLineEdit class is a fancy line edit customized for
filtering purposes with a clear button.
*/
namespace Utils {
FilterLineEdit::FilterLineEdit(QWidget *parent)
: FancyLineEdit(parent)
, m_timerSearch( new QTimer(this) )
{
setButtonVisible(Left, true);
setButtonVisible(Right, true);
connect(this, &FancyLineEdit::rightButtonClicked, this, &QLineEdit::clear);
// search timer
m_timerSearch->setSingleShot(true);
m_timerSearch->setInterval(200);
connect( m_timerSearch, &QTimer::timeout,
this, &FilterLineEdit::filterChanged );
connect( this, &QLineEdit::textChanged,
this, &FilterLineEdit::onTextChanged );
// menu
auto menu = new QMenu(this);
setButtonMenu(Left, menu);
connect( menu, &QMenu::triggered,
this, &FilterLineEdit::onMenuAction );
m_actionRe = menu->addAction(tr("Regular Expression"));
m_actionRe->setCheckable(true);
m_actionCaseInsensitive = menu->addAction(tr("Case Insensitive"));
m_actionCaseInsensitive->setCheckable(true);
}
ItemFilterPtr FilterLineEdit::filter() const
{
const QString pattern = text();
if (m_actionRe->isChecked()) {
const auto sensitivity =
m_actionCaseInsensitive->isChecked()
? QRegularExpression::CaseInsensitiveOption
: QRegularExpression::NoPatternOption;
return std::make_shared<ItemFilterRegExp>(QRegularExpression(pattern, sensitivity), pattern);
}
const auto sensitivity = m_actionCaseInsensitive->isChecked()
? Qt::CaseInsensitive : Qt::CaseSensitive;
return std::make_shared<ItemFilterFixedStrings>(pattern, sensitivity);
}
void FilterLineEdit::loadSettings()
{
AppConfig appConfig;
const bool filterRegEx = appConfig.option<Config::filter_regular_expression>();
m_actionRe->setChecked(filterRegEx);
const bool filterCaseSensitive = appConfig.option<Config::filter_case_insensitive>();
m_actionCaseInsensitive->setChecked(filterCaseSensitive);
const QIcon icon1 = getIcon("edit-clear", IconXmark);
setButtonIcon(Right, icon1);
const QIcon icon2 = getIcon("edit-find", IconMagnifyingGlass);
setButtonIcon(Left, icon2);
if ( appConfig.option<Config::save_filter_history>() ) {
if ( !completer() ) {
FilterCompleter::installCompleter(this);
restoreOldFilterHistory();
completer()->setProperty( "history", FilterHistory().history() );
}
} else {
FilterCompleter::removeCompleter(this);
FilterHistory().setHistory(QStringList());
}
}
void FilterLineEdit::keyPressEvent(QKeyEvent *ke)
{
// Up/Down arrow keys should be passed to the item list
// (on OS X this moves text cursor to the beginning/end).
if (ke->key() == Qt::Key_Down || ke->key() == Qt::Key_Up) {
ke->ignore();
return;
}
// If no text is selected, pass copy actions to the item list.
if ( selectionLength() == 0 && ke->matches(QKeySequence::Copy) ) {
ke->ignore();
return;
}
FancyLineEdit::keyPressEvent(ke);
}
void FilterLineEdit::hideEvent(QHideEvent *event)
{
FancyLineEdit::hideEvent(event);
if (completer()) {
const QStringList history = completer()->property("history").toStringList();
FilterHistory().setHistory(history);
}
}
void FilterLineEdit::focusInEvent(QFocusEvent *event)
{
FancyLineEdit::focusInEvent(event);
}
void FilterLineEdit::focusOutEvent(QFocusEvent *event)
{
FancyLineEdit::focusOutEvent(event);
if ( m_timerSearch->isActive() ) {
m_timerSearch->stop();
onTextChanged();
}
}
void FilterLineEdit::onTextChanged()
{
if ( hasFocus() )
m_timerSearch->start();
else
emit filterChanged();
}
void FilterLineEdit::onMenuAction()
{
AppConfig appConfig;
appConfig.setOption("filter_regular_expression", m_actionRe->isChecked());
appConfig.setOption("filter_case_insensitive", m_actionCaseInsensitive->isChecked());
emit filterChanged();
}
} // namespace Utils
| 15,033
|
C++
|
.cpp
| 410
| 28.878049
| 117
| 0.624734
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,241
|
filtercompleter.cpp
|
hluk_CopyQ/src/gui/filtercompleter.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "filtercompleter.h"
#include <QAbstractListModel>
#include <QApplication>
#include <QAction>
#include <QEvent>
#include <QLineEdit>
#include <QMoveEvent>
namespace {
const int maxCompletionItems = 100;
class CompletionModel final : public QAbstractListModel
{
public:
explicit CompletionModel(QObject *parent)
: QAbstractListModel(parent)
{
}
int rowCount(const QModelIndex &parent = QModelIndex()) const override
{
return parent.isValid() ? 0 : m_items.size();
}
QVariant data(const QModelIndex &index, int role) const override
{
if (index.isValid() && (role == Qt::EditRole || role == Qt::DisplayRole))
return m_items[index.row()];
return QVariant();
}
bool setData(const QModelIndex &index, const QVariant &value, int role) override
{
if (!index.isValid() && role == Qt::EditRole) {
const QString text = value.toString();
removeAll(text);
crop(maxCompletionItems - 1);
prepend(text);
}
return false;
}
bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex()) override
{
const auto end = row + count;
if ( parent.isValid() || row < 0 || end > rowCount() )
return false;
beginRemoveRows(QModelIndex(), row, end);
m_items.erase( m_items.begin() + row, m_items.begin() + end );
endRemoveRows();
return true;
}
private:
void prepend(const QString &text)
{
beginInsertRows(QModelIndex(), 0, 0);
m_items.prepend(text);
endInsertRows();
}
void removeAll(const QString &text)
{
for ( int row = m_items.indexOf(text);
row != -1;
row = m_items.indexOf(text, row) )
{
removeRows(row, 1);
}
}
void crop(int maxItems)
{
const int itemCount = m_items.size();
if (itemCount > maxItems)
removeRows(maxItems, itemCount - maxItems);
}
QStringList m_items;
};
} // namespace
void FilterCompleter::installCompleter(QLineEdit *lineEdit)
{
Q_ASSERT(lineEdit);
new FilterCompleter(lineEdit);
}
void FilterCompleter::removeCompleter(QLineEdit *lineEdit)
{
lineEdit->setCompleter(nullptr);
}
QStringList FilterCompleter::history() const
{
QStringList history;
for (int i = 0; i < model()->rowCount(); ++i) {
const QModelIndex index = model()->index(i, 0);
history.append( index.data(Qt::EditRole).toString() );
}
return history;
}
void FilterCompleter::setHistory(const QStringList &history)
{
model()->removeRows( 0, model()->rowCount() );
for (int i = history.size() - 1; i >= 0; --i)
prependItem(history[i]);
}
bool FilterCompleter::eventFilter(QObject *obj, QEvent *event)
{
// Close popup menu if mouse wheel scrolls and mouse pointer is outside the menu.
if (event->type() == QEvent::Wheel) {
auto popup = qobject_cast<QWidget*>(obj);
if (popup && !popup->underMouse())
popup->hide();
return true;
}
return QCompleter::eventFilter(obj, event);
}
void FilterCompleter::onTextEdited(const QString &text)
{
m_lastText = text;
setUnfiltered(false);
}
void FilterCompleter::onEditingFinished()
{
prependItem(m_lastText);
m_lastText.clear();
setUnfiltered(false);
}
void FilterCompleter::onComplete()
{
if (m_lineEdit->text().isEmpty()) {
setUnfiltered(true);
const QModelIndex firstIndex = model()->index(0, 0);
const QString text = model()->data(firstIndex, Qt::EditRole).toString();
m_lineEdit->setText(text);
} else {
complete();
}
}
FilterCompleter::FilterCompleter(QLineEdit *lineEdit)
: QCompleter(lineEdit)
, m_lineEdit(lineEdit)
{
setModel(new CompletionModel(this));
setWrapAround(true);
setUnfiltered(false);
QWidget *window = lineEdit->window();
if (window) {
auto act = new QAction(this);
act->setShortcut(tr("Alt+Down", "Filter completion shortcut"));
connect(act, &QAction::triggered, this, &FilterCompleter::onComplete);
window->addAction(act);
}
// Postpone prepending item to completion list because incorrect
// item will be completed otherwise (prepending shifts rows).
connect( lineEdit, &QLineEdit::editingFinished,
this, &FilterCompleter::onEditingFinished, Qt::QueuedConnection );
connect( lineEdit, &QLineEdit::textEdited,
this, &FilterCompleter::onTextEdited );
lineEdit->setCompleter(this);
}
void FilterCompleter::setUnfiltered(bool unfiltered)
{
setCompletionMode(unfiltered ? QCompleter::UnfilteredPopupCompletion
: QCompleter::PopupCompletion);
}
void FilterCompleter::prependItem(const QString &item)
{
if ( !item.isEmpty() )
model()->setData(QModelIndex(), item);
}
| 5,023
|
C++
|
.cpp
| 161
| 25.409938
| 91
| 0.649399
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,242
|
fancylineedit.cpp
|
hluk_CopyQ/src/gui/fancylineedit.cpp
|
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#include "execmenu.h"
#include "fancylineedit.h"
#include "common/common.h"
#include "gui/iconfactory.h"
#include <QAbstractItemView>
#include <QKeyEvent>
#include <QMenu>
#include <QStylePainter>
#include <QStyle>
/*!
The FancyLineEdit class is an enhanced line edit with several
opt-in features.
A FancyLineEdit instance can have:
- An embedded pixmap on one side that is connected to a menu.
- A grayed hintText (like "Type Here to")
when not focused and empty. When connecting to the changed signals and
querying text, one has to be aware that the text is set to that hint
text if isShowingHintText() returns true (that is, does not contain
valid user input).
*/
namespace Utils {
// --------- FancyLineEditPrivate
class FancyLineEditPrivate final : public QObject
{
public:
explicit FancyLineEditPrivate(FancyLineEdit *parent);
bool eventFilter(QObject *obj, QEvent *event) override;
FancyLineEdit *m_lineEdit;
QString m_oldText;
QMenu *m_menu[2]{};
bool m_menuTabFocusTrigger[2]{};
IconButton *m_iconbutton[2]{};
bool m_iconEnabled[2]{};
};
FancyLineEditPrivate::FancyLineEditPrivate(FancyLineEdit *parent) :
QObject(parent),
m_lineEdit(parent)
{
for (int i = 0; i < 2; ++i) {
m_menu[i] = nullptr;
m_menuTabFocusTrigger[i] = false;
m_iconbutton[i] = new IconButton(parent);
m_iconbutton[i]->installEventFilter(this);
m_iconbutton[i]->hide();
m_iconEnabled[i] = false;
}
}
bool FancyLineEditPrivate::eventFilter(QObject *obj, QEvent *event)
{
int buttonIndex = -1;
for (int i = 0; i < 2; ++i) {
if (obj == m_iconbutton[i]) {
buttonIndex = i;
break;
}
}
if (buttonIndex == -1)
return QObject::eventFilter(obj, event);
if ( event->type() == QEvent::FocusIn
&& m_menuTabFocusTrigger[buttonIndex]
&& m_menu[buttonIndex])
{
m_lineEdit->setFocus();
execMenuAtWidget(m_menu[buttonIndex], m_iconbutton[buttonIndex]);
return true;
}
return QObject::eventFilter(obj, event);
}
// --------- FancyLineEdit
FancyLineEdit::FancyLineEdit(QWidget *parent) :
QLineEdit(parent),
d(new FancyLineEditPrivate(this))
{
ensurePolished();
updateMargins();
connect(d->m_iconbutton[Left], &QAbstractButton::clicked,
this, &FancyLineEdit::iconClicked);
connect(d->m_iconbutton[Right], &QAbstractButton::clicked,
this, &FancyLineEdit::iconClicked);
}
FancyLineEdit::~FancyLineEdit() = default;
void FancyLineEdit::setButtonVisible(Side side, bool visible)
{
d->m_iconbutton[side]->setVisible(visible);
d->m_iconEnabled[side] = visible;
updateMargins();
}
bool FancyLineEdit::isButtonVisible(Side side) const
{
return d->m_iconEnabled[side];
}
QAbstractButton *FancyLineEdit::button(FancyLineEdit::Side side) const
{
return d->m_iconbutton[side];
}
void FancyLineEdit::iconClicked()
{
IconButton *button = qobject_cast<IconButton *>(sender());
int index = -1;
for (int i = 0; i < 2; ++i)
if (d->m_iconbutton[i] == button)
index = i;
if (index == -1)
return;
if (d->m_menu[index]) {
execMenuAtWidget(d->m_menu[index], button);
} else {
emit buttonClicked(static_cast<Side>(index));
if (index == Left)
emit leftButtonClicked();
else if (index == Right)
emit rightButtonClicked();
}
}
void FancyLineEdit::updateMargins()
{
bool leftToRight = (layoutDirection() == Qt::LeftToRight);
Side realLeft = (leftToRight ? Left : Right);
Side realRight = (leftToRight ? Right : Left);
const auto buttonExtent = height();
auto leftMargin = static_cast<int>( buttonExtent + 8 );
auto rightMargin = static_cast<int>( buttonExtent + 8 );
// Note KDE does not reserve space for the highlight color
if (style()->inherits("OxygenStyle")) {
leftMargin = qMax(24, leftMargin);
rightMargin = qMax(24, rightMargin);
}
QMargins margins((d->m_iconEnabled[realLeft] ? leftMargin : 0), 0,
(d->m_iconEnabled[realRight] ? rightMargin : 0), 0);
setTextMargins(margins);
}
void FancyLineEdit::updateButtonPositions()
{
QRect contentRect = rect();
for (int i = 0; i < 2; ++i) {
Side iconpos = static_cast<Side>(i);
if (layoutDirection() == Qt::RightToLeft)
iconpos = (iconpos == Left ? Right : Left);
IconButton *button = d->m_iconbutton[i];
const auto margin = 8 - (button->hasMenu() ? 3 : 0);
if (iconpos == FancyLineEdit::Right) {
const int iconoffset = textMargins().right() - margin;
button->setGeometry(contentRect.adjusted(contentRect.width() - iconoffset, 0, 0, 0));
} else {
const int iconoffset = textMargins().left() - margin;
button->setGeometry(contentRect.adjusted(0, 0, -contentRect.width() + iconoffset, 0));
}
}
}
void FancyLineEdit::resizeEvent(QResizeEvent *)
{
updateMargins();
updateButtonPositions();
}
void FancyLineEdit::setButtonIcon(Side side, const QIcon &icon)
{
d->m_iconbutton[side]->setIcon(icon);
}
void FancyLineEdit::setButtonMenu(Side side, QMenu *buttonMenu)
{
d->m_menu[side] = buttonMenu;
d->m_iconbutton[side]->setHasMenu(buttonMenu != nullptr);
}
QMenu *FancyLineEdit::buttonMenu(Side side) const
{
return d->m_menu[side];
}
bool FancyLineEdit::hasMenuTabFocusTrigger(Side side) const
{
return d->m_menuTabFocusTrigger[side];
}
void FancyLineEdit::setMenuTabFocusTrigger(Side side, bool v)
{
if (d->m_menuTabFocusTrigger[side] == v)
return;
d->m_menuTabFocusTrigger[side] = v;
d->m_iconbutton[side]->setFocusPolicy(v ? Qt::TabFocus : Qt::NoFocus);
}
void FancyLineEdit::setButtonToolTip(Side side, const QString &tip)
{
d->m_iconbutton[side]->setToolTip(tip);
}
void FancyLineEdit::setButtonFocusPolicy(Side side, Qt::FocusPolicy policy)
{
d->m_iconbutton[side]->setFocusPolicy(policy);
}
//
// IconButton - helper class to represent a clickable icon
//
IconButton::IconButton(QWidget *parent)
: QAbstractButton(parent)
, m_hasMenu(false)
{
setCursor(Qt::PointingHandCursor);
setFocusPolicy(Qt::NoFocus);
}
void IconButton::paintEvent(QPaintEvent *)
{
const auto m = 3;
auto pixmapRect = contentsRect().adjusted(m, m, -m, -m);
if (m_hasMenu)
pixmapRect.setWidth( pixmapRect.width() - 2 );
QStylePainter painter(this);
m_icon.paint(&painter, pixmapRect);
if (m_hasMenu) {
// small triangle next to icon to indicate menu
QPolygon triangle;
triangle.append(QPoint(0, 0));
triangle.append(QPoint(6, 0));
triangle.append(QPoint(3, 3));
const QColor c = getDefaultIconColor(*this);
painter.save();
painter.translate(pixmapRect.bottomRight() + QPoint(0, -4));
painter.setBrush(c);
painter.setPen(Qt::NoPen);
painter.drawPolygon(triangle);
painter.restore();
}
if (hasFocus()) {
QStyleOptionFocusRect focusOption;
focusOption.initFrom(this);
focusOption.rect = pixmapRect;
#ifdef Q_OS_MAC
focusOption.rect.adjust(-4, -4, 4, 4);
painter.drawControl(QStyle::CE_FocusFrame, focusOption);
#endif
painter.drawPrimitive(QStyle::PE_FrameFocusRect, focusOption);
}
}
void IconButton::keyPressEvent(QKeyEvent *ke)
{
QAbstractButton::keyPressEvent(ke);
if (!ke->modifiers() && (ke->key() == Qt::Key_Enter || ke->key() == Qt::Key_Return))
click();
// do not forward to line edit
ke->accept();
}
void IconButton::keyReleaseEvent(QKeyEvent *ke)
{
QAbstractButton::keyReleaseEvent(ke);
// do not forward to line edit
ke->accept();
}
} // namespace Utils
| 9,103
|
C++
|
.cpp
| 268
| 29.257463
| 98
| 0.665984
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,243
|
clipboardspy.cpp
|
hluk_CopyQ/src/gui/clipboardspy.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "clipboardspy.h"
#include "common/common.h"
#include "common/mimetypes.h"
#include "platform/platformclipboard.h"
#include "platform/platformnativeinterface.h"
#include <QApplication>
#include <QTimer>
ClipboardSpy::ClipboardSpy(ClipboardMode mode, const QByteArray &owner)
: m_mode(mode)
, m_clipboard(platformNativeInterface()->clipboard())
{
m_oldOwnerData = owner.isEmpty() ? currentOwnerData() : owner;
connect( m_clipboard.get(), &PlatformClipboard::changed, this,
[this](ClipboardMode changedMode) {
if (changedMode == m_mode)
check();
}
);
m_clipboard->startMonitoring( QStringList(mimeOwner) );
}
void ClipboardSpy::wait(int ms, int checkIntervalMs)
{
if (m_mode == ClipboardMode::Selection && !m_clipboard->isSelectionSupported())
return;
QEventLoop loop;
connect( this, &ClipboardSpy::changed, &loop, &QEventLoop::quit );
connect( this, &ClipboardSpy::stopped, &loop, &QEventLoop::quit );
QTimer timerStop;
if (ms >= 0) {
timerStop.setInterval(ms);
connect( &timerStop, &QTimer::timeout, &loop, &QEventLoop::quit );
timerStop.start();
}
QTimer timerCheck;
timerCheck.setInterval(checkIntervalMs);
connect( &timerCheck, &QTimer::timeout, this, &ClipboardSpy::check );
timerCheck.start();
loop.exec();
}
bool ClipboardSpy::setClipboardData(const QVariantMap &data)
{
m_oldOwnerData = currentOwnerData();
m_clipboard->setData(m_mode, data);
wait();
m_oldOwnerData = data.value(mimeOwner).toByteArray();
return m_oldOwnerData == currentOwnerData();
}
QByteArray ClipboardSpy::currentOwnerData() const
{
return m_clipboard->data(m_mode, QStringList(mimeOwner)).value(mimeOwner).toByteArray();
}
void ClipboardSpy::stop()
{
emit stopped();
}
bool ClipboardSpy::check()
{
if (!m_oldOwnerData.isEmpty() && m_oldOwnerData == currentOwnerData())
return false;
emit changed();
return true;
}
| 2,057
|
C++
|
.cpp
| 63
| 28.301587
| 92
| 0.699848
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,244
|
shortcutswidget.cpp
|
hluk_CopyQ/src/gui/shortcutswidget.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "gui/shortcutswidget.h"
#include "ui_shortcutswidget.h"
#include "common/command.h"
#include "common/common.h"
#include "common/predefinedcommands.h"
#include "common/shortcuts.h"
#include "common/timer.h"
#include "gui/commanddialog.h"
#include "gui/iconfactory.h"
#include "gui/iconfont.h"
#include "gui/icons.h"
#include "gui/menuitems.h"
#include "gui/shortcutbutton.h"
#include <QList>
#include <QPushButton>
#include <QSettings>
#include <algorithm>
namespace {
namespace Columns {
enum Columns {
Icon,
Text,
Shortcut,
Count
};
}
QString uiText(QString text)
{
return text.remove('&');
}
Command *findShortcutCommand(const QString &name, QVector<Command> &commands)
{
for (auto &command2 : commands) {
if (command2.name == name)
return &command2;
}
return nullptr;
}
bool hasShortcutCommand(const QString &name, const QVector<MenuAction> &actions)
{
for (auto &action : actions) {
if (action.command.name == name)
return true;
}
return false;
}
bool canAddCommandAction(const Command &command, const QVector<MenuAction> &actions)
{
return command.type() & (CommandType::Menu | CommandType::GlobalShortcut)
&& !hasShortcutCommand(command.name, actions);
}
const QStringList &shortcuts(const Command &command)
{
return (command.type() & CommandType::GlobalShortcut)
? command.globalShortcuts
: command.shortcuts;
}
void setShortcuts(Command *command, const QStringList &shortcutNames)
{
if (command->type() & CommandType::GlobalShortcut)
command->globalShortcuts = shortcutNames;
else
command->shortcuts = shortcutNames;
}
} // namespace
ShortcutsWidget::ShortcutsWidget(QWidget *parent)
: QWidget(parent)
, ui(new Ui::ShortcutsWidget)
{
ui->setupUi(this);
connect(ui->lineEditFilter, &QLineEdit::textChanged,
this, &ShortcutsWidget::onLineEditFilterTextChanged);
const int iconSize = iconFontSizePixels();
for (auto table : { ui->tableWidgetApplication, ui->tableWidgetGlobal }) {
table->setColumnCount(Columns::Count);
table->horizontalHeader()->setStretchLastSection(true);
table->horizontalHeader()->hide();
table->verticalHeader()->hide();
table->setIconSize(QSize(iconSize, iconSize));
}
initSingleShotTimer( &m_timerCheckAmbiguous, 0, this, &ShortcutsWidget::checkAmbiguousShortcuts );
}
ShortcutsWidget::~ShortcutsWidget()
{
delete ui;
}
void ShortcutsWidget::loadShortcuts(const QSettings &settings)
{
MenuItems items = menuItems();
::loadShortcuts(&items, settings);
m_actions.clear();
m_shortcuts.clear();
for (auto table : { ui->tableWidgetApplication, ui->tableWidgetGlobal }) {
while (table->rowCount() > 0)
table->removeRow(0);
}
for (const auto &item : items) {
MenuAction action;
action.iconName = item.iconName;
action.iconId = item.iconId;
action.text = item.text;
action.settingsKey = item.settingsKey;
addShortcutRow(action);
action.shortcutButton->setDefaultShortcut(item.defaultShortcut);
for (const auto &shortcut : item.shortcuts)
action.shortcutButton->addShortcut(shortcut);
}
addCommands( loadAllCommands() );
addCommands( predefinedCommands() );
}
void ShortcutsWidget::saveShortcuts(QSettings *settings)
{
auto commands = loadAllCommands();
bool needSaveCommands = false;
for (const auto &action : m_actions) {
QStringList shortcutNames;
for (const auto &shortcut : action.shortcutButton->shortcuts())
shortcutNames.append(portableShortcutText(shortcut));
if ( action.settingsKey.isEmpty() ) {
auto savedCommand = findShortcutCommand(action.command.name, commands);
if (savedCommand) {
if ( savedCommand->enable ? (shortcuts(*savedCommand) != shortcutNames) : !shortcutNames.empty() ) {
needSaveCommands = true;
savedCommand->enable = true;
setShortcuts(savedCommand, shortcutNames);
}
} else if ( !shortcutNames.isEmpty() ) {
needSaveCommands = true;
auto command = action.command;
setShortcuts(&command, shortcutNames);
commands.append(command);
}
} else {
// Workaround for QTBUG-51237 (saving empty list results in invalid value).
if (shortcutNames.isEmpty())
settings->setValue(action.settingsKey, QString());
else
settings->setValue(action.settingsKey, shortcutNames);
}
}
if (needSaveCommands) {
saveCommands(commands);
emit commandsSaved();
}
}
void ShortcutsWidget::addCommands(const QVector<Command> &commands)
{
for ( const auto &command : commands ) {
if ( canAddCommandAction(command, m_actions) ) {
MenuAction action;
action.iconId = toIconId(command.icon);
action.text = command.name;
action.command = command;
addShortcutRow(action);
if (command.enable) {
for (const auto &shortcut : shortcuts(command))
action.shortcutButton->addShortcut(shortcut);
}
}
}
}
void ShortcutsWidget::showEvent(QShowEvent *event)
{
for (auto &action : m_actions) {
if ( action.tableItem->icon().isNull() )
action.tableItem->setIcon( getIcon(action.iconName, action.iconId) );
}
QWidget::showEvent(event);
for (auto table : { ui->tableWidgetApplication, ui->tableWidgetGlobal }) {
table->resizeColumnToContents(Columns::Icon);
table->resizeColumnToContents(Columns::Text);
}
m_timerCheckAmbiguous.start(); // Update because shortcuts for commands may have changed.
}
void ShortcutsWidget::onShortcutAdded(const QKeySequence &shortcut)
{
m_shortcuts.append(shortcut);
m_timerCheckAmbiguous.start();
}
void ShortcutsWidget::onShortcutRemoved(const QKeySequence &shortcut)
{
m_shortcuts.removeOne(shortcut);
m_timerCheckAmbiguous.start();
}
void ShortcutsWidget::checkAmbiguousShortcuts()
{
const auto iconAmbiguous = getIcon("", IconCircleExclamation);
const auto toolTipAmbiguous = tr("Shortcut already exists!");
std::sort( m_shortcuts.begin(), m_shortcuts.end() );
QList<QKeySequence> ambiguousShortcuts;
for ( int i = 1; i < m_shortcuts.size(); ++i ) {
if (m_shortcuts[i] == m_shortcuts[i - 1])
ambiguousShortcuts.append(m_shortcuts[i]);
}
for ( const auto &action : m_actions )
action.shortcutButton->checkAmbiguousShortcuts(ambiguousShortcuts, iconAmbiguous, toolTipAmbiguous);
}
void ShortcutsWidget::onLineEditFilterTextChanged(const QString &text)
{
const QString needle = text.toLower();
for ( const auto &action : m_actions ) {
bool found = uiText(action.text).toLower().contains(needle);
if (!found) {
for ( const auto &shortcut : action.shortcutButton->shortcuts() ) {
if ( shortcut.toString(QKeySequence::NativeText).toLower().contains(needle) ) {
found = true;
break;
}
}
}
const int row = action.tableItem->row();
QTableWidget *table = action.tableItem->tableWidget();
table->setRowHidden(row, !found);
}
}
void ShortcutsWidget::addShortcutRow(MenuAction &action)
{
const bool isGlobal = action.command.type() & CommandType::GlobalShortcut;
QTableWidget *table = isGlobal
? ui->tableWidgetGlobal
: ui->tableWidgetApplication;
const int row = table->rowCount();
table->insertRow(row);
auto tableItem = new QTableWidgetItem();
action.tableItem = tableItem;
table->setItem(row, Columns::Icon, tableItem);
tableItem->setFlags(Qt::ItemIsEnabled);
tableItem = new QTableWidgetItem(uiText(action.text));
table->setItem(row, Columns::Text, tableItem);
tableItem->setFlags(Qt::ItemIsEnabled);
action.shortcutButton = new ShortcutButton(table);
table->setCellWidget(row, Columns::Shortcut, action.shortcutButton);
m_actions.append(action);
connect( action.shortcutButton, &ShortcutButton::shortcutAdded,
this, &ShortcutsWidget::onShortcutAdded );
connect( action.shortcutButton, &ShortcutButton::shortcutRemoved,
this, &ShortcutsWidget::onShortcutRemoved );
}
| 8,701
|
C++
|
.cpp
| 239
| 29.736402
| 116
| 0.669402
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,245
|
shortcutbutton.cpp
|
hluk_CopyQ/src/gui/shortcutbutton.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "gui/shortcutbutton.h"
#include "gui/iconfactory.h"
#include "gui/icons.h"
#include "gui/shortcutdialog.h"
#include <QAction>
#include <QToolButton>
#include <QVariant>
namespace {
const char propertyShortcut[] = "CopyQ_shortcut";
} // namespace
ShortcutButton::ShortcutButton(QWidget *parent)
: QToolBar(parent)
, m_defaultShortcut()
{
setFocusPolicy(Qt::WheelFocus);
setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
m_actionAddShortcut = addAction(QString());
m_actionAddShortcut->setToolTip( tr("Add shortcut") );
connect( m_actionAddShortcut, &QAction::triggered,
this, &ShortcutButton::onButtonAddShortcutClicked );
addShortcut(m_defaultShortcut);
}
void ShortcutButton::addShortcut(const QKeySequence &shortcut)
{
const auto shortcuts = this->shortcuts();
if ( shortcut.isEmpty() || shortcuts.contains(shortcut) )
return;
auto button = new QAction(this);
insertAction(m_actionAddShortcut, button);
connect( button, &QAction::triggered,
this, &ShortcutButton::onShortcutButtonClicked );
setButtonShortcut(button, shortcut);
// Non-flat buttons
auto toolButton = qobject_cast<QToolButton *>(widgetForAction(button));
if (toolButton)
toolButton->setAutoRaise(false);
emit shortcutAdded(shortcut);
}
void ShortcutButton::addShortcut(const QString &shortcutPortableText)
{
QKeySequence shortcut(shortcutPortableText, QKeySequence::PortableText);
if ( !shortcut.isEmpty() )
addShortcut(shortcut);
}
void ShortcutButton::clearShortcuts()
{
for (auto action : actions()) {
if (action == m_actionAddShortcut)
continue;
emit shortcutRemoved( shortcutForButton(*action) );
action->deleteLater();
}
}
void ShortcutButton::resetShortcuts()
{
clearShortcuts();
addShortcut(m_defaultShortcut);
}
void ShortcutButton::setDefaultShortcut(const QKeySequence &defaultShortcut)
{
m_defaultShortcut = defaultShortcut;
}
QList<QKeySequence> ShortcutButton::shortcuts() const
{
QList<QKeySequence> shortcuts;
for (auto action : actions()) {
if (action == m_actionAddShortcut)
continue;
shortcuts.append( shortcutForButton(*action) );
}
return shortcuts;
}
void ShortcutButton::checkAmbiguousShortcuts(const QList<QKeySequence> &ambiguousShortcuts,
const QIcon &warningIcon, const QString &warningToolTip)
{
for (auto action : actions()) {
if ( ambiguousShortcuts.contains( shortcutForButton(*action) ) ) {
action->setProperty("icon", warningIcon);
action->setProperty("toolTip", warningToolTip);
} else if ( action->property("toolTip").toString() == warningToolTip ) {
action->setProperty("icon", QIcon());
action->setProperty("toolTip", QString());
}
}
}
void ShortcutButton::showEvent(QShowEvent *event)
{
if ( m_actionAddShortcut->icon().isNull() )
m_actionAddShortcut->setIcon( getIcon("list-add", IconPlus) );
QWidget::showEvent(event);
}
void ShortcutButton::focusInEvent(QFocusEvent *event)
{
QToolBar::focusInEvent(event);
if ( !hasFocus() )
return;
focusNextPrevChild(true);
}
bool ShortcutButton::focusNextPrevChild(bool next)
{
const QList<QAction*> actions = this->actions();
if ( actions.isEmpty() )
return false;
auto w = focusWidget();
if (!w || w == this) {
w = widgetForAction( next ? actions.first() : actions.last() );
} else if (w && w->hasFocus()) {
auto it = std::find_if(std::begin(actions), std::end(actions), [&](QAction *action) {
return widgetForAction(action) == w;
});
if (next && it == std::end(actions))
return focusNextPrevious(next);
if (!next && it == std::begin(actions))
return focusNextPrevious(next);
if (next)
++it;
else
--it;
if (it == std::end(actions))
return false;
w = widgetForAction(*it);
}
if (!w)
return false;
if (!w->isVisible())
return focusNextPrevious(next);
w->setFocus();
return true;
}
void ShortcutButton::onShortcutButtonClicked()
{
QAction *button = qobject_cast<QAction*>(sender());
Q_ASSERT(button != nullptr);
addShortcut(button);
}
void ShortcutButton::onButtonAddShortcutClicked()
{
addShortcut(nullptr);
}
void ShortcutButton::addShortcut(QAction *shortcutButton)
{
auto dialog = new ShortcutDialog(this);
if (dialog->exec() == QDialog::Rejected)
return;
const QKeySequence newShortcut = dialog->shortcut();
const QKeySequence oldShortcut = shortcutButton
? shortcutForButton(*shortcutButton)
: QKeySequence();
if (oldShortcut == newShortcut)
return;
// Remove shortcut button if shortcut is removed, unrecognized or already set.
if ( newShortcut.isEmpty() || shortcuts().contains(newShortcut) ) {
if (shortcutButton) {
delete shortcutButton;
emit shortcutRemoved(oldShortcut);
}
} else if (shortcutButton) {
emit shortcutRemoved(oldShortcut);
setButtonShortcut(shortcutButton, newShortcut);
emit shortcutAdded(newShortcut);
} else {
addShortcut(newShortcut);
}
}
void ShortcutButton::setButtonShortcut(QAction *shortcutButton, const QKeySequence &shortcut)
{
QString label = shortcut.toString(QKeySequence::NativeText);
label.replace( QLatin1Char('&'), QLatin1String("&&") );
shortcutButton->setText(label);
shortcutButton->setProperty(propertyShortcut, shortcut);
}
QKeySequence ShortcutButton::shortcutForButton(const QAction &w) const
{
return w.property(propertyShortcut).value<QKeySequence>();
}
bool ShortcutButton::focusNextPrevious(bool next)
{
auto w = next ? nextInFocusChain() : previousInFocusChain();
if (w) {
w->setFocus();
return true;
}
return false;
}
| 6,140
|
C++
|
.cpp
| 185
| 27.502703
| 101
| 0.678348
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,246
|
tabdialog.cpp
|
hluk_CopyQ/src/gui/tabdialog.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "tabdialog.h"
#include "ui_tabdialog.h"
#include <QPushButton>
TabDialog::TabDialog(TabDialog::TabDialogType type, QWidget *parent)
: QDialog(parent)
, ui(new Ui::TabDialog)
, m_tabGroupName()
, m_tabs()
{
ui->setupUi(this);
if (type == TabNew) {
setWindowTitle( tr("New Tab") );
setWindowIcon( QIcon(":/images/tab_new") );
} else if (type == TabRename) {
setWindowTitle( tr("Rename Tab") );
setWindowIcon( QIcon(":/images/tab_rename") );
} else {
setWindowTitle( tr("Rename Tab Group") );
setWindowIcon( QIcon(":/images/tab_rename") );
}
connect( this, &TabDialog::accepted,
this, &TabDialog::onAccepted );
connect( ui->lineEditTabName, &QLineEdit::textChanged,
this, &TabDialog::validate );
validate();
}
TabDialog::~TabDialog()
{
delete ui;
}
void TabDialog::setTabIndex(int tabIndex)
{
m_tabIndex = tabIndex;
}
void TabDialog::setTabs(const QStringList &tabs)
{
m_tabs = tabs;
validate();
}
void TabDialog::setTabName(const QString &tabName)
{
ui->lineEditTabName->setText(tabName);
ui->lineEditTabName->selectAll();
}
void TabDialog::setTabGroupName(const QString &tabGroupName)
{
m_tabGroupName = tabGroupName;
ui->lineEditTabName->setText(m_tabGroupName);
}
void TabDialog::validate()
{
bool ok = true;
const QString text = ui->lineEditTabName->text();
if ( m_tabGroupName.isEmpty() ) {
ok = !text.isEmpty() && !m_tabs.contains(text);
} else {
const QString tabPrefix = m_tabGroupName + '/';
for (const auto &tab : m_tabs) {
if ( tab == m_tabGroupName || tab.startsWith(tabPrefix) ) {
const QString newName = text + tab.mid(m_tabGroupName.size());
if ( newName.isEmpty() || m_tabs.contains(newName) ) {
ok = false;
break;
}
}
}
}
ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(ok);
}
void TabDialog::onAccepted()
{
const auto newName = ui->lineEditTabName->text();
if ( m_tabGroupName.isEmpty() && m_tabIndex == -1 )
emit newTabNameAccepted(newName);
else if ( m_tabGroupName.isEmpty() )
emit barTabNameAccepted(newName, m_tabIndex);
else
emit treeTabNameAccepted(newName, m_tabGroupName);
}
| 2,441
|
C++
|
.cpp
| 80
| 24.775
| 78
| 0.629266
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,247
|
commandaction.cpp
|
hluk_CopyQ/src/gui/commandaction.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "commandaction.h"
#include "common/common.h"
#include "common/mimetypes.h"
#include "common/shortcuts.h"
#include "common/textdata.h"
#include "gui/iconfactory.h"
#include <QMenu>
#include <QShortcutEvent>
CommandAction::CommandAction(
const Command &command,
const QString &name,
QMenu *parentMenu)
: QAction(parentMenu)
, m_command(command)
{
setText( elideText(name, parentMenu->font(), QString()) );
setIcon( iconFromFile(m_command.icon) );
if (m_command.icon.size() == 1)
setProperty( "CopyQ_icon_id", m_command.icon[0].unicode() );
connect(this, &QAction::triggered, this, &CommandAction::onTriggered);
parentMenu->addAction(this);
}
const Command &CommandAction::command() const
{
return m_command;
}
bool CommandAction::event(QEvent *event)
{
if (event->type() == QEvent::Shortcut) {
QShortcutEvent *shortcutEvent = static_cast<QShortcutEvent*>(event);
m_triggeredShortcut = portableShortcutText(shortcutEvent->key());
}
return QAction::event(event);
}
void CommandAction::onTriggered()
{
const auto triggeredShortcut = m_triggeredShortcut;
m_triggeredShortcut.clear();
emit triggerCommand(this, triggeredShortcut);
}
| 1,295
|
C++
|
.cpp
| 41
| 27.780488
| 76
| 0.717619
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,248
|
pluginwidget.cpp
|
hluk_CopyQ/src/gui/pluginwidget.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "pluginwidget.h"
#include "ui_pluginwidget.h"
#include "item/itemwidget.h"
PluginWidget::PluginWidget(const ItemLoaderPtr &loader, QWidget *parent)
: QWidget(parent)
, ui(new Ui::PluginWidget)
, m_loader(loader)
{
ui->setupUi(this);
const QString author = m_loader->author();
if (author.isEmpty())
ui->labelAuthor->hide();
else
ui->labelAuthor->setText(author);
const QString description = m_loader->description();
if (description.isEmpty())
ui->labelDescription->hide();
else
ui->labelDescription->setText(m_loader->description());
QWidget *loaderSettings = m_loader->createSettingsWidget(this);
if (loaderSettings) {
ui->verticalLayout->insertWidget(2, loaderSettings);
ui->verticalLayout->setStretch(2, 1);
}
}
PluginWidget::~PluginWidget()
{
delete ui;
}
| 924
|
C++
|
.cpp
| 30
| 26.1
| 72
| 0.687711
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,249
|
tabicons.cpp
|
hluk_CopyQ/src/gui/tabicons.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "tabicons.h"
#include "common/appconfig.h"
#include "common/config.h"
#include "common/settings.h"
#include "common/textdata.h"
#include "gui/iconfactory.h"
#include <QComboBox>
#include <QDir>
#include <QHash>
#include <QIcon>
namespace {
QHash<QString, QString> tabIcons()
{
QHash<QString, QString> icons;
Settings settings;
const int size = settings.beginReadArray("Tabs");
for(int i = 0; i < size; ++i) {
settings.setArrayIndex(i);
icons.insert(settings.value("name").toString(),
settings.value("icon").toString());
}
return icons;
}
QByteArray tabNameFromFileSuffix(QByteArray base64Suffix)
{
return QByteArray::fromBase64(base64Suffix.replace('-', '/'));
}
} // namespace
QList<QString> savedTabs()
{
QList<QString> tabs = AppConfig().option<Config::tabs>();
const QString configPath = settingsDirectoryPath();
QDir configDir(configPath);
QList<QString> files = configDir.entryList({QStringLiteral("*_tab_*.dat")});
files.append(configDir.entryList({QStringLiteral("*_tab_*.dat.tmp")}));
QRegularExpression re("_tab_([^.]*)");
for (const auto &fileName : files) {
const auto m = re.match(fileName);
if (m.hasMatch()) {
const QString tabName =
getTextData(tabNameFromFileSuffix(m.captured(1).toUtf8()));
if ( !tabName.isEmpty() && !tabs.contains(tabName) )
tabs.append(tabName);
}
}
if ( tabs.isEmpty() )
tabs.append( AppConfig().option<Config::clipboard_tab>() );
return tabs;
}
QString getIconNameForTabName(const QString &tabName)
{
Settings settings;
const int size = settings.beginReadArray("Tabs");
for(int i = 0; i < size; ++i) {
settings.setArrayIndex(i);
if (settings.value("name").toString() == tabName)
return settings.value("icon").toString();
}
return QString();
}
void setIconNameForTabName(const QString &name, const QString &icon)
{
QHash<QString, QString> icons = tabIcons();
icons[name] = icon;
Settings settings;
settings.beginWriteArray("Tabs");
int i = 0;
for (auto it = icons.constBegin(); it != icons.constEnd(); ++it) {
settings.setArrayIndex(i++);
settings.setValue("name", it.key());
settings.setValue("icon", it.value());
}
settings.endArray();
}
QIcon getIconForTabName(const QString &tabName)
{
const QString fileName = getIconNameForTabName(tabName);
return fileName.isEmpty() ? QIcon() : iconFromFile(fileName);
}
void initTabComboBox(QComboBox *comboBox)
{
setComboBoxItems(comboBox, AppConfig().option<Config::tabs>());
for (int i = 1; i < comboBox->count(); ++i) {
const QString tabName = comboBox->itemText(i);
const QIcon icon = getIconForTabName(tabName);
comboBox->setItemIcon(i, icon);
}
}
void setDefaultTabItemCounterStyle(QWidget *widget)
{
QFont font = widget->font();
const qreal pointSize = font.pointSizeF();
if (pointSize > 0.0)
font.setPointSizeF(pointSize * 0.7);
else
font.setPixelSize( static_cast<int>(font.pixelSize() * 0.7) );
widget->setFont(font);
QPalette pal = widget->palette();
const QPalette::ColorRole role = widget->foregroundRole();
QColor color = pal.color(role);
color.setAlpha( qMax(50, color.alpha() - 100) );
color.setRed( qMin(255, color.red() + 120) );
pal.setColor(role, color);
widget->setPalette(pal);
}
void setComboBoxItems(QComboBox *comboBox, const QList<QString> &items)
{
const QString text = comboBox->currentText();
comboBox->clear();
comboBox->addItem(QString());
comboBox->addItems(items);
comboBox->setEditText(text);
const int currentIndex = comboBox->findText(text);
if (currentIndex != -1)
comboBox->setCurrentIndex(currentIndex);
}
| 3,954
|
C++
|
.cpp
| 117
| 28.74359
| 80
| 0.666754
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
18,251
|
tabtree.cpp
|
hluk_CopyQ/src/gui/tabtree.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "tabtree.h"
#include "common/common.h"
#include "common/display.h"
#include "common/timer.h"
#include "gui/iconfactory.h"
#include "gui/iconfont.h"
#include "gui/tabicons.h"
#include <QApplication>
#include <QLabel>
#include <QList>
#include <QMimeData>
#include <QMouseEvent>
#include <QScrollBar>
#include <QHBoxLayout>
#include <QTreeWidgetItemIterator>
namespace {
enum {
DataText = Qt::UserRole,
DataItemCount
};
void updateItemSize(QTreeWidgetItem *item)
{
QSize size(0, 0);
QWidget *w = item->treeWidget()->itemWidget(item, 0);
if (w) {
size = w->minimumSizeHint();
if (!item->icon(0).isNull()) {
const QSize iconSize = item->treeWidget()->iconSize();
size = QSize(
size.width() + iconSize.width() + 8,
qMax(size.height(), iconSize.height())
);
}
}
item->setSizeHint(0, size);
}
void setItemWidgetSelected(QTreeWidgetItem *item)
{
if (item == nullptr)
return;
QTreeWidget *parent = item->treeWidget();
if (parent == nullptr)
return;
QWidget *w = parent->itemWidget(item, 0);
if (w) {
QStyle *style = w->style();
style->unpolish(w);
style->polish(w);
bool selected = parent->currentItem() == item;
for (auto child : w->findChildren<QWidget *>()) {
child->setProperty("CopyQ_selected", selected);
style->unpolish(child);
style->polish(child);
}
}
updateItemSize(item);
}
QTreeWidgetItem *findLastTreeItem(const QTreeWidget &tree, QStringList *pathComponents)
{
QTreeWidgetItem *parentItem = nullptr;
if ( !pathComponents->isEmpty() ) {
const QString &text = pathComponents->first();
for (int i = 0; i < tree.topLevelItemCount(); ++i) {
if ( tree.topLevelItem(i)->data(0, DataText).toString() == text ) {
parentItem = tree.topLevelItem(i);
break;
}
}
}
if (parentItem != nullptr) {
pathComponents->pop_front();
while ( !pathComponents->isEmpty() ) {
const QString &text = pathComponents->first();
QTreeWidgetItem *item = nullptr;
for (int i = 0; i < parentItem->childCount(); ++i) {
if ( parentItem->child(i)->data(0, DataText).toString() == text ) {
item = parentItem->child(i);
break;
}
}
if (item == nullptr)
break;
parentItem = item;
pathComponents->pop_front();
}
}
return parentItem;
}
QTreeWidgetItem *dropItemsTarget(const QDropEvent &event, const QTreeWidget &parent)
{
return canDropToTab(event) ? parent.itemAt( event.pos() ) : nullptr;
}
int itemLabelPadding()
{
return iconFontSizePixels() / 4;
}
QLabel *createLabel(const QString &objectName, QWidget *parent)
{
QLabel *label = new QLabel(parent);
const int p = itemLabelPadding();
label->setContentsMargins({p,p,p,p});
label->setObjectName(objectName);
return label;
}
class ItemLabel final : public QWidget {
public:
explicit ItemLabel(QTreeWidgetItem *item)
: QWidget(item->treeWidget())
, m_treeWidget(item->treeWidget())
, m_label(createLabel("tab_tree_item", this))
, m_labelItemCount(nullptr)
, m_layout(new QHBoxLayout(this))
{
m_label->setBuddy(m_treeWidget);
m_label->installEventFilter(this);
m_layout->addWidget(m_label);
m_layout->setContentsMargins({});
m_layout->addStretch(1);
m_layout->setSizeConstraint(QLayout::SetMinimumSize);
updateFromItem(item);
}
void updateFromItem(QTreeWidgetItem *item)
{
const QString text = item->data(0, DataText).toString();
const QString itemCount = item->data(0, DataItemCount).toString();
setText(text);
setItemCountLabel(itemCount);
}
void setText(const QString &text)
{
m_label->setText(text);
}
void setItemCountLabel(const QString &itemCount)
{
if (itemCount.isEmpty()) {
delete m_labelItemCount;
m_labelItemCount = nullptr;
} else {
if (!m_labelItemCount) {
m_labelItemCount = createLabel("tab_item_counter", this);
setDefaultTabItemCounterStyle(m_labelItemCount);
m_layout->insertWidget(1, m_labelItemCount);
m_labelItemCount->show();
}
m_labelItemCount->setProperty("text", itemCount);
}
}
protected:
bool eventFilter(QObject *, QEvent *event) override
{
if ( event->type() == QEvent::Shortcut ) {
for ( QTreeWidgetItemIterator it(m_treeWidget->topLevelItem(0)); *it; ++it ) {
auto item = *it;
if ( m_treeWidget->itemWidget(item, 0) == this ) {
m_treeWidget->setCurrentItem(item);
return true;
}
}
}
return false;
}
private:
QTreeWidget *m_treeWidget;
QLabel *m_label;
QLabel *m_labelItemCount;
QHBoxLayout *m_layout;
};
ItemLabel *itemLabel(QTreeWidgetItem *item)
{
return static_cast<ItemLabel*>( item->treeWidget()->itemWidget(item, 0) );
}
void labelItem(QTreeWidgetItem *item)
{
ItemLabel *label = itemLabel(item);
if (label) {
label->updateFromItem(item);
return;
}
QTreeWidget *parent = item->treeWidget();
label = new ItemLabel(item);
label->installEventFilter(parent);
item->setTextAlignment(0, Qt::AlignLeft);
parent->setItemWidget(item, 0, label);
setItemWidgetSelected(item);
}
bool isInside(QWidget *child, QWidget *parent)
{
const QPoint scrollBarPosition = child->mapTo(parent, QPoint(0,0));
return parent->contentsRect().contains(scrollBarPosition);
}
} // namespace
TabTree::TabTree(QWidget *parent)
: QTreeWidget(parent)
{
connect( this, &QTreeWidget::currentItemChanged,
this, &TabTree::onCurrentItemChanged );
setDragEnabled(true);
setDragDropMode(QAbstractItemView::InternalMove);
setDragDropOverwriteMode(false);
setDefaultDropAction(Qt::CopyAction); // otherwise tab is lost if moved outside tree
setFrameShape(QFrame::NoFrame);
setHeaderHidden(true);
setSelectionMode(QAbstractItemView::SingleSelection);
const int x = smallIconSize();
setIconSize(QSize(x, x));
setRootIsDecorated(false);
setMinimumHeight(fontMetrics().lineSpacing() * 3);
verticalScrollBar()->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Ignored);
verticalScrollBar()->installEventFilter(this);
connect( this, &QTreeWidget::itemCollapsed, this, &TabTree::updateSize );
connect( this, &QTreeWidget::itemExpanded, this, &TabTree::updateSize );
initSingleShotTimer( &m_timerUpdate, 0, this, &TabTree::doUpdateSize );
}
QString TabTree::getCurrentTabPath() const
{
return getTabPath( currentItem() );
}
bool TabTree::isTabGroup(const QString &tab) const
{
return isTabGroup( findTreeItem(tab) );
}
QString TabTree::tabName(int tabIndex) const
{
return getTabPath( findTreeItem(tabIndex) );
}
void TabTree::setTabName(int tabIndex, const QString &tabName)
{
QTreeWidgetItem *item = findTreeItem(tabIndex);
Q_ASSERT(item);
if (getTabPath(item) == tabName)
return;
const QString itemCount = item->data(0, DataItemCount).toString();
insertTab(tabIndex, tabName);
if (item == currentItem())
setCurrentTab(tabIndex);
// Remove old item if it's an empty group.
m_tabs.removeOne(item);
if ( isEmptyTabGroup(item) )
deleteItem(item);
item = findTreeItem(tabIndex);
Q_ASSERT(item);
Q_ASSERT(getTabPath(item) == tabName);
if ( !itemCount.isEmpty() )
setTabItemCount(tabName, itemCount);
updateItemSize(item);
updateSize();
}
void TabTree::setTabItemCount(const QString &tabName, const QString &itemCount)
{
QTreeWidgetItem *item = findTreeItem(tabName);
if (!item)
return;
item->setData(0, DataItemCount, itemCount);
ItemLabel *label = itemLabel(item);
Q_ASSERT(label);
label->setItemCountLabel(itemCount);
updateItemSize(item);
updateSize();
}
void TabTree::setTabIcon(QTreeWidgetItem *item, const QString &icon)
{
item->setIcon(0, icon.isEmpty() ? QIcon() : iconFromFile(icon));
updateItemSize(item);
updateSize();
}
void TabTree::setTabIcon(const QString &tabName, const QString &icon)
{
QTreeWidgetItem *item = findTreeItem(tabName);
if (item)
setTabIcon(item, icon);
}
void TabTree::insertTab(int index, const QString &path)
{
QStringList pathComponents = path.split('/');
QTreeWidgetItem *item = findLastTreeItem(*this, &pathComponents);
const bool selectTab = topLevelItemCount() == 0;
for (const auto &text : pathComponents) {
QTreeWidgetItem *parent = item;
if (parent != nullptr) {
int to = 0;
for ( ; to < parent->childCount(); ++to ) {
const int index2 = getTabIndex(parent->child(to));
if (index2 != -1 && index < index2)
break;
}
int from = parent->childCount();
item = new QTreeWidgetItem(parent);
if (from != to)
parent->insertChild(to, parent->takeChild(from));
} else {
int to = 0;
for ( ; to < topLevelItemCount(); ++to ) {
const int index2 = getTabIndex(topLevelItem(to));
if (index2 != -1 && index < index2)
break;
}
int from = topLevelItemCount();
item = new QTreeWidgetItem(this);
if (from != to)
insertTopLevelItem(to, takeTopLevelItem(from));
}
item->setExpanded(true);
item->setData(0, DataText, text);
labelItem(item);
}
Q_ASSERT(item != nullptr);
m_tabs.insert(index, item);
if (selectTab)
setCurrentItem(item);
updateSize();
}
void TabTree::removeTab(int index)
{
QTreeWidgetItem *item = findTreeItem(index);
if (item == nullptr)
return;
m_tabs.removeOne(item);
if (item->childCount() == 0)
deleteItem(item);
updateSize();
}
void TabTree::updateCollapsedTabs(QList<QString> *tabs) const
{
tabs->clear();
for ( QTreeWidgetItemIterator it(topLevelItem(0)); *it; ++it ) {
auto item = *it;
if ( isTabGroup(item) && !item->isExpanded() )
tabs->append( getTabPath(item) );
}
}
void TabTree::setCollapsedTabs(const QList<QString> &collapsedPaths)
{
for (const auto &path : collapsedPaths) {
QTreeWidgetItem *item = findTreeItem(path);
if ( isTabGroup(item) )
item->setExpanded(false);
}
}
void TabTree::updateTabIcons(const QHash<QString, QString> &tabIcons)
{
for ( QTreeWidgetItemIterator it(topLevelItem(0)); *it; ++it ) {
const QString name = getTabPath(*it);
const QString icon = tabIcons.value(name);
setTabIcon(*it, icon);
}
}
void TabTree::nextTab()
{
QTreeWidgetItem *item = currentItem();
if (item != nullptr)
item = itemBelow(item);
if (item == nullptr)
item = topLevelItem(0);
if (item != nullptr)
setCurrentItem(item);
}
void TabTree::previousTab()
{
QTreeWidgetItem *item = currentItem();
if (item != nullptr)
item = itemAbove(item);
if (item == nullptr) {
item = topLevelItem( topLevelItemCount() - 1 );
while ( isTabGroup(item) && item->isExpanded() )
item = item->child( item->childCount() - 1 );
}
if (item != nullptr)
setCurrentItem(item);
}
void TabTree::setCurrentTab(int index)
{
if (index < 0)
return;
QTreeWidgetItem *item = findTreeItem(index);
if (item != nullptr)
setCurrentItem(item);
}
void TabTree::adjustSize()
{
updateSize();
}
QTreeWidgetItem *TabTree::findTreeItem(int index) const
{
return m_tabs.value(index);
}
QTreeWidgetItem *TabTree::findTreeItem(const QString &path) const
{
QStringList pathComponents = path.split('/');
QTreeWidgetItem *parentItem = findLastTreeItem(*this, &pathComponents);
return pathComponents.isEmpty() ? parentItem : nullptr;
}
int TabTree::getTabIndex(const QTreeWidgetItem *item) const
{
return (item == nullptr) ? -1 : m_tabs.indexOf( const_cast<QTreeWidgetItem*>(item) );
}
QString TabTree::getTabPath(const QTreeWidgetItem *item) const
{
QString result;
const QTreeWidgetItem *parent = item;
while (parent != nullptr) {
const QString part = parent->data(0, DataText).toString();
result.prepend('/');
result.prepend(part);
parent = parent->parent();
}
result.chop(1);
return result;
}
bool TabTree::isTabGroup(const QTreeWidgetItem *item) const
{
return item != nullptr && item->childCount() > 0;
}
bool TabTree::isEmptyTabGroup(const QTreeWidgetItem *item) const
{
return item->childCount() == 0 && getTabIndex(item) < 0;
}
QSize TabTree::sizeHint() const
{
return minimumSizeHint();
}
void TabTree::contextMenuEvent(QContextMenuEvent *event)
{
requestTabMenu(event->pos(), event->globalPos());
event->accept();
}
void TabTree::dragEnterEvent(QDragEnterEvent *event)
{
if ( canDropToTab(*event) ) {
acceptDrag(event);
} else {
QTreeWidget::dragEnterEvent(event);
// Workaround for QTBUG-44939 (Qt 5.4): Don't ignore successive drag move events.
event->acceptProposedAction();
}
}
void TabTree::dragMoveEvent(QDragMoveEvent *event)
{
if ( dropItemsTarget(*event, *this) )
acceptDrag(event);
else if ( itemAt(event->pos()) )
QTreeWidget::dragMoveEvent(event);
else
event->ignore();
}
void TabTree::dropEvent(QDropEvent *event)
{
const auto current = currentItem();
if (current == nullptr)
return;
const auto targetItem = dropItemsTarget(*event, *this);
if (targetItem) {
acceptDrag(event);
emit dropItems( getTabPath(targetItem), event->mimeData() );
} else if ( itemAt(event->pos()) ) {
const QString oldPrefix = getTabPath(current);
blockSignals(true);
QTreeWidget::dropEvent(event);
setCurrentItem(current);
setItemWidgetSelected(current);
blockSignals(false);
// Rename moved item if non-unique.
QStringList uniqueTabNames;
const auto parent = current->parent();
for (int i = 0, count = parent ? parent->childCount() : topLevelItemCount(); i < count; ++i) {
QTreeWidgetItem *sibling = parent ? parent->child(i) : topLevelItem(i);
if (sibling != current)
uniqueTabNames.append( getTabPath(sibling) );
}
auto newPrefix = getTabPath(current);
if ( uniqueTabNames.contains(newPrefix) ) {
renameToUnique(&newPrefix, uniqueTabNames);
const QString text = newPrefix.mid( newPrefix.lastIndexOf(QChar('/')) + 1 );
current->setData(0, DataText, text);
labelItem(current);
}
QList<QTreeWidgetItem*> newTabs;
QList<int> indexes;
for ( QTreeWidgetItemIterator it(topLevelItem(0)); *it; ++it ) {
auto item = *it;
// Remove empty groups.
if ( isEmptyTabGroup(item) ) {
deleteItem(item);
} else {
const int oldIndex = getTabIndex(item);
if (oldIndex != -1) {
newTabs.append(item);
indexes.append(oldIndex);
}
}
}
m_tabs = std::move(newTabs);
emit tabsMoved(oldPrefix, newPrefix, indexes);
updateSize();
} else {
event->ignore();
}
}
bool TabTree::eventFilter(QObject *obj, QEvent *event)
{
if ( obj == verticalScrollBar() ) {
if ( event->type() == QEvent::Show || event->type() == QEvent::Hide )
updateSize();
}
return QTreeWidget::eventFilter(obj, event);
}
void TabTree::rowsInserted(const QModelIndex &parent, int start, int end)
{
QTreeWidget::rowsInserted(parent, start, end);
QList<QTreeWidgetItem *> items;
for (int row = start; row <= end; ++row) {
items.clear();
items.append( parent.isValid() ? itemFromIndex(model()->index(row, 0, parent))
: topLevelItem(row) );
while ( !items.isEmpty() ) {
QTreeWidgetItem *item = items.takeLast();
labelItem(item);
const int n = item->childCount();
items.reserve(items.size() + n);
for (int i = 0; i < n; ++i)
items.append(item->child(i));
}
}
}
void TabTree::showEvent(QShowEvent *event)
{
QTreeWidget::showEvent(event);
updateSize();
}
void TabTree::onCurrentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous)
{
emit currentTabChanged( getTabIndex(current) );
setItemWidgetSelected(current);
setItemWidgetSelected(previous);
}
void TabTree::updateSize()
{
m_timerUpdate.start();
}
void TabTree::doUpdateSize()
{
doItemsLayout();
const QMargins margins = contentsMargins();
int w = margins.left() + margins.right();
// Some styles put scrollbar outside of parent's contents so there is no need
// to resize parent widget.
if ( verticalScrollBar()->isVisible() && isInside(verticalScrollBar(), this) )
w += verticalScrollBar()->width();
resizeColumnToContents(0);
w += sizeHintForColumn(0);
setFixedWidth(w);
}
void TabTree::requestTabMenu(QPoint itemPosition, QPoint menuPosition)
{
QTreeWidgetItem *item = itemAt(itemPosition);
QString tabPath = getTabPath(item);
emit tabTreeMenuRequested(menuPosition, tabPath);
}
void TabTree::deleteItem(QTreeWidgetItem *item)
{
// Recursively remove empty parent item.
QTreeWidgetItem *parent = item->parent();
while (parent != nullptr && parent->childCount() == 1 && getTabIndex(parent) < 0) {
item = parent;
parent = item->parent();
}
delete item;
}
| 18,475
|
C++
|
.cpp
| 568
| 25.917254
| 102
| 0.630774
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,252
|
notificationnative.cpp
|
hluk_CopyQ/src/gui/notificationnative/notificationnative.cpp
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "notificationnative.h"
#include "common/log.h"
#include "common/timer.h"
#include "gui/iconfactory.h"
#include "gui/icons.h"
#include "gui/notification.h"
#include <KNotification>
#include <QApplication>
#include <QDialog>
#include <QDialogButtonBox>
#include <QDir>
#include <QGridLayout>
#include <QHBoxLayout>
#include <QIcon>
#include <QLabel>
#include <QMap>
#include <QMouseEvent>
#include <QPainter>
#include <QPointer>
#include <QPushButton>
#include <QTextEdit>
#include <knotifications_version.h>
#include <memory>
namespace {
constexpr auto componentName = "copyq";
constexpr auto maxTitleLength = 10000;
constexpr auto maxBodyLength = 100000;
constexpr auto maxLines = 100;
QString limitLength(const QString &text, int maxLength)
{
QString result = text.left(maxLength).split('\n').mid(0, maxLines).join('\n');
if (result.length() < text.length())
result.append("\n…");
return result;
}
QPixmap defaultIcon()
{
static QPixmap pixmap = appIcon().pixmap(512);
return pixmap;
}
class NotificationNative final : public Notification
{
Q_OBJECT
public:
explicit NotificationNative(const QColor &iconColor, QObject *parent = nullptr);
~NotificationNative();
void setTitle(const QString &title) override;
void setMessage(const QString &msg, Qt::TextFormat format = Qt::PlainText) override;
void setPixmap(const QPixmap &pixmap) override;
void setIcon(const QString &icon) override;
void setIcon(ushort icon) override;
void setInterval(int msec) override;
void setOpacity(qreal) override {}
void setButtons(const NotificationButtons &buttons) override;
void adjust() override {}
QWidget *widget() override { return nullptr; }
void show() override;
void close() override;
private:
void onButtonClicked(unsigned int id);
void onDestroyed();
void onClosed();
void onIgnored();
#if KNOTIFICATIONS_VERSION < QT_VERSION_CHECK(5,245,0)
void onActivated();
#endif
void update();
void notificationLog(const char *message);
KNotification *dropNotification();
QPointer<KNotification> m_notification;
NotificationButtons m_buttons;
QColor m_iconColor;
QTimer m_timer;
int m_intervalMsec = -1;
QString m_title;
QString m_message;
QString m_icon;
ushort m_iconId;
QPixmap m_pixmap;
bool m_closed = false;
};
} // namespace
NotificationNative::NotificationNative(const QColor &iconColor, QObject *parent)
: Notification(parent)
, m_iconColor(iconColor)
{
initSingleShotTimer( &m_timer, 0, this, &NotificationNative::close );
}
NotificationNative::~NotificationNative()
{
auto notification = dropNotification();
if (notification) {
notificationLog("Delete");
notification->close();
}
}
void NotificationNative::setTitle(const QString &title)
{
m_title = limitLength(title, maxTitleLength);
}
void NotificationNative::setMessage(const QString &msg, Qt::TextFormat format)
{
m_message = limitLength(msg, maxBodyLength);
if (format == Qt::PlainText) {
m_message = m_message.toHtmlEscaped();
}
}
void NotificationNative::setPixmap(const QPixmap &pixmap)
{
m_icon.clear();
m_iconId = 0;
m_pixmap = pixmap;
}
void NotificationNative::setIcon(const QString &icon)
{
m_iconId = toIconId(icon);
if (m_iconId == 0)
m_icon = icon;
else
m_icon.clear();
m_pixmap = QPixmap();
}
void NotificationNative::setIcon(ushort icon)
{
m_icon.clear();
m_iconId = icon;
m_pixmap = QPixmap();
}
void NotificationNative::setInterval(int msec)
{
m_intervalMsec = msec;
}
void NotificationNative::setButtons(const NotificationButtons &buttons)
{
m_buttons = buttons;
}
void NotificationNative::show()
{
if (m_closed)
return;
notificationLog("Update");
if (m_notification) {
update();
#if KNOTIFICATIONS_VERSION < QT_VERSION_CHECK(5,110,0)
if (m_notification)
m_notification->update();
#endif
notificationLog("Updated");
return;
}
m_notification = new KNotification(QStringLiteral("generic"));
notificationLog("Create");
m_notification->setComponentName(componentName);
#if KNOTIFICATIONS_VERSION < QT_VERSION_CHECK(5,245,0)
connect( m_notification.data(), static_cast<void (KNotification::*)(unsigned int)>(&KNotification::activated),
this, &NotificationNative::onButtonClicked );
# if KNOTIFICATIONS_VERSION < QT_VERSION_CHECK(5,67,0)
connect( m_notification.data(), static_cast<void (KNotification::*)()>(&KNotification::activated),
this, &NotificationNative::onActivated );
# else
connect( m_notification.data(), &KNotification::defaultActivated,
this, &NotificationNative::onActivated );
# endif
#endif
connect( m_notification.data(), &KNotification::closed,
this, &NotificationNative::onClosed );
connect( m_notification.data(), &KNotification::ignored,
this, &NotificationNative::onIgnored );
connect( m_notification.data(), &QObject::destroyed,
this, &NotificationNative::onDestroyed );
update();
if (m_notification)
m_notification->sendEvent();
notificationLog("Created");
}
void NotificationNative::close()
{
notificationLog("Close");
auto notification = dropNotification();
if (notification)
notification->close();
notificationLog("Closed");
}
void NotificationNative::onButtonClicked(unsigned int id)
{
notificationLog(QByteArray("onButtonClicked ") + QByteArray::number(id));
if ( id - 1 < static_cast<unsigned int>(m_buttons.size()) ) {
emit buttonClicked(m_buttons[id - 1]);
emit closeNotification(this);
}
}
void NotificationNative::onDestroyed()
{
notificationLog("Destroyed");
dropNotification();
}
void NotificationNative::onClosed()
{
notificationLog("onClosed");
dropNotification();
}
void NotificationNative::onIgnored()
{
notificationLog("onIgnored");
dropNotification();
}
#if KNOTIFICATIONS_VERSION < QT_VERSION_CHECK(5,245,0)
void NotificationNative::onActivated()
{
notificationLog("onActivated");
dropNotification();
}
#endif
void NotificationNative::update()
{
if (!m_notification)
return;
if (m_intervalMsec == 0) {
close();
return;
}
m_notification->setTitle(m_title);
#ifdef Q_OS_WIN
// On Windows, notification doesn't show up if the message is empty.
if (m_message.isEmpty())
m_notification->setText(QLatin1String("-"));
else
m_notification->setText(m_message);
#else
m_notification->setText(m_message);
#endif
if (m_pixmap.isNull() && m_iconId != 0) {
const auto height = 64;
const auto ratio = qApp->devicePixelRatio();
m_pixmap = createPixmap(m_iconId, m_iconColor, static_cast<int>(height * ratio));
m_pixmap.setDevicePixelRatio(ratio);
}
if ( !m_icon.isEmpty() ) {
m_notification->setIconName(m_icon);
} else if ( !m_pixmap.isNull() ) {
m_notification->setPixmap(m_pixmap);
} else {
m_notification->setPixmap(defaultIcon());
}
#if KNOTIFICATIONS_VERSION >= QT_VERSION_CHECK(5,245,0)
m_notification->clearActions();
for (int i = 0; i < m_buttons.size(); ++i) {
KNotificationAction* act = m_notification->addAction(m_buttons[i].name);
connect( act, &KNotificationAction::activated,
this, [=](){ onButtonClicked(i + 1); } );
}
#else
QStringList actions;
for (const auto &button : m_buttons)
actions.append(button.name);
m_notification->setActions(actions);
#endif
if (m_intervalMsec < 0) {
m_timer.stop();
m_notification->setFlags(KNotification::Persistent);
#if KNOTIFICATIONS_VERSION >= QT_VERSION_CHECK(5,58,0)
m_notification->setUrgency(KNotification::HighUrgency);
#endif
} else {
// Specific timeout is not supported by KNotifications.
m_timer.start(m_intervalMsec);
m_notification->setFlags(KNotification::CloseOnTimeout);
#if KNOTIFICATIONS_VERSION >= QT_VERSION_CHECK(5,58,0)
const KNotification::Urgency urgency = m_intervalMsec <= 10000
? KNotification::LowUrgency
: KNotification::NormalUrgency;
m_notification->setUrgency(urgency);
#endif
}
}
void NotificationNative::notificationLog(const char *message)
{
COPYQ_LOG_VERBOSE(
QString("Notification [%1:%2]: %3")
.arg(reinterpret_cast<quintptr>(this))
.arg(reinterpret_cast<quintptr>(m_notification.data()))
.arg(message) );
}
KNotification *NotificationNative::dropNotification()
{
m_closed = true;
auto notification = m_notification;
if (notification) {
m_notification = nullptr;
notification->disconnect(this);
}
emit closeNotification(this);
return notification;
}
Notification *createNotificationNative(const QColor &iconColor, QObject *parent)
{
return new NotificationNative(iconColor, parent);
}
#include "notificationnative.moc"
| 9,187
|
C++
|
.cpp
| 300
| 26.186667
| 114
| 0.697996
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
18,253
|
itemfakevim.h
|
hluk_CopyQ/plugins/itemfakevim/itemfakevim.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMFAKEVIM_H
#define ITEMFAKEVIM_H
#include "item/itemwidgetwrapper.h"
namespace Ui {
class ItemFakeVimSettings;
}
class QWidget;
class ItemFakeVimLoader final : public QObject, public ItemLoaderInterface
{
Q_OBJECT
Q_PLUGIN_METADATA(IID COPYQ_PLUGIN_ITEM_LOADER_ID)
Q_INTERFACES(ItemLoaderInterface)
public:
ItemFakeVimLoader();
~ItemFakeVimLoader();
QString id() const override { return "itemfakevim"; }
QString name() const override { return tr("FakeVim"); }
QString author() const override
{ return tr("FakeVim plugin is part of Qt Creator")
+ " (Copyright (C) 2016 The Qt Company Ltd.)"; }
QString description() const override { return tr("Emulate Vim editor while editing items."); }
QVariant icon() const override;
void setEnabled(bool enabled) override;
void applySettings(QSettings &settings) override;
void loadSettings(const QSettings &settings) override;
QWidget *createSettingsWidget(QWidget *parent) override;
QObject *tests(const TestInterfacePtr &test) const override;
bool eventFilter(QObject *watched, QEvent *event) override;
signals:
void deleteAllWrappers();
private:
void updateCurrentlyEnabledState();
void wrapEditWidget(QObject *obj);
bool m_reallyEnabled = false;
bool m_currentlyEnabled = false;
QString m_sourceFileName;
QScopedPointer<Ui::ItemFakeVimSettings> ui;
int m_oldCursorFlashTime = -1;
};
#endif // ITEMFAKEVIM_H
| 1,540
|
C++
|
.h
| 41
| 33.268293
| 98
| 0.746622
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,254
|
fakevimhandler.h
|
hluk_CopyQ/plugins/itemfakevim/fakevim/fakevimhandler.h
|
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
#pragma once
#define FAKEVIM_STANDALONE
#ifdef FAKEVIM_STANDALONE
# include "private/fakevim_export.h"
#endif
#include <QObject>
#include <QTextEdit>
#include <functional>
#include <vector>
namespace FakeVim {
namespace Internal {
enum RangeMode
{
// Reordering first three enum items here will break
// compatibility with clipboard format stored by Vim.
RangeCharMode, // v
RangeLineMode, // V
RangeBlockMode, // Ctrl-v
RangeLineModeExclusive,
RangeBlockAndTailMode // Ctrl-v for D and X
};
struct FAKEVIM_EXPORT Range
{
Range() = default;
Range(int b, int e, RangeMode m = RangeCharMode);
QString toString() const;
bool isValid() const;
int beginPos = -1;
int endPos = -1;
RangeMode rangemode = RangeCharMode;
};
struct FAKEVIM_EXPORT ExCommand
{
ExCommand() = default;
ExCommand(const QString &cmd, const QString &args = QString(),
const Range &range = Range());
bool matches(const QString &min, const QString &full) const;
QString cmd;
bool hasBang = false;
QString args;
Range range;
int count = 1;
};
// message levels sorted by severity
enum MessageLevel
{
MessageMode, // show current mode (format "-- %1 --")
MessageCommand, // show last Ex command or search
MessageInfo, // result of a command
MessageWarning, // warning
MessageError, // error
MessageShowCmd // partial command
};
template <typename Type>
class Signal
{
public:
using Callable = std::function<Type>;
void connect(const Callable &callable) { m_callables.push_back(callable); }
template <typename ...Args>
void operator()(Args ...args) const
{
for (const Callable &callable : m_callables)
callable(args...);
}
private:
std::vector<Callable> m_callables;
};
class FAKEVIM_EXPORT FakeVimHandler : public QObject
{
Q_OBJECT
public:
explicit FakeVimHandler(QWidget *widget, QObject *parent = nullptr);
~FakeVimHandler() override;
QWidget *widget();
// call before widget is deleted
void disconnectFromEditor();
static void updateGlobalMarksFilenames(const QString &oldFileName, const QString &newFileName);
public:
void setCurrentFileName(const QString &fileName);
QString currentFileName() const;
void showMessage(MessageLevel level, const QString &msg);
// This executes an "ex" style command taking context
// information from the current widget.
void handleCommand(const QString &cmd);
void handleReplay(const QString &keys);
void handleInput(const QString &keys);
void enterCommandMode();
void installEventFilter();
// Convenience
void setupWidget();
void restoreWidget(int tabSize);
// Test only
int physicalIndentation(const QString &line) const;
int logicalIndentation(const QString &line) const;
QString tabExpand(int n) const;
void miniBufferTextEdited(const QString &text, int cursorPos, int anchorPos);
// Set text cursor position. Keeps anchor if in visual mode.
void setTextCursorPosition(int position);
QTextCursor textCursor() const;
void setTextCursor(const QTextCursor &cursor);
bool jumpToLocalMark(QChar mark, bool backTickMode);
bool eventFilter(QObject *ob, QEvent *ev) override;
Signal<void(const QString &msg, int cursorPos, int anchorPos, int messageLevel)> commandBufferChanged;
Signal<void(const QString &msg)> statusDataChanged;
Signal<void(const QString &msg)> extraInformationChanged;
Signal<void(const QList<QTextEdit::ExtraSelection> &selection)> selectionChanged;
Signal<void(const QString &needle)> highlightMatches;
Signal<void(bool *moved, bool *forward, QTextCursor *cursor)> moveToMatchingParenthesis;
Signal<void(bool *result, QChar c)> checkForElectricCharacter;
Signal<void(int beginLine, int endLine, QChar typedChar)> indentRegion;
Signal<void(const QString &needle, bool forward)> simpleCompletionRequested;
Signal<void(const QString &key, int count)> windowCommandRequested;
Signal<void(bool reverse)> findRequested;
Signal<void(bool reverse)> findNextRequested;
Signal<void(bool *handled, const ExCommand &cmd)> handleExCommandRequested;
Signal<void()> requestDisableBlockSelection;
Signal<void(const QTextCursor &cursor)> requestSetBlockSelection;
Signal<void(QTextCursor *cursor)> requestBlockSelection;
Signal<void(bool *on)> requestHasBlockSelection;
Signal<void(int depth)> foldToggle;
Signal<void(bool fold)> foldAll;
Signal<void(int depth, bool dofold)> fold;
Signal<void(int count, bool current)> foldGoTo;
Signal<void(QChar mark, bool backTickMode, const QString &fileName)> requestJumpToLocalMark;
Signal<void(QChar mark, bool backTickMode, const QString &fileName)> requestJumpToGlobalMark;
Signal<void()> completionRequested;
Signal<void()> tabPreviousRequested;
Signal<void()> tabNextRequested;
public:
class Private;
private:
Private *d;
};
} // namespace Internal
} // namespace FakeVim
Q_DECLARE_METATYPE(FakeVim::Internal::ExCommand)
| 5,288
|
C++
|
.h
| 139
| 33.870504
| 106
| 0.737038
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,255
|
fakevimtr.h
|
hluk_CopyQ/plugins/itemfakevim/fakevim/fakevimtr.h
|
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
#pragma once
#include <QCoreApplication>
namespace FakeVim {
struct Tr
{
Q_DECLARE_TR_FUNCTIONS(FakeVim)
};
} // namespace FakeVim
| 284
|
C++
|
.h
| 10
| 26.5
| 101
| 0.762082
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,256
|
fakevimactions.h
|
hluk_CopyQ/plugins/itemfakevim/fakevim/fakevimactions.h
|
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0+ OR GPL-3.0 WITH Qt-GPL-exception-1.0
#pragma once
#define FAKEVIM_STANDALONE
#ifdef FAKEVIM_STANDALONE
# include "private/fakevim_export.h"
#else
# include <utils/savedaction.h>
#endif
#include <QCoreApplication>
#include <QHash>
#include <QObject>
#include <QString>
#include <QVariant>
namespace FakeVim {
namespace Internal {
#ifdef FAKEVIM_STANDALONE
class FAKEVIM_EXPORT FvBaseAspect
{
public:
FvBaseAspect();
virtual ~FvBaseAspect() {}
void setValue(const QVariant &value);
QVariant value() const;
void setDefaultValue(const QVariant &value);
QVariant defaultValue() const;
void setSettingsKey(const QString &group, const QString &key);
QString settingsKey() const;
void setCheckable(bool) {}
void setDisplayName(const QString &) {}
void setToolTip(const QString &) {}
private:
QVariant m_value;
QVariant m_defaultValue;
QString m_settingsGroup;
QString m_settingsKey;
};
class FvBoolAspect : public FvBaseAspect
{
public:
bool value() const { return FvBaseAspect::value().toBool(); }
};
class FvIntegerAspect : public FvBaseAspect
{
public:
qint64 value() const { return FvBaseAspect::value().toLongLong(); }
};
class FvStringAspect : public FvBaseAspect
{
public:
QString value() const { return FvBaseAspect::value().toString(); }
};
class FvAspectContainer : public FvBaseAspect
{
public:
};
#else
using FvAspectContainer = Utils::AspectContainer;
using FvBaseAspect = Utils::BaseAspect;
using FvBoolAspect = Utils::BoolAspect;
using FvIntegerAspect = Utils::IntegerAspect;
using FvStringAspect = Utils::StringAspect;
#endif
class FAKEVIM_EXPORT FakeVimSettings final : public FvAspectContainer
{
Q_DECLARE_TR_FUNCTIONS(FakeVim)
public:
FakeVimSettings();
~FakeVimSettings();
FvBaseAspect *item(const QString &name);
QString trySetValue(const QString &name, const QString &value);
FvBoolAspect useFakeVim;
FvBoolAspect readVimRc;
FvStringAspect vimRcPath;
FvBoolAspect startOfLine;
FvIntegerAspect tabStop;
FvBoolAspect hlSearch;
FvBoolAspect smartTab;
FvIntegerAspect shiftWidth;
FvBoolAspect expandTab;
FvBoolAspect autoIndent;
FvBoolAspect smartIndent;
FvBoolAspect incSearch;
FvBoolAspect useCoreSearch;
FvBoolAspect smartCase;
FvBoolAspect ignoreCase;
FvBoolAspect wrapScan;
// command ~ behaves as g~
FvBoolAspect tildeOp;
// indent allow backspacing over autoindent
// eol allow backspacing over line breaks (join lines)
// start allow backspacing over the start of insert; CTRL-W and CTRL-U
// stop once at the start of insert.
FvStringAspect backspace;
// @,48-57,_,192-255
FvStringAspect isKeyword;
// other actions
FvBoolAspect showMarks;
FvBoolAspect passControlKey;
FvBoolAspect passKeys;
FvStringAspect clipboard;
FvBoolAspect showCmd;
FvIntegerAspect scrollOff;
FvBoolAspect relativeNumber;
FvStringAspect formatOptions;
// Plugin emulation
FvBoolAspect emulateVimCommentary;
FvBoolAspect emulateReplaceWithRegister;
FvBoolAspect emulateExchange;
FvBoolAspect emulateArgTextObj;
FvBoolAspect emulateSurround;
FvBoolAspect blinkingCursor;
private:
void setup(FvBaseAspect *aspect, const QVariant &value,
const QString &settingsKey,
const QString &shortName,
const QString &label);
QHash<QString, FvBaseAspect *> m_nameToAspect;
QHash<FvBaseAspect *, QString> m_aspectToName;
};
FAKEVIM_EXPORT FakeVimSettings *fakeVimSettings();
} // namespace Internal
} // namespace FakeVim
| 3,790
|
C++
|
.h
| 123
| 26.845528
| 101
| 0.750275
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,257
|
itemfakevimtests.h
|
hluk_CopyQ/plugins/itemfakevim/tests/itemfakevimtests.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMFAKEVIMTESTS_H
#define ITEMFAKEVIMTESTS_H
#include "tests/testinterface.h"
#include <QObject>
class ItemFakeVimTests final : public QObject
{
Q_OBJECT
public:
explicit ItemFakeVimTests(const TestInterfacePtr &test, QObject *parent = nullptr);
static QString fileNameToSource();
private slots:
void initTestCase();
void cleanupTestCase();
void init();
void cleanup();
void createItem();
void blockSelection();
void search();
void incDecNumbers();
private:
TestInterfacePtr m_test;
};
#endif // ITEMFAKEVIMTESTS_H
| 629
|
C++
|
.h
| 24
| 22.708333
| 87
| 0.748735
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,258
|
filewatcher.h
|
hluk_CopyQ/plugins/itemsync/filewatcher.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef FILEWATCHER_H
#define FILEWATCHER_H
#include "common/mimetypes.h"
#include <QLockFile>
#include <QObject>
#include <QPersistentModelIndex>
#include <QSet>
#include <QStringList>
#include <QTimer>
#include <QVector>
class QAbstractItemModel;
class QDir;
struct Ext;
struct BaseNameExtensions;
#define COPYQ_MIME_PREFIX_ITEMSYNC COPYQ_MIME_PREFIX "itemsync-"
#define COPYQ_MIME_PREFIX_ITEMSYNC_PRIVATE COPYQ_MIME_PRIVATE_PREFIX "itemsync-"
extern const QLatin1String mimeExtensionMap;
extern const QLatin1String mimeBaseName;
extern const QLatin1String mimeNoSave;
extern const QLatin1String mimeSyncPath;
extern const QLatin1String mimeNoFormat;
extern const QLatin1String mimeUnknownFormats;
extern const QLatin1String mimePrivateSyncPrefix;
extern const QLatin1String mimeOldBaseName;
extern const QLatin1String mimeHashPrefix;
enum class UpdateType {
Inserted,
Changed,
};
struct FileFormat {
bool isValid() const { return !extensions.isEmpty(); }
QStringList extensions;
QString itemMime;
QString icon;
};
using BaseNameExtensionsList = QList<BaseNameExtensions>;
using Hash = QByteArray;
class SyncDataFile;
QDataStream &operator<<(QDataStream &out, SyncDataFile value);
QDataStream &operator>>(QDataStream &in, SyncDataFile &value);
void registerSyncDataFileConverter();
class FileWatcher final : public QObject {
public:
static QString getBaseName(const QModelIndex &index);
static QString getBaseName(const QVariantMap &data);
/**
* Return true only if base name is empty or it matches the internal format.
*/
static bool isOwnBaseName(const QString &baseName);
static void removeFilesForRemovedIndex(const QString &tabPath, const QModelIndex &index);
static Hash calculateHash(const QByteArray &bytes);
FileWatcher(
const QString &path,
const QStringList &paths,
QAbstractItemModel *model,
int maxItems,
const QList<FileFormat> &formatSettings,
int itemDataThreshold,
QObject *parent = nullptr
);
const QString &path() const { return m_path; }
bool isValid() const { return m_valid; }
bool lock();
void unlock();
QVariantMap itemDataFromFiles(const QDir &dir, const BaseNameExtensions &baseNameWithExts);
void prependItemsFromFiles(const QDir &dir, const BaseNameExtensionsList &fileList);
void insertItemsFromFiles(const QDir &dir, const BaseNameExtensionsList &fileList);
/**
* Check for new files.
*/
void updateItems();
void updateItemsIfNeeded();
void setUpdatesEnabled(bool enabled);
private:
void onRowsInserted(const QModelIndex &, int first, int last);
void onDataChanged(const QModelIndex &a, const QModelIndex &b);
void onRowsRemoved(const QModelIndex &, int first, int last);
void onRowsMoved(const QModelIndex &, int start, int end, const QModelIndex &, int destinationRow);
QString oldBaseName(const QModelIndex &index) const;
void createItems(const QVector<QVariantMap> &dataMaps, int targetRow);
void updateIndexData(const QModelIndex &index, QVariantMap *itemData);
QList<QPersistentModelIndex> indexList(int first, int last);
void saveItems(int first, int last, UpdateType updateType);
bool renameMoveCopy(
const QDir &dir, const QList<QPersistentModelIndex> &indexList, UpdateType updateType);
void updateDataAndWatchFile(
const QDir &dir, const BaseNameExtensions &baseNameWithExts,
QVariantMap *dataMap, QVariantMap *mimeToExtension);
bool copyFilesFromUriList(const QByteArray &uriData, int targetRow, const QSet<QString> &baseNames);
void updateMovedRows();
QAbstractItemModel *m_model;
QTimer m_updateTimer;
QTimer m_moveTimer;
int m_moveEnd = -1;
int m_interval = 0;
const QList<FileFormat> &m_formatSettings;
QString m_path;
bool m_valid;
int m_maxItems;
bool m_updatesEnabled = false;
qint64 m_lastUpdateTimeMs = 0;
QList<QPersistentModelIndex> m_batchIndexData;
BaseNameExtensionsList m_fileList;
int m_lastBatchIndex = -1;
int m_itemDataThreshold = -1;
QLockFile m_lock;
};
#endif // FILEWATCHER_H
| 4,256
|
C++
|
.h
| 109
| 34.669725
| 104
| 0.762856
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,259
|
itemsync.h
|
hluk_CopyQ/plugins/itemsync/itemsync.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMSYNC_H
#define ITEMSYNC_H
#include "gui/icons.h"
#include "item/itemwidgetwrapper.h"
#include <QVariantMap>
#include <QWidget>
#include <memory>
namespace Ui {
class ItemSyncSettings;
}
class QTextEdit;
class FileWatcher;
struct FileFormat;
using ItemSyncTabPaths = QMap<QString, QString>;
class ItemSync final : public QWidget, public ItemWidgetWrapper
{
Q_OBJECT
public:
ItemSync(const QString &label, const QString &icon, ItemWidget *childItem = nullptr);
protected:
void updateSize(QSize maximumSize, int idealWidth) override;
bool eventFilter(QObject *, QEvent *event) override;
private:
QTextEdit *m_label;
QWidget *m_icon;
};
class ItemSyncSaver final : public QObject, public ItemSaverInterface
{
Q_OBJECT
public:
ItemSyncSaver(const QString &tabPath, FileWatcher *watcher);
bool saveItems(const QString &tabName, const QAbstractItemModel &model, QIODevice *file) override;
bool canRemoveItems(const QList<QModelIndex> &indexList, QString *error) override;
void itemsRemovedByUser(const QList<QPersistentModelIndex> &indexList) override;
QVariantMap copyItem(const QAbstractItemModel &model, const QVariantMap &itemData) override;
void setFocus(bool focus) override;
void setFileWatcher(FileWatcher *watcher);
private:
QString m_tabPath;
FileWatcher *m_watcher;
};
class ItemSyncScriptable final : public ItemScriptable
{
Q_OBJECT
Q_PROPERTY(QVariantMap tabPaths READ getTabPaths CONSTANT)
Q_PROPERTY(QString mimeBaseName READ getMimeBaseName CONSTANT)
public:
explicit ItemSyncScriptable(const QVariantMap &tabPaths)
: m_tabPaths(tabPaths)
{
}
QVariantMap getTabPaths() const { return m_tabPaths; }
QString getMimeBaseName() const;
public slots:
QString selectedTabPath();
private:
QVariantMap m_tabPaths;
};
/**
* Synchronizes selected tab with destination path.
*
* For all tabs that have user-set synchronization directory, loads up to maximum number of items
* from files (tries to use the same files every time tab is loaded).
*
* Items contains base name of assigned files (MIME is 'application/x-copyq-itemsync-basename').
* E.g. files 'example.txt', 'example.html' and 'example_notes.txt' belong to single item with
* base name 'example' containing text, HTML and notes.
*
* If item data are changed it is saved to appropriate files and vice versa.
*
* If files is in synchronization directory but is of unknown type, hidden, unreadable or its
* file name starts with dot (this is hidden file on UNIX so lets make it same everywhere) it
* won't be added to the list.
*
* Unknown file types can be defined in settings so such files are loaded.
*
* Item data with unknown MIME type is serialized in '<BASE NAME>_copyq.dat' file.
*/
class ItemSyncLoader final : public QObject, public ItemLoaderInterface
{
Q_OBJECT
Q_PLUGIN_METADATA(IID COPYQ_PLUGIN_ITEM_LOADER_ID)
Q_INTERFACES(ItemLoaderInterface)
public:
ItemSyncLoader();
~ItemSyncLoader();
QString id() const override { return "itemsync"; }
QString name() const override { return tr("Synchronize"); }
QString author() const override { return QString(); }
QString description() const override { return tr("Synchronize items and notes with a directory on disk."); }
QVariant icon() const override { return QVariant(IconUpload); }
void applySettings(QSettings &settings) override;
void loadSettings(const QSettings &settings) override;
QWidget *createSettingsWidget(QWidget *parent) override;
bool canLoadItems(QIODevice *file) const override;
bool canSaveItems(const QString &tabName) const override;
ItemSaverPtr loadItems(const QString &tabName, QAbstractItemModel *model, QIODevice *file, int maxItems) override;
ItemSaverPtr initializeTab(const QString &tabName, QAbstractItemModel *model, int maxItems) override;
ItemWidget *transform(ItemWidget *itemWidget, const QVariantMap &data) override;
bool matches(const QModelIndex &index, const ItemFilter &filter) const override;
QObject *tests(const TestInterfacePtr &test) const override;
const QObject *signaler() const override { return this; }
ItemScriptable *scriptableObject() override;
signals:
void error(const QString &);
private slots:
void onBrowseButtonClicked();
private:
ItemSaverPtr loadItems(const QString &tabName, QAbstractItemModel *model, const QStringList &files, int maxItems);
std::unique_ptr<Ui::ItemSyncSettings> ui;
ItemSyncTabPaths m_tabPaths;
QStringList m_tabPathsSaved;
QList<FileFormat> m_formatSettings;
int m_itemDataThreshold = -1;
};
#endif // ITEMSYNC_H
| 4,765
|
C++
|
.h
| 117
| 37.17094
| 118
| 0.768913
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,260
|
itemsynctests.h
|
hluk_CopyQ/plugins/itemsync/tests/itemsynctests.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMSYNCTESTS_H
#define ITEMSYNCTESTS_H
#include "tests/testinterface.h"
#include <QObject>
class ItemSyncTests final : public QObject
{
Q_OBJECT
public:
explicit ItemSyncTests(const TestInterfacePtr &test, QObject *parent = nullptr);
static QString testTab(int i);
static QString testDir(int i);
private slots:
void initTestCase();
void cleanupTestCase();
void init();
void cleanup();
void createRemoveTestDir();
void itemsToFiles();
void filesToItems();
void removeOwnItems();
void removeNotOwnedItems();
void removeNotOwnedItemsCancel();
void removeFiles();
void modifyItems();
void modifyFiles();
void itemToClipboard();
void notes();
void customFormats();
void getAbsoluteFilePath();
void addItemsWhenFull();
void addItemsWhenFullOmitDeletingNotOwned();
void moveOwnItemsSortsBaseNames();
void avoidDuplicateItemsAddedFromClipboard();
void saveLargeItem();
private:
TestInterfacePtr m_test;
};
#endif // ITEMSYNCTESTS_H
| 1,108
|
C++
|
.h
| 39
| 24.076923
| 84
| 0.74021
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,261
|
itemtags.h
|
hluk_CopyQ/plugins/itemtags/itemtags.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMTAGS_H
#define ITEMTAGS_H
#include "gui/icons.h"
#include "item/itemwidgetwrapper.h"
#include "item/itemsaverwrapper.h"
#include <QVariant>
#include <QVector>
#include <QWidget>
namespace Ui {
class ItemTagsSettings;
}
class QTableWidgetItem;
class ItemTags final : public QWidget, public ItemWidgetWrapper
{
Q_OBJECT
public:
struct Tag {
QString name;
QString color;
QString icon;
QString styleSheet;
QString match;
bool lock;
};
using Tags = QVector<ItemTags::Tag>;
ItemTags(ItemWidget *childItem, const Tags &tags);
signals:
void runCommand(const Command &command);
protected:
void updateSize(QSize maximumSize, int idealWidth) override;
private:
QWidget *m_tagWidget;
};
class ItemTagsLoader;
class ItemTagsScriptable final : public ItemScriptable
{
Q_OBJECT
Q_PROPERTY(QStringList userTags READ getUserTags CONSTANT)
Q_PROPERTY(QString mimeTags READ getMimeTags CONSTANT)
public:
explicit ItemTagsScriptable(const QStringList &userTags)
: m_userTags(userTags)
{
}
QStringList getUserTags() const;
QString getMimeTags() const;
public slots:
QStringList tags();
void tag();
void untag();
void clearTags();
bool hasTag();
private:
QString askTagName(const QString &dialogTitle, const QStringList &tags);
QString askRemoveTagName(const QStringList &tags);
QList<int> rows(const QVariantList &arguments, int skip);
QStringList tags(int row);
void setTags(int row, const QStringList &tags);
bool addTag(const QString &tagName, QStringList *tags);
bool removeTag(const QString &tagName, QStringList *tags);
QStringList m_userTags;
};
class ItemTagsSaver final : public ItemSaverWrapper
{
public:
ItemTagsSaver(const ItemTags::Tags &tags, const ItemSaverPtr &saver);
bool canRemoveItems(const QList<QModelIndex> &indexList, QString *error) override;
bool canDropItem(const QModelIndex &index) override;
bool canMoveItems(const QList<QModelIndex> &indexList) override;
private:
ItemTags::Tags m_tags;
};
class ItemTagsLoader final : public QObject, public ItemLoaderInterface
{
Q_OBJECT
Q_PLUGIN_METADATA(IID COPYQ_PLUGIN_ITEM_LOADER_ID)
Q_INTERFACES(ItemLoaderInterface)
public:
ItemTagsLoader();
~ItemTagsLoader();
QString id() const override { return "itemtags"; }
QString name() const override { return tr("Tags"); }
QString author() const override { return QString(); }
QString description() const override { return tr("Display tags for items."); }
QVariant icon() const override { return QVariant(IconTag); }
QStringList formatsToSave() const override;
void applySettings(QSettings &settings) override;
void loadSettings(const QSettings &settings) override;
QWidget *createSettingsWidget(QWidget *parent) override;
ItemWidget *transform(ItemWidget *itemWidget, const QVariantMap &data) override;
ItemSaverPtr transformSaver(const ItemSaverPtr &saver, QAbstractItemModel *model) override;
bool matches(const QModelIndex &index, const ItemFilter &filter) const override;
QObject *tests(const TestInterfacePtr &test) const override;
const QObject *signaler() const override { return this; }
ItemScriptable *scriptableObject() override;
QVector<Command> commands() const override;
private:
void onColorButtonClicked();
void onTableWidgetItemChanged(QTableWidgetItem *item);
void onAllTableWidgetItemsChanged();
QStringList userTags() const;
using Tag = ItemTags::Tag;
using Tags = ItemTags::Tags;
static QString serializeTag(const Tag &tag);
static Tag deserializeTag(const QString &tagText);
Tags toTags(const QStringList &tagList);
void addTagToSettingsTable(const Tag &tag = Tag());
Tag tagFromTable(int row);
Tags m_tags;
std::unique_ptr<Ui::ItemTagsSettings> ui;
bool m_blockDataChange;
};
#endif // ITEMTAGS_H
| 4,052
|
C++
|
.h
| 114
| 31.201754
| 95
| 0.748779
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,262
|
itemtagstests.h
|
hluk_CopyQ/plugins/itemtags/tests/itemtagstests.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMTAGSTESTS_H
#define ITEMTAGSTESTS_H
#include "tests/testinterface.h"
#include <QObject>
class ItemTagsTests final : public QObject
{
Q_OBJECT
public:
explicit ItemTagsTests(const TestInterfacePtr &test, QObject *parent = nullptr);
static QStringList testTags();
private slots:
void initTestCase();
void cleanupTestCase();
void init();
void cleanup();
void userTags();
void tag();
void untag();
void clearTags();
void searchTags();
void tagSelected();
void untagSelected();
private:
TestInterfacePtr m_test;
};
#endif // ITEMTAGSTESTS_H
| 663
|
C++
|
.h
| 27
| 20.962963
| 84
| 0.723642
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,263
|
itemencrypted.h
|
hluk_CopyQ/plugins/itemencrypted/itemencrypted.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMENCRYPTED_H
#define ITEMENCRYPTED_H
#include "item/itemwidget.h"
#include "gui/icons.h"
#include <QProcess>
#include <QVariant>
#include <QWidget>
#include <memory>
namespace Ui {
class ItemEncryptedSettings;
}
class QIODevice;
class ItemEncrypted final : public QWidget, public ItemWidget
{
Q_OBJECT
public:
explicit ItemEncrypted(QWidget *parent);
};
class ItemEncryptedSaver final : public QObject, public ItemSaverInterface
{
Q_OBJECT
public:
bool saveItems(const QString &tabName, const QAbstractItemModel &model, QIODevice *file) override;
signals:
void error(const QString &);
private:
void emitEncryptFailed();
};
class ItemEncryptedScriptable final : public ItemScriptable
{
Q_OBJECT
public slots:
bool isEncrypted();
QByteArray encrypt();
QByteArray decrypt();
void encryptItem();
void decryptItem();
void encryptItems();
void decryptItems();
void copyEncryptedItems();
void pasteEncryptedItems();
QString generateTestKeys();
bool isGpgInstalled();
private:
QByteArray encrypt(const QByteArray &bytes);
QByteArray decrypt(const QByteArray &bytes);
};
class ItemEncryptedLoader final : public QObject, public ItemLoaderInterface
{
Q_OBJECT
Q_PLUGIN_METADATA(IID COPYQ_PLUGIN_ITEM_LOADER_ID)
Q_INTERFACES(ItemLoaderInterface)
public:
ItemEncryptedLoader();
~ItemEncryptedLoader();
ItemWidget *create(const QVariantMap &data, QWidget *parent, bool) const override;
QString id() const override { return "itemencrypted"; }
QString name() const override { return tr("Encryption"); }
QString author() const override { return QString(); }
QString description() const override { return tr("Encrypt items and tabs."); }
QVariant icon() const override { return QVariant(IconLock); }
QStringList formatsToSave() const override;
void applySettings(QSettings &settings) override;
void loadSettings(const QSettings &settings) override;
QWidget *createSettingsWidget(QWidget *parent) override;
bool canLoadItems(QIODevice *file) const override;
bool canSaveItems(const QString &tabName) const override;
ItemSaverPtr loadItems(const QString &tabName, QAbstractItemModel *model, QIODevice *file, int maxItems) override;
ItemSaverPtr initializeTab(const QString &, QAbstractItemModel *model, int maxItems) override;
QObject *tests(const TestInterfacePtr &test) const override;
const QObject *signaler() const override { return this; }
ItemScriptable *scriptableObject() override;
QVector<Command> commands() const override;
bool data(QVariantMap *data, const QModelIndex &) const override;
bool setData(const QVariantMap &data, const QModelIndex &index, QAbstractItemModel *model) const override;
signals:
void error(const QString &);
private:
void setPassword();
void terminateGpgProcess();
void onGpgProcessFinished(int exitCode, QProcess::ExitStatus exitStatus);
enum GpgProcessStatus {
GpgCheckIfInstalled,
GpgNotInstalled,
GpgNotRunning,
GpgGeneratingKeys,
GpgChangingPassword
};
void updateUi();
void emitDecryptFailed();
ItemSaverPtr createSaver();
GpgProcessStatus status() const;
std::unique_ptr<Ui::ItemEncryptedSettings> ui;
QStringList m_encryptTabs;
mutable GpgProcessStatus m_gpgProcessStatus;
QProcess *m_gpgProcess;
};
#endif // ITEMENCRYPTED_H
| 3,532
|
C++
|
.h
| 99
| 31.414141
| 118
| 0.758122
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,264
|
itemencryptedtests.h
|
hluk_CopyQ/plugins/itemencrypted/tests/itemencryptedtests.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMENCRYPTEDTESTS_H
#define ITEMENCRYPTEDTESTS_H
#include "tests/testinterface.h"
#include <QObject>
class ItemEncryptedTests final : public QObject
{
Q_OBJECT
public:
explicit ItemEncryptedTests(const TestInterfacePtr &test, QObject *parent = nullptr);
private slots:
void initTestCase();
void cleanupTestCase();
void init();
void cleanup();
void encryptDecryptData();
void encryptDecryptItems();
private:
bool isGpgInstalled() const;
TestInterfacePtr m_test;
};
#endif // ITEMENCRYPTEDTESTS_H
| 599
|
C++
|
.h
| 22
| 23.954545
| 89
| 0.765432
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,265
|
itempinned.h
|
hluk_CopyQ/plugins/itempinned/itempinned.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMPINNED_H
#define ITEMPINNED_H
#include "gui/icons.h"
#include "item/itemwidgetwrapper.h"
#include "item/itemsaverwrapper.h"
#include <QPointer>
#include <QVariant>
#include <QWidget>
class ItemPinned final : public QWidget, public ItemWidgetWrapper
{
Q_OBJECT
public:
explicit ItemPinned(ItemWidget *childItem);
protected:
void paintEvent(QPaintEvent *paintEvent) override;
void updateSize(QSize maximumSize, int idealWidth) override;
};
class ItemPinnedScriptable final : public ItemScriptable
{
Q_OBJECT
Q_PROPERTY(QString mimePinned READ getMimePinned CONSTANT)
public slots:
bool isPinned();
void pin();
void unpin();
void pinData();
void unpinData();
QString getMimePinned() const;
};
class ItemPinnedSaver final : public QObject, public ItemSaverWrapper
{
Q_OBJECT
public:
ItemPinnedSaver(QAbstractItemModel *model, const ItemSaverPtr &saver);
bool canRemoveItems(const QList<QModelIndex> &indexList, QString *error) override;
bool canDropItem(const QModelIndex &index) override;
bool canMoveItems(const QList<QModelIndex> &indexList) override;
private:
void onRowsInserted(const QModelIndex &parent, int start, int end);
void onRowsRemoved(const QModelIndex &parent, int start, int end);
void onRowsMoved(const QModelIndex &, int start, int end, const QModelIndex &, int destinationRow);
void onDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);
void moveRow(int from, int to);
void updateLastPinned(int from, int to);
QPointer<QAbstractItemModel> m_model;
// Last pinned row in list (improves performance of updates).
int m_lastPinned = -1;
};
class ItemPinnedLoader final : public QObject, public ItemLoaderInterface
{
Q_OBJECT
Q_PLUGIN_METADATA(IID COPYQ_PLUGIN_ITEM_LOADER_ID)
Q_INTERFACES(ItemLoaderInterface)
public:
ItemPinnedLoader();
~ItemPinnedLoader();
QString id() const override { return "itempinned"; }
QString name() const override { return tr("Pinned Items"); }
QString author() const override { return QString(); }
QString description() const override {
return tr(
"<p>Pin items to lock them in current row and avoid deletion (unless unpinned).</p>"
"<p>Provides shortcuts and scripting functionality.</p>"
);
}
QVariant icon() const override { return QVariant(IconThumbtack); }
QStringList formatsToSave() const override;
ItemWidget *transform(ItemWidget *itemWidget, const QVariantMap &data) override;
ItemSaverPtr transformSaver(const ItemSaverPtr &saver, QAbstractItemModel *model) override;
QObject *tests(const TestInterfacePtr &test) const override;
const QObject *signaler() const override { return this; }
ItemScriptable *scriptableObject() override;
QVector<Command> commands() const override;
private:
ItemLoaderPtr m_transformedLoader;
};
#endif // ITEMPINNED_H
| 3,030
|
C++
|
.h
| 78
| 34.602564
| 103
| 0.752312
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,266
|
itempinnedtests.h
|
hluk_CopyQ/plugins/itempinned/tests/itempinnedtests.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMPINNEDTESTS_H
#define ITEMPINNEDTESTS_H
#include "tests/testinterface.h"
#include <QObject>
class ItemPinnedTests final : public QObject
{
Q_OBJECT
public:
explicit ItemPinnedTests(const TestInterfacePtr &test, QObject *parent = nullptr);
private slots:
void initTestCase();
void cleanupTestCase();
void init();
void cleanup();
void isPinned();
void pin();
void pinMultiple();
void unpin();
void unpinMultiple();
void removePinnedThrows();
void pinToRow();
void fullTab();
private:
TestInterfacePtr m_test;
};
#endif // ITEMPINNEDTESTS_H
| 666
|
C++
|
.h
| 27
| 21.037037
| 86
| 0.726115
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,267
|
itemtext.h
|
hluk_CopyQ/plugins/itemtext/itemtext.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMTEXT_H
#define ITEMTEXT_H
#include "gui/icons.h"
#include "item/itemwidget.h"
#include <QTextDocument>
#include <QTextDocumentFragment>
#include <QTextEdit>
#include <memory>
namespace Ui {
class ItemTextSettings;
}
class ItemText final : public QTextEdit, public ItemWidget
{
Q_OBJECT
public:
ItemText(
const QString &text,
const QString &richText,
const QString &defaultStyleSheet,
int maxLines,
int lineLength,
int maximumHeight,
QWidget *parent);
protected:
void updateSize(QSize maximumSize, int idealWidth) override;
bool eventFilter(QObject *, QEvent *event) override;
QMimeData *createMimeDataFromSelection() const override;
private:
void onSelectionChanged();
QTextDocument m_textDocument;
QTextDocumentFragment m_elidedFragment;
int m_ellipsisPosition = -1;
int m_maximumHeight;
bool m_isRichText = false;
};
class ItemTextLoader final : public QObject, public ItemLoaderInterface
{
Q_OBJECT
Q_PLUGIN_METADATA(IID COPYQ_PLUGIN_ITEM_LOADER_ID)
Q_INTERFACES(ItemLoaderInterface)
public:
ItemTextLoader();
~ItemTextLoader();
ItemWidget *create(const QVariantMap &data, QWidget *parent, bool preview) const override;
QString id() const override { return "itemtext"; }
QString name() const override { return tr("Text"); }
QString author() const override { return QString(); }
QString description() const override { return tr("Display plain text and simple HTML items."); }
QVariant icon() const override { return QVariant(IconFont); }
QStringList formatsToSave() const override;
void applySettings(QSettings &settings) override;
void loadSettings(const QSettings &settings) override;
QWidget *createSettingsWidget(QWidget *parent) override;
private:
bool m_useRichText = true;
int m_maxLines = 0;
int m_maxHeight = 0;
QString m_defaultStyleSheet;
std::unique_ptr<Ui::ItemTextSettings> ui;
};
#endif // ITEMTEXT_H
| 2,077
|
C++
|
.h
| 62
| 29.241935
| 100
| 0.739087
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,268
|
itemimage.h
|
hluk_CopyQ/plugins/itemimage/itemimage.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMIMAGE_H
#define ITEMIMAGE_H
#include "gui/icons.h"
#include "item/itemwidget.h"
#include <QLabel>
#include <QPixmap>
#include <QVariant>
#include <memory>
class QMovie;
namespace Ui {
class ItemImageSettings;
}
class ItemImage final : public QLabel, public ItemWidget
{
Q_OBJECT
public:
ItemImage(
const QPixmap &pix,
const QByteArray &animationData, const QByteArray &animationFormat,
QWidget *parent);
void updateSize(QSize maximumSize, int idealWidth) override;
void setCurrent(bool current) override;
protected:
void showEvent(QShowEvent *event) override;
void hideEvent(QHideEvent *event) override;
void paintEvent(QPaintEvent *event) override;
private:
void startAnimation();
void stopAnimation();
QPixmap m_pixmap;
QByteArray m_animationData;
QByteArray m_animationFormat;
QMovie *m_animation;
};
class ItemImageLoader final : public QObject, public ItemLoaderInterface
{
Q_OBJECT
Q_PLUGIN_METADATA(IID COPYQ_PLUGIN_ITEM_LOADER_ID)
Q_INTERFACES(ItemLoaderInterface)
public:
ItemImageLoader();
~ItemImageLoader();
ItemWidget *create(const QVariantMap &data, QWidget *parent, bool preview) const override;
int priority() const override { return 15; }
QString id() const override { return "itemimage"; }
QString name() const override { return tr("Images"); }
QString author() const override { return QString(); }
QString description() const override { return tr("Display images."); }
QVariant icon() const override { return QVariant(IconCamera); }
QStringList formatsToSave() const override;
QObject *tests(const TestInterfacePtr &test) const override;
void applySettings(QSettings &settings) override;
void loadSettings(const QSettings &settings) override;
QWidget *createSettingsWidget(QWidget *parent) override;
QObject *createExternalEditor(const QModelIndex &index, const QVariantMap &data, QWidget *parent) const override;
private:
int m_maxImageWidth = 320;
int m_maxImageHeight = 240;
QString m_imageEditor;
QString m_svgEditor;
std::unique_ptr<Ui::ItemImageSettings> ui;
};
#endif // ITEMIMAGE_H
| 2,272
|
C++
|
.h
| 64
| 31.28125
| 117
| 0.746104
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,269
|
itemimagetests.h
|
hluk_CopyQ/plugins/itemimage/tests/itemimagetests.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include "tests/testinterface.h"
#include <QObject>
class ItemImageTests final : public QObject
{
Q_OBJECT
public:
explicit ItemImageTests(const TestInterfacePtr &test, QObject *parent = nullptr);
private slots:
void initTestCase();
void cleanupTestCase();
void init();
void cleanup();
void supportedFormats();
void savePng();
void saveBmp();
void saveGif();
void saveWebp();
private:
TestInterfacePtr m_test;
};
| 525
|
C++
|
.h
| 22
| 20.409091
| 85
| 0.722334
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,270
|
itemnotes.h
|
hluk_CopyQ/plugins/itemnotes/itemnotes.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMNOTES_H
#define ITEMNOTES_H
#include "gui/icons.h"
#include "item/itemwidgetwrapper.h"
#include <QVariant>
#include <QWidget>
namespace Ui {
class ItemNotesSettings;
}
class QTextEdit;
class QTimer;
enum NotesPosition {
NotesAbove,
NotesBelow,
NotesBeside,
};
class ItemNotes final : public QWidget, public ItemWidgetWrapper
{
Q_OBJECT
public:
ItemNotes(ItemWidget *childItem, const QString &text, const QByteArray &icon,
NotesPosition notesPosition, bool showToolTip);
void setCurrent(bool current) override;
protected:
void updateSize(QSize maximumSize, int idealWidth) override;
void paintEvent(QPaintEvent *event) override;
bool eventFilter(QObject *, QEvent *event) override;
private:
void showToolTip();
QTextEdit *m_notes;
QWidget *m_icon;
QTimer *m_timerShowToolTip;
QString m_toolTipText;
bool m_isCurrent = false;
};
class ItemNotesLoader final : public QObject, public ItemLoaderInterface
{
Q_OBJECT
Q_PLUGIN_METADATA(IID COPYQ_PLUGIN_ITEM_LOADER_ID)
Q_INTERFACES(ItemLoaderInterface)
public:
ItemNotesLoader();
~ItemNotesLoader();
QString id() const override { return "itemnotes"; }
QString name() const override { return tr("Notes"); }
QString author() const override { return QString(); }
QString description() const override { return tr("Display notes for items."); }
QVariant icon() const override { return QVariant(IconPenToSquare); }
QStringList formatsToSave() const override;
void applySettings(QSettings &settings) override;
void loadSettings(const QSettings &settings) override;
QWidget *createSettingsWidget(QWidget *parent) override;
ItemWidget *transform(ItemWidget *itemWidget, const QVariantMap &data) override;
bool matches(const QModelIndex &index, const ItemFilter &filter) const override;
private:
bool m_notesAtBottom = false;
bool m_notesBeside = false;
bool m_showTooltip = false;
std::unique_ptr<Ui::ItemNotesSettings> ui;
};
#endif // ITEMNOTES_H
| 2,119
|
C++
|
.h
| 62
| 30.290323
| 84
| 0.751969
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,274
|
tests.h
|
hluk_CopyQ/src/tests/tests.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef TESTS_H
#define TESTS_H
#include "tests/testinterface.h"
#include <QObject>
#include <QStringList>
class QProcess;
class QByteArray;
/**
* Tests for the application.
*/
class Tests final : public QObject
{
Q_OBJECT
public:
explicit Tests(const TestInterfacePtr &test, QObject *parent = nullptr);
private slots:
void initTestCase();
void cleanupTestCase();
void init();
void cleanup();
void readLog();
void commandHelp();
void commandVersion();
void badCommand();
void badSessionName();
void commandCatchExceptions();
void commandExit();
void commandEval();
void commandEvalThrows();
void commandEvalSyntaxError();
void commandEvalArguments();
void commandEvalEndingWithComment();
void commandPrint();
void commandAbort();
void commandFail();
void commandSource();
void commandVisible();
void commandToggle();
void commandHide();
void commandShow();
void commandShowAt();
void commandFocused();
void commandsUnicode();
void commandsAddRead();
void commandsWriteRead();
void commandChange();
void commandSetCurrentTab();
void commandConfig();
void commandToggleConfig();
void commandDialog();
void commandDialogCloseOnDisconnect();
void commandMenuItems();
void commandsPackUnpack();
void commandsBase64();
void commandsGetSetItem();
void commandsChecksums();
void commandEscapeHTML();
void commandExecute();
void commandSettings();
void commandsEnvSetEnv();
void commandSleep();
void commandsData();
void commandCurrentWindowTitle();
void commandCopy();
void commandClipboard();
void commandHasClipboardFormat();
void commandEdit();
void commandEditItem();
void commandGetSetCurrentPath();
void commandSelectItems();
void commandsExportImport();
void commandsGetSetCommands();
void commandsImportExportCommands();
void commandsImportExportCommandsFixIndentation();
void commandsAddCommandsRegExp();
void commandScreenshot();
void commandNotification();
void commandIcon();
void commandIconTag();
void commandIconTagColor();
void commandLoadTheme();
void commandDateString();
void commandAfterMilliseconds();
void commandAsync();
void commandFilter();
void commandMimeTypes();
void commandUnload();
void commandForceUnload();
void commandServerLogAndLogs();
void classByteArray();
void classFile();
void classDir();
void classTemporaryFile();
void classItemSelection();
void classItemSelectionGetCurrent();
void classItemSelectionByteArray();
void classItemSelectionSort();
void classSettings();
void calledWithInstance();
void pipingCommands();
void chainingCommands();
void configMaxitems();
void keysAndFocusing();
void selectItems();
void moveItems();
void deleteItems();
void searchItems();
void searchItemsAndSelect();
void searchItemsAndCopy();
void searchRowNumber();
void searchAccented();
void copyItems();
void selectAndCopyOrder();
void sortAndReverse();
void createTabDialog();
void copyPasteCommands();
void editItems();
void createNewItem();
void editNotes();
void toggleClipboardMonitoring();
void clipboardToItem();
void itemToClipboard();
void tabAdd();
void tabRemove();
void tabIcon();
void action();
void insertRemoveItems();
void renameTab();
void renameClipboardTab();
void importExportTab();
void removeAllFoundItems();
void nextPrevious();
void externalEditor();
void nextPreviousTab();
void itemPreview();
void openAndSavePreferences();
void pasteFromMainWindow();
void tray();
void menu();
void traySearch();
void trayPaste();
void pasteNext();
// Options for tray menu.
void configTrayTab();
void configMove();
void configTrayTabIsCurrent();
void configAutostart();
void configPathEnvVariable();
void itemDataPathEnvVariable();
void configTabs();
void selectedItems();
void shortcutCommand();
void shortcutCommandOverrideEnter();
void shortcutCommandMatchInput();
void shortcutCommandMatchCmd();
void shortcutCommandSelectedItemData();
void shortcutCommandSetSelectedItemData();
void shortcutCommandSelectedItemsData();
void shortcutCommandSetSelectedItemsData();
void shortcutCommandSelectedAndCurrent();
void shortcutCommandMoveSelected();
void automaticCommandIgnore();
void automaticCommandRemove();
void automaticCommandInput();
void automaticCommandRegExp();
void automaticCommandSetData();
void automaticCommandOutputTab();
void automaticCommandNoOutputTab();
void automaticCommandChaining();
void automaticCommandCopyToTab();
void automaticCommandStoreSpecialFormat();
void automaticCommandIgnoreSpecialFormat();
void globalCommandInMenu();
void scriptCommandLoaded();
void scriptCommandAddFunction();
void scriptCommandOverrideFunction();
void scriptCommandEnhanceFunction();
void scriptCommandEndingWithComment();
void scriptCommandWithError();
void scriptPaste();
void scriptOnTabSelected();
void scriptOnItemsRemoved();
void scriptOnItemsAdded();
void scriptOnItemsChanged();
void scriptOnItemsLoaded();
void scriptEventMaxRecursion();
void scriptSlowCollectOverrides();
void displayCommand();
void displayCommandForMenu();
void synchronizeInternalCommands();
void queryKeyboardModifiersCommand();
void pointerPositionCommand();
void setPointerPositionCommand();
void setTabName();
void showHideAboutDialog();
void showHideClipboardDialog();
void showHideItemDialog();
void showHideLogDialog();
void showHideActionHandlerDialog();
void shortcutDialogAddShortcut();
void shortcutDialogAddTwoShortcuts();
void shortcutDialogChangeShortcut();
void shortcutDialogSameShortcut();
void shortcutDialogCancel();
void actionDialogCancel();
void actionDialogAccept();
void actionDialogSelectionInputOutput();
void exitConfirm();
void exitNoConfirm();
void exitStopCommands();
void abortInputReader();
void changeAlwaysOnTop();
void networkGet();
void networkGetPostAsync();
void pluginNotInstalled();
void startServerAndRunCommand();
void avoidStoringPasswords();
void scriptsForPasswords();
void currentClipboardOwner();
void saveLargeItem();
void slowClipboard();
void clipboardUriList();
private:
void clearServerErrors();
int run(const QStringList &arguments, QByteArray *stdoutData = nullptr,
QByteArray *stderrData = nullptr, const QByteArray &in = QByteArray(),
const QStringList &environment = QStringList());
bool hasTab(const QString &tabName);
TestInterfacePtr m_test;
};
int runTests(int argc, char *argv[]);
#endif // TESTS_H
| 7,193
|
C++
|
.h
| 233
| 25.695279
| 82
| 0.731089
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,275
|
test_utils.h
|
hluk_CopyQ/src/tests/test_utils.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include <QByteArray>
#include <QKeySequence>
#include <QString>
#include <QStringList>
#include <QTest>
#include <QTimer>
#include <QVariantMap>
constexpr int maxReadLogSize = 1 * 1024 * 1024;
constexpr auto clipboardTabName = "CLIPBOARD";
constexpr auto defaultSessionColor = "#ff8800";
constexpr auto defaultTagColor = "#000000";
constexpr auto clipboardBrowserId = "focus:ClipboardBrowser";
constexpr auto clipboardBrowserRefreshButtonId = "focus:ClipboardBrowserRefreshButton";
constexpr auto filterEditId = "focus:Utils::FilterLineEdit";
constexpr auto trayMenuId = "focus:TrayMenu";
constexpr auto menuId = "focus:Menu";
constexpr auto customMenuId = "focus:CustomMenu";
constexpr auto editorId = "focus::ItemEditorWidget";
constexpr auto tabDialogLineEditId = "focus:lineEditTabName";
constexpr auto commandDialogId = "focus:CommandDialog";
constexpr auto commandDialogSaveButtonId = "focus::QPushButton in :QMessageBox";
constexpr auto commandDialogListId = "focus:listWidgetItems";
constexpr auto configurationDialogId = "focus:ConfigurationManager";
constexpr auto shortcutButtonId = "focus::QToolButton in CommandDialog";
constexpr auto shortcutDialogId = "focus::QKeySequenceEdit in ShortcutDialog";
constexpr auto actionDialogId = "focus:ActionDialog";
constexpr auto aboutDialogId = "focus:AboutDialog";
constexpr auto logDialogId = "focus:LogDialog";
constexpr auto actionHandlerDialogId = "focus:ActionHandlerDialog";
constexpr auto actionHandlerFilterId = "focus:filterLineEdit";
constexpr auto actionHandlerTableId = "focus:tableView";
constexpr auto clipboardDialogId = "focus:ClipboardDialog";
constexpr auto clipboardDialogFormatListId = "focus:listWidgetFormats";
constexpr auto confirmExitDialogId = "focus::QPushButton in :QMessageBox";
constexpr auto itemPreviewId = "focus:in dockWidgetItemPreviewContents";
#define KEEP_STDIN_OPEN "KEEP_STDIN_OPEN"
#define NO_ERRORS(ERRORS_OR_EMPTY) !m_test->writeOutErrors(ERRORS_OR_EMPTY)
/**
* Verify that method call (TestInterface::startServer(), TestInterface::runClient() etc.)
* didn't fail or print error.
*/
#define TEST(ERRORS_OR_EMPTY) \
QVERIFY2( NO_ERRORS(ERRORS_OR_EMPTY), "Failed with errors above." )
#define RUN(ARGUMENTS, STDOUT_EXPECTED) \
TEST( m_test->runClient((Args() << ARGUMENTS), toByteArray(STDOUT_EXPECTED)) )
#define RUN_WITH_INPUT(ARGUMENTS, INPUT, STDOUT_EXPECTED) \
TEST( m_test->runClient((Args() << ARGUMENTS), toByteArray(STDOUT_EXPECTED), toByteArray(INPUT)) )
#define RUN_EXPECT_ERROR(ARGUMENTS, EXIT_CODE) \
TEST( m_test->runClientWithError((Args() << ARGUMENTS), (EXIT_CODE)) )
#define RUN_EXPECT_ERROR_WITH_STDERR(ARGUMENTS, EXIT_CODE, STDERR_CONTAINS) \
TEST( m_test->runClientWithError((Args() << ARGUMENTS), (EXIT_CODE), toByteArray(STDERR_CONTAINS)) )
#define WAIT_FOR_CLIPBOARD(DATA) \
TEST( m_test->verifyClipboard(DATA, "text/plain") )
#define WAIT_FOR_CLIPBOARD2(DATA, MIME) \
TEST( m_test->verifyClipboard((DATA), (MIME)) )
#define RETURN_ON_ERROR(CALLBACK, ERROR) \
do { \
const auto errors = (CALLBACK); \
if ( !errors.isEmpty() ) \
return QByteArray(ERROR) + ":\n" + QByteArray(errors); \
} while(false)
/// Skip rest of the tests
#define SKIP(MESSAGE) QSKIP(MESSAGE, SkipAll)
#define WAIT_ON_OUTPUT(ARGUMENTS, OUTPUT) \
TEST( m_test->waitOnOutput((Args() << ARGUMENTS), toByteArray(OUTPUT)) )
#define SKIP_ON_ENV(ENV) \
if ( qgetenv(ENV) == "1" ) \
SKIP("Unset " ENV " to run the tests")
#define WITH_TIMEOUT "afterMilliseconds(10000, fail); "
/// Interval to wait (in ms) before and after setting clipboard.
#ifdef Q_OS_MAC
// macOS seems to require larger delay before/after setting clipboard
const int waitMsSetClipboard = 1000;
#else
const int waitMsSetClipboard = 250;
#endif
/// Interval to wait (in ms) for pasting clipboard.
const int waitMsPasteClipboard = 1000;
/// Interval to wait (in ms) for client process.
const int waitClientRun = 30000;
using Args = QStringList;
inline QByteArray toByteArray(const QString &text)
{
return text.toUtf8();
}
inline QByteArray toByteArray(const QByteArray &text)
{
return text;
}
inline QByteArray toByteArray(const char *text)
{
return text;
}
/// Naming scheme for test tabs in application.
inline QString testTab(int i)
{
return "Tab_&" + QString::number(i);
}
inline QString keyNameFor(QKeySequence::StandardKey standardKey)
{
return QKeySequence(standardKey).toString();
}
template <typename Fn1, typename Fn2>
void runMultiple(Fn1 f1, Fn2 f2)
{
QTimer timer;
timer.setSingleShot(true);
timer.setInterval(0);
QObject::connect(&timer, &QTimer::timeout, f2);
timer.start();
f1();
}
| 4,763
|
C++
|
.h
| 114
| 39.412281
| 104
| 0.764286
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,276
|
testinterface.h
|
hluk_CopyQ/src/tests/testinterface.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef TESTINTERFACE_H
#define TESTINTERFACE_H
#include "common/clipboardmode.h"
#include <QByteArray>
#include <QStringList>
#include <QVariant>
#include <QtContainerFwd>
#include <memory>
/**
* Interface for tests.
*/
class TestInterface {
public:
enum ReadStderrFlag {
// Read errors from stderr (lines with "Error:", "Warning:" and similar).
ReadErrors = 0,
// Read all stderr.
ReadAllStderr = 1,
// Read errors from stderr but omit single exception in script.
ReadErrorsWithoutScriptException = 2
};
TestInterface() = default;
virtual ~TestInterface() = default;
/// Start or restart GUI server and return true if successful.
virtual QByteArray startServer() = 0;
/// Stop GUI server and return true if server is was stopped or is not running.
virtual QByteArray stopServer() = 0;
/// Returns an error if server doesn't stop after some interval.
virtual QByteArray waitForServerToStop() = 0;
/// Return true if GUI server is not running.
virtual bool isServerRunning() = 0;
/// Run client with given @a arguments and input and read outputs and return exit code.
virtual int run(const QStringList &arguments, QByteArray *stdoutData = nullptr,
QByteArray *stderrData = nullptr, const QByteArray &in = QByteArray(),
const QStringList &environment = QStringList()) = 0;
/// Run client with given @a arguments and read all errors/warnings.
virtual QByteArray runClient(const QStringList &arguments, const QByteArray &stdoutExpected,
const QByteArray &input = QByteArray()) = 0;
/// Run client with given @a arguments and expect errors/warnings on server and client side.
virtual QByteArray runClientWithError(const QStringList &arguments, int expectedExitCode,
const QByteArray &stderrContains = QByteArray()) = 0;
/// Run client with given @a arguments and read output, check stderr and exit code.
virtual QByteArray getClientOutput(const QStringList &arguments, QByteArray *stdoutActual) = 0;
/// Waits on client output.
virtual QByteArray waitOnOutput(const QStringList &arguments, const QByteArray &stdoutExpected) = 0;
/// Set clipboard through monitor process.
virtual QByteArray setClipboard(const QMap<QString, QVariant> &data, ClipboardMode mode = ClipboardMode::Clipboard) = 0;
/// Set clipboard through monitor process.
virtual QByteArray setClipboard(
const QByteArray &bytes,
const QString &mime = QLatin1String("text/plain"),
ClipboardMode mode = ClipboardMode::Clipboard) = 0;
/// Verify clipboard content.
virtual QByteArray verifyClipboard(const QByteArray &data, const QString &mime, bool exact = true) = 0;
/**
* Return errors/warning from server (otherwise empty output).
* If @a readAll is set, read all stderr.
*/
virtual QByteArray readServerErrors(ReadStderrFlag flag = ReadErrors) = 0;
/// Init test case. Return error string on error.
virtual QByteArray initTestCase() = 0;
/// Clean up test case. Return error string on error.
virtual QByteArray cleanupTestCase() = 0;
/// Init test. Return error string on error.
virtual QByteArray init() = 0;
/// Clean up tabs and items. Return error string on error.
virtual QByteArray cleanup() = 0;
/// Platform specific key to remove (usually Delete, Backspace on OS X).
virtual QString shortcutToRemove() = 0;
/// Set environment variable for test.
virtual void setEnv(const QString &name, const QString &value) = 0;
virtual bool writeOutErrors(const QByteArray &errors) = 0;
TestInterface(const TestInterface &) = delete;
TestInterface &operator=(const TestInterface &) = delete;
};
using TestInterfacePtr = std::shared_ptr<TestInterface>;
#endif // TESTINTERFACE_H
| 4,007
|
C++
|
.h
| 78
| 44.910256
| 124
| 0.705053
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,277
|
tests_common.h
|
hluk_CopyQ/src/tests/tests_common.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include "tests/testinterface.h"
#include <QObject>
#include <QStringList>
class QByteArray;
// Similar to QTemporaryFile but allows removing from other process.
class TemporaryFile {
public:
TemporaryFile();
~TemporaryFile();
QString fileName() const { return m_fileName; }
private:
QString m_fileName;
};
int count(const QStringList &items, const QString &pattern);
QStringList splitLines(const QByteArray &nativeText);
bool testStderr(
const QByteArray &stderrData,
TestInterface::ReadStderrFlag flag = TestInterface::ReadErrors);
/// Generate unique data.
QByteArray generateData();
QString appWindowTitle(const QString &text);
| 725
|
C++
|
.h
| 23
| 29
| 68
| 0.787265
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,278
|
itemfilter.h
|
hluk_CopyQ/src/item/itemfilter.h
|
#pragma once
#include <memory>
class QModelIndex;
class QString;
class QTextCharFormat;
class QTextEdit;
class ItemFilter
{
public:
virtual ~ItemFilter() = default;
virtual bool matchesAll() const = 0;
virtual bool matchesNone() const = 0;
virtual bool matches(const QString &text) const = 0;
virtual bool matchesIndex(const QModelIndex &index) const = 0;
virtual void highlight(QTextEdit *edit, const QTextCharFormat &format) const = 0;
virtual void search(QTextEdit *edit, bool backwards) const = 0;
virtual QString searchString() const = 0;
};
using ItemFilterPtr = std::shared_ptr<ItemFilter>;
| 634
|
C++
|
.h
| 19
| 30.473684
| 85
| 0.754501
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,279
|
itemwidgetwrapper.h
|
hluk_CopyQ/src/item/itemwidgetwrapper.h
|
#ifndef ITEMWIDGETWRAPPER_H
#define ITEMWIDGETWRAPPER_H
#include "itemwidget.h"
#include <memory>
class ItemWidgetWrapper : public ItemWidget
{
public:
ItemWidgetWrapper(ItemWidget *childItem, QWidget *widget);
void updateSize(QSize maximumSize, int idealWidth) override;
void setCurrent(bool current) override;
void setTagged(bool tagged) override;
protected:
ItemWidget *childItem() const { return m_childItem.get(); }
private:
std::unique_ptr<ItemWidget> m_childItem;
};
#endif // ITEMWIDGETWRAPPER_H
| 537
|
C++
|
.h
| 17
| 28.647059
| 64
| 0.784736
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,280
|
itemsaverwrapper.h
|
hluk_CopyQ/src/item/itemsaverwrapper.h
|
#pragma once
#include "item/itemwidget.h"
class ItemSaverWrapper : public ItemSaverInterface
{
public:
explicit ItemSaverWrapper(const ItemSaverPtr &saver);
bool saveItems(const QString &tabName, const QAbstractItemModel &model, QIODevice *file) override;
bool canRemoveItems(const QList<QModelIndex> &indexList, QString *error) override;
bool canDropItem(const QModelIndex &index) override;
bool canMoveItems(const QList<QModelIndex> &indexList) override;
void itemsRemovedByUser(const QList<QPersistentModelIndex> &indexList) override;
QVariantMap copyItem(const QAbstractItemModel &model, const QVariantMap &itemData) override;
void setFocus(bool focus) override;
protected:
ItemSaverInterface *wrapped() const { return m_saver.get(); }
private:
ItemSaverPtr m_saver;
};
| 825
|
C++
|
.h
| 18
| 42
| 102
| 0.795226
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,281
|
serialize.h
|
hluk_CopyQ/src/item/serialize.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef SERIALIZE_H
#define SERIALIZE_H
#include <QVariantMap>
class QAbstractItemModel;
class QByteArray;
class QDataStream;
class QIODevice;
class DataFile;
QDataStream &operator<<(QDataStream &out, DataFile value);
QDataStream &operator>>(QDataStream &in, DataFile &value);
void registerDataFileConverter();
void serializeData(QDataStream *stream, const QVariantMap &data, int itemDataThreshold = -1);
bool deserializeData(QDataStream *stream, QVariantMap *data);
QByteArray serializeData(const QVariantMap &data);
bool deserializeData(QVariantMap *data, const QByteArray &bytes);
bool serializeData(const QAbstractItemModel &model, QDataStream *stream, int itemDataThreshold = -1);
bool deserializeData(QAbstractItemModel *model, QDataStream *stream, int maxItems);
bool serializeData(const QAbstractItemModel &model, QIODevice *file, int itemDataThreshold = -1);
bool deserializeData(QAbstractItemModel *model, QIODevice *file, int maxItems);
QString itemDataPath();
bool itemDataFiles(QIODevice *file, QStringList *files);
#endif // SERIALIZE_H
| 1,104
|
C++
|
.h
| 23
| 46.652174
| 101
| 0.82479
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,282
|
persistentdisplayitem.h
|
hluk_CopyQ/src/item/persistentdisplayitem.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef PERSISTENTDISPLAYITEM_H
#define PERSISTENTDISPLAYITEM_H
#include <QMetaType>
#include <QPointer>
#include <QString>
#include <QVariantMap>
class ItemDelegate;
class QAction;
class QModelIndex;
class QWidget;
class QString;
/**
* Holds data for currently displayed item.
*
* Can be used to change the data for displaying without altering the item data itself.
*/
class PersistentDisplayItem final
{
public:
PersistentDisplayItem() = default;
PersistentDisplayItem(
ItemDelegate *delegate, const QVariantMap &data, QWidget *widget);
PersistentDisplayItem(QAction *action, const QVariantMap &data);
/**
* Returns display data of the item.
*
* This method is thread-safe.
*/
const QVariantMap &data() const noexcept { return m_data; }
/**
* Returns true only if display item widget is still available.
*/
bool isValid();
/**
* Sets display data.
*
* If data is empty, the item will be displayed later again.
*/
void setData(const QVariantMap &data);
private:
QVariantMap m_data;
QPointer<QWidget> m_widget;
QPointer<QAction> m_action;
QPointer<ItemDelegate> m_delegate;
};
Q_DECLARE_METATYPE(PersistentDisplayItem)
#endif // PERSISTENTDISPLAYITEM_H
| 1,328
|
C++
|
.h
| 48
| 23.958333
| 87
| 0.727129
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,283
|
itemwidget.h
|
hluk_CopyQ/src/item/itemwidget.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMWIDGET_H
#define ITEMWIDGET_H
#include "tests/testinterface.h"
#include <QObject>
#include <QtContainerFwd>
#include <memory>
struct Command;
class ItemFilter;
class TestInterface;
class QAbstractItemModel;
class QIODevice;
class QModelIndex;
class QPersistentModelIndex;
class QSettings;
class QTextEdit;
class QWidget;
class ItemLoaderInterface;
using ItemLoaderPtr = std::shared_ptr<ItemLoaderInterface>;
class ItemSaverInterface;
using ItemSaverPtr = std::shared_ptr<ItemSaverInterface>;
class ItemScriptableFactoryInterface;
using ItemScriptableFactoryPtr = std::shared_ptr<ItemScriptableFactoryInterface>;
using TestInterfacePtr = std::shared_ptr<TestInterface>;
#define COPYQ_PLUGIN_ITEM_LOADER_ID "com.github.hluk.copyq.itemloader/9.1.0"
/**
* Handles item in list.
*/
class ItemWidget
{
public:
explicit ItemWidget(QWidget *widget);
virtual ~ItemWidget() = default;
/**
* Return widget to render.
*/
QWidget *widget() const { return m_widget; }
/**
* Size of widget needs to be updated (because maximum size changed).
*/
virtual void updateSize(QSize maximumSize, int idealWidth);
/**
* Called if widget is set or unset as current.
*/
virtual void setCurrent(bool current);
/**
* Mark item as tagged/untagged.
*
* Used to hide unimportant data when notes or tags are present.
*/
virtual void setTagged(bool) {}
ItemWidget(const ItemWidget &) = delete;
ItemWidget &operator=(const ItemWidget &) = delete;
protected:
/**
* Filter mouse events for QTextEdit widgets.
*
* With Shift modifier pressed (item should be selected first), text in QTextEdit widget
* can be selected.
*
* Without Shift modifier pressed, mouse press selects item and mouse move with left button
* pressed drags item.
*
* Use QWidget::installEventFilter() on QTextEdit::viewport() and call this method from
* overridden QWidget::eventFilter().
*/
bool filterMouseEvents(QTextEdit *edit, QEvent *event);
private:
QWidget *m_widget;
};
/**
* Adss functions and variables accessible from scripts/commands.
*
* New functions and variables will be available in scripts under `plugins.<PLUGIN_ID>`.
*
* Public slots will be available as functions.
*
* Public QObject properties will be available as variables.
*
* Important: The slots and properties are used in different than main thread.
*/
class ItemScriptable : public QObject
{
public:
/** Return scriptable object (nullptr before start() is called). */
QObject *scriptable() const { return m_scriptable; }
/** Set scriptable (used internally before scripts starts). */
void setScriptable(QObject *scriptable) { m_scriptable = scriptable; }
/** Called before script starts (and scriptable is valid). */
virtual void start() {}
protected:
/**
* Call scriptable function by name with given @a arguments.
*
* Shouldn't be called before start().
*/
QVariant call(const QString &method, const QVariantList &arguments = QVariantList());
/**
* Evaluate script.
*
* Shouldn't be called before start().
*/
QVariant eval(const QString &script);
/**
* Return arguments passed to slots from script.
*
* Shouldn't be called before start().
*/
QVariantList currentArguments();
void throwError(const QString &message);
private:
QObject *m_scriptable = nullptr;
};
/**
* Factory for creating script objects.
*/
class ItemScriptableFactoryInterface
{
public:
virtual ~ItemScriptableFactoryInterface() = default;
/**
* Create script object.
*
* This method must be thread-safe.
*/
virtual ItemScriptable *create() const = 0;
/**
* Variable name for scriptable object in script.
*
* This method is thread-safe.
*/
QString name() const { return m_name; }
void setName(const QString &name) { m_name = name; }
private:
QString m_name;
};
/**
* Handles saving and modifying item models.
*/
class ItemSaverInterface
{
public:
ItemSaverInterface() = default;
virtual ~ItemSaverInterface() = default;
/**
* Save items.
* @return true only if items were saved
*/
virtual bool saveItems(const QString &tabName, const QAbstractItemModel &model, QIODevice *file);
/**
* Called before items are deleted by user.
* @return true if items can be removed, false to cancel the removal
*/
virtual bool canRemoveItems(const QList<QModelIndex> &indexList, QString *error);
/**
* Called before item is deleted from end so new items can be inserted.
* @return true if item can be dropped, false to disallow the drop
*/
virtual bool canDropItem(const QModelIndex &index);
/**
* Called before items are moved out of list (i.e. deleted) by user.
* @return true if items can be moved, false to cancel the removal
*/
virtual bool canMoveItems(const QList<QModelIndex> &);
/**
* Called when items are being deleted by user.
*/
virtual void itemsRemovedByUser(const QList<QPersistentModelIndex> &indexList);
/**
* Return copy of items data.
*/
virtual QVariantMap copyItem(const QAbstractItemModel &model, const QVariantMap &itemData);
virtual void setFocus(bool focus);
ItemSaverInterface(const ItemSaverInterface &) = delete;
ItemSaverInterface &operator=(const ItemSaverInterface &) = delete;
};
/**
* Main class for plugins (needs to be implemented).
*
* Identifies the plugin (id, name, author, description) and optionally:
* - loads items from file (creates ItemSaverInterface instance),
* - creates item widgets (creates ItemWidget instance),
* - adds scripting capabilities (creates ItemScriptable instance),
* - matches/filters items,
* - provides commands for Command dialog,
* - provides settings widget for Configuration dialog.
*/
class ItemLoaderInterface
{
public:
ItemLoaderInterface() = default;
virtual ~ItemLoaderInterface() = default;
/**
* Return priority.
*
* Use this loader before all others with lower priority.
*/
virtual int priority() const { return 0; }
/**
* Create ItemWidget instance from index data.
*
* @return nullptr if index hasn't appropriate data
*/
virtual ItemWidget *create(const QVariantMap &data, QWidget *parent, bool preview) const;
/**
* Simple ID of plugin.
*
* Name configuration sub-section and plugin object in scripts (`plugins.<PLUGIN_ID>`).
*
* Should be short and contain only lower case letters.
*/
virtual QString id() const = 0;
/**
* Return descriptive name (translatable).
*/
virtual QString name() const = 0;
/**
* Return author's name.
*/
virtual QString author() const = 0;
/**
* Return plugin description (translatable).
*/
virtual QString description() const = 0;
/**
* Return icon representing the plugin.
*
* Return value can be QIcon or UInt (to render a character from icon font).
*
* Default is no icon.
*/
virtual QVariant icon() const = 0;
/**
* Provide formats to save (possibly configurable).
*
* The values are stored into user QSettings, under group with name same as value of id().
*/
virtual QStringList formatsToSave() const;
/**
* Save and return configuration values to save from current settings widget.
*/
virtual void applySettings(QSettings &) {}
virtual void setEnabled(bool enabled) { m_enabled = enabled; }
bool isEnabled() const { return m_enabled; }
/**
* Load stored configuration values.
*/
virtual void loadSettings(const QSettings &) {}
/**
* Create settings widget.
*/
virtual QWidget *createSettingsWidget(QWidget *) { return nullptr; }
/**
* @return true only if items can be loaded
*/
virtual bool canLoadItems(QIODevice *file) const;
/**
* @return true only if items can be saved
*/
virtual bool canSaveItems(const QString &tabName) const;
/**
* Load items.
* @return true only if items were saved by this plugin (or just not to load them any further)
*/
virtual ItemSaverPtr loadItems(
const QString &tabName, QAbstractItemModel *model, QIODevice *file, int maxItems);
/**
* Initialize tab (tab was not yet saved or loaded).
* @return true only if successful
*/
virtual ItemSaverPtr initializeTab(const QString &tabName, QAbstractItemModel *model, int maxItems);
/**
* Allow to transform item widget (wrap around a new widget).
* By default returns nullptr not to wrap the widget.
* New ItemWidget must take care of deleting the old one!
*/
virtual ItemWidget *transform(ItemWidget *itemWidget, const QVariantMap &data);
/**
* Transform loader.
*/
virtual ItemSaverPtr transformSaver(const ItemSaverPtr &saver, QAbstractItemModel *model);
/**
* Return true if regular expression matches items content.
* Returns false by default.
*/
virtual bool matches(const QModelIndex &index, const ItemFilter &filter) const;
/**
* Return object with tests.
*
* All private slots are executed (see QtTest documentation).
*
* Property "CopyQ_test_settings" contains configuration for GUI server and
* if will be passed to ItemLoaderInterface::loadSettings() for this plugin.
*/
virtual QObject *tests(const TestInterfacePtr &test) const;
/**
* Return QObject instance with signals (by default null pointer).
*
* Returned QObject can have signal error(QString) for signaling errors.
*/
virtual const QObject *signaler() const;
/**
* Return scriptable object.
*/
virtual ItemScriptable *scriptableObject();
/**
* Adds commands from scripts for command dialog.
*/
virtual QVector<Command> commands() const;
virtual bool data(QVariantMap *data, const QModelIndex &index) const;
virtual bool setData(const QVariantMap &data, const QModelIndex &index, QAbstractItemModel *model) const;
/**
* Create external editor for @a index.
*
* Default implementation returns nullptr.
*
* @param index index for which the editor is opened
*
* @return Editor object -- see documentation for public signals and slots of ItemEditor class --
* nullptr so default text editor is opened.
*/
virtual QObject *createExternalEditor(const QModelIndex &index, const QVariantMap &data, QWidget *parent) const;
ItemLoaderInterface(const ItemLoaderInterface &) = delete;
ItemLoaderInterface &operator=(const ItemLoaderInterface &) = delete;
private:
bool m_enabled = true;
};
Q_DECLARE_INTERFACE(ItemLoaderInterface, COPYQ_PLUGIN_ITEM_LOADER_ID)
#endif // ITEMWIDGET_H
| 11,094
|
C++
|
.h
| 329
| 28.99696
| 116
| 0.695978
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,284
|
itemfactory.h
|
hluk_CopyQ/src/item/itemfactory.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMFACTORY_H
#define ITEMFACTORY_H
#include "common/command.h"
#include "item/itemwidget.h"
#include <QMap>
#include <QObject>
#include <QtContainerFwd>
class ItemLoaderInterface;
class ItemWidget;
class ScriptableProxy;
class QAbstractItemModel;
class QIODevice;
class QModelIndex;
class QSettings;
class QWidget;
struct Command;
struct CommandMenu;
using ItemLoaderList = QList<ItemLoaderPtr>;
/**
* Loads item plugins (loaders) and instantiates ItemWidget objects using appropriate
* ItemLoaderInterface::create().
*/
class ItemFactory final : public QObject
{
Q_OBJECT
public:
/**
* Loads item plugins.
*/
explicit ItemFactory(QObject *parent = nullptr);
~ItemFactory();
/**
* Instantiate ItemWidget using given @a loader if possible.
*/
ItemWidget *createItem(
const ItemLoaderPtr &loader, const QVariantMap &data, QWidget *parent,
bool antialiasing, bool transform = true, bool preview = false);
/**
* Instantiate ItemWidget using appropriate loader or creates simple ItemWidget (DummyItem).
*/
ItemWidget *createItem(const QVariantMap &data, QWidget *parent, bool antialiasing,
bool transform = true, bool preview = false);
ItemWidget *createSimpleItem(const QVariantMap &data, QWidget *parent, bool antialiasing);
/**
* Formats to save in history, union of enabled ItemLoaderInterface objects.
*/
QStringList formatsToSave() const;
/**
* Return list of loaders.
*/
const ItemLoaderList &loaders() const { return m_loaders; }
/**
* Sort loaders by priority.
*
* Method createItem() tries to instantiate ItemWidget with loader in this order.
*
* If priority of a loader is not set here, it is sorted after using
* ItemLoaderInterface::priority() after all loader explicitly sorted.
*/
void setPluginPriority(const QStringList &pluginNames);
/**
* Return true if no plugins were loaded.
*/
bool hasLoaders() const { return !m_loaders.isEmpty(); }
/**
* Load items using a plugin.
* @return the first plugin (or nullptr) for which ItemLoaderInterface::loadItems() returned true
*/
ItemSaverPtr loadItems(const QString &tabName, QAbstractItemModel *model, QIODevice *file, int maxItems);
/**
* Initialize tab.
* @return the first plugin (or nullptr) for which ItemLoaderInterface::initializeTab() returned true
*/
ItemSaverPtr initializeTab(const QString &tabName, QAbstractItemModel *model, int maxItems);
/**
* Return true only if any plugin (ItemLoaderInterface::matches()) returns true;
*/
bool matches(const QModelIndex &index, const ItemFilter &filter) const;
ItemScriptable* scriptableObject(const QString &name) const;
/**
* Adds commands from scripts for command dialog.
*/
QVector<Command> commands(bool enabled = true) const;
void emitError(const QString &errorString);
bool loadPlugins();
void loadItemFactorySettings(QSettings *settings);
QObject *createExternalEditor(const QModelIndex &index, const QVariantMap &data, QWidget *parent) const;
QVariantMap data(const QModelIndex &index) const;
bool setData(const QVariantMap &data, const QModelIndex &index, QAbstractItemModel *model) const;
signals:
void error(const QString &errorString);
void addCommands(const QVector<Command> &commands);
private:
/** Called if child ItemWidget destroyed. **/
void loaderChildDestroyed(QObject *obj);
/** Calls ItemLoaderInterface::transform() for all plugins in reverse order. */
ItemWidget *transformItem(ItemWidget *item, const QVariantMap &data);
void addLoader(const ItemLoaderPtr &loader);
ItemLoaderPtr loadPlugin(const QString &fileName, const QString &id) const;
bool loadItemFactorySettings(const ItemLoaderPtr &loader, QSettings *settings) const;
ItemLoaderList m_loaders;
ItemLoaderPtr m_dummyLoader;
QMap<QObject *, ItemLoaderPtr> m_loaderChildren;
};
#endif // ITEMFACTORY_H
| 4,141
|
C++
|
.h
| 106
| 34.349057
| 109
| 0.731067
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,285
|
itemeditor.h
|
hluk_CopyQ/src/item/itemeditor.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMEDITOR_H
#define ITEMEDITOR_H
#include <QDateTime>
#include <QFileInfo>
#include <QObject>
#include <QPersistentModelIndex>
#include <QString>
class Action;
class QModelIndex;
class QTimer;
class ItemEditor final : public QObject
{
Q_OBJECT
public:
ItemEditor(const QByteArray &data, const QString &mime, const QString &editor,
QObject *parent = nullptr);
~ItemEditor();
/**
* Set index to edited item (will be emitted with fileModified()).
*/
void setIndex(const QModelIndex &index);
/**
* Execute editor process.
* @retval true Editor successfully opened.
* @retval false An error occurred (failed to create temporary file), editor was not opened.
*/
Q_SLOT bool start();
signals:
/**
* File was modified.
* @param data modified data
* @param mime MIME type of the data
* @param index index of edited item or invalid
*/
void fileModified(const QByteArray &data, const QString &mime, const QModelIndex &index);
/**
* Editor was closed.
* @param who pointer to this object
*/
void closed(QObject *who, const QModelIndex &index);
/**
* Failed to run editor command.
*/
void error(const QString &errorString);
private:
/**
* Close editor.
*/
void close();
void onTimer();
/** Return true only if file was modified and reset this status. */
bool wasFileModified();
QByteArray m_data;
QString m_mime;
// hash of original string (saves some memory)
uint m_hash;
QString m_editorcmd;
Action *m_editor;
QTimer *m_timer;
QFileInfo m_info;
QDateTime m_lastmodified;
qint64 m_lastSize;
bool m_modified;
QPersistentModelIndex m_index;
};
#endif // ITEMEDITOR_H
| 2,061
|
C++
|
.h
| 67
| 23.089552
| 101
| 0.604757
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,286
|
clipboardmodel.h
|
hluk_CopyQ/src/item/clipboardmodel.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef CLIPBOARDMODEL_H
#define CLIPBOARDMODEL_H
#include "item/clipboarditem.h"
#include <QAbstractListModel>
#include <QList>
/**
* Container with clipboard items.
*
* Item prepending is optimized.
*/
class ClipboardItemList final {
public:
ClipboardItem &operator [](int i)
{
return m_items[i];
}
const ClipboardItem &operator [](int i) const
{
return m_items[i];
}
void insert(int row, const ClipboardItem &item)
{
m_items.insert(row, item);
}
void remove(int row, int count)
{
const QList<ClipboardItem>::iterator from = m_items.begin() + row;
const QList<ClipboardItem>::iterator to = from + count;
m_items.erase(from, to);
}
int size() const
{
return m_items.size();
}
void move(int from, int to)
{
const ClipboardItem item = m_items[from];
m_items.removeAt(from);
m_items.insert(to, item);
}
void move(int from, int count, int to);
void reserve(int maxItems)
{
m_items.reserve(maxItems);
}
void resize(int size)
{
if (size < this->size())
remove(size, this->size());
while (size > this->size())
m_items.append(ClipboardItem());
}
private:
QList<ClipboardItem> m_items;
};
/**
* Model containing ClipboardItem objects.
*
* Class implements QAbstractListModel interface.
*
* Clipboard item in model can be serialized and deserialized using
* operators << and >> (see @ref clipboard_model_serialization_operators).
*/
class ClipboardModel final : public QAbstractListModel
{
public:
/** Return true if @a lhs is less than @a rhs. */
using CompareItems = bool (const QModelIndex &, const QModelIndex &);
explicit ClipboardModel(QObject *parent = nullptr);
/** Return number of items in model. */
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
/** Return data for given @a index. */
QVariant data(const QModelIndex &index, int role) const override;
/** Return flags for given @a index. */
Qt::ItemFlags flags(const QModelIndex &index) const override;
bool setData(const QModelIndex &index, const QVariant &value,
int role = Qt::EditRole) override;
bool insertRows(int position, int rows,
const QModelIndex &index = QModelIndex()) override;
bool removeRows(int position, int rows,
const QModelIndex &index = QModelIndex()) override;
bool moveRows(const QModelIndex &sourceParent, int sourceRow, int rows,
const QModelIndex &destinationParent, int destinationRow) override;
/** insert new item to model. */
void insertItem(const QVariantMap &data, int row);
void insertItems(const QVector<QVariantMap> &dataList, int row);
void setItemsData(const QMap<QPersistentModelIndex, QVariantMap> &itemsData);
/**
* Sort items in ascending order.
*/
void sortItems(const QModelIndexList &indexList, CompareItems *compare);
void sortItems(const QList<QPersistentModelIndex> &sorted);
/**
* Find item with given @a hash.
* @return Row number with found item or -1 if no item was found.
*/
int findItem(uint itemHash) const;
private:
ClipboardItemList m_clipboardList;
};
#endif // CLIPBOARDMODEL_H
| 3,415
|
C++
|
.h
| 102
| 28.009804
| 81
| 0.672855
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,287
|
itemeditorwidget.h
|
hluk_CopyQ/src/item/itemeditorwidget.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMEDITORWIDGET_H
#define ITEMEDITORWIDGET_H
#include "item/itemfilter.h"
#include "item/itemwidget.h"
#include "gui/menuitems.h"
#include <QPersistentModelIndex>
#include <QTextEdit>
#include <memory>
class ItemWidget;
class QAbstractItemModel;
class QPlainTextEdit;
class QTextCursor;
class QTextDocument;
class QWidget;
/**
* Internal editor widget for items.
*/
class ItemEditorWidget final : public QTextEdit
{
Q_OBJECT
public:
ItemEditorWidget(const QModelIndex &index, const QString &format, QWidget *parent = nullptr);
bool isValid() const;
bool hasChanges() const;
void setHasChanges(bool hasChanges);
void setSaveOnReturnKey(bool enabled);
QVariantMap data() const;
QModelIndex index() const { return m_index; }
void search(const ItemFilterPtr &filter);
void findNext();
void findPrevious();
QWidget *createToolbar(QWidget *parent, const MenuItems &menuItems);
signals:
void save();
void cancel();
void invalidate();
void searchRequest();
protected:
void keyPressEvent(QKeyEvent *event) override;
bool canInsertFromMimeData(const QMimeData *source) const override;
void insertFromMimeData(const QMimeData *source) override;
private:
void saveAndExit();
void changeSelectionFont();
void toggleBoldText();
void toggleItalicText();
void toggleUnderlineText();
void toggleStrikethroughText();
void setForeground();
void setBackground();
void eraseStyle();
void search(bool backwards);
QPersistentModelIndex m_index;
bool m_saveOnReturnKey;
QString m_format;
ItemFilterPtr m_filter;
};
#endif // ITEMEDITORWIDGET_H
| 1,733
|
C++
|
.h
| 59
| 25.677966
| 97
| 0.757429
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,288
|
itemstore.h
|
hluk_CopyQ/src/item/itemstore.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMSTORE_H
#define ITEMSTORE_H
#include "item/itemwidget.h"
class QAbstractItemModel;
class ItemFactory;
class QString;
/** Load items from configuration file. */
ItemSaverPtr loadItems(const QString &tabName, QAbstractItemModel &model //!< Model for items.
, ItemFactory *itemFactory, int maxItems);
/** Save items to configuration file. */
bool saveItems(const QString &tabName, const QAbstractItemModel &model //!< Model containing items to save.
, const ItemSaverPtr &saver);
/** Remove configuration file for items. */
void removeItems(const QString &tabName //!< See ClipboardBrowser::getID().
);
/** Move configuration file for items. */
bool moveItems(
const QString &oldId, //!< See ClipboardBrowser::getID().
const QString &newId //!< See ClipboardBrowser::getID().
);
void cleanDataFiles(const QStringList &tabNames);
#endif // ITEMSTORE_H
| 961
|
C++
|
.h
| 23
| 38.347826
| 107
| 0.734409
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,289
|
clipboarditem.h
|
hluk_CopyQ/src/item/clipboarditem.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef CLIPBOARDITEM_H
#define CLIPBOARDITEM_H
#include <QVariant>
class QByteArray;
class QString;
/**
* Class for clipboard items in ClipboardModel.
*
* Clipboard item stores data of different MIME types and has single default
* MIME type for displaying the contents.
*/
class ClipboardItem final
{
public:
ClipboardItem();
explicit ClipboardItem(const QVariantMap &data);
/** Compare with other item (using hash). */
bool operator ==(const ClipboardItem &item) const;
/** Set item's MIME type data. */
void setData(const QString &mimeType, const QByteArray &data);
/**
* Set item's text data.
* Clears all other text data and saves @a text as text/plain MIME type.
*/
void setText(const QString &text);
/**
* Set formats from map with MIME type as key and data as value.
*/
bool setData(const QVariantMap &data);
/**
* Update current data.
* Clears non-internal data if passed data map contains non-internal data.
* @return true if any data were changed
*/
bool updateData(const QVariantMap &data);
/** Remove item's MIME type data. */
void removeData(const QString &mimeType);
/** Remove item's MIME type data. */
bool removeData(const QStringList &mimeTypeList);
/** Return data for given @a role. */
QVariant data(int role) const;
/** Return data for format. */
QByteArray data(const QString &format) const { return m_data.value(format).toByteArray(); }
/** Return hash for item's data. */
unsigned int dataHash() const;
private:
void invalidateDataHash();
QVariantMap m_data;
mutable unsigned int m_hash;
};
#endif // CLIPBOARDITEM_H
| 1,755
|
C++
|
.h
| 52
| 29.519231
| 95
| 0.697329
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,290
|
itemdelegate.h
|
hluk_CopyQ/src/item/itemdelegate.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ITEMDELEGATE_H
#define ITEMDELEGATE_H
#include "item/itemfilter.h"
#include "gui/clipboardbrowsershared.h"
#include <QItemDelegate>
#include <QRegularExpression>
#include <QTimer>
#include <memory>
#include <vector>
class Item;
class ItemEditorWidget;
class ItemFactory;
class ItemWidget;
class ClipboardBrowser;
class PersistentDisplayItem;
constexpr int defaultItemHeight = 100;
/**
* Delegate for items in ClipboardBrowser.
*
* Creates editor on demand and draws contents of all items.
*
* To achieve better performance the first call to get sizeHint() value for
* an item returns some default value (so it doesn't have to render all items).
*
* Before calling paint() for an index item on given index must be cached
* using cache().
*/
class ItemDelegate final : public QItemDelegate
{
Q_OBJECT
public:
ItemDelegate(ClipboardBrowser *view, const ClipboardBrowserSharedPtr &sharedData, QWidget *parent = nullptr);
~ItemDelegate();
QSize sizeHint(const QModelIndex &index) const;
QSize sizeHint(const QStyleOptionViewItem &option,
const QModelIndex &index) const override;
bool eventFilter(QObject *obj, QEvent *event) override;
/** Remove item widget if not currently visible and return true if removed. */
bool invalidateHidden(QWidget *widget);
/** Set regular expression for highlighting. */
void setItemFilter(const ItemFilterPtr &filter);
/** Return regular expression for highlighting. */
const ItemFilterPtr &itemFilter() const { return m_filter; }
/** Creates item widget if not created already. */
void createItemWidget(const QModelIndex &index);
/**
* Update data to display.
*/
void updateWidget(QObject *widget, const QVariantMap &data);
/** Set maximum size for all items. */
void setItemSizes(int maxWidth, int idealWidth);
/** Create internal item editor widget. */
ItemEditorWidget *createCustomEditor(
QWidget *parent, const QModelIndex &index, const QString &format);
/**
* Highlight matched text with current search expression, font and color.
*/
void highlightMatches(ItemWidget *itemWidget) const;
/// Update positions of all widgets
/// (after filtering out items or invalidating).
void updateAllRows();
void updateLater();
void updateIfNeeded();
/**
* Set or unset item widget as current.
*
* Only current item widget should receive mouse events (e.g. text selection).
*
* This allows interaction only for current item widget.
*/
void setItemWidgetCurrent(const QModelIndex &index, bool isCurrent);
/**
* Set or unset item widget as selected.
*
* This changes item appearace according to current theme/style.
*/
void setItemWidgetSelected(const QModelIndex &index, bool isSelected);
void dataChanged(const QModelIndex &a, const QModelIndex &b);
void rowsRemoved(const QModelIndex &parent, int start, int end);
void rowsInserted(const QModelIndex &parent, int start, int end);
void rowsMoved(const QModelIndex &parent, int sourceStart, int sourceEnd,
const QModelIndex &destination, int destinationRow);
QWidget *createPreview(const QVariantMap &data, QWidget *parent);
void setCurrentRow(int row, bool current);
signals:
void itemWidgetCreated(const PersistentDisplayItem &selection);
protected:
void paint(QPainter *painter, const QStyleOptionViewItem &option,
const QModelIndex &index) const override;
private:
struct Item {
ItemWidget *operator->() const noexcept { return item.get(); }
ItemWidget *get() const noexcept { return item.get(); }
operator bool() const noexcept { return static_cast<bool>(item); }
std::shared_ptr<ItemWidget> item;
int appliedFilterId = 0;
QSize size = QSize(0, defaultItemHeight);
};
void setIndexWidget(const QModelIndex &index, ItemWidget *w);
/// Updates style for selected/unselected widgets.
void setWidgetSelected(QWidget *ww, bool selected);
int findWidgetRow(const QObject *obj) const;
ItemWidget *updateWidget(const QModelIndex &index, const QVariantMap &data);
void updateItemWidgetSize(int row);
void updateItemSize(const QModelIndex &index, QSize itemWidgetSize);
QPoint findPositionForWidget(const QModelIndex &index) const;
void invalidateAllHiddenNow();
ClipboardBrowser *m_view;
ClipboardBrowserSharedPtr m_sharedData;
ItemFilterPtr m_filter;
int m_filterId = 0;
int m_maxWidth;
int m_idealWidth;
QTimer m_timerInvalidateHidden;
std::vector<Item> m_items;
};
#endif // ITEMDELEGATE_H
| 5,117
|
C++
|
.h
| 118
| 35.542373
| 117
| 0.680177
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,291
|
regexp.h
|
hluk_CopyQ/src/common/regexp.h
|
#ifndef REGEXP_H
#define REGEXP_H
#include <QRegularExpression>
static QRegularExpression anchoredRegExp(const QString &pattern)
{
#if QT_VERSION >= QT_VERSION_CHECK(5,12,0)
return QRegularExpression(QRegularExpression::anchoredPattern(pattern));
#else
const auto anchoredPattern = QLatin1String("\\A(?:") + pattern + QLatin1String(")\\z");
return QRegularExpression(anchoredPattern);
#endif
}
#endif // REGEXP_H
| 428
|
C++
|
.h
| 13
| 30.769231
| 91
| 0.776699
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,292
|
actiontablemodel.h
|
hluk_CopyQ/src/common/actiontablemodel.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef ACTIONTABLEMODEL_H
#define ACTIONTABLEMODEL_H
#include <QAbstractTableModel>
#include <QDateTime>
class Action;
enum class ActionState;
class ActionTableModel final : public QAbstractTableModel
{
public:
explicit ActionTableModel(QObject *parent = nullptr);
void setMaxRowCount(uint rows);
int actionAboutToStart(Action *action);
void actionStarted(Action *action);
void actionFailed(Action *action, const QString &error);
void actionFinished(Action *action);
void actionFinished(const QString &name);
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
int columnCount(const QModelIndex &parent = QModelIndex()) const override;
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
private:
struct ActionData {
int id;
QString name;
QDateTime started;
qint64 finished;
QString error;
};
static ActionState actionState(const ActionData &data);
ActionData &actionData(int row) { return m_actions[row]; }
const ActionData &actionData(int row) const { return m_actions[row]; }
int rowFor(const Action *action) const;
int actionCount() const { return m_actions.size(); }
void limitItems();
std::vector<ActionData> m_actions;
uint m_maxRowCount = 1000;
};
#endif // ACTIONTABLEMODEL_H
| 1,528
|
C++
|
.h
| 39
| 34.615385
| 109
| 0.74152
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,293
|
messagehandlerforqt.h
|
hluk_CopyQ/src/common/messagehandlerforqt.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef MESSAGEHANDLERFORQT_H
#define MESSAGEHANDLERFORQT_H
void installMessageHandlerForQt();
#endif // MESSAGEHANDLERFORQT_H
| 175
|
C++
|
.h
| 5
| 33.4
| 44
| 0.838323
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,294
|
client_server.h
|
hluk_CopyQ/src/common/client_server.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef CLIENT_SERVER_H
#define CLIENT_SERVER_H
class QString;
QString clipboardServerName();
#endif // CLIENT_SERVER_H
| 169
|
C++
|
.h
| 6
| 26.5
| 44
| 0.798742
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,295
|
navigationstyle.h
|
hluk_CopyQ/src/common/navigationstyle.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include <QtGlobal>
#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
# include <QMetaType>
#endif
enum class NavigationStyle {
Default,
Vi,
Emacs
};
#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
Q_DECLARE_METATYPE(NavigationStyle)
#endif
| 300
|
C++
|
.h
| 14
| 19.357143
| 44
| 0.738516
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,296
|
clientsocket.h
|
hluk_CopyQ/src/common/clientsocket.h
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef CLIENTSOCKET_H
#define CLIENTSOCKET_H
#include <QLocalSocket>
#include <QObject>
#include <QPointer>
using ClientSocketId = qulonglong;
class LocalSocketGuard final
{
public:
explicit LocalSocketGuard(QLocalSocket *socket);
~LocalSocketGuard();
QLocalSocket *get() const { return m_socket; }
QLocalSocket *operator->() const { return m_socket; }
operator QLocalSocket*() { return m_socket; }
operator bool() { return !m_socket.isNull(); }
LocalSocketGuard(const LocalSocketGuard &) = delete;
LocalSocketGuard &operator=(const LocalSocketGuard &) = delete;
private:
QPointer<QLocalSocket> m_socket;
};
class ClientSocket final : public QObject
{
Q_OBJECT
public:
ClientSocket();
explicit ClientSocket(const QString &serverName, QObject *parent = nullptr);
explicit ClientSocket(QLocalSocket *socket, QObject *parent = nullptr);
~ClientSocket();
/// Return socket ID unique in process (thread-safe).
ClientSocketId id() const { return m_socketId; }
/// Start emitting messageReceived().
bool start();
/** Send message to client. */
void sendMessage(
const QByteArray &message, //!< Message for client.
int messageCode //!< Custom message code.
);
void close();
signals:
void messageReceived(const QByteArray &message, int messageCode, ClientSocketId clientId);
void disconnected(ClientSocketId clientId);
void connectionFailed(ClientSocketId clientId);
private:
void onReadyRead();
void onError(QLocalSocket::LocalSocketError error);
void onStateChanged(QLocalSocket::LocalSocketState state);
void error(const QString &errorMessage);
LocalSocketGuard m_socket;
ClientSocketId m_socketId;
bool m_closed;
bool m_hasMessageLength = false;
quint32 m_messageLength = 0;
QByteArray m_message;
};
#endif // CLIENTSOCKET_H
| 1,959
|
C++
|
.h
| 56
| 30.535714
| 94
| 0.729012
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
18,297
|
actionhandlerenums.h
|
hluk_CopyQ/src/common/actionhandlerenums.h
|
#ifndef ACTIONHANDLERENUMS_H
#define ACTIONHANDLERENUMS_H
#include <QtGlobal>
enum class ActionState {
Starting,
Running,
Finished,
Error,
};
namespace ActionHandlerColumn {
enum {
id,
name,
status,
started,
finished,
error,
count
};
}
namespace ActionHandlerRole {
enum {
sort = Qt::UserRole,
status,
id
};
}
#endif // ACTIONHANDLERENUMS_H
| 402
|
C++
|
.h
| 28
| 11.178571
| 31
| 0.699187
|
hluk/CopyQ
| 8,577
| 439
| 420
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.