---

vrj::GlWindowWin32 Class Reference

#include <GlWindowWin32.h>

Inheritance diagram for vrj::GlWindowWin32:

[legend]Collaboration diagram for vrj::GlWindowWin32:

[legend]List of all members.

Public Methods
	GlWindowWin32 ()
virtual	~GlWindowWin32 ()
virtual int	open ()
	Opens the OpenGL window. More...
virtual int	close ()
	Closes the OpenGL window. More...
virtual bool	makeCurrent ()
	Sets the current OpenGL context to this window. More...
virtual void	swapBuffers ()
	Performs an OpenGL swap buffers command. More...
virtual void	checkEvents ()
	Checks for window events. More...
void	configWindow (vrj::Display *disp)
	Configures the window. More...
Public Attributes
HWND	mWinHandle
	Window handle. More...
HGLRC	mRenderContext
	Permenant Rendering context. More...
HDC	mDeviceContext
	Private GDI Device context. More...
std::string	window_name
int	mPipe
std::string	mXDisplayName
	Name of the x display to use. More...
PIXELFORMATDESCRIPTOR *	mMatch
	Points the the found pixel format. More...
Protected Methods
LRESULT	handleEvent (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
bool	setPixelFormat (HDC hDC)
	Sets the pixel format for the given display context. More...
void	sizeChanged (long width, long height)
virtual void	processEvent (UINT message, UINT wParam, LONG lParam)
	Sample from the window. More...
void	becomeEventWindowDevice ()
	Do the stuff needed to become an event window. More...
void	removeEventWindowDevice ()
	do the stuff to make this not a gadgeteer device. More...
Static Protected Methods
bool	registerWindowClass ()
LRESULT CALLBACK	WndProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
	Global Window event handler. More...
void	addWindow (HWND handle, GlWindowWin32 *glWin)
	Adds a window to the map. More...
void	removeWindow (HWND handle)
	Removes a window from the map. More...
GlWindowWin32 *	getGlWin (HWND handle)
	Gets the glWin we are dealing with. More...
Static Protected Attributes
WNDCLASS	mWinClass
	The window class to register. More...
bool	mWinRegisteredClass = false
	Window registration. More...
std::map< HWND, GlWindowWin32 * >	mGlWinMap

---

Constructor & Destructor Documentation

vrj::GlWindowWin32::GlWindowWin32 (    )

Definition at line 51 of file GlWindowWin32.cpp. Referenced by WndProc. : mMatch(NULL), mWinHandle(NULL), mRenderContext(NULL), mDeviceContext(NULL) { }

vrj::GlWindowWin32::~GlWindowWin32 (    )  [virtual]

Definition at line 56 of file GlWindowWin32.cpp. References close. { this->close(); }

---

Member Function Documentation

int vrj::GlWindowWin32::open (    )  [virtual]

Opens the OpenGL window. Precondition: this has been configured. Postcondition: Window created. Create message sets the visual. Returns: true if the window opened correctly. Reimplemented from vrj::GlWindow. Definition at line 65 of file GlWindowWin32.cpp. References becomeEventWindowDevice, GL_WINDOW_WIN32_CLASSNAME, vrj::GlWindow::mAreEventSource, mDeviceContext, mRenderContext, mWinHandle, vrj::GlWindow::origin_x, vrj::GlWindow::origin_y, setPixelFormat, vrjDBG_DRAW_MGR, vrj::GlWindow::window_height, vrj::GlWindow::window_is_open, and vrj::GlWindow::window_width. { if ( false == GlWindowWin32::registerWindowClass() ) { return 0; } if ( window_is_open ) { return 1; } HMODULE hMod = GetModuleHandle(NULL); DWORD style; int root_height; // OpenGL requires WS_CLIPCHILDREN and WS_CLIPSIBLINGS. style = WS_CLIPCHILDREN | WS_CLIPSIBLINGS; // If we want a border, create an overlapped window. This will have // a titlebar and a border. if ( border ) { vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_HVERB_LVL) << "attempting to give window a border" << std::endl << vprDEBUG_FLUSH; style |= WS_OVERLAPPEDWINDOW; } // Otherwise, come as close as possible to having no border by using // the thin-line border. else { vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_HVERB_LVL) << "attempting to make window borderless" << std::endl << vprDEBUG_FLUSH; style |= WS_OVERLAPPED | WS_POPUP | WS_VISIBLE; } root_height = GetSystemMetrics(SM_CYSCREEN); // Create the main application window mWinHandle = CreateWindow(GL_WINDOW_WIN32_CLASSNAME, GL_WINDOW_WIN32_CLASSNAME, style, origin_x, root_height - origin_y - window_height, window_width, window_height, NULL, NULL, hMod, NULL); // If window was not created, quit if ( NULL == mWinHandle ) { return 0; } // Attach a pointer to the device for use from the WNDPROC SetWindowLong( mWinHandle, GWL_USERDATA, (LPARAM)this ); // We have a valid window, so... Create the context //case WM_CREATE: mDeviceContext = GetDC(mWinHandle); // Store the device context if ( false == setPixelFormat(mDeviceContext) ) // Select the pixel format { return 0; } // Create the rendering context and make it current mRenderContext = wglCreateContext(mDeviceContext); vprASSERT(mRenderContext != NULL); wglMakeCurrent(mDeviceContext, mRenderContext); // Register the window with the window list GlWindowWin32::addWindow(mWinHandle,this); // Display the window ShowWindow(mWinHandle, SW_SHOW); UpdateWindow(mWinHandle); // Tell the window to paint window_is_open = true; // ----------- Event window device starting -------------- // // Are we going to act like as an event source? if (true == mAreEventSource) { this->becomeEventWindowDevice(); } return 1; }

int vrj::GlWindowWin32::close (    )  [virtual]

Closes the OpenGL window. Returns: true if the window closed correctly. Note: Must be called by the same thread that called open. Reimplemented from vrj::GlWindow. Definition at line 189 of file GlWindowWin32.cpp. References mWinHandle, removeEventWindowDevice, and vrj::GlWindow::window_is_open. Referenced by ~GlWindowWin32. { //vprASSERT( !mXfuncLock.test() && "Attempting to close a display window that is locked" ); // Assert that we have not impllemented correct shutdown for the case that we // are an event window as well //vprASSERT(!mAreEventSource && "Need to implement win32 window close with gadget::EventWindow"); // if not open, then don't bother. if ( !window_is_open ) { return false; } if (mAreEventSource) { this->removeEventWindowDevice(); } // Remove window from window list GlWindowWin32::removeWindow(mWinHandle); window_is_open = false; // destroy the win32 window return(1 == DestroyWindow(mWinHandle)); }

bool vrj::GlWindowWin32::makeCurrent (    )  [virtual]

Sets the current OpenGL context to this window. Postcondition: this.context is active context. Reimplemented from vrj::GlWindow. Definition at line 220 of file GlWindowWin32.cpp. References mDeviceContext, and mRenderContext. { vprASSERT((mDeviceContext != NULL) && (mRenderContext != NULL)); wglMakeCurrent(mDeviceContext, mRenderContext); // Make our context current return true; }

void vrj::GlWindowWin32::swapBuffers (    )  [virtual]

Performs an OpenGL swap buffers command. Reimplemented from vrj::GlWindow. Definition at line 229 of file GlWindowWin32.cpp. References mDeviceContext. { vprASSERT(mDeviceContext != NULL); SwapBuffers(mDeviceContext); }

void vrj::GlWindowWin32::checkEvents (    )  [virtual]

Checks for window events. Postcondition: All win32 events have ben dispatched and dealt with. Reimplemented from vrj::GlWindow. Definition at line 235 of file GlWindowWin32.cpp. References vrj::GlWindow::mAreEventSource. { if (true == mAreEventSource) { gadget::EventWindowWin32::sample(); // if event source, use its event processor // it will pass all events up to this->processEvent() // when done, so that we can see the messages. } else { // not an event source, so pump our own events MSG win_message; while (PeekMessage( &win_message, NULL, 0, 0, PM_REMOVE )) { // Test if quit if (win_message.message == WM_QUIT) { break; } TranslateMessage( &win_message ); // Translate the accelerator keys DispatchMessage( &win_message ); // Send to the WinProc } } }

void vrj::GlWindowWin32::configWindow (  vrj::Display *    disp )  [virtual]

Configures the window. Postcondition: this is configured based on the data in display. Reimplemented from vrj::GlWindow. Definition at line 268 of file GlWindowWin32.cpp. References becomeEventWindowDevice, vrj::GlWindow::configWindow, vrj::Display::getConfigElement, vrj::Display::getName, vrj::Display::getPipe, vrj::GlWindow::mAreEventSource, mPipe, mXDisplayName, removeEventWindowDevice, vrjDBG_DRAW_MGR, and window_name. { const char neg_one_STRING[] = "-1"; vprASSERT( disp != NULL ); vrj::GlWindow::configWindow( disp ); // Get the vector of display chunks jccl::ConfigElementPtr disp_sys_elt = DisplayManager::instance()->getDisplaySystemElement(); jccl::ConfigElementPtr display_elt = disp->getConfigElement(); window_name = disp->getName(); mPipe = disp->getPipe(); vprASSERT( mPipe >= 0 ); mXDisplayName = disp_sys_elt->getProperty<std::string>("x11_pipes", mPipe); if (mXDisplayName == neg_one_STRING) // Use display env { const std::string DISPLAY_str("DISPLAY"); // DISPLAY_str[] = "DISPLAY"; const char* d = getenv(DISPLAY_str.c_str()); if (NULL != d) { mXDisplayName = std::string( d ); } } vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_VERB_LVL) << "glxWindow::config: display name is: " << mXDisplayName << std::endl << vprDEBUG_FLUSH; bool was_i_a_keyboard = mAreEventSource; mAreEventSource = display_elt->getProperty<bool>("act_as_event_source"); // If i'm being configured to NOT be an event source, and I was one already. if (false == mAreEventSource && true == was_i_a_keyboard) { this->removeEventWindowDevice(); } // If i'm being configured to be an event source, and I wasn't one already. else if (true == mAreEventSource && false == was_i_a_keyboard) { // Configure event window device portion. jccl::ConfigElementPtr event_win_chunk = display_elt->getProperty<jccl::ConfigElementPtr>("event_window_device"); // Set the name of the chunk to the same as the parent chunk (so we can point at it) //event_win_chunk->setProperty("name", display_elt->getName(); gadget::EventWindowWin32::config(event_win_chunk); // Custom configuration gadget::EventWindowWin32::mWidth = GlWindowWin32::window_width; gadget::EventWindowWin32::mHeight = GlWindowWin32::window_height; mWeOwnTheWindow = false; // Event window device does not own window // if the window is already open, then make it an event window device // otherwise, this will be called once the window opens. if (window_is_open) { this->becomeEventWindowDevice(); } } }

LRESULT vrj::GlWindowWin32::handleEvent (  HWND    hWnd, UINT    message, WPARAM    wParam, LPARAM    lParam )  [protected]

Definition at line 334 of file GlWindowWin32.cpp. References mDeviceContext, mRenderContext, setPixelFormat, and sizeChanged. { switch ( message ) { // ---- Window creation, setup for OpenGL ---- // case WM_CREATE: vprASSERT(false); // Should never get called because //we are not registered when this gets called mDeviceContext = GetDC(hWnd); // Store the device context if ( false == setPixelFormat(mDeviceContext) ) // Select the pixel format { return 0; } // Create the rendering context and make it current mRenderContext = wglCreateContext(mDeviceContext); wglMakeCurrent(mDeviceContext, mRenderContext); break; // ---- Window is being destroyed, cleanup ---- // case WM_DESTROY: // Deselect the current rendering context and delete it wglMakeCurrent(mDeviceContext, NULL); wglDeleteContext(mRenderContext); // Tell the application to terminate after the window // is gone. PostQuitMessage(0); break; // --- Window is resized. --- // case WM_SIZE: // Call our function which modifies the clipping // volume and viewport sizeChanged(LOWORD(lParam), HIWORD(lParam)); break; // The painting function. This message sent by Windows // whenever the screen needs updating. case WM_PAINT: { PAINTSTRUCT ps; // Paint structure BeginPaint(hWnd, &ps); // Validate the drawing of the window EndPaint(hWnd, &ps); } break; default: // Passes it on if unproccessed return(DefWindowProc(hWnd, message, wParam, lParam)); } return(0L); }

bool vrj::GlWindowWin32::setPixelFormat (  HDC    hDC )  [protected]

Sets the pixel format for the given display context. Returns: success Definition at line 394 of file GlWindowWin32.cpp. References vrj::Display::getGlFrameBufferConfig, vrj::Display::getName, vrj::GlWindow::in_stereo, vrj::Display::isStereoRequested, mMatch, vrj::GlWindow::mVrjDisplay, vrjDBG_DISP_MGR, and vrjDBG_DRAW_MGR. Referenced by handleEvent, and open. { int pixel_format; PIXELFORMATDESCRIPTOR pfd; mMatch = NULL; memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR)); pfd.nSize = (sizeof(PIXELFORMATDESCRIPTOR)); pfd.nVersion = 1; /* Defaults. */ pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER; if ( mVrjDisplay->isStereoRequested() ) { in_stereo = true; pfd.dwFlags |= PFD_STEREO; } else { in_stereo = false; } int red_size(8), green_size(8), blue_size(8), alpha_size(8), db_size(32); jccl::ConfigElementPtr gl_fb_chunk = mVrjDisplay->getGlFrameBufferConfig(); if ( gl_fb_chunk.get() != NULL ) { red_size = gl_fb_chunk->getProperty<int>("red_size"); green_size = gl_fb_chunk->getProperty<int>("green_size"); blue_size = gl_fb_chunk->getProperty<int>("blue_size"); alpha_size = gl_fb_chunk->getProperty<int>("alpha_size"); db_size = gl_fb_chunk->getProperty<int>("depth_buffer_size"); if ( red_size < 0 ) { vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_WARNING_LVL) << "WARNING: Red channel size was negative, set to: " << red_size << ". Setting to 1.\n" << vprDEBUG_FLUSH; red_size = 1; } if ( green_size < 0 ) { vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_WARNING_LVL) << "WARNING: Green channel size was negative, set to: " << green_size << ". Setting to 1.\n" << vprDEBUG_FLUSH; green_size = 1; } if ( blue_size < 0 ) { vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_WARNING_LVL) << "WARNING: Blue channel size was negative, set to: " << blue_size << ". Setting to 1.\n" << vprDEBUG_FLUSH; blue_size = 1; } if ( alpha_size < 0 ) { vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_WARNING_LVL) << "WARNING: Alpha channel size was negative, set to: " << alpha_size << ". Setting to 1.\n" << vprDEBUG_FLUSH; alpha_size = 1; } if ( db_size < 0 ) { vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_WARNING_LVL) << "WARNING: Depth buffer size was negative, set to: " << db_size << ". Setting to 1.\n" << vprDEBUG_FLUSH; db_size = 1; } } vprDEBUG(vrjDBG_DISP_MGR, vprDBG_CONFIG_LVL) << "Frame buffer visual settings for " << mVrjDisplay->getName() << ": R:" << red_size << " G:" << green_size << " B:" << blue_size << " A:" << alpha_size << " DB:" << db_size << std::endl << vprDEBUG_FLUSH; pfd.iPixelType = PFD_TYPE_RGBA; pfd.cColorBits = 32; pfd.cRedBits = red_size; pfd.cGreenBits = green_size; pfd.cBlueBits = blue_size; pfd.cAlphaBits = alpha_size; pfd.cDepthBits = db_size; pfd.cStencilBits = 0; pfd.cAccumBits = 0; pfd.cAuxBuffers = 0; // Let Win32 choose one for us pixel_format = ChoosePixelFormat(hDC, &pfd); if ( pixel_format > 0 ) { mMatch = (PIXELFORMATDESCRIPTOR *) malloc(sizeof(PIXELFORMATDESCRIPTOR)); DescribePixelFormat(hDC, pixel_format, sizeof(PIXELFORMATDESCRIPTOR), mMatch); /* ChoosePixelFormat is dumb in that it will return a pixel format that doesn't have stereo even if it was requested so we need to make sure that if stereo was selected, we got it. */ if ( mVrjDisplay->isStereoRequested() ) { if ( !(mMatch->dwFlags & PFD_STEREO) ) { free(mMatch); return NULL; } } } // Set the pixel format for the device context SetPixelFormat(hDC, pixel_format, &pfd); return true; }

void vrj::GlWindowWin32::sizeChanged (  long    width, long    height )  [protected]

Definition at line 514 of file GlWindowWin32.cpp. References vrj::GlWindow::window_height, and vrj::GlWindow::window_width. Referenced by handleEvent. { window_width = width; window_height = height; if ( window_width == 0 ) // Make sure we don't have window of 1 size (divide by zero would follow) { window_width = 1; } if ( window_height == 0 ) { window_height = 1; } // XXX: Should reset viewport here }

bool vrj::GlWindowWin32::registerWindowClass (    )  [static, protected]

Definition at line 561 of file GlWindowWin32.cpp. References GL_WINDOW_WIN32_CLASSNAME, mWinClass, and mWinRegisteredClass. { if ( mWinRegisteredClass ) { return true; } char lpszAppName[1024]; GetModuleFileName(NULL,lpszAppName,sizeof(lpszAppName)); mWinRegisteredClass = true; // We have registered now HINSTANCE hInstance = GetModuleHandle(NULL); // Register Window style mWinClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; mWinClass.lpfnWndProc = (WNDPROC)GlWindowWin32::WndProc; mWinClass.cbClsExtra = 0; mWinClass.cbWndExtra = 0; mWinClass.hInstance = hInstance; // Get handle to the module that created current process mWinClass.hIcon = LoadIcon(NULL, IDI_WINLOGO);; mWinClass.hCursor = LoadCursor(NULL, IDC_ARROW); // No need for background brush for OpenGL window mWinClass.hbrBackground = NULL; mWinClass.lpszMenuName = NULL; mWinClass.lpszClassName = GL_WINDOW_WIN32_CLASSNAME; // Register the window class if ( RegisterClass(&mWinClass) == 0 ) { return false; } else { return true; } }

LRESULT CALLBACK vrj::GlWindowWin32::WndProc (  HWND    hWnd, UINT    message, WPARAM    wParam, LPARAM    lParam )  [static, protected]

Global Window event handler. Definition at line 537 of file GlWindowWin32.cpp. References getGlWin, and GlWindowWin32. { GlWindowWin32* glWin = getGlWin(hWnd); if ( glWin != NULL ) // Message for one of ours { glWin->processEvent( message, wParam, lParam ); return glWin->handleEvent(hWnd, message, wParam, lParam); } else { return DefWindowProc(hWnd, message, wParam, lParam); } }

void vrj::GlWindowWin32::addWindow (  HWND    handle, GlWindowWin32 *    glWin )  [static, protected]

Adds a window to the map. Definition at line 604 of file GlWindowWin32.cpp. References mGlWinMap. { vprASSERT(glWin != NULL); if ( mGlWinMap.find(handle) == mGlWinMap.end() ) // Not already there { mGlWinMap[handle] = glWin; } //else // vprASSERT(false); }

void vrj::GlWindowWin32::removeWindow (  HWND    handle )  [static, protected]

Removes a window from the map. Definition at line 616 of file GlWindowWin32.cpp. References mGlWinMap. { mGlWinMap.erase(handle); // Erase the entry in the list }

GlWindowWin32 * vrj::GlWindowWin32::getGlWin (  HWND    handle )  [static, protected]

Gets the glWin we are dealing with. Definition at line 621 of file GlWindowWin32.cpp. References mGlWinMap. Referenced by WndProc. { std::map<HWND, GlWindowWin32*>::iterator glWinIter; glWinIter = mGlWinMap.find(handle); if ( glWinIter == mGlWinMap.end() ) // Not found { return NULL; } else { return(*glWinIter).second; // Return the found window } }

void vrj::GlWindowWin32::processEvent (  UINT    message, UINT    wParam, LONG    lParam )  [protected, virtual]

Sample from the window. Called from seperate process (event window device update). Definition at line 263 of file GlWindowWin32.cpp. { }

void vrj::GlWindowWin32::becomeEventWindowDevice (    )  [protected]

Do the stuff needed to become an event window. Precondition: can be called any time Definition at line 151 of file GlWindowWin32.cpp. References mWinHandle. Referenced by configWindow, and open. { // Set the parameters that we will need to get events gadget::EventWindowWin32::m_hWnd = mWinHandle; // Start up the device /* Do it in out check event function gadget::EventWindowWin32::startSampling(); */ gadget::Input* dev_ptr = dynamic_cast<gadget::Input*>(this); vprASSERT( dev_ptr != NULL ); // @todo Possibly not the best way to add this to input manager // - What happens when the event window is removed at run-time??? // - What happens when this is called again? vrj::Kernel::instance()->getInputManager()->addDevice( dev_ptr ); }

void vrj::GlWindowWin32::removeEventWindowDevice (    )  [protected]

do the stuff to make this not a gadgeteer device. Precondition: can be called any time Definition at line 170 of file GlWindowWin32.cpp. Referenced by close, and configWindow. { gadget::EventWindowWin32::m_hWnd = 0; gadget::Input* dev_ptr = dynamic_cast<gadget::Input*>(this); vprASSERT( dev_ptr != NULL ); // @todo Possibly not the best way to add this to input manager // - What happens when the event window is removed at run-time??? // - What happens when this is called again? // @todo reenable this when InputManager::removeDevice(Input*) is public //vrj::Kernel::instance()->getInputManager()->removeDevice( dev_ptr ); }

---

Member Data Documentation

WNDCLASS vrj::GlWindowWin32::mWinClass [static, protected]

The window class to register. Definition at line 557 of file GlWindowWin32.cpp. Referenced by registerWindowClass.

bool vrj::GlWindowWin32::mWinRegisteredClass = false [static, protected]

Window registration. Definition at line 556 of file GlWindowWin32.cpp. Referenced by registerWindowClass.

std::map< HWND, GlWindowWin32 * > vrj::GlWindowWin32::mGlWinMap [static, protected]

Definition at line 558 of file GlWindowWin32.cpp. Referenced by addWindow, getGlWin, and removeWindow.

HWND vrj::GlWindowWin32::mWinHandle

Window handle. Definition at line 147 of file GlWindowWin32.h. Referenced by becomeEventWindowDevice, close, and open.

HGLRC vrj::GlWindowWin32::mRenderContext

Permenant Rendering context. Definition at line 148 of file GlWindowWin32.h. Referenced by handleEvent, makeCurrent, and open.

HDC vrj::GlWindowWin32::mDeviceContext

Private GDI Device context. Definition at line 149 of file GlWindowWin32.h. Referenced by handleEvent, makeCurrent, open, and swapBuffers.

std::string vrj::GlWindowWin32::window_name

Definition at line 151 of file GlWindowWin32.h. Referenced by configWindow.

int vrj::GlWindowWin32::mPipe

Definition at line 152 of file GlWindowWin32.h. Referenced by configWindow.

std::string vrj::GlWindowWin32::mXDisplayName

Name of the x display to use. Definition at line 153 of file GlWindowWin32.h. Referenced by configWindow.

PIXELFORMATDESCRIPTOR* vrj::GlWindowWin32::mMatch

Points the the found pixel format. Definition at line 155 of file GlWindowWin32.h. Referenced by setPixelFormat.

---

The documentation for this class was generated from the following files:

• GlWindowWin32.h
• GlWindowWin32.cpp

---