void Window::setCarbonWindow( WindowRef window )
{
LBVERB << "set Carbon window " << window << std::endl;
if( _impl->carbonWindow == window )
return;
if( _impl->carbonWindow )
exitEventHandler();
_impl->carbonWindow = window;
if( !window )
return;
if( getIAttribute( WindowSettings::IATTR_HINT_DRAWABLE ) == OFF )
return;
initEventHandler();
Rect rect;
Global::enterCarbon();
if( GetWindowBounds( window, kWindowContentRgn, &rect ) == noErr )
{
PixelViewport pvp( rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top );
if( getIAttribute( WindowSettings::IATTR_HINT_DECORATION ) != OFF )
pvp.y -= EQ_AGL_MENUBARHEIGHT;
setPixelViewport( pvp );
}
Global::leaveCarbon();
}
bool Window::configInitAGLFullscreen()
{
AGLContext context = getAGLContext();
if( !context )
{
sendError( ERROR_AGLWINDOW_NO_CONTEXT );
return false;
}
Global::enterCarbon();
aglEnable( context, AGL_FS_CAPTURE_SINGLE );
const PixelViewport& pvp = getPixelViewport();
if( !aglSetFullScreen( context, pvp.w, pvp.h, 0, 0 ))
LBWARN << "aglSetFullScreen to " << pvp << " failed: " << aglError()
<< std::endl;
// Do focus hell
ProcessSerialNumber selfProcess = { 0, kCurrentProcess };
SetFrontProcess( &selfProcess );
Global::leaveCarbon();
setPixelViewport( pvp );
if( getIAttribute( WindowSettings::IATTR_HINT_DRAWABLE ) != OFF )
initEventHandler();
return true;
}
bool Window::configInitGLXWindow( GLXFBConfig* fbConfig )
{
if( !_impl->xDisplay )
{
sendError( ERROR_GLXWINDOW_NO_DISPLAY );
return false;
}
PixelViewport pvp = getPixelViewport();
if( getIAttribute( IATTR_HINT_FULLSCREEN ) == ON )
{
const int screen = DefaultScreen( _impl->xDisplay );
pvp.h = DisplayHeight( _impl->xDisplay, screen );
pvp.w = DisplayWidth( _impl->xDisplay, screen );
pvp.x = 0;
pvp.y = 0;
setPixelViewport( pvp );
}
XID drawable = _createGLXWindow( fbConfig, pvp );
if( !drawable )
return false;
// map and wait for MapNotify event
XMapWindow( _impl->xDisplay, drawable );
XEvent event;
XIfEvent( _impl->xDisplay, &event, WaitForNotify, (XPointer)(drawable) );
XMoveResizeWindow( _impl->xDisplay, drawable, pvp.x, pvp.y, pvp.w, pvp.h );
XFlush( _impl->xDisplay );
// Grab keyboard focus in fullscreen mode
if( getIAttribute( IATTR_HINT_FULLSCREEN ) == ON ||
getIAttribute( IATTR_HINT_DECORATION ) == OFF )
{
XGrabKeyboard( _impl->xDisplay, drawable, True, GrabModeAsync,
GrabModeAsync, CurrentTime );
}
setXDrawable( drawable );
LBVERB << "Created X11 drawable " << drawable << std::endl;
return true;
}
bool Window::configInitSystemWindow( const uint128_t& )
{
const Pipe* pipe = getPipe();
WindowSettings settings = getSettings();
const SystemWindow* sysWindow = _sharedContextWindow ?
_sharedContextWindow->getSystemWindow() : 0;
settings.setSharedContextWindow( sysWindow );
SystemWindow* systemWindow =
pipe->getWindowSystem().createWindow( this, settings );
LBASSERT( systemWindow );
if( !systemWindow->configInit( ))
{
LBWARN << "System window initialization failed" << std::endl;
systemWindow->configExit();
delete systemWindow;
return false;
}
setPixelViewport( systemWindow->getPixelViewport( ));
setSystemWindow( systemWindow );
return true;
}
bool Window::processEvent( const Event& event )
{
// see comment in _updateEvent
_updateEvent( const_cast< Event& >( event ));
switch( event.type )
{
case Event::WINDOW_HIDE:
setPixelViewport( PixelViewport( 0, 0, 0, 0 ));
break;
case Event::WINDOW_SHOW:
case Event::WINDOW_RESIZE:
setPixelViewport( PixelViewport( event.resize.x, event.resize.y,
event.resize.w, event.resize.h ));
break;
case Event::KEY_PRESS:
case Event::KEY_RELEASE:
if( event.key.key == KC_VOID )
return true; // ignore
// else fall through
case Event::WINDOW_EXPOSE:
case Event::WINDOW_CLOSE:
case Event::STATISTIC:
case Event::MAGELLAN_AXIS:
case Event::MAGELLAN_BUTTON:
break;
case Event::WINDOW_POINTER_GRAB:
_grabbedChannels = _getEventChannels( event.pointer );
break;
case Event::WINDOW_POINTER_UNGRAB:
_grabbedChannels.clear();
break;
case Event::WINDOW_POINTER_MOTION:
case Event::WINDOW_POINTER_BUTTON_PRESS:
case Event::WINDOW_POINTER_BUTTON_RELEASE:
case Event::WINDOW_POINTER_WHEEL:
{
const Channels& channels = _getEventChannels( event.pointer );
for( Channels::const_iterator i = channels.begin();
i != channels.end(); ++i )
{
Channel* channel = *i;
Event channelEvent = event;
switch( event.type )
{
case Event::WINDOW_POINTER_MOTION:
channelEvent.type = Event::CHANNEL_POINTER_MOTION;
break;
case Event::WINDOW_POINTER_BUTTON_PRESS:
channelEvent.type = Event::CHANNEL_POINTER_BUTTON_PRESS;
break;
case Event::WINDOW_POINTER_BUTTON_RELEASE:
channelEvent.type = Event::CHANNEL_POINTER_BUTTON_RELEASE;
break;
case Event::WINDOW_POINTER_WHEEL:
channelEvent.type = Event::CHANNEL_POINTER_WHEEL;
break;
default:
LBWARN << "Unhandled window event of type " << event.type
<< std::endl;
LBUNIMPLEMENTED;
}
// convert y to GL notation (Channel PVP uses GL coordinates)
const PixelViewport& pvp = getPixelViewport();
const int32_t y = pvp.h - event.pointer.y;
const PixelViewport& channelPVP =
channel->getNativePixelViewport();
channelEvent.originator = channel->getID();
channelEvent.serial = channel->getSerial();
channelEvent.pointer.x -= channelPVP.x;
channelEvent.pointer.y = channelPVP.h - y + channelPVP.y;
channel->processEvent( channelEvent );
}
break;
}
case Event::WINDOW_SCREENSAVER:
switch( getIAttribute( WindowSettings::IATTR_HINT_SCREENSAVER ))
{
case OFF:
return true; // screen saver stays inactive
case ON:
return false; // screen saver becomes active
default: // AUTO
if( getDrawableConfig().doublebuffered &&
getIAttribute( WindowSettings::IATTR_HINT_DRAWABLE ) == WINDOW )
{
return true; // screen saver stays inactive
}
return false;
}
case Event::UNKNOWN:
// unknown window-system native event, which was not handled
return false;
default:
LBWARN << "Unhandled window event of type " << event.type
<< std::endl;
LBUNIMPLEMENTED;
}
Config* config = getConfig();
ConfigEvent configEvent;
configEvent.data = event;
config->sendEvent( configEvent );
return true;
}
void Window::setXDrawable( XID drawable )
{
LBASSERT( _impl->xDisplay );
if( _impl->xDrawable == drawable )
return;
if( _impl->xDrawable )
exitEventHandler();
_impl->xDrawable = drawable;
if( !drawable )
return;
const int32_t drawableType = getIAttribute( IATTR_HINT_DRAWABLE );
if( drawableType != OFF )
initEventHandler();
// query pixel viewport of window
switch( drawableType )
{
case PBUFFER:
{
unsigned width = 0;
unsigned height = 0;
glXQueryDrawable( _impl->xDisplay, drawable, GLX_WIDTH, &width );
glXQueryDrawable( _impl->xDisplay, drawable, GLX_HEIGHT, &height );
setPixelViewport(
PixelViewport( 0, 0, int32_t( width ), int32_t( height )));
break;
}
case WINDOW:
case AUTO:
case UNDEFINED:
{
XWindowAttributes wa;
XGetWindowAttributes( _impl->xDisplay, drawable, &wa );
// position is relative to parent: translate to absolute coords
::Window root, parent, *children;
unsigned nChildren;
XQueryTree( _impl->xDisplay, drawable, &root, &parent, &children,
&nChildren );
if( children != 0 )
XFree( children );
int x,y;
::Window childReturn;
XTranslateCoordinates( _impl->xDisplay, parent, root, wa.x, wa.y,
&x, &y, &childReturn );
setPixelViewport( PixelViewport( x, y, wa.width, wa.height ));
break;
}
default:
LBERROR << "Unknown drawable type " << drawableType << std::endl;
LBUNIMPLEMENTED;
case OFF:
case FBO:
LBASSERT( getPixelViewport().hasArea( ));
}
}
