You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
866 lines
22 KiB
866 lines
22 KiB
/***************************************************************************
|
|
* Copyright (C) 2005-2008 by Tarek Saidi, Felix Geyer *
|
|
* tarek.saidi@arcor.de *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; version 2 of the License. *
|
|
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with this program; if not, write to the *
|
|
* Free Software Foundation, Inc., *
|
|
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
|
|
***************************************************************************/
|
|
|
|
#include "AutoTypeX11.h"
|
|
|
|
#include "mainwindow.h"
|
|
#include "lib/HelperX11.h"
|
|
#include <QX11Info>
|
|
|
|
#ifndef GLOBAL_AUTOTYPE
|
|
AutoType* autoType = NULL;
|
|
|
|
void initAutoType(KeepassMainWindow* mainWin) {
|
|
autoType = new AutoTypeX11(mainWin);
|
|
}
|
|
#endif
|
|
|
|
AutoTypeAction::AutoTypeAction(AutoTypeActionType t, quint16 d) : type(t), data(d){
|
|
}
|
|
|
|
bool AutoTypeX11::error_detected = false;
|
|
|
|
AutoTypeX11::AutoTypeX11(KeepassMainWindow* mainWin) {
|
|
this->mainWin = mainWin;
|
|
dpy = mainWin->x11Info().display();
|
|
|
|
keysym_table = NULL;
|
|
alt_mask = 0;
|
|
meta_mask = 0;
|
|
altgr_mask = 0;
|
|
altgr_keysym = NoSymbol;
|
|
focused_window = None;
|
|
focused_subwindow = None;
|
|
|
|
ReadKeymap();
|
|
if (!altgr_mask)
|
|
AddModifier(XK_Mode_switch);
|
|
}
|
|
|
|
void AutoTypeX11::perform(IEntryHandle* entry, bool hideWindow, int nr, bool wasLocked){
|
|
QString indexStr;
|
|
if (nr==0)
|
|
indexStr = "Auto-Type:";
|
|
else
|
|
indexStr = QString("Auto-Type-%1:").arg(nr);
|
|
QString str;
|
|
QString comment=entry->comment();
|
|
int c=comment.count(indexStr, Qt::CaseInsensitive);
|
|
if(c>1) {
|
|
qWarning("More than one 'Auto-Type:' key sequence found.\nAllowed is only one per entry.");
|
|
return;
|
|
}
|
|
else if (c==1) {
|
|
int start = comment.indexOf(indexStr,0,Qt::CaseInsensitive) + indexStr.length();
|
|
int end = comment.indexOf("\n", start);
|
|
if (end == -1)
|
|
end = comment.length();
|
|
|
|
str=comment.mid(start,end-start).trimmed();
|
|
if (str.isEmpty())
|
|
return;
|
|
}
|
|
else {
|
|
bool usernameEmpty = entry->username().trimmed().isEmpty();
|
|
SecString password=entry->password();
|
|
password.unlock();
|
|
bool passwordEmpty = password.string().trimmed().isEmpty();
|
|
if (usernameEmpty && passwordEmpty)
|
|
return;
|
|
else if (usernameEmpty)
|
|
str="{PASSWORD}{ENTER}";
|
|
else if (passwordEmpty)
|
|
str="{USERNAME}{ENTER}";
|
|
else
|
|
str="{USERNAME}{TAB}{PASSWORD}{ENTER}";
|
|
}
|
|
|
|
QList<AutoTypeAction> Keys;
|
|
for(int i=0;i<str.size();i++){
|
|
if(str[i]=='{'){
|
|
QString tmpl;
|
|
i++;
|
|
while(str[i]!='}' && i<str.size()){
|
|
tmpl += str[i];
|
|
i++;
|
|
}
|
|
if(i>=str.size()){
|
|
qWarning("Syntax Error in Auto-Type sequence near character %d\nFound '{' without closing '}'", i+10);
|
|
return;
|
|
}
|
|
templateToKeysyms(tmpl.toLower(),Keys,entry);
|
|
continue;
|
|
}
|
|
else{
|
|
Keys << AutoTypeAction(TypeKey, str[i].unicode());
|
|
}
|
|
}
|
|
|
|
if (hideWindow)
|
|
mainWin->hide();
|
|
|
|
QApplication::processEvents();
|
|
sleepTime(config->autoTypePreGap());
|
|
|
|
QString type;
|
|
for(int i=0;i<Keys.size();i++){
|
|
if (Keys[i].type==TypeKey){
|
|
SendKeyPressedEvent(Keys[i].data, 0);
|
|
sleepKeyStrokeDelay();
|
|
}
|
|
else if (Keys[i].type==Delay){
|
|
QApplication::processEvents();
|
|
sleepTime(Keys[i].data);
|
|
}
|
|
}
|
|
|
|
if (config->lockOnMinimize()){
|
|
if (hideWindow || wasLocked){
|
|
if ( !(config->showSysTrayIcon() && config->minimizeTray()) )
|
|
mainWin->showMinimized();
|
|
else
|
|
mainWin->OnUnLockWorkspace();
|
|
}
|
|
}
|
|
else{
|
|
if (hideWindow && !(config->showSysTrayIcon() && config->minimizeTray()) )
|
|
mainWin->showMinimized();
|
|
if (wasLocked)
|
|
mainWin->OnUnLockWorkspace();
|
|
}
|
|
}
|
|
|
|
void AutoTypeX11::sleepTime(int msec){
|
|
if (msec==0) return;
|
|
timespec timeOut, remains;
|
|
timeOut.tv_sec = msec/1000;
|
|
timeOut.tv_nsec = (msec%1000)*1000000;
|
|
nanosleep(&timeOut, &remains);
|
|
}
|
|
|
|
void AutoTypeX11::templateToKeysyms(const QString& tmpl, QList<AutoTypeAction>& keys,IEntryHandle* entry){
|
|
//tmpl must be lower case!!!
|
|
if(!tmpl.compare("title")){
|
|
stringToKeysyms(entry->title(),keys);
|
|
return;
|
|
}
|
|
if(!tmpl.compare("username")){
|
|
stringToKeysyms(entry->username(),keys);
|
|
return;
|
|
}
|
|
if(!tmpl.compare("url")){
|
|
stringToKeysyms(entry->url(),keys);
|
|
return;
|
|
}
|
|
if(!tmpl.compare("password")){
|
|
SecString password=entry->password();
|
|
password.unlock();
|
|
stringToKeysyms(password,keys);
|
|
return;
|
|
}
|
|
if(!tmpl.compare("space")){
|
|
keys << AutoTypeAction(TypeKey, HelperX11::getKeysym(' '));
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("backspace") || !tmpl.compare("bs") || !tmpl.compare("bksp")){
|
|
keys << AutoTypeAction(TypeKey, XK_BackSpace);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("break")){
|
|
keys << AutoTypeAction(TypeKey, XK_Break);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("capslock")){
|
|
keys << AutoTypeAction(TypeKey, XK_Caps_Lock);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("del") || !tmpl.compare("delete")){
|
|
keys << AutoTypeAction(TypeKey, XK_Delete);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("end")){
|
|
keys << AutoTypeAction(TypeKey, XK_End);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("enter")){
|
|
keys << AutoTypeAction(TypeKey, XK_Return);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("esc")){
|
|
keys << AutoTypeAction(TypeKey, XK_Escape);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("help")){
|
|
keys << AutoTypeAction(TypeKey, XK_Help);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("home")){
|
|
keys << AutoTypeAction(TypeKey, XK_Home);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("insert") || !tmpl.compare("ins")){
|
|
keys << AutoTypeAction(TypeKey, XK_Insert);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("numlock")){
|
|
keys << AutoTypeAction(TypeKey, XK_Num_Lock);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("scroll")){
|
|
keys << AutoTypeAction(TypeKey, XK_Scroll_Lock);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("pgdn")){
|
|
keys << AutoTypeAction(TypeKey, XK_Page_Down);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("pgup")){
|
|
keys << AutoTypeAction(TypeKey, XK_Page_Up);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("prtsc")){
|
|
keys << AutoTypeAction(TypeKey, XK_3270_PrintScreen);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("up")){
|
|
keys << AutoTypeAction(TypeKey, XK_Up);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("down")){
|
|
keys << AutoTypeAction(TypeKey, XK_Down);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("left")){
|
|
keys << AutoTypeAction(TypeKey, XK_Left);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("right")){
|
|
keys << AutoTypeAction(TypeKey, XK_Right);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f1")){
|
|
keys << AutoTypeAction(TypeKey, XK_F1);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f2")){
|
|
keys << AutoTypeAction(TypeKey, XK_F2);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f3")){
|
|
keys << AutoTypeAction(TypeKey, XK_F3);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f4")){
|
|
keys << AutoTypeAction(TypeKey, XK_F4);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f5")){
|
|
keys << AutoTypeAction(TypeKey, XK_F5);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f6")){
|
|
keys << AutoTypeAction(TypeKey, XK_F6);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f7")){
|
|
keys << AutoTypeAction(TypeKey, XK_F7);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f8")){
|
|
keys << AutoTypeAction(TypeKey, XK_F8);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f9")){
|
|
keys << AutoTypeAction(TypeKey, XK_F9);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f10")){
|
|
keys << AutoTypeAction(TypeKey, XK_F10);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f11")){
|
|
keys << AutoTypeAction(TypeKey, XK_F11);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f12")){
|
|
keys << AutoTypeAction(TypeKey, XK_F12);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f13")){
|
|
keys << AutoTypeAction(TypeKey, XK_F13);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f14")){
|
|
keys << AutoTypeAction(TypeKey, XK_F14);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f15")){
|
|
keys << AutoTypeAction(TypeKey, XK_F15);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("f16")){
|
|
keys << AutoTypeAction(TypeKey, XK_F16);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("add") || !tmpl.compare("plus")){
|
|
keys << AutoTypeAction(TypeKey, HelperX11::getKeysym('+'));
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("subtract")){
|
|
keys << AutoTypeAction(TypeKey, HelperX11::getKeysym('-'));
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("multiply")){
|
|
keys << AutoTypeAction(TypeKey, HelperX11::getKeysym('+'));
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("divide")){
|
|
keys << AutoTypeAction(TypeKey, HelperX11::getKeysym('/'));
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("at")){
|
|
keys << AutoTypeAction(TypeKey, HelperX11::getKeysym('@'));
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("percent")){
|
|
keys << AutoTypeAction(TypeKey, HelperX11::getKeysym('%'));
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("caret")){
|
|
keys << AutoTypeAction(TypeKey, HelperX11::getKeysym('^'));
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("tilde")){
|
|
keys << AutoTypeAction(TypeKey, HelperX11::getKeysym('~'));
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("leftbrace")){
|
|
keys << AutoTypeAction(TypeKey, HelperX11::getKeysym('{'));
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("rightbrace")){
|
|
keys << AutoTypeAction(TypeKey, HelperX11::getKeysym('}'));
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("leftparen")){
|
|
keys << AutoTypeAction(TypeKey, HelperX11::getKeysym('('));
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("rightparen")){
|
|
keys << AutoTypeAction(TypeKey, HelperX11::getKeysym(')'));
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("winl")){
|
|
keys << AutoTypeAction(TypeKey, XK_Super_L);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("winr")){
|
|
keys << AutoTypeAction(TypeKey, XK_Super_R);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("win")){
|
|
keys << AutoTypeAction(TypeKey, XK_Super_L);
|
|
return;
|
|
}
|
|
|
|
if(!tmpl.compare("tab")){
|
|
keys << AutoTypeAction(TypeKey, XK_Tab);
|
|
return;
|
|
}
|
|
|
|
if(tmpl.startsWith("delay ") && tmpl.length()>6){
|
|
bool ok;
|
|
quint16 delay = tmpl.right(tmpl.length()-6).toInt(&ok);
|
|
if (ok && delay>0 && delay<=10000)
|
|
keys << AutoTypeAction(Delay, delay);
|
|
}
|
|
}
|
|
|
|
void AutoTypeX11::stringToKeysyms(const QString& string,QList<AutoTypeAction>& KeySymList){
|
|
for(int i=0; i<string.length();i++)
|
|
KeySymList << AutoTypeAction(TypeKey, HelperX11::getKeysym(string[i]));
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------
|
|
// The following code is taken from xvkbd and has been slightly modified.
|
|
// ----------------------------------------------------------------------
|
|
|
|
/*
|
|
* xvkbd - Virtual Keyboard for X Window System
|
|
* (Version 3.0, 2008-05-05)
|
|
*
|
|
* Copyright (C) 2000-2008 by Tom Sato <VEF00200@nifty.ne.jp>
|
|
* http://homepage3.nifty.com/tsato/
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
* See the GNU General Public License for more details.
|
|
*/
|
|
|
|
/*
|
|
* Insert a specified keysym to unused position in the keymap table.
|
|
* This will be called to add required keysyms on-the-fly.
|
|
* if the second parameter is TRUE, the keysym will be added to the
|
|
* non-shifted position - this may be required for modifier keys
|
|
* (e.g. Mode_switch) and some special keys (e.g. F20).
|
|
*/
|
|
int AutoTypeX11::AddKeysym(KeySym keysym, bool top)
|
|
{
|
|
int keycode, pos, max_pos, inx, phase;
|
|
|
|
if (top) {
|
|
max_pos = 0;
|
|
} else {
|
|
max_pos = keysym_per_keycode - 1;
|
|
if (4 <= max_pos) max_pos = 3;
|
|
if (2 <= max_pos && altgr_keysym != XK_Mode_switch) max_pos = 1;
|
|
}
|
|
|
|
for (phase = 0; phase < 2; phase++) {
|
|
for (keycode = max_keycode; min_keycode <= keycode; keycode--) {
|
|
for (pos = max_pos; 0 <= pos; pos--) {
|
|
inx = (keycode - min_keycode) * keysym_per_keycode;
|
|
if ((phase != 0 || keysym_table[inx] == NoSymbol) && keysym_table[inx] < 0xFF00) {
|
|
/* In the first phase, to avoid modifing existing keys, */
|
|
/* add the keysym only to the keys which has no keysym in the first position. */
|
|
/* If no place fuond in the first phase, add the keysym for any keys except */
|
|
/* for modifier keys and other special keys */
|
|
if (keysym_table[inx + pos] == NoSymbol) {
|
|
keysym_table[inx + pos] = keysym;
|
|
XChangeKeyboardMapping(dpy, keycode, keysym_per_keycode, &keysym_table[inx], 1);
|
|
XFlush(dpy);
|
|
return keycode;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
qWarning("Couldn't add \"%s\" to keymap", XKeysymToString(keysym));
|
|
return NoSymbol;
|
|
}
|
|
|
|
/*
|
|
* Add the specified key as a new modifier.
|
|
* This is used to use Mode_switch (AltGr) as a modifier.
|
|
*/
|
|
void AutoTypeX11::AddModifier(KeySym keysym)
|
|
{
|
|
XModifierKeymap *modifiers;
|
|
int keycode, i, pos;
|
|
|
|
keycode = XKeysymToKeycode(dpy, keysym);
|
|
if (keycode == NoSymbol) keycode = AddKeysym(keysym, TRUE);
|
|
|
|
modifiers = XGetModifierMapping(dpy);
|
|
for (i = 7; 3 < i; i--) {
|
|
if (modifiers->modifiermap[i * modifiers->max_keypermod] == NoSymbol
|
|
|| ((keysym_table[(modifiers->modifiermap[i * modifiers->max_keypermod]
|
|
- min_keycode) * keysym_per_keycode]) == XK_ISO_Level3_Shift
|
|
&& keysym == XK_Mode_switch))
|
|
{
|
|
for (pos = 0; pos < modifiers->max_keypermod; pos++) {
|
|
if (modifiers->modifiermap[i * modifiers->max_keypermod + pos] == NoSymbol) {
|
|
modifiers->modifiermap[i * modifiers->max_keypermod + pos] = keycode;
|
|
XSetModifierMapping(dpy, modifiers);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
qWarning("Couldn't add \"%s\" as modifier", XKeysymToString(keysym));
|
|
}
|
|
|
|
/*
|
|
* Read keyboard mapping and modifier mapping.
|
|
* Keyboard mapping is used to know what keys are in shifted position.
|
|
* Modifier mapping is required because we should know Alt and Meta
|
|
* key are used as which modifier.
|
|
*/
|
|
void AutoTypeX11::ReadKeymap()
|
|
{
|
|
int i;
|
|
int keycode, inx, pos;
|
|
KeySym keysym;
|
|
XModifierKeymap *modifiers;
|
|
int last_altgr_mask;
|
|
|
|
XDisplayKeycodes(dpy, &min_keycode, &max_keycode);
|
|
if (keysym_table != NULL) XFree(keysym_table);
|
|
keysym_table = XGetKeyboardMapping(dpy,
|
|
min_keycode, max_keycode - min_keycode + 1,
|
|
&keysym_per_keycode);
|
|
for (keycode = min_keycode; keycode <= max_keycode; keycode++) {
|
|
/* if the first keysym is alphabet and the second keysym is NoSymbol,
|
|
it is equivalent to pair of lowercase and uppercase alphabet */
|
|
inx = (keycode - min_keycode) * keysym_per_keycode;
|
|
if (keysym_table[inx + 1] == NoSymbol
|
|
&& ((XK_A <= keysym_table[inx] && keysym_table[inx] <= XK_Z)
|
|
|| (XK_a <= keysym_table[inx] && keysym_table[inx] <= XK_z)))
|
|
{
|
|
if (XK_A <= keysym_table[inx] && keysym_table[inx] <= XK_Z)
|
|
keysym_table[inx] = keysym_table[inx] - XK_A + XK_a;
|
|
keysym_table[inx + 1] = keysym_table[inx] - XK_a + XK_A;
|
|
}
|
|
}
|
|
|
|
last_altgr_mask = altgr_mask;
|
|
alt_mask = 0;
|
|
meta_mask = 0;
|
|
altgr_mask = 0;
|
|
altgr_keysym = NoSymbol;
|
|
modifiers = XGetModifierMapping(dpy);
|
|
for (i = 0; i < 8; i++) {
|
|
for (pos = 0; pos < modifiers->max_keypermod; pos++) {
|
|
keycode = modifiers->modifiermap[i * modifiers->max_keypermod + pos];
|
|
if (keycode < min_keycode || max_keycode < keycode) continue;
|
|
|
|
keysym = keysym_table[(keycode - min_keycode) * keysym_per_keycode];
|
|
if (keysym == XK_Alt_L || keysym == XK_Alt_R) {
|
|
alt_mask = 1 << i;
|
|
} else if (keysym == XK_Meta_L || keysym == XK_Meta_R) {
|
|
meta_mask = 1 << i;
|
|
} else if (keysym == XK_Mode_switch) {
|
|
if (altgr_keysym == XK_ISO_Level3_Shift) {
|
|
} else {
|
|
altgr_mask = 0x0101 << i;
|
|
/* I don't know why, but 0x2000 was required for mod3 on my Linux box */
|
|
altgr_keysym = keysym;
|
|
}
|
|
} else if (keysym == XK_ISO_Level3_Shift) {
|
|
/* if no Mode_switch, try to use ISO_Level3_Shift instead */
|
|
/* however, it may not work as intended - I don't know why */
|
|
altgr_mask = 1 << i;
|
|
altgr_keysym = keysym;
|
|
}
|
|
}
|
|
}
|
|
XFreeModifiermap(modifiers);
|
|
}
|
|
|
|
/*
|
|
* Send event to the focused window.
|
|
* If input focus is specified explicitly, select the window
|
|
* before send event to the window.
|
|
*/
|
|
void AutoTypeX11::SendEvent(XKeyEvent *event)
|
|
{
|
|
static bool first = TRUE;
|
|
|
|
XSync(event->display, FALSE);
|
|
int (*oldHandler) (Display*, XErrorEvent*) = XSetErrorHandler(MyErrorHandler);
|
|
|
|
error_detected = FALSE;
|
|
if (focused_window != None) {
|
|
/* set input focus if input focus is set explicitly */
|
|
XSetInputFocus(event->display, focused_window, RevertToParent, CurrentTime);
|
|
XSync(event->display, FALSE);
|
|
}
|
|
if (!error_detected) {
|
|
Window root, child, w;
|
|
int root_x, root_y, x, y;
|
|
unsigned int mask;
|
|
int revert_to;
|
|
|
|
w = None;
|
|
first = FALSE;
|
|
|
|
w = focused_subwindow;
|
|
if (w == None)
|
|
XGetInputFocus(event->display, &w, &revert_to);
|
|
|
|
if (w != None) {
|
|
XQueryPointer(event->display, w,
|
|
&root, &child, &root_x, &root_y, &x, &y, &mask);
|
|
XWarpPointer(event->display, None, w, 0, 0, 0, 0, 1, 1);
|
|
XFlush(event->display);
|
|
}
|
|
|
|
XTestFakeKeyEvent(event->display, event->keycode, event->type == KeyPress, 0);
|
|
XFlush(event->display);
|
|
|
|
if (w != None) {
|
|
XWarpPointer(event->display, None, root, 0, 0, 0, 0, root_x, root_y);
|
|
XFlush(event->display);
|
|
}
|
|
} else {
|
|
XTestFakeKeyEvent(event->display, event->keycode, event->type == KeyPress, 0);
|
|
XFlush(event->display);
|
|
}
|
|
|
|
if (error_detected) {
|
|
/* reset focus because focused window is (probably) no longer exist */
|
|
focused_window = None;
|
|
focused_subwindow = None;
|
|
}
|
|
|
|
XSetErrorHandler(oldHandler);
|
|
}
|
|
|
|
/*
|
|
* Send sequence of KeyPressed/KeyReleased events to the focused
|
|
* window to simulate keyboard. If modifiers (shift, control, etc)
|
|
* are set ON, many events will be sent.
|
|
*/
|
|
void AutoTypeX11::SendKeyPressedEvent(KeySym keysym, unsigned int shift)
|
|
{
|
|
Window cur_focus;
|
|
int revert_to;
|
|
XKeyEvent event;
|
|
int keycode;
|
|
int phase, inx;
|
|
bool found;
|
|
|
|
if (focused_subwindow != None)
|
|
cur_focus = focused_subwindow;
|
|
else
|
|
XGetInputFocus(dpy, &cur_focus, &revert_to);
|
|
|
|
found = FALSE;
|
|
keycode = 0;
|
|
if (keysym != NoSymbol) {
|
|
for (phase = 0; phase < 2; phase++) {
|
|
for (keycode = min_keycode; !found && (keycode <= max_keycode); keycode++) {
|
|
/* Determine keycode for the keysym: we use this instead
|
|
of XKeysymToKeycode() because we must know shift_state, too */
|
|
inx = (keycode - min_keycode) * keysym_per_keycode;
|
|
if (keysym_table[inx] == keysym) {
|
|
shift &= ~altgr_mask;
|
|
if (keysym_table[inx + 1] != NoSymbol) shift &= ~ShiftMask;
|
|
found = TRUE;
|
|
break;
|
|
} else if (keysym_table[inx + 1] == keysym) {
|
|
shift &= ~altgr_mask;
|
|
shift |= ShiftMask;
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if (!found && altgr_mask && 3 <= keysym_per_keycode) {
|
|
for (keycode = min_keycode; !found && (keycode <= max_keycode); keycode++) {
|
|
inx = (keycode - min_keycode) * keysym_per_keycode;
|
|
if (keysym_table[inx + 2] == keysym) {
|
|
shift &= ~ShiftMask;
|
|
shift |= altgr_mask;
|
|
found = TRUE;
|
|
break;
|
|
} else if (4 <= keysym_per_keycode && keysym_table[inx + 3] == keysym) {
|
|
shift |= ShiftMask | altgr_mask;
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (found) break;
|
|
|
|
if (0xF000 <= keysym) {
|
|
/* for special keys such as function keys,
|
|
first try to add it in the non-shifted position of the keymap */
|
|
if (AddKeysym(keysym, TRUE) == NoSymbol) AddKeysym(keysym, FALSE);
|
|
} else {
|
|
AddKeysym(keysym, FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
event.display = dpy;
|
|
event.window = cur_focus;
|
|
event.root = RootWindow(event.display, DefaultScreen(event.display));
|
|
event.subwindow = None;
|
|
event.time = CurrentTime;
|
|
event.x = 1;
|
|
event.y = 1;
|
|
event.x_root = 1;
|
|
event.y_root = 1;
|
|
event.same_screen = TRUE;
|
|
|
|
Window root, child;
|
|
int root_x, root_y, x, y;
|
|
unsigned int mask;
|
|
|
|
XQueryPointer(dpy, event.root, &root, &child, &root_x, &root_y, &x, &y, &mask);
|
|
|
|
event.type = KeyRelease;
|
|
event.state = 0;
|
|
if (mask & ControlMask) {
|
|
event.keycode = XKeysymToKeycode(dpy, XK_Control_L);
|
|
SendEvent(&event);
|
|
}
|
|
if (mask & alt_mask) {
|
|
event.keycode = XKeysymToKeycode(dpy, XK_Alt_L);
|
|
SendEvent(&event);
|
|
}
|
|
if (mask & meta_mask) {
|
|
event.keycode = XKeysymToKeycode(dpy, XK_Meta_L);
|
|
SendEvent(&event);
|
|
}
|
|
if (mask & altgr_mask) {
|
|
event.keycode = XKeysymToKeycode(dpy, altgr_keysym);
|
|
SendEvent(&event);
|
|
}
|
|
if (mask & ShiftMask) {
|
|
event.keycode = XKeysymToKeycode(dpy, XK_Shift_L);
|
|
SendEvent(&event);
|
|
}
|
|
if (mask & LockMask) {
|
|
event.keycode = XKeysymToKeycode(dpy, XK_Caps_Lock);
|
|
SendEvent(&event);
|
|
}
|
|
|
|
event.type = KeyPress;
|
|
event.state = 0;
|
|
if (shift & ControlMask) {
|
|
event.keycode = XKeysymToKeycode(dpy, XK_Control_L);
|
|
SendEvent(&event);
|
|
event.state |= ControlMask;
|
|
}
|
|
if (shift & alt_mask) {
|
|
event.keycode = XKeysymToKeycode(dpy, XK_Alt_L);
|
|
SendEvent(&event);
|
|
event.state |= alt_mask;
|
|
}
|
|
if (shift & meta_mask) {
|
|
event.keycode = XKeysymToKeycode(dpy, XK_Meta_L);
|
|
SendEvent(&event);
|
|
event.state |= meta_mask;
|
|
}
|
|
if (shift & altgr_mask) {
|
|
event.keycode = XKeysymToKeycode(dpy, altgr_keysym);
|
|
SendEvent(&event);
|
|
event.state |= altgr_mask;
|
|
}
|
|
if (shift & ShiftMask) {
|
|
event.keycode = XKeysymToKeycode(dpy, XK_Shift_L);
|
|
SendEvent(&event);
|
|
event.state |= ShiftMask;
|
|
}
|
|
|
|
if (keysym != NoSymbol) { /* send event for the key itself */
|
|
event.keycode = found ? keycode : XKeysymToKeycode(dpy, keysym);
|
|
if (event.keycode == NoSymbol) {
|
|
if ((keysym & ~0x7f) == 0 && isprint(keysym))
|
|
qWarning("No such key: %c", (char)keysym);
|
|
else if (XKeysymToString(keysym) != NULL)
|
|
qWarning("No such key: keysym=%s (0x%lX)", XKeysymToString(keysym), (long)keysym);
|
|
else
|
|
qWarning("No such key: keysym=0x%lX", (long)keysym);
|
|
} else {
|
|
SendEvent(&event);
|
|
event.type = KeyRelease;
|
|
SendEvent(&event);
|
|
}
|
|
}
|
|
|
|
event.type = KeyRelease;
|
|
if (shift & ShiftMask) {
|
|
event.keycode = XKeysymToKeycode(dpy, XK_Shift_L);
|
|
SendEvent(&event);
|
|
event.state &= ~ShiftMask;
|
|
}
|
|
if (shift & altgr_mask) {
|
|
event.keycode = XKeysymToKeycode(dpy, altgr_keysym);
|
|
SendEvent(&event);
|
|
event.state &= ~altgr_mask;
|
|
}
|
|
if (shift & meta_mask) {
|
|
event.keycode = XKeysymToKeycode(dpy, XK_Meta_L);
|
|
SendEvent(&event);
|
|
event.state &= ~meta_mask;
|
|
}
|
|
if (shift & alt_mask) {
|
|
event.keycode = XKeysymToKeycode(dpy, XK_Alt_L);
|
|
SendEvent(&event);
|
|
event.state &= ~alt_mask;
|
|
}
|
|
if (shift & ControlMask) {
|
|
event.keycode = XKeysymToKeycode(dpy, XK_Control_L);
|
|
SendEvent(&event);
|
|
event.state &= ~ControlMask;
|
|
}
|
|
}
|
|
|
|
int AutoTypeX11::MyErrorHandler(Display *my_dpy, XErrorEvent *event)
|
|
{
|
|
char msg[200];
|
|
|
|
error_detected = TRUE;
|
|
if (event->error_code == BadWindow) {
|
|
return 0;
|
|
}
|
|
XGetErrorText(my_dpy, event->error_code, msg, sizeof(msg) - 1);
|
|
qWarning("X error trapped: %s, request-code=%d\n", msg, event->request_code);
|
|
return 0;
|
|
}
|
|
|