dlls/ddrawex/main.c

   1 /*        DirectDrawEx
   2  *
   3  * Copyright 2006 Ulrich Czekalla
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20
  21 #include "wine/debug.h"
  22
  23 #define COBJMACROS
  24
  25 #include "winbase.h"
  26 #include "wingdi.h"
  27 #include "objbase.h"
  28 #include "rpcproxy.h"
  29
  30 #include "ddraw.h"
  31
  32 #include "initguid.h"
  33 #include "ddrawex_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(ddrawex);
  36
  37 static HINSTANCE instance;
  38
  39 struct ddrawex_class_factory
  40 {
  41     IClassFactory IClassFactory_iface;
  42     LONG ref;
  43     HRESULT (*pfnCreateInstance)(IUnknown *outer, REFIID iid, void **out);
  44 };
  45
  46 static inline struct ddrawex_class_factory *impl_from_IClassFactory(IClassFactory *iface)
  47 {
  48     return CONTAINING_RECORD(iface, struct ddrawex_class_factory, IClassFactory_iface);
  49 }
  50
  51 static HRESULT WINAPI ddrawex_class_factory_QueryInterface(IClassFactory *iface, REFIID riid, void **out)
  52 {
  53     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
  54
  55     if (IsEqualGUID(riid, &IID_IClassFactory)
  56             || IsEqualGUID(riid, &IID_IUnknown))
  57     {
  58         IClassFactory_AddRef(iface);
  59         *out = iface;
  60         return S_OK;
  61     }
  62
  63     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  64
  65     *out = NULL;
  66     return E_NOINTERFACE;
  67 }
  68
  69 static ULONG WINAPI ddrawex_class_factory_AddRef(IClassFactory *iface)
  70 {
  71     struct ddrawex_class_factory *factory = impl_from_IClassFactory(iface);
  72     ULONG refcount = InterlockedIncrement(&factory->ref);
  73
  74     TRACE("%p increasing refcount to %u.\n", iface, refcount);
  75
  76     return refcount;
  77 }
  78
  79 static ULONG WINAPI ddrawex_class_factory_Release(IClassFactory *iface)
  80 {
  81     struct ddrawex_class_factory *factory = impl_from_IClassFactory(iface);
  82     ULONG refcount = InterlockedDecrement(&factory->ref);
  83
  84     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
  85
  86     if (!refcount)
  87         HeapFree(GetProcessHeap(), 0, factory);
  88
  89     return refcount;
  90 }
  91
  92 static HRESULT WINAPI ddrawex_class_factory_CreateInstance(IClassFactory *iface,
  93         IUnknown *outer_unknown, REFIID riid, void **out)
  94 {
  95     struct ddrawex_class_factory *factory = impl_from_IClassFactory(iface);
  96
  97     TRACE("iface %p, outer_unknown %p, riid %s, out %p.\n",
  98             iface, outer_unknown, debugstr_guid(riid), out);
  99
 100     return factory->pfnCreateInstance(outer_unknown, riid, out);
 101 }
 102
 103 static HRESULT WINAPI ddrawex_class_factory_LockServer(IClassFactory *iface, BOOL dolock)
 104 {
 105     FIXME("iface %p, dolock %#x stub!\n", iface, dolock);
 106
 107     return S_OK;
 108 }
 109
 110 static const IClassFactoryVtbl ddrawex_class_factory_vtbl =
 111 {
 112     ddrawex_class_factory_QueryInterface,
 113     ddrawex_class_factory_AddRef,
 114     ddrawex_class_factory_Release,
 115     ddrawex_class_factory_CreateInstance,
 116     ddrawex_class_factory_LockServer,
 117 };
 118
 119 struct ddrawex_factory
 120 {
 121     IDirectDrawFactory IDirectDrawFactory_iface;
 122     LONG ref;
 123 };
 124
 125 static inline struct ddrawex_factory *impl_from_IDirectDrawFactory(IDirectDrawFactory *iface)
 126 {
 127     return CONTAINING_RECORD(iface, struct ddrawex_factory, IDirectDrawFactory_iface);
 128 }
 129
 130 static HRESULT WINAPI ddrawex_factory_QueryInterface(IDirectDrawFactory *iface, REFIID riid, void **out)
 131 {
 132     TRACE("iface %p, riid %s, out %p.\n", iface, debugstr_guid(riid), out);
 133
 134     if (IsEqualGUID(riid, &IID_IDirectDrawFactory)
 135             || IsEqualGUID(riid, &IID_IUnknown))
 136     {
 137         IDirectDrawFactory_AddRef(iface);
 138         *out = iface;
 139         return S_OK;
 140     }
 141
 142     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 143
 144     *out = NULL;
 145     return E_NOINTERFACE;
 146 }
 147
 148 static ULONG WINAPI ddrawex_factory_AddRef(IDirectDrawFactory *iface)
 149 {
 150     struct ddrawex_factory *factory = impl_from_IDirectDrawFactory(iface);
 151     ULONG refcount = InterlockedIncrement(&factory->ref);
 152
 153     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 154
 155     return refcount;
 156 }
 157
 158 static ULONG WINAPI ddrawex_factory_Release(IDirectDrawFactory *iface)
 159 {
 160     struct ddrawex_factory *factory = impl_from_IDirectDrawFactory(iface);
 161     ULONG refcount = InterlockedDecrement(&factory->ref);
 162
 163     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 164
 165     if (!refcount)
 166         HeapFree(GetProcessHeap(), 0, factory);
 167
 168     return refcount;
 169 }
 170
 171 static HRESULT WINAPI ddrawex_factory_DirectDrawEnumerate(IDirectDrawFactory *iface,
 172         LPDDENUMCALLBACKW cb, void *ctx)
 173 {
 174     FIXME("iface %p, cb %p, ctx %p stub!\n", iface, cb, ctx);
 175
 176     return E_FAIL;
 177 }
 178
 179 static const IDirectDrawFactoryVtbl ddrawex_factory_vtbl =
 180 {
 181     ddrawex_factory_QueryInterface,
 182     ddrawex_factory_AddRef,
 183     ddrawex_factory_Release,
 184     ddrawex_factory_CreateDirectDraw,
 185     ddrawex_factory_DirectDrawEnumerate,
 186 };
 187
 188 static HRESULT ddrawex_factory_create(IUnknown *outer_unknown, REFIID riid, void **out)
 189 {
 190     struct ddrawex_factory *factory;
 191     HRESULT hr;
 192
 193     TRACE("outer_unknown %p, riid %s, out %p.\n", outer_unknown, debugstr_guid(riid), out);
 194
 195     if (outer_unknown)
 196         return CLASS_E_NOAGGREGATION;
 197
 198     if (!(factory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*factory))))
 199         return E_OUTOFMEMORY;
 200
 201     factory->IDirectDrawFactory_iface.lpVtbl = &ddrawex_factory_vtbl;
 202
 203     if (FAILED(hr = ddrawex_factory_QueryInterface(&factory->IDirectDrawFactory_iface, riid, out)))
 204         HeapFree(GetProcessHeap(), 0, factory);
 205
 206     return hr;
 207 }
 208
 209 /*******************************************************************************
 210  * DllCanUnloadNow [DDRAWEX.@]  Determines whether the DLL is in use.
 211  */
 212 HRESULT WINAPI DllCanUnloadNow(void)
 213 {
 214     return S_FALSE;
 215 }
 216
 217
 218 /*******************************************************************************
 219  * DllGetClassObject [DDRAWEX.@]
 220  */
 221 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **out)
 222 {
 223     struct ddrawex_class_factory *factory;
 224
 225     TRACE("rclsid %s, riid %s, out %p.\n", debugstr_guid(rclsid), debugstr_guid(riid), out);
 226
 227     if (!IsEqualGUID( &IID_IClassFactory, riid)
 228         && !IsEqualGUID( &IID_IUnknown, riid))
 229         return E_NOINTERFACE;
 230
 231     if (!IsEqualGUID(&CLSID_DirectDrawFactory, rclsid))
 232     {
 233         FIXME("%s: no class found.\n", debugstr_guid(rclsid));
 234         return CLASS_E_CLASSNOTAVAILABLE;
 235     }
 236
 237     factory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*factory));
 238     if (factory == NULL) return E_OUTOFMEMORY;
 239
 240     factory->IClassFactory_iface.lpVtbl = &ddrawex_class_factory_vtbl;
 241     factory->ref = 1;
 242
 243     factory->pfnCreateInstance = ddrawex_factory_create;
 244
 245     *out = factory;
 246
 247     return S_OK;
 248 }
 249
 250
 251 /***********************************************************************
 252  * DllMain
 253  */
 254 BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, void *reserved)
 255 {
 256     switch (reason)
 257     {
 258     case DLL_PROCESS_ATTACH:
 259         instance = inst;
 260         DisableThreadLibraryCalls( inst );
 261         break;
 262     }
 263     return TRUE;
 264 }
 265
 266 /***********************************************************************
 267  *              DllRegisterServer (DDRAWEX.@)
 268  */
 269 HRESULT WINAPI DllRegisterServer(void)
 270 {
 271     return __wine_register_resources( instance );
 272 }
 273
 274 /***********************************************************************
 275  *              DllUnregisterServer (DDRAWEX.@)
 276  */
 277 HRESULT WINAPI DllUnregisterServer(void)
 278 {
 279     return __wine_unregister_resources( instance );
 280 }