Initial commit.

1 files changed, 1342 insertions, 0 deletions

diff --git a/fpdfsdk/src/pdfwindow/PWL_Wnd.cpp b/fpdfsdk/src/pdfwindow/PWL_Wnd.cpp
new file mode 100644
index 0000000000..035ffbbf4d
--- /dev/null
+++ b/fpdfsdk/src/pdfwindow/PWL_Wnd.cpp
@@ -0,0 +1,1342 @@
+// Copyright 2014 PDFium Authors. All rights reserved.

+// Use of this source code is governed by a BSD-style license that can be

+// found in the LICENSE file.

+ 

+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com

+

+#include "../../include/pdfwindow/PDFWindow.h"

+#include "../../include/pdfwindow/PWL_Wnd.h"

+#include "../../include/pdfwindow/PWL_Utils.h"

+#include "../../include/pdfwindow/PWL_ScrollBar.h"

+

+/* -------------------------- CPWL_Timer -------------------------- */

+

+static CFX_MapPtrTemplate<FX_INT32, CPWL_Timer*>	g_TimeMap;

+

+CPWL_Timer::CPWL_Timer(CPWL_TimerHandler* pAttached, IFX_SystemHandler* pSystemHandler) : 

+	m_pAttached(pAttached),

+	m_nTimerID(0),

+	m_pSystemHandler(pSystemHandler)

+{

+	ASSERT(m_pAttached != NULL);

+	ASSERT(m_pSystemHandler != NULL);

+}

+

+CPWL_Timer::~CPWL_Timer()

+{

+	KillPWLTimer();

+}

+

+FX_INT32 CPWL_Timer::SetPWLTimer(FX_INT32 nElapse)

+{	

+	if (m_nTimerID != 0) KillPWLTimer();

+	m_nTimerID = m_pSystemHandler->SetTimer(nElapse, TimerProc);

+	g_TimeMap.SetAt(m_nTimerID, this);

+	return m_nTimerID;

+}

+

+void CPWL_Timer::KillPWLTimer()

+{

+	if (m_nTimerID != 0)

+	{

+		m_pSystemHandler->KillTimer(m_nTimerID);

+		g_TimeMap.RemoveKey(m_nTimerID);

+		m_nTimerID = 0;

+	}

+}

+

+void CPWL_Timer::TimerProc(FX_INT32 idEvent)

+{

+	CPWL_Timer* pTimer = NULL;

+	if (g_TimeMap.Lookup(idEvent, pTimer))

+	{

+		if (pTimer)

+		{			

+			if (pTimer->m_pAttached) 

+				pTimer->m_pAttached->TimerProc();

+		}

+	}

+}

+

+/* -------------------------- CPWL_TimerHandler -------------------------- */

+

+CPWL_TimerHandler::CPWL_TimerHandler() : m_pTimer(NULL)

+{

+}

+

+CPWL_TimerHandler::~CPWL_TimerHandler()

+{

+	if (m_pTimer) delete m_pTimer;

+}

+

+void CPWL_TimerHandler::BeginTimer(FX_INT32 nElapse)

+{

+	if (!m_pTimer)

+		m_pTimer = new CPWL_Timer(this, GetSystemHandler());

+

+	if (m_pTimer)

+		m_pTimer->SetPWLTimer(nElapse);

+}

+

+void CPWL_TimerHandler::EndTimer()

+{

+	if (m_pTimer)

+		m_pTimer->KillPWLTimer();

+}

+

+void CPWL_TimerHandler::TimerProc()

+{

+}

+

+/* --------------------------- CPWL_MsgControl ---------------------------- */

+

+class CPWL_MsgControl

