void OpenGLSdlGraphicsManager::warpMouse(int x, int y) {
int scaledX = x;
int scaledY = y;
if (_videoMode.mode == OpenGL::GFX_NORMAL) {
if (_videoMode.hardwareWidth != _videoMode.overlayWidth)
scaledX = scaledX * _videoMode.hardwareWidth / _videoMode.overlayWidth;
if (_videoMode.hardwareHeight != _videoMode.overlayHeight)
scaledY = scaledY * _videoMode.hardwareHeight / _videoMode.overlayHeight;
if (!_overlayVisible) {
scaledX *= _videoMode.scaleFactor;
scaledY *= _videoMode.scaleFactor;
}
} else {
if (_overlayVisible) {
if (_displayWidth != _videoMode.overlayWidth)
scaledX = scaledX * _displayWidth / _videoMode.overlayWidth;
if (_displayHeight != _videoMode.overlayHeight)
scaledY = scaledY * _displayHeight / _videoMode.overlayHeight;
} else {
if (_displayWidth != _videoMode.screenWidth)
scaledX = scaledX * _displayWidth / _videoMode.screenWidth;
if (_displayHeight != _videoMode.screenHeight)
scaledY = scaledY * _displayHeight / _videoMode.screenHeight;
}
scaledX += _displayX;
scaledY += _displayY;
}
SDL_WarpMouse(scaledX, scaledY);
setMousePos(scaledX, scaledY);
}
void initializeMove(CITWINDOW *wnd, Bool show)
{
if (wnd->flags.moveable)
{
CITWINDOW *mover;
SRECT rect;
WINDOWFLAGS flags;
int len;
len = strlen(getcwmsg(1)) + 2;
memset(&flags, 0, sizeof(flags));
flags.visible = show;
flags.showTitle = show;
rect.top = (scrollpos - 3) / 2;
rect.left = (conCols - len) / 2;
rect.bottom = rect.top + 2;
rect.right = rect.left + len;
mover = makeCitWindow(moverHandler, wnd, getcwmsg(3), flags, rect,
NULL, FALSE);
if (mover)
{
(mover->func)(EVT_DRAWALL, 0, 0, mover);
setFocus(mover);
setMousePos(wnd->extents.left * 8, wnd->extents.top * 8);
}
}
}
void Input::addMouseEvent(int button, int state, int x, int y) {
setMousePos(x, y);
if(vMouseBtns.size() < button+1) vMouseBtns.resize(button+1);
vMouseBtns[button].state = state; // If So, Mark It As FALSE
vMouseBtns[button].x = x;
vMouseBtns[button].y = y;
}
void EasySelectorWidget::mouseMoveEvent(QMouseEvent *e)
{
Q_D(EasySelectorWidget);
if (d->buttonDown) {
setMousePos(e->pos());
if (d->length != d->oldLength || d->complexity != d->oldComplexity) {
emit valuesChanged(d->length, d->complexity);
d->oldLength = d->length;
d->oldComplexity = d->complexity;
}
}
}
void WINCESdlGraphicsManager::warpMouse(int x, int y) {
if (_mouseCurState.x != x || _mouseCurState.y != y) {
SDL_WarpMouse(x * _scaleFactorXm / _scaleFactorXd, y * _scaleFactorYm / _scaleFactorYd);
// SDL_WarpMouse() generates a mouse movement event, so
// set_mouse_pos() would be called eventually. However, the
// cannon script in CoMI calls this function twice each time
// the cannon is reloaded. Unless we update the mouse position
// immediately the second call is ignored, causing the cannon
// to change its aim.
setMousePos(x, y);
}
}
void JAbout::startup() {
int w, dx;
int h = theRootWindow->height/4;
int dy = (theRootWindow->height-h)/2;
char *name = "NeatTools V1.2";
JFont font("courier", JFont::BOLD_ITALIC, h*2/3);
setJFont(font);
setText(name);
JFontMetrics fm(getJGraphics());
w = fm.stringWidth(name)+80;
dx = (theRootWindow->width-w)/2;
setBackground(JColor::green.darker());
reshape(dx, dy, w, h);
setResizable(false);
setMousePos(dx+w/2, dy+h/2);
show();
}
void CMouse::update(float eTime){
ISceneNode::update(eTime);
mousePos = setMousePos();
pos = D3DXVECTOR2(mousePos.x, mousePos.y);
if(mouseFlag == false)
{
pushSceneNode(0,mouse);
rect = Rect(-mouse->width/2.f, -mouse->height/2.f, mouse->width/2.f, mouse->height/2.f);
}
else{
pushSceneNode(0,mouse2);
pos = D3DXVECTOR2(mousePos.x, mousePos.y);
rect = Rect(-mouse2->width/2.f, -mouse2->height/2.f, mouse2->width/2.f, mouse2->height/2.f);
range->visible = false;
}
}
void OSystem_SDL::warpMouse(int x, int y) {
int y1 = y;
if (_adjustAspectRatio && !_overlayVisible)
y1 = real2Aspect(y);
if (_mouseCurState.x != x || _mouseCurState.y != y) {
if (!_overlayVisible)
SDL_WarpMouse(x * _scaleFactor, y1 * _scaleFactor);
else
SDL_WarpMouse(x, y1);
// SDL_WarpMouse() generates a mouse movement event, so
// setMousePos() would be called eventually. However, the
// cannon script in CoMI calls this function twice each time
// the cannon is reloaded. Unless we update the mouse position
// immediately the second call is ignored, causing the cannon
// to change its aim.
setMousePos(x, y);
}
}
HI_VOID *SAMPLE_HIFB_PANDISPLAY(void *pData)
{
HI_S32 i,x,y,s32Ret;
TDE_HANDLE s32Handle;
struct fb_fix_screeninfo fix;
struct fb_var_screeninfo var;
HI_U32 u32FixScreenStride = 0;
unsigned char *pShowScreen;
unsigned char *pHideScreen;
HI_U32 u32HideScreenPhy = 0;
HI_U16 *pShowLine;
HIFB_ALPHA_S stAlpha;
HIFB_POINT_S stPoint = {40, 112};
char file[12] = "/dev/fb0";
HI_BOOL g_bCompress = HI_FALSE;
char image_name[128];
HI_U8 *pDst = NULL;
HI_BOOL bShow;
PTHREAD_HIFB_sw_INFO *pstInfo;
HIFB_COLORKEY_S stColorKey;
TDE2_RECT_S stSrcRect,stDstRect;
TDE2_SURFACE_S stSrc,stDst;
HI_U32 Phyaddr;
HI_VOID *Viraddr;
U8 cPollData[4];
struct pollfd stPoll[1];
if (HI_NULL == pData)
{
return HI_NULL;
}
pstInfo = (PTHREAD_HIFB_sw_INFO *)pData;
switch (pstInfo->layer)
{
case 0 :
strcpy(file, "/dev/fb0");
break;
case 1 :
strcpy(file, "/dev/fb1");
break;
case 2 :
strcpy(file, "/dev/fb2");
break;
case 3 :
strcpy(file, "/dev/fb3");
break;
default:
strcpy(file, "/dev/fb0");
break;
}
pstInfo->fd = open(file, O_RDWR, 0);
if (pstInfo->fd < 0)
{
printf("open %s failed!\n",file);
return HI_NULL;
}
{
U8 imps2_param [] = {243,200,243,100,243,80};
int fd = open(DEV_MOUSE, O_RDWR);
if (fd > 0)
{
write(fd, imps2_param, sizeof (imps2_param));
stPoll[0].fd = fd;
stPoll[0].events = POLLIN;
}
else
{
printf("open %s fail\n", DEV_MOUSE);
}
}
bShow = HI_FALSE;
if (ioctl(pstInfo->fd, FBIOPUT_SHOW_HIFB, &bShow) < 0)
{
printf("FBIOPUT_SHOW_HIFB failed!\n");
return HI_NULL;
}
switch (pstInfo->ctrlkey)
{
case 3:
{
stPoint.s32XPos = 150;
stPoint.s32YPos = 150;
}
break;
default:
{
stPoint.s32XPos = 0;
stPoint.s32YPos = 0;
}
}
setMousePos(*(POINT_S *)&stPoint);
if (ioctl(pstInfo->fd, FBIOPUT_SCREEN_ORIGIN_HIFB, &stPoint) < 0)
{
printf("set screen original show position failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
stAlpha.bAlphaEnable = HI_FALSE;
stAlpha.bAlphaChannel = HI_FALSE;
stAlpha.u8Alpha0 = 0x80;
stAlpha.u8Alpha1 = 0xff;
stAlpha.u8GlobalAlpha = 0x80;
if (ioctl(pstInfo->fd, FBIOPUT_ALPHA_HIFB, &stAlpha) < 0)
{
printf("Set alpha failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
stColorKey.bKeyEnable = HI_TRUE;
stColorKey.u32Key = 0x7fff;
if (ioctl(pstInfo->fd, FBIOPUT_COLORKEY_HIFB, &stColorKey) < 0)
{
printf("FBIOPUT_COLORKEY_HIFB!\n");
close(pstInfo->fd);
return HI_NULL;
}
if (ioctl(pstInfo->fd, FBIOGET_VSCREENINFO, &var) < 0)
{
printf("Get variable screen info failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
usleep(4*1000*1000);
switch (pstInfo->ctrlkey)
{
case 3:
{
var.xres_virtual = 24;
var.yres_virtual = 24;
var.xres = 24;
var.yres = 24;
}
break;
default:
{
var.xres_virtual = 1280;
var.yres_virtual = 720*2;
var.xres = 1280;
var.yres = 720;
}
}
var.transp= g_a16;
var.red = g_r16;
var.green = g_g16;
var.blue = g_b16;
var.bits_per_pixel = 16;
var.activate = FB_ACTIVATE_NOW;
if (ioctl(pstInfo->fd, FBIOPUT_VSCREENINFO, &var) < 0)
{
printf("Put variable screen info failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
if (ioctl(pstInfo->fd, FBIOGET_FSCREENINFO, &fix) < 0)
{
printf("Get fix screen info failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
u32FixScreenStride = fix.line_length;
pShowScreen = mmap(HI_NULL, fix.smem_len, PROT_READ|PROT_WRITE, MAP_SHARED, pstInfo->fd, 0);
if (MAP_FAILED == pShowScreen)
{
printf("mmap framebuffer failed!\n");
close(pstInfo->fd);
return HI_NULL;
}
memset(pShowScreen, 0x00, fix.smem_len);
bShow = HI_TRUE;
if (ioctl(pstInfo->fd, FBIOPUT_SHOW_HIFB, &bShow) < 0)
{
printf("FBIOPUT_SHOW_HIFB failed!\n");
munmap(pShowScreen, fix.smem_len);
return HI_NULL;
}
switch (pstInfo->ctrlkey)
{
case 3:
{
U16* pbuf=NULL;
SAMPLE_HIFB_LoadBmp("cursor.bmp",pShowScreen);
if (ioctl(pstInfo->fd, FBIOPAN_DISPLAY, &var) < 0)
{
printf("FBIOPAN_DISPLAY failed!\n");
munmap(pShowScreen, fix.smem_len);
close(pstInfo->fd);
return HI_FALSE;
}
printf("show cursor\n");
sleep(2);
while(1)
{
int len=0;
MS_PARAM msMsg;
if (poll(stPoll, 1, 1) > 0)
{
if (stPoll[0].revents)
{
len = read(stPoll[0].fd, cPollData, 4);
printf("%d\t%d\t%d\t%d\n",cPollData[0],cPollData[1],cPollData[2],cPollData[3]);
stPoint.s32XPos +=(cPollData[1]>127?cPollData[1]-256:cPollData[1]);
stPoint.s32YPos -=(cPollData[2]>127?cPollData[2]-256:cPollData[2]);
stPoint.s32XPos =stPoint.s32XPos<0?0:stPoint.s32XPos;
stPoint.s32XPos =stPoint.s32XPos>1280?1280:stPoint.s32XPos;
stPoint.s32YPos =stPoint.s32YPos<0?0:stPoint.s32YPos;
stPoint.s32YPos =stPoint.s32YPos>720?720:stPoint.s32YPos;
ioctl(pstInfo->fd, FBIOPUT_SCREEN_ORIGIN_HIFB, &stPoint);
setMousePos(*(POINT_S *)&stPoint);
msMsg.pos_s=getMousePos();
transMouse(cPollData,&msMsg);
pWINDOW_S pWnd_s=NULL;
pWnd_s=posInAboveWnd(msMsg.pos_s);
if(pWnd_s&&pWnd_s !=getOSDWnd())
{
msMsg.pthis=pWnd_s;
pCONTROL pCtrl=NULL;
{
MSG msg;
int ret;
msg.message=msMsg.mesg;
msg.param=(pMS_PARAM)malloc(sizeof(MS_PARAM));
*(pMS_PARAM)msg.param=msMsg;
ret=SendMsg(pWnd_s->msgid,msg);
}
}
else if(pWnd_s==getOSDWnd())
{
MSG msg;
int ret;
pCONTROL pCtrl=NULL;
pWINDOW_S pCur_s=getCurWnd();
if(pCur_s)
{
pCtrl=lookUpCtrlInWnd(pCur_s,pCur_s->focusCtrlHdl);
if(pCtrl)
{
setCtrlLostFocus(pCur_s,pCtrl);
}
}
msg.message=msMsg.mesg;
msg.param=(pMS_PARAM)malloc(sizeof(MS_PARAM));
if(!msg.param)
{
printf("%s\t%d\n",__FUNCTION__,__LINE__);
}
*(pMS_PARAM)msg.param=msMsg;
ret=SendMsg(pWnd_s->msgid,msg);
}
else
{
printf("%s\t%d\n",__FUNCTION__,__LINE__);
}
}
}
}
}
break;
}
munmap(pShowScreen, fix.smem_len);
bShow = HI_FALSE;
return HI_NULL;
}
void Window::setMouseCentre()
{
setMousePos(glm::vec2(width/2,height/2));
}
//get any new input
void WindowSFML::updateInput()
{
if (!windowIsOpen)
{
return;
}
else if (!windowObj.isOpen())
{
windowIsOpen=0;
return;
}
sf::Event event;
keyPressListPos=0;
keyPressNum=0;
bool lDwn=0, rDwn=0, mDwn=0;
double scroll=0;
while (windowObj.pollEvent(event))
{
switch (event.type)
{
// window closed
case sf::Event::Closed:
windowObj.close();
break;
// key pressed
case sf::Event::KeyPressed:
if (keyPressNum<MAX_KEY_PRESSES)
{
keyPresses[keyPressNum]=key2char[event.key.code];
++keyPressNum;
}
else
{
err << "key press overflow" << err;
}
break;
case sf::Event::MouseButtonPressed:
switch (event.mouseButton.button)
{
case sf::Mouse::Left:
lDwn=1;
break;
case sf::Mouse::Right:
rDwn=1;
break;
case sf::Mouse::Middle:
mDwn=1;
break;
default:
break;
}
break;
case sf::Event::MouseWheelMoved:
scroll+=event.mouseWheel.delta;
break;
case sf::Event::Resized:
hasBeenResized();
break;
case sf::Event::GainedFocus:
windowHasFocus=1;
break;
case sf::Event::LostFocus:
windowHasFocus=0;
break;
// we don't process other types of events
default:
break;
}
}
auto mouseVctr=sf::Mouse::getPosition(windowObj);
shiftDwnBool=sf::Keyboard::isKeyPressed(sf::Keyboard::LShift) || sf::Keyboard::isKeyPressed(sf::Keyboard::RShift);
ctrlDwnBool=sf::Keyboard::isKeyPressed(sf::Keyboard::LControl) || sf::Keyboard::isKeyPressed(sf::Keyboard::RControl);
altDwnBool=sf::Keyboard::isKeyPressed(sf::Keyboard::LAlt) || sf::Keyboard::isKeyPressed(sf::Keyboard::RAlt);
superDwnBool=sf::Keyboard::isKeyPressed(sf::Keyboard::RSystem) || sf::Keyboard::isKeyPressed(sf::Keyboard::RSystem);
if (sf::Mouse::isButtonPressed(sf::Mouse::Left))
lDwn=true;
if (sf::Mouse::isButtonPressed(sf::Mouse::Right))
rDwn=true;
if (sf::Mouse::isButtonPressed(sf::Mouse::Middle))
mDwn=true;
setMouseButton(&mouse.left, lDwn);
setMouseButton(&mouse.right, rDwn);
setMouseButton(&mouse.middle, mDwn);
setMousePos(V2d(mouseVctr.x, dim.y-mouseVctr.y));
setMouseScroll(scroll);
dltaTime=dltaTimer.get();
dltaTimer.reset();
}
void EventManager::initMouse() {
CursorMan.pushCursor(mouseData, MOUSE_WIDTH, MOUSE_HEIGHT, 0, 0, 0);
CursorMan.showMouse(false);
setMousePos(Common::Point(_vm->_graphics->_screenWidth / 2, _vm->_graphics->_screenHeight / 2));
}
bool OSystem_IPOD::pollEvent(Event &event) {
SDL_Event ev;
int axis;
byte b = 0;
handleKbdMouse();
// If the screen mode changed, send an EVENT_SCREEN_CHANGED
if (_modeChanged) {
_modeChanged = false;
event.type = EVENT_SCREEN_CHANGED;
return true;
}
while(SDL_PollEvent(&ev)) {
switch(ev.type) {
case SDL_KEYDOWN:{
b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
// Alt-Return and Alt-Enter toggle full screen mode
if (b == KBD_ALT && (ev.key.keysym.sym == SDLK_RETURN
|| ev.key.keysym.sym == SDLK_KP_ENTER)) {
setFullscreenMode(!_fullscreen);
#ifdef USE_OSD
if (_fullscreen)
displayMessageOnOSD("Fullscreen mode");
else
displayMessageOnOSD("Windowed mode");
#endif
break;
}
// Alt-S: Create a screenshot
if (b == KBD_ALT && ev.key.keysym.sym == 's') {
char filename[20];
for (int n = 0;; n++) {
SDL_RWops *file;
sprintf(filename, "scummvm%05d.bmp", n);
file = SDL_RWFromFile(filename, "r");
if (!file)
break;
SDL_RWclose(file);
}
if (saveScreenshot(filename))
printf("Saved '%s'\n", filename);
else
printf("Could not save screenshot!\n");
break;
}
// Ctrl-m toggles mouse capture
if (b == KBD_CTRL && ev.key.keysym.sym == 'm') {
toggleMouseGrab();
break;
}
#ifdef MACOSX
// On Macintosh', Cmd-Q quits
if ((ev.key.keysym.mod & KMOD_META) && ev.key.keysym.sym == 'q') {
event.type = EVENT_QUIT;
return true;
}
#elif defined(UNIX)
// On other unices, Control-Q quits
if ((ev.key.keysym.mod & KMOD_CTRL) && ev.key.keysym.sym == 'q') {
event.type = EVENT_QUIT;
return true;
}
#else
// Ctrl-z and Alt-X quit
if ((b == KBD_CTRL && ev.key.keysym.sym == 'z') || (b == KBD_ALT && ev.key.keysym.sym == 'x')) {
event.type = EVENT_QUIT;
return true;
}
#endif
// Ctrl-Alt-<key> will change the GFX mode
if ((b & (KBD_CTRL|KBD_ALT)) == (KBD_CTRL|KBD_ALT)) {
handleScalerHotkeys(ev.key);
break;
}
const bool event_complete = remapKey(ev,event);
if (event_complete)
return true;
event.type = EVENT_KEYDOWN;
event.kbd.keycode = ev.key.keysym.sym;
event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
return true;
}
case SDL_KEYUP:
{
const bool event_complete = remapKey(ev,event);
if (event_complete)
return true;
event.type = EVENT_KEYUP;
event.kbd.keycode = ev.key.keysym.sym;
event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
// Ctrl-Alt-<key> will change the GFX mode
if ((b & (KBD_CTRL|KBD_ALT)) == (KBD_CTRL|KBD_ALT)) {
// Swallow these key up events
break;
}
return true;
}
case SDL_MOUSEMOTION:
event.type = EVENT_MOUSEMOVE;
fillMouseEvent(event, ev.motion.x, ev.motion.y);
setMousePos(event.mouse.x, event.mouse.y);
return true;
case SDL_MOUSEBUTTONDOWN:
if (ev.button.button == SDL_BUTTON_LEFT)
event.type = EVENT_LBUTTONDOWN;
else if (ev.button.button == SDL_BUTTON_RIGHT)
event.type = EVENT_RBUTTONDOWN;
#if defined(SDL_BUTTON_WHEELUP) && defined(SDL_BUTTON_WHEELDOWN)
else if (ev.button.button == SDL_BUTTON_WHEELUP)
event.type = EVENT_WHEELUP;
else if (ev.button.button == SDL_BUTTON_WHEELDOWN)
event.type = EVENT_WHEELDOWN;
#endif
else
break;
fillMouseEvent(event, ev.button.x, ev.button.y);
return true;
case SDL_MOUSEBUTTONUP:
if (ev.button.button == SDL_BUTTON_LEFT)
event.type = EVENT_LBUTTONUP;
else if (ev.button.button == SDL_BUTTON_RIGHT)
event.type = EVENT_RBUTTONUP;
else
break;
fillMouseEvent(event, ev.button.x, ev.button.y);
return true;
case SDL_JOYBUTTONDOWN:
if (ev.jbutton.button == JOY_BUT_LMOUSE) {
event.type = EVENT_LBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button == JOY_BUT_RMOUSE) {
event.type = EVENT_RBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
} else {
event.type = EVENT_KEYDOWN;
switch (ev.jbutton.button) {
case JOY_BUT_ESCAPE:
event.kbd.keycode = SDLK_ESCAPE;
event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
break;
case JOY_BUT_PERIOD:
event.kbd.keycode = SDLK_PERIOD;
event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
break;
case JOY_BUT_SPACE:
event.kbd.keycode = SDLK_SPACE;
event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
break;
case JOY_BUT_F5:
event.kbd.keycode = SDLK_F5;
event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
break;
}
}
return true;
case SDL_JOYBUTTONUP:
if (ev.jbutton.button == JOY_BUT_LMOUSE) {
event.type = EVENT_LBUTTONUP;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button == JOY_BUT_RMOUSE) {
event.type = EVENT_RBUTTONUP;
fillMouseEvent(event, _km.x, _km.y);
} else {
event.type = EVENT_KEYUP;
switch (ev.jbutton.button) {
case JOY_BUT_ESCAPE:
event.kbd.keycode = SDLK_ESCAPE;
event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
break;
case JOY_BUT_PERIOD:
event.kbd.keycode = SDLK_PERIOD;
event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
break;
case JOY_BUT_SPACE:
event.kbd.keycode = SDLK_SPACE;
event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
break;
case JOY_BUT_F5:
event.kbd.keycode = SDLK_F5;
event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
break;
}
}
return true;
case SDL_JOYAXISMOTION:
axis = ev.jaxis.value;
if ( axis > JOY_DEADZONE) {
axis -= JOY_DEADZONE;
event.type = EVENT_MOUSEMOVE;
} else if ( axis < -JOY_DEADZONE ) {
axis += JOY_DEADZONE;
event.type = EVENT_MOUSEMOVE;
} else
axis = 0;
if ( ev.jaxis.axis == JOY_XAXIS) {
#ifdef JOY_ANALOG
_km.x_vel = axis/2000;
_km.x_down_count = 0;
#else
if (axis != 0) {
_km.x_vel = (axis > 0) ? 1:-1;
_km.x_down_count = 1;
} else {
_km.x_vel = 0;
_km.x_down_count = 0;
}
#endif
} else if (ev.jaxis.axis == JOY_YAXIS) {
#ifndef JOY_INVERT_Y
axis = -axis;
#endif
#ifdef JOY_ANALOG
_km.y_vel = -axis / 2000;
_km.y_down_count = 0;
#else
if (axis != 0) {
_km.y_vel = (-axis > 0) ? 1: -1;
_km.y_down_count = 1;
} else {
_km.y_vel = 0;
_km.y_down_count = 0;
}
#endif
}
fillMouseEvent(event, _km.x, _km.y);
return true;
case SDL_VIDEOEXPOSE:
_forceFull = true;
break;
case SDL_QUIT:
event.type = EVENT_QUIT;
return true;
}
}
return false;
}
void Mouse::update(float dt)
{
memcpy(m_lastButtonState, m_buttonState, sizeof(bool) * 2);
#ifdef _WIN32
m_buttonState[0] = (GetAsyncKeyState(VK_LBUTTON) & 0x8000) ? true : false;
m_buttonState[1] = (GetAsyncKeyState(VK_RBUTTON) & 0x8000) ? true : false;
#elif defined __APPLE__
#ifndef MARBLE_IOS_BUILD
Uint8 mouseState = SDL_GetMouseState(NULL, NULL);
m_buttonState[0] = (mouseState & SDL_BUTTON(SDL_BUTTON_LEFT)) ? true : false;
m_buttonState[1] = (mouseState & SDL_BUTTON(SDL_BUTTON_RIGHT)) ? true : false;
#endif
#endif
/*
This next section of code allows for really smooth mouse movement no matter
what the frame rate (well... within reason). The last 10 positions
are stored in a list. Each frame a new relative position is added and the oldest is removed.
These positions are then added together using a weighting value. The most recent position
has the most weight, whereas the oldest as the lowest weighting. This value is then averaged
to produce the new relative mouse position.
*/
elapsed_time += dt;
if (elapsed_time > timestep_threshold)
{
static std::list<std::pair<float, float> > mousePositionHistory;
if (m_mouseLocked) {
int x, y;
getMousePos(x, y);
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
if ( !firstFrame ) {
//Add the current mouse position - starting position
mousePositionHistory.push_front(std::make_pair((float)x - (viewport[2] / 2), (float)y - (viewport[3] / 2)));
if (mousePositionHistory.size() > 10)
{
//Make sure only the last 10 positions are stored
mousePositionHistory.pop_back();
}
m_relativeMousePosX = 0.0f;
m_relativeMousePosY = 0.0f;
float weight = 1.0f;
//Calculate a weighted average
for (std::list<std::pair<float, float> >::iterator i = mousePositionHistory.begin();
i != mousePositionHistory.end(); ++i)
{
m_relativeMousePosX += (*i).first * weight;
m_relativeMousePosY += (*i).second * weight;
weight *= 0.5f;
}
m_relativeMousePosX /= 10.0f;
m_relativeMousePosY /= 10.0f;
}
firstFrame = false;
//Put the mouse in the middle of the screen
setMousePos(viewport[2] / 2, viewport[3] / 2);
showCursor(false);
}
elapsed_time = 0.0f;
}
}
/* Override the SDL pollEvent with the Wiz's own event code. */
bool OSystem_GP2XWIZ::pollEvent(Common::Event &event) {
SDL_Event ev;
int axis;
byte b = 0;
handleKbdMouse();
// If the screen mode changed, send an Common::EVENT_SCREEN_CHANGED
if (_modeChanged) {
_modeChanged = false;
event.type = Common::EVENT_SCREEN_CHANGED;
return true;
}
// GP2X Wiz Input mappings.
/*
Single Button
Movement:
GP2X_BUTTON_UP Cursor Up
GP2X_BUTTON_DOWN Cursor Down
GP2X_BUTTON_LEFT Cursor Left
GP2X_BUTTON_RIGHT Cursor Right
GP2X_BUTTON_UPLEFT Cursor Up Left
GP2X_BUTTON_UPRIGHT Cursor Up Right
GP2X_BUTTON_DOWNLEFT Cursor Down Left
GP2X_BUTTON_DOWNRIGHT Cursor Down Right
Button Emulation:
GP2X_BUTTON_A . (Period)
GP2X_BUTTON_B Left Mouse Click
GP2X_BUTTON_Y Space Bar
GP2X_BUTTON_X Right Mouse Click
GP2X_BUTTON_L Combo Modifier (Left Trigger)
GP2X_BUTTON_R Return (Right Trigger)
GP2X_BUTTON_MENU F5 (Game Menu)
GP2X_BUTTON_SELECT Escape
GP2X_BUTTON_VOLUP /dev/mixer Global Volume Up
GP2X_BUTTON_VOLDOWN /dev/mixer Global Volume Down
Combos:
GP2X_BUTTON_VOLUP & GP2X_BUTTON_VOLDOWN 0 (For Monkey 2 CP) or Virtual Keyboard if enabled
GP2X_BUTTON_L & GP2X_BUTTON_SELECT Common::EVENT_QUIT (Calls Sync() to make sure SD is flushed)
GP2X_BUTTON_L & GP2X_BUTTON_MENU Common::EVENT_MAINMENU (ScummVM Global Main Menu)
GP2X_BUTTON_L & GP2X_BUTTON_A Common::EVENT_PREDICTIVE_DIALOG for predictive text entry box (AGI games)
*/
while (SDL_PollEvent(&ev)) {
switch(ev.type) {
case SDL_KEYDOWN:{
b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
const bool event_complete = remapKey(ev,event);
if (event_complete)
return true;
event.type = Common::EVENT_KEYDOWN;
event.kbd.keycode = (Common::KeyCode)ev.key.keysym.sym;
event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
return true;
}
case SDL_KEYUP:
{
const bool event_complete = remapKey(ev,event);
if (event_complete)
return true;
event.type = Common::EVENT_KEYUP;
event.kbd.keycode = (Common::KeyCode)ev.key.keysym.sym;
event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
// Ctrl-Alt-<key> will change the GFX mode
if ((b & (Common::KBD_CTRL|Common::KBD_ALT)) == (Common::KBD_CTRL|Common::KBD_ALT)) {
// Swallow these key up events
break;
}
return true;
}
case SDL_MOUSEMOTION:
event.type = Common::EVENT_MOUSEMOVE;
fillMouseEvent(event, ev.motion.x, ev.motion.y);
setMousePos(event.mouse.x, event.mouse.y);
return true;
case SDL_MOUSEBUTTONDOWN:
if (ev.button.button == SDL_BUTTON_LEFT)
event.type = Common::EVENT_LBUTTONDOWN;
else if (ev.button.button == SDL_BUTTON_RIGHT)
event.type = Common::EVENT_RBUTTONDOWN;
#if defined(SDL_BUTTON_WHEELUP) && defined(SDL_BUTTON_WHEELDOWN)
else if (ev.button.button == SDL_BUTTON_WHEELUP)
event.type = Common::EVENT_WHEELUP;
else if (ev.button.button == SDL_BUTTON_WHEELDOWN)
event.type = Common::EVENT_WHEELDOWN;
#endif
#if defined(SDL_BUTTON_MIDDLE)
else if (ev.button.button == SDL_BUTTON_MIDDLE)
event.type = Common::EVENT_MBUTTONDOWN;
#endif
else
break;
fillMouseEvent(event, ev.button.x, ev.button.y);
return true;
case SDL_MOUSEBUTTONUP:
if (ev.button.button == SDL_BUTTON_LEFT)
event.type = Common::EVENT_LBUTTONUP;
else if (ev.button.button == SDL_BUTTON_RIGHT)
event.type = Common::EVENT_RBUTTONUP;
#if defined(SDL_BUTTON_MIDDLE)
else if (ev.button.button == SDL_BUTTON_MIDDLE)
event.type = Common::EVENT_MBUTTONUP;
#endif
else
break;
fillMouseEvent(event, ev.button.x, ev.button.y);
return true;
case SDL_JOYBUTTONDOWN:
_stickBtn[ev.jbutton.button] = 1;
if (ev.jbutton.button == GP2X_BUTTON_B) {
event.type = Common::EVENT_LBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button == GP2X_BUTTON_X) {
event.type = Common::EVENT_RBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
} else if (_stickBtn[GP2X_BUTTON_L] && (ev.jbutton.button == GP2X_BUTTON_SELECT)) {
event.type = Common::EVENT_QUIT;
} else if (ev.jbutton.button < 8) {
moveStick();
event.type = Common::EVENT_MOUSEMOVE;
fillMouseEvent(event, _km.x, _km.y);
} else {
event.type = Common::EVENT_KEYDOWN;
event.kbd.flags = 0;
switch (ev.jbutton.button) {
case GP2X_BUTTON_L:
GP2X_BUTTON_STATE_L = true;
break;
case GP2X_BUTTON_R:
if (GP2X_BUTTON_STATE_L == true) {
#ifdef ENABLE_VKEYBD
event.kbd.keycode = Common::KEYCODE_F7;
event.kbd.ascii = mapKey(SDLK_F7, ev.key.keysym.mod, 0);
#else
event.kbd.keycode = Common::KEYCODE_0;
event.kbd.ascii = mapKey(SDLK_0, ev.key.keysym.mod, 0);
#endif
} else {
event.kbd.keycode = Common::KEYCODE_RETURN;
event.kbd.ascii = mapKey(SDLK_RETURN, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_SELECT:
if (GP2X_BUTTON_STATE_L == true) {
event.type = Common::EVENT_QUIT;
} else {
event.kbd.keycode = Common::KEYCODE_ESCAPE;
event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_A:
if (GP2X_BUTTON_STATE_L == true) {
event.type = Common::EVENT_PREDICTIVE_DIALOG;
} else {
event.kbd.keycode = Common::KEYCODE_PERIOD;
event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_Y:
event.kbd.keycode = Common::KEYCODE_SPACE;
event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
break;
case GP2X_BUTTON_MENU:
if (GP2X_BUTTON_STATE_L == true) {
event.type = Common::EVENT_MAINMENU;
} else {
event.kbd.keycode = Common::KEYCODE_F5;
event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_VOLUP:
WIZ_HW::mixerMoveVolume(2);
if (WIZ_HW::volumeLevel == 100) {
displayMessageOnOSD("Maximum Volume");
} else {
displayMessageOnOSD("Increasing Volume");
}
break;
case GP2X_BUTTON_VOLDOWN:
WIZ_HW::mixerMoveVolume(1);
if (WIZ_HW::volumeLevel == 0) {
displayMessageOnOSD("Minimal Volume");
} else {
displayMessageOnOSD("Decreasing Volume");
}
break;
}
}
return true;
case SDL_JOYBUTTONUP:
_stickBtn[ev.jbutton.button] = 0;
if (ev.jbutton.button == GP2X_BUTTON_B) {
event.type = Common::EVENT_LBUTTONUP;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button == GP2X_BUTTON_X) {
event.type = Common::EVENT_RBUTTONUP;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button < 8) {
moveStick();
event.type = Common::EVENT_MOUSEMOVE;
fillMouseEvent(event, _km.x, _km.y);
} else {
event.type = Common::EVENT_KEYUP;
event.kbd.flags = 0;
switch (ev.jbutton.button) {
case GP2X_BUTTON_SELECT:
event.kbd.keycode = Common::KEYCODE_ESCAPE;
event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
break;
case GP2X_BUTTON_A:
event.kbd.keycode = Common::KEYCODE_PERIOD;
event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
break;
case GP2X_BUTTON_Y:
event.kbd.keycode = Common::KEYCODE_SPACE;
event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
break;
case GP2X_BUTTON_MENU:
if (GP2X_BUTTON_STATE_L == true) {
event.type = Common::EVENT_MAINMENU;
} else {
event.kbd.keycode = Common::KEYCODE_F5;
event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_L:
GP2X_BUTTON_STATE_L = false;
break;
case GP2X_BUTTON_R:
if (GP2X_BUTTON_STATE_L == true) {
#ifdef ENABLE_VKEYBD
event.kbd.keycode = Common::KEYCODE_F7;
event.kbd.ascii = mapKey(SDLK_F7, ev.key.keysym.mod, 0);
#else
event.kbd.keycode = Common::KEYCODE_0;
event.kbd.ascii = mapKey(SDLK_0, ev.key.keysym.mod, 0);
#endif
} else {
event.kbd.keycode = Common::KEYCODE_RETURN;
event.kbd.ascii = mapKey(SDLK_RETURN, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_VOLUP:
break;
case GP2X_BUTTON_VOLDOWN:
break;
}
}
return true;
case SDL_JOYAXISMOTION:
axis = ev.jaxis.value;
if ( axis > JOY_DEADZONE) {
axis -= JOY_DEADZONE;
event.type = Common::EVENT_MOUSEMOVE;
} else if ( axis < -JOY_DEADZONE ) {
axis += JOY_DEADZONE;
event.type = Common::EVENT_MOUSEMOVE;
} else
axis = 0;
if ( ev.jaxis.axis == JOY_XAXIS) {
if (axis != 0) {
_km.x_vel = (axis > 0) ? 1:-1;
_km.x_down_count = 1;
} else {
_km.x_vel = 0;
_km.x_down_count = 0;
}
} else if (ev.jaxis.axis == JOY_YAXIS) {
#ifndef JOY_INVERT_Y
axis = -axis;
#endif
#ifdef JOY_ANALOG
_km.y_vel = -axis / 2000;
_km.y_down_count = 0;
#else
if (axis != 0) {
_km.y_vel = (-axis > 0) ? 1: -1;
_km.y_down_count = 1;
} else {
_km.y_vel = 0;
_km.y_down_count = 0;
}
#endif
}
fillMouseEvent(event, _km.x, _km.y);
return true;
case SDL_VIDEOEXPOSE:
_forceFull = true;
break;
case SDL_QUIT:
event.type = Common::EVENT_QUIT;
return true;
}
}
return false;
}
