mirror of
https://github.com/brl/mutter.git
synced 2024-09-20 14:35:48 -04:00
02a3670e88
* clutter-backend-win32 had an unused variable * clutter-event-win32 was using the abs function without including stdlib.h
619 lines
18 KiB
C
619 lines
18 KiB
C
/* Clutter.
|
|
* An OpenGL based 'interactive canvas' library.
|
|
* Authored By Matthew Allum <mallum@openedhand.com>
|
|
* Copyright (C) 2006-2007 OpenedHand
|
|
*
|
|
* 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 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, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <windows.h>
|
|
|
|
#include "clutter-backend-win32.h"
|
|
#include "clutter-stage-win32.h"
|
|
#include "clutter-win32.h"
|
|
#include "clutter-device-manager-win32.h"
|
|
|
|
#include "clutter-event.h"
|
|
#include "clutter-main.h"
|
|
#include "clutter-device-manager-private.h"
|
|
#include "clutter-debug.h"
|
|
#include "clutter-private.h"
|
|
#include "clutter-stage-private.h"
|
|
#include "clutter-version.h"
|
|
|
|
#include "cogl/cogl.h"
|
|
|
|
G_DEFINE_TYPE (ClutterBackendWin32, clutter_backend_win32,
|
|
CLUTTER_TYPE_BACKEND);
|
|
|
|
typedef int (WINAPI * SwapIntervalProc) (int interval);
|
|
|
|
/* singleton object */
|
|
static ClutterBackendWin32 *backend_singleton = NULL;
|
|
|
|
static gchar *clutter_vblank_name = NULL;
|
|
|
|
static HINSTANCE clutter_hinst = NULL;
|
|
|
|
/* various flags corresponding to pre init setup calls */
|
|
static gboolean _no_event_retrieval = FALSE;
|
|
|
|
gboolean
|
|
clutter_backend_win32_pre_parse (ClutterBackend *backend,
|
|
GError **error)
|
|
{
|
|
const gchar *env_string;
|
|
|
|
if ((env_string = g_getenv ("CLUTTER_VBLANK")))
|
|
clutter_vblank_name = g_strdup (env_string);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_init_events (ClutterBackend *backend)
|
|
{
|
|
ClutterBackendWin32 *backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
|
|
CLUTTER_NOTE (EVENT, "initialising the event loop");
|
|
|
|
backend_win32->device_manager =
|
|
g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_WIN32,
|
|
"backend", backend_win32,
|
|
NULL);
|
|
|
|
if (!_no_event_retrieval)
|
|
_clutter_backend_win32_events_init (backend);
|
|
}
|
|
|
|
HCURSOR
|
|
_clutter_backend_win32_get_invisible_cursor (ClutterBackend *backend)
|
|
{
|
|
ClutterBackendWin32 *backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
|
|
if (backend_win32->invisible_cursor == NULL)
|
|
backend_win32->invisible_cursor =
|
|
LoadCursor (clutter_hinst, MAKEINTRESOURCE (42));
|
|
|
|
return backend_win32->invisible_cursor;
|
|
}
|
|
|
|
static const GOptionEntry entries[] =
|
|
{
|
|
{
|
|
"vblank", 0,
|
|
0,
|
|
G_OPTION_ARG_STRING, &clutter_vblank_name,
|
|
"VBlank method to be used (none, default or wgl)", "METHOD"
|
|
},
|
|
{ NULL }
|
|
};
|
|
|
|
void
|
|
clutter_backend_win32_add_options (ClutterBackend *backend,
|
|
GOptionGroup *group)
|
|
{
|
|
g_option_group_add_entries (group, entries);
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_finalize (GObject *gobject)
|
|
{
|
|
backend_singleton = NULL;
|
|
|
|
timeEndPeriod (1);
|
|
|
|
G_OBJECT_CLASS (clutter_backend_win32_parent_class)->finalize (gobject);
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_dispose (GObject *gobject)
|
|
{
|
|
ClutterBackendWin32 *backend_win32 = CLUTTER_BACKEND_WIN32 (gobject);
|
|
ClutterStageManager *stage_manager;
|
|
|
|
CLUTTER_NOTE (BACKEND, "Disposing the of stages");
|
|
stage_manager = clutter_stage_manager_get_default ();
|
|
|
|
g_object_unref (stage_manager);
|
|
|
|
CLUTTER_NOTE (BACKEND, "Removing the event source");
|
|
_clutter_backend_win32_events_uninit (CLUTTER_BACKEND (backend_win32));
|
|
|
|
/* Unrealize all shaders, since the GL context is going away */
|
|
_clutter_shader_release_all ();
|
|
|
|
if (backend_win32->gl_context)
|
|
{
|
|
wglMakeCurrent (NULL, NULL);
|
|
wglDeleteContext (backend_win32->gl_context);
|
|
backend_win32->gl_context = NULL;
|
|
}
|
|
|
|
if (backend_win32->dummy_dc)
|
|
{
|
|
ReleaseDC (backend_win32->dummy_hwnd, backend_win32->dummy_dc);
|
|
backend_win32->dummy_dc = NULL;
|
|
}
|
|
|
|
if (backend_win32->dummy_hwnd)
|
|
{
|
|
DestroyWindow (backend_win32->dummy_hwnd);
|
|
backend_win32->dummy_hwnd = NULL;
|
|
}
|
|
|
|
G_OBJECT_CLASS (clutter_backend_win32_parent_class)->dispose (gobject);
|
|
}
|
|
|
|
static GObject *
|
|
clutter_backend_win32_constructor (GType gtype,
|
|
guint n_params,
|
|
GObjectConstructParam *params)
|
|
{
|
|
GObjectClass *parent_class;
|
|
GObject *retval;
|
|
|
|
if (!backend_singleton)
|
|
{
|
|
parent_class = G_OBJECT_CLASS (clutter_backend_win32_parent_class);
|
|
retval = parent_class->constructor (gtype, n_params, params);
|
|
|
|
backend_singleton = CLUTTER_BACKEND_WIN32 (retval);
|
|
|
|
return retval;
|
|
}
|
|
|
|
g_warning ("Attempting to create a new backend object. This should "
|
|
"never happen, so we return the singleton instance.");
|
|
|
|
return g_object_ref (backend_singleton);
|
|
}
|
|
|
|
static gboolean
|
|
check_vblank_env (const char *name)
|
|
{
|
|
return clutter_vblank_name && !g_ascii_strcasecmp (clutter_vblank_name, name);
|
|
}
|
|
|
|
ClutterFeatureFlags
|
|
clutter_backend_win32_get_features (ClutterBackend *backend)
|
|
{
|
|
ClutterFeatureFlags flags;
|
|
const gchar *extensions;
|
|
SwapIntervalProc swap_interval;
|
|
ClutterBackendWin32 *backend_win32;
|
|
|
|
/* this will make sure that the GL context exists and is bound to a
|
|
drawable */
|
|
backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
g_return_val_if_fail (backend_win32->gl_context != NULL, 0);
|
|
g_return_val_if_fail (wglGetCurrentDC () != NULL, 0);
|
|
|
|
extensions = (const gchar *) glGetString (GL_EXTENSIONS);
|
|
|
|
CLUTTER_NOTE (BACKEND,
|
|
"Checking features\n"
|
|
" GL_VENDOR: %s\n"
|
|
" GL_RENDERER: %s\n"
|
|
" GL_VERSION: %s\n"
|
|
" GL_EXTENSIONS: %s\n",
|
|
glGetString (GL_VENDOR),
|
|
glGetString (GL_RENDERER),
|
|
glGetString (GL_VERSION),
|
|
extensions);
|
|
|
|
flags = CLUTTER_FEATURE_STAGE_USER_RESIZE
|
|
| CLUTTER_FEATURE_STAGE_CURSOR
|
|
| CLUTTER_FEATURE_STAGE_MULTIPLE;
|
|
|
|
/* If the VBlank should be left at the default or it has been
|
|
disabled elsewhere (eg NVIDIA) then don't bother trying to check
|
|
for the swap control extension */
|
|
if (getenv ("__GL_SYNC_TO_VBLANK") || check_vblank_env ("default"))
|
|
CLUTTER_NOTE (BACKEND, "vblank sync: left at default at user request");
|
|
else if (_cogl_check_extension ("WGL_EXT_swap_control", extensions)
|
|
&& (swap_interval = (SwapIntervalProc)
|
|
cogl_get_proc_address ("wglSwapIntervalEXT")))
|
|
{
|
|
/* According to the specification for the WGL_EXT_swap_control
|
|
extension the default swap interval is 1 anyway, so if no
|
|
vblank is requested then we should explicitly set it to
|
|
zero */
|
|
if (check_vblank_env ("none"))
|
|
{
|
|
if (swap_interval (0))
|
|
CLUTTER_NOTE (BACKEND, "vblank sync: successfully disabled");
|
|
else
|
|
CLUTTER_NOTE (BACKEND, "vblank sync: disabling failed");
|
|
}
|
|
else
|
|
{
|
|
if (swap_interval (1))
|
|
{
|
|
flags |= CLUTTER_FEATURE_SYNC_TO_VBLANK;
|
|
CLUTTER_NOTE (BACKEND, "vblank sync: wglSwapIntervalEXT "
|
|
"vblank setup success");
|
|
}
|
|
else
|
|
CLUTTER_NOTE (BACKEND, "vblank sync: wglSwapIntervalEXT "
|
|
"vblank setup failed");
|
|
}
|
|
}
|
|
else
|
|
CLUTTER_NOTE (BACKEND, "no use-able vblank mechanism found");
|
|
|
|
CLUTTER_NOTE (BACKEND, "backend features checked");
|
|
|
|
return flags;
|
|
}
|
|
|
|
static ATOM
|
|
clutter_backend_win32_get_dummy_window_class ()
|
|
{
|
|
static ATOM klass = 0;
|
|
|
|
if (klass == 0)
|
|
{
|
|
WNDCLASSW wndclass;
|
|
memset (&wndclass, 0, sizeof (wndclass));
|
|
wndclass.lpfnWndProc = DefWindowProc;
|
|
wndclass.hInstance = GetModuleHandleW (NULL);
|
|
wndclass.lpszClassName = L"ClutterBackendWin32DummyWindow";
|
|
klass = RegisterClassW (&wndclass);
|
|
}
|
|
|
|
return klass;
|
|
}
|
|
|
|
static gboolean
|
|
clutter_backend_win32_pixel_format_is_better (const PIXELFORMATDESCRIPTOR *pfa,
|
|
const PIXELFORMATDESCRIPTOR *pfb)
|
|
{
|
|
/* Always prefer a format with a stencil buffer */
|
|
if (pfa->cStencilBits == 0)
|
|
{
|
|
if (pfb->cStencilBits > 0)
|
|
return TRUE;
|
|
}
|
|
else if (pfb->cStencilBits == 0)
|
|
return FALSE;
|
|
|
|
/* Prefer a bigger color buffer */
|
|
if (pfb->cColorBits > pfa->cColorBits)
|
|
return TRUE;
|
|
else if (pfb->cColorBits < pfa->cColorBits)
|
|
return FALSE;
|
|
|
|
/* Prefer a bigger depth buffer */
|
|
return pfb->cDepthBits > pfa->cDepthBits;
|
|
}
|
|
|
|
static int
|
|
clutter_backend_win32_choose_pixel_format (HDC dc, PIXELFORMATDESCRIPTOR *pfd)
|
|
{
|
|
int i, num_formats, best_pf = 0;
|
|
PIXELFORMATDESCRIPTOR best_pfd;
|
|
|
|
num_formats = DescribePixelFormat (dc, 0, sizeof (best_pfd), NULL);
|
|
|
|
for (i = 1; i <= num_formats; i++)
|
|
{
|
|
memset (pfd, 0, sizeof (*pfd));
|
|
|
|
if (DescribePixelFormat (dc, i, sizeof (best_pfd), pfd)
|
|
/* Check whether this format is useable by Clutter */
|
|
&& ((pfd->dwFlags & (PFD_SUPPORT_OPENGL
|
|
| PFD_DRAW_TO_WINDOW
|
|
| PFD_DOUBLEBUFFER
|
|
| PFD_GENERIC_FORMAT))
|
|
== (PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW))
|
|
&& pfd->iPixelType == PFD_TYPE_RGBA
|
|
&& pfd->cColorBits >= 16 && pfd->cColorBits <= 32
|
|
&& pfd->cDepthBits >= 16 && pfd->cDepthBits <= 32
|
|
/* Check whether this is a better format than one we've
|
|
already found */
|
|
&& (best_pf == 0
|
|
|| clutter_backend_win32_pixel_format_is_better (&best_pfd, pfd)))
|
|
{
|
|
best_pf = i;
|
|
best_pfd = *pfd;
|
|
}
|
|
}
|
|
|
|
*pfd = best_pfd;
|
|
|
|
return best_pf;
|
|
}
|
|
|
|
static gboolean
|
|
clutter_backend_win32_create_context (ClutterBackend *backend,
|
|
GError **error)
|
|
{
|
|
ClutterBackendWin32 *backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
|
|
/* COGL assumes that there is always a GL context selected; in order
|
|
* to make sure that a WGL context exists and is made current, we
|
|
* use a small dummy window that never gets shown to which we can
|
|
* always fall back if no stage is available
|
|
*/
|
|
if (backend_win32->dummy_hwnd == NULL)
|
|
{
|
|
ATOM window_class = clutter_backend_win32_get_dummy_window_class ();
|
|
|
|
if (window_class == 0)
|
|
{
|
|
g_critical ("Unable to register window class");
|
|
return FALSE;
|
|
}
|
|
|
|
backend_win32->dummy_hwnd =
|
|
CreateWindowW ((LPWSTR) MAKEINTATOM (window_class),
|
|
L".",
|
|
WS_OVERLAPPEDWINDOW,
|
|
CW_USEDEFAULT,
|
|
CW_USEDEFAULT,
|
|
1, 1,
|
|
NULL, NULL,
|
|
GetModuleHandle (NULL),
|
|
NULL);
|
|
|
|
if (backend_win32->dummy_hwnd == NULL)
|
|
{
|
|
g_critical ("Unable to create dummy window");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (backend_win32->dummy_dc == NULL)
|
|
{
|
|
PIXELFORMATDESCRIPTOR pfd;
|
|
int pf;
|
|
|
|
backend_win32->dummy_dc = GetDC (backend_win32->dummy_hwnd);
|
|
|
|
pf = clutter_backend_win32_choose_pixel_format (backend_win32->dummy_dc,
|
|
&pfd);
|
|
|
|
if (pf == 0 || !SetPixelFormat (backend_win32->dummy_dc, pf, &pfd))
|
|
{
|
|
g_critical ("Unable to find suitable GL pixel format");
|
|
ReleaseDC (backend_win32->dummy_hwnd, backend_win32->dummy_dc);
|
|
backend_win32->dummy_dc = NULL;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (backend_win32->gl_context == NULL)
|
|
{
|
|
backend_win32->gl_context = wglCreateContext (backend_win32->dummy_dc);
|
|
|
|
if (backend_win32->gl_context == NULL)
|
|
{
|
|
g_critical ("Unable to create suitable GL context");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
CLUTTER_NOTE (BACKEND, "Selecting dummy 0x%x for the WGL context",
|
|
(unsigned int) backend_win32->dummy_hwnd);
|
|
|
|
wglMakeCurrent (backend_win32->dummy_dc, backend_win32->gl_context);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_ensure_context (ClutterBackend *backend,
|
|
ClutterStage *stage)
|
|
{
|
|
ClutterStageWindow *impl;
|
|
|
|
if (stage == NULL ||
|
|
CLUTTER_ACTOR_IN_DESTRUCTION (stage) ||
|
|
((impl = _clutter_stage_get_window (stage)) == NULL))
|
|
{
|
|
CLUTTER_NOTE (MULTISTAGE, "Clearing all context");
|
|
|
|
wglMakeCurrent (NULL, NULL);
|
|
}
|
|
else
|
|
{
|
|
ClutterBackendWin32 *backend_win32;
|
|
ClutterStageWin32 *stage_win32;
|
|
|
|
g_return_if_fail (impl != NULL);
|
|
|
|
CLUTTER_NOTE (MULTISTAGE, "Setting context for stage of type %s [%p]",
|
|
g_type_name (G_OBJECT_TYPE (impl)),
|
|
impl);
|
|
|
|
backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
stage_win32 = CLUTTER_STAGE_WIN32 (impl);
|
|
|
|
/* no GL context to set */
|
|
if (backend_win32->gl_context == NULL)
|
|
return;
|
|
|
|
/* we might get here inside the final dispose cycle, so we
|
|
* need to handle this gracefully
|
|
*/
|
|
if (stage_win32->client_dc == NULL)
|
|
{
|
|
CLUTTER_NOTE (MULTISTAGE,
|
|
"Received a stale stage, clearing all context");
|
|
|
|
if (backend_win32->dummy_dc != NULL)
|
|
wglMakeCurrent (backend_win32->dummy_dc,
|
|
backend_win32->gl_context);
|
|
else
|
|
wglMakeCurrent (NULL, NULL);
|
|
}
|
|
else
|
|
{
|
|
CLUTTER_NOTE (BACKEND,
|
|
"MakeCurrent window %p (%s), context %p",
|
|
stage_win32->hwnd,
|
|
stage_win32->is_foreign_win ? "foreign" : "native",
|
|
backend_win32->gl_context);
|
|
wglMakeCurrent (stage_win32->client_dc,
|
|
backend_win32->gl_context);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_redraw (ClutterBackend *backend,
|
|
ClutterStage *stage)
|
|
{
|
|
ClutterStageWin32 *stage_win32;
|
|
ClutterStageWindow *impl;
|
|
|
|
impl = _clutter_stage_get_window (stage);
|
|
if (impl == NULL)
|
|
return;
|
|
|
|
g_return_if_fail (CLUTTER_IS_STAGE_WIN32 (impl));
|
|
|
|
stage_win32 = CLUTTER_STAGE_WIN32 (impl);
|
|
|
|
/* this will cause the stage implementation to be painted */
|
|
_clutter_stage_do_paint (stage, NULL);
|
|
cogl_flush ();
|
|
|
|
if (stage_win32->client_dc)
|
|
SwapBuffers (stage_win32->client_dc);
|
|
}
|
|
|
|
static ClutterStageWindow *
|
|
clutter_backend_win32_create_stage (ClutterBackend *backend,
|
|
ClutterStage *wrapper,
|
|
GError **error)
|
|
{
|
|
ClutterBackendWin32 *backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
ClutterStageWin32 *stage_win32;
|
|
ClutterStageWindow *stage;
|
|
|
|
CLUTTER_NOTE (BACKEND, "Creating stage of type '%s'",
|
|
g_type_name (CLUTTER_STAGE_TYPE));
|
|
|
|
stage = g_object_new (CLUTTER_TYPE_STAGE_WIN32, NULL);
|
|
|
|
/* copy backend data into the stage */
|
|
stage_win32 = CLUTTER_STAGE_WIN32 (stage);
|
|
stage_win32->backend = backend_win32;
|
|
stage_win32->wrapper = wrapper;
|
|
|
|
return stage;
|
|
}
|
|
|
|
static ClutterDeviceManager *
|
|
clutter_backend_win32_get_device_manager (ClutterBackend *backend)
|
|
{
|
|
ClutterBackendWin32 *backend_win32 = CLUTTER_BACKEND_WIN32 (backend);
|
|
|
|
if (G_UNLIKELY (backend_win32->device_manager == NULL))
|
|
{
|
|
backend_win32->device_manager =
|
|
g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_WIN32,
|
|
"backend", backend_win32,
|
|
NULL);
|
|
}
|
|
|
|
return backend_win32->device_manager;
|
|
}
|
|
|
|
/**
|
|
* clutter_win32_disable_event_retrieval
|
|
*
|
|
* Disables retrieval of Windows messages in the main loop. Use to
|
|
* create event-less canvas.
|
|
*
|
|
* This function can only be called before calling clutter_init().
|
|
*
|
|
* Since: 0.8
|
|
*/
|
|
void
|
|
clutter_win32_disable_event_retrieval (void)
|
|
{
|
|
if (_clutter_context_is_initialized ())
|
|
{
|
|
g_warning ("clutter_win32_disable_event_retrieval() can only be "
|
|
"called before clutter_init()");
|
|
return;
|
|
}
|
|
|
|
_no_event_retrieval = TRUE;
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_class_init (ClutterBackendWin32Class *klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
ClutterBackendClass *backend_class = CLUTTER_BACKEND_CLASS (klass);
|
|
|
|
gobject_class->constructor = clutter_backend_win32_constructor;
|
|
gobject_class->dispose = clutter_backend_win32_dispose;
|
|
gobject_class->finalize = clutter_backend_win32_finalize;
|
|
|
|
backend_class->pre_parse = clutter_backend_win32_pre_parse;
|
|
backend_class->init_events = clutter_backend_win32_init_events;
|
|
backend_class->create_stage = clutter_backend_win32_create_stage;
|
|
backend_class->add_options = clutter_backend_win32_add_options;
|
|
backend_class->get_features = clutter_backend_win32_get_features;
|
|
backend_class->redraw = clutter_backend_win32_redraw;
|
|
backend_class->create_context = clutter_backend_win32_create_context;
|
|
backend_class->ensure_context = clutter_backend_win32_ensure_context;
|
|
backend_class->get_device_manager = clutter_backend_win32_get_device_manager;
|
|
}
|
|
|
|
static void
|
|
clutter_backend_win32_init (ClutterBackendWin32 *backend_win32)
|
|
{
|
|
backend_win32->gl_context = NULL;
|
|
backend_win32->invisible_cursor = NULL;
|
|
|
|
/* FIXME: get from GetSystemMetric?
|
|
clutter_backend_set_double_click_time (backend, 250);
|
|
clutter_backend_set_double_click_distance (backend, 5);
|
|
clutter_backend_set_resolution (backend, 96.0);
|
|
*/
|
|
|
|
/* Set the maximum precision for Windows time functions. Without
|
|
this glib will not be able to sleep accurately enough to give a
|
|
reasonable frame rate */
|
|
timeBeginPeriod (1);
|
|
}
|
|
|
|
GType
|
|
_clutter_backend_impl_get_type (void)
|
|
{
|
|
return clutter_backend_win32_get_type ();
|
|
}
|
|
|
|
BOOL WINAPI
|
|
DllMain (HINSTANCE hinst, DWORD reason, LPVOID reserved)
|
|
{
|
|
if (reason == DLL_PROCESS_ATTACH)
|
|
/* Store the module handle so that we can use it to load resources */
|
|
clutter_hinst = hinst;
|
|
|
|
return TRUE;
|
|
}
|