App::App(QCoreApplication *application, const QString &sessionName)
: m_app(application)
, m_exitCode(0)
, m_closed(false)
{
QString session("copyq");
if ( !sessionName.isEmpty() ) {
session += "-" + sessionName;
m_app->setProperty( "CopyQ_session_name", QVariant(sessionName) );
}
QCoreApplication::setOrganizationName(session);
QCoreApplication::setApplicationName(session);
#ifdef HAS_TESTS
initTests();
#endif
#ifdef Q_OS_UNIX
if ( !UnixSignalHandler::create(m_app.data()) )
log( QString("Failed to create handler for Unix signals!"), LogError );
#endif
createPlatformNativeInterface()->loadSettings();
installTranslator();
#ifdef HAS_TESTS
initTestsSettings();
#endif
}
bool ScriptableProxyHelper::copyFromCurrentWindow()
{
INVOKE(copyFromCurrentWindow());
PlatformWindowPtr window = createPlatformNativeInterface()->getCurrentWindow();
if (!window)
return false;
window->copy();
return true;
}
bool ScriptableProxyHelper::pasteToCurrentWindow()
{
INVOKE(pasteToCurrentWindow());
PlatformWindowPtr window = createPlatformNativeInterface()->getCurrentWindow();
if (!window)
return false;
window->pasteClipboard();
return true;
}
void ConfigurationManager::updateAutostart()
{
PlatformPtr platform = createPlatformNativeInterface();
if ( platform->canAutostart() ) {
bind<Config::autostart>(ui->checkBoxAutostart);
} else {
ui->checkBoxAutostart->hide();
}
}
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 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 NO_GLOBAL_SHORTCUTS
ui->checkBoxGlobalShortcut->hide();
ui->shortcutButtonGlobalShortcut->hide();
#else
ui->checkBoxGlobalShortcut->setIcon(iconShortcut());
#endif
ui->checkBoxAutomatic->setIcon(iconClipboard());
ui->checkBoxInMenu->setIcon(iconMenu());
ui->checkBoxIsScript->setIcon(iconScript());
ui->checkBoxDisplay->setIcon(iconDisplay());
// Add tab names to combo boxes.
initTabComboBox(ui->comboBoxCopyToTab);
initTabComboBox(ui->comboBoxOutputTab);
if ( !createPlatformNativeInterface()->canGetWindowTitle() )
ui->lineEditWindow->hide();
}
void App::restoreSettings(bool canModifySettings)
{
m_app->setProperty("CopyQ_server", canModifySettings);
createPlatformNativeInterface()->loadSettings();
Settings::restore();
installTranslator();
#ifdef HAS_TESTS
initTestsSettings();
#endif
}
ClipboardMonitor::ClipboardMonitor(int &argc, char **argv)
: Client()
, App(createPlatformNativeInterface()->createMonitorApplication(argc, argv))
, m_formats()
, m_newdata()
, m_updateTimer( new QTimer(this) )
, m_needCheckClipboard(false)
#ifdef COPYQ_WS_X11
, m_needCheckSelection(false)
, m_x11(new PrivateX11)
#endif
#ifdef Q_OS_MAC
, m_prevChangeCount(0)
, m_clipboardCheckTimer(new MacTimer(this))
, m_macPlatform(new MacPlatform())
#endif
{
Q_ASSERT(argc == 3);
const QString serverName( QString::fromUtf8(argv[2]) );
#ifdef HAS_TESTS
if ( serverName == QString("copyq_TEST") )
QCoreApplication::instance()->setProperty("CopyQ_testing", true);
#endif
m_updateTimer->setSingleShot(true);
m_updateTimer->setInterval(300);
connect( m_updateTimer, SIGNAL(timeout()),
this, SLOT(updateTimeout()));
#ifdef COPYQ_WS_X11
connect( &m_x11->incompleteSelectionTimer(), SIGNAL(timeout()),
this, SLOT(updateSelection()) );
connect( &m_x11->syncTimer(), SIGNAL(timeout()),
this, SLOT(synchronize()) );
connect( &m_x11->resetClipboardTimer(), SIGNAL(timeout()),
this, SLOT(resetClipboard()) );
#endif
#ifdef Q_OS_MAC
m_clipboardCheckTimer->setInterval(250);
m_clipboardCheckTimer->setTolerance(500);
connect(m_clipboardCheckTimer, SIGNAL(timeout()), this, SLOT(clipboardTimeout()));
m_clipboardCheckTimer->start();
#endif
Arguments arguments(argc, argv);
if ( !startClientSocket(serverName, arguments) )
exit(1);
}
bool ShortcutDialog::eventFilter(QObject *object, QEvent *event)
{
if (object != ui->lineEditShortcut)
return false;
if (event->type() == QEvent::KeyPress) {
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
COPYQ_LOG(QString("Shortcut key press: %1").arg(keyEvent->key()));
const int key = createPlatformNativeInterface()->keyCode(*keyEvent);
Qt::KeyboardModifiers mods = getModifiers(*keyEvent);
if (mods == Qt::NoModifier) {
if (key == Qt::Key_Tab)
return false;
if (key == Qt::Key_Escape) {
reject();
return true;
}
if (m_expectModifier)
return true;
}
event->accept();
processKey(key, mods);
if ( isNonModifierKey(key) )
accept();
return false;
} else if (event->type() == QEvent::KeyRelease) {
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
COPYQ_LOG(QString("Shortcut key release: %1").arg(keyEvent->key()));
Qt::KeyboardModifiers mods = getModifiers(*keyEvent);
processKey(0, mods);
return true;
}
return false;
}
bool ShortcutDialog::eventFilter(QObject *object, QEvent *event)
{
if (object != ui->lineEditShortcut)
return QDialog::eventFilter(object, event);
if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
auto keyEvent = static_cast<QKeyEvent*>(event);
const int key = createPlatformNativeInterface()->keyCode(*keyEvent);
const int mods = getModifiers(*keyEvent);
if (mods == Qt::NoModifier) {
if (key == Qt::Key_Tab)
return QDialog::eventFilter(object, event);
if (key == Qt::Key_Escape) {
reject();
return true;
}
}
event->accept();
if (event->type() == QEvent::KeyPress) {
COPYQ_LOG(QString("Shortcut key press: %1").arg(keyEvent->key()));
if ( isModifierKey(keyEvent->key()) ) {
processKey(0, mods);
} else {
processKey(key, mods);
accept();
}
} else if (result() != QDialog::Accepted) {
COPYQ_LOG(QString("Shortcut key release: %1").arg(keyEvent->key()));
processKey(0, mods);
}
return true;
}
return QDialog::eventFilter(object, event);
}
ClipboardMonitor::ClipboardMonitor(const QStringList &formats)
: m_clipboard(createPlatformNativeInterface()->clipboard())
, m_formats(formats)
{
const AppConfig config;
m_storeClipboard = config.option<Config::check_clipboard>();
m_clipboardTab = config.option<Config::clipboard_tab>();
m_clipboard->setFormats(formats);
connect( m_clipboard.get(), &PlatformClipboard::changed,
this, &ClipboardMonitor::onClipboardChanged );
#ifdef HAS_MOUSE_SELECTIONS
m_storeSelection = config.option<Config::check_selection>();
m_clipboardToSelection = config.option<Config::copy_clipboard>();
m_selectionToClipboard = config.option<Config::copy_selection>();
onClipboardChanged(ClipboardMode::Selection);
#endif
onClipboardChanged(ClipboardMode::Clipboard);
}
void ClipboardMonitor::checkClipboard(QClipboard::Mode mode)
{
#ifdef COPYQ_WS_X11
m_x11->cancelSynchronization();
#endif
// Check clipboard after interval because someone is updating it very quickly.
bool needToWait = m_updateTimer->isActive();
if (mode == QClipboard::Clipboard)
m_needCheckClipboard = needToWait;
#ifdef COPYQ_WS_X11
else if (mode == QClipboard::Selection)
m_needCheckSelection = needToWait;
#endif
else
return;
m_updateTimer->start();
if (needToWait)
return;
#ifdef COPYQ_WS_X11
if ( mode == QClipboard::Selection && m_x11->isSelectionIncomplete() )
return;
if ( m_x11->maybeResetClipboard(mode) )
return;
#endif
COPYQ_LOG( QString("Checking for new %1 content.")
.arg(mode == QClipboard::Clipboard ? "clipboard" : "selection") );
// get clipboard data
const QMimeData *data = clipboardData(mode);
// data retrieved?
if (!data) {
log( tr("Cannot access clipboard data!"), LogError );
return;
}
// clone only mime types defined by user
#if defined(Q_OS_MAC)
// On OS X, when you copy files in Finder, etc. you get:
// - The file name(s) (not paths) as plain text
// - The file URI(s)
// - The icon (not thumbnail) for the type of item you have in various image formants
// We really only want the URI list, so throw the rest away
QStringList formats = m_formats;
if (data->formats().contains(mimeUriList) && formats.contains(mimeUriList)) {
formats = QStringList() << mimeUriList;
}
QVariantMap data2( cloneData(*data, formats) );
#else
QVariantMap data2( cloneData(*data, m_formats) );
#endif
// add window title of clipboard owner
if ( !data2.contains(mimeOwner) && !data2.contains(mimeWindowTitle) ) {
PlatformPtr platform = createPlatformNativeInterface();
PlatformWindowPtr currentWindow = platform->getCurrentWindow();
if (currentWindow)
data2.insert( mimeWindowTitle, currentWindow->getTitle().toUtf8() );
}
#ifdef COPYQ_WS_X11
m_x11->setData(mode, data2);
if (mode == QClipboard::Clipboard) {
if ( !ownsClipboardData(data2) && m_x11->synchronize(QClipboard::Selection) )
m_needCheckSelection = false;
clipboardChanged(data2);
} else {
data2.insert(mimeClipboardMode, "selection");
if ( !ownsClipboardData(data2) && m_x11->synchronize(QClipboard::Clipboard) )
m_needCheckClipboard = false;
if ( m_x11->hasCheckSelection() )
clipboardChanged(data2);
}
#else /* !COPYQ_WS_X11 */
clipboardChanged(data2);
#endif
}
void ConfigurationManager::setAutostartEnable()
{
PlatformPtr platform = createPlatformNativeInterface();
platform->setAutostartEnabled( AppConfig().option<Config::autostart>() );
}
void ClipboardMonitor::checkClipboard(QClipboard::Mode mode)
{
#ifdef COPYQ_WS_X11
if ( m_x11->isSynchronizing() )
return;
m_x11->synchronizeNone();
#endif
// Check clipboard after interval because someone is updating it very quickly.
bool needToWait = m_updateTimer->isActive();
if (mode == QClipboard::Clipboard)
m_needCheckClipboard = needToWait;
#ifdef COPYQ_WS_X11
else if (mode == QClipboard::Selection)
m_needCheckSelection = needToWait;
#endif
m_updateTimer->start();
if (needToWait)
return;
COPYQ_LOG( QString("Checking for new %1 content.")
.arg(mode == QClipboard::Clipboard ? "clipboard" : "selection") );
#ifdef COPYQ_WS_X11
if (mode == QClipboard::Clipboard) {
if ( QApplication::clipboard()->ownsClipboard() )
return;
} else if (mode == QClipboard::Selection) {
if ( (!m_checksel && !m_copysel) ||
QApplication::clipboard()->ownsSelection() ||
!updateSelection(false) )
{
return;
}
} else {
return;
}
#else /* !COPYQ_WS_X11 */
// check if clipboard data are needed
if (mode != QClipboard::Clipboard || QApplication::clipboard()->ownsClipboard())
return;
#endif
// get clipboard data
const QMimeData *data = clipboardData(mode);
// data retrieved?
if (!data) {
log( tr("Cannot access clipboard data!"), LogError );
return;
}
// clone only mime types defined by user
QMimeData *data2 = cloneData(*data, &m_formats);
// any data found?
if ( data2->formats().isEmpty() ) {
delete data2;
return;
}
// add window title of clipboard owner
PlatformPtr platform = createPlatformNativeInterface();
data2->setData( QString(mimeWindowTitle),
platform->getWindowTitle(platform->getCurrentWindow()).toUtf8() );
#ifdef COPYQ_WS_X11
if (mode == QClipboard::Clipboard) {
if (m_copyclip)
m_x11->synchronize(data2, QClipboard::Selection);
clipboardChanged(mode, data2);
} else {
if (m_copysel)
m_x11->synchronize(data2, QClipboard::Clipboard);
if (m_checksel)
clipboardChanged(mode, data2);
else
delete data2;
}
#else /* !COPYQ_WS_X11 */
clipboardChanged(mode, data2);
#endif
}
void ClipboardMonitor::onClipboardChanged(ClipboardMode mode)
{
QVariantMap data = m_clipboard->data(mode, m_formats);
auto clipboardData = mode == ClipboardMode::Clipboard
? &m_clipboardData : &m_selectionData;
if ( hasSameData(data, *clipboardData) ) {
COPYQ_LOG( QString("Ignoring unchanged %1")
.arg(mode == ClipboardMode::Clipboard ? "clipboard" : "selection") );
return;
}
*clipboardData = data;
COPYQ_LOG( QString("%1 changed, owner is \"%2\"")
.arg(mode == ClipboardMode::Clipboard ? "Clipboard" : "Selection",
getTextData(data, mimeOwner)) );
if (mode != ClipboardMode::Clipboard) {
const QString modeName = mode == ClipboardMode::Selection
? "selection"
: "find buffer";
data.insert(mimeClipboardMode, modeName);
}
// add window title of clipboard owner
if ( !data.contains(mimeOwner) && !data.contains(mimeWindowTitle) ) {
PlatformPtr platform = createPlatformNativeInterface();
PlatformWindowPtr currentWindow = platform->getCurrentWindow();
if (currentWindow)
data.insert( mimeWindowTitle, currentWindow->getTitle().toUtf8() );
}
#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 targetData = mode == ClipboardMode::Clipboard
? &m_selectionData : &m_clipboardData;
const auto targetText = getTextData(*targetData);
emit synchronizeSelection(mode, text, qHash(targetText));
}
}
#endif
// run automatic commands
if ( anySessionOwnsClipboardData(data) ) {
emit clipboardChanged(data, ClipboardOwnership::Own);
} else if ( isClipboardDataHidden(data) ) {
emit clipboardChanged(data, ClipboardOwnership::Hidden);
} else {
const auto defaultTab = m_clipboardTab.isEmpty() ? defaultClipboardTabName() : m_clipboardTab;
setTextData(&data, defaultTab, mimeCurrentTab);
#ifdef HAS_MOUSE_SELECTIONS
if (mode == ClipboardMode::Clipboard ? m_storeClipboard : m_storeSelection) {
#else
if (m_storeClipboard) {
#endif
setTextData(&data, m_clipboardTab, mimeOutputTab);
}
emit clipboardChanged(data, ClipboardOwnership::Foreign);
}
}