/**
* @brief FilterWidget::FilterWidget
* @param parent
*/
FilterWidget::FilterWidget(QWidget *parent) :
QWidget(parent),
ui(new Ui::FilterWidget)
{
ui->setupUi(this);
ui->lineEdit->setShowMagnifier(true);
ui->lineEdit->addAdditionalStyleSheet("QLineEdit { border: 1px solid rgba(0, 0, 0, 100); border-radius: 10px; }");
ui->lineEdit->setType(MyLineEdit::TypeClear);
ui->lineEdit->setAttribute(Qt::WA_MacShowFocusRect, false);
m_list = new QListWidget();
m_list->setWindowFlags(Qt::WindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint));
m_list->setAttribute(Qt::WA_ShowWithoutActivating);
m_activeWidget = WidgetMovies;
QPalette palette = m_list->palette();
palette.setColor(QPalette::Highlight, palette.color(QPalette::Highlight));
palette.setColor(QPalette::HighlightedText, palette.color(QPalette::HighlightedText));
m_list->setPalette(palette);
m_list->setStyleSheet(QString("background-color: transparent; border: 1px solid rgba(255, 255, 255, 200); border-radius: 5px;"));
m_list->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_list->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
connect(ui->lineEdit, SIGNAL(textEdited(QString)), this, SLOT(onFilterTextChanged(QString)));
connect(ui->lineEdit, SIGNAL(keyDown()), this, SLOT(onKeyDown()));
connect(ui->lineEdit, SIGNAL(keyUp()), this, SLOT(onKeyUp()));
connect(ui->lineEdit, SIGNAL(focusOut()), m_list, SLOT(hide()));
connect(ui->lineEdit, SIGNAL(focusIn()), this, SLOT(setupFilters()));
connect(ui->lineEdit, SIGNAL(returnPressed()), this, SLOT(addSelectedFilter()));
connect(ui->lineEdit, SIGNAL(backspaceInFront()), this, SLOT(removeLastFilter()));
connect(m_list, SIGNAL(itemClicked(QListWidgetItem*)), this, SLOT(addFilterFromItem(QListWidgetItem*)));
initFilters();
}
void Tile::keyPressEvent(QKeyEvent *event)
{
if (event->key() == Qt::Key_Escape || event->key() == Qt::Key_Q) {
Quit();
} else if (event->key() == Qt::Key_S) {
Shuffle();
} else if (event->key() == Qt::Key_R) {
Reset();
} else if (event->key() == Qt::Key_H) {
Help();
} else if (event->key() == Qt::Key_O) {
Solve();
} else if (event->key() == Qt::Key_Up) {
//focusNextChild();
//qDebug() << qApp->focusWidget();
QPushButton *button = qobject_cast< QPushButton* >(qApp->focusWidget());
if (button) {
keyUp(button);
}
} else if (event->key() == Qt::Key_Down) {
//focusPreviousChild();
//qDebug() << qApp->focusWidget();
QPushButton *button = qobject_cast< QPushButton* >(qApp->focusWidget());
if (button) {
keyDown(button);
}
} else if( event->key() == Qt::Key_Return ) {
QPushButton *button = qobject_cast< QPushButton* >(qApp->focusWidget());
if (button) {
button->click();
}
} else {
return;
}
}
void CInputEventsTranslator::activateKeyboardTranslation()
{
Messages::MessageType keyDown("KEYBOARD_KEYDOWN");
Messages::MessageType keyUp("KEYBOARD_KEYUP");
Messages::MessageType updateKeyboard("UPDATE_KEYBOARD");
DynamicObjectManager *dom = DynamicObjectManager::getInstancePtr();
shared_ptr< Gnoll::DynamicObject::DynamicObject > keyboardConfig = dom->load("keyboardConfig");
/**
* How often will the keyboard module get updated (millisecond)
*/
unsigned long int period = 300;
shared_ptr< Gnoll::DynamicObject::Integer > periodFromConfig = keyboardConfig->getAttribute< Gnoll::DynamicObject::Integer >("period");
period = *periodFromConfig;
CMessageModule* messageModule = CMessageModule::getInstancePtr();
Messages::Messenger* messageManager = messageModule->getMessageManager();
keyboardEventsTranslator = shared_ptr<Messages::Listener> ( new CKeyboardEventsTranslator() );
keyboardEventsTrigger = shared_ptr<Messages::Listener> ( new CKeyboardEventsTrigger(static_pointer_cast<CKeyboardEventsTranslator>(keyboardEventsTranslator) ));
keyboardStateTranslator = shared_ptr<Messages::Listener> ( new CKeyboardStateTranslator() );
try
{
/**
* Continuous keyboard messages
*/
messageManager->addListener ( keyboardEventsTranslator, keyDown );
Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardEventsTranslator listener installed" );
messageManager->addListener ( keyboardEventsTranslator, keyUp );
Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardEventsTranslator listener installed" );
messageManager->addListener ( keyboardEventsTrigger, updateKeyboard );
Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardEventsTrigger listener installed" );
/**
* State based keyboard messages
*/
messageManager->addListener ( keyboardStateTranslator, keyDown );
Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardStateTranslator listener installed" );
messageManager->addListener ( keyboardStateTranslator, keyUp );
Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardStateTranslator listener installed" );
}
catch(...)
{
throw;
}
CTimeModule* timeModule = CTimeModule::getInstancePtr();
m_periodData = shared_ptr<boost::any> (new boost::any(period)) ;
shared_ptr<CMessage> message (new CMessage(updateKeyboard, m_periodData ));
timeModule->addPeriodicEvent(0, message, period);
}
void PageComponent::base_keyUp( unsigned char inASCII ){
for( int i=0; i<mComponents.size(); i++ ) {
PageComponent *c = *( mComponents.getElement( i ) );
if( c->isVisible() && c->isActive() ) {
c->base_keyUp( inASCII );
}
}
keyUp( inASCII );
}
void Keyboard::update()
{
struct input_event e;
while(read(fd, &e, sizeof(struct input_event)) == sizeof(struct input_event))
{
if(e.type == 1 && e.value == 1) keyDown(e.code);
if(e.type == 1 && e.value == 2) keyDown(e.code); //Key repeated
if(e.type == 1 && e.value == 0) keyUp(e.code);
}
}
void Tile::keyUp(QPushButton *button)
{
int id = button->property("id").toInt();
QPushButton *button_up;
if (id < 5) {
button_up = idtoButton(id+12);
} else {
button_up = idtoButton(id-4);
}
if (button_up->isHidden()) {
keyUp(button_up);
} else {
button_up->setFocus();
}
}
bool Node::treeKeyUp( KeyEvent event )
{
if(!mIsVisible) return false;
// test children first, from top to bottom
NodeList nodes(mChildren);
NodeList::reverse_iterator itr;
bool handled = false;
for(itr=nodes.rbegin(); itr!=nodes.rend()&&!handled; ++itr)
handled = (*itr)->treeKeyUp(event);
// if not handled, test this node
if(!handled) handled = keyUp(event);
return handled;
}
void processEvent(sf::Event& event) {
switch(event.type) {
case sf::Event::Closed: {
window->close();
break;
}
case sf::Event::KeyPressed: {
keyDown(event.key.code);
break;
}
case sf::Event::KeyReleased: {
keyUp(event.key.code);
break;
}
}
}
void processEvents()
{
static int lastMouseX = 0;
static int lastMouseY = 0;
SDL_Event event;
SDL_Surface *screen;
int videoFlags = DEFAULT_FLAGS;
/* route all events to specific event handlers */
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_QUIT:
quit();
break;
case SDL_VIDEORESIZE:
screen = SDL_SetVideoMode(
event.resize.w,
event.resize.h,
DEFAULT_DEPTH,
videoFlags
);
eventReshape(screen->w, screen->h);
break;
case SDL_KEYDOWN:
keyDown(event.key.keysym.sym);
break;
case SDL_KEYUP:
keyUp(event.key.keysym.sym);
break;
case SDL_MOUSEBUTTONDOWN:
mouseDown(event.button.button, 1, lastMouseX, lastMouseY);
break;
case SDL_MOUSEBUTTONUP:
mouseDown(event.button.button, 0, lastMouseX, lastMouseY);
break;
case SDL_MOUSEMOTION:
lastMouseX = event.motion.x;
lastMouseY = event.motion.y;
mouseMove(lastMouseX, lastMouseY);
break;
default:
break;
}
}
}
void event_sdl_keyup(int keysym, int keymod)
{
if (keysym == ConfigGetParamInt(g_CoreConfig, kbdStop))
{
return;
}
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdForward))
{
main_set_fastforward(0);
}
else if (keysym == ConfigGetParamInt(g_CoreConfig, kbdGameshark))
{
KbdGamesharkPressed = 0;
}
else keyUp(keymod, keysym);
}
void ArrowLineEdit::keyPressEvent( QKeyEvent * e )
{
switch(e->key()){
case Key_Up:
keyUp(e);
return;
case Key_Down:
keyDown(e);
return;
case Key_Enter:
case Key_Return:
keyEnter(e);
return;
default:
QLineEdit::keyPressEvent(e);
}
}
void Tile::keyPressEvent(QKeyEvent *event)
{
if (event->key() == Qt::Key_Escape || event->key() == Qt::Key_Q) {
Quit();
} else if (event->key() == Qt::Key_Up) {
//focusNextChild();
//qDebug() << qApp->focusWidget();
QPushButton *button = qobject_cast< QPushButton* >(qApp->focusWidget());
keyUp(button);
} else if (event->key() == Qt::Key_Down) {
//focusPreviousChild();
//qDebug() << qApp->focusWidget();
QPushButton *button = qobject_cast< QPushButton* >(qApp->focusWidget());
keyDown(button);
} else {
return;
}
}
void RawInputSystem::update(float delta)
{
PROFILE;
MSG msg;
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
switch (msg.message) // RAW INPUT
{
case WM_INPUT:
handleRawInput(msg);
break;
case WM_KEYDOWN:
if (!(msg.lParam & 0x40000000)) // check the repeat count bit.
keyDown(msg);
break;
case WM_KEYUP:
keyUp(msg);
break;
}
}
POINT cursorPos;
RECT windowRect;
GetCursorPos(&cursorPos);
GetWindowRect(windowHandle, &windowRect);
int x = (int)cursorPos.x - windowRect.left;
int y = (int)cursorPos.y - windowRect.top;
if (lastX != x || lastY != y)
{
inputSystem->axisMove(MOUSE, float(x), float(y));
inputSystem->setCursorPositon(math::Vec2(float(x), float(y)));
lastX = x;
lastY = y;
}
}
/**
* Handles application input.
*/
void BaseGame::pEvents()
{
SDL_Event event;
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_KEYDOWN:
if (event.key.keysym.sym == SDLK_ESCAPE)
{
running = false;
break;
}
keyDown(event.key.keysym.sym);
break;
case SDL_KEYUP:
keyUp(event.key.keysym.sym);
break;
case SDL_QUIT:
running = false;
break;
case SDL_VIDEORESIZE:
screen = SDL_SetVideoMode(event.resize.w, event.resize.h, 32, flags);
resize(event.resize.w, event.resize.h);
break;
case SDL_MOUSEMOTION:
mouseMotion(event.button.button, event.motion.x, event.motion.y);
break;
case SDL_MOUSEBUTTONUP:
mouseBtnUp(event.button.button, event.motion.x, event.motion.y);
break;
case SDL_MOUSEBUTTONDOWN:
mouseBtnDown(event.button.button, event.motion.x, event.motion.y);
break;
}
}
}
void CInputEventsTranslator::deactivateKeyboardTranslation()
{
Messages::MessageType keyDown("KEYBOARD_KEYDOWN");
Messages::MessageType keyUp("KEYBOARD_KEYUP");
Messages::MessageType updateKeyboard("UPDATE_KEYBOARD");
CMessageModule* messageModule = CMessageModule::getInstancePtr();
Messages::Messenger* messageManager = messageModule->getMessageManager();
try
{
/**
* Continuous keybord messages
*/
messageManager->delListener ( keyboardEventsTranslator, keyDown );
Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardEventsTranslator listener removed" );
messageManager->delListener ( keyboardEventsTranslator, keyUp );
Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardEventsTranslator listener removed" );
messageManager->delListener ( keyboardEventsTrigger, updateKeyboard );
Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardEventsTrigger listener removed" );
/**
* State based keyboard messages
*/
messageManager->delListener ( keyboardStateTranslator, keyDown );
Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardStateTranslator listener removed" );
messageManager->delListener ( keyboardStateTranslator, keyUp );
Gnoll::Log::CLogModule::getInstancePtr()->logMessage( "KeyboardStateTranslator listener removed" );
}
catch(...)
{
throw;
}
CTimeModule* timeModule = CTimeModule::getInstancePtr();
shared_ptr<CMessage> message (new CMessage(updateKeyboard, m_periodData ));
timeModule->delPeriodicEvent(0, message, boost::any_cast<unsigned long int> (*m_periodData) );
}
bool SliderKeyBind::saveXML(QDomDocument* doc, QDomElement* vc_root)
{
QDomElement root;
QDomElement tag;
QDomText text;
QString str;
Q_ASSERT(doc != NULL);
Q_ASSERT(vc_root != NULL);
/* SliderKeyBind entry */
root = doc->createElement(KXMLQLCSliderKeyBind);
vc_root->appendChild(root);
/* Up */
tag = doc->createElement(KXMLQLCSliderKeyBindKey);
tag.setAttribute(KXMLQLCSliderKeyBindAction, KXMLQLCSliderKeyBindUp);
root.appendChild(tag);
/* Mod */
str.setNum(modUp());
tag.setAttribute(KXMLQLCSliderKeyBindModifier, str);
/* Key */
str.setNum(keyUp());
text = doc->createTextNode(str);
tag.appendChild(text);
/* Down */
tag = doc->createElement(KXMLQLCSliderKeyBindKey);
tag.setAttribute(KXMLQLCSliderKeyBindAction, KXMLQLCSliderKeyBindDown);
/* Mod */
str.setNum(modDown());
tag.setAttribute(KXMLQLCSliderKeyBindModifier, str);
/* Key */
str.setNum(keyDown());
text = doc->createTextNode(str);
tag.appendChild(text);
return true;
}
void Display::receiveEvents()
{
SDL_Event event;
while(SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_KEYDOWN:
keyDown(event.key.keysym.sym);
break;
case SDL_KEYUP:
keyUp(event.key.keysym.sym);
break;
case SDL_QUIT:
quit = true;
break;
}
}
}
void GameEngine::run(){
const int tickInterval = 1000/FPS;
Uint32 nextTick;
int delay;
bool quit = false;
while (!quit) {
SDL_Event event;
nextTick = SDL_GetTicks() + tickInterval;
while( SDL_PollEvent( &event ) ){
switch( event.type ){
case SDL_QUIT:
quit = true; break;
case SDL_KEYDOWN:
keyDown(event);break;
case SDL_KEYUP:
keyUp(event);
break;
}
}
SDL_FillRect(GE.screen,NULL,0X000000);
for( unsigned int i=0; i<comps.size(); i++ ){
Komponent* other = comps[i];
for( unsigned int x=0; x<comps.size(); x++ ){
if(comps[x] != other){
if( comps[x]->getRect().overlaps(other->getRect() ) )
comps[x]->handleCollision(other);
}
}
comps[i]->draw();
comps[i]->move();
//out of bounds grej
//if(comps[i]->getRect().x<0-comps[i]->getRect().w || comps[i]->getRect().x>GE.screen->w+comps[i]->getRect().w ||comps[i]->getRect().y<0-comps[i]->getRect().h || comps[i]->getRect().y>GE.screen->h+comps[i]->getRect().h){
// comps.erase(comps.begin() + i);
//}
}
delay = nextTick - SDL_GetTicks();
if( delay > 0 )
SDL_Delay( delay );
SDL_Flip(GE.screen);
}
}
LRESULT CALLBACK InputClass::MessageHandler(HWND hwnd, UINT umsg, WPARAM wparam, LPARAM lparam)
{
switch (umsg)
{
case WM_KEYDOWN:
keyDown(wparam);
if (wparam == VK_ESCAPE)
PostQuitMessage(0);
break;
case WM_KEYUP:
keyUp(wparam);
if (wparam == VK_ESCAPE)
PostQuitMessage(0);
default:
{
return DefWindowProc(hwnd, umsg, wparam, lparam);
}
}
}
void processEvent(sf::Event& event) {
switch(event.type) {
case sf::Event::Closed: {
window->close();
break;
}
case sf::Event::KeyPressed: {
keyDown(event.key.code);
break;
}
case sf::Event::KeyReleased: {
keyUp(event.key.code);
break;
}
case sf::Event::MouseButtonPressed: {
mousePress(event.mouseButton.button, event.mouseButton.x, event.mouseButton.y);
break;
}
}
}
static int filter(const SDL_Event *event)
{
switch (event->type)
{
case SDL_KEYDOWN:
switch (event->key.keysym.sym)
{
case SDLK_F5:
savestates_job |= SAVESTATE;
break;
case SDLK_F7:
savestates_job |= LOADSTATE;
break;
case SDLK_ESCAPE:
stop_it();
break;
case SDLK_F1:
changeWindow();
break;
default:
keyDown(0, event->key.keysym.sym);
}
return 0;
break;
case SDL_KEYUP:
switch (event->key.keysym.sym)
{
case SDLK_ESCAPE:
break;
case SDLK_F1:
break;
default:
keyUp(0, event->key.keysym.sym);
}
return 0;
break;
default:
return 1;
}
}
bool Input::keyPress(DWORD key)
{
//check for keydown
if (keyDown(key)) {
m_keyPressState[key] = 1;
}
//check for key reaching the keydown state
if (m_keyPressState[key] == 1) {
//check for key release
if (keyUp(key))
m_keyPressState[key] = 2;
}
//check if key has been pressed and released
if (m_keyPressState[key] == 2) {
//reset the key status
m_keyPressState[key] = 0;
return true;
}
return false;
}
LRESULT CALLBACK WndProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam) {
switch(msg) {
case WM_SIZE:
swidth=LOWORD(lParam); sheight=HIWORD(lParam);
resize(LOWORD(lParam),HIWORD(lParam));
releaseDIB(dibDC);
initDIB(dibDC,LOWORD(lParam),HIWORD(lParam));
InvalidateRect(hWnd,NULL,FALSE);
break;
case WM_KEYDOWN:
keyDown(wParam);
break;
case WM_KEYUP:
keyUp(wParam);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
case WM_QUERYNEWPALETTE:
if(!hPalette)
break;
SelectPalette(hdc,hPalette,FALSE);
RealizePalette(hdc);
InvalidateRect(hWnd,NULL,FALSE);
break;
case WM_PALETTECHANGED:
if(!hPalette||(HWND)wParam==hWnd)
break;
SelectPalette(hdc,hPalette,FALSE);
RealizePalette(hdc);
UpdateColors(hdc);
break;
default:
return DefWindowProc(hWnd,msg,wParam,lParam);
}
return 0;
}
int SDLApplication::run()
{
bool quit = false;
SDL_Event event;
m_totalTime = SDL_GetTicks();
while (!quit)
{
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_KEYDOWN:
if (event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q)
quit = true;
else if (event.key.keysym.sym == SDLK_UP || event.key.keysym.sym == SDLK_w)
keyDown(KEY_MOVE_FORWARD);
else if (event.key.keysym.sym == SDLK_DOWN || event.key.keysym.sym == SDLK_s)
keyDown(KEY_MOVE_BACKWARD);
else if (event.key.keysym.sym == SDLK_LEFT || event.key.keysym.sym == SDLK_a)
keyDown(KEY_MOVE_LEFT);
else if (event.key.keysym.sym == SDLK_RIGHT || event.key.keysym.sym == SDLK_d)
keyDown(KEY_MOVE_RIGHT);
else if (event.key.keysym.sym == SDLK_SPACE)
keyDown(KEY_CONTINUE);
break;
case SDL_KEYUP:
if (event.key.keysym.sym == SDLK_ESCAPE || event.key.keysym.sym == SDLK_q)
quit = true;
else if (event.key.keysym.sym == SDLK_UP || event.key.keysym.sym == SDLK_w)
keyUp(KEY_MOVE_FORWARD);
else if (event.key.keysym.sym == SDLK_DOWN || event.key.keysym.sym == SDLK_s)
keyUp(KEY_MOVE_BACKWARD);
else if (event.key.keysym.sym == SDLK_LEFT || event.key.keysym.sym == SDLK_a)
keyUp(KEY_MOVE_LEFT);
else if (event.key.keysym.sym == SDLK_RIGHT || event.key.keysym.sym == SDLK_d)
keyUp(KEY_MOVE_RIGHT);
else if (event.key.keysym.sym == SDLK_RETURN)
keyUp(KEY_RESET_1);
else if (event.key.keysym.sym == SDLK_c)
keyUp(KEY_RESET_2);
else if (event.key.keysym.sym == SDLK_h)
keyUp(KEY_HELP);
else if (event.key.keysym.sym == SDLK_SPACE)
keyUp(KEY_CONTINUE);
break;
case SDL_MOUSEBUTTONDOWN:
// this is to avoid a "jump" of the mouse delta after the first movement after a mouse click
SDL_WarpMouse(m_width/2, m_height/2);
break;
case SDL_MOUSEMOTION:
if (event.button.button == SDL_BUTTON_LEFT) {
int middleX = int(m_width/2);
int middleY = int(m_height/2);
if (middleX != event.motion.x || middleY != event.motion.y)
{
mouse(KEY_MOUSE_LEFT, middleX - event.motion.x, middleY - event.motion.y);
SDL_WarpMouse(middleX, middleY);
}
}
break;
case SDL_VIDEORESIZE:
{
Uint8 bpp = m_surface->format->BitsPerPixel;
Uint32 flags = m_surface->flags;
SDL_FreeSurface(m_surface);
m_surface = SDL_SetVideoMode(event.resize.w, event.resize.h, bpp, flags);
window_resized(event.resize.w, event.resize.h);
}
break;
case SDL_QUIT:
quit = true;
break;
}
}
int currentTime = SDL_GetTicks();
float dt = float(currentTime - m_totalTime);
if (!m_fixedTimeStep || dt >= m_targetElapsedTime * 1000) {
m_totalTime = currentTime;
if (dt > 0)
update(dt);
}
draw();
SDL_GL_SwapBuffers();
}
SDL_Quit();
return 0;
}
ServerProxy::EResult
ServerProxy::parseMessage(const UInt8* code)
{
if (memcmp(code, kMsgDMouseMove, 4) == 0) {
mouseMove();
}
else if (memcmp(code, kMsgDMouseRelMove, 4) == 0) {
mouseRelativeMove();
}
else if (memcmp(code, kMsgDMouseWheel, 4) == 0) {
mouseWheel();
}
else if (memcmp(code, kMsgDKeyDown, 4) == 0) {
keyDown();
}
else if (memcmp(code, kMsgDKeyUp, 4) == 0) {
keyUp();
}
else if (memcmp(code, kMsgDMouseDown, 4) == 0) {
mouseDown();
}
else if (memcmp(code, kMsgDMouseUp, 4) == 0) {
mouseUp();
}
else if (memcmp(code, kMsgDKeyRepeat, 4) == 0) {
keyRepeat();
}
else if (memcmp(code, kMsgCKeepAlive, 4) == 0) {
// echo keep alives and reset alarm
ProtocolUtil::writef(m_stream, kMsgCKeepAlive);
resetKeepAliveAlarm();
}
else if (memcmp(code, kMsgCNoop, 4) == 0) {
// accept and discard no-op
}
else if (memcmp(code, kMsgCEnter, 4) == 0) {
enter();
}
else if (memcmp(code, kMsgCLeave, 4) == 0) {
leave();
}
else if (memcmp(code, kMsgCClipboard, 4) == 0) {
grabClipboard();
}
else if (memcmp(code, kMsgCScreenSaver, 4) == 0) {
screensaver();
}
else if (memcmp(code, kMsgQInfo, 4) == 0) {
queryInfo();
}
else if (memcmp(code, kMsgCInfoAck, 4) == 0) {
infoAcknowledgment();
}
else if (memcmp(code, kMsgDClipboard, 4) == 0) {
setClipboard();
}
else if (memcmp(code, kMsgCResetOptions, 4) == 0) {
resetOptions();
}
else if (memcmp(code, kMsgDSetOptions, 4) == 0) {
setOptions();
}
else if (memcmp(code, kMsgDFileTransfer, 4) == 0) {
fileChunkReceived();
}
else if (memcmp(code, kMsgDDragInfo, 4) == 0) {
dragInfoReceived();
}
else if (memcmp(code, kMsgCClose, 4) == 0) {
// server wants us to hangup
LOG((CLOG_DEBUG1 "recv close"));
m_client->disconnect(NULL);
return kDisconnect;
}
else if (memcmp(code, kMsgEBad, 4) == 0) {
LOG((CLOG_ERR "server disconnected due to a protocol error"));
m_client->disconnect("server reported a protocol error");
return kDisconnect;
}
else {
return kUnknown;
}
// send a reply. this is intended to work around a delay when
// running a linux server and an OS X (any BSD?) client. the
// client waits to send an ACK (if the system control flag
// net.inet.tcp.delayed_ack is 1) in hopes of piggybacking it
// on a data packet. we provide that packet here. i don't
// know why a delayed ACK should cause the server to wait since
// TCP_NODELAY is enabled.
ProtocolUtil::writef(m_stream, kMsgCNoop);
return kOkay;
}
//
// FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// PURPOSE: Processes messages for the main window.
//
// WM_COMMAND - process the application menu
// WM_PAINT - Paint the main window
// WM_DESTROY - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDM_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_CREATE:
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
{
RECT cr;
GetClientRect(hWnd, &cr);
int width = cr.right - cr.left;
int height = cr.bottom - cr.top;
HDC bufDC;
HBITMAP bufBMP;
bufDC = CreateCompatibleDC(hdc);
bufBMP = CreateCompatibleBitmap(hdc, width, height);
SelectObject(bufDC, bufBMP);
setPaintDC(bufDC);
RECT r = {0};
r.right = width;
r.bottom = height;
FillRect(bufDC, &r, GetStockBrush(WHITE_BRUSH));
paint();
setPaintDC(NULL);
BitBlt(hdc, 0, 0, width, height, bufDC, 0, 0, SRCCOPY);
DeleteObject(bufBMP);
DeleteDC(bufDC);
}
EndPaint(hWnd, &ps);
break;
case WM_MOUSEMOVE:
{
int x = GET_X_LPARAM(lParam);
int y = GET_Y_LPARAM(lParam);
mouseMove(x, y);
}
break;
case WM_LBUTTONDOWN:
SetCapture(hWnd);
mouseDown();
break;
case WM_LBUTTONUP:
ReleaseCapture();
mouseUp();
break;
case WM_KEYDOWN:
{
int vk = wParam;
char ch = MapVirtualKey(vk, MAPVK_VK_TO_CHAR);
keyDown(ch, vk);
}
break;
case WM_KEYUP:
{
int vk = wParam;
char ch = MapVirtualKey(vk, MAPVK_VK_TO_CHAR);
keyUp(ch, vk);
}
break;
case WM_TIMER:
switch(wParam)
{
case IDT_TIMER0:
timerTick();
break;
}
break;
case WM_DESTROY:
finalize();
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
key AnalogKeypad::checkKeys() //returns the pressed key.
{
int keyValue = analogRead(KeyPin);
if(keyValue > minDimUp && keyValue < maxDimUp)
{
bDimUp = true;
keyDown();
}
else
{
if(bDimUp)
{
bDimUp = false;
if(iLongPress > 50)
{
returnValue = DimMax;
}
else
{
returnValue = DimUp;
}
keyUp();
return returnValue;
}
}
if(keyValue > minDimDown && keyValue < maxDimDown)
{
bDimDown = true;
keyDown();
}
else
{
if(bDimDown)
{
bDimDown = false;
if(iLongPress > 50)
{
returnValue = DimMin;
}
else
{
returnValue = DimDown;
}
keyUp();
return returnValue;
}
}
if(keyValue > minOnOff && keyValue < maxOnOff)
{
bOnOff = true;
keyDown();
}
else
{
if(bOnOff)
{
bOnOff = false;
if(iLongPress > 50)
{
returnValue = Debug;
}
else
{
returnValue = OnOff;
}
keyUp();
return returnValue;
}
}
if(keyValue > minNext && keyValue < maxNext)
{
bNext = true;
keyDown();
}
else
{
if(bNext)
{
bNext = false;
keyUp();
return Next;
}
}
if(keyValue > minFaster && keyValue < maxFaster)
{
bFaster = true;
keyDown();
}
else
{
if(bFaster)
{
bFaster = false;
if(iLongPress > 50)
{
returnValue = Fastest;
}
else
{
returnValue = Faster;
}
keyUp();
return returnValue;
}
}
if(keyValue > minSlower && keyValue < maxSlower)
{
bSlower = true;
keyDown();
}
else
{
if(bSlower)
{
bSlower = false;
if(iLongPress > 50)
{
returnValue = Slowest;
}
else
returnValue = Slower;
keyUp();
return returnValue;
}
}
return None;
}
void InputHandler::mouseUp(Uint8 btn, Uint16 /*x*/, Uint16 /*y*/) {
keyUp(SDLKey(SDLK_LAST + btn));
}
void Util::processInput(bool scroll) {
Common::Event event;
Common::EventManager *eventMan = g_system->getEventManager();
int16 x = 0, y = 0;
bool hasMove = false;
_vm->_vidPlayer->updateLive();
while (eventMan->pollEvent(event)) {
switch (event.type) {
case Common::EVENT_MOUSEMOVE:
hasMove = true;
x = event.mouse.x;
y = event.mouse.y;
break;
case Common::EVENT_LBUTTONDOWN:
_mouseButtons = (MouseButtons) (((uint32) _mouseButtons) | ((uint32) kMouseButtonsLeft));
break;
case Common::EVENT_RBUTTONDOWN:
_mouseButtons = (MouseButtons) (((uint32) _mouseButtons) | ((uint32) kMouseButtonsRight));
break;
case Common::EVENT_LBUTTONUP:
_mouseButtons = (MouseButtons) (((uint32) _mouseButtons) & ~((uint32) kMouseButtonsLeft));
break;
case Common::EVENT_RBUTTONUP:
_mouseButtons = (MouseButtons) (((uint32) _mouseButtons) & ~((uint32) kMouseButtonsRight));
break;
case Common::EVENT_KEYDOWN:
keyDown(event);
if (event.kbd.hasFlags(Common::KBD_CTRL)) {
if (event.kbd.keycode == Common::KEYCODE_f)
_fastMode ^= 1;
else if (event.kbd.keycode == Common::KEYCODE_g)
_fastMode ^= 2;
else if (event.kbd.keycode == Common::KEYCODE_p)
_vm->pauseGame();
else if (event.kbd.keycode == Common::KEYCODE_d) {
_vm->getDebugger()->attach();
_vm->getDebugger()->onFrame();
}
break;
}
addKeyToBuffer(event.kbd);
break;
case Common::EVENT_KEYUP:
keyUp(event);
break;
default:
break;
}
}
_vm->_global->_speedFactor = MIN(_fastMode + 1, 3);
if (hasMove && scroll) {
x = CLIP(x, _vm->_global->_mouseMinX, _vm->_global->_mouseMaxX);
y = CLIP(y, _vm->_global->_mouseMinY, _vm->_global->_mouseMaxY);
x -= _vm->_video->_screenDeltaX;
y -= _vm->_video->_screenDeltaY;
_vm->_util->setMousePos(x, y);
_vm->_game->wantScroll(x, y);
// WORKAROUND:
// Force a check of the mouse in order to fix the sofa bug. This apply only for Gob3, and only
// in the impacted TOT file so that the second screen animation is not broken.
if ((_vm->getGameType() == kGameTypeGob3) && _vm->isCurrentTot("EMAP1008.TOT"))
_vm->_game->evaluateScroll();
}
}
int main(int argc, char **argv) {
//////////////////////////////////////////////////////////////////////
// check joystick
//////////////////////////////////////////////////////////////////////
std::string commandNoJoystick = std::string(argv[0]) + " --no-joystick ";
Herve::utilInfo("to disable joystick, use : ", commandNoJoystick.c_str() , __FILE__, __LINE__);
if (argc == 2 and std::string(argv[1]) == "--no-joystick")
gEnableJoystick = false;
//////////////////////////////////////////////////////////////////////
// init
//////////////////////////////////////////////////////////////////////
// display device
gUptrDisplayDevice.reset(new HerveOvr::DisplayDeviceStereoOvr(1024, 1024));
if (not gUptrDisplayDevice->initDevice()) {
gUptrDisplayDevice.reset(new Herve::DisplayDeviceMono());
//gUptrDisplayDevice.reset(new Herve::DisplayDeviceStereoFake(1024, 1024));
gUptrDisplayDevice->initDevice();
}
// SDL
if( SDL_Init( SDL_INIT_EVERYTHING ) < 0 )
Herve::utilError("SDL_Init", "", __FILE__, __LINE__);
const SDL_VideoInfo* info = SDL_GetVideoInfo();
int maxWidth = info->current_w;
int maxHeight = info->current_h;
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
gPtrSurface = SDL_SetVideoMode( gUptrDisplayDevice->getWidth(), gUptrDisplayDevice->getHeight(), 24, SDL_OPENGL|SDL_RESIZABLE );
if( gPtrSurface == NULL )
Herve::utilError("SDL_SetVideoMode", "", __FILE__, __LINE__);
atexit(SDL_Quit);
SDL_EnableUNICODE( SDL_TRUE );
SDL_WM_SetCaption( "DemoSdl1", NULL );
// joysticks
int nbJoysticks = SDL_NumJoysticks();
for(int i=0; i<nbJoysticks; i++) {
SDL_Joystick * stick = SDL_JoystickOpen( i );
if( stick ) {
Herve::utilInfo("joystick = ", SDL_JoystickName(i), __FILE__, __LINE__);
}
}
// scene data
gUptrDisplayDevice->initDisplay(maxWidth, maxHeight);
gScene.init(gUptrDisplayDevice.get());
gFpsCounter.start();
Herve::utilInfo("width = ", std::to_string(gUptrDisplayDevice->getWidth()).c_str(), __FILE__, __LINE__);
Herve::utilInfo("height = ", std::to_string(gUptrDisplayDevice->getHeight()).c_str(), __FILE__, __LINE__);
Herve::utilInfo("maxWidth = ", std::to_string(gUptrDisplayDevice->getMaxWidth()).c_str(), __FILE__, __LINE__);
Herve::utilInfo("maxHeight = ", std::to_string(gUptrDisplayDevice->getMaxHeight()).c_str(), __FILE__, __LINE__);
//////////////////////////////////////////////////////////////////////
// main loop
//////////////////////////////////////////////////////////////////////
SDL_Event event;
while (true) {
// handle events
while( SDL_PollEvent( &event ) ) {
switch(event.type) {
case SDL_QUIT:
exit(0);
break;
case SDL_KEYDOWN:
keyDown(event.key);
break;
case SDL_KEYUP:
keyUp(event.key);
break;
case SDL_MOUSEBUTTONUP :
mouseUp(event.button);
break;
case SDL_MOUSEBUTTONDOWN :
mouseDown(event.button);
break;
case SDL_MOUSEMOTION :
mouseMotion(event.motion);
break;
case SDL_VIDEORESIZE :
resize(event.resize);
break;
case SDL_JOYAXISMOTION :
joyMotion(event.jaxis);
break;
}
}
updateCamera();
render();
}
return 0;
}
