Ejemplo n.º 1
0
InputResponder::InputResponder(RenderingWindow* window, Character* character,
                               Camera* camera, BloomFilterEffect* bloom, LuminanceFilterEffect* luminance) : inputProc(window) {

    //Wire up the event to close window
    CloseWindowEvent* cWindow = new CloseWindowEvent(window);
    inputProc.bind(KeySequence(InputEvent::WinClosed), cWindow);

    //Wire up the event to move the character along the axis
    KeyMovement* movement = new KeyMovement(character, camera);
    KeySequence movementKeys;
    movementKeys.add(InputEvent::KeyW);
    movementKeys.add(InputEvent::KeyA);
    movementKeys.add(InputEvent::KeyS);
    movementKeys.add(InputEvent::KeyD);
    inputProc.bind(movementKeys, movement);

    //Wire up the mouse to rotate view
    MouseLookEvent* mouseLook = new MouseLookEvent(character, window, camera);
    inputProc.bind(KeySequence(InputEvent::MouseMove), mouseLook);

    //Wire up the postprocesseffects controller
    PostprocessParameterInputEvent* pprocessInputs = new PostprocessParameterInputEvent(bloom, luminance);
    KeySequence paramKeys;
    paramKeys.add(InputEvent::Key1);
    paramKeys.add(InputEvent::Key2);
    paramKeys.add(InputEvent::Key3);
    paramKeys.add(InputEvent::Key4);
    inputProc.bind(paramKeys, pprocessInputs);
}
Ejemplo n.º 2
0
void KeySequenceWidget::startRecording()
{
	keySequence() = KeySequence();
	setDown(true);
	setFocus();
	grabKeyboard();
	setStatus(Recording);
}
Ejemplo n.º 3
0
void Configuration::readShortcuts()
{
    Shortcuts = defaultShortcuts;
    QMap<QString, Shortcut>::const_iterator it = Shortcuts.begin();

    while(it != Shortcuts.end())
    {
        const QString id = it.key();
        QString key = shortcutFromConfig(id);
        if(key != "")
        {
            if(key == "NOT_SET")
                Shortcuts[it.key()].Hotkey = QKeySequence();
            else
            {
                QKeySequence KeySequence(key);
                Shortcuts[it.key()].Hotkey = KeySequence;
            }
        }
        it++;
    }
    emit shortcutsUpdated();
}
Ejemplo n.º 4
0
void ShortcutWidget::reset()
{
	clear();
	keysequence_ = KeySequence();
}
Ejemplo n.º 5
0
//bool InputAPI::eventFilter(Object *obj, QEvent *event)
void InputAPI::EventFilter(StringHash eventType, VariantMap& eventData)
{
    Urho3D::Input* input = GetSubsystem<Urho3D::Input>();

    if (eventType == Urho3D::E_KEYDOWN)
    {
        KeyEvent keyEvent(this);
        keyEvent.urhoEvent = eventData;
        keyEvent.keyCode = eventData[Urho3D::KeyDown::P_KEY].GetInt();// StripModifiersFromKey(e->key());
        keyEvent.sequence = KeySequence(eventData[Urho3D::KeyDown::P_KEY].GetInt() | eventData[Urho3D::KeyDown::P_QUALIFIERS].GetInt());
        keyEvent.keyPressCount = 1;
        keyEvent.modifiers = eventData[Urho3D::KeyDown::P_QUALIFIERS].GetInt();
        //keyEvent.text = e->text(); ///\todo
        keyEvent.eventType = KeyEvent::KeyPressed;
        keyEvent.timestamp = framework->Frame()->WallClockTime();
        // Assign the keys from the heldKeys map to the keyEvent.otherHeldKeys vector
        for (auto current = heldKeys.Begin(); current != heldKeys.End(); ++ current)
            keyEvent.otherHeldKeys.Push((*current).first_);

        keyEvent.handled = false;

        currentModifiers = eventData[Urho3D::KeyDown::P_QUALIFIERS].GetInt(); // local tracking for mouse events

        auto keyRecord = heldKeys.Find(keyEvent.keyCode);
        if (keyRecord == heldKeys.End())
        {
            KeyPressInformation info;
            info.keyPressCount = 1;
            info.keyState = KeyEvent::KeyPressed;
            //info.firstPressTime = now; ///\todo
            heldKeys[keyEvent.keyCode] = info;
        }

        // Queue up the press event for the polling API
        if (keyEvent.keyPressCount == 1) /// \todo The polling API does not get key repeats at all. Should it?
            newKeysPressedQueue.Push(eventData[Urho3D::KeyDown::P_KEY].GetInt());

        TriggerKeyEvent(keyEvent);

        return; // If we got true here, need to suppress this event from going to Qt.
    }

    else if (eventType == Urho3D::E_KEYUP)
    {
        HeldKeysMap::Iterator existingKey = heldKeys.Find(eventData[Urho3D::KeyDown::P_KEY].GetInt());

        // If we received a release on an unknown key we haven't received a press for, don't pass it to the scene,
        // since we didn't pass the press to the scene either (or we've already passed the release before, so don't 
        // pass duplicate releases).
        if (existingKey == heldKeys.End())
            return;

        KeyEvent keyEvent(this);
        keyEvent.urhoEvent = eventData;
        keyEvent.keyCode = eventData[Urho3D::KeyDown::P_KEY].GetInt();
        keyEvent.keyPressCount = existingKey->second_.keyPressCount;
        keyEvent.modifiers = eventData[Urho3D::KeyDown::P_QUALIFIERS].GetInt();
        //keyEvent.text = e->text(); ///\todo
        keyEvent.eventType = KeyEvent::KeyReleased;
        //keyEvent.otherHeldKeys = heldKeys; ///\todo
        keyEvent.handled = false;
        keyEvent.timestamp = framework->Frame()->WallClockTime();

        heldKeys.Erase(existingKey);
        currentModifiers = eventData[Urho3D::KeyDown::P_QUALIFIERS].GetInt(); // local tracking for mouse events

        // Queue up the release event for the polling API, independent of whether any Qt widget has keyboard focus.
        if (keyEvent.keyPressCount == 1) /// \todo The polling API does not get key repeats at all. Should it?
            newKeysReleasedQueue.Push(eventData[Urho3D::KeyDown::P_KEY].GetInt());

        TriggerKeyEvent(keyEvent);
        
        return; // Suppress this event from going forward.
    }

    else if (eventType == Urho3D::E_MOUSEBUTTONDOWN || eventType == Urho3D::E_MOUSEBUTTONUP)
    {
        // We always update the global polled input states, independent of whether any the mouse cursor is
        // on top of any Qt widget.
        if (eventType == Urho3D::E_MOUSEBUTTONDOWN)
        {
            heldMouseButtons |= eventData[Urho3D::MouseButtonDown::P_BUTTON].GetInt();  //(MouseEvent::MouseButton)e->button();
            newMouseButtonsPressedQueue |= eventData[Urho3D::MouseButtonDown::P_BUTTON].GetInt();
        }
        else
        {
            heldMouseButtons &= ~eventData[Urho3D::MouseButtonDown::P_BUTTON].GetInt();
            newMouseButtonsReleasedQueue |= eventData[Urho3D::MouseButtonDown::P_BUTTON].GetInt();
        }

        // The mouse coordinates we receive can come from different widgets, and we are interested only in the coordinates
        // in the QGraphicsView client area, so we need to remap them.
        Point mousePos(input->GetMousePosition().x_, input->GetMousePosition().y_);//MapPointToMainGraphicsView(obj, e->pos());

        MouseEvent mouseEvent(this);
        mouseEvent.eventType = (eventType == Urho3D::E_MOUSEBUTTONDOWN) ? MouseEvent::MousePressed : MouseEvent::MouseReleased;

        mouseEvent.button = (MouseEvent::MouseButton)eventData[Urho3D::MouseButtonDown::P_BUTTON].GetInt();
        mouseEvent.x = mousePos.x;
        mouseEvent.y = mousePos.y;
        mouseEvent.z = 0;
        // Mouse presses do not carry relative mouse movement information at the same time.
        // (separate relative movement messages are passed for first-person mode moves)
        mouseEvent.relativeX = 0;
        mouseEvent.relativeY = 0;
        
        mouseEvent.relativeZ = 0;
        mouseEvent.modifiers = eventData[Urho3D::MouseButtonDown::P_QUALIFIERS].GetInt();//currentModifiers;

        lastMouseX = mouseEvent.x;
        lastMouseY = mouseEvent.y;

        mouseEvent.globalX = mouseEvent.x;
        mouseEvent.globalY = mouseEvent.y;

        mouseEvent.otherButtons = eventData[Urho3D::MouseButtonDown::P_BUTTONS].GetUInt();
        mouseEvent.modifiers = eventData[Urho3D::MouseButtonDown::P_QUALIFIERS].GetInt();
        for (auto current = heldKeys.Begin(); current != heldKeys.End(); ++ current)
            mouseEvent.heldKeys.Push((*current).first_);
        mouseEvent.handled = false;
        mouseEvent.timestamp = framework->Frame()->WallClockTime();

        TriggerMouseEvent(mouseEvent);
        return;
    }

    //case Urho3D::E_MOUSEMOVE:
    else if (eventType == Urho3D::E_MOUSEMOVE)
    {
        MouseEvent mouseEvent(this);
        mouseEvent.eventType = MouseEvent::MouseMove;
        mouseEvent.button = (MouseEvent::MouseButton)eventData[Urho3D::MouseMove::P_BUTTONS].GetInt();

        // The mouse coordinates we receive can come from different widgets, and we are interested only in the coordinates
        // in the QGraphicsView client area, so we need to remap them.
        Point mousePos(input->GetMousePosition().x_, input->GetMousePosition().y_);

        mouseEvent.z = 0;
        mouseEvent.relativeX = eventData[Urho3D::MouseMove::P_DX].GetInt();
        mouseEvent.relativeY = eventData[Urho3D::MouseMove::P_DY].GetInt();
        mouseEvent.relativeZ = 0;

        mouseEvent.x = mousePos.x;
        mouseEvent.y = mousePos.y;

        // If there wasn't any change to the mouse relative coords in FPS mode, ignore this event.
        if (mouseEvent.relativeX == 0 && mouseEvent.relativeY == 0)
            return;
        
        mouseEvent.globalX = mousePos.x;
        mouseEvent.globalY = mousePos.y;
        mouseEvent.otherButtons = eventData[Urho3D::MouseMove::P_BUTTONS].GetInt();
        for (auto current = heldKeys.Begin(); current != heldKeys.End(); ++ current)
            mouseEvent.heldKeys.Push((*current).first_);
        mouseEvent.handled = false;
        mouseEvent.timestamp = framework->Frame()->WallClockTime();

        // Save the absolute coordinates to be able to compute the proper relative movement values in the next
        // mouse event.
        lastMouseX = mouseEvent.x;
        lastMouseY = mouseEvent.y;

        TriggerMouseEvent(mouseEvent);

        return;
    }

    else if (eventType == Urho3D::E_MOUSEWHEEL)
    {
        MouseEvent mouseEvent(this);
        mouseEvent.eventType = MouseEvent::MouseScroll;
        
        mouseEvent.button = MouseEvent::NoButton;
        mouseEvent.otherButtons = eventData[Urho3D::MouseWheel::P_BUTTONS].GetInt();
        mouseEvent.x = input->GetMousePosition().x_;
        mouseEvent.y = input->GetMousePosition().y_;
        mouseEvent.z = 0; // Mouse wheel does not have an absolute z position, only relative.
        mouseEvent.relativeX = 0;
        mouseEvent.relativeY = 0;
        mouseEvent.relativeZ = eventData[Urho3D::MouseWheel::P_WHEEL].GetInt();
        mouseEvent.globalX = input->GetMousePosition().x_;
        mouseEvent.globalY = input->GetMousePosition().y_;

        mouseEvent.modifiers = eventData[Urho3D::MouseWheel::P_QUALIFIERS].GetInt();
        for (auto current = heldKeys.Begin(); current != heldKeys.End(); ++ current)
            mouseEvent.heldKeys.Push((*current).first_);
        mouseEvent.handled = false;
        mouseEvent.timestamp = framework->Frame()->WallClockTime();

        TriggerMouseEvent(mouseEvent);
        return;
    }
    else if (eventType == Urho3D::E_TOUCHBEGIN)
    {
        UpdateTouchPoints();
        TouchBegin.Emit(eventData);
        return;
    }
    else if (eventType == Urho3D::E_TOUCHMOVE)
    {
        UpdateTouchPoints();
        TouchUpdate.Emit(eventData);
        return;
    }

    else if (eventType == Urho3D::E_TOUCHEND)
    {
        UpdateTouchPoints();
        TouchEnd.Emit(eventData);
        return;
        
    } // ~switch
}
Ejemplo n.º 6
0
KeySequence InputAPI::KeyBinding(const String &actionName) const
{
    auto iter = keyboardMappings.Find(actionName);
    return iter != keyboardMappings.End() ? iter->second_ : KeySequence();
}