full screen display

BlockingQueue.h

@@ -4,6 +4,8 @@
 #include <deque>
 #include <mutex>
 
+namespace engine {
+
 template <typename T>
 class BlockingQueue {
  private:
@@ -44,3 +46,4 @@ class BlockingQueue {
     return {std::move(rc)};
   }
 };
+} // namespace

COM_ClassFactory.cpp

@@ -0,0 +1,90 @@
+#include "COM_ClassFactory.h"
+#include "COM_ICoverflowControl.h"
+
+void LockModule(BOOL bLock)
+{
+  if (bLock) {
+    InterlockedIncrement(&g_lLocks);
+  } else {
+    InterlockedDecrement(&g_lLocks);
+  }
+}
+
+CoverflowClassFactory::CoverflowClassFactory()
+{
+  m_refCount = 0;
+
+  g_srvObjCount++;
+}
+
+CoverflowClassFactory::~CoverflowClassFactory()
+{
+  g_srvObjCount--;
+}
+
+STDMETHODIMP_(ULONG) CoverflowClassFactory::AddRef()
+{
+  LockModule(TRUE);
+  return 2;
+}
+
+STDMETHODIMP_(ULONG) CoverflowClassFactory::Release()
+{
+  LockModule(FALSE);
+  return 1;
+}
+
+STDMETHODIMP CoverflowClassFactory::QueryInterface(REFIID riid, LPVOID *ppAny)
+{
+#pragma warning(push)
+#pragma warning(disable : 4838)
+  static const QITAB qit[] = {
+      QITABENT(CoverflowClassFactory, IClassFactory),
+      {0},
+  };
+#pragma warning(pop)
+  return QISearch(this, qit, riid, ppAny);
+}
+
+STDMETHODIMP CoverflowClassFactory::CreateInstance(IUnknown* pUnkOuter, REFIID riid,
+                                               void** ppvObj) {
+  _Module.DllRegisterServer(TRUE);
+
+  HRESULT hr;
+
+  *ppvObj = nullptr;
+
+  if (pUnkOuter != nullptr) {
+    return CLASS_E_NOAGGREGATION;
+  }
+
+  ICoverflowControl* pControl = new ICoverflowControl();
+
+
+  if (pControl == NULL) {
+    return E_UNEXPECTED /*E_OUTOFMEMORY*/;
+  }
+
+  hr = pControl->QueryInterface(riid, ppvObj);
+
+  if (SUCCEEDED(hr)) {
+    pControl->Release();
+  }
+  else {
+    delete pControl;
+  }
+  return hr;
+}
+
+HRESULT __stdcall CoverflowClassFactory::LockServer(BOOL fLock)
+{
+  if (fLock)
+
+    g_srvLockCount++;
+
+  else
+
+    g_srvLockCount--;
+
+  return S_OK;
+}

COM_ClassFactory.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "COM_Guid.h"
+
+#ifndef _COVERFLOWCLASSFACTORY
+#define _COVERFLOWCLASSFACTORY
+
+#include <windows.h>
+
+inline LONG g_lLocks = 0;
+
+inline void LockModule(BOOL bLock);
+
+class CoverflowClassFactory : public IClassFactory {
+ public:
+  STDMETHODIMP QueryInterface(REFIID riid, LPVOID* ppAny);
+  STDMETHODIMP_(ULONG) AddRef();
+  STDMETHODIMP_(ULONG) Release();
+
+  STDMETHODIMP CreateInstance(IUnknown* pUnkOuter, REFIID riid, void** ppvObject);
+  STDMETHODIMP LockServer(BOOL fLock);
+
+  CoverflowClassFactory();
+  virtual ~CoverflowClassFactory();
+
+ private:
+  ULONG m_refCount;
+};
+#endif

COM_GetClassObject.h

@@ -0,0 +1,39 @@
+#pragma once
+#include "COM_Guid.h"
+
+#include <xkeycheck.h>
+#include "COM_ClassFactory.h"
+
+STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppAny)
+{
+  static CoverflowClassFactory pFactory;
+  HRESULT hr;
+
+  *ppAny = NULL;
+
+  if (IsEqualCLSID(rclsid, CLSID_Coverflow_Control)) {
+
+    hr = pFactory.QueryInterface(riid, ppAny);
+
+  }
+  else {
+    FB2K_console_formatter() << "ICoverflowControl COM not available";
+    hr = CLASS_E_CLASSNOTAVAILABLE;
+  }
+
+  if (FAILED(hr)) {
+    FB2K_console_formatter() << "ICoverflowControl COM factory failed";
+    hr = CLASS_E_CLASSNOTAVAILABLE;
+  }
+
+  return hr;
+}
+
+STDAPI DllCanUnloadNow()
+{
+  if (g_srvLockCount == 0 && g_objCount == 0) {
+    return S_OK;
+  } else {
+    return S_FALSE;
+  }
+}

COM_Guid.h

@@ -0,0 +1,8 @@
+#pragma once
+#include <initguid.h>
+
+// {2543AA7C-5E5A-4F20-AC6D-04D6683ACDDA}
+DEFINE_GUID(CLSID_Coverflow_Control, 0x2543aa7c, 0x5e5a, 0x4f20, 0xac, 0x6d, 0x4, 0xd6, 0x68, 0x3a, 0xcd, 0xda);
+// {2543AA7E-5E5A-4F20-AC6D-04D6683ACDDA}
+DEFINE_GUID(CLSID_Coverflow_Library, 0x2543aa7e, 0x5e5a, 0x4f20, 0xac, 0x6d, 0x4, 0xd6, 0x68, 0x3a, 0xcd, 0xda);
+