astyle formatting cleanup to make the sourcecode more accessible

switch used: astyle --style=ansi --min-conditional-indent=0 --pad=oper --unpad=paren
http://astyle.sourceforge.net/

git-svn-id: https://mpc-hc.svn.sourceforge.net/svnroot/mpc-hc/trunk@1783 10f7b99b-c216-0410-bff0-8a66a9350fd8

1 files changed, 143 insertions, 118 deletions

diff --git a/src/filters/BaseClasses/videoctl.cpp b/src/filters/BaseClasses/videoctl.cpp
index b12ccbd37..655b8db1e 100644
--- a/src/filters/BaseClasses/videoctl.cpp
+++ b/src/filters/BaseClasses/videoctl.cpp
@@ -17,7 +17,8 @@
 

 LPTSTR WINAPI StringFromResource(__out_ecount(STR_MAX_LENGTH) LPTSTR pBuffer, int iResourceID)

 {

-    if (LoadString(g_hInst,iResourceID,pBuffer,STR_MAX_LENGTH) == 0) {

+    if(LoadString(g_hInst, iResourceID, pBuffer, STR_MAX_LENGTH) == 0)

+    {

         return TEXT("");

     }

     return pBuffer;

@@ -26,7 +27,8 @@ LPTSTR WINAPI StringFromResource(__out_ecount(STR_MAX_LENGTH) LPTSTR pBuffer, in
 #ifdef UNICODE

 LPSTR WINAPI StringFromResource(__out_ecount(STR_MAX_LENGTH) LPSTR pBuffer, int iResourceID)

 {

-    if (LoadStringA(g_hInst,iResourceID,pBuffer,STR_MAX_LENGTH) == 0) {

+    if(LoadStringA(g_hInst, iResourceID, pBuffer, STR_MAX_LENGTH) == 0)

+    {

         return "";

     }

     return pBuffer;

@@ -48,17 +50,21 @@ LPWSTR WINAPI WideStringFromResource(__out_ecount(STR_MAX_LENGTH) LPWSTR pBuffer
 {

     *pBuffer = 0;

 

-    if (g_amPlatform == VER_PLATFORM_WIN32_NT) {

-	LoadStringW(g_hInst,iResourceID,pBuffer,STR_MAX_LENGTH);

-    } else {

-

-	CHAR szBuffer[STR_MAX_LENGTH];

-	DWORD dwStringLength = LoadString(g_hInst,iResourceID,szBuffer,STR_MAX_LENGTH);

-	// if we loaded a string convert it to wide characters, ensuring

-	// that we also null terminate the result.

-	if (dwStringLength++) {

-	    MultiByteToWideChar(CP_ACP,0,szBuffer,dwStringLength,pBuffer,STR_MAX_LENGTH);

-	}

+    if(g_amPlatform == VER_PLATFORM_WIN32_NT)

+    {

+        LoadStringW(g_hInst, iResourceID, pBuffer, STR_MAX_LENGTH);

+    }

+    else

+    {

+

+        CHAR szBuffer[STR_MAX_LENGTH];

+        DWORD dwStringLength = LoadString(g_hInst, iResourceID, szBuffer, STR_MAX_LENGTH);

+        // if we loaded a string convert it to wide characters, ensuring

+        // that we also null terminate the result.

+        if(dwStringLength++)

+        {

+            MultiByteToWideChar(CP_ACP, 0, szBuffer, dwStringLength, pBuffer, STR_MAX_LENGTH);

+        }

     }

     return pBuffer;

 }

@@ -83,7 +89,8 @@ BOOL WINAPI GetDialogSize(int iResourceID,
                              GetDesktopWindow(),

                              pDlgProc,

                              lParam);

-    if (hwnd == NULL) {

+    if(hwnd == NULL)

+    {

         return FALSE;

     }

 

@@ -110,10 +117,13 @@ STDMETHODIMP CAggDirectDraw::NonDelegatingQueryInterface(REFIID riid, __deref_ou
 

     // Do we have this interface

 

-    if (riid == IID_IDirectDraw) {

-        return GetInterface((IDirectDraw *)this,ppv);

-    } else {

-        return CUnknown::NonDelegatingQueryInterface(riid,ppv);

+    if(riid == IID_IDirectDraw)

+    {

+        return GetInterface((IDirectDraw *)this, ppv);

+    }

+    else

+    {

+        return CUnknown::NonDelegatingQueryInterface(riid, ppv);

     }

 }

 

@@ -128,54 +138,54 @@ STDMETHODIMP CAggDirectDraw::Compact()
 STDMETHODIMP CAggDirectDraw::CreateClipper(DWORD dwFlags, __deref_out LPDIRECTDRAWCLIPPER *lplpDDClipper, __inout_opt IUnknown *pUnkOuter)

 {

     ASSERT(m_pDirectDraw);

-    return m_pDirectDraw->CreateClipper(dwFlags,lplpDDClipper,pUnkOuter);

+    return m_pDirectDraw->CreateClipper(dwFlags, lplpDDClipper, pUnkOuter);

 }

 

 

 STDMETHODIMP CAggDirectDraw::CreatePalette(DWORD dwFlags,

-                                           __in LPPALETTEENTRY lpColorTable,

-                                           __deref_out LPDIRECTDRAWPALETTE *lplpDDPalette,

-                                           __inout_opt IUnknown *pUnkOuter)

+        __in LPPALETTEENTRY lpColorTable,

+        __deref_out LPDIRECTDRAWPALETTE *lplpDDPalette,

+        __inout_opt IUnknown *pUnkOuter)

 {

     ASSERT(m_pDirectDraw);

-    return m_pDirectDraw->CreatePalette(dwFlags,lpColorTable,lplpDDPalette,pUnkOuter);

+    return m_pDirectDraw->CreatePalette(dwFlags, lpColorTable, lplpDDPalette, pUnkOuter);

 }

 

 

 STDMETHODIMP CAggDirectDraw::CreateSurface(__in LPDDSURFACEDESC lpDDSurfaceDesc,

-                                           __deref_out LPDIRECTDRAWSURFACE *lplpDDSurface,

-                                           __inout_opt IUnknown *pUnkOuter)

+        __deref_out LPDIRECTDRAWSURFACE *lplpDDSurface,

+        __inout_opt IUnknown *pUnkOuter)

 {

     ASSERT(m_pDirectDraw);

-    return m_pDirectDraw->CreateSurface(lpDDSurfaceDesc,lplpDDSurface,pUnkOuter);

+    return m_pDirectDraw->CreateSurface(lpDDSurfaceDesc, lplpDDSurface, pUnkOuter);

 }

 

 

 STDMETHODIMP CAggDirectDraw::DuplicateSurface(__in LPDIRECTDRAWSURFACE lpDDSurface,

-                                              __deref_out LPDIRECTDRAWSURFACE *lplpDupDDSurface)

+        __deref_out LPDIRECTDRAWSURFACE *lplpDupDDSurface)

 {

     ASSERT(m_pDirectDraw);

-    return m_pDirectDraw->DuplicateSurface(lpDDSurface,lplpDupDDSurface);

+    return m_pDirectDraw->DuplicateSurface(lpDDSurface, lplpDupDDSurface);

 }

 

 

 STDMETHODIMP CAggDirectDraw::EnumDisplayModes(DWORD dwSurfaceDescCount,

-                                              __in LPDDSURFACEDESC lplpDDSurfaceDescList,

-                                              __in LPVOID lpContext,

-                                              __in LPDDENUMMODESCALLBACK lpEnumCallback)

+        __in LPDDSURFACEDESC lplpDDSurfaceDescList,

+        __in LPVOID lpContext,

+        __in LPDDENUMMODESCALLBACK lpEnumCallback)

 {

     ASSERT(m_pDirectDraw);

-    return m_pDirectDraw->EnumDisplayModes(dwSurfaceDescCount,lplpDDSurfaceDescList,lpContext,lpEnumCallback);

+    return m_pDirectDraw->EnumDisplayModes(dwSurfaceDescCount, lplpDDSurfaceDescList, lpContext, lpEnumCallback);

 }

 

 

 STDMETHODIMP CAggDirectDraw::EnumSurfaces(DWORD dwFlags,

-                                          __in LPDDSURFACEDESC lpDDSD,

-                                          __in LPVOID lpContext,

-                                          __in LPDDENUMSURFACESCALLBACK lpEnumCallback)

+        __in LPDDSURFACEDESC lpDDSD,

+        __in LPVOID lpContext,

+        __in LPDDENUMSURFACESCALLBACK lpEnumCallback)

 {

     ASSERT(m_pDirectDraw);

-    return m_pDirectDraw->EnumSurfaces(dwFlags,lpDDSD,lpContext,lpEnumCallback);

+    return m_pDirectDraw->EnumSurfaces(dwFlags, lpDDSD, lpContext, lpEnumCallback);

 }

 

 

@@ -186,10 +196,10 @@ STDMETHODIMP CAggDirectDraw::FlipToGDISurface()
 }

 

 

-STDMETHODIMP CAggDirectDraw::GetCaps(__out LPDDCAPS lpDDDriverCaps,__out LPDDCAPS lpDDHELCaps)

+STDMETHODIMP CAggDirectDraw::GetCaps(__out LPDDCAPS lpDDDriverCaps, __out LPDDCAPS lpDDHELCaps)

 {

     ASSERT(m_pDirectDraw);

-    return m_pDirectDraw->GetCaps(lpDDDriverCaps,lpDDHELCaps);

+    return m_pDirectDraw->GetCaps(lpDDDriverCaps, lpDDHELCaps);

 }

 

 

@@ -200,10 +210,10 @@ STDMETHODIMP CAggDirectDraw::GetDisplayMode(__out LPDDSURFACEDESC lpDDSurfaceDes
 }

 

 

-STDMETHODIMP CAggDirectDraw::GetFourCCCodes(__inout LPDWORD lpNumCodes,__out_ecount(*lpNumCodes) LPDWORD lpCodes)

+STDMETHODIMP CAggDirectDraw::GetFourCCCodes(__inout LPDWORD lpNumCodes, __out_ecount(*lpNumCodes) LPDWORD lpCodes)

 {

     ASSERT(m_pDirectDraw);

-    return m_pDirectDraw->GetFourCCCodes(lpNumCodes,lpCodes);

+    return m_pDirectDraw->GetFourCCCodes(lpNumCodes, lpCodes);

 }

 

 

@@ -249,24 +259,24 @@ STDMETHODIMP CAggDirectDraw::RestoreDisplayMode()
 }

 

 

-STDMETHODIMP CAggDirectDraw::SetCooperativeLevel(HWND hWnd,DWORD dwFlags)

+STDMETHODIMP CAggDirectDraw::SetCooperativeLevel(HWND hWnd, DWORD dwFlags)

 {

     ASSERT(m_pDirectDraw);

-    return m_pDirectDraw->SetCooperativeLevel(hWnd,dwFlags);

+    return m_pDirectDraw->SetCooperativeLevel(hWnd, dwFlags);

 }

 

 

-STDMETHODIMP CAggDirectDraw::SetDisplayMode(DWORD dwWidth,DWORD dwHeight,DWORD dwBpp)

+STDMETHODIMP CAggDirectDraw::SetDisplayMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBpp)

 {

     ASSERT(m_pDirectDraw);

-    return m_pDirectDraw->SetDisplayMode(dwWidth,dwHeight,dwBpp);

+    return m_pDirectDraw->SetDisplayMode(dwWidth, dwHeight, dwBpp);

 }

 

 

-STDMETHODIMP CAggDirectDraw::WaitForVerticalBlank(DWORD dwFlags,HANDLE hEvent)

+STDMETHODIMP CAggDirectDraw::WaitForVerticalBlank(DWORD dwFlags, HANDLE hEvent)

 {

     ASSERT(m_pDirectDraw);

-    return m_pDirectDraw->WaitForVerticalBlank(dwFlags,hEvent);

+    return m_pDirectDraw->WaitForVerticalBlank(dwFlags, hEvent);

 }

 

 

@@ -284,10 +294,13 @@ STDMETHODIMP CAggDrawSurface::NonDelegatingQueryInterface(REFIID riid, __deref_o
 

     // Do we have this interface

 

-    if (riid == IID_IDirectDrawSurface) {

-        return GetInterface((IDirectDrawSurface *)this,ppv);

-    } else {

-        return CUnknown::NonDelegatingQueryInterface(riid,ppv);

+    if(riid == IID_IDirectDrawSurface)

+    {

+        return GetInterface((IDirectDrawSurface *)this, ppv);

+    }

+    else

+    {

+        return CUnknown::NonDelegatingQueryInterface(riid, ppv);

     }

 }

 

@@ -313,64 +326,64 @@ STDMETHODIMP CAggDrawSurface::Blt(__in LPRECT lpDestRect,
                                   __in LPDDBLTFX lpDDBltFx)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->Blt(lpDestRect,lpDDSrcSurface,lpSrcRect,dwFlags,lpDDBltFx);

+    return m_pDirectDrawSurface->Blt(lpDestRect, lpDDSrcSurface, lpSrcRect, dwFlags, lpDDBltFx);

 }

 

 

-STDMETHODIMP CAggDrawSurface::BltBatch(__in_ecount(dwCount) LPDDBLTBATCH lpDDBltBatch,DWORD dwCount,DWORD dwFlags)

+STDMETHODIMP CAggDrawSurface::BltBatch(__in_ecount(dwCount) LPDDBLTBATCH lpDDBltBatch, DWORD dwCount, DWORD dwFlags)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->BltBatch(lpDDBltBatch,dwCount,dwFlags);

+    return m_pDirectDrawSurface->BltBatch(lpDDBltBatch, dwCount, dwFlags);

 }

 

 

