Menu
▾
▴
[openvrml-commit] openvrml/lib/gtkglext/gdk/win32 .cvsignore, NONE, 1.2.2.1 Makefile.am, NONE, 1.2.2.1 gdkglconfig-win32.c, NONE, 1.1.1.1.4.1 gdkglconfig-win32.h, NONE, 1.1.1.1.4.1 gdkglcontext-win32.c, NONE, 1.1.1.1.4.1 gdkglcontext-win32.h, NONE, 1.1.1.1.4.1 gdkgldrawable-win32.c, NONE, 1.1.1.1.4.1 gdkglfont-win32.c, NONE, 1.1.1.1.4.1 gdkglpixmap-win32.c, NONE, 1.1.1.1.4.1 gdkglpixmap-win32.h, NONE, 1.1.1.1.4.1 gdkglprivate-win32.h, NONE, 1.1.1.1.4.1 gdkglquery-win32.c, NONE, 1.1.1.1.4.1 gdkglwglext.c, NONE, 1.1.1.1.4.1 gdkglwglext.h, NONE, 1.1.1.1.4.1 gdkglwin32.h, NONE, 1.1.1.1.4.1 gdkglwindow-win32.c, NONE, 1.1.1.1.4.1 gdkglwindow-win32.h, NONE, 1.1.1.1.4.1
Update of /cvsroot/openvrml/openvrml/lib/gtkglext/gdk/win32 In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv7146/lib/gtkglext/gdk/win32 Added Files: Tag: OpenVRML-0_16-BRANCH .cvsignore Makefile.am gdkglconfig-win32.c gdkglconfig-win32.h gdkglcontext-win32.c gdkglcontext-win32.h gdkgldrawable-win32.c gdkglfont-win32.c gdkglpixmap-win32.c gdkglpixmap-win32.h gdkglprivate-win32.h gdkglquery-win32.c gdkglwglext.c gdkglwglext.h gdkglwin32.h gdkglwindow-win32.c gdkglwindow-win32.h Log Message: Build/package the GtkPlug application separately from the Mozilla plug-in. The Mozilla plug-in is just one possible client for this application. --- NEW FILE: .cvsignore --- Makefile.in --- NEW FILE: gdkglcontext-win32.h --- /* GdkGLExt - OpenGL Extension to GDK * Copyright (C) 2002-2004 Naofumi Yasufuku * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #ifndef __GDK_GL_CONTEXT_WIN32_H__ #define __GDK_GL_CONTEXT_WIN32_H__ #include <gdk/gdkglcontext.h> #include <gdk/win32/gdkglwin32.h> G_BEGIN_DECLS typedef struct _GdkGLContextImplWin32 GdkGLContextImplWin32; typedef struct _GdkGLContextImplWin32Class GdkGLContextImplWin32Class; #define GDK_TYPE_GL_CONTEXT_IMPL_WIN32 (gdk_gl_context_impl_win32_get_type ()) #define GDK_GL_CONTEXT_IMPL_WIN32(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_GL_CONTEXT_IMPL_WIN32, GdkGLContextImplWin32)) #define GDK_GL_CONTEXT_IMPL_WIN32_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_GL_CONTEXT_IMPL_WIN32, GdkGLContextImplWin32Class)) #define GDK_IS_GL_CONTEXT_IMPL_WIN32(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_GL_CONTEXT_IMPL_WIN32)) #define GDK_IS_GL_CONTEXT_IMPL_WIN32_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_GL_CONTEXT_IMPL_WIN32)) #define GDK_GL_CONTEXT_IMPL_WIN32_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_GL_CONTEXT_IMPL_WIN32, GdkGLContextImplWin32Class)) struct _GdkGLContextImplWin32 { GdkGLContext parent_instance; HGLRC hglrc; GdkGLContext *share_list; int render_type; GdkGLConfig *glconfig; GdkGLDrawable *gldrawable; GdkGLDrawable *gldrawable_read; /* currently unused. */ guint is_destroyed : 1; guint is_foreign : 1; }; struct _GdkGLContextImplWin32Class { GdkGLContextClass parent_class; }; GType gdk_gl_context_impl_win32_get_type (void); G_END_DECLS #endif /* __GDK_GL_CONTEXT_WIN32_H__ */ --- NEW FILE: gdkglconfig-win32.h --- /* GdkGLExt - OpenGL Extension to GDK * Copyright (C) 2002-2004 Naofumi Yasufuku * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #ifndef __GDK_GL_CONFIG_WIN32_H__ #define __GDK_GL_CONFIG_WIN32_H__ #include <gdk/gdkglconfig.h> #include <gdk/win32/gdkglwin32.h> G_BEGIN_DECLS typedef struct _GdkGLConfigImplWin32 GdkGLConfigImplWin32; typedef struct _GdkGLConfigImplWin32Class GdkGLConfigImplWin32Class; #define GDK_TYPE_GL_CONFIG_IMPL_WIN32 (gdk_gl_config_impl_win32_get_type ()) #define GDK_GL_CONFIG_IMPL_WIN32(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_GL_CONFIG_IMPL_WIN32, GdkGLConfigImplWin32)) #define GDK_GL_CONFIG_IMPL_WIN32_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_GL_CONFIG_IMPL_WIN32, GdkGLConfigImplWin32Class)) #define GDK_IS_GL_CONFIG_IMPL_WIN32(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_GL_CONFIG_IMPL_WIN32)) #define GDK_IS_GL_CONFIG_IMPL_WIN32_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_GL_CONFIG_IMPL_WIN32)) #define GDK_GL_CONFIG_IMPL_WIN32_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_GL_CONFIG_IMPL_WIN32, GdkGLConfigImplWin32Class)) struct _GdkGLConfigImplWin32 { GdkGLConfig parent_instance; PIXELFORMATDESCRIPTOR pfd; GdkScreen *screen; GdkColormap *colormap; gint depth; }; struct _GdkGLConfigImplWin32Class { GdkGLConfigClass parent_class; }; GType gdk_gl_config_impl_win32_get_type (void); G_END_DECLS #endif /* __GDK_GL_CONFIG_WIN32_H__ */ --- NEW FILE: gdkglprivate-win32.h --- /* GdkGLExt - OpenGL Extension to GDK * Copyright (C) 2002-2004 Naofumi Yasufuku * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #ifndef __GDK_GL_PRIVATE_WIN32_H__ #define __GDK_GL_PRIVATE_WIN32_H__ #include <gdk/gdkprivate.h> #include <gdk/gdkglprivate.h> #include <gdk/win32/gdkglwin32.h> G_BEGIN_DECLS int _gdk_win32_gl_config_find_pixel_format (HDC hdc, CONST PIXELFORMATDESCRIPTOR* req_pfd, PIXELFORMATDESCRIPTOR* found_pfd); void _gdk_win32_gl_print_pfd (PIXELFORMATDESCRIPTOR *pfd); GdkGLContext *_gdk_win32_gl_context_new (GdkGLDrawable *gldrawable, GdkGLContext *share_list, gboolean direct, int render_type); void _gdk_gl_context_set_gl_drawable (GdkGLContext *glcontext, GdkGLDrawable *gldrawable); /* currently unused. */ /* void _gdk_gl_context_set_gl_drawable_read (GdkGLContext *glcontext, GdkGLDrawable *gldrawable_read); */ #define GDK_GL_CONTEXT_IS_DESTROYED(glcontext) \ ( ((GdkGLContextImplWin32 *) (glcontext))->is_destroyed ) #define GDK_GL_PIXMAP_IS_DESTROYED(glpixmap) \ ( ((GdkGLPixmapImplWin32 *) (glpixmap))->is_destroyed ) #define GDK_GL_WINDOW_IS_DESTROYED(glwindow) \ ( ((GdkGLWindowImplWin32 *) (glwindow))->is_destroyed ) G_END_DECLS #endif /* __GDK_GL_PRIVATE_WIN32_H__ */ --- NEW FILE: gdkglpixmap-win32.h --- /* GdkGLExt - OpenGL Extension to GDK * Copyright (C) 2002-2004 Naofumi Yasufuku * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #ifndef __GDK_GL_PIXMAP_WIN32_H__ #define __GDK_GL_PIXMAP_WIN32_H__ #include <gdk/gdkglpixmap.h> #include <gdk/win32/gdkglwin32.h> G_BEGIN_DECLS typedef struct _GdkGLPixmapImplWin32 GdkGLPixmapImplWin32; typedef struct _GdkGLPixmapImplWin32Class GdkGLPixmapImplWin32Class; #define GDK_TYPE_GL_PIXMAP_IMPL_WIN32 (gdk_gl_pixmap_impl_win32_get_type ()) #define GDK_GL_PIXMAP_IMPL_WIN32(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_GL_PIXMAP_IMPL_WIN32, GdkGLPixmapImplWin32)) #define GDK_GL_PIXMAP_IMPL_WIN32_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_GL_PIXMAP_IMPL_WIN32, GdkGLPixmapImplWin32Class)) #define GDK_IS_GL_PIXMAP_IMPL_WIN32(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_GL_PIXMAP_IMPL_WIN32)) #define GDK_IS_GL_PIXMAP_IMPL_WIN32_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_GL_PIXMAP_IMPL_WIN32)) #define GDK_GL_PIXMAP_IMPL_WIN32_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_GL_PIXMAP_IMPL_WIN32, GdkGLPixmapImplWin32Class)) struct _GdkGLPixmapImplWin32 { GdkGLPixmap parent_instance; GdkPixmap *pixmap_gl; int width; int height; PIXELFORMATDESCRIPTOR pfd; int pixel_format; GdkGLConfig *glconfig; /*< private >*/ HDC hdc_gl; HDC hdc_gdk; HBITMAP hbitmap_gdk; guint is_destroyed : 1; }; struct _GdkGLPixmapImplWin32Class { GdkGLPixmapClass parent_class; }; GType gdk_gl_pixmap_impl_win32_get_type (void); #define GDK_GL_PIXMAP_IMPL_WIN32_HDC_GET(impl) \ ( (impl)->hdc_gl ) #define GDK_GL_PIXMAP_IMPL_WIN32_HDC_RELEASE(impl) \ ( (void) 0 ) G_END_DECLS #endif /* __GDK_GL_PIXMAP_WIN32_H__ */ --- NEW FILE: gdkglfont-win32.c --- /* GdkGLExt - OpenGL Extension to GDK * Copyright (C) 2002-2004 Naofumi Yasufuku * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #include <pango/pangowin32.h> #include "gdkglwin32.h" #include "gdkglprivate-win32.h" #include "gdkglfont.h" #ifdef GDKGLEXT_MULTIHEAD_SUPPORT #include <gdk/gdkdisplay.h> #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ PangoFont * gdk_gl_font_use_pango_font (const PangoFontDescription *font_desc, int first, int count, int list_base) { PangoFontMap *font_map; PangoFont *font = NULL; LOGFONT *logfont = NULL; PangoWin32FontCache *font_cache; HFONT hfont; HDC hdc; g_return_val_if_fail (font_desc != NULL, NULL); GDK_GL_NOTE_FUNC (); font_map = pango_win32_font_map_for_display (); font = pango_font_map_load_font (font_map, NULL, font_desc); if (font == NULL) { g_warning ("cannot load PangoFont"); goto FAIL; } logfont = pango_win32_font_logfont (font); if (logfont == NULL) { g_warning ("cannot get LOGFONT struct"); font = NULL; goto FAIL; } font_cache = pango_win32_font_map_get_font_cache (font_map); hfont = pango_win32_font_cache_load (font_cache, logfont); hdc = CreateCompatibleDC (NULL); if (hdc == NULL) { g_warning ("cannot create a memory DC"); font = NULL; goto FAIL; } SelectObject (hdc, hfont); if (!wglUseFontBitmaps (hdc, first, count, list_base)) { g_warning ("cannot create the font display lists"); font = NULL; goto FAIL; } if (!DeleteDC (hdc)) g_warning ("cannot delete the memory DC"); pango_win32_font_cache_unload (font_cache, hfont); FAIL: if (logfont != NULL) g_free (logfont); return font; } #ifdef GDKGLEXT_MULTIHEAD_SUPPORT PangoFont * gdk_gl_font_use_pango_font_for_display (GdkDisplay *display, const PangoFontDescription *font_desc, int first, int count, int list_base) { return gdk_gl_font_use_pango_font (font_desc, first, count, list_base); } #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ --- NEW FILE: gdkglwin32.h --- /* GdkGLExt - OpenGL Extension to GDK * Copyright (C) 2002-2004 Naofumi Yasufuku * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #ifndef __GDK_GL_WIN32_H__ #define __GDK_GL_WIN32_H__ #include <gdk/gdkwin32.h> #ifndef STRICT #define STRICT /* We want strict type checks */ #endif #define WIN32_LEAN_AND_MEAN 1 #include <windows.h> #include <GL/gl.h> #include <gdk/win32/gdkglwglext.h> /* MinGW's wingdi.h bug. */ #ifndef PFD_SWAP_LAYER_BUFFERS #define PFD_SWAP_LAYER_BUFFERS 0x00000800 #endif G_BEGIN_DECLS gboolean gdk_win32_gl_query_wgl_extension (GdkGLConfig *glconfig, const char *extension); GdkGLConfig *gdk_win32_gl_config_new_from_pixel_format (int pixel_format); PIXELFORMATDESCRIPTOR *gdk_win32_gl_config_get_pfd (GdkGLConfig *glconfig); GdkGLContext *gdk_win32_gl_context_foreign_new (GdkGLConfig *glconfig, GdkGLContext *share_list, HGLRC hglrc); HGLRC gdk_win32_gl_context_get_hglrc (GdkGLContext *glcontext); HDC gdk_win32_gl_drawable_hdc_get (GdkGLDrawable *gldrawable); void gdk_win32_gl_drawable_hdc_release (GdkGLDrawable *gldrawable); PIXELFORMATDESCRIPTOR *gdk_win32_gl_pixmap_get_pfd (GdkGLPixmap *glpixmap); int gdk_win32_gl_pixmap_get_pixel_format (GdkGLPixmap *glpixmap); PIXELFORMATDESCRIPTOR *gdk_win32_gl_window_get_pfd (GdkGLWindow *glwindow); int gdk_win32_gl_window_get_pixel_format (GdkGLWindow *glwindow); #ifdef INSIDE_GDK_GL_WIN32 #define GDK_GL_CONFIG_PFD(glconfig) (&(GDK_GL_CONFIG_IMPL_WIN32 (glconfig)->pfd)) #define GDK_GL_CONTEXT_HGLRC(glcontext) (GDK_GL_CONTEXT_IMPL_WIN32 (glcontext)->hglrc) #define GDK_GL_PIXMAP_PFD(glpixmap) (&(GDK_GL_PIXMAP_IMPL_WIN32 (glpixmap)->pfd)) #define GDK_GL_PIXMAP_PIXEL_FORMAT(glpixmap) (GDK_GL_PIXMAP_IMPL_WIN32 (glpixmap)->pixel_format) #define GDK_GL_WINDOW_PFD(glwindow) (&(GDK_GL_WINDOW_IMPL_WIN32 (glwindow)->pfd)) #define GDK_GL_WINDOW_PIXEL_FORMAT(glwindow) (GDK_GL_WINDOW_IMPL_WIN32 (glwindow)->pixel_format) #else #define GDK_GL_CONFIG_PFD(glconfig) (gdk_win32_gl_config_get_pfd (glconfig)) #define GDK_GL_CONTEXT_HGLRC(glcontext) (gdk_win32_gl_context_get_hglrc (glcontext)) #define GDK_GL_PIXMAP_PFD(glpixmap) (gdk_win32_gl_pixmap_get_pfd (glpixmap)) #define GDK_GL_PIXMAP_PIXEL_FORMAT(glpixmap) (gdk_win32_gl_pixmap_get_pixel_format (glpixmap)) #define GDK_GL_WINDOW_PFD(glwindow) (gdk_win32_gl_window_get_pfd (glwindow)) #define GDK_GL_WINDOW_PIXEL_FORMAT(glwindow) (gdk_win32_gl_window_get_pixel_format (glwindow)) #endif G_END_DECLS #endif /* __GDK_GL_WIN32_H__ */ --- NEW FILE: gdkglcontext-win32.c --- /* GdkGLExt - OpenGL Extension to GDK * Copyright (C) 2002-2004 Naofumi Yasufuku * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #include "gdkglwin32.h" #include "gdkglprivate-win32.h" #include "gdkglconfig-win32.h" #include "gdkglcontext-win32.h" static void gdk_gl_context_insert (GdkGLContext *glcontext); static void gdk_gl_context_remove (GdkGLContext *glcontext); static GdkGLContext *gdk_gl_context_lookup (HGLRC hglrc); static guint gdk_gl_context_hash (HGLRC *hglrc); static gboolean gdk_gl_context_equal (HGLRC *a, HGLRC *b); static void gdk_gl_context_impl_win32_class_init (GdkGLContextImplWin32Class *klass); static void gdk_gl_context_impl_win32_finalize (GObject *object); static gpointer parent_class = NULL; GType gdk_gl_context_impl_win32_get_type (void) { static GType type = 0; if (!type) { static const GTypeInfo type_info = { sizeof (GdkGLContextImplWin32Class), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gdk_gl_context_impl_win32_class_init, (GClassFinalizeFunc) NULL, NULL, /* class_data */ sizeof (GdkGLContextImplWin32), 0, /* n_preallocs */ (GInstanceInitFunc) NULL }; type = g_type_register_static (GDK_TYPE_GL_CONTEXT, "GdkGLContextImplWin32", &type_info, 0); } return type; } static void gdk_gl_context_impl_win32_class_init (GdkGLContextImplWin32Class *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GDK_GL_NOTE_FUNC_PRIVATE (); parent_class = g_type_class_peek_parent (klass); object_class->finalize = gdk_gl_context_impl_win32_finalize; } void _gdk_gl_context_destroy (GdkGLContext *glcontext) { GdkGLContextImplWin32 *impl = GDK_GL_CONTEXT_IMPL_WIN32 (glcontext); GDK_GL_NOTE_FUNC_PRIVATE (); if (impl->is_destroyed) return; gdk_gl_context_remove (glcontext); if (impl->hglrc == wglGetCurrentContext ()) { glFinish (); GDK_GL_NOTE_FUNC_IMPL ("wglMakeCurrent"); wglMakeCurrent (NULL, NULL); } if (!impl->is_foreign) { GDK_GL_NOTE_FUNC_IMPL ("wglDeleteContext"); wglDeleteContext (impl->hglrc); impl->hglrc = NULL; } if (impl->gldrawable != NULL) { g_object_remove_weak_pointer (G_OBJECT (impl->gldrawable), (gpointer *) &(impl->gldrawable)); impl->gldrawable = NULL; } /* currently unused. */ /* if (impl->gldrawable_read != NULL) { g_object_remove_weak_pointer (G_OBJECT (impl->gldrawable_read), (gpointer *) &(impl->gldrawable_read)); impl->gldrawable_read = NULL; } */ impl->is_destroyed = TRUE; } static void gdk_gl_context_impl_win32_finalize (GObject *object) { GdkGLContextImplWin32 *impl = GDK_GL_CONTEXT_IMPL_WIN32 (object); GDK_GL_NOTE_FUNC_PRIVATE (); _gdk_gl_context_destroy (GDK_GL_CONTEXT (object)); g_object_unref (G_OBJECT (impl->glconfig)); if (impl->share_list != NULL) g_object_unref (G_OBJECT (impl->share_list)); G_OBJECT_CLASS (parent_class)->finalize (object); } static GdkGLContext * gdk_gl_context_new_common (GdkGLConfig *glconfig, GdkGLContext *share_list, int render_type, HGLRC hglrc, gboolean is_foreign) { GdkGLContext *glcontext; GdkGLContextImplWin32 *impl; GDK_GL_NOTE_FUNC_PRIVATE (); /* * Instantiate the GdkGLContextImplWin32 object. */ glcontext = g_object_new (GDK_TYPE_GL_CONTEXT_IMPL_WIN32, NULL); impl = GDK_GL_CONTEXT_IMPL_WIN32 (glcontext); impl->hglrc = hglrc; if (share_list != NULL && GDK_IS_GL_CONTEXT (share_list)) { impl->share_list = share_list; g_object_ref (G_OBJECT (impl->share_list)); } else { impl->share_list = NULL; } impl->render_type = render_type; impl->glconfig = glconfig; g_object_ref (G_OBJECT (impl->glconfig)); impl->gldrawable = NULL; impl->gldrawable_read = NULL; impl->is_foreign = is_foreign; impl->is_destroyed = FALSE; /* * Insert into the GL context hash table. */ gdk_gl_context_insert (glcontext); return glcontext; } /*< private >*/ GdkGLContext * _gdk_win32_gl_context_new (GdkGLDrawable *gldrawable, GdkGLContext *share_list, gboolean direct, int render_type) { GdkGLConfig *glconfig; HDC hdc; HGLRC hglrc; GdkGLContextImplWin32 *share_impl = NULL; GDK_GL_NOTE_FUNC_PRIVATE (); /* * Create an OpenGL rendering context. */ glconfig = gdk_gl_drawable_get_gl_config (gldrawable); /* Get DC. */ hdc = gdk_win32_gl_drawable_hdc_get (gldrawable); if (hdc == NULL) return NULL; GDK_GL_NOTE_FUNC_IMPL ("wglCreateContext"); hglrc = wglCreateContext (hdc); /* Release DC. */ gdk_win32_gl_drawable_hdc_release (gldrawable); if (hglrc == NULL) return NULL; if (share_list != NULL && GDK_IS_GL_CONTEXT (share_list)) { GDK_GL_NOTE_FUNC_IMPL ("wglShareLists"); share_impl = GDK_GL_CONTEXT_IMPL_WIN32 (share_list); if (!wglShareLists (share_impl->hglrc, hglrc)) { wglDeleteContext (hglrc); return NULL; } } /* * Instantiate the GdkGLContextImplWin32 object. */ return gdk_gl_context_new_common (glconfig, share_list, render_type, hglrc, FALSE); } GdkGLContext * gdk_win32_gl_context_foreign_new (GdkGLConfig *glconfig, GdkGLContext *share_list, HGLRC hglrc) { GDK_GL_NOTE_FUNC (); g_return_val_if_fail (GDK_IS_GL_CONFIG_IMPL_WIN32 (glconfig), NULL); g_return_val_if_fail (hglrc != NULL, NULL); /* * Instantiate the GdkGLContextImplWin32 object. */ return gdk_gl_context_new_common (glconfig, share_list, (glconfig->is_rgba) ? GDK_GL_RGBA_TYPE : GDK_GL_COLOR_INDEX_TYPE, hglrc, TRUE); } gboolean gdk_gl_context_copy (GdkGLContext *glcontext, GdkGLContext *src, unsigned long mask) { HGLRC dst_hglrc, src_hglrc; g_return_val_if_fail (GDK_IS_GL_CONTEXT_IMPL_WIN32 (glcontext), FALSE); g_return_val_if_fail (GDK_IS_GL_CONTEXT_IMPL_WIN32 (src), FALSE); dst_hglrc = GDK_GL_CONTEXT_HGLRC (glcontext); if (dst_hglrc == NULL) return FALSE; src_hglrc = GDK_GL_CONTEXT_HGLRC (src); if (src_hglrc == NULL) return FALSE; GDK_GL_NOTE_FUNC_IMPL ("wglCopyContext"); return wglCopyContext (src_hglrc, dst_hglrc, mask); } /*< private >*/ void _gdk_gl_context_set_gl_drawable (GdkGLContext *glcontext, GdkGLDrawable *gldrawable) { GdkGLContextImplWin32 *impl = GDK_GL_CONTEXT_IMPL_WIN32 (glcontext); GDK_GL_NOTE_FUNC_PRIVATE (); if (impl->gldrawable == gldrawable) return; if (impl->gldrawable != NULL) { g_object_remove_weak_pointer (G_OBJECT (impl->gldrawable), (gpointer *) &(impl->gldrawable)); impl->gldrawable = NULL; } if (gldrawable != NULL && GDK_IS_GL_DRAWABLE (gldrawable)) { impl->gldrawable = gldrawable; g_object_add_weak_pointer (G_OBJECT (impl->gldrawable), (gpointer *) &(impl->gldrawable)); } } /*< private >*/ /* currently unused. */ /* void _gdk_gl_context_set_gl_drawable_read (GdkGLContext *glcontext, GdkGLDrawable *gldrawable_read) { GdkGLContextImplWin32 *impl = GDK_GL_CONTEXT_IMPL_WIN32 (glcontext); GDK_GL_NOTE_FUNC_PRIVATE (); if (impl->gldrawable_read == gldrawable_read) return; if (impl->gldrawable_read != NULL) { g_object_remove_weak_pointer (G_OBJECT (impl->gldrawable_read), (gpointer *) &(impl->gldrawable_read)); impl->gldrawable_read = NULL; } if (gldrawable_read != NULL && GDK_IS_GL_DRAWABLE (gldrawable_read)) { impl->gldrawable_read = gldrawable_read; g_object_add_weak_pointer (G_OBJECT (impl->gldrawable_read), (gpointer *) &(impl->gldrawable_read)); } } */ GdkGLDrawable * gdk_gl_context_get_gl_drawable (GdkGLContext *glcontext) { g_return_val_if_fail (GDK_IS_GL_CONTEXT_IMPL_WIN32 (glcontext), NULL); return GDK_GL_CONTEXT_IMPL_WIN32 (glcontext)->gldrawable; } GdkGLConfig * gdk_gl_context_get_gl_config (GdkGLContext *glcontext) { g_return_val_if_fail (GDK_IS_GL_CONTEXT_IMPL_WIN32 (glcontext), NULL); return GDK_GL_CONTEXT_IMPL_WIN32 (glcontext)->glconfig; } GdkGLContext * gdk_gl_context_get_share_list (GdkGLContext *glcontext) { g_return_val_if_fail (GDK_IS_GL_CONTEXT_IMPL_WIN32 (glcontext), NULL); return GDK_GL_CONTEXT_IMPL_WIN32 (glcontext)->share_list; } gboolean gdk_gl_context_is_direct (GdkGLContext *glcontext) { return FALSE; } int gdk_gl_context_get_render_type (GdkGLContext *glcontext) { g_return_val_if_fail (GDK_IS_GL_CONTEXT_IMPL_WIN32 (glcontext), 0); return GDK_GL_CONTEXT_IMPL_WIN32 (glcontext)->render_type; } GdkGLContext * gdk_gl_context_get_current (void) { static GdkGLContext *current = NULL; HGLRC hglrc; GDK_GL_NOTE_FUNC (); hglrc = wglGetCurrentContext (); if (hglrc == NULL) return NULL; if (current && GDK_GL_CONTEXT_HGLRC (current) == hglrc) return current; current = gdk_gl_context_lookup (hglrc); return current; } HGLRC gdk_win32_gl_context_get_hglrc (GdkGLContext *glcontext) { g_return_val_if_fail (GDK_IS_GL_CONTEXT_IMPL_WIN32 (glcontext), NULL); return GDK_GL_CONTEXT_IMPL_WIN32 (glcontext)->hglrc; } /* * GdkGLContext hash table. */ static GHashTable *gl_context_ht = NULL; static void gdk_gl_context_insert (GdkGLContext *glcontext) { GdkGLContextImplWin32 *impl; GDK_GL_NOTE_FUNC_PRIVATE (); g_return_if_fail (GDK_IS_GL_CONTEXT_IMPL_WIN32 (glcontext)); if (gl_context_ht == NULL) { GDK_GL_NOTE (MISC, g_message (" -- Create GL context hash table.")); gl_context_ht = g_hash_table_new ((GHashFunc) gdk_gl_context_hash, (GEqualFunc) gdk_gl_context_equal); } impl = GDK_GL_CONTEXT_IMPL_WIN32 (glcontext); g_hash_table_insert (gl_context_ht, &(impl->hglrc), glcontext); } static void gdk_gl_context_remove (GdkGLContext *glcontext) { GdkGLContextImplWin32 *impl; GDK_GL_NOTE_FUNC_PRIVATE (); g_return_if_fail (GDK_IS_GL_CONTEXT_IMPL_WIN32 (glcontext)); if (gl_context_ht == NULL) return; impl = GDK_GL_CONTEXT_IMPL_WIN32 (glcontext); g_hash_table_remove (gl_context_ht, &(impl->hglrc)); if (g_hash_table_size (gl_context_ht) == 0) { GDK_GL_NOTE (MISC, g_message (" -- Destroy GL context hash table.")); g_hash_table_destroy (gl_context_ht); gl_context_ht = NULL; } } static GdkGLContext * gdk_gl_context_lookup (HGLRC hglrc) { GDK_GL_NOTE_FUNC_PRIVATE (); if (gl_context_ht == NULL) return NULL; return g_hash_table_lookup (gl_context_ht, &hglrc); } static guint gdk_gl_context_hash (HGLRC *hglrc) { return (guint) *hglrc; } static gboolean gdk_gl_context_equal (HGLRC *a, HGLRC *b) { return (*a == *b); } --- NEW FILE: gdkglconfig-win32.c --- /* GdkGLExt - OpenGL Extension to GDK * Copyright (C) 2002-2004 Naofumi Yasufuku * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #include "gdkglwin32.h" #include "gdkglprivate-win32.h" #include "gdkglconfig-win32.h" #ifdef GDKGLEXT_MULTIHEAD_SUPPORT #include <gdk/gdkscreen.h> #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ static void gdk_gl_config_impl_win32_class_init (GdkGLConfigImplWin32Class *klass); static void gdk_gl_config_impl_win32_finalize (GObject *object); static gpointer parent_class = NULL; GType gdk_gl_config_impl_win32_get_type (void) { static GType type = 0; if (!type) { static const GTypeInfo type_info = { sizeof (GdkGLConfigImplWin32Class), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gdk_gl_config_impl_win32_class_init, (GClassFinalizeFunc) NULL, NULL, /* class_data */ sizeof (GdkGLConfigImplWin32), 0, /* n_preallocs */ (GInstanceInitFunc) NULL }; type = g_type_register_static (GDK_TYPE_GL_CONFIG, "GdkGLConfigImplWin32", &type_info, 0); } return type; } static void gdk_gl_config_impl_win32_class_init (GdkGLConfigImplWin32Class *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GDK_GL_NOTE_FUNC_PRIVATE (); parent_class = g_type_class_peek_parent (klass); object_class->finalize = gdk_gl_config_impl_win32_finalize; } static void gdk_gl_config_impl_win32_finalize (GObject *object) { GdkGLConfigImplWin32 *impl = GDK_GL_CONFIG_IMPL_WIN32 (object); GDK_GL_NOTE_FUNC_PRIVATE (); g_object_unref (G_OBJECT (impl->colormap)); G_OBJECT_CLASS (parent_class)->finalize (object); } /* * This code is based on lib/glut/win32_glx.c of GLUT by Nate Robins. */ static void gdk_gl_config_parse_attrib_list (const int *attrib_list, PIXELFORMATDESCRIPTOR *pfd) { int *p; gboolean buffer_size_is_specified = FALSE; BYTE buffer_size; int layer_plane; GDK_GL_NOTE_FUNC_PRIVATE (); memset (pfd, 0, sizeof (PIXELFORMATDESCRIPTOR)); /* Specifies the size of this data structure. */ pfd->nSize = sizeof (PIXELFORMATDESCRIPTOR); /* Specifies the version of this data structure. This value should be set to 1. */ pfd->nVersion = 1; /* Defaults. */ /* A set of bit flags that specify properties of the pixel buffer. PFD_SUPPORT_GDI and PFD_DOUBLEBUFFER are mutually exclusive in the current generic implementation. */ /* PFD_DRAW_TO_WINDOW or PFD_DRAW_TO_BITMAP is not specified at this stage. The flag is set by gdk_gl_(window|pixmap)_new(). */ pfd->dwFlags = PFD_SUPPORT_OPENGL | PFD_SUPPORT_GDI; /* Specifies the type of pixel data. */ pfd->iPixelType = PFD_TYPE_COLORINDEX; /* Specifies the number of color bitplanes in each color buffer. For RGBA pixel types, it is the size of the color buffer, excluding the alpha bitplanes. For color-index pixels, it is the size of the color-index buffer. */ pfd->cColorBits = 32; /* Max */ /* Ignored. Earlier implementations of OpenGL used this member, but it is no longer used. */ layer_plane = 0; pfd->iLayerType = PFD_MAIN_PLANE; p = (int *) attrib_list; while (*p != GDK_GL_ATTRIB_LIST_NONE) { switch (*p) { case GDK_GL_USE_GL: /* The buffer supports OpenGL drawing. */ pfd->dwFlags |= PFD_SUPPORT_OPENGL; break; case GDK_GL_BUFFER_SIZE: /* Specifies the number of color bitplanes in each color buffer. */ pfd->cColorBits = *(++p); buffer_size_is_specified = TRUE; break; case GDK_GL_LEVEL: layer_plane = *(++p); /* Ignored. Earlier implementations of OpenGL used this member, but it is no longer used. */ if (layer_plane > 0) pfd->iLayerType = PFD_OVERLAY_PLANE; else if (layer_plane < 0) pfd->iLayerType = PFD_UNDERLAY_PLANE; break; case GDK_GL_RGBA: /* RGBA pixels. */ pfd->iPixelType = PFD_TYPE_RGBA; break; case GDK_GL_DOUBLEBUFFER: /* The buffer is double-buffered. */ pfd->dwFlags &= ~PFD_SUPPORT_GDI; pfd->dwFlags |= PFD_DOUBLEBUFFER; break; case GDK_GL_STEREO: /* The buffer is stereoscopic. This flag is not supported in the current generic implementation. */ pfd->dwFlags |= PFD_STEREO; break; case GDK_GL_AUX_BUFFERS: /* Specifies the number of auxiliary buffers. Auxiliary buffers are not supported. */ pfd->cAuxBuffers = *(++p); break; case GDK_GL_RED_SIZE: /* Specifies the number of red bitplanes in each RGBA color buffer. Not used by ChoosePixelFormat. */ pfd->cRedBits = *(++p); break; case GDK_GL_GREEN_SIZE: /* Specifies the number of green bitplanes in each RGBA color buffer. Not used by ChoosePixelFormat. */ pfd->cGreenBits = *(++p); break; case GDK_GL_BLUE_SIZE: /* Specifies the number of blue bitplanes in each RGBA color buffer. Not used by ChoosePixelFormat. */ pfd->cBlueBits = *(++p); break; case GDK_GL_ALPHA_SIZE: /* Specifies the number of alpha bitplanes in each RGBA color buffer. Alpha bitplanes are not supported. */ pfd->cAlphaBits = *(++p); break; case GDK_GL_DEPTH_SIZE: /* Specifies the depth of the depth (z-axis) buffer. */ pfd->cDepthBits = *(++p); break; case GDK_GL_STENCIL_SIZE: /* Specifies the depth of the stencil buffer. */ pfd->cStencilBits = *(++p); break; case GDK_GL_ACCUM_RED_SIZE: /* Specifies the number of red bitplanes in the accumulation buffer. Not used by ChoosePixelFormat. */ pfd->cAccumRedBits = *(++p); break; case GDK_GL_ACCUM_GREEN_SIZE: /* Specifies the number of green bitplanes in the accumulation buffer. Not used by ChoosePixelFormat. */ pfd->cAccumGreenBits = *(++p); break; case GDK_GL_ACCUM_BLUE_SIZE: /* Specifies the number of blue bitplanes in the accumulation buffer. Not used by ChoosePixelFormat. */ pfd->cAccumBlueBits = *(++p); break; case GDK_GL_ACCUM_ALPHA_SIZE: /* Specifies the number of alpha bitplanes in the accumulation buffer. Not used by ChoosePixelFormat.*/ pfd->cAccumAlphaBits = *(++p); break; } ++p; } /* If GDK_GL_BUFFER_SIZE is not specified. */ if (!buffer_size_is_specified) { buffer_size = pfd->cRedBits + pfd->cGreenBits + pfd->cBlueBits; if (buffer_size != 0) pfd->cColorBits = buffer_size; } /* Specifies the total number of bitplanes in the accumulation buffer. */ /* Nate Robins says ... I believe that WGL only used the cAccumRedBits, cAccumBlueBits, cAccumGreenBits, and cAccumAlphaBits fields when returning info about the accumulation buffer precision. Only cAccumBits is used for requesting an accumulation buffer. */ pfd->cAccumBits = pfd->cAccumRedBits + pfd->cAccumGreenBits + pfd->cAccumBlueBits + pfd->cAccumAlphaBits; } /* * Find an appropriate pixel format. * Basic idea of this code is ripped from FLTK. */ /*< private >*/ int _gdk_win32_gl_config_find_pixel_format (HDC hdc, CONST PIXELFORMATDESCRIPTOR *req_pfd, PIXELFORMATDESCRIPTOR *found_pfd) { PIXELFORMATDESCRIPTOR pfd, chosen_pfd; int pixel_format = 0; int i; GDK_GL_NOTE_FUNC_PRIVATE (); memset (&chosen_pfd, 0, sizeof (chosen_pfd)); for (i = 1; ; i++) { if (DescribePixelFormat (hdc, i, sizeof (pfd), &pfd) == 0) break; if (~(pfd.dwFlags) & req_pfd->dwFlags) continue; if (pfd.iPixelType != req_pfd->iPixelType) continue; if (pfd.cColorBits < req_pfd->cColorBits) continue; if (pfd.cAlphaBits < req_pfd->cAlphaBits) continue; if (pfd.cAccumBits < req_pfd->cAccumBits) continue; if (pfd.cDepthBits < req_pfd->cDepthBits) continue; if (pfd.cStencilBits < req_pfd->cStencilBits) continue; if (pfd.cAuxBuffers < req_pfd->cAuxBuffers) continue; /* if (pfd.iLayerType != req_pfd->iLayerType) continue; */ /* Check whether pfd is better than chosen_pfd. */ if (pixel_format != 0) { /* Offering overlay is better. */ if ((pfd.bReserved & 0x0f) && !(chosen_pfd.bReserved & 0x0f)) {} /* More color bitplanes is better. */ else if (pfd.cColorBits > chosen_pfd.cColorBits) {} /* pfd is not better than chosen_pfd. */ else continue; } pixel_format = i; chosen_pfd = pfd; } *found_pfd = chosen_pfd; return pixel_format; } /* * Setup PFD. */ static gboolean gdk_gl_config_setup_pfd (CONST PIXELFORMATDESCRIPTOR *req_pfd, PIXELFORMATDESCRIPTOR *pfd) { HDC hdc; PIXELFORMATDESCRIPTOR temp_pfd; PIXELFORMATDESCRIPTOR w_pfd, b_pfd; int w_pf, b_pf; GDK_GL_NOTE_FUNC_PRIVATE (); /* Get DC. */ hdc = GetDC (NULL); if (hdc == NULL) { g_warning ("cannot get DC"); return FALSE; } w_pfd = *req_pfd; w_pfd.dwFlags &= ~PFD_DRAW_TO_BITMAP; w_pfd.dwFlags |= PFD_DRAW_TO_WINDOW; w_pf = _gdk_win32_gl_config_find_pixel_format (hdc, &w_pfd, &w_pfd); GDK_GL_NOTE (MISC, g_message (" -- pixel format for windows = 0x%x", w_pf)); GDK_GL_NOTE (MISC, _gdk_win32_gl_print_pfd (&w_pfd)); b_pfd = *req_pfd; b_pfd.dwFlags &= ~PFD_DRAW_TO_WINDOW; b_pfd.dwFlags |= PFD_DRAW_TO_BITMAP; b_pf = _gdk_win32_gl_config_find_pixel_format (hdc, &b_pfd, &b_pfd); GDK_GL_NOTE (MISC, g_message (" -- pixel format for bitmaps = 0x%x", b_pf)); GDK_GL_NOTE (MISC, _gdk_win32_gl_print_pfd (&b_pfd)); /* Release DC. */ ReleaseDC (NULL, hdc); if (w_pf == 0 && b_pf == 0) return FALSE; if (w_pf == 0) { temp_pfd = b_pfd; temp_pfd.dwFlags = req_pfd->dwFlags; } else if (b_pf == 0) { temp_pfd = w_pfd; temp_pfd.dwFlags = req_pfd->dwFlags; } else { temp_pfd = w_pfd; temp_pfd.dwFlags = req_pfd->dwFlags; if (temp_pfd.cColorBits > b_pfd.cColorBits) { temp_pfd.cColorBits = b_pfd.cColorBits; temp_pfd.cRedBits = b_pfd.cRedBits; temp_pfd.cRedShift = b_pfd.cRedShift; temp_pfd.cGreenBits = b_pfd.cGreenBits; temp_pfd.cGreenShift = b_pfd.cGreenShift; temp_pfd.cBlueBits = b_pfd.cBlueBits; temp_pfd.cBlueShift = b_pfd.cBlueShift; } if (temp_pfd.cAlphaBits > b_pfd.cAlphaBits) { temp_pfd.cAlphaBits = b_pfd.cAlphaBits; temp_pfd.cAlphaShift = b_pfd.cAlphaShift; } if (temp_pfd.cAccumBits > b_pfd.cAccumBits) { temp_pfd.cAccumBits = b_pfd.cAccumBits; temp_pfd.cAccumRedBits = b_pfd.cAccumRedBits; temp_pfd.cAccumGreenBits = b_pfd.cAccumGreenBits; temp_pfd.cAccumBlueBits = b_pfd.cAccumBlueBits; temp_pfd.cAccumAlphaBits = b_pfd.cAccumAlphaBits; } temp_pfd.cDepthBits = MIN (temp_pfd.cDepthBits, b_pfd.cDepthBits); temp_pfd.cStencilBits = MIN (temp_pfd.cStencilBits, b_pfd.cStencilBits); temp_pfd.cAuxBuffers = MIN (temp_pfd.cAuxBuffers, b_pfd.cAuxBuffers); } *pfd = temp_pfd; return TRUE; } /* * Setup colormap. */ /* * !!! RGB palette management should be implemented... */ #ifdef GDKGLEXT_MULTIHEAD_SUPPORT static GdkColormap * gdk_gl_config_setup_colormap (GdkScreen *screen, PIXELFORMATDESCRIPTOR *pfd, gboolean is_rgba) { GDK_GL_NOTE_FUNC_PRIVATE (); if (is_rgba) { /* * For RGBA mode. */ /* System default colormap. */ GDK_GL_NOTE (MISC, g_message (" -- Colormap: system default")); return g_object_ref (G_OBJECT (gdk_screen_get_system_colormap (screen))); } else { /* * For color index mode. */ /* New private colormap. */ GDK_GL_NOTE (MISC, g_message (" -- Colormap: new allocated writable")); return gdk_colormap_new (gdk_screen_get_system_visual (screen), TRUE); } /* not reached */ return NULL; } #else /* GDKGLEXT_MULTIHEAD_SUPPORT */ static GdkColormap * gdk_gl_config_setup_colormap (GdkScreen *screen, PIXELFORMATDESCRIPTOR *pfd, gboolean is_rgba) { GDK_GL_NOTE_FUNC_PRIVATE (); if (is_rgba) { /* * For RGBA mode. */ /* Default colormap. */ GDK_GL_NOTE (MISC, g_message (" -- Colormap: system default")); return g_object_ref (G_OBJECT (gdk_colormap_get_system ())); } else { /* * For color index mode. */ /* New private colormap. */ GDK_GL_NOTE (MISC, g_message (" -- Colormap: new allocated writable")); return gdk_colormap_new (gdk_visual_get_system (), TRUE); } /* not reached */ return NULL; } #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ static void gdk_gl_config_init_attrib (GdkGLConfig *glconfig) { PIXELFORMATDESCRIPTOR *pfd; pfd = GDK_GL_CONFIG_PFD (glconfig); /* RGBA mode? */ glconfig->is_rgba = (pfd->iPixelType == PFD_TYPE_RGBA) ? TRUE : FALSE; /* Layer plane. */ if (pfd->bReserved != 0) { glconfig->layer_plane = pfd->bReserved & 0x0f; if (glconfig->layer_plane == 0) glconfig->layer_plane = -1 * ((pfd->bReserved & 0xf0) >> 4); } else { glconfig->layer_plane = 0; } /* Double buffering is supported? */ glconfig->is_double_buffered = (pfd->dwFlags & PFD_DOUBLEBUFFER) ? TRUE : FALSE; /* Stereo is supported? (not work on Windows) */ glconfig->is_stereo = (pfd->dwFlags & PFD_STEREO) ? TRUE : FALSE; /* Number of aux buffers */ glconfig->n_aux_buffers = pfd->cAuxBuffers; /* Has alpha bits? */ glconfig->has_alpha = pfd->cAlphaBits ? TRUE : FALSE; /* Has depth buffer? */ glconfig->has_depth_buffer = pfd->cDepthBits ? TRUE : FALSE; /* Has stencil buffer? */ glconfig->has_stencil_buffer = pfd->cStencilBits ? TRUE : FALSE; /* Has accumulation buffer? */ glconfig->has_accum_buffer = pfd->cAccumBits ? TRUE : FALSE; /* Number of multisample buffers (not supported yet) */ glconfig->n_sample_buffers = 0; } static GdkGLConfig * gdk_gl_config_new_common (GdkScreen *screen, const int *attrib_list) { GdkGLConfig *glconfig; GdkGLConfigImplWin32 *impl; PIXELFORMATDESCRIPTOR pfd; GDK_GL_NOTE_FUNC_PRIVATE (); /* * Parse GLX style attrib_list. */ gdk_gl_config_parse_attrib_list (attrib_list, &pfd); GDK_GL_NOTE (MISC, _gdk_win32_gl_print_pfd (&pfd)); /* * Setup PFD. */ if (!gdk_gl_config_setup_pfd (&pfd, &pfd)) return NULL; GDK_GL_NOTE (MISC, g_message (" -- created PFD")); GDK_GL_NOTE (MISC, _gdk_win32_gl_print_pfd (&pfd)); /* * Instantiate the GdkGLConfigImplWin32 object. */ glconfig = g_object_new (GDK_TYPE_GL_CONFIG_IMPL_WIN32, NULL); impl = GDK_GL_CONFIG_IMPL_WIN32 (glconfig); impl->pfd = pfd; impl->screen = screen; /* * Get an appropriate colormap. */ impl->colormap = gdk_gl_config_setup_colormap (screen, &pfd, (pfd.iPixelType == PFD_TYPE_RGBA)); /* * Set depth (number of bits per pixel). */ impl->depth = pfd.cRedBits + pfd.cGreenBits + pfd.cBlueBits; /* * Init configuration attributes. */ gdk_gl_config_init_attrib (glconfig); return glconfig; } GdkGLConfig * gdk_gl_config_new (const int *attrib_list) { GdkScreen *screen; GDK_GL_NOTE_FUNC (); g_return_val_if_fail (attrib_list != NULL, NULL); #ifdef GDKGLEXT_MULTIHEAD_SUPPORT screen = gdk_screen_get_default (); #else /* GDKGLEXT_MULTIHEAD_SUPPORT */ screen = NULL; #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ return gdk_gl_config_new_common (screen, attrib_list); } #ifdef GDKGLEXT_MULTIHEAD_SUPPORT GdkGLConfig * gdk_gl_config_new_for_screen (GdkScreen *screen, const int *attrib_list) { GDK_GL_NOTE_FUNC (); g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); g_return_val_if_fail (attrib_list != NULL, NULL); return gdk_gl_config_new_common (screen, attrib_list); } #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ GdkGLConfig * gdk_win32_gl_config_new_from_pixel_format (int pixel_format) { GdkGLConfig *glconfig; GdkGLConfigImplWin32 *impl; HDC hdc; PIXELFORMATDESCRIPTOR pfd; int result; GDK_GL_NOTE_FUNC (); /* * Get PFD. */ /* Get DC. */ hdc = GetDC (NULL); if (hdc == NULL) { g_warning ("cannot get DC"); return NULL; } result = DescribePixelFormat (hdc, pixel_format, sizeof (pfd), &pfd); /* Release DC. */ ReleaseDC (NULL, hdc); if (result == 0) return NULL; GDK_GL_NOTE (MISC, g_message (" -- pixel_format = 0x%x", pixel_format)); GDK_GL_NOTE (MISC, _gdk_win32_gl_print_pfd (&pfd)); /* * Instantiate the GdkGLConfigImplWin32 object. */ glconfig = g_object_new (GDK_TYPE_GL_CONFIG_IMPL_WIN32, NULL); impl = GDK_GL_CONFIG_IMPL_WIN32 (glconfig); impl->pfd = pfd; #ifdef GDKGLEXT_MULTIHEAD_SUPPORT impl->screen = gdk_screen_get_default (); #else /* GDKGLEXT_MULTIHEAD_SUPPORT */ impl->screen = NULL; #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ /* * Get an appropriate colormap. */ impl->colormap = gdk_gl_config_setup_colormap (impl->screen, &pfd, (pfd.iPixelType == PFD_TYPE_RGBA)); /* * Set depth (number of bits per pixel). */ impl->depth = pfd.cRedBits + pfd.cGreenBits + pfd.cBlueBits; /* * Init configuration attributes. */ gdk_gl_config_init_attrib (glconfig); return glconfig; } GdkScreen * gdk_gl_config_get_screen (GdkGLConfig *glconfig) { g_return_val_if_fail (GDK_IS_GL_CONFIG_IMPL_WIN32 (glconfig), NULL); return GDK_GL_CONFIG_IMPL_WIN32 (glconfig)->screen; } /* * This code is based on lib/glut/win32_glx.c of GLUT by Nate Robins. */ gboolean gdk_gl_config_get_attrib (GdkGLConfig *glconfig, int attribute, int *value) { GdkGLConfigImplWin32 *impl; g_return_val_if_fail (GDK_IS_GL_CONFIG_IMPL_WIN32 (glconfig), FALSE); impl = GDK_GL_CONFIG_IMPL_WIN32 (glconfig); switch (attribute) { case GDK_GL_USE_GL: if (impl->pfd.dwFlags & PFD_SUPPORT_OPENGL) { *value = 1; /* Mark J. Kilgard says ... XXX Brad's Matrox Millenium II has problems creating color index windows in 24-bit mode (lead to GDI crash) and 32-bit mode (lead to black window). The cColorBits filed of the PIXELFORMATDESCRIPTOR returned claims to have 24 and 32 bits respectively of color indices. 2^24 and 2^32 are ridiculously huge writable colormaps. Assume that if we get back a color index PIXELFORMATDESCRIPTOR with 24 or more bits, the PIXELFORMATDESCRIPTOR doesn't really work and skip it. -mjk */ #if 0 if (impl->pfd.iPixelType == PFD_TYPE_COLORINDEX && impl->pfd.cColorBits >= 24) *value = 0; else *value = 1; #endif } else { *value = 0; } break; case GDK_GL_BUFFER_SIZE: /* Nate Robins says ... KLUDGE: if we're RGBA, return the number of bits/pixel, otherwise, return 8 (we guessed at 256 colors in CI mode). */ if (impl->pfd.iPixelType == PFD_TYPE_RGBA) *value = impl->pfd.cColorBits; else *value = 8; break; case GDK_GL_LEVEL: *value = glconfig->layer_plane; break; case GDK_GL_RGBA: *value = impl->pfd.iPixelType == PFD_TYPE_RGBA; break; case GDK_GL_DOUBLEBUFFER: *value = impl->pfd.dwFlags & PFD_DOUBLEBUFFER; break; case GDK_GL_STEREO: *value = impl->pfd.dwFlags & PFD_STEREO; break; case GDK_GL_AUX_BUFFERS: *value = impl->pfd.cAuxBuffers; break; case GDK_GL_RED_SIZE: *value = impl->pfd.cRedBits; break; case GDK_GL_GREEN_SIZE: *value = impl->pfd.cGreenBits; break; case GDK_GL_BLUE_SIZE: *value = impl->pfd.cBlueBits; break; case GDK_GL_ALPHA_SIZE: *value = impl->pfd.cAlphaBits; break; case GDK_GL_DEPTH_SIZE: *value = impl->pfd.cDepthBits; break; case GDK_GL_STENCIL_SIZE: *value = impl->pfd.cStencilBits; break; case GDK_GL_ACCUM_RED_SIZE: *value = impl->pfd.cAccumRedBits; break; case GDK_GL_ACCUM_GREEN_SIZE: *value = impl->pfd.cAccumGreenBits; break; case GDK_GL_ACCUM_BLUE_SIZE: *value = impl->pfd.cAccumBlueBits; break; case GDK_GL_ACCUM_ALPHA_SIZE: *value = impl->pfd.cAccumAlphaBits; break; default: return FALSE; } return TRUE; } GdkColormap * gdk_gl_config_get_colormap (GdkGLConfig *glconfig) { g_return_val_if_fail (GDK_IS_GL_CONFIG_IMPL_WIN32 (glconfig), NULL); return GDK_GL_CONFIG_IMPL_WIN32 (glconfig)->colormap; } GdkVisual * gdk_gl_config_get_visual (GdkGLConfig *glconfig) { g_return_val_if_fail (GDK_IS_GL_CONFIG_IMPL_WIN32 (glconfig), NULL); return gdk_colormap_get_visual (GDK_GL_CONFIG_IMPL_WIN32 (glconfig)->colormap); } gint gdk_gl_config_get_depth (GdkGLConfig *glconfig) { g_return_val_if_fail (GDK_IS_GL_CONFIG_IMPL_WIN32 (glconfig), 0); return GDK_GL_CONFIG_IMPL_WIN32 (glconfig)->depth; } PIXELFORMATDESCRIPTOR * gdk_win32_gl_config_get_pfd (GdkGLConfig *glconfig) { g_return_val_if_fail (GDK_IS_GL_CONFIG_IMPL_WIN32 (glconfig), NULL); return &(GDK_GL_CONFIG_IMPL_WIN32 (glconfig)->pfd); } /*< private >*/ void _gdk_win32_gl_print_pfd (PIXELFORMATDESCRIPTOR *pfd) { g_message (" -- pfd->dwFlags & PFD_DRAW_TO_WINDOW = %s", (pfd->dwFlags & PFD_DRAW_TO_WINDOW) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_DRAW_TO_BITMAP = %s", (pfd->dwFlags & PFD_DRAW_TO_BITMAP) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_SUPPORT_GDI = %s", (pfd->dwFlags & PFD_SUPPORT_GDI) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_SUPPORT_OPENGL = %s", (pfd->dwFlags & PFD_SUPPORT_OPENGL) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_GENERIC_ACCELERATED = %s", (pfd->dwFlags & PFD_GENERIC_ACCELERATED) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_GENERIC_FORMAT = %s", (pfd->dwFlags & PFD_GENERIC_FORMAT) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_NEED_PALETTE = %s", (pfd->dwFlags & PFD_NEED_PALETTE) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_NEED_SYSTEM_PALETTE = %s", (pfd->dwFlags & PFD_NEED_SYSTEM_PALETTE) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_DOUBLEBUFFER = %s", (pfd->dwFlags & PFD_DOUBLEBUFFER) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_STEREO = %s", (pfd->dwFlags & PFD_STEREO) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_SWAP_LAYER_BUFFERS = %s", (pfd->dwFlags & PFD_SWAP_LAYER_BUFFERS) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_DEPTH_DONTCARE = %s", (pfd->dwFlags & PFD_DEPTH_DONTCARE) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE = %s", (pfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_STEREO_DONTCARE = %s", (pfd->dwFlags & PFD_STEREO_DONTCARE) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_SWAP_COPY = %s", (pfd->dwFlags & PFD_SWAP_COPY) ? "TRUE" : "FALSE"); g_message (" -- pfd->dwFlags & PFD_SWAP_EXCHANGE = %s", (pfd->dwFlags & PFD_SWAP_EXCHANGE) ? "TRUE" : "FALSE"); g_message (" -- pfd->iPixelType = %d (%s)", pfd->iPixelType, (pfd->iPixelType == PFD_TYPE_RGBA) ? "PFD_TYPE_RGBA" : "PFD_TYPE_COLORINDEX"); g_message (" -- pfd->cColorBits = %d", pfd->cColorBits); g_message (" -- pfd->cRedBits = %d", pfd->cRedBits); g_message (" -- pfd->cRedShift = %d", pfd->cRedShift); g_message (" -- pfd->cGreenBits = %d", pfd->cGreenBits); g_message (" -- pfd->cGreenShift = %d", pfd->cGreenShift); g_message (" -- pfd->cBlueBits = %d", pfd->cBlueBits); g_message (" -- pfd->cBlueShift = %d", pfd->cBlueShift); g_message (" -- pfd->cAlphaBits = %d", pfd->cAlphaBits); g_message (" -- pfd->cAlphaShift = %d", pfd->cAlphaShift); g_message (" -- pfd->cAccumBits = %d", pfd->cAccumBits); g_message (" -- pfd->cAccumRedBits = %d", pfd->cAccumRedBits); g_message (" -- pfd->cAccumGreenBits = %d", pfd->cAccumGreenBits); g_message (" -- pfd->cAccumBlueBits = %d", pfd->cAccumBlueBits); g_message (" -- pfd->cAccumAlphaBits = %d", pfd->cAccumAlphaBits); g_message (" -- pfd->cDepthBits = %d", pfd->cDepthBits); g_message (" -- pfd->cStencilBits = %d", pfd->cStencilBits); g_message (" -- pfd->cAuxBuffers = %d", pfd->cAuxBuffers); /* Ignored */ g_message (" -- pfd->iLayerType = %d", pfd->iLayerType); g_message (" -- pfd->bReserved & 0x0f = %d", pfd->bReserved & 0x0f); g_message (" -- (pfd->bReserved & 0xf0) >> 4 = %d", (pfd->bReserved & 0xf0) >> 4); /* Ignored */ g_message (" -- pfd->dwLayerMask = 0x%lx", pfd->dwLayerMask); g_message (" -- pfd->dwVisibleMask = 0x%lx", pfd->dwVisibleMask); g_message (" -- pfd->dwDamageMask = 0x%lx", pfd->dwDamageMask); } --- NEW FILE: gdkglwindow-win32.c --- /* GdkGLExt - OpenGL Extension to GDK * Copyright (C) 2002-2004 Naofumi Yasufuku * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #include "gdkglwin32.h" #include "gdkglprivate-win32.h" #include "gdkglconfig-win32.h" #include "gdkglcontext-win32.h" #include "gdkglwindow-win32.h" static gboolean gdk_gl_window_impl_win32_make_context_current (GdkGLDrawable *draw, GdkGLDrawable *read, GdkGLContext *glcontext); static gboolean gdk_gl_window_impl_win32_is_double_buffered (GdkGLDrawable *gldrawable); static void gdk_gl_window_impl_win32_swap_buffers (GdkGLDrawable *gldrawable); static void gdk_gl_window_impl_win32_wait_gl (GdkGLDrawable *gldrawable); static void gdk_gl_window_impl_win32_wait_gdk (GdkGLDrawable *gldrawable); /* static gboolean gdk_gl_window_impl_win32_gl_begin (GdkGLDrawable *draw, GdkGLDrawable *read, GdkGLContext *glcontext); */ static void gdk_gl_window_impl_win32_gl_end (GdkGLDrawable *gldrawable); static GdkGLConfig *gdk_gl_window_impl_win32_get_gl_config (GdkGLDrawable *gldrawable); static void gdk_gl_window_impl_win32_class_init (GdkGLWindowImplWin32Class *klass); static void gdk_gl_window_impl_win32_finalize (GObject *object); static void gdk_gl_window_impl_win32_gl_drawable_interface_init (GdkGLDrawableClass *iface); static gpointer parent_class = NULL; GType gdk_gl_window_impl_win32_get_type (void) { static GType type = 0; if (!type) { static const GTypeInfo type_info = { sizeof (GdkGLWindowImplWin32Class), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gdk_gl_window_impl_win32_class_init, (GClassFinalizeFunc) NULL, NULL, /* class_data */ sizeof (GdkGLWindowImplWin32), 0, /* n_preallocs */ (GInstanceInitFunc) NULL }; static const GInterfaceInfo gl_drawable_interface_info = { (GInterfaceInitFunc) gdk_gl_window_impl_win32_gl_drawable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL /* interface_data */ }; type = g_type_register_static (GDK_TYPE_GL_WINDOW, "GdkGLWindowImplWin32", &type_info, 0); g_type_add_interface_static (type, GDK_TYPE_GL_DRAWABLE, &gl_drawable_interface_info); } return type; } static void gdk_gl_window_impl_win32_class_init (GdkGLWindowImplWin32Class *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GDK_GL_NOTE_FUNC_PRIVATE (); parent_class = g_type_class_peek_parent (klass); object_class->finalize = gdk_gl_window_impl_win32_finalize; } void _gdk_gl_window_destroy (GdkGLWindow *glwindow) { GdkGLWindowImplWin32 *impl = GDK_GL_WINDOW_IMPL_WIN32 (glwindow); GDK_GL_NOTE_FUNC_PRIVATE (); if (impl->is_destroyed) return; /* Get DC. */ if (impl->hdc == NULL) { impl->hdc = GetDC (impl->hwnd); if (impl->hdc == NULL) return; } if (impl->hdc == wglGetCurrentDC ()) { glFinish (); GDK_GL_NOTE_FUNC_IMPL ("wglMakeCurrent"); wglMakeCurrent (NULL, NULL); } /* Release DC. */ if (impl->need_release_dc) ... [truncated message content] |
