diff options
Diffstat (limited to 'fpdfsdk/src/pdfwindow/PWL_Wnd.cpp')
| -rw-r--r-- | fpdfsdk/src/pdfwindow/PWL_Wnd.cpp | 1342 |
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;
+}
+
|