-STDMETHODIMP CAggDrawSurface::BltFast(DWORD dwX,DWORD dwY,

+STDMETHODIMP CAggDrawSurface::BltFast(DWORD dwX, DWORD dwY,

                                       __in LPDIRECTDRAWSURFACE lpDDSrcSurface,

                                       __in LPRECT lpSrcRect,

                                       DWORD dwTrans)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->BltFast(dwX,dwY,lpDDSrcSurface,lpSrcRect,dwTrans);

+    return m_pDirectDrawSurface->BltFast(dwX, dwY, lpDDSrcSurface, lpSrcRect, dwTrans);

 }

 

 

 STDMETHODIMP CAggDrawSurface::DeleteAttachedSurface(DWORD dwFlags,

-                                                    __in LPDIRECTDRAWSURFACE lpDDSAttachedSurface)

+        __in LPDIRECTDRAWSURFACE lpDDSAttachedSurface)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->DeleteAttachedSurface(dwFlags,lpDDSAttachedSurface);

+    return m_pDirectDrawSurface->DeleteAttachedSurface(dwFlags, lpDDSAttachedSurface);

 }

 

 

 STDMETHODIMP CAggDrawSurface::EnumAttachedSurfaces(__in LPVOID lpContext,

-                                                   __in LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback)