+{

+	friend class CPWL_Wnd;

+

+public:

+	CPWL_MsgControl(CPWL_Wnd * pWnd)

+	{

+//		PWL_TRACE("new CPWL_MsgControl\n");

+		m_pCreatedWnd = pWnd;

+		Default();

+	}

+

+	~CPWL_MsgControl()

+	{

+//		PWL_TRACE("~CPWL_MsgControl\n");

+		Default();

+	}

+

+	void Default()

+	{

+		m_aMousePath.RemoveAll();

+		m_aKeyboardPath.RemoveAll();

+		m_pMainMouseWnd = NULL;

+		m_pMainKeyboardWnd = NULL;

+	}

+

+	FX_BOOL IsWndCreated(const CPWL_Wnd * pWnd) const

+	{

+		return m_pCreatedWnd == pWnd;

+	}

+

+	FX_BOOL IsMainCaptureMouse(const CPWL_Wnd * pWnd) const

+	{

+		return pWnd == m_pMainMouseWnd;

+	}

+

+	FX_BOOL IsWndCaptureMouse(const CPWL_Wnd * pWnd) const

+	{

+		if (pWnd)

+			for( FX_INT32 i=0,sz=m_aMousePath.GetSize(); i<sz; i++)

+				if (m_aMousePath.GetAt(i) == pWnd)

+					return TRUE;

+

+		return FALSE;

+	}

+

+	FX_BOOL IsMainCaptureKeyboard(const CPWL_Wnd * pWnd) const

+	{

+		return pWnd == m_pMainKeyboardWnd;

+	}

+

+

+	FX_BOOL IsWndCaptureKeyboard(const CPWL_Wnd * pWnd) const

+	{

+		if (pWnd)

+			for( FX_INT32 i=0,sz=m_aKeyboardPath.GetSize(); i<sz; i++)

+				if (m_aKeyboardPath.GetAt(i) == pWnd)

+					return TRUE;

+		

+		return FALSE;

+	}

+

+	void SetFocus(CPWL_Wnd * pWnd)

+	{

+		m_aKeyboardPath.RemoveAll();

+

+		if (pWnd)

+		{

+			m_pMainKeyboardWnd = pWnd;

+

+			CPWL_Wnd * pParent = pWnd;

+			while (pParent)

+			{

+				m_aKeyboardPath.Add(pParent);

+				pParent = pParent->GetParentWindow();

+			}

+

+			pWnd->OnSetFocus();

+		}

+	}

+

+	void KillFocus()

+	{

+		if (m_aKeyboardPath.GetSize() > 0)

+			if (CPWL_Wnd* pWnd = m_aKeyboardPath.GetAt(0))

+				pWnd->OnKillFocus();

+

+		m_pMainKeyboardWnd = NULL;

+		m_aKeyboardPath.RemoveAll();

+	}

+

+	void SetCapture(CPWL_Wnd * pWnd)

+	{

+		m_aMousePath.RemoveAll();

+

+		if (pWnd)

+		{

+			m_pMainMouseWnd = pWnd;

+

+			CPWL_Wnd * pParent = pWnd;

+			while (pParent)

+			{

+				m_aMousePath.Add(pParent);

+				pParent = pParent->GetParentWindow();

+			}

+		}

+	}

+

+	void ReleaseCapture()

+	{

+		m_pMainMouseWnd = NULL;

+		m_aMousePath.RemoveAll();

+	}

+

+private:

+	CFX_ArrayTemplate<CPWL_Wnd*>	m_aMousePath;

+	CFX_ArrayTemplate<CPWL_Wnd*>	m_aKeyboardPath;

+	CPWL_Wnd*						m_pCreatedWnd;

+	CPWL_Wnd*						m_pMainMouseWnd;

+	CPWL_Wnd*						m_pMainKeyboardWnd;

+};

+

+/* --------------------------- CPWL_Wnd ---------------------------- */

+

+CPWL_Wnd::CPWL_Wnd() :

+	m_pVScrollBar(NULL),

+	m_rcWindow(),

+	m_rcClip(),

+	m_bCreated(FALSE),			

+	m_bVisible(FALSE),

+	m_bNotifying(FALSE),

+	m_bEnabled(TRUE)

+{

+}

+

+CPWL_Wnd::~CPWL_Wnd()

+{

+	ASSERT(m_bCreated == FALSE);

+}

+

+CFX_ByteString CPWL_Wnd::GetClassName() const

+{

+	return "CPWL_Wnd";

+}

+

+void CPWL_Wnd::Create(const PWL_CREATEPARAM & cp)

+{

+	if (!IsValid())

+	{

+		m_sPrivateParam = cp;

+

+		OnCreate(m_sPrivateParam);

+

+		m_sPrivateParam.rcRectWnd.Normalize();

+		m_rcWindow = m_sPrivateParam.rcRectWnd;

+		m_rcClip = CPWL_Utils::InflateRect(m_rcWindow,1.0f);

+

+		CreateMsgControl();

+

+		if (m_sPrivateParam.pParentWnd)

+			m_sPrivateParam.pParentWnd->OnNotify(this, PNM_ADDCHILD);

+

+		PWL_CREATEPARAM ccp = m_sPrivateParam;

+

+		ccp.dwFlags &= 0xFFFF0000L; //remove sub styles

+		ccp.mtChild = CPDF_Matrix(1,0,0,1,0,0);

+		

+		CreateScrollBar(ccp);

+		CreateChildWnd(ccp); 

+

+		m_bVisible = HasFlag(PWS_VISIBLE);

+

+		OnCreated();

+

+		RePosChildWnd();

+		m_bCreated = TRUE;

+	}

+}

+

+void CPWL_Wnd::OnCreate(PWL_CREATEPARAM & cp)

+{

+}

+

+void CPWL_Wnd::OnCreated()

+{

+}

+

+void CPWL_Wnd::OnDestroy()

+{

+}

+

+void CPWL_Wnd::Destroy()

+{

+	KillFocus();

+

+	OnDestroy();

+

+	if (m_bCreated)

+	{

+		for (FX_INT32 i = m_aChildren.GetSize()-1; i >= 0; i --)

+		{

+			if (CPWL_Wnd * pChild = m_aChildren[i])

+			{

+				pChild->Destroy();

+				delete pChild;

+				pChild = NULL;

+			}

+		}

+

+		if (m_sPrivateParam.pParentWnd)

+			m_sPrivateParam.pParentWnd->OnNotify(this, PNM_REMOVECHILD);

+		m_bCreated = FALSE;

+	}

+

+	DestroyMsgControl();

+

+	FXSYS_memset(&m_sPrivateParam, 0, sizeof(PWL_CREATEPARAM));

+	m_aChildren.RemoveAll();	

+	m_pVScrollBar = NULL;

+}

+

+void CPWL_Wnd::Move(const CPDF_Rect & rcNew, FX_BOOL bReset,FX_BOOL bRefresh)

