Gui::Gui(Scene& scene,
Game& game,
Camera& camera,
Input& input,
Timer& timer) :
m_game(game),
m_camera(camera),
m_scene(scene),
m_timer(timer)
{
TwInit(TW_OPENGL_CORE, nullptr);
TwWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
const std::string barname = "GraphicsTweaker";
m_tweakbar = TwNewBar(barname.c_str());
m_tweaker = std::make_unique<Tweaker>(m_tweakbar);
const int border = 10;
std::ostringstream stream;
stream << barname << " label='Graphics Tweaker' "
<< "position='" << border << " " << border << "' "
<< "size='250 " << WINDOW_HEIGHT-border*2 << "' "
<< "alpha=180 text=light valueswidth=80 color='0 0 0' "
<< "refresh=0.05 iconified=false resizable=true "
<< "fontsize=2 fontresizable=false ";
TwDefine(stream.str().c_str());
FillTweakBar();
auto AddKeyCallback = [&input](unsigned int key, unsigned int code)
{
input.AddCallback(key, false, [code]()
{
TwKeyPressed(code, 0);
});
};
// Keys required for modifying entries in the tweak bar
AddKeyCallback(GLFW_KEY_0, '0');
AddKeyCallback(GLFW_KEY_1, '1');
AddKeyCallback(GLFW_KEY_2, '2');
AddKeyCallback(GLFW_KEY_3, '3');
AddKeyCallback(GLFW_KEY_4, '4');
AddKeyCallback(GLFW_KEY_5, '5');
AddKeyCallback(GLFW_KEY_6, '6');
AddKeyCallback(GLFW_KEY_7, '7');
AddKeyCallback(GLFW_KEY_8, '8');
AddKeyCallback(GLFW_KEY_9, '9');
AddKeyCallback(GLFW_KEY_PERIOD, '.');
AddKeyCallback(GLFW_KEY_MINUS, '-');
AddKeyCallback(GLFW_KEY_ENTER, TW_KEY_RETURN);
AddKeyCallback(GLFW_KEY_LEFT, TW_KEY_LEFT);
AddKeyCallback(GLFW_KEY_RIGHT, TW_KEY_RIGHT);
AddKeyCallback(GLFW_KEY_TAB, TW_KEY_TAB);
AddKeyCallback(GLFW_KEY_END, TW_KEY_END);
AddKeyCallback(GLFW_KEY_HOME, TW_KEY_HOME);
AddKeyCallback(GLFW_KEY_BACKSPACE, TW_KEY_BACKSPACE);
LogInfo("GUI: Tweak bar initialised");
}
int TW_CALL TwEventCharGLFW(int glfwChar, int glfwAction)
{
if( glfwAction==GLFW_PRESS && (glfwChar & 0xff00)==0 )
return TwKeyPressed(glfwChar, g_KMod);
else
return 0;
}
void updateEvents() const
{
unsigned int size = _eventsToHandle.size();
for ( unsigned int i=0; i<size; ++i )
{
const osgGA::GUIEventAdapter& ea = *(_eventsToHandle.front());
float x = ea.getX(), y = ea.getWindowHeight() - ea.getY();
switch ( ea.getEventType() )
{
case osgGA::GUIEventAdapter::PUSH:
TwMouseMotion( x, y );
TwMouseButton( TW_MOUSE_PRESSED, getTwButton(ea.getButton()) );
break;
case osgGA::GUIEventAdapter::RELEASE:
TwMouseMotion( x, y );
TwMouseButton( TW_MOUSE_RELEASED, getTwButton(ea.getButton()) );
break;
case osgGA::GUIEventAdapter::DRAG:
case osgGA::GUIEventAdapter::MOVE:
TwMouseMotion( x, y );
break;
case osgGA::GUIEventAdapter::KEYDOWN:
{
bool useCtrl = false;
if ( ea.getModKeyMask()&osgGA::GUIEventAdapter::MODKEY_CTRL ) useCtrl = true;
TwKeyPressed( getTwKey(ea.getKey(), useCtrl), getTwModKeyMask(ea.getModKeyMask()) );
}
break;
default: break;
}
const_cast<TwGUIManager*>(this)->_eventsToHandle.pop();
}
}
int TW_CALL TwEventCharModsGLFW3(GLFWwindow *window, int glfwChar, int glfwMods)
{
if( (glfwChar & 0xff00)==0 )
return TwKeyPressed(glfwChar, convertModifiers(glfwMods));
return 0;
}
void GUI::onKeyPressed(int key, int mod) {
switch(key) {
case GLFW_KEY_LEFT: key = TW_KEY_LEFT; break;
case GLFW_KEY_RIGHT: key = TW_KEY_RIGHT; break;
case GLFW_KEY_UP: key = TW_KEY_UP; break;
case GLFW_KEY_DOWN: key = TW_KEY_DOWN; break;
case GLFW_KEY_BACKSPACE: key = TW_KEY_BACKSPACE; break;
case GLFW_KEY_DELETE: key = TW_KEY_DELETE; break;
case GLFW_KEY_ENTER: key = TW_KEY_RETURN; break;
default: break;
}
int tw_mod = TW_KMOD_NONE;
if(mod & GLFW_MOD_SHIFT) {
tw_mod |= TW_KMOD_SHIFT;
}
if(mod & GLFW_MOD_CONTROL) {
tw_mod |= TW_KMOD_CTRL;
}
if(mod & GLFW_MOD_ALT) {
tw_mod |= TW_KMOD_ALT;
}
TwKeyPressed(key, TW_KMOD_NONE);
}
// TwEventSDL12 returns zero if msg has not been handled,
// and a non-zero value if it has been handled by the AntTweakBar library.
int TW_CALL TwEventSDL12(const void *sdlEvent)
{
int handled = 0;
const SDL_Event *event = (const SDL_Event *)sdlEvent;
if( event==NULL )
return 0;
switch( event->type )
{
case SDL_KEYDOWN:
if( event->key.keysym.unicode!=0 && (event->key.keysym.unicode & 0xFF00)==0 )
{
if( (event->key.keysym.unicode & 0xFF)<32 && (event->key.keysym.unicode & 0xFF)!=event->key.keysym.sym )
handled = TwKeyPressed((event->key.keysym.unicode & 0xFF)+'a'-1, event->key.keysym.mod);
else
handled = TwKeyPressed(event->key.keysym.unicode & 0xFF, event->key.keysym.mod);
}
else
handled = TwKeyPressed(event->key.keysym.sym, event->key.keysym.mod);
break;
case SDL_MOUSEMOTION:
handled = TwMouseMotion(event->motion.x, event->motion.y);
break;
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEBUTTONDOWN:
if( event->type==SDL_MOUSEBUTTONDOWN && (event->button.button==4 || event->button.button==5) ) // mouse wheel
{
static int s_WheelPos = 0;
if( event->button.button==4 )
++s_WheelPos;
else
--s_WheelPos;
handled = TwMouseWheel(s_WheelPos);
}
else
handled = TwMouseButton((event->type==SDL_MOUSEBUTTONUP)?TW_MOUSE_RELEASED:TW_MOUSE_PRESSED, (TwMouseButtonID)event->button.button);
break;
case SDL_VIDEORESIZE:
// tell the new size to TweakBar
TwWindowSize(event->resize.w, event->resize.h);
// do not set 'handled', SDL_VIDEORESIZE may be also processed by the calling application
break;
}
return handled;
}
int TW_GLUT_CALL TwEventSpecialGLUT(int glutKey, int mouseX, int mouseY)
{
int k = 0, kmod = 0;
if( g_GLUTGetModifiers!=NULL )
{
int glutMod = g_GLUTGetModifiers();
if( glutMod&GLUT_ACTIVE_SHIFT )
kmod |= TW_KMOD_SHIFT;
if( glutMod&GLUT_ACTIVE_CTRL )
kmod |= TW_KMOD_CTRL;
if( glutMod&GLUT_ACTIVE_ALT )
kmod |= TW_KMOD_ALT;
}
if( glutKey>=GLUT_KEY_F1 && glutKey<=GLUT_KEY_F12 )
k = TW_KEY_F1 + (glutKey-GLUT_KEY_F1);
else
{
switch( glutKey )
{
case GLUT_KEY_LEFT:
k = TW_KEY_LEFT;
break;
case GLUT_KEY_UP:
k = TW_KEY_UP;
break;
case GLUT_KEY_RIGHT:
k = TW_KEY_RIGHT;
break;
case GLUT_KEY_DOWN:
k = TW_KEY_DOWN;
break;
case GLUT_KEY_PAGE_UP:
k = TW_KEY_PAGE_UP;
break;
case GLUT_KEY_PAGE_DOWN:
k = TW_KEY_PAGE_DOWN;
break;
case GLUT_KEY_HOME:
k = TW_KEY_HOME;
break;
case GLUT_KEY_END:
k = TW_KEY_END;
break;
case GLUT_KEY_INSERT:
k = TW_KEY_INSERT;
break;
}
}
if( k>0 && k<TW_KEY_LAST )
return TwKeyPressed(k, kmod);
else
return 0;
}
bool ATB::KeyboardCB(OGLDEV_KEY OgldevKey)
{
int ATBKey = OgldevKeyToATBKey(OgldevKey);
if (ATBKey == TW_KEY_LAST) {
return false;
}
return (TwKeyPressed(ATBKey, TW_KMOD_NONE) == 1);
}
void ofxTweakbars::keyPressed(ofKeyEventArgs& rArgs) {
TwKeyPressed(rArgs.key, TW_KMOD_NONE); // fix this!
// default keys (not sure if this is really user friendly.. people?)
if(rArgs.key == '.') {
autoStore();
}
else if (rArgs.key == ',') {
toggle();
}
changed();
}
void ofxTweakbars::keyPressed(ofKeyEventArgs& rArgs) {
// up, down, left, right are working now!
if(rArgs.key == OF_KEY_DOWN) { rArgs.key = TW_KEY_DOWN; }
else if(rArgs.key == OF_KEY_UP) { rArgs.key = TW_KEY_UP; }
else if(rArgs.key == OF_KEY_LEFT) { rArgs.key = TW_KEY_LEFT; }
else if(rArgs.key == OF_KEY_RIGHT) { rArgs.key = TW_KEY_RIGHT; }
TwKeyPressed(rArgs.key, TW_KMOD_NONE); // fix this!
// default keys (not sure if this is really user friendly.. people?)
if(rArgs.key == '.') {
autoStore();
}
else if (rArgs.key == ',') {
toggle();
}
}
int TW_GLUT_CALL TwEventKeyboardGLUT(unsigned char glutKey, int mouseX, int mouseY)
{
int kmod = 0;
if( g_GLUTGetModifiers!=NULL )
{
int glutMod = g_GLUTGetModifiers();
if( glutMod&GLUT_ACTIVE_SHIFT )
kmod |= TW_KMOD_SHIFT;
if( glutMod&GLUT_ACTIVE_CTRL )
kmod |= TW_KMOD_CTRL;
if( glutMod&GLUT_ACTIVE_ALT )
kmod |= TW_KMOD_ALT;
}
if( (kmod&TW_KMOD_CTRL) && (glutKey>0 && glutKey<27) ) // CTRL special case
glutKey += 'a'-1;
return TwKeyPressed((int)glutKey, kmod);
}
void GXBaseContext::OnKeyboard(int key, bool down)
{
if (down)
{
int kmod = 0;
if(GetShiftKey()) kmod |= TW_KMOD_SHIFT;
if(GetCtrlKey()) kmod |= TW_KMOD_CTRL;
if(GetAltKey()) kmod |= TW_KMOD_ALT;
if( (kmod&TW_KMOD_CTRL) && (key>0 && key<27) ) // CTRL special case
key += 'a'-1;
if (!TwKeyPressed(key, kmod))
{
// Process keyboard event inside application
if(VK_UP==key)if(m_camera->m_zoom--<=1)m_camera->m_zoom=1;
if(VK_DOWN==key)if(m_camera->m_zoom++>=100)m_camera->m_zoom=100;
}
}
}
int TwKeyPressQt(QKeyEvent *e)
{
int kmod = 0;
if(e->modifiers() & Qt::ShiftModifier ) kmod |= TW_KMOD_SHIFT;
if(e->modifiers() & Qt::ControlModifier ) kmod |= TW_KMOD_CTRL;
if(e->modifiers() & Qt::AltModifier ) kmod |= TW_KMOD_ALT;
int key = e->key();
int k = 0;
if( key>0 && key<0x7e ) k=key; // plain ascii codes
if( key>=Qt::Key_F1 && key<=Qt::Key_F12 )
k = TW_KEY_F1 + (key-Qt::Key_F1 );
else
{
switch( key )
{
case Qt::Key_Left: k = TW_KEY_LEFT; break;
case Qt::Key_Up: k = TW_KEY_UP; break;
case Qt::Key_Right: k = TW_KEY_RIGHT; break;
case Qt::Key_Down: k = TW_KEY_DOWN; break;
case Qt::Key_PageUp: k = TW_KEY_PAGE_UP; break;
case Qt::Key_PageDown: k = TW_KEY_PAGE_DOWN; break;
case Qt::Key_Home: k = TW_KEY_HOME; break;
case Qt::Key_End: k = TW_KEY_END; break;
case Qt::Key_Insert: k = TW_KEY_INSERT; break;
case Qt::Key_Backspace: k = TW_KEY_BACKSPACE; break;
case Qt::Key_Delete: k = TW_KEY_DELETE; break;
case Qt::Key_Return: k = TW_KEY_RETURN; break;
case Qt::Key_Enter: k = TW_KEY_RETURN; break;
case Qt::Key_Escape: k = TW_KEY_ESCAPE; break;
case Qt::Key_Tab: k = TW_KEY_TAB; break;
case Qt::Key_Space: k = TW_KEY_SPACE; break;
}
}
return TwKeyPressed(k, kmod);
}
int TW_CALL TwEventKeyGLFW(int glfwKey, int glfwAction)
{
int handled = 0;
// Register of modifiers state
if( glfwAction==GLFW_PRESS )
{
switch( glfwKey )
{
case GLFW_KEY_LSHIFT:
case GLFW_KEY_RSHIFT:
g_KMod |= TW_KMOD_SHIFT;
break;
case GLFW_KEY_LCTRL:
case GLFW_KEY_RCTRL:
g_KMod |= TW_KMOD_CTRL;
break;
case GLFW_KEY_LALT:
case GLFW_KEY_RALT:
g_KMod |= TW_KMOD_ALT;
break;
}
}
else
{
switch( glfwKey )
{
case GLFW_KEY_LSHIFT:
case GLFW_KEY_RSHIFT:
g_KMod &= ~TW_KMOD_SHIFT;
break;
case GLFW_KEY_LCTRL:
case GLFW_KEY_RCTRL:
g_KMod &= ~TW_KMOD_CTRL;
break;
case GLFW_KEY_LALT:
case GLFW_KEY_RALT:
g_KMod &= ~TW_KMOD_ALT;
break;
}
}
// Process key pressed
if( glfwAction==GLFW_PRESS )
{
int mod = g_KMod;
int testkp = ((mod&TW_KMOD_CTRL) || (mod&TW_KMOD_ALT)) ? 1 : 0;
if( (mod&TW_KMOD_CTRL) && glfwKey>0 && glfwKey<GLFW_KEY_SPECIAL ) // CTRL cases
handled = TwKeyPressed(glfwKey, mod);
else if( glfwKey>=GLFW_KEY_SPECIAL )
{
int k = 0;
if( glfwKey>=GLFW_KEY_F1 && glfwKey<=GLFW_KEY_F15 )
k = TW_KEY_F1 + (glfwKey-GLFW_KEY_F1);
else if( testkp && glfwKey>=GLFW_KEY_KP_0 && glfwKey<=GLFW_KEY_KP_9 )
k = '0' + (glfwKey-GLFW_KEY_KP_0);
else
{
switch( glfwKey )
{
case GLFW_KEY_ESC:
k = TW_KEY_ESCAPE;
break;
case GLFW_KEY_UP:
k = TW_KEY_UP;
break;
case GLFW_KEY_DOWN:
k = TW_KEY_DOWN;
break;
case GLFW_KEY_LEFT:
k = TW_KEY_LEFT;
break;
case GLFW_KEY_RIGHT:
k = TW_KEY_RIGHT;
break;
case GLFW_KEY_TAB:
k = TW_KEY_TAB;
break;
case GLFW_KEY_ENTER:
k = TW_KEY_RETURN;
break;
case GLFW_KEY_BACKSPACE:
k = TW_KEY_BACKSPACE;
break;
case GLFW_KEY_INSERT:
k = TW_KEY_INSERT;
break;
case GLFW_KEY_DEL:
k = TW_KEY_DELETE;
break;
case GLFW_KEY_PAGEUP:
k = TW_KEY_PAGE_UP;
break;
case GLFW_KEY_PAGEDOWN:
k = TW_KEY_PAGE_DOWN;
break;
case GLFW_KEY_HOME:
k = TW_KEY_HOME;
break;
case GLFW_KEY_END:
k = TW_KEY_END;
break;
case GLFW_KEY_KP_ENTER:
k = TW_KEY_RETURN;
break;
case GLFW_KEY_KP_DIVIDE:
if( testkp )
k = '/';
break;
case GLFW_KEY_KP_MULTIPLY:
if( testkp )
k = '*';
break;
case GLFW_KEY_KP_SUBTRACT:
if( testkp )
k = '-';
break;
case GLFW_KEY_KP_ADD:
if( testkp )
k = '+';
break;
case GLFW_KEY_KP_DECIMAL:
if( testkp )
k = '.';
break;
case GLFW_KEY_KP_EQUAL:
if( testkp )
k = '=';
break;
}
}
if( k>0 )
handled = TwKeyPressed(k, mod);
}
}
return handled;
}
int TW_CALL TwEventKeyGLFW3(GLFWwindow *window, int glfwKey, int glfwScancode, int glfwAction, int glfwMods)
{
int handled = 0;
int mod = convertModifiers(glfwMods);
int testkp = ((mod&TW_KMOD_CTRL) || (mod&TW_KMOD_ALT)) ? 1 : 0;
int k = 0;
if (glfwAction == GLFW_RELEASE)
return 0;
if( (mod&TW_KMOD_CTRL) && glfwKey>0 && glfwKey<GLFW_KEY_SPECIAL ) // CTRL cases
return TwKeyPressed(glfwKey, mod);
if (glfwKey < GLFW_KEY_SPECIAL)
return 0;
if( glfwKey>=GLFW_KEY_F1 && glfwKey<=GLFW_KEY_F15 )
k = TW_KEY_F1 + (glfwKey-GLFW_KEY_F1);
else if( testkp && glfwKey>=GLFW_KEY_KP_0 && glfwKey<=GLFW_KEY_KP_9 )
k = '0' + (glfwKey-GLFW_KEY_KP_0);
else
{
switch( glfwKey )
{
case GLFW_KEY_ESCAPE:
k = TW_KEY_ESCAPE;
break;
case GLFW_KEY_UP:
k = TW_KEY_UP;
break;
case GLFW_KEY_DOWN:
k = TW_KEY_DOWN;
break;
case GLFW_KEY_LEFT:
k = TW_KEY_LEFT;
break;
case GLFW_KEY_RIGHT:
k = TW_KEY_RIGHT;
break;
case GLFW_KEY_TAB:
k = TW_KEY_TAB;
break;
case GLFW_KEY_ENTER:
k = TW_KEY_RETURN;
break;
case GLFW_KEY_BACKSPACE:
k = TW_KEY_BACKSPACE;
break;
case GLFW_KEY_INSERT:
k = TW_KEY_INSERT;
break;
case GLFW_KEY_DELETE:
k = TW_KEY_DELETE;
break;
case GLFW_KEY_PAGE_UP:
k = TW_KEY_PAGE_UP;
break;
case GLFW_KEY_PAGE_DOWN:
k = TW_KEY_PAGE_DOWN;
break;
case GLFW_KEY_HOME:
k = TW_KEY_HOME;
break;
case GLFW_KEY_END:
k = TW_KEY_END;
break;
case GLFW_KEY_KP_ENTER:
k = TW_KEY_RETURN;
break;
case GLFW_KEY_KP_DIVIDE:
if( testkp )
k = '/';
break;
case GLFW_KEY_KP_MULTIPLY:
if( testkp )
k = '*';
break;
case GLFW_KEY_KP_SUBTRACT:
if( testkp )
k = '-';
break;
case GLFW_KEY_KP_ADD:
if( testkp )
k = '+';
break;
case GLFW_KEY_KP_DECIMAL:
if( testkp )
k = '.';
break;
case GLFW_KEY_KP_EQUAL:
if( testkp )
k = '=';
break;
}
}
return k ? TwKeyPressed(k, mod) : 0;
}
// TwEventSDL returns zero if msg has not been handled,
// and a non-zero value if it has been handled by the AntTweakBar library.
int TW_CALL TwEventSDL(const void *sdlEvent, unsigned char sdlMajorVersion, unsigned char sdlMinorVersion)
{
int handled = 0;
static int s_KeyMod = 0;
const SDL_Event *event = (const SDL_Event *)sdlEvent;
if( event==NULL )
return 0;
switch( event->type )
{
case SDL_TEXTINPUT:
if( event->text.text[0]!=0 && event->text.text[1]==0 )
{
if( s_KeyMod & TW_KMOD_CTRL && event->text.text[0]<32 )
handled = TwKeyPressed(event->text.text[0]+'a'-1, s_KeyMod);
else
{
if (s_KeyMod & KMOD_RALT)
s_KeyMod &= ~KMOD_CTRL;
handled = TwKeyPressed(event->text.text[0], s_KeyMod);
}
}
s_KeyMod = 0;
break;
case SDL_KEYDOWN:
if( event->key.keysym.sym & SDLK_SCANCODE_MASK )
{
int key = 0;
switch( event->key.keysym.sym )
{
case SDLK_UP:
key = TW_KEY_UP;
break;
case SDLK_DOWN:
key = TW_KEY_DOWN;
break;
case SDLK_RIGHT:
key = TW_KEY_RIGHT;
break;
case SDLK_LEFT:
key = TW_KEY_LEFT;
break;
case SDLK_INSERT:
key = TW_KEY_INSERT;
break;
case SDLK_HOME:
key = TW_KEY_HOME;
break;
case SDLK_END:
key = TW_KEY_END;
break;
case SDLK_PAGEUP:
key = TW_KEY_PAGE_UP;
break;
case SDLK_PAGEDOWN:
key = TW_KEY_PAGE_DOWN;
break;
default:
if( event->key.keysym.sym>=SDLK_F1 && event->key.keysym.sym<=SDLK_F12 )
key = event->key.keysym.sym + TW_KEY_F1 - SDLK_F1;
}
if( key!=0 )
handled = TwKeyPressed(key, event->key.keysym.mod);
}
else if( event->key.keysym.mod & TW_KMOD_ALT )
handled = TwKeyPressed(event->key.keysym.sym & 0xFF, event->key.keysym.mod);
else
s_KeyMod = event->key.keysym.mod;
break;
case SDL_KEYUP:
s_KeyMod = 0;
break;
case SDL_MOUSEMOTION:
handled = TwMouseMotion(event->motion.x, event->motion.y);
break;
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEBUTTONDOWN:
if( event->type==SDL_MOUSEBUTTONDOWN && (event->button.button==4 || event->button.button==5) ) // mouse wheel
{
static int s_WheelPos = 0;
if( event->button.button==4 )
++s_WheelPos;
else
--s_WheelPos;
handled = TwMouseWheel(s_WheelPos);
}
else
handled = TwMouseButton((event->type==SDL_MOUSEBUTTONUP)?TW_MOUSE_RELEASED:TW_MOUSE_PRESSED, (TwMouseButtonID)event->button.button);
break;
case SDL_WINDOWEVENT:
switch( event->window.event )
{
case SDL_WINDOWEVENT_SIZE_CHANGED:
// tell the new size to TweakBar
TwWindowSize(event->window.data1, event->window.data2);
// do not set 'handled', SDL_VIDEORESIZE may be also processed by the calling application
break;
}
break;
}
return handled;
}
// TwEventSFML returns zero if msg has not been handled,
// and a non-zero value if it has been handled by the AntTweakBar library.
int TW_CALL TwEventSFML(const void *sfmlEvent, unsigned char majorVersion, unsigned char minorVersion)
{
// Assume version 1.6 (will possibly not work for version != 1.6, but give it a chance)
/*
if (majorVersion > 1 || (majorVersion == 1 && minorVersion > 6)
{
static const char *g_ErrBadSFMLVersion = "Unsupported SFML version";
TwSetLastError(g_ErrBadSFMLVersion);
return 0;
}
*/
(void)majorVersion, (void)minorVersion;
int handled = 0;
const sf::Event *event = (const sf::Event *)sfmlEvent;
TwMouseAction mouseAction;
int key = 0;
static int s_KMod = 0;
static bool s_PreventTextHandling = false;
static int s_WheelPos = 0;
if (event == NULL)
return 0;
switch (event->Type)
{
case sf::Event::KeyPressed:
s_PreventTextHandling = false;
s_KMod = 0;
if (event->Key.Shift) s_KMod |= TW_KMOD_SHIFT;
if (event->Key.Alt) s_KMod |= TW_KMOD_ALT;
if (event->Key.Control) s_KMod |= TW_KMOD_CTRL;
key = 0;
switch (event->Key.Code)
{
case sf::Key::Escape:
key = TW_KEY_ESCAPE;
break;
case sf::Key::Return:
key = TW_KEY_RETURN;
break;
case sf::Key::Tab:
key = TW_KEY_TAB;
break;
case sf::Key::Back:
key = TW_KEY_BACKSPACE;
break;
case sf::Key::PageUp:
key = TW_KEY_PAGE_UP;
break;
case sf::Key::PageDown:
key = TW_KEY_PAGE_DOWN;
break;
case sf::Key::Up:
key = TW_KEY_UP;
break;
case sf::Key::Down:
key = TW_KEY_DOWN;
break;
case sf::Key::Left:
key = TW_KEY_LEFT;
break;
case sf::Key::Right:
key = TW_KEY_RIGHT;
break;
case sf::Key::End:
key = TW_KEY_END;
break;
case sf::Key::Home:
key = TW_KEY_HOME;
break;
case sf::Key::Insert:
key = TW_KEY_INSERT;
break;
case sf::Key::Delete:
key = TW_KEY_DELETE;
break;
case sf::Key::Space:
key = TW_KEY_SPACE;
break;
default:
if (event->Key.Code >= sf::Key::F1 && event->Key.Code <= sf::Key::F15)
key = TW_KEY_F1 + event->Key.Code - sf::Key::F1;
else if (s_KMod & TW_KMOD_ALT)
{
if (event->Key.Code >= sf::Key::A && event->Key.Code <= sf::Key::Z)
{
if (s_KMod & TW_KMOD_SHIFT)
key = 'A' + event->Key.Code - sf::Key::A;
else
key = 'a' + event->Key.Code - sf::Key::A;
}
}
}
if (key != 0)
{
handled = TwKeyPressed(key, s_KMod);
s_PreventTextHandling = true;
}
break;
case sf::Event::KeyReleased:
s_PreventTextHandling = false;
s_KMod = 0;
break;
case sf::Event::TextEntered:
if (!s_PreventTextHandling && event->Text.Unicode != 0 && (event->Text.Unicode & 0xFF00) == 0)
{
if ((event->Text.Unicode & 0xFF) < 32) // CTRL+letter
handled = TwKeyPressed((event->Text.Unicode & 0xFF)+'a'-1, TW_KMOD_CTRL|s_KMod);
else
handled = TwKeyPressed(event->Text.Unicode & 0xFF, 0);
}
s_PreventTextHandling = false;
break;
case sf::Event::MouseMoved:
handled = TwMouseMotion(event->MouseMove.X, event->MouseMove.Y);
break;
case sf::Event::MouseButtonPressed:
case sf::Event::MouseButtonReleased:
mouseAction = (event->Type==sf::Event::MouseButtonPressed) ? TW_MOUSE_PRESSED : TW_MOUSE_RELEASED;
switch (event->MouseButton.Button)
{
case sf::Mouse::Left:
handled = TwMouseButton(mouseAction, TW_MOUSE_LEFT);
break;
case sf::Mouse::Middle:
handled = TwMouseButton(mouseAction, TW_MOUSE_MIDDLE);
break;
case sf::Mouse::Right:
handled = TwMouseButton(mouseAction, TW_MOUSE_RIGHT);
break;
default:
break;
}
break;
case sf::Event::MouseWheelMoved:
s_WheelPos += event->MouseWheel.Delta;
handled = TwMouseWheel(s_WheelPos);
break;
case sf::Event::Resized:
// tell the new size to TweakBar
TwWindowSize(event->Size.Width, event->Size.Height);
// do not set 'handled', sf::Event::Resized may be also processed by the client application
break;
default:
break;
}
return handled;
}
// --------------------------------------------------------------- keyboard ---
void keyboard( GLFWwindow* window, int key, int scancode, int action, int mods )
{
int tw_key = 0;
int tw_mods = TW_KMOD_NONE;
if( action != GLFW_PRESS )
{
return;
}
// those map to the corresponding number ascii code
if ( GLFW_KEY_0 <= key && key <= GLFW_KEY_9 )
{
tw_key = key;
}
// those map to the corresponding upper case ascii code
if ( GLFW_KEY_A <= key && key <= GLFW_KEY_Z )
{
tw_key = key;
}
if ( GLFW_KEY_PERIOD == key )
{
tw_key = '.';
}
if ( GLFW_KEY_BACKSPACE == key )
{
tw_key = TW_KEY_BACKSPACE;
}
if ( GLFW_KEY_DELETE == key )
{
tw_key = TW_KEY_DELETE;
}
if ( GLFW_KEY_LEFT == key )
{
tw_key = TW_KEY_LEFT;
}
if ( GLFW_KEY_RIGHT == key )
{
tw_key = TW_KEY_RIGHT;
}
if ( GLFW_KEY_UP == key )
{
tw_key = TW_KEY_UP;
}
if ( GLFW_KEY_DOWN == key )
{
tw_key = TW_KEY_DOWN;
}
if ( GLFW_KEY_ENTER == key )
{
tw_key = TW_KEY_RETURN;
}
if( GLFW_MOD_SHIFT & mods )
{
tw_mods |= TW_KMOD_SHIFT;
}
if( GLFW_MOD_CONTROL & mods )
{
tw_mods |= TW_KMOD_CTRL;
}
if( GLFW_MOD_ALT & mods )
{
tw_mods |= TW_KMOD_ALT;
}
TwKeyPressed( tw_key, tw_mods );
}
// TwEventWin32 returns zero if msg has not been handled,
// and a non-zero value if it has been handled by the AntTweakBar library.
int TW_CALL TwEventWin32(void *wnd, unsigned int msg, unsigned int _W64 wParam, int _W64 lParam)
{
int handled = 0;
switch( msg )
{
case WM_MOUSEMOVE:
// send signed! mouse coordinates
handled = TwMouseMotion((short)LOWORD(lParam), (short)HIWORD(lParam));
break;
case WM_LBUTTONDOWN:
SetCapture(wnd);
handled = TwMouseButton(TW_MOUSE_PRESSED, TW_MOUSE_LEFT);
break;
case WM_LBUTTONUP:
ReleaseCapture();
handled = TwMouseButton(TW_MOUSE_RELEASED, TW_MOUSE_LEFT);
break;
case WM_MBUTTONDOWN:
SetCapture(wnd);
handled = TwMouseButton(TW_MOUSE_PRESSED, TW_MOUSE_MIDDLE);
break;
case WM_MBUTTONUP:
ReleaseCapture();
handled = TwMouseButton(TW_MOUSE_RELEASED, TW_MOUSE_MIDDLE);
break;
case WM_RBUTTONDOWN:
SetCapture(wnd);
handled = TwMouseButton(TW_MOUSE_PRESSED, TW_MOUSE_RIGHT);
break;
case WM_RBUTTONUP:
ReleaseCapture();
handled = TwMouseButton(TW_MOUSE_RELEASED, TW_MOUSE_RIGHT);
break;
case WM_CHAR:
case WM_SYSCHAR:
{
int key = (int)(wParam&0xff);
int kmod = 0;
if( GetAsyncKeyState(VK_SHIFT)<0 )
kmod |= TW_KMOD_SHIFT;
if( GetAsyncKeyState(VK_CONTROL)<0 )
{
kmod |= TW_KMOD_CTRL;
if( key>0 && key<27 )
key += 'a'-1;
}
if( GetAsyncKeyState(VK_MENU)<0 )
kmod |= TW_KMOD_ALT;
if( key>0 && key<256 )
handled = TwKeyPressed(key, kmod);
}
break;
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
{
int kmod = 0;
int testkp = 0;
int k = 0;
if( GetAsyncKeyState(VK_SHIFT)<0 )
kmod |= TW_KMOD_SHIFT;
if( GetAsyncKeyState(VK_CONTROL)<0 )
{
kmod |= TW_KMOD_CTRL;
testkp = 1;
}
if( GetAsyncKeyState(VK_MENU)<0 )
{
kmod |= TW_KMOD_ALT;
testkp = 1;
}
if( wParam>=VK_F1 && wParam<=VK_F15 )
k = TW_KEY_F1 + ((int)wParam-VK_F1);
else if( testkp && wParam>=VK_NUMPAD0 && wParam<=VK_NUMPAD9 )
k = '0' + ((int)wParam-VK_NUMPAD0);
else
{
switch( wParam )
{
case VK_UP:
k = TW_KEY_UP;
break;
case VK_DOWN:
k = TW_KEY_DOWN;
break;
case VK_LEFT:
k = TW_KEY_LEFT;
break;
case VK_RIGHT:
k = TW_KEY_RIGHT;
break;
case VK_INSERT:
k = TW_KEY_INSERT;
break;
case VK_DELETE:
k = TW_KEY_DELETE;
break;
case VK_PRIOR:
k = TW_KEY_PAGE_UP;
break;
case VK_NEXT:
k = TW_KEY_PAGE_DOWN;
break;
case VK_HOME:
k = TW_KEY_HOME;
break;
case VK_END:
k = TW_KEY_END;
break;
case VK_DIVIDE:
if( testkp )
k = '/';
break;
case VK_MULTIPLY:
if( testkp )
k = '*';
break;
case VK_SUBTRACT:
if( testkp )
k = '-';
break;
case VK_ADD:
if( testkp )
k = '+';
break;
case VK_DECIMAL:
if( testkp )
k = '.';
break;
default:
if( (kmod&TW_KMOD_CTRL) && (kmod&TW_KMOD_ALT) )
k = MapVirtualKey( (UINT)wParam, 2 ) & 0x0000FFFF;
}
}
if( k!=0 )
handled = TwKeyPressed(k, kmod);
}
break;
case WM_MOUSEWHEEL:
{
static int s_WheelPos = 0;
s_WheelPos += ((short)HIWORD(wParam))/WHEEL_DELTA;
handled = TwMouseWheel(s_WheelPos);
}
break;
case WM_SIZE:
// tell the new size to TweakBar
TwWindowSize(LOWORD(lParam), HIWORD(lParam));
// do not set 'handled', WM_SIZE may be also processed by the calling application
break;
}
return handled;
}
int TW_CALL TwEventSDL20(const void *sdlEvent)
{
int handled = 0;
const SDL_Event *event = (const SDL_Event *)sdlEvent;
if (event == NULL)
return 0;
switch (event->type)
{
case SDL_KEYDOWN:
if (event->key.keysym.sym & SDLK_SCANCODE_MASK) {
int key = 0;
switch (event->key.keysym.sym) {
case SDLK_UP:
key = TW_KEY_UP;
break;
case SDLK_DOWN:
key = TW_KEY_DOWN;
break;
case SDLK_RIGHT:
key = TW_KEY_RIGHT;
break;
case SDLK_LEFT:
key = TW_KEY_LEFT;
break;
case SDLK_INSERT:
key = TW_KEY_INSERT;
break;
case SDLK_HOME:
key = TW_KEY_HOME;
break;
case SDLK_END:
key = TW_KEY_END;
break;
case SDLK_PAGEUP:
key = TW_KEY_PAGE_UP;
break;
case SDLK_PAGEDOWN:
key = TW_KEY_PAGE_DOWN;
break;
default:
if (event->key.keysym.sym >= SDLK_F1 &&
event->key.keysym.sym <= SDLK_F12) {
key = event->key.keysym.sym + TW_KEY_F1 - SDLK_F1;
}
break;
}
if (key != 0) {
handled = TwKeyPressed(key, event->key.keysym.mod);
}
}
else {
handled = TwKeyPressed(event->key.keysym.sym /*& 0xFF*/,
event->key.keysym.mod);
}
break;
case SDL_MOUSEMOTION:
handled = TwMouseMotion(event->motion.x, event->motion.y);
break;
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEBUTTONDOWN:
if (event->type == SDL_MOUSEBUTTONDOWN &&
(event->button.button == 4 || event->button.button == 5)) {
// mouse wheel
static int s_WheelPos = 0;
if (event->button.button == 4)
++s_WheelPos;
else
--s_WheelPos;
handled = TwMouseWheel(s_WheelPos);
}
else {
handled = TwMouseButton(
(event->type == SDL_MOUSEBUTTONUP) ?
TW_MOUSE_RELEASED : TW_MOUSE_PRESSED,
(TwMouseButtonID)event->button.button);
}
break;
case SDL_WINDOWEVENT:
if (event->window.event == SDL_WINDOWEVENT_RESIZED) {
// tell the new size to TweakBar
TwWindowSize(event->window.data1, event->window.data2);
// do not set 'handled'
// SDL_VIDEORESIZE may be also processed by the calling application
}
break;
}
return handled;
}
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
static int _XKeyPress(XEvent *event)
{
int modifiers = 0; // modifiers sent to AntTweakBar
int k = 0; // key sent to AntTweakBar
KeySym keysym;
char buffer[buff_sz];
int num_char = XLookupString((XKeyEvent *)event, buffer, buff_sz, &keysym, 0);
if (event->xkey.state & ControlMask)
modifiers |= TW_KMOD_CTRL;
if (event->xkey.state & ShiftMask)
modifiers |= TW_KMOD_SHIFT;
if (event->xkey.state & Mod1Mask)
modifiers |= TW_KMOD_ALT;
switch (keysym)
{
case XK_Control_L:
case XK_Control_R: s_KMod |= TW_KMOD_CTRL; break;
case XK_Shift_L:
case XK_Shift_R: s_KMod |= TW_KMOD_SHIFT; break;
case XK_Alt_L:
case XK_Alt_R: s_KMod |= TW_KMOD_ALT; break;
case XK_Escape: k = TW_KEY_ESCAPE; break;
case XK_Help: k = TW_KEY_F1; break;
case XK_F1: k = TW_KEY_F1; break;
case XK_F2: k = TW_KEY_F2; break;
case XK_F3: k = TW_KEY_F3; break;
case XK_F4: k = TW_KEY_F4; break;
case XK_F5: k = TW_KEY_F5; break;
case XK_F6: k = TW_KEY_F6; break;
case XK_F7: k = TW_KEY_F7; break;
case XK_F8: k = TW_KEY_F8; break;
case XK_F9: k = TW_KEY_F9; break;
case XK_F10: k = TW_KEY_F10; break;
case XK_F11: k = TW_KEY_F11; break;
case XK_F12: k = TW_KEY_F12; break;
case XK_Up: k = TW_KEY_UP; break;
case XK_Down: k = TW_KEY_DOWN; break;
case XK_Right: k = TW_KEY_RIGHT; break;
case XK_Left: k = TW_KEY_LEFT; break;
case XK_Return: k = TW_KEY_RETURN; break;
case XK_Insert: k = TW_KEY_INSERT; break;
case XK_Delete: k = TW_KEY_DELETE; break;
case XK_BackSpace: k = TW_KEY_BACKSPACE; break;
case XK_Home: k = TW_KEY_HOME; break;
case XK_Tab: k = TW_KEY_TAB; break;
case XK_End: k = TW_KEY_END; break;
#ifdef XK_Enter
case XK_Enter: k = TW_KEY_RETURN; break;
#endif
#ifdef XK_KP_Home
case XK_KP_Home: k = TW_KEY_HOME; break;
case XK_KP_End: k = TW_KEY_END; break;
case XK_KP_Delete: k = TW_KEY_DELETE; break;
#endif
#ifdef XK_KP_Up
case XK_KP_Up: k = TW_KEY_UP; break;
case XK_KP_Down: k = TW_KEY_DOWN; break;
case XK_KP_Right: k = TW_KEY_RIGHT; break;
case XK_KP_Left: k = TW_KEY_LEFT; break;
#endif
#ifdef XK_KP_Page_Up
case XK_KP_Page_Up: k = TW_KEY_PAGE_UP; break;
case XK_KP_Page_Down: k = TW_KEY_PAGE_DOWN; break;
#endif
#ifdef XK_KP_Tab
case XK_KP_Tab: k = TW_KEY_TAB; break;
#endif
default:
if (0)
{
// should we do that, or rely on the buffer (see code below)
if (keysym > 12 && keysym < 127)
k = keysym;
}
break;
}
if (k == 0 && num_char)
{
int i, handled = 0;
for (i=0; i<num_char; ++i)
if (TwKeyPressed(buffer[i], modifiers))
handled = 1;
return handled;
}
// if we have a valid key, send to AntTweakBar
// -------------------------------------------
return (k > 0) ? TwKeyPressed(k, modifiers) : 0;
}
/**
* Handles all keyboard input.
* @param vkCode the key pressed
* @param bKeyDown <code>true</code> if the key is pressed, else it is released
* @param sender the window that send the keyboard messages
*/
bool ApplicationBase::HandleKeyboard(unsigned int vkCode, bool bKeyDown, BaseGLWindow* sender)
{
auto handled = 0;
static unsigned __int64 s_PrevKeyDown = 0;
static __int64 s_PrevKeyDownMod = 0;
static auto s_PrevKeyDownHandled = 0;
auto kmod = 0;
auto testkp = 0;
auto k = 0;
auto twVKCode = vkCode == VK_NUMRETURN ? VK_RETURN : vkCode;
if (sender->GetKeyboardModState(VK_MOD_SHIFT)) kmod |= TW_KMOD_SHIFT;
if (sender->GetKeyboardModState(VK_MOD_CTRL)) {
kmod |= TW_KMOD_CTRL; testkp = 1;
}
if (sender->GetKeyboardModState(VK_MOD_MENU)) {
kmod |= TW_KMOD_ALT; testkp = 1;
}
if (twVKCode >= VK_F1 && twVKCode <= VK_F15)
k = TW_KEY_F1 + (twVKCode - VK_F1);
else if (testkp && twVKCode >= VK_NUMPAD0 && twVKCode <= VK_NUMPAD9)
k = '0' + (twVKCode - VK_NUMPAD0);
else switch (twVKCode)
{
case VK_UP:
k = TW_KEY_UP;
break;
case VK_DOWN:
k = TW_KEY_DOWN;
break;
case VK_LEFT:
k = TW_KEY_LEFT;
break;
case VK_RIGHT:
k = TW_KEY_RIGHT;
break;
case VK_INSERT:
k = TW_KEY_INSERT;
break;
case VK_DELETE:
k = TW_KEY_DELETE;
break;
case VK_PRIOR:
k = TW_KEY_PAGE_UP;
break;
case VK_NEXT:
k = TW_KEY_PAGE_DOWN;
break;
case VK_HOME:
k = TW_KEY_HOME;
break;
case VK_END:
k = TW_KEY_END;
break;
case VK_DIVIDE:
if (testkp)
k = '/';
break;
case VK_MULTIPLY:
if (testkp)
k = '*';
break;
case VK_SUBTRACT:
if (testkp)
k = '-';
break;
case VK_ADD:
if (testkp)
k = '+';
break;
case VK_DECIMAL:
if (testkp)
k = '.';
break;
default:
if ((kmod&TW_KMOD_CTRL) && (kmod&TW_KMOD_ALT))
k = MapVirtualKey(twVKCode, 2) & 0x0000FFFF;
}
if (bKeyDown) {
if (k != 0)
handled = TwKeyPressed(k, kmod);
else
{
// if the key will be handled at next WM_CHAR report this event as handled
auto key = static_cast<int>(MapVirtualKey(twVKCode, 2) & 0xff);
if (kmod&TW_KMOD_CTRL && key > 0 && key < 27)
key += 'a' - 1;
if (key > 0 && key < 256)
handled = TwKeyPressed(key, kmod);
}
s_PrevKeyDown = twVKCode;
s_PrevKeyDownMod = kmod;
s_PrevKeyDownHandled = handled;
} else {
// if the key has been handled at previous WM_KEYDOWN report this event as handled
if (s_PrevKeyDown == twVKCode && s_PrevKeyDownMod == kmod)
handled = s_PrevKeyDownHandled;
else
{
// if the key would have been handled report this event as handled
auto key = static_cast<int>(MapVirtualKey(twVKCode, 2) & 0xff);
if (kmod&TW_KMOD_CTRL && key > 0 && key < 27)
key += 'a' - 1;
if (key > 0 && key < 256)
handled = TwKeyTest(key, kmod);
}
// reset previous keydown
s_PrevKeyDown = 0;
s_PrevKeyDownMod = 0;
s_PrevKeyDownHandled = 0;
}
if (bKeyDown && handled == 0) {
switch (vkCode)
{
case VK_ESCAPE:
this->win.CloseWindow();
handled = 1;
break;
case VK_F9:
this->programManager->RecompileAll();
handled = 1;
break;
}
}
if (handled == 0 && IsRunning() && !IsPaused()) handled = cameraView->HandleKeyboard(vkCode, bKeyDown, sender);
return handled == 1;
}
// TwEventWin returns zero if msg has not been handled,
// and a non-zero value if it has been handled by the AntTweakBar library.
int TW_CALL TwEventWin(void *wnd, unsigned int msg, unsigned PARAM_INT _W64 wParam, PARAM_INT _W64 lParam)
{
int handled = 0;
static unsigned PARAM_INT s_PrevKeyDown = 0;
static PARAM_INT s_PrevKeyDownMod = 0;
static int s_PrevKeyDownHandled = 0;
switch( msg )
{
case WM_MOUSEMOVE:
// send signed! mouse coordinates
handled = TwMouseMotion((short)LOWORD(lParam), (short)HIWORD(lParam));
break;
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
SetCapture(wnd);
handled = TwMouseButton(TW_MOUSE_PRESSED, TW_MOUSE_LEFT);
break;
case WM_LBUTTONUP:
ReleaseCapture();
handled = TwMouseButton(TW_MOUSE_RELEASED, TW_MOUSE_LEFT);
break;
case WM_MBUTTONDOWN:
case WM_MBUTTONDBLCLK:
SetCapture(wnd);
handled = TwMouseButton(TW_MOUSE_PRESSED, TW_MOUSE_MIDDLE);
break;
case WM_MBUTTONUP:
ReleaseCapture();
handled = TwMouseButton(TW_MOUSE_RELEASED, TW_MOUSE_MIDDLE);
break;
case WM_RBUTTONDOWN:
case WM_RBUTTONDBLCLK:
SetCapture(wnd);
handled = TwMouseButton(TW_MOUSE_PRESSED, TW_MOUSE_RIGHT);
break;
case WM_RBUTTONUP:
ReleaseCapture();
handled = TwMouseButton(TW_MOUSE_RELEASED, TW_MOUSE_RIGHT);
break;
case WM_CHAR:
case WM_SYSCHAR:
{
int key = (int)(wParam&0xff);
int kmod = 0;
if( GetAsyncKeyState(VK_SHIFT)<0 )
kmod |= TW_KMOD_SHIFT;
if( GetAsyncKeyState(VK_CONTROL)<0 )
{
kmod |= TW_KMOD_CTRL;
if( key>0 && key<27 )
key += 'a'-1;
}
if( GetAsyncKeyState(VK_MENU)<0 )
kmod |= TW_KMOD_ALT;
if( key>0 && key<256 )
handled = TwKeyPressed(key, kmod);
}
break;
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
{
int kmod = 0;
int testkp = 0;
int k = 0;
if( GetAsyncKeyState(VK_SHIFT)<0 )
kmod |= TW_KMOD_SHIFT;
if( GetAsyncKeyState(VK_CONTROL)<0 )
{
kmod |= TW_KMOD_CTRL;
testkp = 1;
}
if( GetAsyncKeyState(VK_MENU)<0 )
{
kmod |= TW_KMOD_ALT;
testkp = 1;
}
if( wParam>=VK_F1 && wParam<=VK_F15 )
k = TW_KEY_F1 + ((int)wParam-VK_F1);
else if( testkp && wParam>=VK_NUMPAD0 && wParam<=VK_NUMPAD9 )
k = '0' + ((int)wParam-VK_NUMPAD0);
else
{
switch( wParam )
{
case VK_UP:
k = TW_KEY_UP;
break;
case VK_DOWN:
k = TW_KEY_DOWN;
break;
case VK_LEFT:
k = TW_KEY_LEFT;
break;
case VK_RIGHT:
k = TW_KEY_RIGHT;
break;
case VK_INSERT:
k = TW_KEY_INSERT;
break;
case VK_DELETE:
k = TW_KEY_DELETE;
break;
case VK_PRIOR:
k = TW_KEY_PAGE_UP;
break;
case VK_NEXT:
k = TW_KEY_PAGE_DOWN;
break;
case VK_HOME:
k = TW_KEY_HOME;
break;
case VK_END:
k = TW_KEY_END;
break;
case VK_DIVIDE:
if( testkp )
k = '/';
break;
case VK_MULTIPLY:
if( testkp )
k = '*';
break;
case VK_SUBTRACT:
if( testkp )
k = '-';
break;
case VK_ADD:
if( testkp )
k = '+';
break;
case VK_DECIMAL:
if( testkp )
k = '.';
break;
default:
if( (kmod&TW_KMOD_CTRL) && (kmod&TW_KMOD_ALT) )
k = MapVirtualKey( (UINT)wParam, 2 ) & 0x0000FFFF;
}
}
if( k!=0 )
handled = TwKeyPressed(k, kmod);
else
{
// if the key will be handled at next WM_CHAR report this event as handled
int key = (int)(wParam&0xff);
if( kmod&TW_KMOD_CTRL && key>0 && key<27 )
key += 'a'-1;
if( key>0 && key<256 )
handled = TwKeyTest(key, kmod);
}
s_PrevKeyDown = wParam;
s_PrevKeyDownMod = kmod;
s_PrevKeyDownHandled = handled;
}
break;
case WM_KEYUP:
case WM_SYSKEYUP:
{
int kmod = 0;
if( GetAsyncKeyState(VK_SHIFT)<0 )
kmod |= TW_KMOD_SHIFT;
if( GetAsyncKeyState(VK_CONTROL)<0 )
kmod |= TW_KMOD_CTRL;
if( GetAsyncKeyState(VK_MENU)<0 )
kmod |= TW_KMOD_ALT;
// if the key has been handled at previous WM_KEYDOWN report this event as handled
if( s_PrevKeyDown==wParam && s_PrevKeyDownMod==kmod )
handled = s_PrevKeyDownHandled;
else
{
// if the key would have been handled report this event as handled
int key = (int)(wParam&0xff);
if( kmod&TW_KMOD_CTRL && key>0 && key<27 )
key += 'a'-1;
if( key>0 && key<256 )
handled = TwKeyTest(key, kmod);
}
// reset previous keydown
s_PrevKeyDown = 0;
s_PrevKeyDownMod = 0;
s_PrevKeyDownHandled = 0;
}
break;
case WM_MOUSEWHEEL:
{
static int s_WheelPos = 0;
s_WheelPos += ((short)HIWORD(wParam))/WHEEL_DELTA;
handled = TwMouseWheel(s_WheelPos);
}
break;
case WM_SIZE:
// tell the new size to AntTweakBar
TwWindowSize(LOWORD(lParam), HIWORD(lParam));
// do not set 'handled', WM_SIZE may be also processed by the calling application
break;
}
if( handled )
// Event has been handled by AntTweakBar, so we invalidate the window
// content to send a WM_PAINT which will redraw the tweak bar(s).
InvalidateRect(wnd, NULL, FALSE);
return handled;
}
bool ControlUI::keyPressed(const OIS::KeyEvent &arg)
{
int atbKey = OISKeyToATBKey(arg.key);
return (TwKeyPressed(atbKey, TW_KMOD_NONE) == 1);
}
bool Tweaker::TranslateEvent(SDL_Event& event)
{
if(!s_isInit || !s_enabled || s_doNotUseLib) {
return false;
}
int handled = 0;
switch (event.type)
{
case SDL_KEYDOWN:
if (event.key.keysym.sym & SDLK_SCANCODE_MASK) {
int key = 0;
switch (event.key.keysym.sym) {
case SDLK_UP:
key = TW_KEY_UP;
break;
case SDLK_DOWN:
key = TW_KEY_DOWN;
break;
case SDLK_RIGHT:
key = TW_KEY_RIGHT;
break;
case SDLK_LEFT:
key = TW_KEY_LEFT;
break;
case SDLK_INSERT:
key = TW_KEY_INSERT;
break;
case SDLK_HOME:
key = TW_KEY_HOME;
break;
case SDLK_END:
key = TW_KEY_END;
break;
case SDLK_PAGEUP:
key = TW_KEY_PAGE_UP;
break;
case SDLK_PAGEDOWN:
key = TW_KEY_PAGE_DOWN;
break;
default:
if (event.key.keysym.sym >= SDLK_F1 &&
event.key.keysym.sym <= SDLK_F12) {
key = event.key.keysym.sym + TW_KEY_F1 - SDLK_F1;
}
break;
}
if (key != 0) {
handled = TwKeyPressed(key, event.key.keysym.mod);
}
} else {
handled = TwKeyPressed(event.key.keysym.sym /*& 0xFF*/,
event.key.keysym.mod);
}
break;
case SDL_MOUSEMOTION:
handled = TwMouseMotion(event.motion.x, event.motion.y);
break;
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEBUTTONDOWN:
if (event.type == SDL_MOUSEBUTTONDOWN &&
(event.button.button == 4 || event.button.button == 5)) {
// mouse wheel
static int s_WheelPos = 0;
if (event.button.button == 4)
++s_WheelPos;
else
--s_WheelPos;
handled = TwMouseWheel(s_WheelPos);
} else {
handled = TwMouseButton(
(event.type == SDL_MOUSEBUTTONUP) ?
TW_MOUSE_RELEASED : TW_MOUSE_PRESSED,
(TwMouseButtonID)event.button.button);
}
break;
case SDL_WINDOWEVENT:
if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
// tell the new size to TweakBar
TwWindowSize(event.window.data1, event.window.data2);
// do not set 'handled'
// SDL_VIDEORESIZE may be also processed by the calling application
}
break;
}
return handled != 0? true : false;
}