+        __in LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->EnumAttachedSurfaces(lpContext,lpEnumSurfacesCallback);

+    return m_pDirectDrawSurface->EnumAttachedSurfaces(lpContext, lpEnumSurfacesCallback);

 }

 

 

 STDMETHODIMP CAggDrawSurface::EnumOverlayZOrders(DWORD dwFlags,

-                                                 __in LPVOID lpContext,

-                                                 __in LPDDENUMSURFACESCALLBACK lpfnCallback)

+        __in LPVOID lpContext,

+        __in LPDDENUMSURFACESCALLBACK lpfnCallback)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->EnumOverlayZOrders(dwFlags,lpContext,lpfnCallback);

+    return m_pDirectDrawSurface->EnumOverlayZOrders(dwFlags, lpContext, lpfnCallback);

 }

 

 

-STDMETHODIMP CAggDrawSurface::Flip(__in LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride,DWORD dwFlags)

+STDMETHODIMP CAggDrawSurface::Flip(__in LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DWORD dwFlags)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->Flip(lpDDSurfaceTargetOverride,dwFlags);

+    return m_pDirectDrawSurface->Flip(lpDDSurfaceTargetOverride, dwFlags);

 }

 

 

 STDMETHODIMP CAggDrawSurface::GetAttachedSurface(__in LPDDSCAPS lpDDSCaps,

-                                                 __deref_out LPDIRECTDRAWSURFACE *lplpDDAttachedSurface)