+{

+	if (IsValid())

+	{

+		CPDF_Rect rcOld = this->GetWindowRect();

+

+		m_rcWindow = rcNew;

+		m_rcWindow.Normalize();

+		//m_rcClip = CPWL_Utils::InflateRect(m_rcWindow,1.0f); //for special caret 

+

+		if (rcOld.left != rcNew.left || rcOld.right != rcNew.right ||

+			rcOld.top != rcNew.top || rcOld.bottom != rcNew.bottom)

+		{

+			if (bReset)

+			{

+				RePosChildWnd();	

+			}	

+

+		}

+		if (bRefresh)

+		{	

+			InvalidateRectMove(rcOld,rcNew);

+		}

+

+		m_sPrivateParam.rcRectWnd = m_rcWindow;

+	}

+}

+

+void  CPWL_Wnd::InvalidateRectMove(const CPDF_Rect & rcOld, const CPDF_Rect & rcNew)

+{

+	CPDF_Rect rcUnion = rcOld;

+	rcUnion.Union(rcNew);

+

+	InvalidateRect(&rcUnion);

+

+	/*

+	CPDF_Rect SubArray[4]; 

+

+	rcOld.Substract4(rcNew,SubArray);

+	for (FX_INT32 i=0;i<4;i++)

+	{

+		if (SubArray[i].left == 0 &&

+			SubArray[i].right == 0 &&

+			SubArray[i].top == 0 &&

+			SubArray[i].bottom == 0)continue;

+

+		InvalidateRect(&CPWL_Utils::InflateRect(SubArray[i],2));

+	}

+

+	rcNew.Substract4(rcOld,SubArray);

+	for (FX_INT32 j=0;j<4;j++)

+	{

+		if (SubArray[j].left == 0 &&

+			SubArray[j].right == 0 &&

+			SubArray[j].top == 0 &&

+			SubArray[j].bottom == 0)continue;

+

+		InvalidateRect(&CPWL_Utils::InflateRect(SubArray[j],2));

+	}

+	*/

+}

+

+void CPWL_Wnd::GetAppearanceStream(CFX_ByteString & sAppStream)

+{

+	if (IsValid())

+	{

+		CFX_ByteTextBuf sTextBuf;

+		GetAppearanceStream(sTextBuf);

+		sAppStream += sTextBuf.GetByteString();

+	}

+}

+

+void CPWL_Wnd::GetAppearanceStream(CFX_ByteTextBuf & sAppStream)

+{

+	if (IsValid() && IsVisible())

+	{

+		GetThisAppearanceStream(sAppStream);

+		GetChildAppearanceStream(sAppStream);

+	}

+}

+

+//if don't set,Get default apperance stream

+void CPWL_Wnd::GetThisAppearanceStream(CFX_ByteTextBuf & sAppStream)

+{

+	CPDF_Rect rectWnd = GetWindowRect();

+	if (!rectWnd.IsEmpty())

+	{

+		CFX_ByteTextBuf sThis;

+

+		if (HasFlag(PWS_BACKGROUND))

+			sThis << CPWL_Utils::GetRectFillAppStream(rectWnd,this->GetBackgroundColor());

+

+		if (HasFlag(PWS_BORDER))

+			sThis << CPWL_Utils::GetBorderAppStream(rectWnd,

+									(FX_FLOAT)GetBorderWidth(),

+									GetBorderColor(),

+									this->GetBorderLeftTopColor(this->GetBorderStyle()),

+									this->GetBorderRightBottomColor(this->GetBorderStyle()),

+									this->GetBorderStyle(),

+									this->GetBorderDash());

+

+		sAppStream << sThis;

+	}

+}

+

+void CPWL_Wnd::GetChildAppearanceStream(CFX_ByteTextBuf & sAppStream)

+{

+	for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)

+	{

+		if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))

+		{

+			pChild->GetAppearanceStream(sAppStream);

+		}

+	}

+}

+

+void CPWL_Wnd::DrawAppearance(CFX_RenderDevice* pDevice, CPDF_Matrix* pUser2Device)

+{

+	if (IsValid() && IsVisible())

+	{

+		DrawThisAppearance(pDevice,pUser2Device);

+		DrawChildAppearance(pDevice,pUser2Device);

+	}

+}

+

+void CPWL_Wnd::DrawThisAppearance(CFX_RenderDevice* pDevice, CPDF_Matrix* pUser2Device)

+{

+	CPDF_Rect rectWnd = GetWindowRect();

+	if (!rectWnd.IsEmpty())

+	{		

+		if (HasFlag(PWS_BACKGROUND))

+		{

+			CPDF_Rect rcClient = CPWL_Utils::DeflateRect(rectWnd,(FX_FLOAT)(GetBorderWidth()+GetInnerBorderWidth()));

+			CPWL_Utils::DrawFillRect(pDevice,pUser2Device,rcClient,this->GetBackgroundColor(),GetTransparency());

+		}

+

+		if (HasFlag(PWS_BORDER))

+			CPWL_Utils::DrawBorder(pDevice,

+								pUser2Device,

+								rectWnd,

+								(FX_FLOAT)GetBorderWidth(),

+								GetBorderColor(),

+								this->GetBorderLeftTopColor(this->GetBorderStyle()),

+								this->GetBorderRightBottomColor(this->GetBorderStyle()),

+								this->GetBorderStyle(),

+								this->GetBorderDash(),

+								GetTransparency());								

+	}

+}

+

+void CPWL_Wnd::DrawChildAppearance(CFX_RenderDevice* pDevice, CPDF_Matrix* pUser2Device)

+{

+	for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)

+	{

+		if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))

