Qt::Native::Status sendNativeMouseButtonEvent_Quartz(const QNativeMouseButtonEvent &event)
{
CGPoint pos;
pos.x = event.globalPos.x();
pos.y = event.globalPos.y();
CGEventType type = kCGEventNull;
if (event.button == Qt::LeftButton)
type = (event.clickCount > 0) ? kCGEventLeftMouseDown : kCGEventLeftMouseUp;
else if (event.button == Qt::RightButton)
type = (event.clickCount > 0) ? kCGEventRightMouseDown : kCGEventRightMouseUp;
else
type = (event.clickCount > 0) ? kCGEventOtherMouseDown : kCGEventOtherMouseUp;
// The mouseButton argument to CGEventCreateMouseEvent() is ignored unless the type
// is kCGEventOtherSomething, so defaulting to kCGMouseButtonLeft is fine.
CGMouseButton mouseButton = (type == kCGEventOtherMouseDown || type == kCGEventOtherMouseUp) ?
kCGMouseButtonCenter : kCGMouseButtonLeft;
CGEventRef e = CGEventCreateMouseEvent(0, type, pos, mouseButton);
setModifiersFromQNativeEvent(e, event);
CGEventSetIntegerValueField(e, kCGMouseEventClickState, event.clickCount);
CGEventPost(kCGHIDEventTap, e);
CFRelease(e);
return Qt::Native::Success;
}
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);
}
bool wxUIActionSimulator::MouseDblClick(int button)
{
CGEventType downtype = CGEventTypeForMouseButton(button, true);
CGEventType uptype = CGEventTypeForMouseButton(button, false);
wxCFRef<CGEventRef> event(
CGEventCreateMouseEvent(NULL, downtype, GetMousePosition(), CGButtonForMouseButton(button)));
if ( !event )
return false;
CGEventSetType(event,downtype);
CGEventPost(tap, event);
CGEventSetType(event, uptype);
CGEventPost(tap, event);
CGEventSetIntegerValueField(event, kCGMouseEventClickState, 2);
CGEventSetType(event, downtype);
CGEventPost(tap, event);
CGEventSetType(event, uptype);
CGEventPost(tap, event);
wxCFEventLoop* loop = dynamic_cast<wxCFEventLoop*>(wxEventLoop::GetActive());
if (loop)
loop->SetShouldWaitForEvent(true);
return true;
}
/**
* Special function for sending double clicks, needed for Mac OS X.
* @param button Button to click.
*/
void doubleClick(MMMouseButton button)
{
#if defined(IS_MACOSX)
/* Double click for Mac. */
const CGPoint currentPos = CGPointFromMMPoint(getMousePos());
const CGEventType mouseTypeDown = MMMouseToCGEventType(true, button);
const CGEventType mouseTypeUP = MMMouseToCGEventType(false, button);
CGEventRef event = CGEventCreateMouseEvent(NULL, mouseTypeDown, currentPos, kCGMouseButtonLeft);
/* Set event to double click. */
CGEventSetIntegerValueField(event, kCGMouseEventClickState, 2);
CGEventPost(kCGHIDEventTap, event);
CGEventSetType(event, mouseTypeUP);
CGEventPost(kCGHIDEventTap, event);
CFRelease(event);
#else
/* Double click for everything else. */
clickMouse(button);
microsleep(200);
clickMouse(button);
#endif
}
/**
* Calculate the delta for a mouse move and add them to the event.
* @param event The mouse move event (by ref).
* @param point The new mouse x and y.
*/
void calculateDeltas(CGEventRef *event, MMPoint point)
{
/**
* The next few lines are a workaround for games not detecting mouse moves.
* See this issue for more information:
* https://github.com/octalmage/robotjs/issues/159
*/
CGEventRef get = CGEventCreate(NULL);
CGPoint mouse = CGEventGetLocation(get);
// Calculate the deltas.
int64_t deltaX = point.x - mouse.x;
int64_t deltaY = point.y - mouse.y;
CGEventSetIntegerValueField(*event, kCGMouseEventDeltaX, deltaX);
CGEventSetIntegerValueField(*event, kCGMouseEventDeltaY, deltaY);
CFRelease(get);
}
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);
}
void MouseMac::leftMouseUp(bool isDoubleClick)
{
CGEventRef mouseEv = CGEventCreateMouseEvent(
NULL, kCGEventLeftMouseUp,
getCursorPositionCGPoint(),
kCGMouseButtonLeft);
if (isDoubleClick)
{
CGEventSetIntegerValueField(mouseEv, kCGMouseEventClickState, 2);
}
CGEventPost(kCGHIDEventTap, mouseEv);
CFRelease(mouseEv);
}
CGEventRef remapEvent(CGEventRef event) {
CGKeyCode keycode = (CGKeyCode) CGEventGetIntegerValueField(event, kCGKeyboardEventKeycode);
int newcode = findMapping(keycode);
if (newcode != keycode) {
CGEventSetIntegerValueField(event, kCGKeyboardEventKeycode, newcode);
} else {
printf("Debug: rewrite requested, but no rewrite for this event. Passing as-is!\n");
}
return event;
}
Qt::Native::Status sendNativeMouseWheelEvent_Quartz(const QNativeMouseWheelEvent &event)
{
CGPoint pos;
pos.x = event.globalPos.x();
pos.y = event.globalPos.y();
CGEventRef e = CGEventCreateScrollWheelEvent(0, kCGScrollEventUnitPixel, 1, 0);
CGEventSetIntegerValueField(e, kCGScrollWheelEventDeltaAxis1, event.delta);
CGEventSetLocation(e, pos);
setModifiersFromQNativeEvent(e, event);
CGEventPost(kCGHIDEventTap, e);
CFRelease(e);
return Qt::Native::Success;
}
// This callback will be invoked every time there is a keystroke.
CGEventRef myCGEventCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon) {
CGEventFlags *oldFlags = (CGEventFlags *) refcon;
//Paranoid sanity check.
if ((type != kCGEventKeyDown) && (type != kCGEventKeyUp) && (type !=kCGEventFlagsChanged))
return event;
//The incoming keycode.
CGKeyCode keycode = (CGKeyCode) CGEventGetIntegerValueField( event, kCGKeyboardEventKeycode);
fprintf(stderr, "keycode %x \n" , (int) keycode);
if(keycode == 24) {
fprintf(stderr, "you pressed equals I will make it look like you pressed f \n" );
CGEventSetIntegerValueField( event, kCGKeyboardEventKeycode, 3);
}
return event;
}
void
mouse_multi_click2(size_t num_clicks, CGPoint point)
{
CGEventRef base_event = NEW_EVENT(
kCGEventLeftMouseDown,
point,
kCGMouseButtonLeft
);
CGEventSetIntegerValueField(base_event, kCGMouseEventClickState, num_clicks);
CHANGE(base_event, kCGEventLeftMouseDown);
POST(base_event);
CHANGE(base_event, kCGEventLeftMouseUp);
POSTRELEASE(base_event);
}
void MacOSMouseOStream::doubleClick(pair<uint32_t, uint32_t> mouse, int clickCount) {
#if __APPLE__
CGPoint point = CGPointMake(mouse.first, mouse.second);
CGEventRef theEvent = CGEventCreateMouseEvent(
NULL, kCGEventLeftMouseDown, point, kCGMouseButtonLeft);
ProcessSerialNumber psn = { 0, kNoProcess };
GetFrontProcess( &psn );
CGEventSetIntegerValueField(theEvent, kCGMouseEventClickState, clickCount);
CGEventPostToPSN(&psn, theEvent);
CGEventSetType(theEvent, kCGEventLeftMouseUp);
CGEventPostToPSN(&psn, theEvent);
CGEventSetType(theEvent, kCGEventLeftMouseDown);
CGEventPostToPSN(&psn, theEvent);
CGEventSetType(theEvent, kCGEventLeftMouseUp);
CGEventPostToPSN(&psn, theEvent);
CFRelease(theEvent);
#endif
}
Qt::Native::Status sendNativeMouseButtonEvent_Quartz(const QNativeMouseButtonEvent &event)
{
CGPoint pos;
pos.x = event.globalPos.x();
pos.y = event.globalPos.y();
CGEventType type = 0;
if (event.button == Qt::LeftButton)
type = (event.clickCount > 0) ? kCGEventLeftMouseDown : kCGEventLeftMouseUp;
else if (event.button == Qt::RightButton)
type = (event.clickCount > 0) ? kCGEventRightMouseDown : kCGEventRightMouseUp;
else
type = (event.clickCount > 0) ? kCGEventOtherMouseDown : kCGEventOtherMouseUp;
CGEventRef e = CGEventCreateMouseEvent(0, type, pos, event.button);
setModifiersFromQNativeEvent(e, event);
CGEventSetIntegerValueField(e, kCGMouseEventClickState, event.clickCount);
CGEventPost(kCGHIDEventTap, e);
CFRelease(e);
return Qt::Native::Success;
}
void
COSXScreen::fakeMouseButton(ButtonID id, bool press)
{
NXEventHandle handle = NXOpenEventStatus();
double clickTime = NXClickTime(handle);
if ((ARCH->time() - m_lastDoubleClick) <= clickTime) {
// drop all down and up fakes immedately after a double click.
// TODO: perhaps there is a better way to do this, usually in
// finder, if you tripple click a folder, it will open it and
// then select a folder under the cursor -- and perhaps other
// strange behaviour might happen?
LOG((CLOG_DEBUG1 "dropping mouse button %s",
press ? "press" : "release"));
return;
}
// Buttons are indexed from one, but the button down array is indexed from zero
UInt32 index = id - kButtonLeft;
if (index >= NumButtonIDs) {
return;
}
CGPoint pos;
if (!m_cursorPosValid) {
SInt32 x, y;
getCursorPos(x, y);
}
pos.x = m_xCursor;
pos.y = m_yCursor;
// variable used to detect mouse coordinate differences between
// old & new mouse clicks. Used in double click detection.
SInt32 xDiff = m_xCursor - m_lastSingleClickXCursor;
SInt32 yDiff = m_yCursor - m_lastSingleClickYCursor;
double diff = sqrt(xDiff * xDiff + yDiff * yDiff);
// max sqrt(x^2 + y^2) difference allowed to double click
// since we don't have double click distance in NX APIs
// we define our own defaults.
const double maxDiff = sqrt(2) + 0.0001;
if (press && (id == kButtonLeft) &&
((ARCH->time() - m_lastSingleClick) <= clickTime) &&
diff <= maxDiff) {
LOG((CLOG_DEBUG1 "faking mouse left double click"));
// finder does not seem to detect double clicks from two separate
// CGEventCreateMouseEvent calls. so, if we detect a double click we
// use CGEventSetIntegerValueField to tell the OS.
//
// the caveat here is that findor will see this as a single click
// followed by a double click (even though there should be only a
// double click). this may cause weird behaviour in other apps.
//
// for some reason using the old CGPostMouseEvent function, doesn't
// cause double clicks (though i'm sure it did work at some point).
CGEventRef event = CGEventCreateMouseEvent(
NULL, kCGEventLeftMouseDown, pos, kCGMouseButtonLeft);
CGEventSetIntegerValueField(event, kCGMouseEventClickState, 2);
m_buttonState.set(index, kMouseButtonDown);
CGEventPost(kCGHIDEventTap, event);
CGEventSetType(event, kCGEventLeftMouseUp);
m_buttonState.set(index, kMouseButtonUp);
CGEventPost(kCGHIDEventTap, event);
CFRelease(event);
m_lastDoubleClick = ARCH->time();
}
else {
// ... otherwise, perform a single press or release as normal.
MouseButtonState state = press ? kMouseButtonDown : kMouseButtonUp;
LOG((CLOG_DEBUG1 "faking mouse button %s", press ? "press" : "release"));
MouseButtonEventMapType thisButtonMap = MouseButtonEventMap[index];
CGEventType type = thisButtonMap[state];
CGEventRef event = CGEventCreateMouseEvent(NULL, type, pos, index);
m_buttonState.set(index, state);
CGEventPost(kCGHIDEventTap, event);
CFRelease(event);
m_lastSingleClick = ARCH->time();
m_lastSingleClickXCursor = m_xCursor;
m_lastSingleClickYCursor = m_yCursor;
}
}
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);
}
CGEventRef CGEventCallback(CGEventTapProxy Proxy, CGEventType Type, CGEventRef Event, void *Refcon)
{
switch(Type)
{
case kCGEventTapDisabledByTimeout:
case kCGEventTapDisabledByUserInput:
{
if(!KWMMach.DisableEventTapInternal)
{
DEBUG("Restarting Event Tap");
CGEventTapEnable(KWMMach.EventTap, true);
}
} break;
case kCGEventKeyDown:
{
if(KWMToggles.UseBuiltinHotkeys)
{
hotkey Eventkey = {}, Hotkey = {};
CreateHotkeyFromCGEvent(Event, &Eventkey);
if(HotkeyExists(Eventkey.Mod, Eventkey.Key, &Hotkey, KWMHotkeys.ActiveMode->Name))
{
KWMHotkeys.Queue.push(Hotkey);
if(!Hotkey.Passthrough)
return NULL;
}
}
if(KWMMode.Focus == FocusModeAutofocus &&
!IsActiveSpaceFloating())
{
CGEventSetIntegerValueField(Event, kCGKeyboardEventAutorepeat, 0);
CGEventPostToPSN(&KWMFocus.PSN, Event);
return NULL;
}
} break;
case kCGEventKeyUp:
{
if(KWMMode.Focus == FocusModeAutofocus &&
!IsActiveSpaceFloating())
{
CGEventSetIntegerValueField(Event, kCGKeyboardEventAutorepeat, 0);
CGEventPostToPSN(&KWMFocus.PSN, Event);
return NULL;
}
} break;
case kCGEventMouseMoved:
{
pthread_mutex_lock(&KWMThread.Lock);
if(!IsSpaceTransitionInProgress())
{
UpdateActiveScreen();
if(KWMMode.Focus != FocusModeDisabled &&
KWMMode.Focus != FocusModeStandby &&
!IsActiveSpaceFloating())
FocusWindowBelowCursor();
}
pthread_mutex_unlock(&KWMThread.Lock);
} break;
default: {} break;
}
return Event;
}
CGPoint mouseLoc() {
Point currLoc;
GetGlobalMouse(&currLoc);
CGPoint cgLoc = {.x = currLoc.h, .y = currLoc.v};
return cgLoc;
}
// btn: 0 = none, 1 = left, 2 = right, etc
CGEventType mouseEventType(int btn, int btnState) {
switch(btn) {
case NO_MOUSE_BUTTON:
return kCGEventMouseMoved;
case LEFT_MOUSE:
switch(btnState) {
case MOUSE_UP:
return kCGEventLeftMouseUp;
case MOUSE_DRAGGED:
return kCGEventLeftMouseDragged;
default:
return kCGEventLeftMouseDown;
}
case RIGHT_MOUSE:
switch(btnState) {
case MOUSE_UP:
return kCGEventRightMouseUp;
case MOUSE_DRAGGED:
return kCGEventRightMouseDragged;
default:
return kCGEventRightMouseDown;
}
default:
switch(btnState) {
case MOUSE_UP:
return kCGEventOtherMouseUp;
case MOUSE_DRAGGED:
return kCGEventOtherMouseDragged;
default:
return kCGEventOtherMouseDown;
}
}
}
void mouseEvent(int btn, int btnState, int clickType) {
CGPoint currLoc;
currLoc = mouseLoc();
CGEventType mouseType = mouseEventType(btn, btnState);
CGMouseButton mb = (btn == LEFT_MOUSE) ?
kCGMouseButtonLeft :
(btn == RIGHT_MOUSE) ?
kCGMouseButtonRight :
kCGMouseButtonCenter;
CGEventRef theEvent = CGEventCreateMouseEvent(NULL, mouseType, currLoc, mb);
if (clickType) {
CGEventSetIntegerValueField(theEvent, kCGMouseEventClickState, clickType);
}
CGEventPost(kCGHIDEventTap, theEvent);
CFRelease(theEvent);
}
// 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;
}
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;
}