+        __deref_out LPDIRECTDRAWSURFACE *lplpDDAttachedSurface)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->GetAttachedSurface(lpDDSCaps,lplpDDAttachedSurface);

+    return m_pDirectDrawSurface->GetAttachedSurface(lpDDSCaps, lplpDDAttachedSurface);

 }

 

 

@@ -395,10 +408,10 @@ STDMETHODIMP CAggDrawSurface::GetClipper(__deref_out LPDIRECTDRAWCLIPPER *lplpDD
 }

 

 

-STDMETHODIMP CAggDrawSurface::GetColorKey(DWORD dwFlags,__out LPDDCOLORKEY lpDDColorKey)

+STDMETHODIMP CAggDrawSurface::GetColorKey(DWORD dwFlags, __out LPDDCOLORKEY lpDDColorKey)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->GetColorKey(dwFlags,lpDDColorKey);

+    return m_pDirectDrawSurface->GetColorKey(dwFlags, lpDDColorKey);

 }

 

 

@@ -416,10 +429,10 @@ STDMETHODIMP CAggDrawSurface::GetFlipStatus(DWORD dwFlags)
 }

 

 

-STDMETHODIMP CAggDrawSurface::GetOverlayPosition(__out LPLONG lpdwX,__out LPLONG lpdwY)