+		{

+			CPDF_Matrix mt = pChild->GetChildMatrix();

+			if (mt.IsIdentity())

+			{

+				pChild->DrawAppearance(pDevice,pUser2Device);

+			}

+			else

+			{

+				mt.Concat(*pUser2Device);

+				pChild->DrawAppearance(pDevice,&mt);

+			}

+		}

+	}

+}

+

+void CPWL_Wnd::InvalidateRect(CPDF_Rect* pRect)

+{

+	if (IsValid())

+	{

+		CPDF_Rect rcRefresh = pRect ? *pRect : GetWindowRect();

+

+		if (!HasFlag(PWS_NOREFRESHCLIP))

+		{

+			CPDF_Rect rcClip = GetClipRect();		

+			if (!rcClip.IsEmpty())

+			{

+				rcRefresh.Intersect(rcClip);

+			}

+		}

+

+		FX_RECT rcWin = PWLtoWnd(rcRefresh);

+		rcWin.left -= PWL_INVALIDATE_INFLATE;

+		rcWin.top -= PWL_INVALIDATE_INFLATE;

+		rcWin.right += PWL_INVALIDATE_INFLATE;

+		rcWin.bottom += PWL_INVALIDATE_INFLATE;

+

+		if (IFX_SystemHandler* pSH = GetSystemHandler())

+		{

+			if (FX_HWND hWnd = GetAttachedHWnd())

+			{

+				pSH->InvalidateRect(hWnd, rcWin);

+			}

+		}

+	}

+}

+

+#define PWL_IMPLEMENT_KEY_METHOD(key_method_name)\

+FX_BOOL CPWL_Wnd::key_method_name(FX_WORD nChar, FX_DWORD nFlag)\

+{\

+	if (IsValid() && IsVisible() && IsEnabled())\

+	{\

+		if (IsWndCaptureKeyboard(this))\

+		{\

+			for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)\

+			{\

+				if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))\

+				{\

+					if (IsWndCaptureKeyboard(pChild))\

+					{\

+						return pChild->key_method_name(nChar,nFlag);\

+					}\

+				}\

+			}\

+		}\

+	}\

+	return FALSE;\

+}

+

+#define PWL_IMPLEMENT_MOUSE_METHOD(mouse_method_name)\

+FX_BOOL CPWL_Wnd::mouse_method_name(const CPDF_Point & point, FX_DWORD nFlag)\

+{\

+	if (IsValid() && IsVisible() && IsEnabled())\

+	{\

+		if (IsWndCaptureMouse(this))\

+		{\

+			for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)\

+			{\

+				if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))\

+				{\

+					if (IsWndCaptureMouse(pChild))\

+					{\

+						return pChild->mouse_method_name(pChild->ParentToChild(point),nFlag);\

+					}\

+				}\

+			}\

+			SetCursor();\

+		}\

+		else\

+		{\

+			for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)\

+			{\

+				if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))\

+				{\

+					if (pChild->WndHitTest(pChild->ParentToChild(point)))\

+					{\

+						return pChild->mouse_method_name(pChild->ParentToChild(point),nFlag);\

+					}\

+				}\

+			}\

+			if (this->WndHitTest(point))\

+				SetCursor();\

+		}\

+	}\

+	return FALSE;\

+}

+

+PWL_IMPLEMENT_KEY_METHOD(OnKeyDown)

+PWL_IMPLEMENT_KEY_METHOD(OnKeyUp)

+PWL_IMPLEMENT_KEY_METHOD(OnChar)

+

+PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonDblClk)

+PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonDown)

+PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonUp)

+PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonDblClk)

+PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonDown)

+PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonUp)

+PWL_IMPLEMENT_MOUSE_METHOD(OnRButtonDblClk)

+PWL_IMPLEMENT_MOUSE_METHOD(OnRButtonDown)

+PWL_IMPLEMENT_MOUSE_METHOD(OnRButtonUp)

+PWL_IMPLEMENT_MOUSE_METHOD(OnMouseMove)

+

+FX_BOOL	CPWL_Wnd::OnMouseWheel(short zDelta, const CPDF_Point & point, FX_DWORD nFlag)

+{

+	if (IsValid() && IsVisible() && IsEnabled())

+	{

+		SetCursor();

+		if (IsWndCaptureKeyboard(this))

+		{

+			for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)

+			{

+				if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))

+				{

+					if (IsWndCaptureKeyboard(pChild))

+					{

+						return pChild->OnMouseWheel(zDelta,pChild->ParentToChild(point), nFlag);

+					}

+				}

+			}

+		}

+	}

+	return FALSE;

+}

+

+void CPWL_Wnd::AddChild(CPWL_Wnd * pWnd)

+{

+	m_aChildren.Add(pWnd);

+}

+

+void CPWL_Wnd::RemoveChild(CPWL_Wnd * pWnd)

+{

+	for (FX_INT32 i = m_aChildren.GetSize()-1; i >= 0; i --)

+	{

+		if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))

+		{

+			if (pChild == pWnd)

+			{

+				m_aChildren.RemoveAt(i);

+				break;

+			}

+		}

+	}

+}

+

+void CPWL_Wnd::OnNotify(CPWL_Wnd* pWnd, FX_DWORD msg, FX_INTPTR wParam, FX_INTPTR lParam)

+{

+	switch (msg)

+	{

+	case PNM_ADDCHILD:

+		this->AddChild(pWnd);

+		break;

+	case PNM_REMOVECHILD:

+		this->RemoveChild(pWnd);

+		break;

+	default:

+		break;

+	}

+}

