bool AGameController::handleEvent(sf::Event const& event) {
switch (event.type) {
case sf::Event::MouseMoved:
return onMouseOver(event);
case sf::Event::MouseButtonPressed:
return onMouseClick(event);
case sf::Event::MouseButtonReleased:
return onMouseClickReleased(event);
case sf::Event::KeyPressed:
return onKeyPressed(event);
case sf::Event::Closed:
return onClose(event);
case sf::Event::TextEntered:
return onText(event);
default:
break;
}
return false;
}
void Widget::handleEvents(void)
{
if(dumb)
return;
bool lastWithin = hover;
bool lastMouseDown = mouseDown;
mouseDown = g_Input.MouseLeft;
within = isWithin();
// Mouse Enter
if(within && !lastWithin)
{
hover = true;
onMouseEnter();
}
// Mouse Exit
if(!within && lastWithin)
{
hover = false;
onMouseExit();
}
g_GUI.mouseOverSomeWidget |= hover;
// Mouse Up
if(!mouseDown && lastMouseDown)
{
if(hover)
{
onMouseUp();
// Click
if(depressed && !g_GUI.clickAlreadyProcessedThisTick)
{
g_GUI.clickAlreadyProcessedThisTick = true; // top-most widgets are updated first anyway
g_SoundSystem.play("data/sound/click.wav");
onMouseClick();
}
}
depressed = false;
}
// Mouse Down
if(hover && mouseDown)
{
depressed = true;
if(!lastMouseDown)
{
onMouseDown();
}
}
}
void
Button::OnMouseUp(Control * sender)
{
if ( mouse_down) {
onMouseClick(this);
mouse_down = false;
SetActiveState(state_mouse);
}
}
void ColorPicker::processMouse(const scv::MouseEvent &evt) {
static Kernel *kernel = Kernel::getInstance();
static Cursor * cursor = Cursor::getInstance();
if (!_receivingCallbacks) {
Component::processMouse(evt);
} else {
Panel::processMouse(evt);
}
if (!_receivingCallbacks) return;
if (_pickerWaitingColor) {
kernel->lockMouseUse(this);
cursor->forceCursor(kernel->glfwWindow, GLFW_CROSSHAIR_CURSOR);
glReadPixels(evt.getPosition().x, evt.getInversePosition().y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &_currentColor);
setSpinsColor();
onColorChange();
if (evt.getState() == MouseEvent::CLICK && evt.getButton() == MouseEvent::LEFT) {
_btPicker->setState(false);
_pickerWaitingColor = false;
_currentColorPosition = foundHSL();
createTexture();
}
} else {
if (isInside(evt.getPosition()) && kernel->requestMouseUse(this)) {
if (isFocused()) {
Point relativeMouse = evt.getPosition()-getAbsolutePosition();
if (relativeMouse.x < MatrixTemplate<ColorRGBA>::getWidth() && relativeMouse.y < MatrixTemplate<ColorRGBA>::getHeight()) {
cursor->forceCursor(kernel->glfwWindow, GLFW_CROSSHAIR_CURSOR);
if (evt.getState() == MouseEvent::CLICK && evt.getButton() == MouseEvent::LEFT) {
_isDragging = false;
_currentColorPosition = relativeMouse;
_currentColor = ColorRGBA(MatrixTemplate<ColorRGBA>::get(_currentColorPosition.y,_currentColorPosition.x));
setSpinsColor();
onColorChange();
onMouseClick(evt);
} else if (evt.getState() == MouseEvent::HOLD && evt.getButton() == MouseEvent::LEFT) {
kernel->lockMouseUse(this);
_isDragging = false;
_currentColorPosition = relativeMouse;
_currentColor = ColorRGBA(MatrixTemplate<ColorRGBA>::get(_currentColorPosition.y,_currentColorPosition.x));
setSpinsColor();
onColorChange();
onMouseDrag(evt);
} else if (evt.getState() == MouseEvent::UP) {
kernel->unlockMouseUse(this);
}
}
}
} else if (evt.getState() == MouseEvent::UP) {
kernel->unlockMouseUse(this);
}
}
}
void Widget::onEvent (Event *e)
{
MouseClickEvent *eClick = Class::SafeCast< MouseClickEvent >( e );
if (eClick != NULL) onMouseClick( eClick );
MouseEnterEvent *eEnter = Class::SafeCast< MouseEnterEvent >( e );
if (eEnter != NULL) onMouseEnter( eEnter );
MouseLeaveEvent *eLeave = Class::SafeCast< MouseLeaveEvent >( e );
if (eLeave != NULL) onMouseLeave( eLeave );
}
QSanSkillButton::QSanSkillButton(QGraphicsItem *parent)
: QSanButton(parent)
{
_m_groupName = QSanRoomSkin::S_SKIN_KEY_BUTTON_SKILL;
_m_emitActivateSignal = false;
_m_emitDeactivateSignal = false;
_m_canEnable = true;
_m_canDisable = true;
_m_skill = NULL;
_m_viewAsSkill = NULL;
connect(this, SIGNAL(clicked()), this, SLOT(onMouseClick()));
_m_skill = NULL;
}
void ContextMenu::processMouseCallback(const MouseEvent &evt, std::deque<std::string> address) {
static MenuHolder *holder = MenuHolder::getInstance();
address.push_front(_label);
if (_parentMenu == NULL) {
if (evt.getState() == MouseEvent::UP) {
holder->closeAllMenus();
onMouseClick(evt, address);
onMenuAccessed(address);
} else if (evt.getState() == MouseEvent::MOTION) {
onMouseOver(evt, address);
}
} else _parentMenu->processMouseCallback(evt, address);
}
void RectangleButton::Update(){
isPressed = wasPressed = false;
if (mouseIn()){
select();
if (mouseX_pre != mouseX && mouseY_pre != mouseY && onMouseIn)
onMouseIn();
if (hge->Input_KeyUp(HGEK_LBUTTON)){
if(onMouseClick)
onMouseClick();
wasPressed = true;
}
if (hge->Input_GetKeyState(HGEK_LBUTTON)){
float mod = 0.5;
captionDx *= mod;
captionDy *= mod;
isPressed = true;
}
}else{
deselect();
if (in(mouseX_pre, mouseY_pre) && onMouseOut)
onMouseOut();
}
}
bool updateMouse() {
if (mouse_fd < 0) {
return false;
}
struct input_event mousee;
while ( readMouseEvent(&mousee) ) {
mouse.velX=0;
mouse.velY=0;
float x,y = 0.0f;
int button = 0;
switch(mousee.type) {
// Update Mouse Event
case EV_KEY:
switch (mousee.code) {
case BTN_LEFT:
if (mousee.value == 1){
button = 1;
}
break;
case BTN_RIGHT:
if(mousee.value == 1){
button = 2;
}
break;
case BTN_MIDDLE:
if(mousee.value == 1){
button = 3;
}
break;
default:
button = 0;
break;
}
if (button != mouse.button) {
mouse.button = button;
if(mouse.button == 0){
onMouseRelease(mouse.x,mouse.y);
} else {
onMouseClick(mouse.x,mouse.y,mouse.button);
}
}
break;
case EV_REL:
switch (mousee.code) {
case REL_X:
mouse.velX = mousee.value;
break;
case REL_Y:
mousee.value = mousee.value * -1;
mouse.velY = mousee.value;
break;
// case REL_WHEEL:
// if (mousee.value > 0)
// std::cout << "Mouse wheel Forward" << std::endl;
// else if(mousee.value < 0)
// std::cout << "Mouse wheel Backward" << std::endl;
// break;
default:
break;
}
mouse.x+=mouse.velX;
mouse.y+=mouse.velY;
// Clamp values
if (mouse.x < 0) mouse.x=0;
if (mouse.y < 0) mouse.y=0;
if (mouse.x > viewport.z) mouse.x = viewport.z;
if (mouse.y > viewport.w) mouse.y = viewport.w;
if (mouse.button != 0) {
onMouseDrag(mouse.x,mouse.y,mouse.button);
} else {
onMouseMove(mouse.x,mouse.y);
}
break;
case EV_ABS:
switch (mousee.code) {
case ABS_X:
x = ((float)mousee.value/4095.0f)*viewport.z;
mouse.velX = x - mouse.x;
mouse.x = x;
break;
case ABS_Y:
y = (1.0-((float)mousee.value/4095.0f))*viewport.w;
mouse.velY = y - mouse.y;
mouse.y = y;
break;
default:
break;
}
if (mouse.button != 0) {
onMouseDrag(mouse.x,mouse.y,mouse.button);
} else {
onMouseMove(mouse.x,mouse.y);
}
break;
default:
break;
}
}
return true;
}
void Window::process(const InputState &state) {
Window *popup = nullptr;
m_is_focused = true;
for(int n = 0; n < (int)m_children.size(); n++) {
m_children[n]->m_is_focused = false;
m_children[n]->m_is_mouse_over = false;
if(m_children[n]->m_is_closing) {
PWindow window = m_children[n];
m_children.erase(m_children.begin() + n);
sendEvent(window.get(), Event::window_closed, m_children[n]->m_closing_value);
n--;
}
else if(m_children[n]->m_is_popup)
popup = m_children[n].get();
}
if(popup) {
popup->process(state);
return;
}
int2 mouse_pos = state.mousePos();
int2 local_mouse_pos = mouse_pos - m_clipped_rect.min;
int finished_dragging = 0;
bool escape = state.isKeyDown(InputKey::esc);
InputButton button_map[3] = { InputButton::left, InputButton::right, InputButton::middle };
if(m_dragging_mode) {
if(!state.isMouseButtonPressed(button_map[m_dragging_mode - 1]) || escape)
finished_dragging = escape? -1 : 1;
}
else {
for(int k = 0; k < 3; k++) {
if(state.isMouseButtonDown(button_map[k])) {
m_dragging_mode = k + 1;
m_drag_start = local_mouse_pos;
break;
}
}
}
int2 focus_point = m_dragging_mode? m_drag_start : local_mouse_pos;
bool is_handled = false;
for(int n = (int)m_children.size() - 1; n >= 0; n--) {
Window *child = m_children[n].get();
if(child->isVisible() && m_has_hard_focus == child->m_has_hard_focus) {
if(m_has_hard_focus || child->rect().isInside(focus_point)) {
child->m_is_mouse_over = child->clippedRect().isInside(mouse_pos);
child->process(state);
is_handled = true;
break;
}
}
}
if(!is_handled) {
if(m_dragging_mode && !is_handled) {
if(m_has_inner_rect && m_dragging_mode - 1 == 2) {
setInnerRect(m_inner_rect + state.mouseMove());
is_handled = true;
}
if(!is_handled)
is_handled = onMouseDrag(state, m_drag_start, local_mouse_pos, m_dragging_mode - 1, finished_dragging);
if(!is_handled)
is_handled = onMouseClick(state, local_mouse_pos, m_dragging_mode - 1, finished_dragging);
}
if(!is_handled) {
if(m_has_inner_rect) {
int wheel = state.mouseWheelMove();
int2 vector(0, 0);
if(wheel)
vector.y += wheel * rect().height() / 8;
if(state.isKeyDownAuto(InputKey::pageup, 2))
vector.y += rect().height();
if(state.isKeyDownAuto(InputKey::pagedown, 2))
vector.y -= rect().height();
setInnerRect(m_inner_rect + vector);
}
onInput(state);
}
}
if(escape && (!m_parent || m_is_popup) && !m_dragging_mode) // sending Event::escape only from main window
sendEvent(this, Event::escape); //TODO: send only to focused windows
if(finished_dragging)
m_dragging_mode = 0;
}
