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;
}
bool GTMouseDriver::doubleClick() {
QPoint mousePos = QCursor::pos();
CGEventType eventTypeMouseDown = kCGEventLeftMouseDown ;
CGEventRef eventPress = CGEventCreateMouseEvent(NULL, eventTypeMouseDown, CGPointMake(mousePos.x(), mousePos.y()), 0 /*ignored*/);
DRIVER_CHECK(eventPress != NULL, "Can't create event");
CGEventType eventTypeMouseUp = kCGEventLeftMouseUp ;
CGEventRef eventRelease = CGEventCreateMouseEvent(NULL, eventTypeMouseUp, CGPointMake(mousePos.x(), mousePos.y()), 0 /*ignored*/);
DRIVER_CHECK(eventRelease != NULL, "Can't create event");
CGEventPost(kCGSessionEventTap, eventPress);
GTGlobals::sleep(0); // don't touch, it's Mac's magic
CGEventPost(kCGSessionEventTap, eventRelease);
GTGlobals::sleep(0);
CGEventSetDoubleValueField(eventPress, kCGMouseEventClickState, 2);
CGEventSetDoubleValueField(eventRelease, kCGMouseEventClickState, 2);
CGEventPost(kCGSessionEventTap, eventPress);
GTGlobals::sleep(0); // don't touch, it's Mac's magic
CGEventPost(kCGSessionEventTap, eventRelease);
GTGlobals::sleep(0);
GTGlobals::sleep(100);
CFRelease(eventPress);
CFRelease(eventRelease);
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
}
//--------------------------------------------------------------
void testApp::update(){
openNIDevice.update();
int holdTime = 300;
currTime = ofGetElapsedTimeMillis();
if((currTime - keyTime) > holdTime && leftKeyFlag){
cout << "RELEASE LEFT KEY" << endl;
CGEventRef b = CGEventCreateKeyboardEvent(NULL, 123, 0);
CGEventPost(kCGHIDEventTap, b);
leftKeyFlag = false;
}
if((currTime - keyTime) > holdTime && rightKeyFlag){
cout << "RELEASE RIGHT KEY" << endl;
CGEventRef f = CGEventCreateKeyboardEvent(NULL, 124, 0);
CGEventPost(kCGHIDEventTap, f);
rightKeyFlag = false;
}
if((currTime - keyTime) > holdTime && upKeyFlag){
cout << "RELEASE UP KEY" << endl;
CGEventRef d = CGEventCreateKeyboardEvent(NULL, 126, 0);
CGEventPost(kCGHIDEventTap, d);
upKeyFlag = false;
}
if (upKeyFlag == 1) {
leftByRun = 1;
rightByRun = 1;
} else {
leftByRun = 0;
rightByRun = 0;}
}
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);
}
}
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;
}
void UBKeyboardButton::sendControlSymbol(int nSymbol)
{
CGEventRef event1 = CGEventCreateKeyboardEvent(NULL, nSymbol, true);
CGEventRef event2 = CGEventCreateKeyboardEvent(NULL, nSymbol, false);
CGEventPost(kCGHIDEventTap, event1);
CGEventPost(kCGHIDEventTap, event2);
}
void SendString(CFStringRef str, unsigned delayMS)
{
//virtual keycodes copied from 10.6 SDK. Could not find them in 10.4 SDK
enum { VK_RETURN = 0x24 /*KVK_Return*/, VK_TAB = 0x30 /*kVK_Tab*/, VK_SPACE = 0x31/*kVK_Space*/};
//A list of chars for which we must specify the virtual keycode
static const CFStringRef specialChars = CFSTR("\n\t ");
static const UniChar verticalTab = CFStringGetCharacterAtIndex(CFSTR("\v"), 0);
//each keycode must correspond to the correct char in 'specialChars'
CGKeyCode specialKeyCodes[] = {VK_RETURN, VK_TAB, VK_SPACE };
assert(CFStringGetLength(specialChars) == NumberOf(specialKeyCodes));
for (unsigned i = 0, len = CFStringGetLength(str); i < len; ++i) {
//The next char to send
UniChar c = CFStringGetCharacterAtIndex(str, i);
//throw away 'vertical tab' chars which are only used on Windows to send a shift+tab
//as a workaround for some issues with IE
if (verticalTab == c)
continue;
//see if we need to specify the virtual keycode for this char
CGKeyCode vKey = 0; //0 = kVK_ANSI_A, but I don't know of a more appropriate default value
for (size_t j = 0; j < NumberOf(specialKeyCodes); ++j) {
if ( CFStringGetCharacterAtIndex(specialChars, j) == c) {
vKey = specialKeyCodes[j];
break;
}
}
CGEventRef keyDown = CGEventCreateKeyboardEvent(NULL, vKey, true);
CGEventRef keyUp = CGEventCreateKeyboardEvent(NULL, vKey, false);
if (keyDown && keyUp) {
//may be we should not do this if we found the virtual keycode?
CGEventKeyboardSetUnicodeString(keyDown, 1, &c);
CGEventKeyboardSetUnicodeString(keyUp, 1, &c);
CGEventPost(kCGSessionEventTap, keyDown);
CGEventPost(kCGSessionEventTap, keyUp);
pws_os::sleep_ms(delayMS);
CFRelease(keyDown);
CFRelease(keyUp);
}
else {
if (keyDown) CFRelease(keyDown);
if (keyUp) CFRelease(keyUp);
pws_os::IssueError(_T("Out of memory trying to allocate CGEventRef"));
return;
}
}
}
int main() {
CGEventRef mkey = CGEventCreateKeyboardEvent(NULL, (CGKeyCode)7, true);
CGEventPost(kCGSessionEventTap, mkey);
CFRelease(mkey);
CGEventRef fkey = CGEventCreateKeyboardEvent(NULL, (CGKeyCode)7, false);
CGEventPost(kCGSessionEventTap, fkey);
CFRelease(fkey);
return 0;
}
void UBKeyboardButton::sendUnicodeSymbol(KEYCODE keycode)
{
if (keycode.modifier)
CGEventPost(kCGSessionEventTap, CGEventCreateKeyboardEvent(NULL, 56, true));
CGEventPost(kCGSessionEventTap, CGEventCreateKeyboardEvent(NULL, keycode.code, true));
CGEventPost(kCGSessionEventTap, CGEventCreateKeyboardEvent(NULL, keycode.code, false));
if (keycode.modifier)
CGEventPost(kCGSessionEventTap, CGEventCreateKeyboardEvent(NULL, 56, false));
}
void sendPress(int kc) {
CGEventSourceRef src = NULL;
// CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
CGEventRef down, up;
down = CGEventCreateKeyboardEvent(src,(CGKeyCode)kc, true);
up = CGEventCreateKeyboardEvent(src,(CGKeyCode)kc, false);
CGEventPost(kCGSessionEventTap, down);
CGEventPost(kCGSessionEventTap, up);
CFRelease(down);
CFRelease(up);
}
void Utilities::PostKey(CGKeyCode key)
{
CGEventSourceRef source = CGEventSourceCreate(kCGEventSourceStateCombinedSessionState);
CGEventRef keyDown = CGEventCreateKeyboardEvent(source, key, TRUE);
CGEventRef keyUp = CGEventCreateKeyboardEvent(source, key, FALSE);
CGEventPost(kCGAnnotatedSessionEventTap, keyDown);
CGEventPost(kCGAnnotatedSessionEventTap, keyUp);
CFRelease(keyUp);
CFRelease(keyDown);
CFRelease(source);
}
void XInputSimulatorImplMacOs::mouseMoveRelative(int x, int y)
{
int newX = this->currentX + x;
int newY = this->currentY + y;
if(newX < 0 || newX > this->displayX || newY < 0 || newY > this->displayY )
{
std::cout << "mouse moved beyound screensize." << std::endl;
return;
}
std::cout << "newx: " << newX << " newy: " << newY << std::endl;
CGEventRef mouseEv = CGEventCreateMouseEvent(
NULL, kCGEventMouseMoved,
CGPointMake(newX, newY),
kCGMouseButtonLeft);
CGEventPost(kCGHIDEventTap, mouseEv);
CFRelease(mouseEv);
this->currentX = newX;
this->currentY = newY;
}
void mouseup(char btn) {
CGEventType eventType;
CGMouseButton button;
switch (btn) {
case 'l':
eventType = kCGEventLeftMouseDown;
button = kCGMouseButtonLeft;
break;
case 'r':
eventType = kCGEventRightMouseDown;
button = kCGMouseButtonRight;
break;
case 'm':
eventType = kCGEventOtherMouseDown;
button = kCGMouseButtonCenter;
break;
default:
eventType = kCGEventNull;
break;
}
if (eventType != kCGEventNull) {
CGEventRef event = CGEventCreateMouseEvent(NULL, eventType, mousePos(), button);
CGEventPost(kCGHIDEventTap, event);
CFRelease(event);
}
}
void XInputSimulatorImplMacOs::keyUp(int key)
{
CGKeyCode keycode = key;
CGEventRef commandUp = CGEventCreateKeyboardEvent(NULL, keycode, false);
CGEventPost(kCGAnnotatedSessionEventTap, commandUp);
CFRelease(commandUp);
}
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;
}
bool MouseMac::moveMouseTo(int x, int y)
{
UInt32 maxDisplays = 4;
CGDirectDisplayID displayID[maxDisplays];
CGDisplayCount c = 0;
CGDisplayCount *count = &c;
CGGetDisplaysWithPoint(
CGPointMake(x, y),
maxDisplays,
displayID,
count);
if (*count > 0)
{
CGEventRef mouseEv = CGEventCreateMouseEvent(
NULL, kCGEventMouseMoved,
CGPointMake(x, y),
kCGMouseButtonLeft);
CGEventPost(kCGHIDEventTap, mouseEv);
CFRelease(mouseEv);
return true;
}
else
{
return false;
}
}
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
}
/**
* Move the mouse to a specific point.
* @param point The coordinates to move the mouse to (x, y).
*/
void moveMouse(MMPoint point)
{
#if defined(IS_MACOSX)
CGEventRef move = CGEventCreateMouseEvent(NULL, kCGEventMouseMoved,
CGPointFromMMPoint(point),
kCGMouseButtonLeft);
calculateDeltas(&move, point);
CGEventPost(kCGSessionEventTap, move);
CFRelease(move);
#elif defined(USE_X11)
Display *display = XGetMainDisplay();
XWarpPointer(display, None, DefaultRootWindow(display),
0, 0, 0, 0, point.x, point.y);
XSync(display, false);
#elif defined(IS_WINDOWS)
//Mouse motion is now done using SendInput with MOUSEINPUT. We use Absolute mouse positioning
#define MOUSE_COORD_TO_ABS(coord, width_or_height) (((65536 * coord) / width_or_height) + (coord < 0 ? -1 : 1))
point.x = MOUSE_COORD_TO_ABS(point.x, GetSystemMetrics(SM_CXSCREEN));
point.y = MOUSE_COORD_TO_ABS(point.y, GetSystemMetrics(SM_CYSCREEN));
INPUT mouseInput;
mouseInput.type = INPUT_MOUSE;
mouseInput.mi.dx = point.x;
mouseInput.mi.dy = point.y;
mouseInput.mi.dwFlags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE;
mouseInput.mi.time = 0; //System will provide the timestamp
mouseInput.mi.dwExtraInfo = 0;
mouseInput.mi.mouseData = 0;
SendInput(1, &mouseInput, sizeof(mouseInput));
#endif
}
void convertAndSendVK(PRUint8 vk, bool down) {
CGKeyCode key = 0;
// Hack
usleep(100);
switch (vk) {
case SPACE:
key = kVK_Space;
break;
case BKSP:
key = kVK_Delete;
break;
case TAB:
key = kVK_Tab;
break;
case ENTER:
key = kVK_Return;
break;
case SHIFT:
key = kVK_Shift;
break;
default:
return;
}
CGEventRef event;
CGEventSourceRef eventSource = CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
event = CGEventCreateKeyboardEvent (eventSource, key, down);
CGEventPost(kCGHIDEventTap, event);
CFRelease(eventSource);
CFRelease(event);
}
void XInputSimulatorImplMacOs::mouseScrollY(int length)
{
int scrollDirection = -1; // 1 down -1 up
if(length < 0){
length *= -1;
scrollDirection *= -1;
}
//length *= 100;
for(int cnt = 0; cnt < length; cnt++){
std::cout << "scroll y mac" << std::endl;
CGEventRef scrollEv = CGEventCreateScrollWheelEvent (
NULL, kCGScrollEventUnitLine, // kCGScrollEventUnitLine //kCGScrollEventUnitPixel
1, //CGWheelCount 1 = y 2 = xy 3 = xyz
scrollDirection); // length of scroll from -10 to 10 higher values lead to undef behaviour
CGEventPost(kCGHIDEventTap, scrollEv);
CFRelease(scrollEv);
//sleep(1);
}
}
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);
}
int main() {
int keyCode = 49; //space bar
srand ( time(NULL) );
printf("User input coming in 30 seconds\n");
sleep(27);
printf("3...\n");
sleep(1);
printf("2...\n");
sleep(1);
printf("1...\n");
sleep(1);
printf("NOW!");
while(1){
CGEventRef ourEvent = CGEventCreate(NULL);
CGPoint point = CGEventGetLocation(ourEvent);
CGEventRef click1_down = CGEventCreateMouseEvent(
NULL, kCGEventLeftMouseDown,
point,
kCGMouseButtonLeft
);
CGEventRef click1_up = CGEventCreateMouseEvent(
NULL, kCGEventLeftMouseUp,
point,
kCGMouseButtonLeft
);
CGEventPost(kCGHIDEventTap, click1_down);
sleep(0.11);
CGEventPost(kCGHIDEventTap, click1_up);
CFRelease(click1_up);
CFRelease(click1_down);
CFRelease(ourEvent);
sleep(0.89);
if(rand() % 100 <= 2){ //2% chance
CGEventRef e = CGEventCreateKeyboardEvent (NULL, (CGKeyCode)keyCode, true);
CGEventPost(kCGSessionEventTap, e);
CFRelease(e);
e = CGEventCreateKeyboardEvent (NULL, (CGKeyCode)keyCode, false);
CGEventPost(kCGSessionEventTap, e);
CFRelease(e);
}
sleep(9);
}
}
Qt::Native::Status sendNativeKeyEvent_Quartz(const QNativeKeyEvent &event)
{
CGEventRef e = CGEventCreateKeyboardEvent(0, (uint)event.nativeKeyCode, event.press);
setModifiersFromQNativeEvent(e, event);
CGEventPost(kCGHIDEventTap, e);
CFRelease(e);
return Qt::Native::Success;
}
static inline void ScrollUp() {
CGEventRef scroll = CGEventCreateScrollWheelEvent(
NULL, kCGScrollEventUnitLine,
1, 4);
CGEventPost(kCGHIDEventTap, scroll);
CFRelease(scroll);
}
void MouseMac::rightMouseUp()
{
CGEventRef mouseEv = CGEventCreateMouseEvent(
NULL, kCGEventRightMouseUp,
getCursorPositionCGPoint(),
kCGMouseButtonRight);
CGEventPost(kCGHIDEventTap, mouseEv);
CFRelease(mouseEv);
}
static inline void SendString(short theCode)
{
UniChar unicodeString[1];
unicodeString[0] = theCode;
CGEventRef e = CGEventCreateKeyboardEvent(NULL, 0, true);
CGEventKeyboardSetUnicodeString(e, 1, unicodeString);
CGEventPost(kCGHIDEventTap, e);
CFRelease(e);
}
void SendCharCode(CGCharCode keycode, bool isDown)
{
CGEventRef event = CGEventCreateKeyboardEvent(NULL, keycode, isDown);
if (event)
{
CGEventPost(kCGHIDEventTap, event);
}
CFRelease(event);
}
void MouseUpRight () {
CGEventRef mouse_down = CGEventCreateMouseEvent(
NULL, kCGEventRightMouseUp,
MousePos(),
kCGMouseButtonLeft
);
CGEventPost(kCGHIDEventTap, mouse_down);
CFRelease(mouse_down);
}
void MouseMove (int x, int y) {
CGEventRef move = CGEventCreateMouseEvent(
NULL, kCGEventMouseMoved,
CGPointMake(x, y),
kCGMouseButtonLeft // ignored
);
CGEventPost(kCGHIDEventTap, move);
CFRelease(move);
}