+

+FX_BOOL CPWL_Wnd::IsValid() const

+{

+	return m_bCreated;

+}

+

+PWL_CREATEPARAM CPWL_Wnd::GetCreationParam() const

+{

+	return m_sPrivateParam;

+}

+

+CPWL_Wnd* CPWL_Wnd::GetParentWindow() const

+{

+	return m_sPrivateParam.pParentWnd;

+}

+

+CPDF_Rect CPWL_Wnd::GetOriginWindowRect() const

+{

+	return m_sPrivateParam.rcRectWnd;

+}

+

+CPDF_Rect CPWL_Wnd::GetWindowRect() const

+{

+	return m_rcWindow;

+}

+

+CPDF_Rect CPWL_Wnd::GetClientRect() const

+{

+	CPDF_Rect rcWindow = GetWindowRect();

+	CPDF_Rect rcClient = CPWL_Utils::DeflateRect(rcWindow,(FX_FLOAT)(GetBorderWidth()+GetInnerBorderWidth()));

+

+	if (CPWL_ScrollBar * pVSB = this->GetVScrollBar())

+		rcClient.right -= pVSB->GetScrollBarWidth();

+

+	rcClient.Normalize();

+

+	if (rcWindow.Contains(rcClient))

+		return rcClient;

+	else

+		return CPDF_Rect();

+}

+

+CPDF_Point CPWL_Wnd::GetCenterPoint() const

+{

+	CPDF_Rect rcClient = GetClientRect();

+

+	return CPDF_Point((rcClient.left + rcClient.right) * 0.5f,

+		(rcClient.top + rcClient.bottom) * 0.5f);

+}

+

+CPDF_Rect CPWL_Wnd::GetClientCenterSquare() const

+{

+	return CPWL_Utils::GetCenterSquare(GetClientRect());

+}

+

+CPDF_Rect CPWL_Wnd::GetWindowCenterSquare() const

+{

+	return CPWL_Utils::GetCenterSquare(CPWL_Utils::DeflateRect(GetWindowRect(),0.1f));

+}

+

+FX_BOOL CPWL_Wnd::HasFlag(FX_DWORD dwFlags) const

+{

+	return (m_sPrivateParam.dwFlags & dwFlags) != 0;

+}

+

+void CPWL_Wnd::RemoveFlag(FX_DWORD dwFlags)

+{

+	m_sPrivateParam.dwFlags &= ~dwFlags;

+}

+

+void CPWL_Wnd::AddFlag(FX_DWORD dwFlags)

+{

+	m_sPrivateParam.dwFlags |= dwFlags;

+}

+

+CPWL_Color CPWL_Wnd::GetBackgroundColor() const

+{

+	return m_sPrivateParam.sBackgroundColor;

+}

+

+void CPWL_Wnd::SetBackgroundColor(const CPWL_Color & color)

+{

+	m_sPrivateParam.sBackgroundColor = color;

+}

+

+void CPWL_Wnd::SetTextColor(const CPWL_Color & color)

+{

+	m_sPrivateParam.sTextColor = color;

+}

+

+void CPWL_Wnd::SetTextStrokeColor(const CPWL_Color & color)

+{

+	m_sPrivateParam.sTextStrokeColor = color;

+}

+

+CPWL_Color CPWL_Wnd::GetTextColor() const

+{

+	return m_sPrivateParam.sTextColor;

+}

+

+CPWL_Color CPWL_Wnd::GetTextStrokeColor() const

+{

+	return m_sPrivateParam.sTextStrokeColor;

+}

+

+FX_INT32 CPWL_Wnd::GetBorderStyle() const

+{

+	return m_sPrivateParam.nBorderStyle;

+}

+

+void CPWL_Wnd::SetBorderStyle(FX_INT32 nBorderStyle)

+{

+	if (HasFlag(PWS_BORDER))

+		m_sPrivateParam.nBorderStyle = nBorderStyle;

+}

+

+FX_INT32 CPWL_Wnd::GetBorderWidth() const

+{

+	if (HasFlag(PWS_BORDER))

+		return m_sPrivateParam.dwBorderWidth;

+

+	return 0;

+}

+

+FX_INT32 CPWL_Wnd::GetInnerBorderWidth() const

+{

+	/*

+	switch (GetBorderStyle())

+	{

+	case PBS_BEVELED:

+	case PBS_INSET:

+		return GetBorderWidth() / 2;

+	}

+	*/

+	return 0;

+}

+

+void CPWL_Wnd::SetBorderWidth(FX_INT32 nBorderWidth)

+{

+	if (HasFlag(PWS_BORDER))

+		m_sPrivateParam.dwBorderWidth = nBorderWidth;

+}

+

+CPWL_Color CPWL_Wnd::GetBorderColor() const

+{

+	if (HasFlag(PWS_BORDER))

+		return m_sPrivateParam.sBorderColor;

+

+	return CPWL_Color();

+}

+

+void CPWL_Wnd::SetBorderColor(const CPWL_Color & color)

+{

+	if (HasFlag(PWS_BORDER))

+		m_sPrivateParam.sBorderColor = color;

+}

+

+CPWL_Dash CPWL_Wnd::GetBorderDash() const

+{

+	return m_sPrivateParam.sDash;

+}

+

+void* CPWL_Wnd::GetAttachedData() const

+{

+	return m_sPrivateParam.pAttachedData;

+}

