void SilverbackInput::pushKeyEvent(int key, int rawchar, bool down) {
gcn::KeyInput i;
//Console_Printf("Got input: %d %d %s\n", key, rawchar, down ? "down" : "up");
if(rawchar || key < 200) {
if(rawchar > 32 && rawchar < 127)
i.setKey(gcn::Key(rawchar));
#ifndef _WIN32
else if(rawchar>=127 || (rawchar == key && key <= 32))
i.setKey(convertKey(key));
else if(key > 32 && key < 127)
i.setKey(gcn::Key(key));
#else
else i.setKey(convertKey(key));
#endif
i.setType(down ? gcn::KeyInput::PRESSED : gcn::KeyInput::RELEASED);
i.setShiftPressed(Input_IsKeyDown(KEY_SHIFT));
i.setControlPressed(Input_IsKeyDown(KEY_CTRL));
i.setAltPressed(Input_IsKeyDown(KEY_ALT));
i.setNumericPad(key >= KEY_KEYPAD_0 && key <= KEY_KEYPAD_ENTER);
mKeyInputQueue.push(i);
} else if ((key >= KEY_MOUSEFIRSTBUTTON && key <= KEY_MOUSELASTBUTTON) || key == KEY_XBUTTON1 || key == KEY_XBUTTON2) {
pushMouseEvent(key, down);
}
}
void RenderWindow::handleEvent(sf::Event& event)
{
actionMap.pushEvent(event);
if(actionMap.isActive("QUIT"))
this->close();
actionMap.invokeCallbacks(callbackSystem, this);
CEGUI::GUIContext& context = CEGUI::System::getSingleton().getDefaultGUIContext();
sf::Vector2i mousep = sf::Mouse::getPosition(*this);
if(event.type == sf::Event::MouseLeft)
context.injectMouseLeaves();
context.injectMousePosition(mousep.x, mousep.y);
if(event.type == sf::Event::MouseButtonPressed)
context.injectMouseButtonDown(CEGUI::MouseButton(event.mouseButton.button));
if(event.type == sf::Event::MouseButtonReleased)
context.injectMouseButtonUp(CEGUI::MouseButton(event.mouseButton.button));
if(event.type == sf::Event::KeyPressed)
context.injectKeyDown(convertKey(event.key.code));
if(event.type == sf::Event::KeyReleased)
context.injectKeyUp(convertKey(event.key.code));
if(event.type == sf::Event::TextEntered)
context.injectChar(event.text.unicode);
if(event.type == sf::Event::MouseWheelMoved)
context.injectMouseWheelChange(event.mouseWheel.delta);
float elapsedTime = elapsedclock->restart().asSeconds();
CEGUI::System::getSingleton().injectTimePulse(elapsedTime);
context.injectTimePulse(elapsedTime);
actionMap.clearEvents();
}
QStringList MDConfAgent::listDirs(const QString &key) const
{
QStringList children;
gint length = 0;
QByteArray k = convertKey(priv->prefix + key);
//qDebug() << "MDConfItem::listDirs" << k;
gchar **dirs = dconf_client_list(priv->client, k.data(), &length);
GError *error = NULL;
for (gint x = 0; x < length; x++) {
const gchar *dir = g_strdup_printf ("%s%s", k.data(), dirs[x]);
if (dconf_is_dir(dir, &error)) {
// We have to mimic how gconf was behaving.
// so we need to chop off trailing slashes.
// dconf will also barf if it gets a "path" with 2 slashes.
QString d = convertKey(dir);
g_free ((gpointer)dir);
//qDebug() << "have dir:" << d;
if (d.endsWith("/")) {
d.chop(1);
}
children.append(d);
}
}
g_strfreev(dirs);
return children;
}
void MDConfAgent::watchKey(const QString &key, const QVariant &def)
{
if (!priv->values.contains(key)) {
if (!key.endsWith("/")) {
priv->values[key] = MDConf::read(priv->client, convertKey(priv->prefix + key));
if (priv->values[key].isNull() && !def.isNull()) {
priv->values[key] = def;
}
Q_EMIT valueChanged(key);
}
MDConf::watch(priv->client, convertKey(priv->prefix + key));
}
}
bool llm::InputListener::keyPressed(const OIS::KeyEvent &e){
std::cout << "keyPressed" << std::endl;
llm::Application* app = llm::Application::getInstance();
if(app->inGame()) {
switch(e.key) {
case OIS::KC_ESCAPE:
llm::Application::getInstance()->pause();
break;
case OIS::KC_R:
llm::Application::getInstance()->game()->activeMagnetism();
break;
case OIS::KC_F:
llm::Application::getInstance()->game()->player()->switchPole();
case OIS::KC_A:
llm::Application::getInstance()->game()->player()->direction(L);
break;
case OIS::KC_D:
llm::Application::getInstance()->game()->player()->direction(R);
break;
case OIS::KC_Q:
if( app->game()->cubeSelected() != -1 )
app->game()->level()->cubes()[app->game()->cubeSelected()]->rotateLeft();
break;
case OIS::KC_E:
if( app->game()->cubeSelected() != -1 )
app->game()->level()->cubes()[app->game()->cubeSelected()]->rotateRight();
break;
}
} else {
CEGUI::System &sys = CEGUI::System::getSingleton();
sys.injectKeyDown(convertKey(e));
}
return m_bContinue;
}
void MDConfAgent::update_value(const QString &key)
{
QString privKey = key;
privKey = privKey.remove(0, priv->prefix.length());
priv->values[privKey] = MDConf::read(priv->client, convertKey(key));
Q_EMIT valueChanged(privKey);
}
void MDConfAgent::setValue(const QString &key, const QVariant &val)
{
if (priv->values.contains(key)) {
priv->values[key] = val;
}
MDConf::write(priv->client, convertKey(priv->prefix + key), val);
}
void MDConfAgent::unsetValue(const QString &key)
{
if (priv->values.contains(key)) {
priv->values[key] = QVariant();
}
MDConf::clear(priv->client, convertKey(priv->prefix + key));
}
void MDConfAgent::unwatchKey(const QString &key)
{
if (priv->values.contains(key)) {
priv->values.remove(key);
MDConf::unwatch(priv->client, convertKey(priv->prefix + key));
}
}
void GAE_InputSystem_getEvent(GAE_Event_t* const event, void* userData) {
GAE_InputSystem_t* system = (GAE_InputSystem_t*)userData;
SDL_Event* sdlEvent = (SDL_Event*)GAE_Map_begin(event->params);
if (GAE_EVENT_KEYBOARD == event->type) {
switch(sdlEvent->type) {
case SDL_KEYUP:
system->keyboard->keys[convertKey(sdlEvent->key.keysym.sym)] = GAE_FALSE;
break;
case SDL_KEYDOWN:
system->keyboard->keys[convertKey(sdlEvent->key.keysym.sym)] = GAE_TRUE;
break;
default:
break;
}
}
}
QVariant MDConfAgent::value(const QString &key) const
{
if (priv->values.contains(key)) {
return priv->values[key];
}
else {
return MDConf::read(priv->client, convertKey(priv->prefix + key));
}
}
MDConfAgent::~MDConfAgent()
{
g_signal_handler_disconnect(priv->client, priv->handler);
foreach (const QString &key, priv->values.keys()) {
QByteArray k = convertKey(priv->prefix + key);
dconf_client_unwatch_fast(priv->client, k.data());
}
g_object_unref(priv->client);
delete priv;
}
static void GLFWCALL keyboardInput(int key, int state)
{
if (key == GLFW_KEY_RCTRL && state == GLFW_PRESS)
{
mouselocked = !mouselocked;
if (mouselocked)
glfwDisable(GLFW_MOUSE_CURSOR);
else
glfwEnable(GLFW_MOUSE_CURSOR);
}
graphics.injectKeyboard(convertKey(key), state);
}
// *Date params will be deleted by this function
closure* telaRelatorio(closure* cl, char* beginDate, char* endDate)
{
relatorio_t* relatorio;
int isFinished = FALSE, refresh = TRUE;
char buf[MAXBUF];
const char* evId = (const char*)cl->param;
point center = getScreenCenter();
memset (buf,'\0',sizeof(buf));
snprintf(buf,MAXBUF,"Gerando relatório...");
WRITE_AT(buf,center.x-10,center.y*2-1);
CHECK(NULL!=evId);
CHECK(SUCCESS==initAmbiente());
CHECK(SUCCESS==get_relatorio(beginDate,endDate,evId,&relatorio));
CHECK(NULL!=relatorio);
while (!isFinished) {
char szKey;
long lOSEvent = wait_event();
if (refresh /*if there's no check it will keep rewriting constantly*/) {
clrscr ();
show_bmp(LOGO_FILENAME);
WRITE_AT_CENTERED("Relatorio",center.x,center.y-3);
snprintf(buf,MAXBUF,"Inicio: %s\0",relatorio->begin_date);
WRITE_AT(buf,center.x-10,center.y);
snprintf(buf,MAXBUF,"Fim: %s\0",relatorio->end_date);
WRITE_AT(buf,center.x-10,center.y+1);
snprintf(buf,MAXBUF,"Valor: %s\0",valor_withCurrency(relatorio->value));
WRITE_AT(buf,center.x-10,center.y+2);
WRITE_AT("1> Imprimir",center.x-10,center.y+4);
WRITE_AT("#> Tela Anterior",center.x-10,center.y+5);
refresh = FALSE;
}
if (lOSEvent & EVT_KBD) {
if (read(g_conHandle, &szKey, 1) > 0) {
szKey = convertKey (szKey);
if (KEY_HASH == szKey || KEY_BACK == szKey || KEY_ESC == szKey) {
isFinished = TRUE;
} else if (szKey == KEY_1) {
char msg[MAX_BUFF_SIZE];
if(relatorio_hasError(relatorio, msg, MAX_BUFF_SIZE)) {
clrscr();
write_multilineCentered(msg);
SVC_WAIT(2000);
refresh = TRUE;
} else {
CHECK(SUCCESS==print_relatorio(relatorio));
}
}
}
}
}
delete_relatorio(relatorio);
return popClosure(cl);
}
QVariantMap MDConfAgent::listItems(const QString &key) const
{
QVariantMap children;
gint length = 0;
QByteArray k = convertKey(priv->prefix + key);
//qDebug() << "MDConfItem::listItems" << k;
gchar **items = dconf_client_list(priv->client, k.data(), &length);
GError *error = NULL;
for (gint x = 0; x < length; x++) {
const gchar *item = g_strdup_printf ("%s%s", k.data(), items[x]);
if (dconf_is_key(item, &error)) {
// We have to mimic how gconf was behaving.
// so we need to chop off trailing slashes.
// dconf will also barf if it gets a "path" with 2 slashes.
QString child = convertKey(item);
QVariant val;
GVariant *v = dconf_client_read(priv->client, item);
if (!v) {
qWarning() << "MGConfItem Failed to read" << child;
}
else {
val = MDConf::convertValue(v);
children[child] = val;
//qDebug() << "have item:" << child;
g_variant_unref(v);
}
g_free ((gpointer)item);
}
}
g_strfreev(items);
return children;
}
/**
** Get the hot key from a string
*/
int GetHotKey(const std::string &text)
{
int hotkey = 0;
size_t pos = 0;
if (text.length() > 1) {
hotkey = convertKey(text.c_str());
} else if (text.length() == 1) {
GetUTF8(text, pos, hotkey);
}
return hotkey;
}
closure* showMenu2(MenuItem_t* items, int numItems, closure* cl)
{
closure* next_cl = NULL;
int isFinished = FALSE;
bool multipage, firstpage, lastpage;
CHECK(NULL!=cl);
firstpage = cl->page==0;
multipage = (numItems > PAGE_ITEMS);
lastpage = (cl->page+1)*PAGE_ITEMS >= numItems;
CHECK(SUCCESS==printMenu2(items,numItems,multipage,lastpage,cl->page));
while (!isFinished) {
char szKey;
long lOSEvent = wait_event();
if (lOSEvent & EVT_KBD) {
if (read(g_conHandle, &szKey, 1) > 0) {
int i;
const MenuItem_t* curr = items;
szKey = convertKey (szKey);
if (KEY_HASH == szKey || KEY_BACK == szKey) {
if (multipage && !firstpage) {
cl->page--;
next_cl = cl;
isFinished = TRUE;
} else {
next_cl = popClosure(cl);
isFinished = TRUE;
}
} else if (szKey == KEY_STAR) {
if (multipage && !lastpage) {
cl->page++;
next_cl = cl;
isFinished = TRUE;
}
} else {
for (i=0; i<numItems; i++) {
if (curr->key == szKey) {
CHECK(NULL!=(curr->func));
next_cl = pushClosure(cl, curr->func, curr->param);
isFinished = TRUE;
break;
}
curr++;
}
}
}
}
}
return next_cl;
}
/**
** Get the hot key from a string
*/
int GetHotKey(const std::string &text)
{
int hotkey = 0;
int utf8;
size_t pos = 0;
while (GetUTF8(text, pos, utf8)) {
if (utf8 == '~') {
if (pos >= text.size()) {
break;
}
if (text[pos] == '<') {
++pos;
size_t endpos = pos;
while (endpos < text.size()) {
if (text[endpos] == '~') {
break;
}
++endpos;
}
std::string key = text.substr(pos, endpos - pos);
hotkey = convertKey(key.c_str());
break;
}
if (text[pos] == '!') {
++pos;
if (pos >= text.size()) {
break;
}
GetUTF8(text, pos, utf8);
hotkey = utf8;
break;
}
}
}
return hotkey;
}
closure* showMenuWithTimeout(const MenuItem_t* items, int numItems, closure* cl, long msecs, char defKey)
{
closure* next_cl = NULL;
int isFinished = FALSE;
CHECK(NULL!=cl);
CHECK(SUCCESS==printMenu(items, numItems));
while (!isFinished) {
char szKey = 0;
long lOSEvent;
if (msecs > 0) {
CHECK(0<=set_timer(msecs, EVT_TIMER));
}
lOSEvent = wait_event();
if (lOSEvent & EVT_KBD || lOSEvent & EVT_TIMER) {
if (lOSEvent & EVT_TIMER) {
szKey = defKey;
}
if (0!=szKey || read(g_conHandle, &szKey, 1) > 0) {
int i;
const MenuItem_t* curr = items;
szKey = convertKey (szKey);
for (i=0; i<numItems; i++) {
if (curr->key == szKey) {
CHECK(NULL!=(curr->func));
next_cl = pushClosure(cl, curr->func, NULL);
isFinished = TRUE;
break;
}
curr++;
}
}
CHECK(SUCCESS==printMenu(items,numItems));
}
}
return next_cl;
}
OSStatus GHOST_SystemCarbon::handleKeyEvent(EventRef event)
{
OSStatus err = eventNotHandledErr;
GHOST_IWindow *window = m_windowManager->getActiveWindow();
UInt32 kind = ::GetEventKind(event);
UInt32 modifiers;
UInt32 rawCode;
GHOST_TKey key;
unsigned char ascii;
/* Can happen, very rarely - seems to only be when command-H makes
* the window go away and we still get an HKey up.
*/
if (!window) {
//::GetEventParameter(event, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &rawCode);
//key = convertKey(rawCode);
return err;
}
err = noErr;
switch (kind) {
case kEventRawKeyDown:
case kEventRawKeyRepeat:
case kEventRawKeyUp:
::GetEventParameter(event, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &rawCode);
::GetEventParameter(event, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &ascii);
key = convertKey(rawCode);
ascii = convertRomanToLatin(ascii);
// if (key!=GHOST_kKeyUnknown) {
GHOST_TEventType type;
if (kind == kEventRawKeyDown) {
type = GHOST_kEventKeyDown;
}
else if (kind == kEventRawKeyRepeat) {
type = GHOST_kEventKeyDown; /* XXX, fixme */
}
else {
type = GHOST_kEventKeyUp;
}
pushEvent(new GHOST_EventKey(getMilliSeconds(), type, window, key, ascii, NULL) );
// }
break;
case kEventRawKeyModifiersChanged:
/* ugh */
::GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
if ((modifiers & shiftKey) != (m_modifierMask & shiftKey)) {
pushEvent(new GHOST_EventKey(getMilliSeconds(), (modifiers & shiftKey) ? GHOST_kEventKeyDown : GHOST_kEventKeyUp, window, GHOST_kKeyLeftShift) );
}
if ((modifiers & controlKey) != (m_modifierMask & controlKey)) {
pushEvent(new GHOST_EventKey(getMilliSeconds(), (modifiers & controlKey) ? GHOST_kEventKeyDown : GHOST_kEventKeyUp, window, GHOST_kKeyLeftControl) );
}
if ((modifiers & optionKey) != (m_modifierMask & optionKey)) {
pushEvent(new GHOST_EventKey(getMilliSeconds(), (modifiers & optionKey) ? GHOST_kEventKeyDown : GHOST_kEventKeyUp, window, GHOST_kKeyLeftAlt) );
}
if ((modifiers & cmdKey) != (m_modifierMask & cmdKey)) {
pushEvent(new GHOST_EventKey(getMilliSeconds(), (modifiers & cmdKey) ? GHOST_kEventKeyDown : GHOST_kEventKeyUp, window, GHOST_kKeyOS) );
}
m_modifierMask = modifiers;
break;
default:
err = eventNotHandledErr;
break;
}
return err;
}
bool KexiCSVExportWizard::readBoolEntry(const char *key, bool defaultValue)
{
return m_importExportGroup.readEntry(convertKey(key, m_options.mode), defaultValue);
}
QString KexiCSVExportWizard::readEntry(const char *key, const QString& defaultValue)
{
return m_importExportGroup.readEntry(convertKey(key, m_options.mode), defaultValue);
}
void KexiCSVExportWizard::writeEntry(const char *key, bool value)
{
m_importExportGroup.writeEntry(convertKey(key, m_options.mode), value);
}
void KexiCSVExportWizard::deleteEntry(const char *key)
{
m_importExportGroup.deleteEntry(convertKey(key, m_options.mode));
}
const std::string& AndroidKeyboard::getAsString(KeyCode kc)
{
char buf[2] = { (char)convertKey(0, kc).key, 0 };
mGetString.assign(&buf[0],2);
return mGetString;
}
void MainWindow::keyPressEvent(QKeyEvent* evt)
{
// qDebug() << "MainWindow::keyPressEvent()";
currentKeyChanged()(convertKey(evt));
}
