int Window::handleMessage( uint32_t code, void* data, size_t size ) {
switch (code) {
case Y_WINDOW_SHOW :
registerWindow();
break;
case Y_WINDOW_HIDE :
unregisterWindow();
break;
case Y_WINDOW_DO_RESIZE :
resize(reinterpret_cast<WinResize*>(data)->m_size);
break;
case Y_WINDOW_DO_MOVETO :
moveTo(reinterpret_cast<WinMoveTo*>(data)->m_position);
break;
case Y_WINDOW_RENDER : {
if (!m_rendering) {
m_renderContext.init(m_bitmap);
m_rendering = true;
}
bool renderingFinished = handleRender(
reinterpret_cast<uint8_t*>(data) + sizeof(WinHeader),
size - sizeof(WinHeader)
);
if (renderingFinished) {
m_renderContext.finish();
m_rendering = false;
}
break;
}
}
return 0;
}
ShellWindow::ShellWindow(QWaylandSurface *surface, QObject *parent)
: QObject(parent)
, m_role(UnknownRole)
, m_flags(0)
, m_compositor(static_cast<Compositor *>(surface->compositor()))
, m_surface(surface)
{
qRegisterMetaType<ShellWindow *>("ShellWindow*");
// Identifier
m_id++;
// Create view
m_view = new QWaylandSurfaceItem(static_cast<QWaylandQuickSurface *>(surface));
// Connect to surface signals
connect(surface, &QWaylandSurface::mapped, [=] {
registerWindow();
});
connect(surface, &QWaylandSurface::unmapped, [=] {
unregisterWindow(false);
});
}
ShellWindow::~ShellWindow()
{
unregisterWindow(true);
m_view->deleteLater();
}
int Application::exec()
{
Display *display = getDisplay();
XEvent event;
if( !display )
return 1;
while( !m_quit )
{
// update eventinfo
updateEventInfo();
while( XPending(display) )
{
XNextEvent( display, &event );
// handle event
switch( event.type )
{
case ClientMessage:
{
Atom clientMsg = (Atom)event.xclient.data.l[0];
if(clientMsg == m_deleteWindowAtom)
{
// destroy window
getRegisteredWindow( event.xclient.window )->destroy();
}
}break;
case DestroyNotify:
{
Window *w = getRegisteredWindow( event.xdestroywindow.window );
unregisterWindow(w);
// we assume we are in gui mode all the time (gui mode means, when there is no window the app closes)
if(1)
if( m_windowRegister.empty() )
m_quit = true;
}break;
case KeyPress:
{
switch( XKeycodeToKeysym( display, event.xkey.keycode, 0 ) )
{
case XK_Up:
m_eventInfo.keyb.press[KEY_UP] = 1;break;
case XK_Down:
m_eventInfo.keyb.press[KEY_DOWN] = 1;break;
case XK_Left:
m_eventInfo.keyb.press[KEY_LEFT] = 1;break;
case XK_Right:
m_eventInfo.keyb.press[KEY_RIGHT] = 1;break;
case XK_Escape:
m_eventInfo.keyb.press[KEY_ESCAPE] = 1;break;
};
}break;
};
}
// repaint all windows which need repainting
for( WindowRegister::iterator it = m_windowRegister.begin(); it != m_windowRegister.end(); ++it)
{
Window *w = it->second;
w->paint();
}
}
return 0;
}
//
// WinAPI message handler
//
LRESULT CALLBACK Application::windowHandler( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
Window *w = getRegisteredWindow( hWnd );
// we may get invalid windows (e.g. when using GLTemporaryContext)
if(!w)
return DefWindowProc( hWnd, uMsg, wParam, lParam );
switch( uMsg )
{
case WM_CLOSE:
{
w->destroy();
return 0;
}break;
case WM_DESTROY:
{
unregisterWindow(w);
// we assume we are in gui mode all the time (gui mode means, when there is no window the app closes)
if(1)
if( m_windowRegister.empty() )
PostQuitMessage(0);
return 0;
}break;
case WM_KEYDOWN: // a key has been pressed
{
// update central eventinfo
EventInfo &ei = Application::eventInfo();
int conv = 0;
switch( wParam )
{
case VK_LEFT: conv = KEY_LEFT; break;
case VK_RIGHT: conv = KEY_RIGHT; break;
case VK_UP: conv = KEY_UP; break;
case VK_PRIOR: conv = KEY_PGUP; break;
case VK_NEXT: conv = KEY_PGDOWN; break;
case VK_DOWN: conv = KEY_DOWN; break;
case VK_SPACE: conv = KEY_SPACE; break;
case VK_RSHIFT: conv = KEY_RSHIFT; break;
case VK_RCONTROL: conv = KEY_RCONTROL; break;
case VK_LSHIFT: conv = KEY_LSHIFT; break;
case VK_LCONTROL: conv = KEY_LCONTROL; break;
case VK_ESCAPE: conv = KEY_ESCAPE; break;
case VK_RETURN: conv = KEY_RETURN; break;
}
for( int i=KEY_A; i<=KEY_Z; i++ )
{
if( wParam==(WPARAM)('A'+i-KEY_A) )
conv = i;
if( wParam==(WPARAM)('a'+i-KEY_A) )
conv = i;
}
ei.keyb.press[conv] = 1;
if( w->m_keypress )
w->m_keypress(conv);
return( DefWindowProc(hWnd,uMsg,wParam,lParam) );
}break;
case WM_LBUTTONDOWN:
case WM_MBUTTONDOWN:
case WM_RBUTTONDOWN:
{
}break;
case WM_MOUSEMOVE :
{
/*
int xPos = GET_X_LPARAM(lParam);
int yPos = GET_Y_LPARAM(lParam);
m_eventInfo.mouse.ox = m_eventInfo.mouse.x;
m_eventInfo.mouse.oy = m_eventInfo.mouse.y;
m_eventInfo.mouse.x = xPos;
m_eventInfo.mouse.y = yPos;
m_eventInfo.mouse.dx = m_eventInfo.mouse.x - m_eventInfo.mouse.ox;
m_eventInfo.mouse.dy = m_eventInfo.mouse.y - m_eventInfo.mouse.oy;
//w->event();
return( DefWindowProc(hWnd,uMsg,wParam,lParam) );
*/
}break;
default:
return DefWindowProc( hWnd, uMsg, wParam, lParam );
}
return DefWindowProc( hWnd, uMsg, wParam, lParam );
}
int Window::close(void) {
unregisterWindow();
return 0;
}
void pxWindowNative::runEventLoop()
{
displayRef d;
exitFlag = false;
double lastAnimationTime = pxMilliseconds();
while(!exitFlag)
{
XEvent e;
if (XPending(d.getDisplay()))
{
XNextEvent(d.getDisplay(), &e);
XAnyEvent* ae = (XAnyEvent*)&e;
pxWindowNative* w = getPXWindowFromX11Window(ae->window);
if (w)
{
switch(ae->type)
{
case Expose:
{
if(e.xexpose.count<1)
{
GC gc=XCreateGC(ae->display, ae->window, 0, NULL);
pxSurfaceNativeDesc d;
d.display = ae->display;
d.drawable = ae->window;
d.gc = gc;
w->onDraw(&d);
XFreeGC(ae->display, gc);
}
}
break;
case ButtonPress:
{
XGrabPointer(ae->display, ae->window, true,
ButtonPressMask|ButtonReleaseMask|
PointerMotionMask,
GrabModeAsync, GrabModeAsync, None, None,
CurrentTime);
XButtonEvent *be = (XButtonEvent*)ae;
unsigned long flags;
switch(be->button)
{
case Button2: flags = PX_MIDDLEBUTTON;
break;
case Button3: flags = PX_RIGHTBUTTON;
break;
default: flags = PX_LEFTBUTTON;
break;
}
flags |= (be->state & ShiftMask)?PX_MOD_SHIFT:0;
flags |= (be->state & ControlMask)?PX_MOD_CONTROL:0;
flags |= (be->state & Mod1Mask)?PX_MOD_ALT:0;
w->onMouseDown(be->x, be->y, flags);
}
break;
case ButtonRelease:
{
XUngrabPointer(ae->display, CurrentTime);
XButtonEvent *be = (XButtonEvent*)ae;
unsigned long flags;
switch(be->button)
{
case Button2: flags = PX_MIDDLEBUTTON;
break;
case Button3: flags = PX_RIGHTBUTTON;
break;
default: flags = PX_LEFTBUTTON;
break;
}
flags |= (be->state & ShiftMask)?PX_MOD_SHIFT:0;
flags |= (be->state & ControlMask)?PX_MOD_CONTROL:0;
flags |= (be->state & Mod1Mask)?PX_MOD_ALT:0;
w->onMouseUp(be->x, be->y, flags);
}
break;
case KeyPress:
{
XKeyEvent* ke = (XKeyEvent*)ae;
KeySym keySym = ::XKeycodeToKeysym(ae->display,
e.xkey.keycode,
0);
if (keySym >= 'a' && keySym <= 'z')
keySym = (keySym-'a')+'A';
else if (keySym == XK_Shift_R)
keySym = XK_Shift_L;
else if (keySym == XK_Control_R)
keySym = XK_Control_L;
else if (keySym == XK_Alt_R)
keySym = XK_Alt_L;
unsigned long flags = 0;
flags |= (ke->state & ShiftMask)?PX_MOD_SHIFT:0;
flags |= (ke->state & ControlMask)?PX_MOD_CONTROL:0;
flags |= (ke->state & Mod1Mask)?PX_MOD_ALT:0;
w->onKeyDown(keySym, flags);
}
break;
case MotionNotify:
{
XMotionEvent *me = (XMotionEvent*)ae;
w->onMouseMove(me->x, me->y);
}
break;
case KeyRelease:
{
XKeyEvent* ke = (XKeyEvent*)ae;
KeySym keySym = ::XKeycodeToKeysym(ae->display,
e.xkey.keycode,
0);
if (keySym >= 'a' && keySym <= 'z')
keySym = (keySym-'a')+'A';
else if (keySym == XK_Shift_R)
keySym = XK_Shift_L;
else if (keySym == XK_Control_R)
keySym = XK_Control_L;
else if (keySym == XK_Alt_R)
keySym = XK_Alt_L;
unsigned long flags = 0;
flags |= (ke->state & ShiftMask)?PX_MOD_SHIFT:0;
flags |= (ke->state & ControlMask)?PX_MOD_CONTROL:0;
flags |= (ke->state & Mod1Mask)?PX_MOD_ALT:0;
w->onKeyUp(keySym, flags);
}
break;
case ConfigureNotify:
{
// We defer the onSize message after some
// time
if (w->lastWidth != e.xconfigure.width ||
w->lastHeight != e.xconfigure.height)
{
w->resizeFlag = true;
w->lastWidth = e.xconfigure.width;
w->lastHeight = e.xconfigure.height;
}
}
break;
case ClientMessage:
{
if((e.xclient.format == 32) &&
(e.xclient.data.l[0] == int(w->closeatom)))
{
w->onCloseRequest();
}
}
break;
case DestroyNotify:
{
w->onClose();
unregisterWindow(ae->window);
}
break;
case LeaveNotify:
{
w->onMouseLeave();
}
break;
}
}
}
else
{
// The animation/resize handling under x11 needs some serious
// rework
double currentAnimationTime = pxMilliseconds();
vector<windowDesc>::iterator i;
for (i = mWindowMap.begin(); i < mWindowMap.end(); i++)
{
pxWindowNative* w = (*i).p;
double animationDelta = currentAnimationTime-lastAnimationTime;
if (w->resizeFlag)
{
w->resizeFlag = false;
w->onSize((*i).p->lastWidth, (*i).p->lastHeight);
w->invalidateRectInternal(NULL);
}
if (w->mTimerFPS)
{
animationDelta = currentAnimationTime-
w->mLastAnimationTime;
if (animationDelta > (1000/w->mTimerFPS))
{
w->onAnimationTimerInternal();
w->mLastAnimationTime = currentAnimationTime;
}
}
}
pxSleepMS(10); // Breath
}
}
}