+STDMETHODIMP CAggDrawSurface::GetOverlayPosition(__out LPLONG lpdwX, __out LPLONG lpdwY)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->GetOverlayPosition(lpdwX,lpdwY);

+    return m_pDirectDrawSurface->GetOverlayPosition(lpdwX, lpdwY);

 }

 

 

@@ -454,7 +467,8 @@ STDMETHODIMP CAggDrawSurface::GetSurfaceDesc(__out LPDDSURFACEDESC lpDDSurfaceDe
     // First call down to the underlying DirectDraw

 

     HRESULT hr = m_pDirectDrawSurface->GetSurfaceDesc(lpDDSurfaceDesc);

-    if (FAILED(hr)) {

+    if(FAILED(hr))

+    {

         return hr;

     }

 

@@ -464,10 +478,10 @@ STDMETHODIMP CAggDrawSurface::GetSurfaceDesc(__out LPDDSURFACEDESC lpDDSurfaceDe
 }

 

 

-STDMETHODIMP CAggDrawSurface::Initialize(__in LPDIRECTDRAW lpDD,__in LPDDSURFACEDESC lpDDSurfaceDesc)

+STDMETHODIMP CAggDrawSurface::Initialize(__in LPDIRECTDRAW lpDD, __in LPDDSURFACEDESC lpDDSurfaceDesc)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->Initialize(lpDD,lpDDSurfaceDesc);

+    return m_pDirectDrawSurface->Initialize(lpDD, lpDDSurfaceDesc);

 }

 

 

@@ -484,7 +498,7 @@ STDMETHODIMP CAggDrawSurface::Lock(__in LPRECT lpDestRect,
                                    HANDLE hEvent)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->Lock(lpDestRect,lpDDSurfaceDesc,dwFlags,hEvent);

+    return m_pDirectDrawSurface->Lock(lpDestRect, lpDDSurfaceDesc, dwFlags, hEvent);

 }

 

 

@@ -509,17 +523,17 @@ STDMETHODIMP CAggDrawSurface::SetClipper(__in LPDIRECTDRAWCLIPPER lpDDClipper)
 }

 

 

-STDMETHODIMP CAggDrawSurface::SetColorKey(DWORD dwFlags,__in LPDDCOLORKEY lpDDColorKey)

+STDMETHODIMP CAggDrawSurface::SetColorKey(DWORD dwFlags, __in LPDDCOLORKEY lpDDColorKey)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->SetColorKey(dwFlags,lpDDColorKey);

+    return m_pDirectDrawSurface->SetColorKey(dwFlags, lpDDColorKey);

 }

 

 

-STDMETHODIMP CAggDrawSurface::SetOverlayPosition(LONG dwX,LONG dwY)

+STDMETHODIMP CAggDrawSurface::SetOverlayPosition(LONG dwX, LONG dwY)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->SetOverlayPosition(dwX,dwY);

+    return m_pDirectDrawSurface->SetOverlayPosition(dwX, dwY);

 }

 

 

