void KwmEmitKeystroke(modifiers Mod, std::string Key)
{
CGEventFlags Flags = 0;
if(Mod.CmdKey)
Flags |= kCGEventFlagMaskCommand;
if(Mod.CtrlKey)
Flags |= kCGEventFlagMaskControl;
if(Mod.AltKey)
Flags |= kCGEventFlagMaskAlternate;
if(Mod.ShiftKey)
Flags |= kCGEventFlagMaskShift;
CGKeyCode Keycode;
bool Result = GetLayoutIndependentKeycode(Key, &Keycode);
if(!Result)
Result = KeycodeForChar(Key[0], &Keycode);
if(Result)
{
CGEventRef EventKeyDown = CGEventCreateKeyboardEvent(NULL, Keycode, true);
CGEventRef EventKeyUp = CGEventCreateKeyboardEvent(NULL, Keycode, false);
CGEventSetFlags(EventKeyDown, Flags);
CGEventSetFlags(EventKeyUp, Flags);
CGEventPost(kCGHIDEventTap, EventKeyDown);
CGEventPost(kCGHIDEventTap, EventKeyUp);
CFRelease(EventKeyDown);
CFRelease(EventKeyUp);
}
}
void sendControl(int kc) {
CGEventSourceRef src = NULL;
// CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
CGEventRef down, up;
down = CGEventCreateKeyboardEvent(src,(CGKeyCode)kc, true);
CGEventSetFlags(down,kCGEventFlagMaskControl);
up = CGEventCreateKeyboardEvent(src,(CGKeyCode)kc, false);
CGEventSetFlags(up,kCGEventFlagMaskControl);
CGEventPost(kCGSessionEventTap, down);
CGEventPost(kCGSessionEventTap, up);
CFRelease(down);
CFRelease(up);
}
CGEventRef tapcallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void* refcon){
CGEventFlags flags = CGEventGetFlags(event);
for(int i = 1; i < DEV_MAX; i++)
flags |= keyboard[i].eflags;
CGEventSetFlags(event, flags);
return event;
}
bool pws_os::MacSimulateApplicationSwitch(unsigned delayMS)
{
enum { VK_CMD = 55, VK_TAB = 48 };
struct {
CGKeyCode virtualKey;
bool down;
bool mask;
} KeySequence[]={ {VK_CMD, true, true},
{VK_TAB, true, true},
{VK_TAB, false, true},
{VK_CMD, false, false}
};
for (size_t idx = 0; idx < NumberOf(KeySequence); ++idx) {
CGEventRef keystroke = CGEventCreateKeyboardEvent(NULL, KeySequence[idx].virtualKey, KeySequence[idx].down);
if (keystroke) {
if (KeySequence[idx].mask) {
CGEventSetFlags(keystroke, kCGEventFlagMaskCommand);
}
CGEventPost(kCGSessionEventTap, keystroke);
CFRelease(keystroke);
pws_os::sleep_ms(delayMS);
}
else {
return false;
}
}
return true;
}
void toggleKeyCode(MMKeyCode code, const bool down, MMKeyFlags flags)
{
#if defined(IS_MACOSX)
CGEventRef keyEvent = CGEventCreateKeyboardEvent(NULL,
(CGKeyCode)code, down);
assert(keyEvent != NULL);
CGEventSetType(keyEvent, down ? kCGEventKeyDown : kCGEventKeyUp);
CGEventSetFlags(keyEvent, flags);
CGEventPost(kCGSessionEventTap, keyEvent);
CFRelease(keyEvent);
#elif defined(IS_WINDOWS)
const DWORD dwFlags = down ? 0 : KEYEVENTF_KEYUP;
/* Parse modifier keys. */
if (flags & MOD_META) WIN32_KEY_EVENT_WAIT(K_META, dwFlags);
if (flags & MOD_ALT) WIN32_KEY_EVENT_WAIT(K_ALT, dwFlags);
if (flags & MOD_CONTROL) WIN32_KEY_EVENT_WAIT(K_CONTROL, dwFlags);
if (flags & MOD_SHIFT) WIN32_KEY_EVENT_WAIT(K_SHIFT, dwFlags);
win32KeyEvent(code, dwFlags);
#elif defined(USE_X11)
Display *display = XGetMainDisplay();
const Bool is_press = down ? True : False; /* Just to be safe. */
/* Parse modifier keys. */
if (flags & MOD_META) X_KEY_EVENT_WAIT(display, K_META, is_press);
if (flags & MOD_ALT) X_KEY_EVENT_WAIT(display, K_ALT, is_press);
if (flags & MOD_CONTROL) X_KEY_EVENT_WAIT(display, K_CONTROL, is_press);
if (flags & MOD_SHIFT) X_KEY_EVENT_WAIT(display, K_SHIFT, is_press);
X_KEY_EVENT(display, code, is_press);
#endif
}
void keyretrigger(usbdevice* kb, int scancode){
CGEventRef kp = CGEventCreateKeyboardEvent(kb->event, scancode, 1);
CGEventSetIntegerValueField(kp, kCGKeyboardEventAutorepeat, 1);
CGEventSetFlags(kp, kb->eflags);
CGEventPost(kCGHIDEventTap, kp);
CFRelease(kp);
}
void ActivateScreen(screen_info *Screen)
{
CGPoint CursorPos = GetCursorPos();
CGPoint ClickPos = CGPointMake(Screen->X, Screen->Y);
CGEventRef MoveEvent = CGEventCreateMouseEvent(NULL, kCGEventLeftMouseDown, ClickPos, kCGMouseButtonLeft);
CGEventSetFlags(MoveEvent, 0);
CGEventPost(kCGHIDEventTap, MoveEvent);
CFRelease(MoveEvent);
MoveEvent = CGEventCreateMouseEvent(NULL, kCGEventLeftMouseUp, ClickPos, kCGMouseButtonLeft);
CGEventSetFlags(MoveEvent, 0);
CGEventPost(kCGHIDEventTap, MoveEvent);
CFRelease(MoveEvent);
MoveEvent = CGEventCreateMouseEvent(NULL, kCGEventMouseMoved, CursorPos, kCGMouseButtonLeft);
CGEventSetFlags(MoveEvent, 0);
CGEventPost(kCGHIDEventTap, MoveEvent);
CFRelease(MoveEvent);
}
void os_keypress(usbdevice* kb, int scancode, int down){
// Check for modifier keys and update flags
int flags = 0;
if(scancode == KEY_CAPSLOCK){
if(down){
if(!(kb->eflags & kCGEventFlagMaskAlphaShift))
kb->eflags |= kCGEventFlagMaskAlphaShift;
else
kb->eflags &= ~kCGEventFlagMaskAlphaShift;
}
flags = 1;
} else if(scancode == KEY_LEFTSHIFT || scancode == KEY_RIGHTSHIFT){
if(down)
kb->eflags |= kCGEventFlagMaskShift;
else
kb->eflags &= ~kCGEventFlagMaskShift;
flags = 1;
} else if(scancode == KEY_LEFTCTRL || scancode == KEY_RIGHTCTRL){
if(down)
kb->eflags |= kCGEventFlagMaskControl;
else
kb->eflags &= ~kCGEventFlagMaskControl;
flags = 1;
} else if(scancode == KEY_LEFTMETA || scancode == KEY_RIGHTMETA){
if(down)
kb->eflags |= kCGEventFlagMaskCommand;
else
kb->eflags &= ~kCGEventFlagMaskCommand;
flags = 1;
} else if(scancode == KEY_LEFTALT || scancode == KEY_RIGHTALT){
if(down)
kb->eflags |= kCGEventFlagMaskAlternate;
else
kb->eflags &= ~kCGEventFlagMaskAlternate;
flags = 1;
}
CGEventRef kp;
if(flags){
kp = CGEventCreate(kb->event);
CGEventSetType(kp, kCGEventFlagsChanged);
CGEventSetIntegerValueField(kp, kCGKeyboardEventKeycode, scancode);
kb->lastkeypress = -1;
} else {
kp = CGEventCreateKeyboardEvent(kb->event, scancode, down);
kb->lastkeypress = (down ? scancode : -1);
}
kb->keypresstime = 0;
CGEventSetFlags(kp, kb->eflags);
CGEventPost(kCGHIDEventTap, kp);
CFRelease(kp);
}
static void setModifiersFromQNativeEvent(CGEventRef inEvent, const QNativeEvent &event)
{
CGEventFlags flags = 0;
if (event.modifiers.testFlag(Qt::ShiftModifier))
flags |= kCGEventFlagMaskShift;
if (event.modifiers.testFlag(Qt::MetaModifier))
flags |= kCGEventFlagMaskControl;
if (event.modifiers.testFlag(Qt::AltModifier))
flags |= kCGEventFlagMaskAlternate;
if (event.modifiers.testFlag(Qt::ControlModifier))
flags |= kCGEventFlagMaskCommand;
CGEventSetFlags(inEvent, flags);
}
void KwmEmitKeystrokes(std::string Text)
{
CFStringRef TextRef = CFStringCreateWithCString(NULL, Text.c_str(), kCFStringEncodingMacRoman);
CGEventRef EventKeyDown = CGEventCreateKeyboardEvent(NULL, 0, true);
CGEventRef EventKeyUp = CGEventCreateKeyboardEvent(NULL, 0, false);
UniChar OutputBuffer;
for(std::size_t CharIndex = 0; CharIndex < Text.size(); ++CharIndex)
{
CFStringGetCharacters(TextRef, CFRangeMake(CharIndex, 1), &OutputBuffer);
CGEventSetFlags(EventKeyDown, 0);
CGEventKeyboardSetUnicodeString(EventKeyDown, 1, &OutputBuffer);
CGEventPost(kCGHIDEventTap, EventKeyDown);
CGEventSetFlags(EventKeyUp, 0);
CGEventKeyboardSetUnicodeString(EventKeyUp, 1, &OutputBuffer);
CGEventPost(kCGHIDEventTap, EventKeyUp);
}
CFRelease(EventKeyUp);
CFRelease(EventKeyDown);
CFRelease(TextRef);
}
void GiveFocusToScreen(int ScreenIndex)
{
screen_info *Screen = GetDisplayFromScreenID(ScreenIndex);
if(Screen)
{
CGPoint CursorPos = CGPointMake(Screen->X + (Screen->Width / 2),
Screen->Y + (Screen->Height / 2));
CGEventRef MoveEvent = CGEventCreateMouseEvent(NULL, kCGEventLeftMouseDown, CursorPos, kCGMouseButtonLeft);
CGEventSetFlags(MoveEvent, 0);
CGEventPost(kCGHIDEventTap, MoveEvent);
CFRelease(MoveEvent);
DEBUG("GiveFocusToScreen() " << ScreenIndex)
UpdateActiveWindowList(Screen);
tree_node *NewFocusNode = GetFirstLeafNode(Screen->Space[Screen->ActiveSpace].RootNode);
SetWindowFocusByNode(NewFocusNode);
}
}
bool EmulateKeyStrokes(const KeyStroke *KeySequence, size_t num, unsigned delayMS)
{
for (size_t idx = 0; idx < num; ++idx) {
CGEventRef keystroke = CGEventCreateKeyboardEvent(NULL, KeySequence[idx].virtualKey, KeySequence[idx].down);
if (keystroke) {
if (KeySequence[idx].mask) {
CGEventSetFlags(keystroke, kCGEventFlagMaskCommand);
}
CGEventPost(kCGSessionEventTap, keystroke);
CFRelease(keystroke);
if (delayMS)
pws_os::sleep_ms(delayMS);
}
else {
return false;
}
}
return true;
}
CGEventRef myCGEventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon) {
// debug
//fprintf(stderr, "Caught event!\n");
CGEventFlags modifiers = CGEventGetFlags(event);
if ((modifiers & RIGHT_OPT_DOWN) == RIGHT_OPT_DOWN) {
//CGKeyCode keycode = (CGKeyCode)CGEventGetIntegerValueField(event, kCGKeyboardEventKeycode);
//fprintf(stderr, "\nMINE!\n");
//fprintf(stderr, "Type: %i Modifiers: %i Keycode: %i\n", type, (int)modifiers, keycode);
modifiers &= ~RIGHT_OPT_DOWN;
//fprintf(stderr, "Type: %i Modifiers: %i Keycode: %i\n", type, (int)modifiers, keycode);
modifiers |= RIGHT_CTRL_DOWN;
//fprintf(stderr, "Type: %i Modifiers: %i Keycode: %i\n", type, (int)modifiers, keycode);
CGEventSetFlags(event, modifiers);
// debug
//fprintf(stderr, "After swap!\n");
//CGEventFlags modifiers2 = CGEventGetFlags(event);
//CGKeyCode keycode2 = (CGKeyCode)CGEventGetIntegerValueField(event, kCGKeyboardEventKeycode);
//fprintf(stderr, "Type: %i Modifiers: %i Keycode: %i\n", type, (int)modifiers2, keycode2);
}
return event;
}
// This callback will be invoked every time there is a keystroke.
//
CGEventRef myCGEventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon)
{
//printf("called!\n");
// Paranoid sanity check.
if ((type != kCGEventKeyDown) && (type != kCGEventKeyUp) && (type != kCGEventFlagsChanged))
return event;
// The incoming keycode.
CGKeyCode keycode = (CGKeyCode)CGEventGetIntegerValueField(event, kCGKeyboardEventKeycode);
//Control
if(keycode == (CGKeyCode)59||keycode == (CGKeyCode)62){
if(ctr){
ctr = false;
}
else{
ctr = true;
}
}
if(ctr){
CGEventSetFlags(event,NX_CONTROLMASK|CGEventGetFlags(event));
}
//Shift
if(keycode == (CGKeyCode)60||keycode == (CGKeyCode)56){
if(sft){
sft = false;
}
else{
sft = true;
}
}
if(sft){
CGEventSetFlags(event,NX_SHIFTMASK|CGEventGetFlags(event));
}
//Command
if(keycode == (CGKeyCode)55||keycode == (CGKeyCode)54){
if(cmd){
cmd = false;
}
else{
cmd = true;
}
}
if(cmd){
CGEventSetFlags(event,NX_COMMANDMASK|CGEventGetFlags(event));
}
//Option
if(keycode == (CGKeyCode)58||keycode == (CGKeyCode)61){
if(opt){
opt = false;
}
else{
opt = true;
}
}
if(opt){
CGEventSetFlags(event,NX_ALTERNATEMASK|CGEventGetFlags(event));
}
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, (int64_t)keycode);
if (cmd && sft && keycode == 7) {
states = !states;
printf("now states is %i\n", states);
}
//Team T
if(keycode == (CGKeyCode)125||keycode == (CGKeyCode)108)
{
if(dArrow){
dArrow = false;
}
else{
dArrow = true;
}
if(dArrow){
playTeam = 2;
CGEventSetFlags(event,NX_DOWN_ARROW_KEY|CGEventGetFlags(event));
}
}
//Team CT
if(keycode == (CGKeyCode)126||keycode == (CGKeyCode)103)
{
if(uArrow){
uArrow = false;
}
else{
uArrow = true;
}
if(uArrow){
playTeam = 3;
CGEventSetFlags(event,NX_UP_ARROW_KEY|CGEventGetFlags(event));
}
}
// We must return the event for it to be useful.
return event;
}
void
OSXKeyState::fakeKey(const Keystroke& keystroke)
{
switch (keystroke.m_type) {
case Keystroke::kButton: {
KeyButton button = keystroke.m_data.m_button.m_button;
bool keyDown = keystroke.m_data.m_button.m_press;
UInt32 client = keystroke.m_data.m_button.m_client;
CGEventSourceRef source = 0;
CGKeyCode virtualKey = mapKeyButtonToVirtualKey(button);
LOG((CLOG_DEBUG1
" button=0x%04x virtualKey=0x%04x keyDown=%s client=0x%04x",
button, virtualKey, keyDown ? "down" : "up", client));
CGEventRef ref = CGEventCreateKeyboardEvent(
source, virtualKey, keyDown);
if (ref == NULL) {
LOG((CLOG_CRIT "unable to create keyboard event for keystroke"));
return;
}
// persist modifier state.
if (virtualKey == s_shiftVK) {
m_shiftPressed = keyDown;
}
if (virtualKey == s_controlVK) {
m_controlPressed = keyDown;
}
if (virtualKey == s_altVK) {
m_altPressed = keyDown;
}
if (virtualKey == s_superVK) {
m_superPressed = keyDown;
}
if (virtualKey == s_capsLockVK) {
m_capsPressed = keyDown;
}
// set the event flags for special keys
// http://tinyurl.com/pxl742y
CGEventFlags modifiers = 0;
if (m_shiftPressed) {
modifiers |= kCGEventFlagMaskShift;
}
if (m_controlPressed) {
modifiers |= kCGEventFlagMaskControl;
}
if (m_altPressed) {
modifiers |= kCGEventFlagMaskAlternate;
}
if (m_superPressed) {
modifiers |= kCGEventFlagMaskCommand;
}
if (m_capsPressed) {
modifiers |= kCGEventFlagMaskAlphaShift;
}
CGEventSetFlags(ref, modifiers);
CGEventPost(kCGHIDEventTap, ref);
CFRelease(ref);
// add a delay if client data isn't zero
// FIXME -- why?
if (client != 0) {
ARCH->sleep(0.01);
}
break;
}
case Keystroke::kGroup: {
SInt32 group = keystroke.m_data.m_group.m_group;
if (keystroke.m_data.m_group.m_absolute) {
LOG((CLOG_DEBUG1 " group %d", group));
setGroup(group);
}
else {
LOG((CLOG_DEBUG1 " group %+d", group));
setGroup(getEffectiveGroup(pollActiveGroup(), group));
}
break;
}
}
}
CGEventRef myCGEventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon)
{
if ((type != kCGEventKeyDown) && (type != kCGEventKeyUp) && (type != kCGEventFlagsChanged))
{
return event;
}
CGEventFlags flags = CGEventGetFlags(event);
if ((flags & Modifier_CapsLock) != Modifier_CapsLock)
{
return event;
}
CGKeyCode keyCode = (CGKeyCode)CGEventGetIntegerValueField(event, kCGKeyboardEventKeycode);
if (flags == Modifier_CapsLock)
{
switch (keyCode)
{
case kVK_ANSI_A: // Select all, Command+A
case kVK_ANSI_C: // Copy, Command+C
case kVK_ANSI_F: // Find, Command+F
case kVK_ANSI_L: // Location, Command+L
case kVK_ANSI_N: // New, Command+N
case kVK_ANSI_S: // Save, Command+S
case kVK_ANSI_T: // Create Tab, Command+T
case kVK_ANSI_V: // Paste, Command+V
case kVK_ANSI_X: // Cut, Command+X
case kVK_ANSI_Z: // Undo, Command+Z
case kVK_ANSI_Grave: // Next Window, Command+`
case kVK_Tab: // Next Application, Command+Tab
case kVK_Space: // Launcher, Command+Space
CGEventSetFlags(event, Modifier_Command);
break;
case kVK_ANSI_E: // Close Tab, Command+Q
CGEventSetFlags(event, Modifier_Command);
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, kVK_ANSI_W);
break;
case kVK_Escape: // Abort, Control+C
CGEventSetFlags(event, Modifier_Control);
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, kVK_ANSI_C);
break;
case kVK_ANSI_Q: // Previous Tab, Shift+Command+LeftBracket
CGEventSetFlags(event, Modifier_Shift | Modifier_Command);
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, kVK_ANSI_LeftBracket);
break;
case kVK_ANSI_W: // Next Tab, Shift+Command+RightBracket
CGEventSetFlags(event, Modifier_Shift | Modifier_Command);
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, kVK_ANSI_RightBracket);
break;
case kVK_Delete: // Forward Delete
CGEventSetFlags(event, 0);
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, kVK_ForwardDelete);
break;
case kVK_ANSI_Comma: // Page Up, PageUp
CGEventSetFlags(event, 0);
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, kVK_PageUp);
break;
case kVK_ANSI_Period: // Page Down, PageDown
CGEventSetFlags(event, 0);
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, kVK_PageDown);
break;
case kVK_ANSI_I: // Inspect Page, Shift+Command+Inspect
CGEventSetFlags(event, Modifier_Option | Modifier_Command);
break;
}
}
else if (flags == Modifier_ShiftCapsLock)
{
switch (keyCode)
{
case kVK_ANSI_F: // Replace, Shift+Command+F
case kVK_ANSI_Z: // Redo, Shift+Command+Z
case kVK_Tab: // Previous Application, Shift+Command+Tab
CGEventSetFlags(event, Modifier_Shift | Modifier_Command);
break;
case kVK_ANSI_Comma: // Select Previous Page, Shift+PageUp
CGEventSetFlags(event, Modifier_Shift);
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, kVK_PageUp);
break;
case kVK_ANSI_Period: // Select Next Page, Shift+PageDown
CGEventSetFlags(event, Modifier_Shift);
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, kVK_PageDown);
break;
}
}
else if (flags == Modifier_DirectionCapsLock)
{
switch (keyCode)
{
case kVK_UpArrow: // Beginning of Line, Command+Left
CGEventSetFlags(event, Modifier_Direction | Modifier_Command);
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, kVK_LeftArrow);
break;
case kVK_DownArrow: // Beginning of Line, Command+Left
CGEventSetFlags(event, Modifier_Direction | Modifier_Command);
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, kVK_RightArrow);
break;
case kVK_LeftArrow: // Previous Token, Option+Left
case kVK_RightArrow: // Next Token, Option+Right
CGEventSetFlags(event, Modifier_Direction | Modifier_Option);
break;
}
}
else if (flags == Modifier_ShiftDirectionCapsLock)
{
switch (keyCode)
{
case kVK_UpArrow: // Select to Beginning of Line, Shift+Command+Left
CGEventSetFlags(event, Modifier_Shift | Modifier_Direction | Modifier_Command);
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, kVK_LeftArrow);
break;
case kVK_DownArrow: // Select to End of Line, Shift+Command+Left
CGEventSetFlags(event, Modifier_Shift | Modifier_Direction | Modifier_Command);
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, kVK_RightArrow);
break;
}
}
return event;
}
void
COSXKeyState::fakeKey(const Keystroke& keystroke)
{
CGEventRef ref;
switch (keystroke.m_type) {
case Keystroke::kButton:
{
LOG((CLOG_DEBUG1 " %03x (%08x) %s", keystroke.m_data.m_button.m_button, keystroke.m_data.m_button.m_client, keystroke.m_data.m_button.m_press ? "down" : "up"));
// let system figure out character for us
ref = CGEventCreateKeyboardEvent(0, mapKeyButtonToVirtualKey(
keystroke.m_data.m_button.m_button),
keystroke.m_data.m_button.m_press);
if (ref == NULL) {
LOG((CLOG_CRIT "unable to create keyboard event for keystroke"));
}
UInt32 vk = mapKeyButtonToVirtualKey(keystroke.m_data.m_button.m_button);
UInt32 modifierDown = keystroke.m_data.m_button.m_press;
// check the key for specials and store the value (persistent until changed)
if (vk == s_shiftVK) shiftPressed=modifierDown;
if (vk == s_controlVK) controlPressed=modifierDown;
if (vk == s_altVK) altPressed=modifierDown;
if (vk == s_superVK) superPressed=modifierDown;
if (vk == s_capsLockVK) capsPressed=modifierDown;
//Set the event flags for special keys - see following link:
//http://stackoverflow.com/questions/2008126/cgeventpost-possible-bug-when-simulating-keyboard-events
CGEventFlags modifiers = 0;
if (shiftPressed) modifiers |= kCGEventFlagMaskShift;
if (controlPressed) modifiers |= kCGEventFlagMaskControl;
if (altPressed) modifiers |= kCGEventFlagMaskAlternate;
if (superPressed) modifiers |= kCGEventFlagMaskCommand;
if (capsPressed) modifiers |= kCGEventFlagMaskAlphaShift;
CGEventSetFlags(ref, modifiers);
CGEventPost(kCGHIDEventTap, ref);
// add a delay if client data isn't zero
if (keystroke.m_data.m_button.m_client) {
ARCH->sleep(0.01);
}
}
break;
case Keystroke::kGroup:
if (keystroke.m_data.m_group.m_absolute) {
LOG((CLOG_DEBUG1 " group %d", keystroke.m_data.m_group.m_group));
setGroup(keystroke.m_data.m_group.m_group);
}
else {
LOG((CLOG_DEBUG1 " group %+d", keystroke.m_data.m_group.m_group));
setGroup(getEffectiveGroup(pollActiveGroup(),
keystroke.m_data.m_group.m_group));
}
break;
}
}
void QGeneralSettingWidget::TPDP_OnGST(T3K_DEVICE_INFO /*devInfo*/, ResponsePart /*Part*/, unsigned short /*ticktime*/, const char */*partid*/,
unsigned char /*cActionGroup*/, unsigned char cAction, unsigned short /*wFeasibleness*/,
unsigned short /*x*/, unsigned short /*y*/, unsigned short /*w*/, unsigned short /*h*/, float fZoom, const char */*msg*/)
{
if( cAction == t3kgstNoAction || (fZoom == 0.0f || fZoom == 1.0f) /*|| cAction != t3kgstFingersMove*/ )
{
if( g_fZoom != 0.0f && g_fZoom != 1.0f )
{
// end gesture
CGEventRef e = CGEventCreate(NULL);
CGEventSetType(e, 0x1D);
CGEventSetFlags(e, 0x100);
CGEventSetTimestamp(e, 0);
CGEventSetIntegerValueField(e, 0x6E, 0x3E);
CGEventSetIntegerValueField(e, 0x75, 0x00);
CGEventPost(kCGHIDEventTap, e);
CFRelease(e);
g_fZoom = 0.0f;
qDebug() << "end gesture";
}
}
else if( fZoom != 0.0f && fZoom != 1.0f )
{
CGEventRef e = CGEventCreate(NULL);
CGEventSetType(e, 0x1D);
CGEventSetFlags(e, 0x100);
if( g_fZoom == 0.0f || g_fZoom == 1.0f )
{
g_fZoom = fZoom;
qDebug() << "begin gesture : " << g_fZoom;
CGEventSetTimestamp(e, 0);
CGEventSetIntegerValueField(e, 0x6E, 0x3D);
CGEventSetIntegerValueField(e, 0x75, 0x08);
CGEventPost(kCGHIDEventTap, e);
}
else
{
float dZoom = g_fZoom - fZoom;
qDebug() << "=== " << g_fZoom << " " << fZoom << " changed Zoom : " << dZoom;
if( qAbs(dZoom) >= 0.02 && qAbs(dZoom) <= 0.05 )
{
CGEventSetTimestamp(e, 0);
CGEventSetIntegerValueField(e, 0x6E, 0x08);
CGEventSetDoubleValueField(e, 0x71, -dZoom);
CGEventPost(kCGHIDEventTap, e);
}
g_fZoom = fZoom;
}
CFRelease(e);
}
qDebug() << "Zoom : " << fZoom << " " << cAction;
// qDebug() << QString("Gesture : AG(%1), A(%2), F(%3), X(%4), Y(%5), W(%6), H(%7), ZOOM(%8), MSG(%9)").arg(cActionGroup).arg(cAction).arg(wFeasibleness)
// .arg(x).arg(y).arg(w).arg(h).arg(fZoom).arg(msg);
}
void GiveFocusToScreen(unsigned int ScreenIndex, tree_node *FocusNode, bool Mouse, bool UpdateFocus)
{
screen_info *Screen = GetDisplayFromScreenID(ScreenIndex);
if(Screen && Screen != KWMScreen.Current)
{
KWMScreen.PrevSpace = KWMScreen.Current->ActiveSpace;
KWMScreen.Current = Screen;
Screen->ActiveSpace = GetActiveSpaceOfDisplay(Screen);
ShouldActiveSpaceBeManaged();
space_info *Space = GetActiveSpaceOfScreen(Screen);
DEBUG("GiveFocusToScreen() " << ScreenIndex << \
": Space transition ended " << KWMScreen.PrevSpace << \
" -> " << Screen->ActiveSpace);
if(UpdateFocus)
{
if(Space->Initialized && FocusNode)
{
DEBUG("Populated Screen 'Window -f Focus'");
UpdateActiveWindowList(Screen);
FilterWindowList(Screen);
SetWindowFocusByNode(FocusNode);
MoveCursorToCenterOfFocusedWindow();
}
else if(Space->Initialized && Space->RootNode)
{
DEBUG("Populated Screen Key/Mouse Focus");
UpdateActiveWindowList(Screen);
FilterWindowList(Screen);
bool WindowBelowCursor = IsAnyWindowBelowCursor();
if(Mouse && !WindowBelowCursor)
ClearFocusedWindow();
else if(Mouse && WindowBelowCursor)
FocusWindowBelowCursor();
if(!Mouse)
{
if(Space->FocusedWindowID == -1)
{
if(Space->Settings.Mode == SpaceModeBSP)
{
void *FocusNode = NULL;
GetFirstLeafNode(Space->RootNode, (void**)&FocusNode);
Space->FocusedWindowID = ((tree_node*)FocusNode)->WindowID;
}
else if(Space->Settings.Mode == SpaceModeMonocle)
{
if(Space->RootNode->List)
Space->FocusedWindowID = Space->RootNode->List->WindowID;
}
}
FocusWindowByID(Space->FocusedWindowID);
MoveCursorToCenterOfFocusedWindow();
}
}
else
{
if(!Space->Initialized ||
Space->Settings.Mode == SpaceModeFloating ||
!Space->RootNode)
{
DEBUG("Uninitialized Screen");
ClearFocusedWindow();
if(!Mouse)
CGWarpMouseCursorPosition(CGPointMake(Screen->X + (Screen->Width / 2), Screen->Y + (Screen->Height / 2)));
if(Space->Settings.Mode != SpaceModeFloating && !Space->RootNode)
{
CGPoint ClickPos = GetCursorPos();
CGEventRef ClickEvent = CGEventCreateMouseEvent(NULL, kCGEventLeftMouseDown, ClickPos, kCGMouseButtonLeft);
CGEventSetFlags(ClickEvent, 0);
CGEventPost(kCGHIDEventTap, ClickEvent);
CFRelease(ClickEvent);
ClickEvent = CGEventCreateMouseEvent(NULL, kCGEventLeftMouseUp, ClickPos, kCGMouseButtonLeft);
CGEventSetFlags(ClickEvent, 0);
CGEventPost(kCGHIDEventTap, ClickEvent);
CFRelease(ClickEvent);
}
}
}
}
}
}
