void PonscripterLabel::mousePressEvent(SDL_MouseButtonEvent* event)
{
if (variable_edit_mode) return;
if (automode_flag) {
remaining_time = -1;
setAutoMode(false);
return;
}
if (event->button == SDL_BUTTON_RIGHT
&& trap_mode & TRAP_RIGHT_CLICK) {
trapHandler();
return;
}
else if (event->button == SDL_BUTTON_LEFT
&& trap_mode & TRAP_LEFT_CLICK) {
trapHandler();
return;
}
//Mouse didn't have a mouse-down event
if(current_button_state.down_x == -1 && current_button_state.down_y == -1) {
current_button_state.ignore_mouseup = true;
}
/* Use both = -1 to indicate we haven't received a mousedown yet */
if(event->type == SDL_MOUSEBUTTONUP){
current_button_state.down_x = -1;
current_button_state.down_y = -1;
}
current_button_state.x = event->x;
current_button_state.y = event->y;
current_button_state.down_flag = false;
setSkipMode(false);
if (event->button == SDL_BUTTON_RIGHT
&& event->type == SDL_MOUSEBUTTONUP
&& !current_button_state.ignore_mouseup
&& ((rmode_flag && (event_mode & WAIT_TEXT_MODE))
|| (event_mode & WAIT_BUTTON_MODE))) {
current_button_state.button = -1;
volatile_button_state.button = -1;
if (event_mode & WAIT_TEXT_MODE) {
if (!rmenu.empty())
system_menu_mode = SYSTEM_MENU;
else
system_menu_mode = SYSTEM_WINDOWERASE;
}
}
else if (event->button == SDL_BUTTON_LEFT
&& ((!current_button_state.ignore_mouseup && event->type == SDL_MOUSEBUTTONUP) || btndown_flag)) {
current_button_state.button = current_over_button;
volatile_button_state.button = current_over_button;
//#ifdef SKIP_TO_WAIT
if (event_mode & WAIT_SLEEP_MODE) skip_to_wait = 1;
//#endif
if (event->type == SDL_MOUSEBUTTONDOWN) {
current_button_state.down_flag = true;
}
} else {
return;
}
if (event_mode & (WAIT_INPUT_MODE | WAIT_BUTTON_MODE)) {
playClickVoice();
stopAnimation(clickstr_state);
advancePhase();
}
}
void PonscripterLabel::timerEvent(void)
{
timerEventTop:
int ret;
if (event_mode & WAIT_TIMER_MODE) {
int duration = proceedAnimation();
if (duration == 0
|| (remaining_time >= 0
&& remaining_time - duration <= 0)) {
bool end_flag = true;
bool loop_flag = false;
if (remaining_time >= 0) {
remaining_time = -1;
if (event_mode & WAIT_VOICE_MODE && wave_sample[0]) {
end_flag = false;
if (duration > 0) {
resetRemainingTime(duration);
advancePhase(duration);
}
}
else {
loop_flag = true;
if (automode_flag || autoclick_time > 0)
current_button_state.button = 0;
else if (usewheel_flag)
current_button_state.button = -5;
else
current_button_state.button = -2;
}
}
if (end_flag
&& event_mode & (WAIT_INPUT_MODE | WAIT_BUTTON_MODE)
&& (clickstr_state == CLICK_WAIT
|| clickstr_state == CLICK_NEWPAGE)) {
playClickVoice();
stopAnimation(clickstr_state);
}
if (end_flag || duration == 0)
event_mode &= ~WAIT_TIMER_MODE;
if (loop_flag) goto timerEventTop;
}
else {
if (remaining_time > 0)
remaining_time -= duration;
resetRemainingTime(duration);
advancePhase(duration);
}
}
else if (event_mode & EFFECT_EVENT_MODE) {
const char* current = script_h.getCurrent();
ret = this->parseLine();
if (ret & RET_CONTINUE) {
if (ret == RET_CONTINUE) {
readToken(); // skip trailing \0 and mark kidoku
}
if (effect_blank == 0 || effect_counter == 0) goto timerEventTop;
startTimer(effect_blank);
}
else {
script_h.setCurrent(current);
readToken();
advancePhase();
}
return;
}
else {
if (system_menu_mode != SYSTEM_NULL
|| (event_mode & WAIT_INPUT_MODE
&& volatile_button_state.button == -1)) {
if (!system_menu_enter_flag)
event_mode |= WAIT_TIMER_MODE;
executeSystemCall();
}
else
executeLabel();
}
volatile_button_state.button = 0;
}
/* **************************************** *
* Event loop
* **************************************** */
int PonscripterLabel::eventLoop()
{
SDL_Event event, tmp_event;
/* Note, this rate can change if the window is dragged to a new
screen or the monitor settings are changed while running.
We do not handle either of these cases */
Uint32 refresh_delay = getRefreshRateDelay();
Uint32 last_refresh = 0, current_time;
timer_event_flag = false;
#ifdef WIN32
Uint32 win_flags;
#endif
queueRerender();
advancePhase();
// when we're on the first of a button-waiting frame (menu, etc), we snap mouse cursor to button when
// using keyboard/gamecontroller to vastly improve the experience when using not using a mouse directly
bool using_buttonbased_movement = true; // true to snap to main menu when it loads
first_buttonwait_mode_frame = false; // if it's the first frame of a buttonwait (menu/choice), snap to default button
SDL_GetMouseState(&last_mouse_x, &last_mouse_y);
while (SDL_WaitEvent(&event)) {
// ignore continous SDL_MOUSEMOTION
while (event.type == SDL_MOUSEMOTION) {
if (SDL_PeepEvents(&tmp_event, 1, SDL_PEEKEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT) == 0) break;
// improve using keyboard/gamecontroller controls
if ((last_mouse_x != ( (SDL_MouseButtonEvent *) &event)->x) || (last_mouse_y != ( (SDL_MouseButtonEvent *) &event)->y)) {
using_buttonbased_movement = false;
last_mouse_x = ( (SDL_MouseButtonEvent *) &event)->x;
last_mouse_y = ( (SDL_MouseButtonEvent *) &event)->y;
}
if (tmp_event.type != SDL_MOUSEMOTION) break;
SDL_PeepEvents(&tmp_event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT);
event = tmp_event;
}
switch (event.type) {
case SDL_MOUSEMOTION:
mouseMoveEvent((SDL_MouseMotionEvent*) &event);
break;
case SDL_MOUSEBUTTONDOWN:
current_button_state.down_x = ( (SDL_MouseButtonEvent *) &event)->x;
current_button_state.down_y = ( (SDL_MouseButtonEvent *) &event)->y;
current_button_state.ignore_mouseup = false;
if (!btndown_flag) break;
case SDL_MOUSEBUTTONUP:
mousePressEvent((SDL_MouseButtonEvent*) &event);
break;
case SDL_MOUSEWHEEL:
mouseWheelEvent(&event.wheel);
break;
// NOTE: we reverse KEYUP and KEYDOWN for controller presses, because otherwise it feels really slow and junky
// If necessary, we can make keyPressEvent actually interpret controller keys but this works fine for now
case SDL_CONTROLLERBUTTONDOWN:
using_buttonbased_movement = true;
event.key.type = SDL_KEYUP;
// printf("Controller button press: %s\n", SDL_GameControllerGetStringForButton((SDL_GameControllerButton)event.cbutton.button));
event.key.keysym.sym = transControllerButton(event.cbutton.button);
if (event.key.keysym.sym == SDLK_UNKNOWN)
break;
event.key.keysym.sym = transKey(event.key.keysym.sym);
keyDownEvent((SDL_KeyboardEvent*) &event);
keyPressEvent((SDL_KeyboardEvent*) &event);
break;
case SDL_CONTROLLERBUTTONUP:
using_buttonbased_movement = true;
event.key.type = SDL_KEYDOWN;
// printf("Controller button release: %s\n", SDL_GameControllerGetStringForButton((SDL_GameControllerButton)event.cbutton.button));
event.key.keysym.sym = transControllerButton(event.cbutton.button);
if (event.key.keysym.sym == SDLK_UNKNOWN)
break;
event.key.keysym.sym = transKey(event.key.keysym.sym);
keyUpEvent((SDL_KeyboardEvent*) &event);
if (btndown_flag)
keyPressEvent((SDL_KeyboardEvent*) &event);
break;
case SDL_JOYBUTTONDOWN:
using_buttonbased_movement = true;
event.key.type = SDL_KEYDOWN;
event.key.keysym.sym = transJoystickButton(event.jbutton.button);
if (event.key.keysym.sym == SDLK_UNKNOWN)
break;
case SDL_KEYDOWN:
if ((event.key.keysym.sym == SDLK_UP) || (event.key.keysym.sym == SDLK_DOWN) ||
(event.key.keysym.sym == SDLK_LEFT) || (event.key.keysym.sym == SDLK_RIGHT))
using_buttonbased_movement = true;
event.key.keysym.sym = transKey(event.key.keysym.sym);
keyDownEvent((SDL_KeyboardEvent*) &event);
if (btndown_flag)
keyPressEvent((SDL_KeyboardEvent*) &event);
break;
case SDL_JOYBUTTONUP:
using_buttonbased_movement = true;
event.key.type = SDL_KEYUP;
event.key.keysym.sym = transJoystickButton(event.jbutton.button);
if (event.key.keysym.sym == SDLK_UNKNOWN)
break;
case SDL_KEYUP:
event.key.keysym.sym = transKey(event.key.keysym.sym);
keyUpEvent((SDL_KeyboardEvent*) &event);
keyPressEvent((SDL_KeyboardEvent*) &event);
break;
case SDL_JOYAXISMOTION:
{
SDL_KeyboardEvent ke = transJoystickAxis(event.jaxis);
if (ke.keysym.sym != SDLK_UNKNOWN) {
if (ke.type == SDL_KEYDOWN) {
keyDownEvent(&ke);
if (btndown_flag)
keyPressEvent(&ke);
}
else if (ke.type == SDL_KEYUP) {
keyUpEvent(&ke);
keyPressEvent(&ke);
}
}
break;
}
case ONS_SOUND_EVENT:
case ONS_FADE_EVENT:
case ONS_MIDI_EVENT:
case ONS_MUSIC_EVENT:
flushEventSub(event);
break;
case INTERNAL_REDRAW_EVENT:
/* Handle cursor shifting for controller/keyboard button-based movement */
if (first_buttonwait_mode_frame && using_buttonbased_movement && buttons.size() > 1) {
shiftCursorOnButton(0);
}
if (event_mode & WAIT_BUTTON_MODE)
first_buttonwait_mode_frame = true;
else if (first_buttonwait_mode_frame)
first_buttonwait_mode_frame = false;
/* Stop rerendering while minimized; wait for the restore event + queueRerender */
if(minimized_flag) {
break;
}
current_time = SDL_GetTicks();
if((current_time - last_refresh) >= refresh_delay || last_refresh == 0) {
/* It has been longer than the refresh delay since we last started a refresh. Start another */
last_refresh = current_time;
rerender();
/* Refresh time since rerender does take some odd ms */
current_time = SDL_GetTicks();
}
SDL_PumpEvents();
/* Remove all pending redraw events on the queue */
while(SDL_PeepEvents(&tmp_event, 1, SDL_GETEVENT, INTERNAL_REDRAW_EVENT, INTERNAL_REDRAW_EVENT) == 1)
;
/* If there are any events on the queue, re-add us and let it get those events asap.
* It'll then come back to us with no events and we'll just sleep until it's time to redraw again.
* If there are no events, sleep right away
*/
if(SDL_PeepEvents(&tmp_event, 1, SDL_PEEKEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT) == 0) {
if(timer_event_flag && timer_event_time <= current_time) {
timer_event_flag = false;
timerEvent();
} else if(last_refresh <= current_time && refresh_delay >= (current_time - last_refresh)) {
SDL_Delay(std::min(refresh_delay / 3, refresh_delay - (current_time - last_refresh)));
}
}
tmp_event.type = INTERNAL_REDRAW_EVENT;
SDL_PushEvent(&tmp_event);
break;
case ONS_WAVE_EVENT:
flushEventSub(event);
//printf("ONS_WAVE_EVENT %d: %x %d %x\n", event.user.code, wave_sample[0], automode_flag, event_mode);
if (event.user.code != 0
|| !(event_mode & WAIT_VOICE_MODE)) break;
if (remaining_time <= 0) {
event_mode &= ~WAIT_VOICE_MODE;
if (automode_flag)
current_button_state.button = 0;
else if (usewheel_flag)
current_button_state.button = -5;
else
current_button_state.button = -2;
stopAnimation(clickstr_state);
advancePhase();
}
break;
case SDL_WINDOWEVENT:
switch(event.window.event) {
case SDL_WINDOWEVENT_FOCUS_LOST:
break;
case SDL_WINDOWEVENT_FOCUS_GAINED:
/* See comment below under RESIZED */
SDL_PumpEvents();
SDL_PeepEvents(&tmp_event, 1, SDL_GETEVENT, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONDOWN);
current_button_state.ignore_mouseup = true;
#ifdef WIN32
win_flags = SDL_GetWindowFlags(screen);
/* Work around: https://bugzilla.libsdl.org/show_bug.cgi?id=2510
*
* On windows, the RESTORED event does not occur when you restore a
* maximized event. The only events you get are a ton of exposes and
* this one. The screen also remains black if it was maximized until
* the window is "restored".
*/
SDL_RestoreWindow(screen);
if(win_flags & SDL_WINDOW_FULLSCREEN_DESKTOP) {
SDL_SetWindowFullscreen(screen, SDL_WINDOW_FULLSCREEN_DESKTOP);
} else if(win_flags & SDL_WINDOW_FULLSCREEN) {
SDL_SetWindowFullscreen(screen, SDL_WINDOW_FULLSCREEN);
} else if(win_flags & SDL_WINDOW_MAXIMIZED) {
SDL_MaximizeWindow(screen);
}
#endif
break;
case SDL_WINDOWEVENT_MAXIMIZED:
case SDL_WINDOWEVENT_RESIZED:
/* Due to what I suspect is an SDL bug, you get a mosuedown +
* mouseup event when you maximize the window by double
* clicking the titlebar in windows. These events both have
* coordinates inside of the screen, and I can't see any way
* to tell them apart from legitimate clicks. (it even triggers
* a mouse move event).
* To fix this bug, we kill any mousedown events when we maximize.
* Note, we do this under RESIZED too because if you do a
* "vertical maximize" (double click with the upper resize arrow)
* that doesn't trigger a maximized event
*/
SDL_PumpEvents();
SDL_PeepEvents(&tmp_event, 1, SDL_GETEVENT, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONDOWN);
current_button_state.ignore_mouseup = true;
case SDL_WINDOWEVENT_RESTORED:
case SDL_WINDOWEVENT_SHOWN:
case SDL_WINDOWEVENT_EXPOSED:
/* If we weren't minimized, a rerender is already queued */
if(minimized_flag) {
minimized_flag = false;
queueRerender();
}
break;
case SDL_WINDOWEVENT_MINIMIZED:
case SDL_WINDOWEVENT_HIDDEN:
minimized_flag = true;
break;
}
break;
case SDL_QUIT:
endCommand("end");
break;
default:
break;
}
}
return -1;
}
BitmapImage::~BitmapImage()
{
stopAnimation();
}
void SVGImage::resetAnimation()
{
stopAnimation();
}
void VisualizerSetting::updateSetting() {
stopAnimation(); // If animation is played
myFieldDataVisualizer->myHMeshToVtkUnstructuredGridSetScalar(PROPERTY_FIELD_TYPE, PROPERTY_FRAMEID);
myFieldDataVisualizer->myHMeshToVtkUnstructuredGridSetVector(PROPERTY_FRAMEID);
myFieldDataVisualizer->plotVectorField(); // Update Plot
}
bool ONScripter::mousePressEvent( SDL_MouseButtonEvent *event )
{
if ( variable_edit_mode ) return false;
if ( automode_flag ){
automode_flag = false;
return false;
}
if ( (event->button == SDL_BUTTON_RIGHT && trap_mode & TRAP_RIGHT_CLICK) ||
(event->button == SDL_BUTTON_LEFT && trap_mode & TRAP_LEFT_CLICK) ){
if (trapHandler()) return true;
}
current_button_state.x = event->x * screen_width / screen_device_width;
current_button_state.y = event->y * screen_width / screen_device_width;
current_button_state.down_flag = false;
skip_mode &= ~SKIP_NORMAL;
if ( event->button == SDL_BUTTON_RIGHT &&
event->type == SDL_MOUSEBUTTONUP &&
((rmode_flag && event_mode & WAIT_TEXT_MODE) ||
(event_mode & (WAIT_BUTTON_MODE | WAIT_RCLICK_MODE))) ){
current_button_state.button = -1;
sprintf(current_button_state.str, "RCLICK");
if (event_mode & WAIT_TEXT_MODE){
if (root_rmenu_link.next)
system_menu_mode = SYSTEM_MENU;
else
system_menu_mode = SYSTEM_WINDOWERASE;
}
}
else if ( event->button == SDL_BUTTON_LEFT &&
( event->type == SDL_MOUSEBUTTONUP || btndown_flag ) ){
current_button_state.button = current_over_button;
if (current_over_button == -1){
if (!bexec_flag) current_button_state.button = 0;
sprintf(current_button_state.str, "LCLICK");
}
else{
sprintf(current_button_state.str, "S%d", current_over_button);
if (bexec_flag && current_button_link){
ButtonLink *cbl = current_button_link;
if ( current_button_link->exbtn_ctl[2] ){
SDL_Rect check_src_rect = cbl->image_rect;
SDL_Rect check_dst_rect = {0, 0, 0, 0};
decodeExbtnControl( cbl->exbtn_ctl[2], &check_src_rect, &check_dst_rect );
}
else{
sprite_info[ cbl->sprite_no ].visible = true;
sprite_info[ cbl->sprite_no ].setCell(2);
dirty_rect.add( cbl->image_rect );
}
flush( refreshMode() );
}
}
if ( event->type == SDL_MOUSEBUTTONDOWN )
current_button_state.down_flag = true;
}
#if SDL_VERSION_ATLEAST(1, 2, 5)
else if (event->button == SDL_BUTTON_WHEELUP &&
(bexec_flag ||
(event_mode & WAIT_TEXT_MODE) ||
(usewheel_flag && event_mode & WAIT_BUTTON_MODE) ||
system_menu_mode == SYSTEM_LOOKBACK)){
current_button_state.button = -2;
sprintf(current_button_state.str, "WHEELUP");
if (event_mode & WAIT_TEXT_MODE) system_menu_mode = SYSTEM_LOOKBACK;
}
else if ( event->button == SDL_BUTTON_WHEELDOWN &&
(bexec_flag ||
(enable_wheeldown_advance_flag && event_mode & WAIT_TEXT_MODE) ||
(usewheel_flag && event_mode & WAIT_BUTTON_MODE) ||
system_menu_mode == SYSTEM_LOOKBACK ) ){
if (event_mode & WAIT_TEXT_MODE)
current_button_state.button = 0;
else
current_button_state.button = -3;
sprintf(current_button_state.str, "WHEELDOWN");
}
#endif
else if ( getmclick_flag && event->button == SDL_BUTTON_MIDDLE ){
current_button_state.button = -70;
sprintf(current_button_state.str, "MCLICK");
}
else return false;
if ( event_mode & (WAIT_INPUT_MODE | WAIT_BUTTON_MODE) ){
if (!(event_mode & (WAIT_TEXT_MODE)))
skip_mode |= SKIP_TO_EOL;
playClickVoice();
stopAnimation( clickstr_state );
return true;
}
return false;
}
void AsScene2101Door::stCloseDoorDone() {
stopAnimation();
setVisible(false);
}
Animation* MeshObject::replaceAnimation(const Ogre::String& oldAnimName, const Ogre::String& newAnimName, Real speed, unsigned int timesToPlay )
{
stopAnimation(oldAnimName);
return startAnimation( newAnimName, speed, timesToPlay );
}
void AsScene1907Symbol::stPlugInFail() {
_currPositionIndex = _newPositionIndex;
stopAnimation();
_parentScene->plugInFailed();
}
void AsScene1907WaterHint::hide() {
stopAnimation();
setVisible(false);
SetMessageHandler(&Sprite::handleMessage);
}
UBSpinningWheel::~UBSpinningWheel()
{
stopAnimation();
}
// when the action is invoked, it will popup a messageBox showing the given html
this->addAboutDemo( "documentation/about.html" );
// read last setting from .ini file
viewer->readSettings();
}
void MainWindow::connectActions()
{
// Edit menu actions
QObject::connect(this->actionIncremental_Construct, SIGNAL(toggled(bool)),
this->viewer, SLOT(toggleIncremental(bool)));
QObject::connect(this->actionStop_Animation, SIGNAL(triggered()),
this->viewer, SLOT(stopIncremental()));
QObject::connect(this->viewer, SIGNAL(stopIncAnimation()),
this, SLOT(stopAnimation()));
// Show menu actions
QObject::connect(this->actionShow_Axis, SIGNAL(toggled(bool)),
this->viewer, SLOT(toggleShowAxis(bool)));
QObject::connect(this->actionShow_Vertex, SIGNAL(toggled(bool)),
this->viewer, SLOT(toggleShowVertex(bool)));
QObject::connect(this->actionShow_DEdge, SIGNAL(toggled(bool)),
this->viewer, SLOT(toggleShowDEdge(bool)));
QObject::connect(this->actionShow_VEdge, SIGNAL(toggled(bool)),
this->viewer, SLOT(toggleShowVEdge(bool)));
QObject::connect(this->actionShow_Facet, SIGNAL(toggled(bool)),
this->viewer, SLOT(toggleShowFacet(bool)));
QObject::connect(this->actionFlat, SIGNAL(toggled(bool)),
this->viewer, SLOT(toggleFlat(bool)));
bool ONScripter::keyPressEvent( SDL_KeyboardEvent *event )
{
current_button_state.button = 0;
current_button_state.down_flag = false;
if ( automode_flag ){
automode_flag = false;
return false;
}
if ( event->type == SDL_KEYUP ){
if ( variable_edit_mode ){
variableEditMode( event );
return false;
}
if ( edit_flag && event->keysym.sym == SDLK_z ){
variable_edit_mode = EDIT_SELECT_MODE;
variable_edit_sign = 1;
variable_edit_num = 0;
sprintf( wm_edit_string, "%s%s", EDIT_MODE_PREFIX, EDIT_SELECT_STRING );
SDL_WM_SetCaption( wm_edit_string, wm_icon_string );
}
}
if (event->type == SDL_KEYUP)
skip_mode &= ~SKIP_NORMAL;
if ( shift_pressed_status && event->keysym.sym == SDLK_q && current_mode == NORMAL_MODE ){
endCommand();
}
if ( (trap_mode & TRAP_LEFT_CLICK) &&
(event->keysym.sym == SDLK_RETURN ||
event->keysym.sym == SDLK_KP_ENTER ||
event->keysym.sym == SDLK_SPACE ) ){
if (trapHandler()) return true;
}
else if ( (trap_mode & TRAP_RIGHT_CLICK) &&
(event->keysym.sym == SDLK_ESCAPE) ){
if (trapHandler()) return true;
}
if ( event_mode & WAIT_BUTTON_MODE &&
(((event->type == SDL_KEYUP || btndown_flag) &&
((!getenter_flag && event->keysym.sym == SDLK_RETURN) ||
(!getenter_flag && event->keysym.sym == SDLK_KP_ENTER))) ||
((spclclk_flag || !useescspc_flag) && event->keysym.sym == SDLK_SPACE)) ){
if ( event->keysym.sym == SDLK_RETURN ||
event->keysym.sym == SDLK_KP_ENTER ||
(spclclk_flag && event->keysym.sym == SDLK_SPACE) ){
current_button_state.button = current_over_button;
if (current_over_button == -1){
if (!bexec_flag) current_button_state.button = 0;
sprintf(current_button_state.str, "RETURN");
}
else{
sprintf(current_button_state.str, "S%d", current_over_button);
if (bexec_flag && current_button_link){
ButtonLink *cbl = current_button_link;
if ( current_button_link->exbtn_ctl[2] ){
SDL_Rect check_src_rect = cbl->image_rect;
SDL_Rect check_dst_rect = {0, 0, 0, 0};
decodeExbtnControl( cbl->exbtn_ctl[2], &check_src_rect, &check_dst_rect );
}
else{
sprite_info[ cbl->sprite_no ].visible = true;
sprite_info[ cbl->sprite_no ].setCell(2);
dirty_rect.add( cbl->image_rect );
}
flush( refreshMode() );
}
}
if ( event->type == SDL_KEYDOWN )
current_button_state.down_flag = true;
}
else{
current_button_state.button = -1;
if (!bexec_flag) current_button_state.button = 0;
sprintf(current_button_state.str, "SPACE");
}
playClickVoice();
stopAnimation( clickstr_state );
return true;
}
if ( event->type == SDL_KEYDOWN ) return false;
if ( ( event_mode & (WAIT_INPUT_MODE | WAIT_BUTTON_MODE) ) &&
( autoclick_time == 0 || (event_mode & WAIT_BUTTON_MODE)) ){
if ( !useescspc_flag && event->keysym.sym == SDLK_ESCAPE){
current_button_state.button = -1;
sprintf(current_button_state.str, "RCLICK");
if (rmode_flag && event_mode & WAIT_TEXT_MODE){
if (root_rmenu_link.next)
system_menu_mode = SYSTEM_MENU;
else
system_menu_mode = SYSTEM_WINDOWERASE;
}
}
else if ( useescspc_flag && event->keysym.sym == SDLK_ESCAPE ){
current_button_state.button = -10;
}
else if ( !spclclk_flag && useescspc_flag && event->keysym.sym == SDLK_SPACE ){
current_button_state.button = -11;
}
else if (((!getcursor_flag && event->keysym.sym == SDLK_LEFT) ||
event->keysym.sym == SDLK_h) &&
(event_mode & WAIT_TEXT_MODE ||
(usewheel_flag && !getcursor_flag && event_mode & WAIT_BUTTON_MODE) ||
system_menu_mode == SYSTEM_LOOKBACK)){
current_button_state.button = -2;
if (event_mode & WAIT_TEXT_MODE) system_menu_mode = SYSTEM_LOOKBACK;
}
else if (((!getcursor_flag && event->keysym.sym == SDLK_RIGHT) ||
event->keysym.sym == SDLK_l) &&
((enable_wheeldown_advance_flag && event_mode & WAIT_TEXT_MODE) ||
(usewheel_flag && event_mode & WAIT_BUTTON_MODE) ||
system_menu_mode == SYSTEM_LOOKBACK)){
if (event_mode & WAIT_TEXT_MODE)
current_button_state.button = 0;
else
current_button_state.button = -3;
}
else if (((!getcursor_flag && event->keysym.sym == SDLK_UP) ||
event->keysym.sym == SDLK_k ||
event->keysym.sym == SDLK_p) &&
event_mode & WAIT_BUTTON_MODE){
shiftCursorOnButton(1);
return false;
}
else if (((!getcursor_flag && event->keysym.sym == SDLK_DOWN) ||
event->keysym.sym == SDLK_j ||
event->keysym.sym == SDLK_n) &&
event_mode & WAIT_BUTTON_MODE){
shiftCursorOnButton(-1);
return false;
}
else if ( getpageup_flag && event->keysym.sym == SDLK_PAGEUP ){
current_button_state.button = -12;
sprintf(current_button_state.str, "PAGEUP");
}
else if ( getpagedown_flag && event->keysym.sym == SDLK_PAGEDOWN ){
current_button_state.button = -13;
sprintf(current_button_state.str, "PAGEDOWN");
}
else if ( (getenter_flag && event->keysym.sym == SDLK_RETURN) ||
(getenter_flag && event->keysym.sym == SDLK_KP_ENTER) ){
current_button_state.button = -19;
}
else if ( gettab_flag && event->keysym.sym == SDLK_TAB ){
current_button_state.button = -20;
}
else if ( getcursor_flag && event->keysym.sym == SDLK_UP ){
current_button_state.button = -40;
sprintf(current_button_state.str, "UP");
}
else if ( getcursor_flag && event->keysym.sym == SDLK_RIGHT ){
current_button_state.button = -41;
sprintf(current_button_state.str, "RIGHT");
}
else if ( getcursor_flag && event->keysym.sym == SDLK_DOWN ){
current_button_state.button = -42;
sprintf(current_button_state.str, "DOWN");
}
else if ( getcursor_flag && event->keysym.sym == SDLK_LEFT ){
current_button_state.button = -43;
sprintf(current_button_state.str, "LEFT");
}
else if ( getinsert_flag && event->keysym.sym == SDLK_INSERT ){
current_button_state.button = -50;
}
else if ( getzxc_flag && event->keysym.sym == SDLK_z ){
current_button_state.button = -51;
}
else if ( getzxc_flag && event->keysym.sym == SDLK_x ){
current_button_state.button = -52;
}
else if ( getzxc_flag && event->keysym.sym == SDLK_c ){
current_button_state.button = -53;
}
else if ( getfunction_flag &&
event->keysym.sym >= SDLK_F1 && event->keysym.sym <= SDLK_F12 ){
current_button_state.button = -21-(event->keysym.sym - SDLK_F1);
sprintf(current_button_state.str, "F%d", event->keysym.sym - SDLK_F1+1);
}
else if ( bexec_flag &&
event->keysym.sym >= SDLK_0 && event->keysym.sym <= SDLK_9 ){
current_button_state.button = -1; // dummy
sprintf(current_button_state.str, "%d", event->keysym.sym - SDLK_0);
}
else if ( bexec_flag &&
event->keysym.sym >= SDLK_a && event->keysym.sym <= SDLK_z ){
current_button_state.button = -1; // dummy
sprintf(current_button_state.str, "%c", 'A' + event->keysym.sym - SDLK_a);
}
else if ( bexec_flag &&
(event->keysym.sym == SDLK_RSHIFT || event->keysym.sym == SDLK_LSHIFT) ){
current_button_state.button = -1; // dummy
sprintf(current_button_state.str, "SHIFT");
}
if ( current_button_state.button != 0 ){
stopAnimation( clickstr_state );
return true;
}
}
if ( event_mode & WAIT_INPUT_MODE &&
( autoclick_time == 0 || (event_mode & WAIT_BUTTON_MODE)) ){
if (event->keysym.sym == SDLK_RETURN ||
event->keysym.sym == SDLK_KP_ENTER ||
event->keysym.sym == SDLK_SPACE ){
if (!(event_mode & WAIT_TEXT_MODE))
skip_mode |= SKIP_TO_EOL;
playClickVoice();
stopAnimation( clickstr_state );
return true;
}
}
if ( event_mode & WAIT_INPUT_MODE ){
if (event->keysym.sym == SDLK_s && !automode_flag ){
skip_mode |= SKIP_NORMAL;
printf("toggle skip to true\n");
stopAnimation( clickstr_state );
return true;
}
else if (event->keysym.sym == SDLK_o){
if (skip_mode & SKIP_TO_EOP)
skip_mode &= ~SKIP_TO_EOP;
else
skip_mode |= SKIP_TO_EOP;
printf("toggle draw one page flag to %s\n", (skip_mode & SKIP_TO_EOP?"true":"false") );
if ( skip_mode & SKIP_TO_EOP ){
stopAnimation( clickstr_state );
return true;
}
}
else if ( event->keysym.sym == SDLK_a && !automode_flag ){
automode_flag = true;
skip_mode &= ~SKIP_NORMAL;
printf("change to automode\n");
stopAnimation( clickstr_state );
return true;
}
else if ( event->keysym.sym == SDLK_0 ){
if (++text_speed_no > 2) text_speed_no = 0;
sentence_font.wait_time = -1;
}
else if ( event->keysym.sym == SDLK_1 ){
text_speed_no = 0;
sentence_font.wait_time = -1;
}
else if ( event->keysym.sym == SDLK_2 ){
text_speed_no = 1;
sentence_font.wait_time = -1;
}
else if ( event->keysym.sym == SDLK_3 ){
text_speed_no = 2;
sentence_font.wait_time = -1;
}
}
if ( event_mode & ( WAIT_INPUT_MODE | WAIT_BUTTON_MODE ) ){
if ( event->keysym.sym == SDLK_f ){
if ( fullscreen_mode ) menu_windowCommand();
else menu_fullCommand();
}
}
return false;
}
void PonscripterLabel::keyPressEvent(SDL_KeyboardEvent* event)
{
current_button_state.button = 0;
current_button_state.down_flag = false;
// This flag is set by anything before autmode that would like to not interrupt automode.
// At present, this is volume mute and fullscreen. The commands don't simply return in case
// the keypresses are handled below (e.g. telling the script the key 'a' was pressed)
bool automode_ignore = false;
if (event->type == SDL_KEYUP) {
if (variable_edit_mode) {
variableEditMode(event);
return;
}
if (event->keysym.sym == SDLK_m) {
volume_on_flag = !volume_on_flag;
setVolumeMute(!volume_on_flag);
printf("turned %s volume mute\n", !volume_on_flag?"on":"off");
automode_ignore = true;
}
if (event->keysym.sym == SDLK_f) {
if (fullscreen_mode) menu_windowCommand("menu_window");
else menu_fullCommand("menu_full");
return;
automode_ignore = true;
}
if (edit_flag && event->keysym.sym == SDLK_z) {
variable_edit_mode = EDIT_SELECT_MODE;
variable_edit_sign = 1;
variable_edit_num = 0;
wm_edit_string = EDIT_MODE_PREFIX EDIT_SELECT_STRING;
SDL_SetWindowTitle(screen, wm_title_string);
}
}
if (automode_flag && !automode_ignore) {
remaining_time = -1;
setAutoMode(false);
return;
}
if (event->type == SDL_KEYUP
&& (event->keysym.sym == SDLK_RETURN
|| event->keysym.sym == SDLK_KP_ENTER
|| event->keysym.sym == SDLK_SPACE
|| event->keysym.sym == SDLK_s))
setSkipMode(false);
if (shift_pressed_status && event->keysym.sym == SDLK_q &&
current_mode == NORMAL_MODE) {
endCommand("end");
}
if ((trap_mode & TRAP_LEFT_CLICK)
&& (event->keysym.sym == SDLK_RETURN
|| event->keysym.sym == SDLK_KP_ENTER
|| event->keysym.sym == SDLK_SPACE)) {
trapHandler();
return;
}
else if ((trap_mode & TRAP_RIGHT_CLICK)
&& (event->keysym.sym == SDLK_ESCAPE)) {
trapHandler();
return;
}
const bool wait_button_mode = event_mode & WAIT_BUTTON_MODE;
const bool key_or_btn = event->type == SDL_KEYUP || btndown_flag;
const bool enter_key = !getenter_flag &&
(event->keysym.sym == SDLK_RETURN ||
event->keysym.sym == SDLK_KP_ENTER);
const bool space_lclick = spclclk_flag || !useescspc_flag;
const bool space_key = event->keysym.sym == SDLK_SPACE;
if (wait_button_mode && ((key_or_btn && enter_key) ||
(space_lclick && space_key))) {
if (event->keysym.sym == SDLK_RETURN ||
event->keysym.sym == SDLK_KP_ENTER ||
(spclclk_flag && event->keysym.sym == SDLK_SPACE))
{
current_button_state.button =
volatile_button_state.button = current_over_button;
if (event->type == SDL_KEYDOWN) {
current_button_state.down_flag = true;
}
}
else {
current_button_state.button =
volatile_button_state.button = 0;
}
playClickVoice();
stopAnimation(clickstr_state);
advancePhase();
return;
}
if (event->type == SDL_KEYDOWN) return;
if ((event_mode & (WAIT_INPUT_MODE | WAIT_BUTTON_MODE))
&& (autoclick_time == 0 || (event_mode & WAIT_BUTTON_MODE))) {
if (!useescspc_flag && event->keysym.sym == SDLK_ESCAPE) {
current_button_state.button = -1;
if (rmode_flag && event_mode & WAIT_TEXT_MODE) {
if (!rmenu.empty())
system_menu_mode = SYSTEM_MENU;
else
system_menu_mode = SYSTEM_WINDOWERASE;
}
}
else if (useescspc_flag && event->keysym.sym == SDLK_ESCAPE) {
current_button_state.button = -10;
}
else if (!spclclk_flag && useescspc_flag && event->keysym.sym == SDLK_SPACE) {
current_button_state.button = -11;
}
else if (((!getcursor_flag && event->keysym.sym == SDLK_LEFT) ||
event->keysym.sym == SDLK_h) &&
(event_mode & WAIT_TEXT_MODE ||
(usewheel_flag && !getcursor_flag &&
event_mode & WAIT_BUTTON_MODE) ||
system_menu_mode == SYSTEM_LOOKBACK))
{
current_button_state.button = -2;
volatile_button_state.button = -2;
if (event_mode & WAIT_TEXT_MODE) system_menu_mode = SYSTEM_LOOKBACK;
}
else if (((!getcursor_flag && event->keysym.sym == SDLK_RIGHT) ||
event->keysym.sym == SDLK_l) &&
((enable_wheeldown_advance_flag &&
event_mode & WAIT_TEXT_MODE) ||
(usewheel_flag && event_mode & WAIT_BUTTON_MODE) ||
system_menu_mode == SYSTEM_LOOKBACK))
{
if (event_mode & WAIT_TEXT_MODE) {
current_button_state.button = 0;
volatile_button_state.button = 0;
}
else {
current_button_state.button = -3;
volatile_button_state.button = -3;
}
}
else if (((!getcursor_flag && event->keysym.sym == SDLK_UP) ||
event->keysym.sym == SDLK_k ||
event->keysym.sym == SDLK_p) &&
event_mode & WAIT_BUTTON_MODE){
shiftCursorOnButton(1);
return;
}
else if (((!getcursor_flag && event->keysym.sym == SDLK_DOWN) ||
event->keysym.sym == SDLK_j ||
event->keysym.sym == SDLK_n) &&
event_mode & WAIT_BUTTON_MODE){
shiftCursorOnButton(-1);
return;
}
else if (getpageup_flag && event->keysym.sym == SDLK_PAGEUP) {
current_button_state.button = -12;
}
else if (getpagedown_flag && event->keysym.sym == SDLK_PAGEDOWN) {
current_button_state.button = -13;
}
else if ((getenter_flag && event->keysym.sym == SDLK_RETURN)
|| (getenter_flag && event->keysym.sym == SDLK_KP_ENTER)) {
current_button_state.button = -19;
}
else if (gettab_flag && event->keysym.sym == SDLK_TAB) {
current_button_state.button = -20;
}
else if (getcursor_flag && event->keysym.sym == SDLK_UP) {
current_button_state.button = -40;
}
else if (getcursor_flag && event->keysym.sym == SDLK_RIGHT) {
current_button_state.button = -41;
}
else if (getcursor_flag && event->keysym.sym == SDLK_DOWN) {
current_button_state.button = -42;
}
else if (getcursor_flag && event->keysym.sym == SDLK_LEFT) {
current_button_state.button = -43;
}
else if (getinsert_flag && event->keysym.sym == SDLK_INSERT) {
current_button_state.button = -50;
}
else if (getzxc_flag && event->keysym.sym == SDLK_z) {
current_button_state.button = -51;
}
else if (getzxc_flag && event->keysym.sym == SDLK_x) {
current_button_state.button = -52;
}
else if (getzxc_flag && event->keysym.sym == SDLK_c) {
current_button_state.button = -53;
}
else if (getfunction_flag) {
if (event->keysym.sym == SDLK_F1)
current_button_state.button = -21;
else if (event->keysym.sym == SDLK_F2)
current_button_state.button = -22;
else if (event->keysym.sym == SDLK_F3)
current_button_state.button = -23;
else if (event->keysym.sym == SDLK_F4)
current_button_state.button = -24;
else if (event->keysym.sym == SDLK_F5)
current_button_state.button = -25;
else if (event->keysym.sym == SDLK_F6)
current_button_state.button = -26;
else if (event->keysym.sym == SDLK_F7)
current_button_state.button = -27;
else if (event->keysym.sym == SDLK_F8)
current_button_state.button = -28;
else if (event->keysym.sym == SDLK_F9)
current_button_state.button = -29;
else if (event->keysym.sym == SDLK_F10)
current_button_state.button = -30;
else if (event->keysym.sym == SDLK_F11)
current_button_state.button = -31;
else if (event->keysym.sym == SDLK_F12)
current_button_state.button = -32;
}
if (current_button_state.button != 0) {
volatile_button_state.button = current_button_state.button;
stopAnimation(clickstr_state);
advancePhase();
return;
}
}
if (event_mode & WAIT_INPUT_MODE && !key_pressed_flag
&& (autoclick_time == 0 || (event_mode & WAIT_BUTTON_MODE))) {
if (event->keysym.sym == SDLK_RETURN
|| event->keysym.sym == SDLK_KP_ENTER
|| event->keysym.sym == SDLK_SPACE) {
key_pressed_flag = true;
playClickVoice();
stopAnimation(clickstr_state);
advancePhase();
}
}
if (event_mode & (WAIT_INPUT_MODE | WAIT_TEXTBTN_MODE)
&& !key_pressed_flag) {
if (event->keysym.sym == SDLK_s && !automode_flag) {
setSkipMode(true);
//printf("toggle skip to true\n");
key_pressed_flag = true;
stopAnimation(clickstr_state);
advancePhase();
}
else if (event->keysym.sym == SDLK_o) {
draw_one_page_flag = !draw_one_page_flag;
//printf("toggle draw one page flag to %s\n", (draw_one_page_flag ? "true" : "false"));
if (draw_one_page_flag) {
stopAnimation(clickstr_state);
advancePhase();
}
}
else if (event->keysym.sym == SDLK_a && mode_ext_flag &&
!automode_flag)
{
setAutoMode(true);
//printf("change to automode\n");
key_pressed_flag = true;
stopAnimation(clickstr_state);
advancePhase();
}
else if (event->keysym.sym == SDLK_0) {
if (++text_speed_no > 2) text_speed_no = 0;
sentence_font.wait_time = -1;
}
else if (event->keysym.sym == SDLK_1) {
text_speed_no = 0;
sentence_font.wait_time = -1;
}
else if (event->keysym.sym == SDLK_2) {
text_speed_no = 1;
sentence_font.wait_time = -1;
}
else if (event->keysym.sym == SDLK_3) {
text_speed_no = 2;
sentence_font.wait_time = -1;
}
}
if (event_mode & WAIT_SLEEP_MODE) {
if (event->keysym.sym == SDLK_RETURN ||
event->keysym.sym == SDLK_KP_ENTER ||
event->keysym.sym == SDLK_SPACE) {
skip_to_wait = 1;
}
}
}
void AsDiskplayerSceneKey::stDropKeyDone() {
stopAnimation();
SetUpdateHandler(&AnimatedSprite::update);
SetMessageHandler(&Sprite::handleMessage);
setVisible(false);
}
void AnimatedImage::hide() {
stopAnimation();
restoreBackground();
m_lastPaintedFrame = NULL;
}
void AnimationManager::setDefaultFrame(sf::IntRect & frame)
{
m_DefaultFrame = frame;
stopAnimation();
}
BitmapImage::~BitmapImage()
{
invalidatePlatformData();
stopAnimation();
}
void ONScripter::runEventLoop()
{
SDL_Event event, tmp_event;
while ( SDL_WaitEvent(&event) ) {
bool ret = false;
// ignore continous SDL_MOUSEMOTION
while (event.type == SDL_MOUSEMOTION){
#if SDL_VERSION_ATLEAST(1, 3, 0)
if ( SDL_PeepEvents( &tmp_event, 1, SDL_PEEKEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT ) == 0 ) break;
if (tmp_event.type != SDL_MOUSEMOTION) break;
SDL_PeepEvents( &tmp_event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT );
#else
if ( SDL_PeepEvents( &tmp_event, 1, SDL_PEEKEVENT, SDL_ALLEVENTS ) == 0 ) break;
if (tmp_event.type != SDL_MOUSEMOTION) break;
SDL_PeepEvents( &tmp_event, 1, SDL_GETEVENT, SDL_ALLEVENTS );
#endif
event = tmp_event;
}
switch (event.type) {
#if defined(IOS) // || defined(ANDROID)
case SDL_FINGERMOTION:
{
SDL_Touch *touch = SDL_GetTouch(event.tfinger.touchId);
tmp_event.motion.x = device_width *event.tfinger.x/touch->xres - (device_width -screen_device_width)/2;
tmp_event.motion.y = device_height*event.tfinger.y/touch->yres - (device_height-screen_device_height)/2;
if (mouseMoveEvent( &tmp_event.motion )) return;
if (btndown_flag){
event.button.type = SDL_MOUSEBUTTONDOWN;
event.button.button = SDL_BUTTON_LEFT;
if (touch->num_fingers >= 2)
event.button.button = SDL_BUTTON_RIGHT;
event.button.x = tmp_event.motion.x;
event.button.y = tmp_event.motion.y;
ret = mousePressEvent( &event.button );
if (ret) return;
}
}
break;
case SDL_FINGERDOWN:
{
SDL_Touch *touch = SDL_GetTouch(event.tfinger.touchId);
tmp_event.motion.x = device_width *event.tfinger.x/touch->xres - (device_width -screen_device_width)/2;
tmp_event.motion.y = device_height*event.tfinger.y/touch->yres - (device_height-screen_device_height)/2;
if (mouseMoveEvent( &tmp_event.motion )) return;
}
if ( btndown_flag ){
SDL_Touch *touch = SDL_GetTouch(event.tfinger.touchId);
tmp_event.button.type = SDL_MOUSEBUTTONDOWN;
tmp_event.button.button = SDL_BUTTON_LEFT;
if (touch->num_fingers >= 2)
tmp_event.button.button = SDL_BUTTON_RIGHT;
tmp_event.button.x = device_width *event.tfinger.x/touch->xres - (device_width -screen_device_width)/2;
tmp_event.button.y = device_height*event.tfinger.y/touch->yres - (device_height-screen_device_height)/2;
ret = mousePressEvent( &tmp_event.button );
}
{
SDL_Touch *touch = SDL_GetTouch(event.tfinger.touchId);
num_fingers = touch->num_fingers;
if (num_fingers >= 3){
tmp_event.key.keysym.sym = SDLK_LCTRL;
ret |= keyDownEvent( &tmp_event.key );
}
}
if (ret) return;
break;
case SDL_FINGERUP:
if (num_fingers == 0) break;
{
SDL_Touch *touch = SDL_GetTouch(event.tfinger.touchId);
tmp_event.button.type = SDL_MOUSEBUTTONUP;
tmp_event.button.button = SDL_BUTTON_LEFT;
if (touch->num_fingers >= 1)
tmp_event.button.button = SDL_BUTTON_RIGHT;
tmp_event.button.x = device_width *event.tfinger.x/touch->xres - (device_width -screen_device_width)/2;
tmp_event.button.y = device_height*event.tfinger.y/touch->yres - (device_height-screen_device_height)/2;
ret = mousePressEvent( &tmp_event.button );
}
tmp_event.key.keysym.sym = SDLK_LCTRL;
keyUpEvent( &tmp_event.key );
num_fingers = 0;
if (ret) return;
break;
#else
case SDL_MOUSEMOTION:
if (mouseMoveEvent( &event.motion )) return;
if (btndown_flag){
if (event.motion.state & SDL_BUTTON(SDL_BUTTON_LEFT))
tmp_event.button.button = SDL_BUTTON_LEFT;
else if (event.motion.state & SDL_BUTTON(SDL_BUTTON_RIGHT))
tmp_event.button.button = SDL_BUTTON_RIGHT;
else
break;
tmp_event.button.type = SDL_MOUSEBUTTONDOWN;
tmp_event.button.x = event.motion.x;
tmp_event.button.y = event.motion.y;
ret = mousePressEvent( &tmp_event.button );
if (ret) return;
}
break;
case SDL_MOUSEBUTTONDOWN:
current_button_state.event_type = event.type;
current_button_state.event_button = event.button.button;
if ( !btndown_flag ) break;
case SDL_MOUSEBUTTONUP:
current_button_state.event_type = event.type;
current_button_state.event_button = event.button.button;
ret = mousePressEvent( &event.button );
if (ret) return;
break;
#endif
case SDL_JOYBUTTONDOWN:
event.key.type = SDL_KEYDOWN;
event.key.keysym.sym = transJoystickButton(event.jbutton.button);
if(event.key.keysym.sym == SDLK_UNKNOWN)
break;
case SDL_KEYDOWN:
event.key.keysym.sym = transKey(event.key.keysym.sym);
ret = keyDownEvent( &event.key );
if ( btndown_flag )
ret |= keyPressEvent( &event.key );
if (ret) return;
break;
case SDL_JOYBUTTONUP:
event.key.type = SDL_KEYUP;
event.key.keysym.sym = transJoystickButton(event.jbutton.button);
if(event.key.keysym.sym == SDLK_UNKNOWN)
break;
case SDL_KEYUP:
event.key.keysym.sym = transKey(event.key.keysym.sym);
keyUpEvent( &event.key );
ret = keyPressEvent( &event.key );
if (ret) return;
break;
case SDL_JOYAXISMOTION:
{
SDL_KeyboardEvent ke = transJoystickAxis(event.jaxis);
if (ke.keysym.sym != SDLK_UNKNOWN){
if (ke.type == SDL_KEYDOWN){
keyDownEvent( &ke );
if (btndown_flag)
keyPressEvent( &ke );
}
else if (ke.type == SDL_KEYUP){
keyUpEvent( &ke );
keyPressEvent( &ke );
}
}
break;
}
case ONS_TIMER_EVENT:
timerEvent();
break;
case ONS_MUSIC_EVENT:
case ONS_BGMFADE_EVENT:
case ONS_CDAUDIO_EVENT:
case ONS_MIDI_EVENT:
flushEventSub( event );
break;
case ONS_CHUNK_EVENT:
flushEventSub( event );
//printf("ONS_CHUNK_EVENT %d: %x %d %x\n", event.user.code, wave_sample[0], automode_flag, event_mode);
if ( event.user.code != 0 ||
!(event_mode & WAIT_VOICE_MODE) ) break;
event_mode &= ~WAIT_VOICE_MODE;
case ONS_BREAK_EVENT:
if (event_mode & WAIT_VOICE_MODE && wave_sample[0]){
remaining_time = -1;
timerEvent();
break;
}
if (automode_flag || autoclick_time > 0)
current_button_state.button = 0;
else if ( usewheel_flag ){
current_button_state.button = -5;
sprintf(current_button_state.str, "TIMEOUT");
}
else{
current_button_state.button = -2;
sprintf(current_button_state.str, "TIMEOUT");
}
if (event_mode & (WAIT_INPUT_MODE | WAIT_BUTTON_MODE) &&
( clickstr_state == CLICK_WAIT ||
clickstr_state == CLICK_NEWPAGE ) ){
playClickVoice();
stopAnimation( clickstr_state );
}
return;
case SDL_ACTIVEEVENT:
if ( !event.active.gain ){
// the mouse cursor leaves the window
SDL_MouseMotionEvent mevent;
mevent.x = screen_device_width;
mevent.y = screen_device_height;
mouseMoveEvent( &mevent );
break;
}
#ifdef ANDROID
if (event.active.state == SDL_APPACTIVE){
screen_surface = SDL_SetVideoMode( screen_width, screen_height, screen_bpp, DEFAULT_VIDEO_SURFACE_FLAG );
repaintCommand();
break;
}
#endif
case SDL_VIDEOEXPOSE:
#ifdef USE_SDL_RENDERER
SDL_RenderPresent(renderer);
#else
SDL_UpdateRect( screen_surface, 0, 0, screen_width, screen_height );
#endif
break;
case SDL_QUIT:
endCommand();
break;
default:
break;
}
}
}
