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, 377 insertions, 377 deletions

diff --git a/src/apps/mplayerc/RealMediaWindowlessSite.cpp b/src/apps/mplayerc/RealMediaWindowlessSite.cpp
index e15750e11..84299a241 100644
--- a/src/apps/mplayerc/RealMediaWindowlessSite.cpp
+++ b/src/apps/mplayerc/RealMediaWindowlessSite.cpp
@@ -32,75 +32,75 @@
 

 void DSObjects::ExtractRects(REGION* pRegion)

 {

-	LPRGNDATA lpRgnData;

+    LPRGNDATA lpRgnData;

 

-	DWORD sizeNeeed = GetRegionData((HRGN)pRegion->pOSRegion, 0, NULL); 

+    DWORD sizeNeeed = GetRegionData((HRGN)pRegion->pOSRegion, 0, NULL);

 

-	lpRgnData = (LPRGNDATA)DNew char[sizeNeeed];

-	DWORD returnValue = GetRegionData((HRGN)pRegion->pOSRegion, sizeNeeed, lpRgnData); 

+    lpRgnData = (LPRGNDATA)DNew char[sizeNeeed];

+    DWORD returnValue = GetRegionData((HRGN)pRegion->pOSRegion, sizeNeeed, lpRgnData);

 

-	PN_VECTOR_DELETE(pRegion->rects);

+    PN_VECTOR_DELETE(pRegion->rects);

 

-	pRegion->numRects		= lpRgnData->rdh.nCount;

-	pRegion->extents.left	= lpRgnData->rdh.rcBound.left;

-	pRegion->extents.top	= lpRgnData->rdh.rcBound.top;

-	pRegion->extents.right	= lpRgnData->rdh.rcBound.right;

-	pRegion->extents.bottom	= lpRgnData->rdh.rcBound.bottom;

-	

-	if(lpRgnData->rdh.nCount)

-	{

-		pRegion->rects = DNew PNxRect[lpRgnData->rdh.nCount];

+    pRegion->numRects		= lpRgnData->rdh.nCount;

+    pRegion->extents.left	= lpRgnData->rdh.rcBound.left;

+    pRegion->extents.top	= lpRgnData->rdh.rcBound.top;

+    pRegion->extents.right	= lpRgnData->rdh.rcBound.right;

+    pRegion->extents.bottom	= lpRgnData->rdh.rcBound.bottom;

 

-		// now extract the information.

+    if(lpRgnData->rdh.nCount)

+    {

+        pRegion->rects = DNew PNxRect[lpRgnData->rdh.nCount];

 

-		for(int j = 0; j < (int) lpRgnData->rdh.nCount;j++)

-		{

-			RECT* pRect = (RECT*)lpRgnData->Buffer;

-			pRegion->rects[j].left = pRect[j].left;

-			pRegion->rects[j].top = pRect[j].top;

-			pRegion->rects[j].right = pRect[j].right;

-			pRegion->rects[j].bottom = pRect[j].bottom;

-		}

-	}

+        // now extract the information.

 

-	PN_VECTOR_DELETE(lpRgnData);

+        for(int j = 0; j < (int) lpRgnData->rdh.nCount; j++)

+        {

+            RECT* pRect = (RECT*)lpRgnData->Buffer;

+            pRegion->rects[j].left = pRect[j].left;

+            pRegion->rects[j].top = pRect[j].top;

+            pRegion->rects[j].right = pRect[j].right;

+            pRegion->rects[j].bottom = pRect[j].bottom;

+        }

+    }

+

+    PN_VECTOR_DELETE(lpRgnData);

 }

 REGION* DSObjects::RMACreateRectRegion(int left, int top, int right, int bottom)

 {

-	REGION* retVal = DNew REGION;

-	retVal->pOSRegion = (void*)CreateRectRgn(left, top, right, bottom);

-	ExtractRects(retVal);

-	return retVal;

+    REGION* retVal = DNew REGION;

+    retVal->pOSRegion = (void*)CreateRectRgn(left, top, right, bottom);

+    ExtractRects(retVal);

+    return retVal;

 }

 void DSObjects::RMASubtractRegion(REGION* regM, REGION* regS, REGION* regD)

 {

-	CombineRgn((HRGN)regD->pOSRegion, (HRGN)regM->pOSRegion, (HRGN)regS->pOSRegion, RGN_DIFF);

-	ExtractRects(regD);

+    CombineRgn((HRGN)regD->pOSRegion, (HRGN)regM->pOSRegion, (HRGN)regS->pOSRegion, RGN_DIFF);

+    ExtractRects(regD);

 }

 void DSObjects::RMAUnionRegion(REGION* reg1, REGION* reg2, REGION* regD)

 {

-	CombineRgn((HRGN)regD->pOSRegion, (HRGN)reg1->pOSRegion, (HRGN)reg2->pOSRegion, RGN_OR);

-	ExtractRects(regD);

+    CombineRgn((HRGN)regD->pOSRegion, (HRGN)reg1->pOSRegion, (HRGN)reg2->pOSRegion, RGN_OR);

+    ExtractRects(regD);

 }

 void DSObjects::RMAIntersectRegion(REGION* reg1, REGION* reg2, REGION* regD)

 {

-	CombineRgn((HRGN)regD->pOSRegion, (HRGN)reg1->pOSRegion, (HRGN)reg2->pOSRegion, RGN_AND);

-	ExtractRects(regD);

+    CombineRgn((HRGN)regD->pOSRegion, (HRGN)reg1->pOSRegion, (HRGN)reg2->pOSRegion, RGN_AND);

+    ExtractRects(regD);

 }

 BOOL DSObjects::RMAEqualRegion(REGION* reg1, REGION* reg2)

 {

-	return EqualRgn((HRGN)reg1->pOSRegion, (HRGN)reg2->pOSRegion)

-		&& !memcmp(&reg1->extents, &reg2->extents, sizeof(PNxRect)) ? TRUE : FALSE;

+    return EqualRgn((HRGN)reg1->pOSRegion, (HRGN)reg2->pOSRegion)

+           && !memcmp(&reg1->extents, &reg2->extents, sizeof(PNxRect)) ? TRUE : FALSE;

 }

 void DSObjects::RMADestroyRegion(REGION* reg)

 {

-	if(reg) DeleteObject((HRGN)reg->pOSRegion),

-	PN_VECTOR_DELETE(reg->rects);

-	PN_DELETE(reg);

+    if(reg) DeleteObject((HRGN)reg->pOSRegion),

+           PN_VECTOR_DELETE(reg->rects);

+    PN_DELETE(reg);

 }

 REGION* DSObjects::RMACreateRegion()

 {

-	return RMACreateRectRegion(0,0,0,0);

+    return RMACreateRectRegion(0, 0, 0, 0);

 }

 

 //