@@ -538,13 +552,13 @@ STDMETHODIMP CAggDrawSurface::Unlock(__in LPVOID lpSurfaceData)
 

 

 STDMETHODIMP CAggDrawSurface::UpdateOverlay(__in LPRECT lpSrcRect,

-                                            __in LPDIRECTDRAWSURFACE lpDDDestSurface,

-                                            __in LPRECT lpDestRect,

-                                            DWORD dwFlags,

-                                            __in LPDDOVERLAYFX lpDDOverlayFX)

+        __in LPDIRECTDRAWSURFACE lpDDDestSurface,

+        __in LPRECT lpDestRect,

+        DWORD dwFlags,

+        __in LPDDOVERLAYFX lpDDOverlayFX)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->UpdateOverlay(lpSrcRect,lpDDDestSurface,lpDestRect,dwFlags,lpDDOverlayFX);

+    return m_pDirectDrawSurface->UpdateOverlay(lpSrcRect, lpDDDestSurface, lpDestRect, dwFlags, lpDDOverlayFX);

 }

 

 

@@ -555,10 +569,10 @@ STDMETHODIMP CAggDrawSurface::UpdateOverlayDisplay(DWORD dwFlags)
 }

 

 

-STDMETHODIMP CAggDrawSurface::UpdateOverlayZOrder(DWORD dwFlags,__in LPDIRECTDRAWSURFACE lpDDSReference)

+STDMETHODIMP CAggDrawSurface::UpdateOverlayZOrder(DWORD dwFlags, __in LPDIRECTDRAWSURFACE lpDDSReference)

 {

     ASSERT(m_pDirectDrawSurface);

-    return m_pDirectDrawSurface->UpdateOverlayZOrder(dwFlags,lpDDSReference);

+    return m_pDirectDrawSurface->UpdateOverlayZOrder(dwFlags, lpDDSReference);

 }

 

 

