RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
open_toontown_panda3d/panda/src/androiddisplay/androidGraphicsWindow.cxx

772 lines
25 KiB
C++
Raw Blame History

// Filename: androidGraphicsWindow.cxx
// Created by: rdb (11Jan13)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University. All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license. You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
#include "androidGraphicsWindow.h"
#include "androidGraphicsStateGuardian.h"
#include "config_androiddisplay.h"
#include "androidGraphicsPipe.h"
#include "graphicsPipe.h"
#include "keyboardButton.h"
#include "mouseButton.h"
#include "clockObject.h"
#include "pStatTimer.h"
#include "textEncoder.h"
#include "throw_event.h"
#include "nativeWindowHandle.h"
#include "android_native_app_glue.h"
#include <android/window.h>
#include <android/log.h>
extern struct android_app* panda_android_app;
TypeHandle AndroidGraphicsWindow::_type_handle;
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::Constructor
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
AndroidGraphicsWindow::
AndroidGraphicsWindow(GraphicsEngine *engine, GraphicsPipe *pipe,
const string &name,
const FrameBufferProperties &fb_prop,
const WindowProperties &win_prop,
int flags,
GraphicsStateGuardian *gsg,
GraphicsOutput *host) :
GraphicsWindow(engine, pipe, name, fb_prop, win_prop, flags, gsg, host)
{
AndroidGraphicsPipe *android_pipe;
DCAST_INTO_V(android_pipe, _pipe);
_egl_display = android_pipe->_egl_display;
_egl_surface = 0;
_app = panda_android_app;
GraphicsWindowInputDevice device =
GraphicsWindowInputDevice::pointer_and_keyboard(this, "keyboard_mouse");
add_input_device(device);
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::Destructor
// Access: Public, Virtual
// Description:
////////////////////////////////////////////////////////////////////
AndroidGraphicsWindow::
~AndroidGraphicsWindow() {
destroy_surface();
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::begin_frame
// Access: Public, Virtual
// Description: This function will be called within the draw thread
// before beginning rendering for a given frame. It
// should do whatever setup is required, and return true
// if the frame should be rendered, or false if it
// should be skipped.
////////////////////////////////////////////////////////////////////
bool AndroidGraphicsWindow::
begin_frame(FrameMode mode, Thread *current_thread) {
PStatTimer timer(_make_current_pcollector, current_thread);
begin_frame_spam(mode);
if (_gsg == (GraphicsStateGuardian *)NULL) {
return false;
}
//XXX not open yet.
if (_egl_surface == EGL_NO_SURFACE) {
return false;
}
AndroidGraphicsStateGuardian *androidgsg;
DCAST_INTO_R(androidgsg, _gsg, false);
{
if (eglGetCurrentDisplay() == _egl_display &&
eglGetCurrentSurface(EGL_READ) == _egl_surface &&
eglGetCurrentSurface(EGL_DRAW) == _egl_surface &&
eglGetCurrentContext() == androidgsg->_context) {
// No need to make the context current again. Short-circuit
// this possibly-expensive call.
} else {
// Need to set the context.
if (!eglMakeCurrent(_egl_display, _egl_surface, _egl_surface, androidgsg->_context)) {
androiddisplay_cat.error() << "Failed to call eglMakeCurrent: "
<< get_egl_error_string(eglGetError()) << "\n";
}
}
}
// Now that we have made the context current to a window, we can
// reset the GSG state if this is the first time it has been used.
// (We can't just call reset() when we construct the GSG, because
// reset() requires having a current context.)
androidgsg->reset_if_new();
if (mode == FM_render) {
// begin_render_texture();
clear_cube_map_selection();
}
_gsg->set_current_properties(&get_fb_properties());
return _gsg->begin_frame(current_thread);
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::end_frame
// Access: Public, Virtual
// Description: This function will be called within the draw thread
// after rendering is completed for a given frame. It
// should do whatever finalization is required.
////////////////////////////////////////////////////////////////////
void AndroidGraphicsWindow::
end_frame(FrameMode mode, Thread *current_thread) {
end_frame_spam(mode);
nassertv(_gsg != (GraphicsStateGuardian *)NULL);
if (mode == FM_render) {
// end_render_texture();
copy_to_textures();
}
_gsg->end_frame(current_thread);
if (mode == FM_render) {
trigger_flip();
clear_cube_map_selection();
}
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::end_flip
// Access: Public, Virtual
// Description: This function will be called within the draw thread
// after begin_flip() has been called on all windows, to
// finish the exchange of the front and back buffers.
//
// This should cause the window to wait for the flip, if
// necessary.
////////////////////////////////////////////////////////////////////
void AndroidGraphicsWindow::
end_flip() {
if (_gsg != (GraphicsStateGuardian *)NULL && _flip_ready) {
// It doesn't appear to be necessary to ensure the graphics
// context is current before flipping the windows, and insisting
// on doing so can be a significant performance hit.
//make_current();
if (_egl_surface != EGL_NO_SURFACE) {
eglSwapBuffers(_egl_display, _egl_surface);
}
}
GraphicsWindow::end_flip();
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::process_events
// Access: Public, Virtual
// Description: Do whatever processing is necessary to ensure that
// the window responds to user events. Also, honor any
// requests recently made via request_properties()
//
// This function is called only within the window
// thread.
////////////////////////////////////////////////////////////////////
void AndroidGraphicsWindow::
process_events() {
GraphicsWindow::process_events();
// Read all pending events.
int looper_id;
int events;
struct android_poll_source* source;
// Loop until all events are read.
while ((looper_id = ALooper_pollAll(0, NULL, &events, (void**)&source)) >= 0) {
// Process this event.
if (source != NULL) {
source->process(_app, source);
}
}
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::set_properties_now
// Access: Public, Virtual
// Description: Applies the requested set of properties to the
// window, if possible, for instance to request a change
// in size or minimization status.
//
// The window properties are applied immediately, rather
// than waiting until the next frame. This implies that
// this method may *only* be called from within the
// window thread.
//
// The return value is true if the properties are set,
// false if they are ignored. This is mainly useful for
// derived classes to implement extensions to this
// function.
////////////////////////////////////////////////////////////////////
void AndroidGraphicsWindow::
set_properties_now(WindowProperties &properties) {
if (_pipe == (GraphicsPipe *)NULL) {
// If the pipe is null, we're probably closing down.
GraphicsWindow::set_properties_now(properties);
return;
}
GraphicsWindow::set_properties_now(properties);
if (!properties.is_any_specified()) {
// The base class has already handled this case.
return;
}
// There's not really much we can change on Android.
if (properties.has_fullscreen()) {
uint32_t add_flags = 0;
uint32_t del_flags = 0;
if (_properties.get_fullscreen()) {
add_flags |= AWINDOW_FLAG_FULLSCREEN;
} else {
del_flags |= AWINDOW_FLAG_FULLSCREEN;
}
ANativeActivity_setWindowFlags(_app->activity, add_flags, del_flags);
_properties.set_fullscreen(properties.get_fullscreen());
properties.clear_fullscreen();
}
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::close_window
// Access: Protected, Virtual
// Description: Closes the window right now. Called from the window
// thread.
////////////////////////////////////////////////////////////////////
void AndroidGraphicsWindow::
close_window() {
destroy_surface();
if (_gsg != (GraphicsStateGuardian *)NULL) {
_gsg.clear();
}
GraphicsWindow::close_window();
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::open_window
// Access: Protected, Virtual
// Description: Opens the window right now. Called from the window
// thread. Returns true if the window is successfully
// opened, or false if there was a problem.
////////////////////////////////////////////////////////////////////
bool AndroidGraphicsWindow::
open_window() {
// GSG Creation/Initialization
AndroidGraphicsStateGuardian *androidgsg;
if (_gsg == 0) {
// There is no old gsg. Create a new one.
androidgsg = new AndroidGraphicsStateGuardian(_engine, _pipe, NULL);
androidgsg->choose_pixel_format(_fb_properties, false, false);
_gsg = androidgsg;
} else {
// If the old gsg has the wrong pixel format, create a
// new one that shares with the old gsg.
DCAST_INTO_R(androidgsg, _gsg, false);
if (!androidgsg->get_fb_properties().subsumes(_fb_properties)) {
androidgsg = new AndroidGraphicsStateGuardian(_engine, _pipe, androidgsg);
androidgsg->choose_pixel_format(_fb_properties, false, false);
_gsg = androidgsg;
}
}
// Register the callbacks
assert(_app != NULL);
_app->userData = this;
_app->onAppCmd = handle_command;
_app->onInputEvent = handle_input_event;
// Wait until Android has opened the window.
while (_app->window == NULL) {
process_events();
}
// create_surface should have been called by now.
if (_egl_surface == EGL_NO_SURFACE) {
return false;
}
// Set some other properties.
_properties.set_origin(0, 0);
_properties.set_cursor_hidden(true);
_properties.set_undecorated(true);
if (!androidgsg->get_fb_properties().verify_hardware_software
(_fb_properties, androidgsg->get_gl_renderer())) {
close_window();
return false;
}
//_fb_properties = androidgsg->get_fb_properties();
androiddisplay_cat.error() << "open_window done\n";
return true;
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::destroy_surface
// Access: Protected, Virtual
// Description: Terminates the EGL surface.
////////////////////////////////////////////////////////////////////
void AndroidGraphicsWindow::
destroy_surface() {
if (_egl_surface != EGL_NO_SURFACE) {
if (!eglDestroySurface(_egl_display, _egl_surface)) {
androiddisplay_cat.error() << "Failed to destroy surface: "
<< get_egl_error_string(eglGetError()) << "\n";
}
_egl_surface = EGL_NO_SURFACE;
}
// Destroy the current context.
if (_gsg != (GraphicsStateGuardian *)NULL) {
AndroidGraphicsStateGuardian *androidgsg;
DCAST_INTO_V(androidgsg, _gsg);
androidgsg->destroy_context();
}
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::create_surface
// Access: Protected, Virtual
// Description: Creates the EGL surface.
////////////////////////////////////////////////////////////////////
bool AndroidGraphicsWindow::
create_surface() {
AndroidGraphicsStateGuardian *androidgsg;
DCAST_INTO_R(androidgsg, _gsg, false);
// Reconfigure the window buffers to match that of our framebuffer config.
ANativeWindow_setBuffersGeometry(_app->window, 0, 0, androidgsg->_format);
// Set any window flags
uint32_t add_flags = 0;
uint32_t del_flags = 0;
if (_properties.get_fullscreen()) {
add_flags |= AWINDOW_FLAG_FULLSCREEN;
} else {
del_flags |= AWINDOW_FLAG_FULLSCREEN;
}
ANativeActivity_setWindowFlags(_app->activity, add_flags, del_flags);
// Create the EGL surface.
_egl_surface = eglCreateWindowSurface(_egl_display, androidgsg->_fbconfig, _app->window, NULL);
if (eglGetError() != EGL_SUCCESS) {
androiddisplay_cat.error()
<< "Failed to create window surface.\n";
return false;
}
// Create a context.
if (androidgsg->_context == EGL_NO_CONTEXT) {
androiddisplay_cat.error() << "creating context\n";
if (!androidgsg->create_context()) {
return false;
}
}
// Switch to our newly created context.
if (!eglMakeCurrent(_egl_display, _egl_surface, _egl_surface, androidgsg->_context)) {
androiddisplay_cat.error() << "Failed to call eglMakeCurrent: "
<< get_egl_error_string(eglGetError()) << "\n";
}
// Query the size of the surface.
//EGLint width, height;
//eglQuerySurface(_egl_display, _egl_surface, EGL_WIDTH, &width);
//eglQuerySurface(_egl_display, _egl_surface, EGL_HEIGHT, &height);
androidgsg->reset_if_new();
if (!androidgsg->is_valid()) {
close_window();
return false;
}
return true;
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::handle_command
// Access: Private, Static
// Description: Android app sends a command from the main thread.
////////////////////////////////////////////////////////////////////
void AndroidGraphicsWindow::
handle_command(struct android_app *app, int32_t command) {
AndroidGraphicsWindow* window = (AndroidGraphicsWindow*) app->userData;
window->ns_handle_command(command);
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::ns_handle_command
// Access: Private
// Description: Android app sends a command from the main thread.
////////////////////////////////////////////////////////////////////
void AndroidGraphicsWindow::
ns_handle_command(int32_t command) {
WindowProperties properties;
switch (command) {
case APP_CMD_SAVE_STATE:
// The system has asked us to save our current state. Do so.
//engine->app->savedState = malloc(sizeof(struct saved_state));
//*((struct saved_state*)engine->app->savedState) = engine->state;
//engine->app->savedStateSize = sizeof(struct saved_state);
break;
case APP_CMD_INIT_WINDOW:
// The window is being shown, get it ready.
if (_app->window != NULL) {
create_surface();
properties.set_minimized(false);
system_changed_properties(properties);
}
break;
case APP_CMD_TERM_WINDOW:
destroy_surface();
properties.set_minimized(true);
system_changed_properties(properties);
break;
case APP_CMD_WINDOW_RESIZED:
break;
case APP_CMD_WINDOW_REDRAW_NEEDED:
break;
case APP_CMD_CONTENT_RECT_CHANGED:
properties.set_origin(_app->contentRect.left, _app->contentRect.top);
properties.set_size(_app->contentRect.right - _app->contentRect.left,
_app->contentRect.bottom - _app->contentRect.top);
system_changed_properties(properties);
break;
case APP_CMD_GAINED_FOCUS:
properties.set_foreground(true);
system_changed_properties(properties);
break;
case APP_CMD_LOST_FOCUS:
properties.set_foreground(false);
system_changed_properties(properties);
break;
case APP_CMD_DESTROY:
close_window();
properties.set_open(false);
system_changed_properties(properties);
break;
}
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::handle_input_event
// Access: Private, Static
// Description: Processes an input event. Returns 1 if the event
// was handled, 0 otherwise.
////////////////////////////////////////////////////////////////////
int32_t AndroidGraphicsWindow::
handle_input_event(struct android_app* app, AInputEvent *event) {
AndroidGraphicsWindow* window = (AndroidGraphicsWindow*) app->userData;
int32_t event_type = AInputEvent_getType(event);
switch (event_type) {
case AINPUT_EVENT_TYPE_KEY:
return window->handle_key_event(event);
case AINPUT_EVENT_TYPE_MOTION:
return window->handle_motion_event(event);
}
return 0;
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::handle_keystroke
// Access: Private
// Description: Processes a key event.
////////////////////////////////////////////////////////////////////
int32_t AndroidGraphicsWindow::
handle_key_event(const AInputEvent *event) {
/*
int32_t meta = AKeyEvent_getMetaState(event);
if (meta | AMETA_ALT_ON) {
_input_devices[0].button_down(KeyboardButton.alt());
}
if (meta | AMETA_ALT_LEFT_ON) {
_input_devices[0].button_down(KeyboardButton.lalt());
}
if (meta | AMETA_ALT_RIGHT_ON) {
_input_devices[0].button_down(KeyboardButton.ralt());
}
if (meta | AMETA_SHIFT_ON) {
_input_devices[0].button_down(KeyboardButton.shift());
}
if (meta | AMETA_SHIFT_LEFT_ON) {
_input_devices[0].button_down(KeyboardButton.lshift());
}
if (meta | AMETA_SHIFT_RIGHT_ON) {
_input_devices[0].button_down(KeyboardButton.rshift());
}*/
int32_t keycode = AKeyEvent_getKeyCode(event);
ButtonHandle button = map_button(keycode);
if (button == ButtonHandle::none()) {
androiddisplay_cat.warning()
<< "Unknown keycode: " << keycode << "\n";
return 0;
}
// Is it an up or down event?
int32_t action = AKeyEvent_getAction(event);
if (action == AKEY_EVENT_ACTION_DOWN) {
_input_devices[0].button_down(button);
} else if (action == AKEY_EVENT_ACTION_UP) {
_input_devices[0].button_up(button);
}
//TODO getRepeatCount, ACTION_MULTIPLE
return 1;
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::handle_motion_event
// Access: Private
// Description: Processes a motion event.
////////////////////////////////////////////////////////////////////
int32_t AndroidGraphicsWindow::
handle_motion_event(const AInputEvent *event) {
int32_t action = AMotionEvent_getAction(event);
action &= AMOTION_EVENT_ACTION_MASK;
if (action == AMOTION_EVENT_ACTION_DOWN) {
_input_devices[0].button_down(MouseButton::one());
} else if (action == AMOTION_EVENT_ACTION_UP) {
_input_devices[0].button_up(MouseButton::one());
}
float x = AMotionEvent_getX(event, 0) - _app->contentRect.left;
float y = AMotionEvent_getY(event, 0) - _app->contentRect.top;
_input_devices[0].set_pointer_in_window(x, y);
return 1;
}
////////////////////////////////////////////////////////////////////
// Function: AndroidGraphicsWindow::map_button
// Access: Private
// Description: Given an Android keycode, returns an appropriate
// ButtonHandle object, or ButtonHandle::none() if
// a matching ButtonHandle does not exist.
////////////////////////////////////////////////////////////////////
ButtonHandle AndroidGraphicsWindow::
map_button(int32_t keycode) {
switch (keycode) {
case AKEYCODE_SOFT_LEFT:
case AKEYCODE_SOFT_RIGHT:
case AKEYCODE_HOME:
case AKEYCODE_BACK:
case AKEYCODE_CALL:
case AKEYCODE_ENDCALL:
break;
case AKEYCODE_0:
return KeyboardButton::ascii_key('0');
case AKEYCODE_1:
return KeyboardButton::ascii_key('1');
case AKEYCODE_2:
return KeyboardButton::ascii_key('2');
case AKEYCODE_3:
return KeyboardButton::ascii_key('3');
case AKEYCODE_4:
return KeyboardButton::ascii_key('4');
case AKEYCODE_5:
return KeyboardButton::ascii_key('5');
case AKEYCODE_6:
return KeyboardButton::ascii_key('6');
case AKEYCODE_7:
return KeyboardButton::ascii_key('7');
case AKEYCODE_8:
return KeyboardButton::ascii_key('8');
case AKEYCODE_9:
return KeyboardButton::ascii_key('9');
case AKEYCODE_STAR:
return KeyboardButton::ascii_key('*');
case AKEYCODE_POUND:
return KeyboardButton::ascii_key('#');
case AKEYCODE_DPAD_UP:
return KeyboardButton::up();
case AKEYCODE_DPAD_DOWN:
return KeyboardButton::down();
case AKEYCODE_DPAD_LEFT:
return KeyboardButton::left();
case AKEYCODE_DPAD_RIGHT:
return KeyboardButton::right();
case AKEYCODE_DPAD_CENTER:
case AKEYCODE_VOLUME_UP:
case AKEYCODE_VOLUME_DOWN:
case AKEYCODE_POWER:
case AKEYCODE_CAMERA:
case AKEYCODE_CLEAR:
break;
case AKEYCODE_A:
return KeyboardButton::ascii_key('a');
case AKEYCODE_B:
return KeyboardButton::ascii_key('b');
case AKEYCODE_C:
return KeyboardButton::ascii_key('c');
case AKEYCODE_D:
return KeyboardButton::ascii_key('d');
case AKEYCODE_E:
return KeyboardButton::ascii_key('e');
case AKEYCODE_F:
return KeyboardButton::ascii_key('f');
case AKEYCODE_G:
return KeyboardButton::ascii_key('g');
case AKEYCODE_H:
return KeyboardButton::ascii_key('h');
case AKEYCODE_I:
return KeyboardButton::ascii_key('i');
case AKEYCODE_J:
return KeyboardButton::ascii_key('j');
case AKEYCODE_K:
return KeyboardButton::ascii_key('k');
case AKEYCODE_L:
return KeyboardButton::ascii_key('l');
case AKEYCODE_M:
return KeyboardButton::ascii_key('m');
case AKEYCODE_N:
return KeyboardButton::ascii_key('n');
case AKEYCODE_O:
return KeyboardButton::ascii_key('o');
case AKEYCODE_P:
return KeyboardButton::ascii_key('p');
case AKEYCODE_Q:
return KeyboardButton::ascii_key('q');
case AKEYCODE_R:
return KeyboardButton::ascii_key('r');
case AKEYCODE_S:
return KeyboardButton::ascii_key('s');
case AKEYCODE_T:
return KeyboardButton::ascii_key('t');
case AKEYCODE_U:
return KeyboardButton::ascii_key('u');
case AKEYCODE_V:
return KeyboardButton::ascii_key('v');
case AKEYCODE_W:
return KeyboardButton::ascii_key('w');
case AKEYCODE_X:
return KeyboardButton::ascii_key('x');
case AKEYCODE_Y:
return KeyboardButton::ascii_key('y');
case AKEYCODE_Z:
return KeyboardButton::ascii_key('z');
case AKEYCODE_COMMA:
return KeyboardButton::ascii_key(',');
case AKEYCODE_PERIOD:
return KeyboardButton::ascii_key('.');
case AKEYCODE_ALT_LEFT:
return KeyboardButton::lalt();
case AKEYCODE_ALT_RIGHT:
return KeyboardButton::ralt();
case AKEYCODE_SHIFT_LEFT:
return KeyboardButton::lshift();
case AKEYCODE_SHIFT_RIGHT:
return KeyboardButton::rshift();
case AKEYCODE_TAB:
return KeyboardButton::tab();
case AKEYCODE_SPACE:
return KeyboardButton::space();
case AKEYCODE_SYM:
case AKEYCODE_EXPLORER:
case AKEYCODE_ENVELOPE:
break;
case AKEYCODE_ENTER:
return KeyboardButton::enter();
case AKEYCODE_DEL:
return KeyboardButton::del();
case AKEYCODE_GRAVE:
return KeyboardButton::ascii_key('`');
case AKEYCODE_MINUS:
return KeyboardButton::ascii_key('-');
case AKEYCODE_EQUALS:
return KeyboardButton::ascii_key('=');
case AKEYCODE_LEFT_BRACKET:
return KeyboardButton::ascii_key('[');
case AKEYCODE_RIGHT_BRACKET:
return KeyboardButton::ascii_key(']');
case AKEYCODE_BACKSLASH:
return KeyboardButton::ascii_key('\\');
case AKEYCODE_SEMICOLON:
return KeyboardButton::ascii_key(';');
case AKEYCODE_APOSTROPHE:
return KeyboardButton::ascii_key('\'');
case AKEYCODE_SLASH:
return KeyboardButton::ascii_key('/');
case AKEYCODE_AT:
return KeyboardButton::ascii_key('@');
case AKEYCODE_NUM:
case AKEYCODE_HEADSETHOOK:
case AKEYCODE_FOCUS:
break;
case AKEYCODE_PLUS:
return KeyboardButton::ascii_key('+');
case AKEYCODE_MENU:
case AKEYCODE_NOTIFICATION:
case AKEYCODE_SEARCH:
case AKEYCODE_MEDIA_PLAY_PAUSE:
case AKEYCODE_MEDIA_STOP:
case AKEYCODE_MEDIA_NEXT:
case AKEYCODE_MEDIA_PREVIOUS:
case AKEYCODE_MEDIA_REWIND:
case AKEYCODE_MEDIA_FAST_FORWARD:
case AKEYCODE_MUTE:
break;
case AKEYCODE_PAGE_UP:
return KeyboardButton::page_up();
case AKEYCODE_PAGE_DOWN:
return KeyboardButton::page_down();
case AKEYCODE_PICTSYMBOLS:
case AKEYCODE_SWITCH_CHARSET:
case AKEYCODE_BUTTON_A:
case AKEYCODE_BUTTON_B:
case AKEYCODE_BUTTON_C:
case AKEYCODE_BUTTON_X:
case AKEYCODE_BUTTON_Y:
case AKEYCODE_BUTTON_Z:
case AKEYCODE_BUTTON_L1:
case AKEYCODE_BUTTON_R1:
case AKEYCODE_BUTTON_L2:
case AKEYCODE_BUTTON_R2:
case AKEYCODE_BUTTON_THUMBL:
case AKEYCODE_BUTTON_THUMBR:
case AKEYCODE_BUTTON_START:
case AKEYCODE_BUTTON_SELECT:
case AKEYCODE_BUTTON_MODE:
default:
break;
}
return ButtonHandle::none();
}
Reference in New Issue View Git Blame Copy Permalink