+

+void CPWL_Wnd::SetBorderDash(const CPWL_Dash & sDash)

+{

+	if (HasFlag(PWS_BORDER))

+		m_sPrivateParam.sDash = sDash;

+}

+

+CPWL_ScrollBar* CPWL_Wnd::GetVScrollBar() const

+{

+	if (HasFlag(PWS_VSCROLL))

+		return m_pVScrollBar;

+

+	return NULL;

+}

+

+void CPWL_Wnd::CreateScrollBar(const PWL_CREATEPARAM & cp)

+{

+	CreateVScrollBar(cp);

+}

+

+void CPWL_Wnd::CreateVScrollBar(const PWL_CREATEPARAM & cp)

+{

+	if (!m_pVScrollBar && HasFlag(PWS_VSCROLL))

+	{

+		PWL_CREATEPARAM scp = cp;

+

+		//flags

+		scp.dwFlags = PWS_CHILD| PWS_BACKGROUND | PWS_AUTOTRANSPARENT | PWS_NOREFRESHCLIP;

+		

+		scp.pParentWnd = this;

+		scp.sBackgroundColor = PWL_DEFAULT_WHITECOLOR;

+		scp.eCursorType = FXCT_ARROW;

+		scp.nTransparency = PWL_SCROLLBAR_TRANSPARANCY;

+

+		if ((m_pVScrollBar = new CPWL_ScrollBar(SBT_VSCROLL)))

+			m_pVScrollBar->Create(scp);

+	}

+}

+

+void CPWL_Wnd::SetCapture()

+{

+	if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())

+		pMsgCtrl->SetCapture(this);

+}

+

+void CPWL_Wnd::ReleaseCapture()

+{

+	for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)

+		if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))

+			pChild->ReleaseCapture();

+

+	if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())

+		pMsgCtrl->ReleaseCapture();

+}

+

+void CPWL_Wnd::SetFocus()

+{

+	if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())

+	{

+		if (!pMsgCtrl->IsMainCaptureKeyboard(this))

+			pMsgCtrl->KillFocus();

+		pMsgCtrl->SetFocus(this);

+	}

+}

+

+void CPWL_Wnd::KillFocus()

+{

+	if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())

+	{

+		if (pMsgCtrl->IsWndCaptureKeyboard(this))

+			pMsgCtrl->KillFocus();

+	}

+}

+

+void CPWL_Wnd::OnSetFocus()

+{

+}

+

+void CPWL_Wnd::OnKillFocus()

+{

+}

+

+FX_BOOL	CPWL_Wnd::WndHitTest(const CPDF_Point & point) const

+{

+	return IsValid() && IsVisible() && GetWindowRect().Contains(point.x,point.y);

+}

+

+FX_BOOL CPWL_Wnd::ClientHitTest(const CPDF_Point & point) const

+{

+	return IsValid() && IsVisible() && GetClientRect().Contains(point.x,point.y);

+}

+

+const CPWL_Wnd * CPWL_Wnd::GetRootWnd() const

+{

+	if (m_sPrivateParam.pParentWnd)

+		return m_sPrivateParam.pParentWnd->GetRootWnd();

+	else

+		return this;

+}

+

+void CPWL_Wnd::SetVisible(FX_BOOL bVisible)

+{

+	if (IsValid())

+	{

+		for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)

+		{

+			if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))

+			{

+				pChild->SetVisible(bVisible);

+			}

+		}

+

+		if (bVisible != m_bVisible)

+		{

+			m_bVisible = bVisible;

+			RePosChildWnd();		

+			InvalidateRect();

+		}	

+	}

+}

+

+void CPWL_Wnd::SetClipRect(const CPDF_Rect & rect)

+{

+	m_rcClip = rect;

+	m_rcClip.Normalize();

+}

+

+CPDF_Rect CPWL_Wnd::GetClipRect() const

+{

+	return m_rcClip;

+}

+

+FX_BOOL	CPWL_Wnd::IsReadOnly() const

+{

+	return HasFlag(PWS_READONLY);

+}

+

+void CPWL_Wnd::RePosChildWnd()

+{

+	CPDF_Rect rcContent = CPWL_Utils::DeflateRect(GetWindowRect(),(FX_FLOAT)(GetBorderWidth()+GetInnerBorderWidth()));

+

+	CPWL_ScrollBar * pVSB = this->GetVScrollBar();

+

+	CPDF_Rect rcVScroll = CPDF_Rect(rcContent.right - PWL_SCROLLBAR_WIDTH,

+							rcContent.bottom,

+							rcContent.right-1.0f,

+							rcContent.top);

+

+	if (pVSB) pVSB->Move(rcVScroll,TRUE,FALSE);

+}

+

+void CPWL_Wnd::CreateChildWnd(const PWL_CREATEPARAM & cp)

+{

+}

+

+void CPWL_Wnd::SetCursor()

+{

+	if (IsValid()) 

+	{

+		if (IFX_SystemHandler* pSH = GetSystemHandler())

+		{

+			FX_INT32 nCursorType = this->GetCreationParam().eCursorType;

+			pSH->SetCursor(nCursorType);

+		}

+	}

+}

+

+void CPWL_Wnd::CreateMsgControl()

+{

+	if (!m_sPrivateParam.pMsgControl)

+		m_sPrivateParam.pMsgControl = new CPWL_MsgControl(this);

+}

+

+void CPWL_Wnd::DestroyMsgControl()