@@ -581,7 +595,8 @@ CLoadDirectDraw::~CLoadDirectDraw()
 {

     ReleaseDirectDraw();

 

-    if (m_hDirectDraw) {

+    if(m_hDirectDraw)

+    {

         NOTE("Unloading library");

         FreeLibrary(m_hDirectDraw);

     }

@@ -609,7 +624,8 @@ HRESULT CLoadDirectDraw::LoadDirectDraw(__in LPSTR szDevice)
 

     // Is DirectDraw already loaded

 

-    if (m_pDirectDraw) {

+    if(m_pDirectDraw)

+    {

         NOTE("Already loaded");

         ASSERT(m_hDirectDraw);

         return NOERROR;

@@ -623,8 +639,9 @@ HRESULT CLoadDirectDraw::LoadDirectDraw(__in LPSTR szDevice)
         m_hDirectDraw = LoadLibrary(TEXT("DDRAW.DLL"));

         SetErrorMode(ErrorMode);

 

-        if (m_hDirectDraw == NULL) {

-            DbgLog((LOG_ERROR,1,TEXT("Can't load DDRAW.DLL")));

+        if(m_hDirectDraw == NULL)

+        {

+            DbgLog((LOG_ERROR, 1, TEXT("Can't load DDRAW.DLL")));

             NOTE("No library");

             return E_NOINTERFACE;

         }

@@ -632,38 +649,40 @@ HRESULT CLoadDirectDraw::LoadDirectDraw(__in LPSTR szDevice)
 

     // Get the DLL address for the creator function

 

-    pDrawCreate = (PDRAWCREATE)GetProcAddress(m_hDirectDraw,"DirectDrawCreate");

+    pDrawCreate = (PDRAWCREATE)GetProcAddress(m_hDirectDraw, "DirectDrawCreate");

     // force ANSI, we assume it

-    pDrawEnum = (PDRAWENUM)GetProcAddress(m_hDirectDraw,"DirectDrawEnumerateA");

+    pDrawEnum = (PDRAWENUM)GetProcAddress(m_hDirectDraw, "DirectDrawEnumerateA");

     pDrawEnumEx = (LPDIRECTDRAWENUMERATEEXA)GetProcAddress(m_hDirectDraw,

-						"DirectDrawEnumerateExA");

+                  "DirectDrawEnumerateExA");

 

     // We don't NEED DirectDrawEnumerateEx, that's just for multimon stuff

-    if (pDrawCreate == NULL || pDrawEnum == NULL) {

-        DbgLog((LOG_ERROR,1,TEXT("Can't get functions: Create=%x Enum=%x"),

-			pDrawCreate, pDrawEnum));

+    if(pDrawCreate == NULL || pDrawEnum == NULL)

+    {

+        DbgLog((LOG_ERROR, 1, TEXT("Can't get functions: Create=%x Enum=%x"),

+                pDrawCreate, pDrawEnum));

         NOTE("No entry point");

         ReleaseDirectDraw();

         return E_NOINTERFACE;

     }

 

-    DbgLog((LOG_TRACE,3,TEXT("Creating DDraw for device %s"),

-					szDevice ? szDevice : "<NULL>"));

+    DbgLog((LOG_TRACE, 3, TEXT("Creating DDraw for device %s"),

+            szDevice ? szDevice : "<NULL>"));

 

     // Create a DirectDraw display provider for this device, using the fancy

     // multimon-aware version, if it exists

-    if (pDrawEnumEx)

+    if(pDrawEnumEx)

         m_pDirectDraw = DirectDrawCreateFromDeviceEx(szDevice, pDrawCreate,

-								pDrawEnumEx);

+                        pDrawEnumEx);

     else

         m_pDirectDraw = DirectDrawCreateFromDevice(szDevice, pDrawCreate,

-								pDrawEnum);

+                        pDrawEnum);

 

-    if (m_pDirectDraw == NULL) {

-            DbgLog((LOG_ERROR,1,TEXT("Can't create DDraw")));

-            NOTE("No instance");

-            ReleaseDirectDraw();

-            return E_NOINTERFACE;

+    if(m_pDirectDraw == NULL)

+    {

+        DbgLog((LOG_ERROR, 1, TEXT("Can't create DDraw")));

+        NOTE("No instance");

+        ReleaseDirectDraw();

+        return E_NOINTERFACE;

     }

     return NOERROR;

 }

@@ -681,7 +700,8 @@ void CLoadDirectDraw::ReleaseDirectDraw()
 

     // Release any DirectDraw provider interface

 

-    if (m_pDirectDraw) {

+    if(m_pDirectDraw)

+    {

         NOTE("Releasing instance");

         m_pDirectDraw->Release();

         m_pDirectDraw = NULL;

@@ -696,7 +716,8 @@ HRESULT CLoadDirectDraw::IsDirectDrawLoaded()
 {

     NOTE("Entering IsDirectDrawLoaded");

 

-    if (m_pDirectDraw == NULL) {

+    if(m_pDirectDraw == NULL)

+    {

         NOTE("DirectDraw not loaded");

         return S_FALSE;

     }

@@ -710,7 +731,8 @@ LPDIRECTDRAW CLoadDirectDraw::GetDirectDraw()
 {

     NOTE("Entering GetDirectDraw");

 

-    if (m_pDirectDraw == NULL) {

+    if(m_pDirectDraw == NULL)

+    {

         NOTE("No DirectDraw");

         return NULL;

     }

@@ -729,18 +751,21 @@ LPDIRECTDRAW CLoadDirectDraw::GetDirectDraw()
 BOOL CLoadDirectDraw::IsDirectDrawVersion1()

 {

 

-    if (m_pDirectDraw == NULL)

-	return FALSE;

+    if(m_pDirectDraw == NULL)

+        return FALSE;

 

     IDirectDraw2 *p = NULL;

     HRESULT hr = m_pDirectDraw->QueryInterface(IID_IDirectDraw2, (void **)&p);

-    if (p)

-	p->Release();

-    if (hr == NOERROR) {

-        DbgLog((LOG_TRACE,3,TEXT("Direct Draw Version 2 or greater")));

-	return FALSE;

-    } else {

-        DbgLog((LOG_TRACE,3,TEXT("Direct Draw Version 1")));

-	return TRUE;

+    if(p)

+        p->Release();

+    if(hr == NOERROR)

+    {

+        DbgLog((LOG_TRACE, 3, TEXT("Direct Draw Version 2 or greater")));

+        return FALSE;

+    }

+    else

+    {

+        DbgLog((LOG_TRACE, 3, TEXT("Direct Draw Version 1")));

+        return TRUE;

     }

 }