void CentralWidget::slotKeyRelease()
{
int key = 0;
QTimer *timer = dynamic_cast< QTimer * >(QObject::sender());
bool needStop = (keyMap[Qt::Key_Up].isPressed +
keyMap[Qt::Key_Down].isPressed + keyMap[Qt::Key_Right].isPressed +
keyMap[Qt::Key_Left].isPressed) == 1;
for (std::map< int, keyState >::iterator it = keyMap.begin();
it != keyMap.end(); it++)
{
if (it->second.isPressed && it->second.releaseTimer == timer)
{
key = it->first;
break;
}
}
switch (key)
{
case Qt::Key_Up:
joystick->setUpButtonPressed(false);
keyRelease(key, needStop ? &CentralWidget::slotCarStopCmd : nullptr);
break;
case Qt::Key_Down:
joystick->setDownButtonPressed(false);
keyRelease(key, needStop ? &CentralWidget::slotCarStopCmd : nullptr);
break;
case Qt::Key_Right:
joystick->setRightButtonPressed(false);
keyRelease(key, needStop ? &CentralWidget::slotCarStopCmd : nullptr);
break;
case Qt::Key_Left:
joystick->setLeftButtonPressed(false);
keyRelease(key, needStop ? &CentralWidget::slotCarStopCmd : nullptr);
break;
case Qt::Key_Space:
hornSignalButton->setDown(false);
keyRelease(key, &CentralWidget::slotHornSignalStop);
break;
default:
break;
}
}
bool MapEditorToolBase::keyReleaseEvent(QKeyEvent* event)
{
active_modifiers = Qt::KeyboardModifiers(event->modifiers() | (key_button_bar ? key_button_bar->activeModifiers() : 0));
#if defined(Q_OS_MAC)
// FIXME: On Mac, QKeyEvent::modifiers() seems to return the keyboard
// modifier flags that existed immediately before the event occurred.
// This is in contradiction to the documenation for QKeyEvent::modifiers(),
// but the documented behaviour of (parent) QInputEvent::modifiers().
// Qt5 doc says QKeyEvent::modifiers() "cannot always be trusted." ...
switch (event->key())
{
case Qt::Key_Shift:
active_modifiers &= ~Qt::ShiftModifier;
break;
case Qt::Key_Control:
active_modifiers &= ~Qt::ControlModifier;
break;
case Qt::Key_Alt:
active_modifiers &= ~Qt::AltModifier;
break;
case Qt::Key_Meta:
active_modifiers &= ~Qt::MetaModifier;
break;
default:
; // nothing
}
#endif
return keyRelease(event);
}
bool App::nativeEvent(xcb_generic_event_t* event)
{
if ((event->response_type & ~0x80) == XCB_KEY_PRESS) {
auto keypress = reinterpret_cast<xcb_key_press_event_t*>(event);
if (keypress->event == QX11Info::appRootWindow()) {
auto sym = xcb_key_press_lookup_keysym(m_syms, keypress, 0);
uint state = keypress->state & USED_MASK;
bool forward;
if ((forward = m_triggersList.contains(qMakePair<uint, uint>(sym, state)))
|| m_triggersList.contains(qMakePair<uint, uint>(sym, state & (~XCB_MOD_MASK_SHIFT)))) {
if (m_keyboardGrabbed) {
ibus_panel_impanel_navigate(m_impanel, false, forward);
} else {
if (grabXKeyboard()) {
ibus_panel_impanel_navigate(m_impanel, true, forward);
} else {
ibus_panel_impanel_move_next(m_impanel);
}
}
}
}
} else if ((event->response_type & ~0x80) == XCB_KEY_RELEASE) {
auto keyrelease = reinterpret_cast<xcb_key_release_event_t*>(event);
if (keyrelease->event == QX11Info::appRootWindow()) {
keyRelease(keyrelease);
}
}
return false;
}
void GTKeyboardDriver::keyClick(GUITestOpStatus &os, char key, int modifiers)
{
GT_CHECK(key != 0, "key = 0");
if (modifiers==GTKeyboardDriver::key["ctrl"])
modifiers=GTKeyboardDriver::key["cmd"];
keyPress(os, key, modifiers);
keyRelease(os, key, modifiers);
}
void GTKeyboardDriver::keyClick(GUITestOpStatus &os, char key, int modifiers)
{
GT_CHECK(key != 0, "key = 0");
keyPress(os, key, modifiers);
keyRelease(os, key, modifiers);
GTGlobals::sleep(10);
}
void ColorSelector::keyReleaseEvent ( QKeyEvent * e )
{
if (e->key() == mHotKey) {
mCtrlPressed = false;
releaseKeyboard();
}
emit (keyRelease(e));
}
void MyInputPanelContext::sendCharacter(QChar character)
{
QPointer<QWidget> w = focusWidget();
if (!w)
return;
QKeyEvent keyPress(QEvent::KeyPress, character.unicode(), Qt::NoModifier, QString(character));
QApplication::sendEvent(w, &keyPress);
if (!w)
return;
QKeyEvent keyRelease(QEvent::KeyPress, character.unicode(), Qt::NoModifier, QString());
QApplication::sendEvent(w, &keyRelease);
}
void GTKeyboardDriver::keyRelease(GUITestOpStatus &os, char key, int modifiers) {
GT_CHECK(key != 0, "key = 0");
const bool isChanged = extractShiftModifier(key);
if (!isChanged) {
key = asciiToVirtual(key);
} else {
CGEventRef event = CGEventCreateKeyboardEvent(NULL, GTKeyboardDriver::key["shift"], false);
GT_CHECK(event != NULL, "Can't create event");
CGEventPost(kCGSessionEventTap, event);
CFRelease(event);
}
GTGlobals::sleep(1);
keyRelease(os, (int) key, modifiers);
}
void GTKeyboardDriver::keyClick(GUITestOpStatus &os, char key, QList<int> modifiers){
switch (modifiers.size()) {
case 0:
keyClick(os, key);
break;
case 1:
keyClick(os, key, modifiers.first());
break;
default:
int modifier = modifiers.takeLast();
foreach (int mod, modifiers) {
keyPress(os, mod);
}
keyClick(os, key, modifier);
foreach (int mod, modifiers) {
keyRelease(os, mod);
}
void MainInterface::keyReleaseEvent(QKeyEvent *k)
{
if(!k->isAutoRepeat()){
k->accept();
switch(k->key())
{
case Qt::Key_F1:
break;
case Qt::Key_F2:
// ui->pushButton_F2->setEnabled(true);
break;
case Qt::Key_F3:
// ui->pushButton_F3->setEnabled(true);
break;
case Qt::Key_F4:
// ui->pushButton_F4->setEnabled(true);
break;
case Qt::Key_F5:
// ui->pushButton_F5->setEnabled(true);
break;
case Qt::Key_F6:
// ui->pushButton_F6->setEnabled(true);
break;
case Qt::Key_F7:
// ui->pushButton_F7->setEnabled(true);
break;
case Qt::Key_F8:
if(timer->isActive()){
timer->stop();
}
break;
case Qt::Key_Up:
case Qt::Key_Down:
case Qt::Key_Left:
case Qt::Key_Right:
emit keyRelease(k->key());
break;
default :
break;
}
}
else
k->ignore();
}
Boolean MRJFrame::handleEvent(const EventRecord* event)
{
Boolean eventHandled = true;
switch (event->what) {
case nsPluginEventType_AdjustCursorEvent:
idle(event->modifiers);
break;
case ::mouseDown:
click(event);
break;
case keyDown:
case autoKey:
keyPress(event->message, event->modifiers);
break;
case keyUp:
keyRelease(event->message, event->modifiers);
break;
case updateEvt:
update();
break;
case activateEvt:
activate((event->modifiers & activeFlag) != 0);
break;
#if 0
case osEvt:
resume((event->message & resumeFlag) != 0);
eventHandled = false;
break;
#endif
default:
eventHandled = false;
break;
}
return eventHandled;
}
void MSWidget::event(const XEvent *pEvent_)
{
if (!_eventOverride||!(*_eventOverride)(pEvent_->type))
switch (pEvent_->type)
{
case Expose: expose(pEvent_); break;
case NoExpose: noExpose(pEvent_); break;
case GraphicsExpose: graphicsExpose(pEvent_); break;
case VisibilityNotify: visibilityNotify(pEvent_); break;
case EnterNotify: if (_server->eventGrabbed(pEvent_,this)==MSTrue) enterNotify(pEvent_); break;
case LeaveNotify: leaveNotify(pEvent_); break;
case ConfigureNotify: configureNotify(pEvent_); break;
case CreateNotify: createNotify(pEvent_); break;
case DestroyNotify: destroyNotify(pEvent_); break;
case ReparentNotify: reparentNotify(pEvent_); break;
case MapNotify: mapNotify(pEvent_); break;
case UnmapNotify: unmapNotify(pEvent_); break;
case PropertyNotify: propertyNotify(pEvent_); break;
case SelectionNotify: selectionNotify(pEvent_); break;
case SelectionClear: selectionClear(pEvent_); break;
case SelectionRequest: selectionRequest(pEvent_); break;
case ClientMessage: clientMessage(pEvent_); break;
case MotionNotify: if (_server->eventGrabbed(pEvent_,this)==MSTrue) motionNotify(pEvent_); break;
case ButtonRelease: if (_server->eventGrabbed(pEvent_,this)==MSTrue) buttonRelease(pEvent_); break;
case ButtonPress: if (_server->eventGrabbed(pEvent_,this)==MSTrue) buttonPress(pEvent_);
else _server->bell(); break;
case KeyRelease: if (_server->eventGrabbed(pEvent_,this)==MSTrue) keyRelease(pEvent_); break;
case KeyPress: if (_server->eventGrabbed(pEvent_,this)==MSTrue) keyPressEvent(pEvent_);
else _server->bell(); break;
case FocusIn: focusInEventNotify(pEvent_); break;
case FocusOut: focusOutEventNotify(pEvent_); break;
default: break;
}
// this event handler is intended to support the mstk builder
// i.e. it is easier to get events this way rather than
// subclass every widget and override the event methods
if (_eventHandler!=0) (*_eventHandler)(this,pEvent_,_eventHandlerData);
}
void MSWidget::keyRelease(const XEvent *pEvent_,KeySym,unsigned int,const char *)
{ keyRelease(pEvent_); }
void QIrrlichtWidget::keyReleaseEvent(QKeyEvent *event)
{
emit(keyRelease(event));
}
void EventReceiver::_onEvent(const int socket)
{
if (socket != _stream.getDescriptor())
return;
while (_stream.hasEvent())
{
const Event& deflectEvent = _stream.getEvent();
switch (deflectEvent.type)
{
case Event::EVT_CLOSE:
_stop();
return;
case Event::EVT_PRESS:
emit pressed(_pos(deflectEvent));
break;
case Event::EVT_RELEASE:
emit released(_pos(deflectEvent));
break;
case Event::EVT_MOVE:
emit moved(_pos(deflectEvent));
break;
case Event::EVT_VIEW_SIZE_CHANGED:
emit resized(QSize{int(deflectEvent.dx), int(deflectEvent.dy)});
break;
case Event::EVT_SWIPE_LEFT:
emit swipeLeft();
break;
case Event::EVT_SWIPE_RIGHT:
emit swipeRight();
break;
case Event::EVT_SWIPE_UP:
emit swipeUp();
break;
case Event::EVT_SWIPE_DOWN:
emit swipeDown();
break;
case Event::EVT_KEY_PRESS:
emit keyPress(deflectEvent.key, deflectEvent.modifiers,
QString::fromStdString(deflectEvent.text));
break;
case Event::EVT_KEY_RELEASE:
emit keyRelease(deflectEvent.key, deflectEvent.modifiers,
QString::fromStdString(deflectEvent.text));
break;
case Event::EVT_TOUCH_ADD:
emit touchPointAdded(deflectEvent.key, _pos(deflectEvent));
break;
case Event::EVT_TOUCH_UPDATE:
emit touchPointUpdated(deflectEvent.key, _pos(deflectEvent));
break;
case Event::EVT_TOUCH_REMOVE:
emit touchPointRemoved(deflectEvent.key, _pos(deflectEvent));
break;
case Event::EVT_CLICK:
case Event::EVT_DOUBLECLICK:
case Event::EVT_PINCH:
case Event::EVT_WHEEL:
default:
break;
}
}
if (!_stream.isConnected())
_stop();
}
bool EventHandler::handleEvent(SDL_Event &event) {
switch (event.type) {
case SDL_TEXTINPUT:
textInput(std::string(event.text.text));
break;
case SDL_KEYUP:
keyRelease((int32_t) event.key.keysym.sym);
break;
case SDL_KEYDOWN:
// we are handling this on our own
if (!event.key.repeat)
keyPress((int32_t) event.key.keysym.sym, (int16_t) event.key.keysym.mod);
break;
case SDL_MOUSEMOTION: {
if (event.motion.which == SDL_TOUCH_MOUSEID)
break;
SDL_Window *window = SDL_GetWindowFromID(event.motion.windowID);
if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_INPUT_FOCUS))
break;
mouseMotion(event.motion.x, event.motion.y, event.motion.xrel, event.motion.yrel);
break;
}
case SDL_MOUSEBUTTONDOWN:
if (event.button.which == SDL_TOUCH_MOUSEID)
break;
mouseButtonPress(event.button.x, event.button.y, event.button.button);
break;
case SDL_MOUSEBUTTONUP:
if (event.button.which == SDL_TOUCH_MOUSEID)
break;
mouseButtonRelease(event.button.x, event.button.y, event.button.button);
break;
case SDL_MOUSEWHEEL:
if (event.wheel.which == SDL_TOUCH_MOUSEID)
break;
mouseWheel(event.wheel.x, event.wheel.y);
break;
case SDL_CONTROLLERAXISMOTION: {
const uint8_t axis = event.caxis.axis;
if (axis != SDL_CONTROLLER_AXIS_LEFTX && axis != SDL_CONTROLLER_AXIS_LEFTY && axis != SDL_CONTROLLER_AXIS_RIGHTX && axis != SDL_CONTROLLER_AXIS_RIGHTY)
break;
const bool horizontal = (axis == SDL_CONTROLLER_AXIS_LEFTX || axis == SDL_CONTROLLER_AXIS_RIGHTX);
joystickMotion(horizontal, event.caxis.value);
break;
}
case SDL_CONTROLLERBUTTONDOWN:
controllerButtonPress(getControllerButtonName(event.cbutton.button));
break;
case SDL_CONTROLLERBUTTONUP:
controllerButtonRelease(getControllerButtonName(event.cbutton.button));
break;
case SDL_CONTROLLERDEVICEADDED:
joystickDeviceAdded(event.cdevice.which);
break;
case SDL_CONTROLLERDEVICEREMOVED:
joystickDeviceRemoved(event.cdevice.which);
break;
case SDL_JOYDEVICEADDED:
joystickDeviceAdded(event.jdevice.which);
break;
case SDL_JOYDEVICEREMOVED:
joystickDeviceRemoved(event.jdevice.which);
break;
case SDL_DOLLARRECORD:
gestureRecord(event.dgesture.gestureId);
break;
case SDL_DOLLARGESTURE:
gesture(event.dgesture.gestureId, event.dgesture.error, event.dgesture.numFingers);
break;
case SDL_MULTIGESTURE:
multiGesture(event.mgesture.dTheta, event.mgesture.dDist, event.mgesture.numFingers);
break;
case SDL_JOYHATMOTION:
break;
case SDL_JOYBUTTONDOWN:
joystickButtonPress(event.jbutton.button);
break;
case SDL_JOYBUTTONUP:
joystickButtonRelease(event.jbutton.button);
break;
case SDL_JOYAXISMOTION:
joystickMotion(event.jaxis.axis == 0, event.jaxis.value);
break;
case SDL_FINGERDOWN:
fingerPress(event.tfinger.fingerId, event.tfinger.x, event.tfinger.y);
break;
case SDL_FINGERUP:
fingerRelease(event.tfinger.fingerId, event.tfinger.x, event.tfinger.y);
break;
case SDL_FINGERMOTION:
fingerMotion(event.tfinger.fingerId, event.tfinger.x, event.tfinger.y, event.tfinger.dx, event.tfinger.dy);
break;
case SDL_WINDOWEVENT:
switch (event.window.event) {
case SDL_WINDOWEVENT_RESIZED:
case SDL_WINDOWEVENT_SIZE_CHANGED:
for (EventObservers::iterator i = _observers.begin(); i != _observers.end(); ++i) {
(*i)->onWindowResize();
}
break;
case SDL_WINDOWEVENT_CLOSE:
return false;
}
break;
}
return true;
}
void Window::keyReleaseEvent(QKeyEvent *event){
int key = event->key();
emit keyRelease(KeyEvent(key, false));
}
void Screen::keyReleaseEvent(QKeyEvent* event)
{
emit keyRelease(event->key());
}
void XComp::keyRelease(int keycode){
keyRelease(keycode, 0);
}
void Renderer::keyReleaseEvent(QKeyEvent* event)
{
emit keyRelease(event); //Syntaxe Qt
}
void GTKeyboardDriver::keyRelease(GUITestOpStatus &os, char key, int modifiers)
{
if (isalpha(key)) {
key = toupper(key);
}
switch (key) {
case '_':
keyRelease(os, VK_OEM_MINUS, GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '=':
keyRelease(os, VK_OEM_PLUS);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '.':
keyRelease(os, VK_DECIMAL, modifiers);
break;
case ',':
keyRelease(os, VK_OEM_COMMA, modifiers);
break;
case ']':
keyRelease(os, VK_OEM_6, modifiers);
break;
case '\\':
keyRelease(os, VK_OEM_5, modifiers);
break;
case '[':
keyRelease(os, VK_OEM_4, modifiers);
break;
case '/':
keyRelease(os, VK_DIVIDE, modifiers);
break;
case '\n':
keyRelease(os, GTKeyboardDriver::key["enter"], modifiers);
break;
case ':':
keyRelease(os, VK_OEM_1, GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case ';':
keyRelease(os, VK_OEM_1);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '<':
keyRelease(os, VK_OEM_COMMA, GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '>':
keyRelease(os, VK_OEM_PERIOD, GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '(':
keyRelease(os, '9', GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case ')':
keyRelease(os, '0', GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '"':
keyRelease(os, VK_OEM_7, GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '!':
keyRelease(os, '1', GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '@':
keyRelease(os, '2', GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '#':
keyRelease(os, '3', GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '$':
keyRelease(os, '4', GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '%':
keyRelease(os, '5', GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '^':
keyRelease(os, '6', GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '&':
keyRelease(os, '7', GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '*':
keyRelease(os, '8', GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '+':
keyRelease(os, VK_OEM_PLUS, GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
case '?':
keyRelease(os, VK_OEM_2, GTKeyboardDriver::key["shift"]);
if (modifiers != 0) {
keyRelease(os, modifiers);
}
break;
default:
keyRelease(os, (int)key, modifiers);
break;
}
}
void QExtMouse3DLinuxInputDevice::translateMscKey(int code, bool press)
{
int qtcode = -1;
switch (code) {
case SPKey_Menu:
// On the SpaceNavigator, map this key to "translation lock".
if (mouseType & QExtMouse3DLinuxInputDevice::MouseSpaceNavigator) {
if (press)
toggleFilter(QExtMouse3DEventProvider::Translations);
qtcode = QGL::Key_Translations;
} else {
qtcode = Qt::Key_Menu;
}
break;
case SPKey_Fit:
// On the SpaceNavigator, map this key to "rotation lock".
if (mouseType & QExtMouse3DLinuxInputDevice::MouseSpaceNavigator) {
if (press)
toggleFilter(QExtMouse3DEventProvider::Rotations);
qtcode = QGL::Key_Rotations;
} else {
qtcode = QGL::Key_Fit;
}
break;
case SPKey_TopView: qtcode = QGL::Key_TopView; break;
case SPKey_LeftView: qtcode = QGL::Key_LeftView; break;
case SPKey_RightView: qtcode = QGL::Key_RightView; break;
case SPKey_FrontView: qtcode = QGL::Key_FrontView; break;
case SPKey_BottomView: qtcode = QGL::Key_BottomView; break;
case SPKey_BackView: qtcode = QGL::Key_BackView; break;
case SPKey_RotateCW90: qtcode = QGL::Key_RotateCW90; break;
case SPKey_RotateCCW90: qtcode = QGL::Key_RotateCCW90; break;
case SPKey_ISO1: qtcode = QGL::Key_ISO1; break;
case SPKey_ISO2: qtcode = QGL::Key_ISO2; break;
case SPKey_F1: qtcode = QGL::Key_Button1; break;
case SPKey_F2: qtcode = QGL::Key_Button2; break;
case SPKey_F3: qtcode = QGL::Key_Button3; break;
case SPKey_F4: qtcode = QGL::Key_Button4; break;
case SPKey_F5: qtcode = QGL::Key_Button5; break;
case SPKey_F6: qtcode = QGL::Key_Button6; break;
case SPKey_F7: qtcode = QGL::Key_Button7; break;
case SPKey_F8: qtcode = QGL::Key_Button8; break;
case SPKey_F9: qtcode = QGL::Key_Button9; break;
case SPKey_F10: qtcode = QGL::Key_Button10; break;
case SPKey_Escape: qtcode = Qt::Key_Escape; break;
case SPKey_Alt: qtcode = Qt::Key_Alt; break;
case SPKey_Shift: qtcode = Qt::Key_Shift; break;
case SPKey_Control: qtcode = Qt::Key_Control; break;
case SPKey_Rotation:
if (press)
toggleFilter(QExtMouse3DEventProvider::Rotations);
qtcode = QGL::Key_Rotations;
break;
case SPKey_Pan:
if (press)
toggleFilter(QExtMouse3DEventProvider::Translations);
qtcode = QGL::Key_Translations;
break;
case SPKey_Dominant:
if (press)
toggleFilter(QExtMouse3DEventProvider::DominantAxis);
qtcode = QGL::Key_DominantAxis;
break;
case SPKey_IncSensitivity:
if (press)
adjustSensitivity(2.0f);
qtcode = QGL::Key_IncreaseSensitivity;
break;
case SPKey_DecSensitivity:
if (press)
adjustSensitivity(0.5f);
qtcode = QGL::Key_DecreaseSensitivity;
break;
default: break;
}
if (qtcode != -1) {
if (press)
keyPress(qtcode);
else
keyRelease(qtcode);
}
}
void processCommand(const char *cmd) {
int tmpx, tmpy, btn;
float tmpInterval;
UInt32 tmpkc;
char str[CMD_STRING_MAXLEN];
bzero(str, CMD_STRING_MAXLEN);
if (IS_CMD(cmd, "mouselocation")) {
CGPoint cgLoc = mouseLoc();
printf("%.f %.f\n", cgLoc.x, cgLoc.y);
} else if (IS_CMD(cmd, "mousewarp ")) {
print_msg("Warping mouse to location.");
sscanf(cmd, "mousewarp %d %d", &tmpx, &tmpy);
mouseMove(tmpx, tmpy);
} else if (IS_CMD(cmd, "mousemove ")) {
print_msg("Moving mouse.");
sscanf(cmd, "mousemove %d %d", &tmpx, &tmpy);
mouseMoveTo(tmpx, tmpy, 0.7);
} else if (IS_CMD(cmd, "mousedown")) {
print_msg("Pressing mouse button.");
sscanf(cmd, "mousedown %d", &btn);
mousePress(btn, SINGLE_CLICK);
} else if (IS_CMD(cmd, "mouseup")) {
print_msg("Releasing mouse button.");
sscanf(cmd, "mouseup %d", &btn);
mouseRelease(btn, SINGLE_CLICK);
} else if (IS_CMD(cmd, "mouseclick")) {
print_msg("Clicking mouse.");
sscanf(cmd, "mouseclick %d", &btn);
mouseClick(btn, SINGLE_CLICK);
} else if (IS_CMD(cmd, "mousedoubleclick")) {
print_msg("Double-clicking mouse.");
sscanf(cmd, "mousedoubleclick %d", &btn);
mouseClick(btn, DOUBLE_CLICK);
} else if (IS_CMD(cmd, "mousetripleclick")) {
print_msg("Triple-clicking mouse.");
sscanf(cmd, "mousetripleclick %d", &btn);
mouseClick(btn, TRIPLE_CLICK);
} else if (IS_CMD(cmd, "mousedrag ")) {
print_msg("Dragging mouse.");
sscanf(cmd, "mousedrag %d %d", &tmpx, &tmpy);
mouseDrag(LEFT_MOUSE, tmpx, tmpy);
} else if (IS_CMD(cmd, "press ")) {
print_msg("Pressing key.");
sscanf(cmd, "press %x", &tmpkc);
keyPress((CGKeyCode)tmpkc, NULL);
} else if (IS_CMD(cmd, "release ")) {
print_msg("Releasing key.");
sscanf(cmd, "release %x", &tmpkc);
keyRelease((CGKeyCode)tmpkc, NULL);
} else if (IS_CMD(cmd, "hit ")) {
print_msg("Hitting key.");
sscanf(cmd, "hit %x", &tmpkc);
keyHit((CGKeyCode)tmpkc, NULL);
} else if (IS_CMD(cmd, "type ")) {
print_msg("Typing.");
strncpy(str, &cmd[5], CMD_STRING_MAXLEN);
typeString(str);
} else if (IS_CMD(cmd, "wait")) {
print_msg("Waiting.");
sscanf(cmd, "wait %f", &tmpInterval);
usleep(1000000 * tmpInterval);
} else {
print_msg("I don't know what you want to do.");
}
}