+{

+	if (CPWL_MsgControl* pMsgControl = GetMsgControl())

+		if (pMsgControl->IsWndCreated(this))

+			delete pMsgControl;

+}

+

+CPWL_MsgControl* CPWL_Wnd::GetMsgControl() const

+{

+	return m_sPrivateParam.pMsgControl;

+}

+

+FX_BOOL CPWL_Wnd::IsCaptureMouse() const

+{

+	return IsWndCaptureMouse(this);

+}

+

+FX_BOOL CPWL_Wnd::IsWndCaptureMouse(const CPWL_Wnd * pWnd) const

+{

+	if (CPWL_MsgControl * pCtrl = GetMsgControl())

+		return pCtrl->IsWndCaptureMouse(pWnd);

+

+	return FALSE;

+}

+

+FX_BOOL CPWL_Wnd::IsWndCaptureKeyboard(const CPWL_Wnd * pWnd) const

+{

+	if (CPWL_MsgControl * pCtrl = GetMsgControl())

+		return pCtrl->IsWndCaptureKeyboard(pWnd);

+

+	return FALSE;

+}

+

+FX_BOOL CPWL_Wnd::IsFocused() const

+{

+	if (CPWL_MsgControl * pCtrl = GetMsgControl())

+		return pCtrl->IsMainCaptureKeyboard(this);

+

+	return FALSE;

+}

+

+CPDF_Rect CPWL_Wnd::GetFocusRect() const

+{

+	return CPWL_Utils::InflateRect(this->GetWindowRect(),1);

+}

+

+FX_FLOAT CPWL_Wnd::GetFontSize() const

+{

+	return this->m_sPrivateParam.fFontSize;

+}

+

+void CPWL_Wnd::SetFontSize(FX_FLOAT fFontSize)

+{

+	this->m_sPrivateParam.fFontSize = fFontSize;

+}

+

+IFX_SystemHandler* CPWL_Wnd::GetSystemHandler() const

+{

+	return m_sPrivateParam.pSystemHandler;

+}

+

+IPWL_FocusHandler* CPWL_Wnd::GetFocusHandler() const

+{

+	return m_sPrivateParam.pFocusHandler;

+}

+

+IPWL_Provider* CPWL_Wnd::GetProvider() const

+{

+	return m_sPrivateParam.pProvider;

+}

+

+IFX_Edit_FontMap* CPWL_Wnd::GetFontMap() const

+{

+	return m_sPrivateParam.pFontMap;

+}

+

+CPWL_Color CPWL_Wnd::GetBorderLeftTopColor(FX_INT32 nBorderStyle) const

+{

+	CPWL_Color color;

+

+	switch (nBorderStyle)

+	{

+		case PBS_SOLID:

+			break;

+		case PBS_DASH:

+			break;

+		case PBS_BEVELED:

+			color = CPWL_Color(COLORTYPE_GRAY,1);

+			break;

+		case PBS_INSET:

+			color = CPWL_Color(COLORTYPE_GRAY,0.5f);

+			break;

+		case PBS_UNDERLINED:

+			break;

+	}

+

+	return color;

+}

+

+CPWL_Color CPWL_Wnd::GetBorderRightBottomColor(FX_INT32 nBorderStyle) const

+{

+	CPWL_Color color;

+

+	switch (nBorderStyle)

+	{

+		case PBS_SOLID:

+			break;

+		case PBS_DASH:

+			break;

+		case PBS_BEVELED:

+			color = CPWL_Utils::DevideColor(GetBackgroundColor(),2);

+			break;

+		case PBS_INSET:

+			color = CPWL_Color(COLORTYPE_GRAY,0.75f);

+			break;

+		case PBS_UNDERLINED:

+			break;

+	}

+

+	return color;

+}

+

+/* ----------------------------------------------------------------- */

+

+FX_INT32 CPWL_Wnd::GetTransparency()

+{

+	return m_sPrivateParam.nTransparency;

+}

+

+void CPWL_Wnd::SetTransparency(FX_INT32 nTransparency)

+{

+	for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)

+	{

+		if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))

+		{

+			pChild->SetTransparency(nTransparency);

+		}

+	}

+

+	m_sPrivateParam.nTransparency = nTransparency;

+}

+

+CPDF_Matrix	CPWL_Wnd::GetWindowMatrix() const

+{

+	CPDF_Matrix mt = this->GetChildToRoot();

+

+	if (IPWL_Provider* pProvider = GetProvider())

+	{

+		mt.Concat(pProvider->GetWindowMatrix(GetAttachedData()));

+		return mt;

+	}

+

+/*

+	if (CReader_App* pApp = CPWL_Module::GetReaderApp())

+		if (CReader_Document* pDocument = pApp->GetCurrentDocument())

+			if (CReader_DocView* pDocView = pDocument->GetCurrentDocView())

+			{

+				CPDF_Matrix mtPageView;

+				pDocView->GetCurrentMatrix(mtPageView);

+				mt.Concat(mtPageView);

+				return mt;

+			}		

+			

+*/

+

+	return mt;

+}

+

+void CPWL_Wnd::PWLtoWnd(const CPDF_Point& point, FX_INT32& x, FX_INT32& y) const

+{

+	CPDF_Matrix mt = GetWindowMatrix();

+	CPDF_Point pt = point;

+	mt.Transform(pt.x,pt.y);

+	x = (FX_INT32)(pt.x+0.5);

+	y = (FX_INT32)(pt.y+0.5);

+}

