// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "glcanvas.h"
-#endif
-
#include "wx/wxprec.h"
#if defined(__BORLANDC__)
#include "wx/app.h"
#endif
+#include "wx/module.h"
+
#include "wx/msw/private.h"
// DLL options compatibility check:
#include "wx/glcanvas.h"
+#if GL_EXT_vertex_array
+ #define WXUNUSED_WITHOUT_GL_EXT_vertex_array(name) name
+#else
+ #define WXUNUSED_WITHOUT_GL_EXT_vertex_array(name) WXUNUSED(name)
+#endif
+
/*
The following two compiler directives are specific to the Microsoft Visual
C++ family of compilers
LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam);
+// ----------------------------------------------------------------------------
+// wxGLModule is responsible for unregistering wxGLCanvasClass Windows class
+// ----------------------------------------------------------------------------
+
+class wxGLModule : public wxModule
+{
+public:
+ bool OnInit() { return true; }
+ void OnExit() { UnregisterClasses(); }
+
+ // register the GL classes if not done yet, return true if ok, false if
+ // registration failed
+ static bool RegisterClasses();
+
+ // unregister the classes, done automatically on program termination
+ static void UnregisterClasses();
+
+private:
+ // wxGLCanvas is only used from the main thread so this is MT-ok
+ static bool ms_registeredGLClasses;
+
+ DECLARE_DYNAMIC_CLASS(wxGLModule)
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxGLModule, wxModule)
+
+bool wxGLModule::ms_registeredGLClasses = false;
+
+/* static */
+bool wxGLModule::RegisterClasses()
+{
+ if (ms_registeredGLClasses)
+ return true;
+
+ // We have to register a special window class because we need the CS_OWNDC
+ // style for GLCanvas.
+
+ /*
+ From Angel Popov <jumpo@bitex.com>
+
+ Here are two snips from a dicussion in the OpenGL Gamedev list that explains
+ how this problem can be fixed:
+
+ "There are 5 common DCs available in Win95. These are aquired when you call
+ GetDC or GetDCEx from a window that does _not_ have the OWNDC flag.
+ OWNDC flagged windows do not get their DC from the common DC pool, the issue
+ is they require 800 bytes each from the limited 64Kb local heap for GDI."
+
+ "The deal is, if you hold onto one of the 5 shared DC's too long (as GL apps
+ do), Win95 will actually "steal" it from you. MakeCurrent fails,
+ apparently, because Windows re-assigns the HDC to a different window. The
+ only way to prevent this, the only reliable means, is to set CS_OWNDC."
+ */
+
+ WNDCLASS wndclass;
+
+ // the fields which are common to all classes
+ wndclass.lpfnWndProc = (WNDPROC)wxWndProc;
+ wndclass.cbClsExtra = 0;
+ wndclass.cbWndExtra = sizeof( DWORD ); // VZ: what is this DWORD used for?
+ wndclass.hInstance = wxhInstance;
+ wndclass.hIcon = (HICON) NULL;
+ wndclass.hCursor = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
+ wndclass.lpszMenuName = NULL;
+
+ // Register the GLCanvas class name
+ wndclass.hbrBackground = (HBRUSH)NULL;
+ wndclass.lpszClassName = wxGLCanvasClassName;
+ wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_OWNDC;
+
+ if ( !::RegisterClass(&wndclass) )
+ {
+ wxLogLastError(wxT("RegisterClass(wxGLCanvasClass)"));
+ return false;
+ }
+
+ // Register the GLCanvas class name for windows which don't do full repaint
+ // on resize
+ wndclass.lpszClassName = wxGLCanvasClassNameNoRedraw;
+ wndclass.style &= ~(CS_HREDRAW | CS_VREDRAW);
+
+ if ( !::RegisterClass(&wndclass) )
+ {
+ wxLogLastError(wxT("RegisterClass(wxGLCanvasClassNameNoRedraw)"));
+
+ ::UnregisterClass(wxGLCanvasClassName, wxhInstance);
+
+ return false;
+ }
+
+ ms_registeredGLClasses = true;
+
+ return true;
+}
+
+/* static */
+void wxGLModule::UnregisterClasses()
+{
+ // we need to unregister the classes in case we're in a DLL which is
+ // unloaded and then loaded again because if we don't, the registration is
+ // going to fail in wxGLCanvas::Create() the next time we're loaded
+ if ( ms_registeredGLClasses )
+ {
+ ::UnregisterClass(wxGLCanvasClassName, wxhInstance);
+ ::UnregisterClass(wxGLCanvasClassNameNoRedraw, wxhInstance);
+
+ ms_registeredGLClasses = false;
+ }
+}
+
/*
* GLContext implementation
*/
m_hDC = win->GetHDC();
m_glContext = wglCreateContext((HDC) m_hDC);
- wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGl context") );
+ wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGL context") );
wglMakeCurrent((HDC) m_hDC, m_glContext);
}
m_hDC = win->GetHDC();
m_glContext = wglCreateContext((HDC) m_hDC);
- wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGl context") );
+ wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGL context") );
if( other != 0 )
wglShareLists( other->m_glContext, m_glContext );
{
wglMakeCurrent((HDC) m_hDC, m_glContext);
}
-
- /*
- setupPixelFormat(hDC);
- setupPalette(hDC);
- */
}
void wxGLContext::SetColour(const wxChar *colour)
if ( ret )
{
SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
- SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
}
m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
SetupPixelFormat(attribList);
SetupPalette(palette);
- m_glContext = new wxGLContext(TRUE, this, palette);
+ m_glContext = new wxGLContext(true, this, palette);
}
wxGLCanvas::wxGLCanvas( wxWindow *parent,
if ( ret )
{
SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
- SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
}
m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
SetupPixelFormat(attribList);
SetupPalette(palette);
- m_glContext = new wxGLContext(TRUE, this, palette, shared );
+ m_glContext = new wxGLContext(true, this, palette, shared );
}
// Not very useful for wxMSW, but this is to be wxGTK compliant
if ( ret )
{
SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
- SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
}
m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
wxGLContext *sharedContext=0;
if (shared) sharedContext=shared->GetContext();
- m_glContext = new wxGLContext(TRUE, this, palette, sharedContext );
+ m_glContext = new wxGLContext(true, this, palette, sharedContext );
}
wxGLCanvas::~wxGLCanvas()
{
- if (m_glContext)
- delete m_glContext;
+ delete m_glContext;
::ReleaseDC((HWND) GetHWND(), (HDC) m_hDC);
}
long style,
const wxString& name)
{
- static bool s_registeredGLCanvasClass = FALSE;
-
- // We have to register a special window class because we need
- // the CS_OWNDC style for GLCanvas.
-
- /*
- From Angel Popov <jumpo@bitex.com>
-
- Here are two snips from a dicussion in the OpenGL Gamedev list that explains
- how this problem can be fixed:
-
- "There are 5 common DCs available in Win95. These are aquired when you call
- GetDC or GetDCEx from a window that does _not_ have the OWNDC flag.
- OWNDC flagged windows do not get their DC from the common DC pool, the issue
- is they require 800 bytes each from the limited 64Kb local heap for GDI."
-
- "The deal is, if you hold onto one of the 5 shared DC's too long (as GL apps
- do), Win95 will actually "steal" it from you. MakeCurrent fails,
- apparently, because Windows re-assigns the HDC to a different window. The
- only way to prevent this, the only reliable means, is to set CS_OWNDC."
- */
-
- if (!s_registeredGLCanvasClass)
- {
- WNDCLASS wndclass;
+ wxCHECK_MSG( parent, false, wxT("can't create wxWindow without parent") );
- // the fields which are common to all classes
- wndclass.lpfnWndProc = (WNDPROC)wxWndProc;
- wndclass.cbClsExtra = 0;
- wndclass.cbWndExtra = sizeof( DWORD ); // VZ: what is this DWORD used for?
- wndclass.hInstance = wxhInstance;
- wndclass.hIcon = (HICON) NULL;
- wndclass.hCursor = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
- wndclass.lpszMenuName = NULL;
-
- // Register the GLCanvas class name
- wndclass.hbrBackground = (HBRUSH)NULL;
- wndclass.lpszClassName = wxGLCanvasClassName;
- wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_OWNDC;
-
- if ( !::RegisterClass(&wndclass) )
+ if ( !wxGLModule::RegisterClasses() )
{
- wxLogLastError(wxT("RegisterClass(wxGLCanvasClass)"));
- return FALSE;
- }
+ wxLogError(_("Failed to register OpenGL window class."));
- // Register the GLCanvas class name for windows which don't do full repaint
- // on resize
- wndclass.lpszClassName = wxGLCanvasClassNameNoRedraw;
- wndclass.style &= ~(CS_HREDRAW | CS_VREDRAW);
-
- if ( !::RegisterClass(&wndclass) )
- {
- wxLogLastError(wxT("RegisterClass(wxGLCanvasClassNameNoRedraw)"));
-
- ::UnregisterClass(wxGLCanvasClassName, wxhInstance);
-
- return FALSE;
+ return false;
}
- s_registeredGLCanvasClass = TRUE;
- }
-
- wxCHECK_MSG( parent, FALSE, wxT("can't create wxWindow without parent") );
+ if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
+ return false;
- if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
- return FALSE;
+ parent->AddChild(this);
- parent->AddChild(this);
+ DWORD msflags = 0;
- DWORD msflags = 0;
+ /*
+ A general rule with OpenGL and Win32 is that any window that will have a
+ HGLRC built for it must have two flags: WS_CLIPCHILDREN & WS_CLIPSIBLINGS.
+ You can find references about this within the knowledge base and most OpenGL
+ books that contain the wgl function descriptions.
+ */
- /*
- A general rule with OpenGL and Win32 is that any window that will have a
- HGLRC built for it must have two flags: WS_CLIPCHILDREN & WS_CLIPSIBLINGS.
- You can find references about this within the knowledge base and most OpenGL
- books that contain the wgl function descriptions.
- */
+ WXDWORD exStyle = 0;
+ msflags |= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
+ msflags |= MSWGetStyle(style, & exStyle) ;
- WXDWORD exStyle = 0;
- msflags |= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
- msflags |= MSWGetStyle(style, & exStyle) ;
-
- return MSWCreate(wxGLCanvasClassName, NULL, pos, size, msflags, exStyle);
+ return MSWCreate(wxGLCanvasClassName, NULL, pos, size, msflags, exStyle);
}
static void AdjustPFDForAttributes(PIXELFORMATDESCRIPTOR& pfd, int *attribList)
pfd.iPixelType = PFD_TYPE_RGBA;
break;
case WX_GL_BUFFER_SIZE:
- pfd.cColorBits = attribList[arg++];
+ pfd.cColorBits = (BYTE)attribList[arg++];
break;
case WX_GL_LEVEL:
// this member looks like it may be obsolete
pfd.dwFlags |= PFD_STEREO;
break;
case WX_GL_AUX_BUFFERS:
- pfd.cAuxBuffers = attribList[arg++];
+ pfd.cAuxBuffers = (BYTE)attribList[arg++];
break;
case WX_GL_MIN_RED:
- pfd.cColorBits += (pfd.cRedBits = attribList[arg++]);
+ pfd.cColorBits = (BYTE)(pfd.cColorBits + (pfd.cRedBits = (BYTE)attribList[arg++]));
break;
case WX_GL_MIN_GREEN:
- pfd.cColorBits += (pfd.cGreenBits = attribList[arg++]);
+ pfd.cColorBits = (BYTE)(pfd.cColorBits + (pfd.cGreenBits = (BYTE)attribList[arg++]));
break;
case WX_GL_MIN_BLUE:
- pfd.cColorBits += (pfd.cBlueBits = attribList[arg++]);
+ pfd.cColorBits = (BYTE)(pfd.cColorBits + (pfd.cBlueBits = (BYTE)attribList[arg++]));
break;
case WX_GL_MIN_ALPHA:
// doesn't count in cColorBits
- pfd.cAlphaBits = attribList[arg++];
+ pfd.cAlphaBits = (BYTE)attribList[arg++];
break;
case WX_GL_DEPTH_SIZE:
- pfd.cDepthBits = attribList[arg++];
+ pfd.cDepthBits = (BYTE)attribList[arg++];
break;
case WX_GL_STENCIL_SIZE:
- pfd.cStencilBits = attribList[arg++];
+ pfd.cStencilBits = (BYTE)attribList[arg++];
break;
case WX_GL_MIN_ACCUM_RED:
- pfd.cAccumBits += (pfd.cAccumRedBits = attribList[arg++]);
+ pfd.cAccumBits = (BYTE)(pfd.cAccumBits + (pfd.cAccumRedBits = (BYTE)attribList[arg++]));
break;
case WX_GL_MIN_ACCUM_GREEN:
- pfd.cAccumBits += (pfd.cAccumGreenBits = attribList[arg++]);
+ pfd.cAccumBits = (BYTE)(pfd.cAccumBits + (pfd.cAccumGreenBits = (BYTE)attribList[arg++]));
break;
case WX_GL_MIN_ACCUM_BLUE:
- pfd.cAccumBits += (pfd.cAccumBlueBits = attribList[arg++]);
+ pfd.cAccumBits = (BYTE)(pfd.cAccumBits + (pfd.cAccumBlueBits = (BYTE)attribList[arg++]));
break;
case WX_GL_MIN_ACCUM_ALPHA:
- pfd.cAccumBits += (pfd.cAccumAlphaBits = attribList[arg++]);
+ pfd.cAccumBits = (BYTE)(pfd.cAccumBits + (pfd.cAccumAlphaBits = (BYTE)attribList[arg++]));
break;
default:
break;
PFD_DRAW_TO_WINDOW |
PFD_DOUBLEBUFFER, /* support double-buffering */
PFD_TYPE_RGBA, /* color type */
- 16, /* prefered color depth */
+ 16, /* preferred color depth */
0, 0, 0, 0, 0, 0, /* color bits (ignored) */
0, /* no alpha buffer */
0, /* alpha bits (ignored) */
if (m_palette.Ok())
{
- SelectPalette((HDC) m_hDC, (HPALETTE) m_palette.GetHPALETTE(), FALSE);
- RealizePalette((HDC) m_hDC);
+ ::SelectPalette((HDC) m_hDC, (HPALETTE) m_palette.GetHPALETTE(), FALSE);
+ ::RealizePalette((HDC) m_hDC);
}
}
LOGPALETTE* pPal =
(LOGPALETTE*) malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
pPal->palVersion = 0x300;
- pPal->palNumEntries = paletteSize;
+ pPal->palNumEntries = (WORD)paletteSize;
/* build a simple RGB color palette */
{
for (i=0; i<paletteSize; ++i) {
pPal->palPalEntry[i].peRed =
- (((i >> pfd.cRedShift) & redMask) * 255) / redMask;
+ (BYTE)((((i >> pfd.cRedShift) & redMask) * 255) / redMask);
pPal->palPalEntry[i].peGreen =
- (((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
+ (BYTE)((((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask);
pPal->palPalEntry[i].peBlue =
- (((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;
+ (BYTE)((((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask);
pPal->palPalEntry[i].peFlags = 0;
}
}
void wxGLCanvas::SetCurrent()
{
+ // although on MSW it works even if the window is still hidden, it doesn't
+ // under wxGTK and documentation mentions that SetCurrent() can only be
+ // called for a shown window, so check it
+ wxASSERT_MSG( GetParent()->IsShown(),
+ _T("can't make hidden GL canvas current") );
+
if (m_glContext)
{
m_glContext->SetCurrent();
::SelectPalette((HDC) GetHDC(), (HPALETTE) GetPalette()->GetHPALETTE(), FALSE);
::RealizePalette((HDC) GetHDC());
Refresh();
- event.SetPaletteRealized(TRUE);
+ event.SetPaletteRealized(true);
}
else
- event.SetPaletteRealized(FALSE);
+ event.SetPaletteRealized(false);
}
// I think this doesn't have to be propagated to child windows.
{
}
-void glDrawArraysEXT(GLenum mode, GLint first, GLsizei count)
+void glDrawArraysEXT(GLenum WXUNUSED_WITHOUT_GL_EXT_vertex_array(mode),
+ GLint WXUNUSED_WITHOUT_GL_EXT_vertex_array(first),
+ GLsizei WXUNUSED_WITHOUT_GL_EXT_vertex_array(count))
{
#ifdef GL_EXT_vertex_array
static PFNGLDRAWARRAYSEXTPROC proc = 0;
{
}
-void glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
+void glNormalPointerEXT(GLenum WXUNUSED_WITHOUT_GL_EXT_vertex_array(type),
+ GLsizei WXUNUSED_WITHOUT_GL_EXT_vertex_array(stride),
+ GLsizei WXUNUSED_WITHOUT_GL_EXT_vertex_array(count),
+ const GLvoid *WXUNUSED_WITHOUT_GL_EXT_vertex_array(pointer))
{
#ifdef GL_EXT_vertex_array
static PFNGLNORMALPOINTEREXTPROC proc = 0;
{
}
-void glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
+void glVertexPointerEXT(GLint WXUNUSED_WITHOUT_GL_EXT_vertex_array(size),
+ GLenum WXUNUSED_WITHOUT_GL_EXT_vertex_array(type),
+ GLsizei WXUNUSED_WITHOUT_GL_EXT_vertex_array(stride),
+ GLsizei WXUNUSED_WITHOUT_GL_EXT_vertex_array(count),
+ const GLvoid *WXUNUSED_WITHOUT_GL_EXT_vertex_array(pointer))
{
#ifdef GL_EXT_vertex_array
static PFNGLVERTEXPOINTEREXTPROC proc = 0;
PFD_DRAW_TO_WINDOW |
PFD_DOUBLEBUFFER, /* support double-buffering */
PFD_TYPE_RGBA, /* color type */
- 16, /* prefered color depth */
+ 16, /* preferred color depth */
0, 0, 0, 0, 0, 0, /* color bits (ignored) */
0, /* no alpha buffer */
0, /* alpha bits (ignored) */
if (pixelFormat == 0) {
wxLogError(_("Failed to initialize OpenGL"));
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
wxGLApp::~wxGLApp()
projects / wxWidgets.git / blobdiff