void
CPatchEngine::Initialize( void )
{GUCEF_TRACE;
assert( m_patchListEngine != NULL );
RegisterEvents();
// Forward events from the list engine
AddForwardingForEvent( PatchListProcessingStartedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchListProcessingProgressEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchListProcessingCompletedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchListProcessingAbortedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchListProcessingFailedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchSetDataRecievedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchSetRetrievalStartedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchSetRetrievalCompletedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchSetRetrievalFailedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchSetRetrievalAbortedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchSetDecodingFailedEvent, EVENTORIGINFILTER_UNMODIFIED );
// Forward events from the set engine
AddForwardingForEvent( PatchSetProcessingStartedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchSetProcessingProgressEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchSetProcessingCompletedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchSetProcessingAbortedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( PatchSetProcessingFailedEvent, EVENTORIGINFILTER_UNMODIFIED );
// Forward events from the dir engines
AddForwardingForEvent( DirProcessingStartedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( DirProcessingProgressEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( DirProcessingCompletedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( SubDirProcessingStartedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( SubDirProcessingCompletedEvent, EVENTORIGINFILTER_UNMODIFIED );
// Forward file engine events
AddForwardingForEvent( FileListProcessingStartedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( LocalFileIsOKEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( LocalFileSizeMismatchEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( LocalFileHashMismatchEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( LocalFileNotFoundEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( LocalFileReplacedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( FileRetrievalStartedEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( FileRetrievalProgressEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( FileRetrievalCompleteEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( FileRetrievalErrorEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( FileStorageErrorEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( FileListProcessingCompleteEvent, EVENTORIGINFILTER_UNMODIFIED );
AddForwardingForEvent( FileListProcessingAbortedEvent, EVENTORIGINFILTER_UNMODIFIED );
SubscribeTo( &m_url );
// Subscribe to all events from the patch list engine
// This should allow us to receive all events that we wish to forward
SubscribeTo( m_patchListEngine );
}
CGUIManager::CGUIManager( void )
: CIConfigurable( true ) ,
m_initialized( false ) ,
m_drivers() ,
m_selectedDriverName() ,
m_guiConfig()
{GUCE_TRACE;
RegisterEvents();
SubscribeTo( CORE::CGUCEApplication::Instance() );
SubscribeTo( GUCEF::GUI::CGUIManager::Instance() );
}
void
CDRNNode::GetAvailableTCPClient( COMCORE::CTCPClientSocket** tcpClient ,
UInt32& socketIndex )
{GUCEF_TRACE;
// Try to find an inactive socket object we can re-use
UInt32 index = 0;
TTCPClients::iterator i = m_tcpClientSockets.begin();
while ( i != m_tcpClientSockets.end() )
{
if ( !(*i)->IsActive() )
{
// Assign output values
*tcpClient = *i;
socketIndex = index;
return;
}
++i; ++index;
}
// no such luck,.. we will create a new TCP client socket
COMCORE::CTCPClientSocket* clientSocket = new COMCORE::CTCPClientSocket( false );
SubscribeTo( clientSocket );
m_tcpClientSockets.push_back( clientSocket );
// Assign output values
socketIndex = (Int32)m_tcpClientSockets.size() - 1;
*tcpClient = clientSocket;
}
Navigator::Navigator( CommandDispatcher* pCD, Position* pOd, WaypointManager* pWM ) : Behavior( pCD )
{
_pPosition = pOd;
_pWaypointManager = pWM;
_pName = F("Navigator");
_pHelpString = F( " T <degrees> : set heading tolerance\n"
" R : restart at first waypoint"
);
// we need to subscribe to events from the two Publishers
SubscribeTo( pCD, 'N' );
// get our initial waypoint
_waypointNumber = 0;
_pCurrentWaypoint = _pWaypointManager->GetWaypoint( _waypointNumber );
_eState = eNormal;
_bCorrecting = false;
// _bAtDestination = false;
_headingTolerance = 2.0 * PI / 180; // 5°, in radians
_brakingFactor = 0.25; // for heading adjustments, slow one side by this factor.
}
void Switchboard::SendAllMessages()
{
_messagesLocked = true;
while (!_messages.empty())
{
String frontMessageName = _messages.front()->GetMessageName();
if (_subscribers.find(frontMessageName) != _subscribers.end())
{
std::set<MessageListener*>::iterator listenIt = _subscribers[frontMessageName].begin();
while (listenIt != _subscribers[frontMessageName].end())
{
(*listenIt)->ReceiveMessage(_messages.front());
listenIt++;
}
}
delete _messages.front();
_messages.pop();
}
_messagesLocked = false;
for(unsigned int i = 0; i < _deferredRemoves.size(); i++)
{
UnsubscribeFrom(_deferredRemoves[i]._subscriber, _deferredRemoves[i]._messageType);
}
_deferredRemoves.clear();
for(unsigned int i = 0; i < _deferredAdds.size(); i++)
{
SubscribeTo(_deferredAdds[i]._subscriber, _deferredAdds[i]._messageType);
}
_deferredAdds.clear();
}
CCodecBasedProductInfoListProvider::CCodecBasedProductInfoListProvider()
: CProductInfoListProvider(),
m_codecToUse( "xml" ),
m_dataRetriever()
{GUCEF_TRACE;
SubscribeTo( &m_dataRetriever );
}
CRefAppSubSystem::CRefAppSubSystem( void )
: CObservingNotifier() ,
//m_console( NULL ) ,
m_debugOverlay( NULL )
{GUCE_TRACE;
SubscribeTo( GUCE::GUI::CGUIManager::Instance(), GUCE::GUI::CGUIManager::GUIInitializedEvent );
}
CWin32WindowContext::CWin32WindowContext( void )
: CWindowContext() ,
m_guiContext() ,
m_id() ,
m_name() ,
m_window()
{GUCEF_TRACE;
SubscribeTo( &m_window );
}
CLogSvcClient::CLogSvcClient( CORE::CPulseGenerator& pulseGenerator )
: CLoggingTask() ,
m_tcpClient( pulseGenerator, false ) ,
m_appName( "Unknown" ) ,
m_connectionInitialized( false )
{GUCEF_TRACE;
RegisterEvents();
SubscribeTo( &m_tcpClient );
}
CLogSvcClient::CLogSvcClient( void )
: CLoggingTask() ,
m_tcpClient( false ) ,
m_appName( "Unknown" ) ,
m_connectionInitialized( false )
{GUCEF_TRACE;
RegisterEvents();
SubscribeTo( &m_tcpClient );
}
CGUIContextGL::CGUIContextGL( CGUIDriverGL& guiDriver ,
GUI::TWindowContextPtr windowContext ,
INPUT::CInputContext* inputContext ,
CEGUI::GUIContext* ceGuiContext )
: GUIDRIVERCEGUI::CGUIContext( guiDriver ,
inputContext ,
ceGuiContext ) ,
m_windowContext( windowContext )
{GUCEF_TRACE;
SubscribeTo( m_windowContext.GetPointer() );
}
CDRNNode::CDRNNode( void )
: CObservingNotifier() ,
m_tcpServerSocket( false ) ,
m_tcpClientSockets() ,
m_udpSocket( false ) ,
m_peerValidator( NULL ) ,
m_peerLinkCrypter( NULL ) ,
m_peerLinkList() ,
m_dataGroupList() ,
m_dataStreamList() ,
m_overrideConnectBack( false ) ,
m_overrideHost( "127.0.0.1" ,
53456 ) ,
m_overrideUDPPort( 53457 )
{GUCEF_TRACE;
RegisterEvents();
SubscribeTo( &m_tcpServerSocket );
SubscribeTo( &m_udpSocket );
}
CXWinGLWindowContext::CXWinGLWindowContext( void )
: CWindowContext() ,
m_guiContext() ,
m_id() ,
m_name() ,
m_window() // ,
//m_renderContext( NULL ) ,
//m_deviceContext( NULL )
{GUCEF_TRACE;
SubscribeTo( &m_window );
}
void
CLogSvcServer::RegisterServerSocketEventHandlers( void )
{
TEventCallback callback( this, &CLogSvcServer::OnServerSocketClientConnected );
SubscribeTo( &m_tcpServer ,
COMCORE::CTCPServerSocket::ClientConnectedEvent ,
callback );
TEventCallback callback2( this, &CLogSvcServer::OnServerSocketClientDisconnected );
SubscribeTo( &m_tcpServer ,
COMCORE::CTCPServerSocket::ClientDisconnectedEvent ,
callback2 );
TEventCallback callback3( this, &CLogSvcServer::OnServerSocketClientError );
SubscribeTo( &m_tcpServer ,
COMCORE::CTCPServerSocket::ClientErrorEvent ,
callback3 );
TEventCallback callback4( this, &CLogSvcServer::OnServerSocketServerSocketClosed );
SubscribeTo( &m_tcpServer ,
COMCORE::CTCPServerSocket::ServerSocketClosedEvent ,
callback4 );
TEventCallback callback5( this, &CLogSvcServer::OnServerSocketServerSocketError );
SubscribeTo( &m_tcpServer ,
COMCORE::CTCPServerSocket::ServerSocketErrorEvent ,
callback5 );
TEventCallback callback6( this, &CLogSvcServer::OnServerSocketServerSocketClientError );
SubscribeTo( &m_tcpServer ,
COMCORE::CTCPServerSocket::ServerSocketClientErrorEvent ,
callback6 );
}
COgreWindowContext::COgreWindowContext( void )
: CWindowContext() ,
m_guiContext() ,
m_id() ,
m_name() ,
m_osWindow( 0 ) ,
m_renderWindow( 0 ) ,
m_initialized( false )
{GUCEF_TRACE;
m_osWindow = CORE::COSWindow::Create();
SubscribeTo( m_osWindow );
}
CGUIContextOgre::CGUIContextOgre( CGUIDriverOgre& guiDriver ,
GUI::TWindowContextPtr windowContext ,
INPUT::CInputContext* inputContext ,
CEGUI::GUIContext* ceGuiContext )
: GUIDRIVERCEGUI::CGUIContext( guiDriver ,
inputContext ,
ceGuiContext ) ,
m_windowContext( windowContext ),
m_lastTimeInjection( clock() )
{GUCEF_TRACE;
SubscribeTo( m_windowContext.GetPointer() );
}
void
CLogSvcServer::RegisterClientConnectionEventHandlers( COMCORE::CTCPServerConnection* connection )
{GUCEF_TRACE;
TEventCallback callback( this, &CLogSvcServer::OnClientConnectionDataReceived );
SubscribeTo( connection ,
COMCORE::CTCPServerConnection::DataRecievedEvent ,
callback );
//static const CORE::CEvent ConnectedEvent;
//static const CORE::CEvent DisconnectedEvent;
//static const CORE::CEvent DataSentEvent;
//static const CORE::CEvent SocketErrorEvent;
}
bool
CHTTPURLHandler::Activate( CORE::CURL& url )
{GUCEF_TRACE;
GUCEF_DEBUG_LOG( CORE::LOGLEVEL_NORMAL, "CHTTPURLHandler(" + CORE::PointerToString( this ) + "): Activating using URL: " + url.GetURL() );
m_transferFinished = false;
delete m_httpClient;
m_httpClient = new CHTTPClient( url.GetPulseGenerator() );
SubscribeTo( m_httpClient );
return m_httpClient->Get( url.GetURL() );
}
CruiseControl::CruiseControl( CommandDispatcher* pCD, Position* pOD, float IPS2Ticks ) : Actor( pCD )
{
_pPosition = pOD;
_IPS2Ticks = IPS2Ticks;
_kP = 1.0;
_kI = 0.5;
_kD = 0.0;
_pName = "Cruise Control";
_bCruising = false;
SubscribeTo( pCD, 'C' ); // All our commands begin with "C"
}
CruiseControl::CruiseControl( CommandDispatcher* pCD, Position* pOD ) : Behavior( pCD )
{
_pPosition = pOD;
_kP = 1.0;
_kI = 0.5;
_kD = 0.0;
_pName = F("Cruise Control");
_pHelpString = F( " S <Speed> : Set cruising speed (IPS)\n"
" P <kP> <kI> <kD> : Set PID coefficients"
);
_bCruising = false;
SubscribeTo( pCD, 'C' ); // All our commands begin with "C"
}
bool Node::SubscribeToMultiple( LockableNodesType &nodes )
{
LockableNodesType::iterator it;
bool bWasSubscribed = false;
nodes.MutexLock();
it = nodes.begin();
while ( it != nodes.end() )
{
if ( SubscribeTo( **it ) == true )
bWasSubscribed = true;
++it;
}
nodes.MutexUnlock();
return bWasSubscribed;
}
void
CVideoSettingsForm::OnPostLayoutLoad( void )
{GUCE_TRACE;
m_resolutionLabel = static_cast< GUCEF::GUI::CLabel* >( GetWidget( "ResolutionLabel" ) );
m_resolutionCombobox = static_cast< GUCEF::GUI::CCombobox* >( GetWidget( "ResolutionCombobox" ) );
m_antiAliasingLabel = static_cast< GUCEF::GUI::CLabel* >( GetWidget( "AntiAliasingLabel" ) );
m_antiAliasingCombobox = static_cast< GUCEF::GUI::CCombobox* >( GetWidget( "AntiAliasingCombobox" ) );
m_fullscreenCheckbox = static_cast< GUCEF::GUI::CCheckbox* >( GetWidget( "FullscreenCheckbox" ) );
m_vSyncCheckbox = static_cast< GUCEF::GUI::CCheckbox* >( GetWidget( "vSyncCheckbox" ) );
m_applyButton = static_cast< GUCEF::GUI::CButton* >( GetWidget( "ApplyButton" ) );
SubscribeTo( m_resolutionLabel );
SubscribeTo( m_resolutionCombobox );
SubscribeTo( m_antiAliasingLabel );
SubscribeTo( m_antiAliasingCombobox );
SubscribeTo( m_fullscreenCheckbox );
SubscribeTo( m_vSyncCheckbox );
SubscribeTo( m_applyButton );
}
bool
CWin32WindowContext::Initialize( const GUI::CString& title ,
const GUI::CVideoSettings& videoSettings )
{GUCEF_TRACE;
// Do not initialize twice
Shutdown();
if ( !CORE::CMsWin32Window::RegisterWindowClass( GetClassTypeName() ) )
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "Win32WindowContext: Could not register window class" );
return false;
}
// First create a regular Win32 window
if ( m_window.WindowCreate( GetClassTypeName() ,
title ,
0 ,
0 ,
videoSettings.GetResolutionWidthInPixels() ,
videoSettings.GetResolutionHeightInPixels() ) )
{
// Display the new window
m_window.Show();
m_window.SendToForegound();
m_window.GrabFocus();
// Grab the main app pulse generator and set the update interval for the context to the desired refresh rate
CORE::CPulseGenerator& pulseGenerator = CORE::CCoreGlobal::Instance()->GetPulseGenerator();
pulseGenerator.RequestPeriodicPulses( this, 1000 / videoSettings.GetFrequency() );
SubscribeTo( &pulseGenerator );
GUCEF_SYSTEM_LOG( CORE::LOGLEVEL_NORMAL, "Win32WindowContext: Succesfully created Win32 window" );
return true;
}
return false;
}
bool
CDRNNode::ConnectToPeer( const COMCORE::CHostAddress& hostAddress )
{GUCEF_TRACE;
// Check if a peer validation mechanism has been provided to this node
if ( m_peerValidator != NULL )
{
// Check if the peer connection is allowed
if ( !m_peerValidator->IsPeerAddressValid( hostAddress ) )
{
return false;
}
}
// Obtain a TCP client socket
COMCORE::CTCPClientSocket* tcpClient = NULL;
UInt32 socketIndex = 0;
GetAvailableTCPClient( &tcpClient ,
socketIndex );
// Attempt the connection
SubscribeTo( tcpClient );
return tcpClient->ConnectTo( hostAddress );
}
bool
COgreWindowContext::Initialize( const GUI::CString& title ,
const GUI::CVideoSettings& videoSettings ,
const GUI::CString& ogreRenderSystem )
{GUCEF_TRACE;
// Do not initialize twice
Shutdown();
// First create a regular O/S window
if ( m_osWindow->WindowCreate( title ,
0 ,
0 ,
videoSettings.GetResolutionWidthInPixels() ,
videoSettings.GetResolutionHeightInPixels() ) )
{
// Display the new window
m_osWindow->Show();
m_osWindow->SendToForegound();
m_osWindow->GrabFocus();
// Now proceed with setting up the Ogre specifics
// We grab the O/S window identifier 'the handle'
// This is passed to Ogre to tie things together
CORE::Int64 windowRef = 0;
CORE::CString windowIntStr = m_osWindow->GetProperty( "WINDOWINT" );
if ( !windowIntStr.IsNULLOrEmpty() )
{
windowRef = CORE::StringToInt64( windowIntStr );
}
Ogre::NameValuePairList options;
options[ "externalWindowHandle" ] = Ogre::StringConverter::toString( (size_t) windowRef );
Ogre::Root* ogreRoot = Ogre::Root::getSingletonPtr();
if ( ogreRoot == nullptr )
{
ogreRoot = OGRE_NEW Ogre::Root( "", "", "" );
}
if ( !ogreRoot->isInitialised() )
{
// Load any Ogre plugins not loaded yet from the bootstrap group
CORE::CCoreGlobal::Instance()->GetPluginControl().LoadPluginGroup( "Ogre" );
const Ogre::RenderSystemList& rsList = ogreRoot->getAvailableRenderers();
if ( rsList.size() == 0 )
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_IMPORTANT, "OgreWindowContext: No Ogre render systems are available, cannot initialize" );
return false;
}
Ogre::RenderSystem* renderSystem = nullptr;
Ogre::RenderSystemList::const_iterator i = rsList.begin();
while ( i != rsList.end() )
{
GUCEF_SYSTEM_LOG( CORE::LOGLEVEL_NORMAL, "OgreWindowContext: Available Ogre render system: " + (*i)->getFriendlyName() );
if ( ogreRenderSystem == (*i)->getName() )
{
GUCEF_SYSTEM_LOG( CORE::LOGLEVEL_NORMAL, "OgreWindowContext: Found desired/preferred Ogre render system: " + (*i)->getFriendlyName() );
renderSystem = (*i);
}
++i;
}
if ( renderSystem == nullptr )
{
GUCEF_WARNING_LOG( CORE::LOGLEVEL_IMPORTANT, "OgreWindowContext: Preferred Ogre render systems not available, using first available alternative: " + (*rsList.begin())->getFriendlyName() );
renderSystem = *rsList.begin();
}
ogreRoot->setRenderSystem( renderSystem );
m_sceneManager = ogreRoot->createSceneManager( Ogre::ST_GENERIC );
m_renderWindow = ogreRoot->initialise( false, title );
}
m_renderWindow = ogreRoot->createRenderWindow( title,
videoSettings.GetResolutionWidthInPixels(),
videoSettings.GetResolutionHeightInPixels(),
videoSettings.GetFullscreenState(),
&options );
// Grab the main app pulse generator and set the update interval for the context to the desired refresh rate
CORE::CPulseGenerator& pulseGenerator = CORE::CCoreGlobal::Instance()->GetPulseGenerator();
pulseGenerator.RequestPeriodicPulses( this, 1000 / videoSettings.GetFrequency() );
SubscribeTo( &pulseGenerator );
GUCEF_SYSTEM_LOG( CORE::LOGLEVEL_NORMAL, "OgreWindowContext: Succesfully created Ogre rendering context" );
m_initialized = true;
return true;
}
return false;
}
bool
CXWinGLWindowContext::Initialize( const GUI::CString& title ,
const GUI::CVideoSettings& videoSettings )
{GUCEF_TRACE;
// Do not initialize twice
Shutdown();
// First get access to the display
::Display* display = CORE::CX11EventDispatcher::Instance()->GetDisplay();
if ( NULL == display )
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "CXWinGLWindowContext: Could not open display" );
return false;
}
// Now proceed with setting up the OpenGL specifics
int dummy = 0;
if ( 0 == glXQueryExtension( display, &dummy, &dummy ) )
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "CXWinGLWindowContext: X server has no OpenGL GLX extension" );
Shutdown();
return false;
}
// find an OpenGL-capable Color Index visual with depth buffer
static int attributes[] = {GLX_RGBA, GLX_DOUBLEBUFFER, None};
//static int attributes[] = {GLX_DEPTH_SIZE, 16, GLX_DOUBLEBUFFER, None};
XVisualInfo* vi = glXChooseVisual( display, DefaultScreen( display ), attributes );
if ( NULL == vi )
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "CXWinGLWindowContext: Could not get visual info for display" );
Shutdown();
return false;
}
// create an OpenGL rendering context
GLXContext cx = glXCreateContext( display, vi, None, GL_TRUE );
if ( NULL == cx )
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "CXWinGLWindowContext: Could not create rendering context" );
XFree( vi );
Shutdown();
return false;
}
GUCEF_DEBUG_LOG( CORE::LOGLEVEL_NORMAL, "CXWinGLWindowContext: Created GL context using GLX" );
// create an X colormap since probably not using default visual
::Colormap cmap = ::XCreateColormap( display, RootWindow( display, vi->screen),
vi->visual, AllocNone);
::XSetWindowAttributes swa;
swa.colormap = cmap;
swa.border_pixel = 0;
swa.event_mask = ExposureMask | EnterWindowMask | StructureNotifyMask | SubstructureNotifyMask;
::Window glwin = ::XCreateWindow(display, RootWindow(display, vi->screen), 0, 0, videoSettings.GetResolutionWidthInPixels(),
videoSettings.GetResolutionHeightInPixels(), 0, vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask, &swa);
if ( 0 == glwin )
{
GUCEF_ERROR_LOG( CORE::LOGLEVEL_NORMAL, "CXWinGLWindowContext: Failed to create X11 window" );
::XFree( vi );
Shutdown();
return false;
}
GUCEF_DEBUG_LOG( CORE::LOGLEVEL_NORMAL, "CXWinGLWindowContext: Created X11 Window" );
// ::XSetStandardProperties(display, glwin, "xogl", "xogl", None, 0,
// 0, NULL);
glXMakeCurrent( display, glwin, cx );
// Set up the default GL state.
glClearColor(0, 0, 0, 1);
//glEnableClientState( GL_VERTEX_ARRAY );
//glEnableClientState( GL_COLOR_ARRAY );
//glEnable( GL_BLEND );
//glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho( 0, GetWidth(), GetHeight(), 0, -1, 1 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
// Hook up our window object to re-use its eventing capabilities
m_window.SetDisplay( display );
m_window.SetScreen( vi->screen );
m_window.SetWindow( glwin );
m_window.SetText( title );
// cleanup
::XFree( vi );
// Display the new window
m_window.Show();
m_window.SendToForegound();
//m_window.GrabFocus();
// Grab the main app pulse generator and set the update interval for the context to the desired refresh rate
CORE::CPulseGenerator& pulseGenerator = CORE::CCoreGlobal::Instance()->GetPulseGenerator();
pulseGenerator.RequestPeriodicPulses( this, 1000 / videoSettings.GetFrequency() );
SubscribeTo( &pulseGenerator, CORE::CPulseGenerator::PulseEvent );
GUCEF_SYSTEM_LOG( CORE::LOGLEVEL_NORMAL, "CXWinGLWindowContext: Succesfully created OpenGL rendering context" );
return true;
}
