366 lines
10 KiB
C++
366 lines
10 KiB
C++
/*************************************************************************/
|
|
/* haiku_direct_window.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
#include <UnicodeChar.h>
|
|
|
|
#include "haiku_direct_window.h"
|
|
#include "key_mapping_haiku.h"
|
|
#include "main/main.h"
|
|
#include "os/keyboard.h"
|
|
|
|
HaikuDirectWindow::HaikuDirectWindow(BRect p_frame) :
|
|
BDirectWindow(p_frame, "Godot", B_TITLED_WINDOW, B_QUIT_ON_WINDOW_CLOSE) {
|
|
last_mouse_pos_valid = false;
|
|
last_buttons_state = 0;
|
|
last_button_mask = 0;
|
|
last_key_modifier_state = 0;
|
|
}
|
|
|
|
HaikuDirectWindow::~HaikuDirectWindow() {
|
|
delete update_runner;
|
|
}
|
|
|
|
void HaikuDirectWindow::SetHaikuGLView(HaikuGLView *p_view) {
|
|
view = p_view;
|
|
}
|
|
|
|
void HaikuDirectWindow::StartMessageRunner() {
|
|
update_runner = new BMessageRunner(BMessenger(this),
|
|
new BMessage(REDRAW_MSG), 1000000 / 30 /* 30 fps */);
|
|
}
|
|
|
|
void HaikuDirectWindow::StopMessageRunner() {
|
|
delete update_runner;
|
|
}
|
|
|
|
void HaikuDirectWindow::SetInput(InputDefault *p_input) {
|
|
input = p_input;
|
|
}
|
|
|
|
void HaikuDirectWindow::SetMainLoop(MainLoop *p_main_loop) {
|
|
main_loop = p_main_loop;
|
|
}
|
|
|
|
bool HaikuDirectWindow::QuitRequested() {
|
|
main_loop->notification(MainLoop::NOTIFICATION_WM_QUIT_REQUEST);
|
|
return false;
|
|
}
|
|
|
|
void HaikuDirectWindow::DirectConnected(direct_buffer_info *info) {
|
|
view->DirectConnected(info);
|
|
view->EnableDirectMode(true);
|
|
}
|
|
|
|
void HaikuDirectWindow::MessageReceived(BMessage *message) {
|
|
switch (message->what) {
|
|
case REDRAW_MSG:
|
|
if (Main::iteration() == true) {
|
|
view->EnableDirectMode(false);
|
|
Quit();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
BDirectWindow::MessageReceived(message);
|
|
}
|
|
}
|
|
|
|
void HaikuDirectWindow::DispatchMessage(BMessage *message, BHandler *handler) {
|
|
switch (message->what) {
|
|
case B_MOUSE_DOWN:
|
|
case B_MOUSE_UP:
|
|
HandleMouseButton(message);
|
|
break;
|
|
|
|
case B_MOUSE_MOVED:
|
|
HandleMouseMoved(message);
|
|
break;
|
|
|
|
case B_MOUSE_WHEEL_CHANGED:
|
|
HandleMouseWheelChanged(message);
|
|
break;
|
|
|
|
case B_KEY_DOWN:
|
|
case B_KEY_UP:
|
|
HandleKeyboardEvent(message);
|
|
break;
|
|
|
|
case B_MODIFIERS_CHANGED:
|
|
HandleKeyboardModifierEvent(message);
|
|
break;
|
|
|
|
case B_WINDOW_RESIZED:
|
|
HandleWindowResized(message);
|
|
break;
|
|
|
|
case LOCKGL_MSG:
|
|
view->LockGL();
|
|
break;
|
|
|
|
case UNLOCKGL_MSG:
|
|
view->UnlockGL();
|
|
break;
|
|
|
|
default:
|
|
BDirectWindow::DispatchMessage(message, handler);
|
|
}
|
|
}
|
|
|
|
void HaikuDirectWindow::HandleMouseButton(BMessage *message) {
|
|
BPoint where;
|
|
if (message->FindPoint("where", &where) != B_OK) {
|
|
return;
|
|
}
|
|
|
|
uint32 modifiers = message->FindInt32("modifiers");
|
|
uint32 buttons = message->FindInt32("buttons");
|
|
uint32 button = buttons ^ last_buttons_state;
|
|
last_buttons_state = buttons;
|
|
|
|
// TODO: implement the mouse_mode checks
|
|
/*
|
|
if (mouse_mode == MOUSE_MODE_CAPTURED) {
|
|
event.xbutton.x=last_mouse_pos.x;
|
|
event.xbutton.y=last_mouse_pos.y;
|
|
}
|
|
*/
|
|
|
|
Ref<InputEvent> mouse_event;
|
|
mouse_event.type = Ref<InputEvent>::MOUSE_BUTTON;
|
|
mouse_event.device = 0;
|
|
|
|
mouse_event.mouse_button.mod = GetKeyModifierState(modifiers);
|
|
mouse_event->get_button_mask() = GetMouseButtonState(buttons);
|
|
mouse_event->get_position().x = where.x;
|
|
mouse_event->get_position().y = where.y;
|
|
mouse_event.mouse_button.global_x = where.x;
|
|
mouse_event.mouse_button.global_y = where.y;
|
|
|
|
switch (button) {
|
|
default:
|
|
case B_PRIMARY_MOUSE_BUTTON:
|
|
mouse_event->get_button_index() = 1;
|
|
break;
|
|
|
|
case B_SECONDARY_MOUSE_BUTTON:
|
|
mouse_event->get_button_index() = 2;
|
|
break;
|
|
|
|
case B_TERTIARY_MOUSE_BUTTON:
|
|
mouse_event->get_button_index() = 3;
|
|
break;
|
|
}
|
|
|
|
mouse_event->is_pressed() = (message->what == B_MOUSE_DOWN);
|
|
|
|
if (message->what == B_MOUSE_DOWN && mouse_event->get_button_index() == 1) {
|
|
int32 clicks = message->FindInt32("clicks");
|
|
|
|
if (clicks > 1) {
|
|
mouse_event.mouse_button.doubleclick = true;
|
|
}
|
|
}
|
|
|
|
input->parse_input_event(mouse_event);
|
|
}
|
|
|
|
void HaikuDirectWindow::HandleMouseMoved(BMessage *message) {
|
|
BPoint where;
|
|
if (message->FindPoint("where", &where) != B_OK) {
|
|
return;
|
|
}
|
|
|
|
Point2i pos(where.x, where.y);
|
|
uint32 modifiers = message->FindInt32("modifiers");
|
|
uint32 buttons = message->FindInt32("buttons");
|
|
|
|
if (!last_mouse_pos_valid) {
|
|
last_mouse_position = pos;
|
|
last_mouse_pos_valid = true;
|
|
}
|
|
|
|
Point2i rel = pos - last_mouse_position;
|
|
|
|
Ref<InputEvent> motion_event;
|
|
motion_event.type = Ref<InputEvent>::MOUSE_MOTION;
|
|
motion_event.device = 0;
|
|
|
|
motion_event.mouse_motion.mod = GetKeyModifierState(modifiers);
|
|
motion_event->get_button_mask() = GetMouseButtonState(buttons);
|
|
motion_event.mouse_motion.x = pos.x;
|
|
motion_event.mouse_motion.y = pos.y;
|
|
input->set_mouse_position(pos);
|
|
motion_event.mouse_motion.global_x = pos.x;
|
|
motion_event.mouse_motion.global_y = pos.y;
|
|
motion_event.mouse_motion.speed_x = input->get_last_mouse_speed().x;
|
|
motion_event.mouse_motion.speed_y = input->get_last_mouse_speed().y;
|
|
|
|
motion_event->get_relative().x = rel.x;
|
|
motion_event->get_relative().y = rel.y;
|
|
|
|
last_mouse_position = pos;
|
|
|
|
input->parse_input_event(motion_event);
|
|
}
|
|
|
|
void HaikuDirectWindow::HandleMouseWheelChanged(BMessage *message) {
|
|
float wheel_delta_y = 0;
|
|
if (message->FindFloat("be:wheel_delta_y", &wheel_delta_y) != B_OK) {
|
|
return;
|
|
}
|
|
|
|
Ref<InputEvent> mouse_event;
|
|
mouse_event.type = Ref<InputEvent>::MOUSE_BUTTON;
|
|
mouse_event.device = 0;
|
|
|
|
mouse_event->get_button_index() = wheel_delta_y < 0 ? 4 : 5;
|
|
mouse_event.mouse_button.mod = GetKeyModifierState(last_key_modifier_state);
|
|
mouse_event->get_button_mask() = last_button_mask;
|
|
mouse_event->get_position().x = last_mouse_position.x;
|
|
mouse_event->get_position().y = last_mouse_position.y;
|
|
mouse_event.mouse_button.global_x = last_mouse_position.x;
|
|
mouse_event.mouse_button.global_y = last_mouse_position.y;
|
|
|
|
mouse_event->is_pressed() = true;
|
|
input->parse_input_event(mouse_event);
|
|
|
|
mouse_event->is_pressed() = false;
|
|
input->parse_input_event(mouse_event);
|
|
}
|
|
|
|
void HaikuDirectWindow::HandleKeyboardEvent(BMessage *message) {
|
|
int32 raw_char = 0;
|
|
int32 key = 0;
|
|
int32 modifiers = 0;
|
|
|
|
if (message->FindInt32("raw_char", &raw_char) != B_OK) {
|
|
return;
|
|
}
|
|
|
|
if (message->FindInt32("key", &key) != B_OK) {
|
|
return;
|
|
}
|
|
|
|
if (message->FindInt32("modifiers", &modifiers) != B_OK) {
|
|
return;
|
|
}
|
|
|
|
Ref<InputEvent> event;
|
|
event.type = Ref<InputEvent>::KEY;
|
|
event.device = 0;
|
|
event.key.mod = GetKeyModifierState(modifiers);
|
|
event->is_pressed() = (message->what == B_KEY_DOWN);
|
|
event->get_scancode() = KeyMappingHaiku::get_keysym(raw_char, key);
|
|
event->is_echo() = message->HasInt32("be:key_repeat");
|
|
event.key.unicode = 0;
|
|
|
|
const char *bytes = NULL;
|
|
if (message->FindString("bytes", &bytes) == B_OK) {
|
|
event.key.unicode = BUnicodeChar::FromUTF8(&bytes);
|
|
}
|
|
|
|
//make it consistent across platforms.
|
|
if (event->get_scancode() == KEY_BACKTAB) {
|
|
event->get_scancode() = KEY_TAB;
|
|
event->get_shift() = true;
|
|
}
|
|
|
|
input->parse_input_event(event);
|
|
}
|
|
|
|
void HaikuDirectWindow::HandleKeyboardModifierEvent(BMessage *message) {
|
|
int32 old_modifiers = 0;
|
|
int32 modifiers = 0;
|
|
|
|
if (message->FindInt32("be:old_modifiers", &old_modifiers) != B_OK) {
|
|
return;
|
|
}
|
|
|
|
if (message->FindInt32("modifiers", &modifiers) != B_OK) {
|
|
return;
|
|
}
|
|
|
|
int32 key = old_modifiers ^ modifiers;
|
|
|
|
Ref<InputEvent> event;
|
|
event.type = Ref<InputEvent>::KEY;
|
|
event.device = 0;
|
|
event.key.mod = GetKeyModifierState(modifiers);
|
|
event->is_pressed() = ((modifiers & key) != 0);
|
|
event->get_scancode() = KeyMappingHaiku::get_modifier_keysym(key);
|
|
event->is_echo() = false;
|
|
event.key.unicode = 0;
|
|
|
|
input->parse_input_event(event);
|
|
}
|
|
|
|
void HaikuDirectWindow::HandleWindowResized(BMessage *message) {
|
|
int32 width = 0;
|
|
int32 height = 0;
|
|
|
|
if ((message->FindInt32("width", &width) != B_OK) || (message->FindInt32("height", &height) != B_OK)) {
|
|
return;
|
|
}
|
|
|
|
current_video_mode->width = width;
|
|
current_video_mode->height = height;
|
|
}
|
|
|
|
inline InputModifierState HaikuDirectWindow::GetKeyModifierState(uint32 p_state) {
|
|
last_key_modifier_state = p_state;
|
|
InputModifierState state;
|
|
|
|
state.shift = (p_state & B_SHIFT_KEY) != 0;
|
|
state.control = (p_state & B_CONTROL_KEY) != 0;
|
|
state.alt = (p_state & B_OPTION_KEY) != 0;
|
|
state.meta = (p_state & B_COMMAND_KEY) != 0;
|
|
|
|
return state;
|
|
}
|
|
|
|
inline int HaikuDirectWindow::GetMouseButtonState(uint32 p_state) {
|
|
int state = 0;
|
|
|
|
if (p_state & B_PRIMARY_MOUSE_BUTTON) {
|
|
state |= 1 << 0;
|
|
}
|
|
|
|
if (p_state & B_SECONDARY_MOUSE_BUTTON) {
|
|
state |= 1 << 1;
|
|
}
|
|
|
|
if (p_state & B_TERTIARY_MOUSE_BUTTON) {
|
|
state |= 1 << 2;
|
|
}
|
|
|
|
last_button_mask = state;
|
|
|
|
return state;
|
|
}
|