+

+FX_RECT CPWL_Wnd::PWLtoWnd(const CPDF_Rect & rect) const

+{

+	CPDF_Rect rcTemp = rect;

+	CPDF_Matrix mt = GetWindowMatrix();

+	mt.TransformRect(rcTemp);	

+	return FX_RECT((FX_INT32)(rcTemp.left+0.5), (FX_INT32)(rcTemp.bottom+0.5), (FX_INT32)(rcTemp.right+0.5), (FX_INT32)(rcTemp.top+0.5));

+}

+

+FX_HWND CPWL_Wnd::GetAttachedHWnd() const

+{

+	return m_sPrivateParam.hAttachedWnd;

+}

+

+CPDF_Point CPWL_Wnd::ChildToParent(const CPDF_Point& point) const

+{

+	CPDF_Matrix mt = GetChildMatrix();

+	if (mt.IsIdentity())

+		return point;

+	else

+	{

+		CPDF_Point pt = point;

+		mt.Transform(pt.x,pt.y);

+		return pt;

+	}

+}

+

+CPDF_Rect CPWL_Wnd::ChildToParent(const CPDF_Rect& rect) const

+{

+	CPDF_Matrix mt = GetChildMatrix();

+	if (mt.IsIdentity())

+		return rect;

+	else

+	{

+		CPDF_Rect rc = rect;

+		mt.TransformRect(rc);

+		return rc;

+	}

+}

+

+CPDF_Point CPWL_Wnd::ParentToChild(const CPDF_Point& point) const

+{

+	CPDF_Matrix mt = GetChildMatrix();

+	if (mt.IsIdentity())

+		return point;

+	else

+	{

+		mt.SetReverse(mt);

+		CPDF_Point pt = point;

+		mt.Transform(pt.x,pt.y);

+		return pt;

+	}

+}

+

+CPDF_Rect CPWL_Wnd::ParentToChild(const CPDF_Rect& rect) const

+{

+	CPDF_Matrix mt = GetChildMatrix();

+	if (mt.IsIdentity())

+		return rect;

+	else

+	{

+		mt.SetReverse(mt);

+		CPDF_Rect rc = rect;

+		mt.TransformRect(rc);

+		return rc;

+	}

+}

+

+CPDF_Matrix CPWL_Wnd::GetChildToRoot() const

+{

+	CPDF_Matrix mt(1,0,0,1,0,0);

+	

+	if (HasFlag(PWS_CHILD))

+	{

+		const CPWL_Wnd* pParent = this;

+		while (pParent)

+		{

+			mt.Concat(pParent->GetChildMatrix());

+			pParent = pParent->GetParentWindow();

+		}

+	}

+

+	return mt;

+}

+

+CPDF_Matrix CPWL_Wnd::GetChildMatrix() const

+{

+	if (HasFlag(PWS_CHILD))

+		return m_sPrivateParam.mtChild;

+

+	return CPDF_Matrix(1,0,0,1,0,0);

+}

+

+void CPWL_Wnd::SetChildMatrix(const CPDF_Matrix& mt)

+{

+	m_sPrivateParam.mtChild = mt;

+}

+

+const CPWL_Wnd*	CPWL_Wnd::GetFocused() const

+{

+	if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())

+	{

+		return pMsgCtrl->m_pMainKeyboardWnd;

+	}

+

+	return NULL;

+}

+

+void CPWL_Wnd::EnableWindow(FX_BOOL bEnable)

+{

+	if (m_bEnabled != bEnable)

+	{

+		for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)

+		{

+			if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))

+			{

+				pChild->EnableWindow(bEnable);

+			}

+		}

+

+		this->m_bEnabled = bEnable;

+

+		if (bEnable)

+			this->OnEnabled();

+		else

+			this->OnDisabled();

+	}

+}

+

+FX_BOOL CPWL_Wnd::IsEnabled()

+{

+	return m_bEnabled;

+}

+

+void CPWL_Wnd::OnEnabled()

+{

+}

+

+void CPWL_Wnd::OnDisabled()

+{

+}

+

+FX_BOOL CPWL_Wnd::IsCTRLpressed(FX_DWORD nFlag) const

+{

+	if (IFX_SystemHandler* pSystemHandler = GetSystemHandler())

+	{

+		return pSystemHandler->IsCTRLKeyDown(nFlag);

+	}

+

+	return FALSE;

+}

+

+FX_BOOL	CPWL_Wnd::IsSHIFTpressed(FX_DWORD nFlag) const

+{

+	if (IFX_SystemHandler* pSystemHandler = GetSystemHandler())

+	{

+		return pSystemHandler->IsSHIFTKeyDown(nFlag);

+	}

+

+	return FALSE;

+}

+

+FX_BOOL	CPWL_Wnd::IsALTpressed(FX_DWORD nFlag) const

+{

+	if (IFX_SystemHandler* pSystemHandler = GetSystemHandler())

+	{

+		return pSystemHandler->IsALTKeyDown(nFlag);

+	}

+

+	return FALSE;

+}

+

+FX_BOOL	CPWL_Wnd::IsINSERTpressed(FX_DWORD nFlag) const

+{

+	if (IFX_SystemHandler* pSystemHandler = GetSystemHandler())

+	{

+		return pSystemHandler->IsINSERTKeyDown(nFlag);

+	}

+

+	return FALSE;

+}

+