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); } } } } } }