@@ -108,606 +108,606 @@ REGION* DSObjects::RMACreateRegion()
 //

 

 CRealMediaWindowlessSite::CRealMediaWindowlessSite(HRESULT& hr, IUnknown* pContext, CRealMediaWindowlessSite* pParentSite, IUnknown* pUnkOuter)

-	: CUnknown(NAME("CRealMediaWindowlessSite"), pUnkOuter, &hr)

-	, m_pContext(pContext)

-	, m_pParentSite(pParentSite)

-	, m_pCCF(pContext)

-	, m_fDamaged(false), m_fInRedraw(false), m_fIsVisible(true)

-	, m_lZOrder(0)

-	, m_pRegion(NULL), m_pRegionWithoutChildren(NULL)

+    : CUnknown(NAME("CRealMediaWindowlessSite"), pUnkOuter, &hr)

+    , m_pContext(pContext)

+    , m_pParentSite(pParentSite)

+    , m_pCCF(pContext)

+    , m_fDamaged(false), m_fInRedraw(false), m_fIsVisible(true)

+    , m_lZOrder(0)

+    , m_pRegion(NULL), m_pRegionWithoutChildren(NULL)

 {

-	m_size.cx = m_size.cy = 0;

-	m_position.x = m_position.y = 0;

+    m_size.cx = m_size.cy = 0;

+    m_position.x = m_position.y = 0;

 

-	memset(&m_lastBitmapInfo, 0, sizeof(m_lastBitmapInfo));

+    memset(&m_lastBitmapInfo, 0, sizeof(m_lastBitmapInfo));

 

-	hr = S_OK;

+    hr = S_OK;

 

-	if(!m_pContext || !m_pCCF)

-	{

-		hr = E_POINTER;

-		return;

-	}

+    if(!m_pContext || !m_pCCF)

+    {

+        hr = E_POINTER;

+        return;

+    }

 

-	m_pCCF->CreateInstance(CLSID_IRMAValues, (void**)&m_pValues);

+    m_pCCF->CreateInstance(CLSID_IRMAValues, (void**)&m_pValues);

 }

 

 CRealMediaWindowlessSite::~CRealMediaWindowlessSite()

 {

-	POSITION pos = m_pChildren.GetHeadPosition();

-	while(pos) DestroyChild(m_pChildren.GetNext(pos));

+    POSITION pos = m_pChildren.GetHeadPosition();

+    while(pos) DestroyChild(m_pChildren.GetNext(pos));

 

-	RMADestroyRegion(m_pRegion);

-	RMADestroyRegion(m_pRegionWithoutChildren);

+    RMADestroyRegion(m_pRegion);

+    RMADestroyRegion(m_pRegionWithoutChildren);

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::NonDelegatingQueryInterface(REFIID riid, void** ppv)

 {

-	return 

-		QI2(IRMASite)

-		QI2(IRMASite2)

-		QI2(IRMASiteWindowless)

-		QI2(IRMAVideoSurface)

-		(m_pValues && m_pValues->QueryInterface(riid, ppv) == PNR_OK) ? PNR_OK :

-		CUnknown::NonDelegatingQueryInterface(riid, ppv);

+    return

+        QI2(IRMASite)

+        QI2(IRMASite2)

+        QI2(IRMASiteWindowless)

+        QI2(IRMAVideoSurface)

+        (m_pValues && m_pValues->QueryInterface(riid, ppv) == PNR_OK) ? PNR_OK :

+        CUnknown::NonDelegatingQueryInterface(riid, ppv);

 }

 

 // public

 

 void CRealMediaWindowlessSite::GetTopLeft(PNxPoint* pPoint)

 {

-	pPoint->x += m_position.x;

-	pPoint->y += m_position.y;

+    pPoint->x += m_position.x;

+    pPoint->y += m_position.y;

 

-	if(m_pParentSite)

-		m_pParentSite->GetTopLeft(pPoint);

+    if(m_pParentSite)

+        m_pParentSite->GetTopLeft(pPoint);

 }

 

 REGION* CRealMediaWindowlessSite::GetRegion()

 {

-	return m_pRegion;

+    return m_pRegion;

 }

 

 // private

 

 void CRealMediaWindowlessSite::RecomputeRegion()

 {

-	if(m_pParentSite) m_pParentSite->RecomputeRegion();

-	else InternalRecomputeRegion();

+    if(m_pParentSite) m_pParentSite->RecomputeRegion();

+    else InternalRecomputeRegion();

 }

 

 void CRealMediaWindowlessSite::InternalRecomputeRegion()

 {

-	ComputeRegion();

+    ComputeRegion();

 

-	POSITION pos = m_pChildren.GetHeadPosition();

-	while(pos)

-	{

-		CRealMediaWindowlessSite* pSite = (CRealMediaWindowlessSite*)(IRMASite*)m_pChildren.GetNext(pos);

-		if(pSite) pSite->InternalRecomputeRegion();

-	}

+    POSITION pos = m_pChildren.GetHeadPosition();

+    while(pos)

+    {

+        CRealMediaWindowlessSite* pSite = (CRealMediaWindowlessSite*)(IRMASite*)m_pChildren.GetNext(pos);

+        if(pSite) pSite->InternalRecomputeRegion();

+    }

 }

 

 void CRealMediaWindowlessSite::ComputeRegion()

 {

-	REGION* pTempRegion = NULL;

+    REGION* pTempRegion = NULL;

 

-	if(m_pRegion)

-	{

-		pTempRegion = RMACreateRegion();

-		RMAUnionRegion(pTempRegion, m_pRegion, pTempRegion);

-		RMADestroyRegion(m_pRegion);

-	}

+    if(m_pRegion)

+    {

+        pTempRegion = RMACreateRegion();

+        RMAUnionRegion(pTempRegion, m_pRegion, pTempRegion);

+        RMADestroyRegion(m_pRegion);

+    }

 

-	if(m_pRegionWithoutChildren)

-	{

-		RMADestroyRegion(m_pRegionWithoutChildren);

-	}

+    if(m_pRegionWithoutChildren)

+    {

+        RMADestroyRegion(m_pRegionWithoutChildren);

+    }

 

-	PNxPoint topleft = {0,0};

-	GetTopLeft(&topleft);

+    PNxPoint topleft = {0, 0};

+    GetTopLeft(&topleft);

 

-	if(IsSiteVisible())

-	{

-		m_pRegionWithoutChildren = RMACreateRectRegion(topleft.x, topleft.y, topleft.x + m_size.cx, topleft.y + m_size.cy);

+    if(IsSiteVisible())

+    {

+        m_pRegionWithoutChildren = RMACreateRectRegion(topleft.x, topleft.y, topleft.x + m_size.cx, topleft.y + m_size.cy);

 

-		if(m_pParentSite)

-		{

-			RMAIntersectRegion(m_pRegionWithoutChildren, m_pParentSite->m_pRegionWithoutChildren, m_pRegionWithoutChildren);

+        if(m_pParentSite)

+        {

+            RMAIntersectRegion(m_pRegionWithoutChildren, m_pParentSite->m_pRegionWithoutChildren, m_pRegionWithoutChildren);

 

-			POSITION pos = m_pParentSite->m_pChildren.GetHeadPosition();

+            POSITION pos = m_pParentSite->m_pChildren.GetHeadPosition();

             while(pos)

-			{

-				CRealMediaWindowlessSite* pSiblingSite = (CRealMediaWindowlessSite*)(IRMASite*)m_pParentSite->m_pChildren.GetNext(pos);

-				if(pSiblingSite != this)

-				{

-					INT32 zOrder;

-					pSiblingSite->GetZOrder(zOrder);

-					

-					if(zOrder > m_lZOrder && pSiblingSite->IsSiteVisible())

-					{

-						pSiblingSite->SubtractSite(m_pRegionWithoutChildren);

-					}

-				}

-			}

-		}

-

-		m_pRegion = RMACreateRegion();

-		RMAUnionRegion(m_pRegion, m_pRegionWithoutChildren, m_pRegion);

-

-		POSITION pos = m_pChildren.GetHeadPosition();

-		while(pos)

-		{

-			CRealMediaWindowlessSite* pChildSite = (CRealMediaWindowlessSite*)(IRMASite*)m_pChildren.GetNext(pos);

-			if(pChildSite->IsSiteVisible()) pChildSite->SubtractSite(m_pRegion);

-		}

-	}

-	else

-	{

-		m_pRegionWithoutChildren = RMACreateRectRegion(0,0,0,0);

-		m_pRegion = RMACreateRectRegion(0,0,0,0);

-	}

-

-	if(pTempRegion && !RMAEqualRegion(m_pRegion, pTempRegion))

-	{

-		ForceRedraw();

-	}

-

-	RMADestroyRegion(pTempRegion);

+            {

+                CRealMediaWindowlessSite* pSiblingSite = (CRealMediaWindowlessSite*)(IRMASite*)m_pParentSite->m_pChildren.GetNext(pos);

+                if(pSiblingSite != this)

+                {

+                    INT32 zOrder;

+                    pSiblingSite->GetZOrder(zOrder);

+

+                    if(zOrder > m_lZOrder && pSiblingSite->IsSiteVisible())

+                    {

+                        pSiblingSite->SubtractSite(m_pRegionWithoutChildren);

+                    }

+                }

+            }

+        }

+

+        m_pRegion = RMACreateRegion();

+        RMAUnionRegion(m_pRegion, m_pRegionWithoutChildren, m_pRegion);

+

+        POSITION pos = m_pChildren.GetHeadPosition();

+        while(pos)

+        {

+            CRealMediaWindowlessSite* pChildSite = (CRealMediaWindowlessSite*)(IRMASite*)m_pChildren.GetNext(pos);

+            if(pChildSite->IsSiteVisible()) pChildSite->SubtractSite(m_pRegion);

+        }

+    }

+    else

+    {

+        m_pRegionWithoutChildren = RMACreateRectRegion(0, 0, 0, 0);

+        m_pRegion = RMACreateRectRegion(0, 0, 0, 0);

+    }

+

+    if(pTempRegion && !RMAEqualRegion(m_pRegion, pTempRegion))

+    {

+        ForceRedraw();

+    }

+

+    RMADestroyRegion(pTempRegion);

 }

 

 void CRealMediaWindowlessSite::SubtractSite(REGION* pRegion)

 {

-	PNxPoint topLeft;

-	memset(&topLeft, 0, sizeof(PNxPoint));

-	GetTopLeft(&topLeft);

-	

-	REGION* pTempRegion = RMACreateRectRegion(topLeft.x, topLeft.y, topLeft.x + m_size.cx, topLeft.y + m_size.cy);

+    PNxPoint topLeft;

+    memset(&topLeft, 0, sizeof(PNxPoint));

+    GetTopLeft(&topLeft);

+

+    REGION* pTempRegion = RMACreateRectRegion(topLeft.x, topLeft.y, topLeft.x + m_size.cx, topLeft.y + m_size.cy);

 

-	RMASubtractRegion(pRegion, pTempRegion, pRegion);

-	RMADestroyRegion(pTempRegion);

+    RMASubtractRegion(pRegion, pTempRegion, pRegion);

+    RMADestroyRegion(pTempRegion);

 }

 

 void CRealMediaWindowlessSite::UpdateZOrder(CRealMediaWindowlessSite* pUpdatedChildSite, INT32 lOldZOrder, INT32 lNewZOrder)

 {

-	POSITION pos = m_pChildren.GetHeadPosition();

-	while(pos)

-	{

-		CRealMediaWindowlessSite* pSite = (CRealMediaWindowlessSite*)(IRMASite*)m_pChildren.GetNext(pos);

-

-		INT32 lItsOldZOrder;

-		pSite->GetZOrder(lItsOldZOrder);

-

-		if(pSite != pUpdatedChildSite)

-		{

-			if(lOldZOrder < lNewZOrder)

-			{

-				if(lItsOldZOrder >= lOldZOrder && lItsOldZOrder < lNewZOrder)

-				{

-					pSite->SetInternalZOrder(lItsOldZOrder-1);

-				}

-			}

-			else

-			{

-				if(lItsOldZOrder >= lNewZOrder && lItsOldZOrder < lOldZOrder)

-				{

-					pSite->SetInternalZOrder(lItsOldZOrder+1);

-				}

-			}

-		}

-		else

-		{

-			pSite->SetInternalZOrder(lNewZOrder);

-		}

-	}

+    POSITION pos = m_pChildren.GetHeadPosition();

+    while(pos)

+    {

+        CRealMediaWindowlessSite* pSite = (CRealMediaWindowlessSite*)(IRMASite*)m_pChildren.GetNext(pos);

+

+        INT32 lItsOldZOrder;

+        pSite->GetZOrder(lItsOldZOrder);

+

+        if(pSite != pUpdatedChildSite)

+        {

+            if(lOldZOrder < lNewZOrder)

+            {

+                if(lItsOldZOrder >= lOldZOrder && lItsOldZOrder < lNewZOrder)

+                {

+                    pSite->SetInternalZOrder(lItsOldZOrder - 1);

+                }

+            }

+            else

+            {

+                if(lItsOldZOrder >= lNewZOrder && lItsOldZOrder < lOldZOrder)

+                {

+                    pSite->SetInternalZOrder(lItsOldZOrder + 1);

+                }

+            }

+        }

+        else

+        {

+            pSite->SetInternalZOrder(lNewZOrder);

+        }

+    }

 }

 

 void CRealMediaWindowlessSite::SetInternalZOrder(INT32 lZOrder)

 {

-	m_lZOrder = lZOrder;

+    m_lZOrder = lZOrder;

 }

 

 // IRMASiteWindowless

 

 STDMETHODIMP CRealMediaWindowlessSite::EventOccurred(PNxEvent* /*IN*/ pEvent)

 {

-	return PNR_NOTIMPL;  /* not necessary within our implementation */

+    return PNR_NOTIMPL;  /* not necessary within our implementation */

 }

 

 STDMETHODIMP_(PNxWindow*) CRealMediaWindowlessSite::GetParentWindow()

 {

-	return NULL;

+    return NULL;

 }

 

 // IRMASite

 

 STDMETHODIMP CRealMediaWindowlessSite::AttachUser(IRMASiteUser* /*IN*/ pUser)

 {

-	HRESULT hr = PNR_FAIL;

+    HRESULT hr = PNR_FAIL;

+

+    if(m_pUser) return PNR_UNEXPECTED;

 

-	if(m_pUser) return PNR_UNEXPECTED;

+    if(CComQIPtr<IRMASite, &IID_IRMASite> pOuterSite = GetOwner())

+        hr = pUser->AttachSite(pOuterSite);

 

-	if(CComQIPtr<IRMASite, &IID_IRMASite> pOuterSite = GetOwner())

-		hr = pUser->AttachSite(pOuterSite);

-	

-	if(PNR_OK == hr)

-		m_pUser = pUser;

+    if(PNR_OK == hr)

+        m_pUser = pUser;

 

-	return hr;

+    return hr;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::DetachUser()

 {

-	HRESULT hr = PNR_OK;

+    HRESULT hr = PNR_OK;

 

-	if(!m_pUser) return PNR_UNEXPECTED;

+    if(!m_pUser) return PNR_UNEXPECTED;

 

-	hr = m_pUser->DetachSite();

+    hr = m_pUser->DetachSite();

 

-	if(PNR_OK == hr)

-		m_pUser = NULL;

+    if(PNR_OK == hr)

+        m_pUser = NULL;

 

-	return hr;

+    return hr;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::GetUser(REF(IRMASiteUser*) /*OUT*/ pUser)

 {

-	HRESULT hr = PNR_OK;

+    HRESULT hr = PNR_OK;

 

-	if(!m_pUser) return PNR_UNEXPECTED;

+    if(!m_pUser) return PNR_UNEXPECTED;

 

-	(pUser = m_pUser)->AddRef();

+    (pUser = m_pUser)->AddRef();

 

-	return hr;

+    return hr;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::CreateChild(REF(IRMASite*) /*OUT*/ pChildSite)

 {

-	HRESULT hr = PNR_OK;

+    HRESULT hr = PNR_OK;

 

-	CComPtr<IRMASite> pSite = 

-		(IRMASite*)DNew CRealMediaWindowlessSite(hr, m_pContext, this);

+    CComPtr<IRMASite> pSite =

+        (IRMASite*)DNew CRealMediaWindowlessSite(hr, m_pContext, this);

 

-	if(FAILED(hr) || !pSite)

-		return E_FAIL;

+    if(FAILED(hr) || !pSite)

+        return E_FAIL;

 

-	pChildSite = pSite.Detach();

+    pChildSite = pSite.Detach();

 

-	m_pChildren.AddTail(pChildSite);

+    m_pChildren.AddTail(pChildSite);

 

-	return hr;

+    return hr;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::DestroyChild(IRMASite* /*IN*/ pChildSite)

 {

-	if(POSITION pos = m_pChildren.Find(pChildSite))

-	{

-		m_pChildren.RemoveAt(pos);

-		return PNR_OK;

-	}

+    if(POSITION pos = m_pChildren.Find(pChildSite))

+    {

+        m_pChildren.RemoveAt(pos);

+        return PNR_OK;

+    }

 

-	return PNR_UNEXPECTED;

+    return PNR_UNEXPECTED;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::AttachWatcher(IRMASiteWatcher* /*IN*/ pWatcher)

 {

-	if(m_pWatcher) return PNR_UNEXPECTED;

+    if(m_pWatcher) return PNR_UNEXPECTED;

 

-	if(m_pWatcher = pWatcher)

-		m_pWatcher->AttachSite((IRMASite*)this);

+    if(m_pWatcher = pWatcher)

+        m_pWatcher->AttachSite((IRMASite*)this);

 

-	return PNR_OK;

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::DetachWatcher()

 {

-	if(!m_pWatcher) return PNR_UNEXPECTED;

+    if(!m_pWatcher) return PNR_UNEXPECTED;

 

-	m_pWatcher->DetachSite();

-	m_pWatcher = NULL;

+    m_pWatcher->DetachSite();

+    m_pWatcher = NULL;

 

-	return PNR_OK;

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::SetPosition(PNxPoint position)

 {

-	HRESULT hr = PNR_OK;

+    HRESULT hr = PNR_OK;

 

-	if(m_pWatcher)

-	{

-		hr = m_pWatcher->ChangingPosition(m_position, position);

-	}

+    if(m_pWatcher)

+    {

+        hr = m_pWatcher->ChangingPosition(m_position, position);

+    }

 

-	if(PNR_OK == hr)

-	{

-		m_position = position;

+    if(PNR_OK == hr)

+    {

+        m_position = position;

 

-		POSITION pos = m_pPassiveWatchers.GetHeadPosition();

-		while(pos) m_pPassiveWatchers.GetNext(pos)->PositionChanged(&position);

+        POSITION pos = m_pPassiveWatchers.GetHeadPosition();

+        while(pos) m_pPassiveWatchers.GetNext(pos)->PositionChanged(&position);

 

-		RecomputeRegion();

-	}

+        RecomputeRegion();

+    }

 

-	return hr;

+    return hr;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::GetPosition(REF(PNxPoint) position)

 {

-	position = m_position;

-	return PNR_OK;

+    position = m_position;

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::SetSize(PNxSize size)

 {

-	HRESULT hr = PNR_OK;

+    HRESULT hr = PNR_OK;

 

-	if(m_pWatcher)

-	{

-		hr = m_pWatcher->ChangingSize(m_size, size);

-	}

+    if(m_pWatcher)

+    {

+        hr = m_pWatcher->ChangingSize(m_size, size);

+    }

 

-	if(PNR_OK == hr && size.cx != 0 && size.cy != 0)

-	{

-		m_size = size;

+    if(PNR_OK == hr && size.cx != 0 && size.cy != 0)

+    {

+        m_size = size;

 

-		POSITION pos = m_pPassiveWatchers.GetHeadPosition();

-		while(pos) m_pPassiveWatchers.GetNext(pos)->SizeChanged(&size);

+        POSITION pos = m_pPassiveWatchers.GetHeadPosition();

+        while(pos) m_pPassiveWatchers.GetNext(pos)->SizeChanged(&size);

 

-		RecomputeRegion();

-	}

+        RecomputeRegion();

+    }

 

-	return hr;

+    return hr;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::GetSize(REF(PNxSize) size)

 {

-	size = m_size;

-	return PNR_OK;

+    size = m_size;

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::DamageRect(PNxRect rect)

 {

-	m_fDamaged = TRUE;

-	return PNR_OK;

+    m_fDamaged = TRUE;

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::DamageRegion(PNxRegion region)

 {

-	m_fDamaged = TRUE;

-	return PNR_OK;

+    m_fDamaged = TRUE;

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::ForceRedraw()

 {

-	// make sure we have a visible window and are not re-enterering and we have damage

-	if(!m_fInRedraw && m_fDamaged && m_fIsVisible)

-	{

-		m_fInRedraw = TRUE; 

-		

-		PNxEvent event = {RMA_SURFACE_UPDATE, NULL, (IRMAVideoSurface*)this, NULL, 0, 0};

-		m_pUser->HandleEvent(&event);

-		

-		m_fInRedraw = FALSE;

-		m_fDamaged = FALSE;

-	}

-	

-	return PNR_OK;

+    // make sure we have a visible window and are not re-enterering and we have damage

+    if(!m_fInRedraw && m_fDamaged && m_fIsVisible)

+    {

+        m_fInRedraw = TRUE;

+

+        PNxEvent event = {RMA_SURFACE_UPDATE, NULL, (IRMAVideoSurface*)this, NULL, 0, 0};

+        m_pUser->HandleEvent(&event);

+

+        m_fInRedraw = FALSE;

+        m_fDamaged = FALSE;

+    }

+

+    return PNR_OK;

 }

 

 // IRMASite2

 

 STDMETHODIMP CRealMediaWindowlessSite::UpdateSiteWindow(PNxWindow* /*IN*/ pWindow)

 {

-	return PNR_OK;

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::ShowSite(BOOL bShow)

 {

-	m_fIsVisible = !!bShow;

-	RecomputeRegion();

-	return PNR_OK;

+    m_fIsVisible = !!bShow;

+    RecomputeRegion();

+    return PNR_OK;

 }

 

 STDMETHODIMP_(BOOL) CRealMediaWindowlessSite::IsSiteVisible()

 {

-	BOOL fIsVisible = m_fIsVisible;

-	if(m_pParentSite) fIsVisible = fIsVisible && m_pParentSite->IsSiteVisible();

-	return fIsVisible;

+    BOOL fIsVisible = m_fIsVisible;

+    if(m_pParentSite) fIsVisible = fIsVisible && m_pParentSite->IsSiteVisible();

+    return fIsVisible;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::SetZOrder(INT32 lZOrder)

 {

-	if(!m_pParentSite) return PNR_UNEXPECTED;

+    if(!m_pParentSite) return PNR_UNEXPECTED;

+

+    if(lZOrder == -1 || lZOrder >= (INT32)m_pParentSite->GetNumberOfChildSites())

+        lZOrder = m_pParentSite->GetNumberOfChildSites() - 1;

 

-	if(lZOrder == -1 || lZOrder >= (INT32)m_pParentSite->GetNumberOfChildSites())

-		lZOrder = m_pParentSite->GetNumberOfChildSites() - 1; 

-	

-	if(m_lZOrder != lZOrder)

-		m_pParentSite->UpdateZOrder(this, m_lZOrder, lZOrder);

+    if(m_lZOrder != lZOrder)

+        m_pParentSite->UpdateZOrder(this, m_lZOrder, lZOrder);

 

-	m_lZOrder = lZOrder;

+    m_lZOrder = lZOrder;

 

-	return PNR_OK;

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::GetZOrder(REF(INT32) lZOrder)

 {

-	if(!m_pParentSite) return PNR_UNEXPECTED;

-	lZOrder = m_lZOrder;

-	return PNR_OK;

+    if(!m_pParentSite) return PNR_UNEXPECTED;

+    lZOrder = m_lZOrder;

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::MoveSiteToTop()

 {

-	if(!m_pParentSite) return PNR_UNEXPECTED;

-	return PNR_NOTIMPL;

+    if(!m_pParentSite) return PNR_UNEXPECTED;

+    return PNR_NOTIMPL;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::GetVideoSurface(REF(IRMAVideoSurface*) pSurface)

 {

-	(pSurface = (IRMAVideoSurface*)this)->AddRef();

-	return PNR_OK;

+    (pSurface = (IRMAVideoSurface*)this)->AddRef();

+    return PNR_OK;

 }

 

 STDMETHODIMP_(UINT32) CRealMediaWindowlessSite::GetNumberOfChildSites()

 {

-	return (UINT32)m_pChildren.GetCount();

+    return (UINT32)m_pChildren.GetCount();

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::AddPassiveSiteWatcher(IRMAPassiveSiteWatcher* pWatcher)

 {

-	m_pPassiveWatchers.AddTail(pWatcher);

-	return PNR_OK;

+    m_pPassiveWatchers.AddTail(pWatcher);

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::RemovePassiveSiteWatcher(IRMAPassiveSiteWatcher* pWatcher)

 {

-	if(POSITION pos = m_pPassiveWatchers.Find(pWatcher))

-	{

-		m_pPassiveWatchers.RemoveAt(pos);

-		return PNR_OK;

-	}

+    if(POSITION pos = m_pPassiveWatchers.Find(pWatcher))

+    {

+        m_pPassiveWatchers.RemoveAt(pos);

+        return PNR_OK;

+    }

 

-	return PNR_UNEXPECTED;

+    return PNR_UNEXPECTED;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::SetCursor(PNxCursor cursor, REF(PNxCursor) oldCursor)

 {

-	return PNR_NOTIMPL;

+    return PNR_NOTIMPL;

 }

 

 // private

 

 void CRealMediaWindowlessSite::IntersectRect(PNxRect* pRect, PNxRect* pBox, PNxRect* pRetVal)

 {

-	pRetVal->left   = max(pRect->left, pBox->left);

-	pRetVal->top    = max(pRect->top, pBox->top);

-	pRetVal->right  = min(pRect->right, pBox->right);

-	pRetVal->bottom = min(pRect->bottom, pBox->bottom);

+    pRetVal->left   = max(pRect->left, pBox->left);

+    pRetVal->top    = max(pRect->top, pBox->top);

+    pRetVal->right  = min(pRect->right, pBox->right);

+    pRetVal->bottom = min(pRect->bottom, pBox->bottom);

 }

 

 // protected

 

 bool CRealMediaWindowlessSite::GetBltService(IRMAVideoSurface** ppBltService)

 {

-	bool fRet = false;

+    bool fRet = false;

+

+    if(ppBltService)

+    {

+        if(m_pParentSite)

+        {

+            fRet = m_pParentSite->GetBltService(ppBltService);

+        }

+        else if(m_pBltService)

+        {

+            (*ppBltService = m_pBltService)->AddRef();

+            fRet = true;

+        }

+    }

 

-	if(ppBltService)

-	{

-		if(m_pParentSite)

-		{

-			fRet = m_pParentSite->GetBltService(ppBltService);

-	    }

-	    else if(m_pBltService)

-		{

-			(*ppBltService = m_pBltService)->AddRef();

-			fRet = true;

-		}

-	}

-       

-	return(fRet);

+    return(fRet);

 }

 

 void CRealMediaWindowlessSite::SetBltService(IRMAVideoSurface* pBltService)

 {

-	m_pBltService = pBltService; 

+    m_pBltService = pBltService;

 }

 

 // IRMAVideoSurface

 

 STDMETHODIMP CRealMediaWindowlessSite::Blt(UCHAR*	/*IN*/ pImageData, RMABitmapInfoHeader* /*IN*/ pBitmapInfo, REF(PNxRect) /*IN*/ inDestRect, REF(PNxRect) /*IN*/ inSrcRect)

 {

-	BeginOptimizedBlt(pBitmapInfo);

-	return OptimizedBlt(pImageData, inDestRect, inSrcRect);

+    BeginOptimizedBlt(pBitmapInfo);

+    return OptimizedBlt(pImageData, inDestRect, inSrcRect);

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::BeginOptimizedBlt(RMABitmapInfoHeader* /*IN*/ pBitmapInfo)

 {

-	if(memcmp(&m_bitmapInfo, pBitmapInfo, sizeof(RMABitmapInfoHeader)))

-	{

-		memcpy(&m_bitmapInfo, pBitmapInfo, sizeof(RMABitmapInfoHeader));

+    if(memcmp(&m_bitmapInfo, pBitmapInfo, sizeof(RMABitmapInfoHeader)))

+    {

+        memcpy(&m_bitmapInfo, pBitmapInfo, sizeof(RMABitmapInfoHeader));

 

         // format of image has changed somehow.

-		// do something here if this affects you.

-	}

+        // do something here if this affects you.

+    }

 

-/*

-	CComPtr<IRMAVideoSurface> pBltService;

-	GetBltService(&pBltService);

-	if(!pBltService)

-		return PNR_UNEXPECTED;

+    /*

+    	CComPtr<IRMAVideoSurface> pBltService;

+    	GetBltService(&pBltService);

+    	if(!pBltService)

+    		return PNR_UNEXPECTED;

 

-	RMA_COMPRESSION_TYPE ulType = (RMA_COMPRESSION_TYPE)-1;

-	pBltService->GetPreferredFormat(ulType);

+    	RMA_COMPRESSION_TYPE ulType = (RMA_COMPRESSION_TYPE)-1;

+    	pBltService->GetPreferredFormat(ulType);

 

-	if(pBitmapInfo->biCompression != ulType)

-		return PNR_UNEXPECTED;

-*/

-	return PNR_OK;

+    	if(pBitmapInfo->biCompression != ulType)

+    		return PNR_UNEXPECTED;

+    */

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::OptimizedBlt(UCHAR* /*IN*/ pImageBits, REF(PNxRect) /*IN*/ rDestRect, REF(PNxRect) /*IN*/ rSrcRect)

 {

-	CComPtr<IRMAVideoSurface> pBltService;

-	GetBltService(&pBltService);

+    CComPtr<IRMAVideoSurface> pBltService;

+    GetBltService(&pBltService);

+

+    REGION* pRegion = GetRegion();

 

-	REGION* pRegion = GetRegion();

+    if(!pBltService || !pRegion)

+        return PNR_UNEXPECTED;

 

-	if(!pBltService || !pRegion)

-		return PNR_UNEXPECTED;

+    PNxPoint origin;

+    memset(&origin, 0, sizeof(PNxPoint));

+    GetTopLeft(&origin);

+    PNxRect adjustedDestRect;

+    adjustedDestRect.left   = rDestRect.left + origin.x;

+    adjustedDestRect.top    = rDestRect.top	+ origin.y;

+    adjustedDestRect.right  = rDestRect.right + origin.x;

+    adjustedDestRect.bottom = rDestRect.bottom + origin.y;

 

-	PNxPoint origin;

-	memset(&origin, 0, sizeof(PNxPoint));

-	GetTopLeft(&origin);

-	PNxRect adjustedDestRect;

-	adjustedDestRect.left   = rDestRect.left + origin.x;

-	adjustedDestRect.top    = rDestRect.top	+ origin.y;

-	adjustedDestRect.right  = rDestRect.right + origin.x;

-	adjustedDestRect.bottom = rDestRect.bottom + origin.y;

+    for(int i = 0; i < pRegion->numRects; i++)

+    {

+        PNxRect* pRect = pRegion->rects + i;

 

-	for(int i = 0; i < pRegion->numRects; i++)

-	{

-		PNxRect* pRect = pRegion->rects+i;

-		

-		// intersect the dest rect with the rect from the

-		// region to get the final dest rect.

-		PNxRect finalDestRect;

-		IntersectRect(&adjustedDestRect, pRect, &finalDestRect);

+        // intersect the dest rect with the rect from the

+        // region to get the final dest rect.

+        PNxRect finalDestRect;

+        IntersectRect(&adjustedDestRect, pRect, &finalDestRect);

 

         // now compute the src rect for this blt.

-		double xStretch = (double) (rDestRect.right - rDestRect.left) / (double) (rSrcRect.right - rSrcRect.left);

-		double yStretch = (double) (rDestRect.bottom - rDestRect.top) / (double) (rSrcRect.bottom - rSrcRect.top);

+        double xStretch = (double)(rDestRect.right - rDestRect.left) / (double)(rSrcRect.right - rSrcRect.left);

+        double yStretch = (double)(rDestRect.bottom - rDestRect.top) / (double)(rSrcRect.bottom - rSrcRect.top);

 

-		PNxRect finalSrcRect;

-		finalSrcRect.left   = (INT32)((double)(finalDestRect.left-origin.x) / xStretch + 0.5);

-		finalSrcRect.top    = (INT32)((double)(finalDestRect.top-origin.y)	/ yStretch + 0.5);

-		finalSrcRect.right  = (INT32)((double)(finalDestRect.right-origin.x) / xStretch + 0.5);

-		finalSrcRect.bottom = (INT32)((double)(finalDestRect.bottom-origin.y) / yStretch + 0.5);

+        PNxRect finalSrcRect;

+        finalSrcRect.left   = (INT32)((double)(finalDestRect.left - origin.x) / xStretch + 0.5);

+        finalSrcRect.top    = (INT32)((double)(finalDestRect.top - origin.y)	/ yStretch + 0.5);

+        finalSrcRect.right  = (INT32)((double)(finalDestRect.right - origin.x) / xStretch + 0.5);

+        finalSrcRect.bottom = (INT32)((double)(finalDestRect.bottom - origin.y) / yStretch + 0.5);

 

-		pBltService->Blt(pImageBits, &m_bitmapInfo, finalDestRect, finalSrcRect);

-	}

+        pBltService->Blt(pImageBits, &m_bitmapInfo, finalDestRect, finalSrcRect);

+    }

 

-	return PNR_OK;

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::EndOptimizedBlt()

 {

-	memset(&m_bitmapInfo, 0, sizeof(m_bitmapInfo));

-	return PNR_OK;

+    memset(&m_bitmapInfo, 0, sizeof(m_bitmapInfo));

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::GetOptimizedFormat(REF(RMA_COMPRESSION_TYPE) /*OUT*/ ulType)

 {

-	ulType =  m_bitmapInfo.biCompression;

-	return PNR_OK;

+    ulType =  m_bitmapInfo.biCompression;

+    return PNR_OK;

 }

 

 STDMETHODIMP CRealMediaWindowlessSite::GetPreferredFormat(REF(RMA_COMPRESSION_TYPE) /*OUT*/ ulType)

 {

-	CComPtr<IRMAVideoSurface> pBltService;

-	GetBltService(&pBltService);

-	if(!pBltService)

-		return PNR_UNEXPECTED;

+    CComPtr<IRMAVideoSurface> pBltService;

+    GetBltService(&pBltService);

+    if(!pBltService)

+        return PNR_UNEXPECTED;

 

-	return pBltService->GetPreferredFormat(ulType);

+    return pBltService->GetPreferredFormat(ulType);

 }