void DisplayWindow::mouseCallback(int event, int x, int y, int flags, void* param){
    switch (event){
    case EVENT_LBUTTONDOWN:
        dragStartL = Point(x,y);
        leftDrag = true;
        clickTime = std::chrono::system_clock::now();
        break;
    case EVENT_RBUTTONDOWN:
        dragStartR = Point(x,y);
        rightDrag = true;
        clickTime = std::chrono::system_clock::now();
        break;
    case EVENT_LBUTTONUP:
        if (dragging) {onDragStop();} else {onLeftClick();}
        leftDrag = false;
        dragging = false;
        break;
    case EVENT_RBUTTONUP:
        if (dragging) {onDragStop();} else {onRightClick();}
        rightDrag = false;
        dragging = false;
        break;
    case EVENT_MOUSEMOVE:
        currentPos = Point(x,y);
        auto diff = std::chrono::system_clock::now()-clickTime;
        std::chrono::milliseconds ms = std::chrono::duration_cast<std::chrono::milliseconds>(diff);
        std::chrono::milliseconds oneClick(250);
        if ((leftDrag || rightDrag) && ms > oneClick) {dragging = true;}
        break;
    }
}
Esempio n. 2
0
void GameObject::update(const sf::Time& frameTime) {
	for (auto& component : m_components) {
		component->update(frameTime);
	}
	if (g_inputController->isMouseOver(&m_boundingBox, m_isInputInDefaultView)) {
		onMouseOver();
		// if the inputcontroller has locked actions, skip these methods.
		if (g_inputController->isActionLocked()) return;

		if (g_inputController->isRightClicked(&m_boundingBox, m_isInputInDefaultView)) {
			onRightClick();
		}
		else if (g_inputController->isRightJustPressed(&m_boundingBox, m_isInputInDefaultView)) {
			onRightJustPressed();
		}
		else if (g_inputController->isLeftClicked(&m_boundingBox, m_isInputInDefaultView)) {
			onLeftClick();
		}
		else if (g_inputController->isLeftJustPressed(&m_boundingBox, m_isInputInDefaultView)) {
			onLeftJustPressed();
		}
	}
}
Esempio n. 3
0
    void Element::handleQueuedEvent(std::shared_ptr<Events::Event> event) {
      switch(event->getEventType()) {
        case Events::EventType::MOUSE_CURSOR: {
          auto casted_event = std::static_pointer_cast<Input::MouseCursorEvent>(event);
          if(cursor_within == false && isActive() && isPointWithin(casted_event->getPosition())) {
            cursor_within = true;
            onCursorEnter();
          }
          else if(cursor_within == true && isActive() && !isPointWithin(casted_event->getPosition())) {
            cursor_within = false;
            onCursorLeave();
          }
          break;
        }

        case Events::EventType::MOUSE_SCROLL: {
          auto casted_event = std::static_pointer_cast<Input::MouseScrollEvent>(event);
          auto change = last_mouse_scroll_position - casted_event->getPosition();
          last_mouse_scroll_position = casted_event->getPosition();
          onScroll(change);
          break;
        }

        case Events::EventType::MOUSE_BUTTON_DOWN: {
          auto casted_event = std::static_pointer_cast<Input::MouseButtonDownEvent>(event);
          if(cursor_within && isActive() && casted_event->getButton() == GLFW_MOUSE_BUTTON_LEFT) {
            onLeftClick();
          }
          else if(cursor_within && isActive() && casted_event->getButton() == GLFW_MOUSE_BUTTON_RIGHT)
            onRightClick();
          break;
        }

        case Events::EventType::MOUSE_BUTTON_UP: {
          auto casted_event = std::static_pointer_cast<Input::MouseButtonUpEvent>(event);
          if(cursor_within && isActive() && casted_event->getButton() == GLFW_MOUSE_BUTTON_LEFT)
            onLeftClickRelease();
          else if(cursor_within && isActive() && casted_event->getButton() == GLFW_MOUSE_BUTTON_RIGHT)
            onRightClickRelease();
          break;
        }

        case Events::EventType::KEY_DOWN: {
          auto casted_event = std::static_pointer_cast<Input::KeyDownEvent>(event);
          onKeyDown(casted_event->getKey());
          break;
        }

        case Events::EventType::KEY_UP: {
          auto casted_event = std::static_pointer_cast<Input::KeyUpEvent>(event);
          onKeyUp(casted_event->getKey());
          break;
        }

        case Events::EventType::KEY_REPEAT: {
          auto casted_event = std::static_pointer_cast<Input::KeyRepeatEvent>(event);
          onKeyRepeat(casted_event->getKey());
          break;
        }

        default: {
          Renderable::handleQueuedEvent(event);
          break;
        }

      }
    }