1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include "../../include/pdfwindow/PDFWindow.h"
8 #include "../../include/pdfwindow/PWL_Wnd.h"
9 #include "../../include/pdfwindow/PWL_Utils.h"
10 #include "../../include/pdfwindow/PWL_ScrollBar.h"
11
12 /* -------------------------- CPWL_Timer -------------------------- */
13
GetPWLTimeMap()14 static CFX_MapPtrTemplate<FX_INT32, CPWL_Timer*>& GetPWLTimeMap()
15 {
16 // Leak the object at shutdown.
17 static auto timeMap = new CFX_MapPtrTemplate<FX_INT32, CPWL_Timer*>;
18 return *timeMap;
19 }
20
CPWL_Timer(CPWL_TimerHandler * pAttached,IFX_SystemHandler * pSystemHandler)21 CPWL_Timer::CPWL_Timer(CPWL_TimerHandler* pAttached, IFX_SystemHandler* pSystemHandler) :
22 m_nTimerID(0),
23 m_pAttached(pAttached),
24 m_pSystemHandler(pSystemHandler)
25 {
26 ASSERT(m_pAttached != NULL);
27 ASSERT(m_pSystemHandler != NULL);
28 }
29
~CPWL_Timer()30 CPWL_Timer::~CPWL_Timer()
31 {
32 KillPWLTimer();
33 }
34
SetPWLTimer(FX_INT32 nElapse)35 FX_INT32 CPWL_Timer::SetPWLTimer(FX_INT32 nElapse)
36 {
37 if (m_nTimerID != 0) KillPWLTimer();
38 m_nTimerID = m_pSystemHandler->SetTimer(nElapse, TimerProc);
39 GetPWLTimeMap().SetAt(m_nTimerID, this);
40 return m_nTimerID;
41 }
42
KillPWLTimer()43 void CPWL_Timer::KillPWLTimer()
44 {
45 if (m_nTimerID != 0)
46 {
47 m_pSystemHandler->KillTimer(m_nTimerID);
48 GetPWLTimeMap().RemoveKey(m_nTimerID);
49 m_nTimerID = 0;
50 }
51 }
52
TimerProc(FX_INT32 idEvent)53 void CPWL_Timer::TimerProc(FX_INT32 idEvent)
54 {
55 CPWL_Timer* pTimer = NULL;
56 if (GetPWLTimeMap().Lookup(idEvent, pTimer))
57 {
58 if (pTimer)
59 {
60 if (pTimer->m_pAttached)
61 pTimer->m_pAttached->TimerProc();
62 }
63 }
64 }
65
66 /* -------------------------- CPWL_TimerHandler -------------------------- */
67
CPWL_TimerHandler()68 CPWL_TimerHandler::CPWL_TimerHandler() : m_pTimer(NULL)
69 {
70 }
71
~CPWL_TimerHandler()72 CPWL_TimerHandler::~CPWL_TimerHandler()
73 {
74 if (m_pTimer) delete m_pTimer;
75 }
76
BeginTimer(FX_INT32 nElapse)77 void CPWL_TimerHandler::BeginTimer(FX_INT32 nElapse)
78 {
79 if (!m_pTimer)
80 m_pTimer = new CPWL_Timer(this, GetSystemHandler());
81
82 if (m_pTimer)
83 m_pTimer->SetPWLTimer(nElapse);
84 }
85
EndTimer()86 void CPWL_TimerHandler::EndTimer()
87 {
88 if (m_pTimer)
89 m_pTimer->KillPWLTimer();
90 }
91
TimerProc()92 void CPWL_TimerHandler::TimerProc()
93 {
94 }
95
96 /* --------------------------- CPWL_MsgControl ---------------------------- */
97
98 class CPWL_MsgControl
99 {
100 friend class CPWL_Wnd;
101
102 public:
CPWL_MsgControl(CPWL_Wnd * pWnd)103 CPWL_MsgControl(CPWL_Wnd * pWnd)
104 {
105 // PWL_TRACE("new CPWL_MsgControl\n");
106 m_pCreatedWnd = pWnd;
107 Default();
108 }
109
~CPWL_MsgControl()110 ~CPWL_MsgControl()
111 {
112 // PWL_TRACE("~CPWL_MsgControl\n");
113 Default();
114 }
115
Default()116 void Default()
117 {
118 m_aMousePath.RemoveAll();
119 m_aKeyboardPath.RemoveAll();
120 m_pMainMouseWnd = NULL;
121 m_pMainKeyboardWnd = NULL;
122 }
123
IsWndCreated(const CPWL_Wnd * pWnd) const124 FX_BOOL IsWndCreated(const CPWL_Wnd * pWnd) const
125 {
126 return m_pCreatedWnd == pWnd;
127 }
128
IsMainCaptureMouse(const CPWL_Wnd * pWnd) const129 FX_BOOL IsMainCaptureMouse(const CPWL_Wnd * pWnd) const
130 {
131 return pWnd == m_pMainMouseWnd;
132 }
133
IsWndCaptureMouse(const CPWL_Wnd * pWnd) const134 FX_BOOL IsWndCaptureMouse(const CPWL_Wnd * pWnd) const
135 {
136 if (pWnd)
137 for( FX_INT32 i=0,sz=m_aMousePath.GetSize(); i<sz; i++)
138 if (m_aMousePath.GetAt(i) == pWnd)
139 return TRUE;
140
141 return FALSE;
142 }
143
IsMainCaptureKeyboard(const CPWL_Wnd * pWnd) const144 FX_BOOL IsMainCaptureKeyboard(const CPWL_Wnd * pWnd) const
145 {
146 return pWnd == m_pMainKeyboardWnd;
147 }
148
149
IsWndCaptureKeyboard(const CPWL_Wnd * pWnd) const150 FX_BOOL IsWndCaptureKeyboard(const CPWL_Wnd * pWnd) const
151 {
152 if (pWnd)
153 for( FX_INT32 i=0,sz=m_aKeyboardPath.GetSize(); i<sz; i++)
154 if (m_aKeyboardPath.GetAt(i) == pWnd)
155 return TRUE;
156
157 return FALSE;
158 }
159
SetFocus(CPWL_Wnd * pWnd)160 void SetFocus(CPWL_Wnd * pWnd)
161 {
162 m_aKeyboardPath.RemoveAll();
163
164 if (pWnd)
165 {
166 m_pMainKeyboardWnd = pWnd;
167
168 CPWL_Wnd * pParent = pWnd;
169 while (pParent)
170 {
171 m_aKeyboardPath.Add(pParent);
172 pParent = pParent->GetParentWindow();
173 }
174
175 pWnd->OnSetFocus();
176 }
177 }
178
KillFocus()179 void KillFocus()
180 {
181 if (m_aKeyboardPath.GetSize() > 0)
182 if (CPWL_Wnd* pWnd = m_aKeyboardPath.GetAt(0))
183 pWnd->OnKillFocus();
184
185 m_pMainKeyboardWnd = NULL;
186 m_aKeyboardPath.RemoveAll();
187 }
188
SetCapture(CPWL_Wnd * pWnd)189 void SetCapture(CPWL_Wnd * pWnd)
190 {
191 m_aMousePath.RemoveAll();
192
193 if (pWnd)
194 {
195 m_pMainMouseWnd = pWnd;
196
197 CPWL_Wnd * pParent = pWnd;
198 while (pParent)
199 {
200 m_aMousePath.Add(pParent);
201 pParent = pParent->GetParentWindow();
202 }
203 }
204 }
205
ReleaseCapture()206 void ReleaseCapture()
207 {
208 m_pMainMouseWnd = NULL;
209 m_aMousePath.RemoveAll();
210 }
211
212 private:
213 CFX_ArrayTemplate<CPWL_Wnd*> m_aMousePath;
214 CFX_ArrayTemplate<CPWL_Wnd*> m_aKeyboardPath;
215 CPWL_Wnd* m_pCreatedWnd;
216 CPWL_Wnd* m_pMainMouseWnd;
217 CPWL_Wnd* m_pMainKeyboardWnd;
218 };
219
220 /* --------------------------- CPWL_Wnd ---------------------------- */
221
CPWL_Wnd()222 CPWL_Wnd::CPWL_Wnd() :
223 m_pVScrollBar(NULL),
224 m_rcWindow(),
225 m_rcClip(),
226 m_bCreated(FALSE),
227 m_bVisible(FALSE),
228 m_bNotifying(FALSE),
229 m_bEnabled(TRUE)
230 {
231 }
232
~CPWL_Wnd()233 CPWL_Wnd::~CPWL_Wnd()
234 {
235 ASSERT(m_bCreated == FALSE);
236 }
237
GetClassName() const238 CFX_ByteString CPWL_Wnd::GetClassName() const
239 {
240 return "CPWL_Wnd";
241 }
242
Create(const PWL_CREATEPARAM & cp)243 void CPWL_Wnd::Create(const PWL_CREATEPARAM & cp)
244 {
245 if (!IsValid())
246 {
247 m_sPrivateParam = cp;
248
249 OnCreate(m_sPrivateParam);
250
251 m_sPrivateParam.rcRectWnd.Normalize();
252 m_rcWindow = m_sPrivateParam.rcRectWnd;
253 m_rcClip = CPWL_Utils::InflateRect(m_rcWindow,1.0f);
254
255 CreateMsgControl();
256
257 if (m_sPrivateParam.pParentWnd)
258 m_sPrivateParam.pParentWnd->OnNotify(this, PNM_ADDCHILD);
259
260 PWL_CREATEPARAM ccp = m_sPrivateParam;
261
262 ccp.dwFlags &= 0xFFFF0000L; //remove sub styles
263 ccp.mtChild = CPDF_Matrix(1,0,0,1,0,0);
264
265 CreateScrollBar(ccp);
266 CreateChildWnd(ccp);
267
268 m_bVisible = HasFlag(PWS_VISIBLE);
269
270 OnCreated();
271
272 RePosChildWnd();
273 m_bCreated = TRUE;
274 }
275 }
276
OnCreate(PWL_CREATEPARAM & cp)277 void CPWL_Wnd::OnCreate(PWL_CREATEPARAM & cp)
278 {
279 }
280
OnCreated()281 void CPWL_Wnd::OnCreated()
282 {
283 }
284
OnDestroy()285 void CPWL_Wnd::OnDestroy()
286 {
287 }
288
Destroy()289 void CPWL_Wnd::Destroy()
290 {
291 KillFocus();
292
293 OnDestroy();
294
295 if (m_bCreated)
296 {
297 for (FX_INT32 i = m_aChildren.GetSize()-1; i >= 0; i --)
298 {
299 if (CPWL_Wnd * pChild = m_aChildren[i])
300 {
301 pChild->Destroy();
302 delete pChild;
303 pChild = NULL;
304 }
305 }
306
307 if (m_sPrivateParam.pParentWnd)
308 m_sPrivateParam.pParentWnd->OnNotify(this, PNM_REMOVECHILD);
309 m_bCreated = FALSE;
310 }
311
312 DestroyMsgControl();
313
314 FXSYS_memset(&m_sPrivateParam, 0, sizeof(PWL_CREATEPARAM));
315 m_aChildren.RemoveAll();
316 m_pVScrollBar = NULL;
317 }
318
Move(const CPDF_Rect & rcNew,FX_BOOL bReset,FX_BOOL bRefresh)319 void CPWL_Wnd::Move(const CPDF_Rect & rcNew, FX_BOOL bReset,FX_BOOL bRefresh)
320 {
321 if (IsValid())
322 {
323 CPDF_Rect rcOld = this->GetWindowRect();
324
325 m_rcWindow = rcNew;
326 m_rcWindow.Normalize();
327 //m_rcClip = CPWL_Utils::InflateRect(m_rcWindow,1.0f); //for special caret
328
329 if (rcOld.left != rcNew.left || rcOld.right != rcNew.right ||
330 rcOld.top != rcNew.top || rcOld.bottom != rcNew.bottom)
331 {
332 if (bReset)
333 {
334 RePosChildWnd();
335 }
336
337 }
338 if (bRefresh)
339 {
340 InvalidateRectMove(rcOld,rcNew);
341 }
342
343 m_sPrivateParam.rcRectWnd = m_rcWindow;
344 }
345 }
346
InvalidateRectMove(const CPDF_Rect & rcOld,const CPDF_Rect & rcNew)347 void CPWL_Wnd::InvalidateRectMove(const CPDF_Rect & rcOld, const CPDF_Rect & rcNew)
348 {
349 CPDF_Rect rcUnion = rcOld;
350 rcUnion.Union(rcNew);
351
352 InvalidateRect(&rcUnion);
353
354 /*
355 CPDF_Rect SubArray[4];
356
357 rcOld.Substract4(rcNew,SubArray);
358 for (FX_INT32 i=0;i<4;i++)
359 {
360 if (SubArray[i].left == 0 &&
361 SubArray[i].right == 0 &&
362 SubArray[i].top == 0 &&
363 SubArray[i].bottom == 0)continue;
364
365 InvalidateRect(&CPWL_Utils::InflateRect(SubArray[i],2));
366 }
367
368 rcNew.Substract4(rcOld,SubArray);
369 for (FX_INT32 j=0;j<4;j++)
370 {
371 if (SubArray[j].left == 0 &&
372 SubArray[j].right == 0 &&
373 SubArray[j].top == 0 &&
374 SubArray[j].bottom == 0)continue;
375
376 InvalidateRect(&CPWL_Utils::InflateRect(SubArray[j],2));
377 }
378 */
379 }
380
GetAppearanceStream(CFX_ByteString & sAppStream)381 void CPWL_Wnd::GetAppearanceStream(CFX_ByteString & sAppStream)
382 {
383 if (IsValid())
384 {
385 CFX_ByteTextBuf sTextBuf;
386 GetAppearanceStream(sTextBuf);
387 sAppStream += sTextBuf.GetByteString();
388 }
389 }
390
GetAppearanceStream(CFX_ByteTextBuf & sAppStream)391 void CPWL_Wnd::GetAppearanceStream(CFX_ByteTextBuf & sAppStream)
392 {
393 if (IsValid() && IsVisible())
394 {
395 GetThisAppearanceStream(sAppStream);
396 GetChildAppearanceStream(sAppStream);
397 }
398 }
399
400 //if don't set,Get default apperance stream
GetThisAppearanceStream(CFX_ByteTextBuf & sAppStream)401 void CPWL_Wnd::GetThisAppearanceStream(CFX_ByteTextBuf & sAppStream)
402 {
403 CPDF_Rect rectWnd = GetWindowRect();
404 if (!rectWnd.IsEmpty())
405 {
406 CFX_ByteTextBuf sThis;
407
408 if (HasFlag(PWS_BACKGROUND))
409 sThis << CPWL_Utils::GetRectFillAppStream(rectWnd,this->GetBackgroundColor());
410
411 if (HasFlag(PWS_BORDER))
412 sThis << CPWL_Utils::GetBorderAppStream(rectWnd,
413 (FX_FLOAT)GetBorderWidth(),
414 GetBorderColor(),
415 this->GetBorderLeftTopColor(this->GetBorderStyle()),
416 this->GetBorderRightBottomColor(this->GetBorderStyle()),
417 this->GetBorderStyle(),
418 this->GetBorderDash());
419
420 sAppStream << sThis;
421 }
422 }
423
GetChildAppearanceStream(CFX_ByteTextBuf & sAppStream)424 void CPWL_Wnd::GetChildAppearanceStream(CFX_ByteTextBuf & sAppStream)
425 {
426 for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
427 {
428 if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))
429 {
430 pChild->GetAppearanceStream(sAppStream);
431 }
432 }
433 }
434
DrawAppearance(CFX_RenderDevice * pDevice,CPDF_Matrix * pUser2Device)435 void CPWL_Wnd::DrawAppearance(CFX_RenderDevice* pDevice, CPDF_Matrix* pUser2Device)
436 {
437 if (IsValid() && IsVisible())
438 {
439 DrawThisAppearance(pDevice,pUser2Device);
440 DrawChildAppearance(pDevice,pUser2Device);
441 }
442 }
443
DrawThisAppearance(CFX_RenderDevice * pDevice,CPDF_Matrix * pUser2Device)444 void CPWL_Wnd::DrawThisAppearance(CFX_RenderDevice* pDevice, CPDF_Matrix* pUser2Device)
445 {
446 CPDF_Rect rectWnd = GetWindowRect();
447 if (!rectWnd.IsEmpty())
448 {
449 if (HasFlag(PWS_BACKGROUND))
450 {
451 CPDF_Rect rcClient = CPWL_Utils::DeflateRect(rectWnd,(FX_FLOAT)(GetBorderWidth()+GetInnerBorderWidth()));
452 CPWL_Utils::DrawFillRect(pDevice,pUser2Device,rcClient,this->GetBackgroundColor(),GetTransparency());
453 }
454
455 if (HasFlag(PWS_BORDER))
456 CPWL_Utils::DrawBorder(pDevice,
457 pUser2Device,
458 rectWnd,
459 (FX_FLOAT)GetBorderWidth(),
460 GetBorderColor(),
461 this->GetBorderLeftTopColor(this->GetBorderStyle()),
462 this->GetBorderRightBottomColor(this->GetBorderStyle()),
463 this->GetBorderStyle(),
464 this->GetBorderDash(),
465 GetTransparency());
466 }
467 }
468
DrawChildAppearance(CFX_RenderDevice * pDevice,CPDF_Matrix * pUser2Device)469 void CPWL_Wnd::DrawChildAppearance(CFX_RenderDevice* pDevice, CPDF_Matrix* pUser2Device)
470 {
471 for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
472 {
473 if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))
474 {
475 CPDF_Matrix mt = pChild->GetChildMatrix();
476 if (mt.IsIdentity())
477 {
478 pChild->DrawAppearance(pDevice,pUser2Device);
479 }
480 else
481 {
482 mt.Concat(*pUser2Device);
483 pChild->DrawAppearance(pDevice,&mt);
484 }
485 }
486 }
487 }
488
InvalidateRect(CPDF_Rect * pRect)489 void CPWL_Wnd::InvalidateRect(CPDF_Rect* pRect)
490 {
491 if (IsValid())
492 {
493 CPDF_Rect rcRefresh = pRect ? *pRect : GetWindowRect();
494
495 if (!HasFlag(PWS_NOREFRESHCLIP))
496 {
497 CPDF_Rect rcClip = GetClipRect();
498 if (!rcClip.IsEmpty())
499 {
500 rcRefresh.Intersect(rcClip);
501 }
502 }
503
504 FX_RECT rcWin = PWLtoWnd(rcRefresh);
505 rcWin.left -= PWL_INVALIDATE_INFLATE;
506 rcWin.top -= PWL_INVALIDATE_INFLATE;
507 rcWin.right += PWL_INVALIDATE_INFLATE;
508 rcWin.bottom += PWL_INVALIDATE_INFLATE;
509
510 if (IFX_SystemHandler* pSH = GetSystemHandler())
511 {
512 if (FX_HWND hWnd = GetAttachedHWnd())
513 {
514 pSH->InvalidateRect(hWnd, rcWin);
515 }
516 }
517 }
518 }
519
520 #define PWL_IMPLEMENT_KEY_METHOD(key_method_name)\
521 FX_BOOL CPWL_Wnd::key_method_name(FX_WORD nChar, FX_DWORD nFlag)\
522 {\
523 if (IsValid() && IsVisible() && IsEnabled())\
524 {\
525 if (IsWndCaptureKeyboard(this))\
526 {\
527 for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)\
528 {\
529 if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))\
530 {\
531 if (IsWndCaptureKeyboard(pChild))\
532 {\
533 return pChild->key_method_name(nChar,nFlag);\
534 }\
535 }\
536 }\
537 }\
538 }\
539 return FALSE;\
540 }
541
542 #define PWL_IMPLEMENT_MOUSE_METHOD(mouse_method_name)\
543 FX_BOOL CPWL_Wnd::mouse_method_name(const CPDF_Point & point, FX_DWORD nFlag)\
544 {\
545 if (IsValid() && IsVisible() && IsEnabled())\
546 {\
547 if (IsWndCaptureMouse(this))\
548 {\
549 for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)\
550 {\
551 if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))\
552 {\
553 if (IsWndCaptureMouse(pChild))\
554 {\
555 return pChild->mouse_method_name(pChild->ParentToChild(point),nFlag);\
556 }\
557 }\
558 }\
559 SetCursor();\
560 }\
561 else\
562 {\
563 for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)\
564 {\
565 if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))\
566 {\
567 if (pChild->WndHitTest(pChild->ParentToChild(point)))\
568 {\
569 return pChild->mouse_method_name(pChild->ParentToChild(point),nFlag);\
570 }\
571 }\
572 }\
573 if (this->WndHitTest(point))\
574 SetCursor();\
575 }\
576 }\
577 return FALSE;\
578 }
579
580 PWL_IMPLEMENT_KEY_METHOD(OnKeyDown)
PWL_IMPLEMENT_KEY_METHOD(OnKeyUp)581 PWL_IMPLEMENT_KEY_METHOD(OnKeyUp)
582 PWL_IMPLEMENT_KEY_METHOD(OnChar)
583
584 PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonDblClk)
585 PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonDown)
586 PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonUp)
587 PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonDblClk)
588 PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonDown)
589 PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonUp)
590 PWL_IMPLEMENT_MOUSE_METHOD(OnRButtonDblClk)
591 PWL_IMPLEMENT_MOUSE_METHOD(OnRButtonDown)
592 PWL_IMPLEMENT_MOUSE_METHOD(OnRButtonUp)
593 PWL_IMPLEMENT_MOUSE_METHOD(OnMouseMove)
594
595 FX_BOOL CPWL_Wnd::OnMouseWheel(short zDelta, const CPDF_Point & point, FX_DWORD nFlag)
596 {
597 if (IsValid() && IsVisible() && IsEnabled())
598 {
599 SetCursor();
600 if (IsWndCaptureKeyboard(this))
601 {
602 for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
603 {
604 if (CPWL_Wnd * pChild = m_aChildren.GetAt(i))
605 {
606 if (IsWndCaptureKeyboard(pChild))
607 {
608 return pChild->OnMouseWheel(zDelta,pChild->ParentToChild(point), nFlag);
609 }
610 }
611 }
612 }
613 }
614 return FALSE;
615 }
616
AddChild(CPWL_Wnd * pWnd)617 void CPWL_Wnd::AddChild(CPWL_Wnd * pWnd)
618 {
619 m_aChildren.Add(pWnd);
620 }
621
RemoveChild(CPWL_Wnd * pWnd)622 void CPWL_Wnd::RemoveChild(CPWL_Wnd * pWnd)
623 {
624 for (FX_INT32 i = m_aChildren.GetSize()-1; i >= 0; i --)
625 {
626 if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))
627 {
628 if (pChild == pWnd)
629 {
630 m_aChildren.RemoveAt(i);
631 break;
632 }
633 }
634 }
635 }
636
OnNotify(CPWL_Wnd * pWnd,FX_DWORD msg,FX_INTPTR wParam,FX_INTPTR lParam)637 void CPWL_Wnd::OnNotify(CPWL_Wnd* pWnd, FX_DWORD msg, FX_INTPTR wParam, FX_INTPTR lParam)
638 {
639 switch (msg)
640 {
641 case PNM_ADDCHILD:
642 this->AddChild(pWnd);
643 break;
644 case PNM_REMOVECHILD:
645 this->RemoveChild(pWnd);
646 break;
647 default:
648 break;
649 }
650 }
651
IsValid() const652 FX_BOOL CPWL_Wnd::IsValid() const
653 {
654 return m_bCreated;
655 }
656
GetCreationParam() const657 PWL_CREATEPARAM CPWL_Wnd::GetCreationParam() const
658 {
659 return m_sPrivateParam;
660 }
661
GetParentWindow() const662 CPWL_Wnd* CPWL_Wnd::GetParentWindow() const
663 {
664 return m_sPrivateParam.pParentWnd;
665 }
666
GetOriginWindowRect() const667 CPDF_Rect CPWL_Wnd::GetOriginWindowRect() const
668 {
669 return m_sPrivateParam.rcRectWnd;
670 }
671
GetWindowRect() const672 CPDF_Rect CPWL_Wnd::GetWindowRect() const
673 {
674 return m_rcWindow;
675 }
676
GetClientRect() const677 CPDF_Rect CPWL_Wnd::GetClientRect() const
678 {
679 CPDF_Rect rcWindow = GetWindowRect();
680 CPDF_Rect rcClient = CPWL_Utils::DeflateRect(rcWindow,(FX_FLOAT)(GetBorderWidth()+GetInnerBorderWidth()));
681
682 if (CPWL_ScrollBar * pVSB = this->GetVScrollBar())
683 rcClient.right -= pVSB->GetScrollBarWidth();
684
685 rcClient.Normalize();
686
687 if (rcWindow.Contains(rcClient))
688 return rcClient;
689 else
690 return CPDF_Rect();
691 }
692
GetCenterPoint() const693 CPDF_Point CPWL_Wnd::GetCenterPoint() const
694 {
695 CPDF_Rect rcClient = GetClientRect();
696
697 return CPDF_Point((rcClient.left + rcClient.right) * 0.5f,
698 (rcClient.top + rcClient.bottom) * 0.5f);
699 }
700
GetClientCenterSquare() const701 CPDF_Rect CPWL_Wnd::GetClientCenterSquare() const
702 {
703 return CPWL_Utils::GetCenterSquare(GetClientRect());
704 }
705
GetWindowCenterSquare() const706 CPDF_Rect CPWL_Wnd::GetWindowCenterSquare() const
707 {
708 return CPWL_Utils::GetCenterSquare(CPWL_Utils::DeflateRect(GetWindowRect(),0.1f));
709 }
710
HasFlag(FX_DWORD dwFlags) const711 FX_BOOL CPWL_Wnd::HasFlag(FX_DWORD dwFlags) const
712 {
713 return (m_sPrivateParam.dwFlags & dwFlags) != 0;
714 }
715
RemoveFlag(FX_DWORD dwFlags)716 void CPWL_Wnd::RemoveFlag(FX_DWORD dwFlags)
717 {
718 m_sPrivateParam.dwFlags &= ~dwFlags;
719 }
720
AddFlag(FX_DWORD dwFlags)721 void CPWL_Wnd::AddFlag(FX_DWORD dwFlags)
722 {
723 m_sPrivateParam.dwFlags |= dwFlags;
724 }
725
GetBackgroundColor() const726 CPWL_Color CPWL_Wnd::GetBackgroundColor() const
727 {
728 return m_sPrivateParam.sBackgroundColor;
729 }
730
SetBackgroundColor(const CPWL_Color & color)731 void CPWL_Wnd::SetBackgroundColor(const CPWL_Color & color)
732 {
733 m_sPrivateParam.sBackgroundColor = color;
734 }
735
SetTextColor(const CPWL_Color & color)736 void CPWL_Wnd::SetTextColor(const CPWL_Color & color)
737 {
738 m_sPrivateParam.sTextColor = color;
739 }
740
SetTextStrokeColor(const CPWL_Color & color)741 void CPWL_Wnd::SetTextStrokeColor(const CPWL_Color & color)
742 {
743 m_sPrivateParam.sTextStrokeColor = color;
744 }
745
GetTextColor() const746 CPWL_Color CPWL_Wnd::GetTextColor() const
747 {
748 return m_sPrivateParam.sTextColor;
749 }
750
GetTextStrokeColor() const751 CPWL_Color CPWL_Wnd::GetTextStrokeColor() const
752 {
753 return m_sPrivateParam.sTextStrokeColor;
754 }
755
GetBorderStyle() const756 FX_INT32 CPWL_Wnd::GetBorderStyle() const
757 {
758 return m_sPrivateParam.nBorderStyle;
759 }
760
SetBorderStyle(FX_INT32 nBorderStyle)761 void CPWL_Wnd::SetBorderStyle(FX_INT32 nBorderStyle)
762 {
763 if (HasFlag(PWS_BORDER))
764 m_sPrivateParam.nBorderStyle = nBorderStyle;
765 }
766
GetBorderWidth() const767 FX_INT32 CPWL_Wnd::GetBorderWidth() const
768 {
769 if (HasFlag(PWS_BORDER))
770 return m_sPrivateParam.dwBorderWidth;
771
772 return 0;
773 }
774
GetInnerBorderWidth() const775 FX_INT32 CPWL_Wnd::GetInnerBorderWidth() const
776 {
777 /*
778 switch (GetBorderStyle())
779 {
780 case PBS_BEVELED:
781 case PBS_INSET:
782 return GetBorderWidth() / 2;
783 }
784 */
785 return 0;
786 }
787
SetBorderWidth(FX_INT32 nBorderWidth)788 void CPWL_Wnd::SetBorderWidth(FX_INT32 nBorderWidth)
789 {
790 if (HasFlag(PWS_BORDER))
791 m_sPrivateParam.dwBorderWidth = nBorderWidth;
792 }
793
GetBorderColor() const794 CPWL_Color CPWL_Wnd::GetBorderColor() const
795 {
796 if (HasFlag(PWS_BORDER))
797 return m_sPrivateParam.sBorderColor;
798
799 return CPWL_Color();
800 }
801
SetBorderColor(const CPWL_Color & color)802 void CPWL_Wnd::SetBorderColor(const CPWL_Color & color)
803 {
804 if (HasFlag(PWS_BORDER))
805 m_sPrivateParam.sBorderColor = color;
806 }
807
GetBorderDash() const808 CPWL_Dash CPWL_Wnd::GetBorderDash() const
809 {
810 return m_sPrivateParam.sDash;
811 }
812
GetAttachedData() const813 void* CPWL_Wnd::GetAttachedData() const
814 {
815 return m_sPrivateParam.pAttachedData;
816 }
817
SetBorderDash(const CPWL_Dash & sDash)818 void CPWL_Wnd::SetBorderDash(const CPWL_Dash & sDash)
819 {
820 if (HasFlag(PWS_BORDER))
821 m_sPrivateParam.sDash = sDash;
822 }
823
GetVScrollBar() const824 CPWL_ScrollBar* CPWL_Wnd::GetVScrollBar() const
825 {
826 if (HasFlag(PWS_VSCROLL))
827 return m_pVScrollBar;
828
829 return NULL;
830 }
831
CreateScrollBar(const PWL_CREATEPARAM & cp)832 void CPWL_Wnd::CreateScrollBar(const PWL_CREATEPARAM & cp)
833 {
834 CreateVScrollBar(cp);
835 }
836
CreateVScrollBar(const PWL_CREATEPARAM & cp)837 void CPWL_Wnd::CreateVScrollBar(const PWL_CREATEPARAM & cp)
838 {
839 if (!m_pVScrollBar && HasFlag(PWS_VSCROLL))
840 {
841 PWL_CREATEPARAM scp = cp;
842
843 //flags
844 scp.dwFlags = PWS_CHILD| PWS_BACKGROUND | PWS_AUTOTRANSPARENT | PWS_NOREFRESHCLIP;
845
846 scp.pParentWnd = this;
847 scp.sBackgroundColor = PWL_DEFAULT_WHITECOLOR;
848 scp.eCursorType = FXCT_ARROW;
849 scp.nTransparency = PWL_SCROLLBAR_TRANSPARANCY;
850
851 if ((m_pVScrollBar = new CPWL_ScrollBar(SBT_VSCROLL)))
852 m_pVScrollBar->Create(scp);
853 }
854 }
855
SetCapture()856 void CPWL_Wnd::SetCapture()
857 {
858 if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())
859 pMsgCtrl->SetCapture(this);
860 }
861
ReleaseCapture()862 void CPWL_Wnd::ReleaseCapture()
863 {
864 for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
865 if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))
866 pChild->ReleaseCapture();
867
868 if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())
869 pMsgCtrl->ReleaseCapture();
870 }
871
SetFocus()872 void CPWL_Wnd::SetFocus()
873 {
874 if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())
875 {
876 if (!pMsgCtrl->IsMainCaptureKeyboard(this))
877 pMsgCtrl->KillFocus();
878 pMsgCtrl->SetFocus(this);
879 }
880 }
881
KillFocus()882 void CPWL_Wnd::KillFocus()
883 {
884 if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())
885 {
886 if (pMsgCtrl->IsWndCaptureKeyboard(this))
887 pMsgCtrl->KillFocus();
888 }
889 }
890
OnSetFocus()891 void CPWL_Wnd::OnSetFocus()
892 {
893 }
894
OnKillFocus()895 void CPWL_Wnd::OnKillFocus()
896 {
897 }
898
WndHitTest(const CPDF_Point & point) const899 FX_BOOL CPWL_Wnd::WndHitTest(const CPDF_Point & point) const
900 {
901 return IsValid() && IsVisible() && GetWindowRect().Contains(point.x,point.y);
902 }
903
ClientHitTest(const CPDF_Point & point) const904 FX_BOOL CPWL_Wnd::ClientHitTest(const CPDF_Point & point) const
905 {
906 return IsValid() && IsVisible() && GetClientRect().Contains(point.x,point.y);
907 }
908
GetRootWnd() const909 const CPWL_Wnd * CPWL_Wnd::GetRootWnd() const
910 {
911 if (m_sPrivateParam.pParentWnd)
912 return m_sPrivateParam.pParentWnd->GetRootWnd();
913 else
914 return this;
915 }
916
SetVisible(FX_BOOL bVisible)917 void CPWL_Wnd::SetVisible(FX_BOOL bVisible)
918 {
919 if (IsValid())
920 {
921 for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
922 {
923 if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))
924 {
925 pChild->SetVisible(bVisible);
926 }
927 }
928
929 if (bVisible != m_bVisible)
930 {
931 m_bVisible = bVisible;
932 RePosChildWnd();
933 InvalidateRect();
934 }
935 }
936 }
937
SetClipRect(const CPDF_Rect & rect)938 void CPWL_Wnd::SetClipRect(const CPDF_Rect & rect)
939 {
940 m_rcClip = rect;
941 m_rcClip.Normalize();
942 }
943
GetClipRect() const944 CPDF_Rect CPWL_Wnd::GetClipRect() const
945 {
946 return m_rcClip;
947 }
948
IsReadOnly() const949 FX_BOOL CPWL_Wnd::IsReadOnly() const
950 {
951 return HasFlag(PWS_READONLY);
952 }
953
RePosChildWnd()954 void CPWL_Wnd::RePosChildWnd()
955 {
956 CPDF_Rect rcContent = CPWL_Utils::DeflateRect(GetWindowRect(),(FX_FLOAT)(GetBorderWidth()+GetInnerBorderWidth()));
957
958 CPWL_ScrollBar * pVSB = this->GetVScrollBar();
959
960 CPDF_Rect rcVScroll = CPDF_Rect(rcContent.right - PWL_SCROLLBAR_WIDTH,
961 rcContent.bottom,
962 rcContent.right-1.0f,
963 rcContent.top);
964
965 if (pVSB) pVSB->Move(rcVScroll,TRUE,FALSE);
966 }
967
CreateChildWnd(const PWL_CREATEPARAM & cp)968 void CPWL_Wnd::CreateChildWnd(const PWL_CREATEPARAM & cp)
969 {
970 }
971
SetCursor()972 void CPWL_Wnd::SetCursor()
973 {
974 if (IsValid())
975 {
976 if (IFX_SystemHandler* pSH = GetSystemHandler())
977 {
978 FX_INT32 nCursorType = this->GetCreationParam().eCursorType;
979 pSH->SetCursor(nCursorType);
980 }
981 }
982 }
983
CreateMsgControl()984 void CPWL_Wnd::CreateMsgControl()
985 {
986 if (!m_sPrivateParam.pMsgControl)
987 m_sPrivateParam.pMsgControl = new CPWL_MsgControl(this);
988 }
989
DestroyMsgControl()990 void CPWL_Wnd::DestroyMsgControl()
991 {
992 if (CPWL_MsgControl* pMsgControl = GetMsgControl())
993 if (pMsgControl->IsWndCreated(this))
994 delete pMsgControl;
995 }
996
GetMsgControl() const997 CPWL_MsgControl* CPWL_Wnd::GetMsgControl() const
998 {
999 return m_sPrivateParam.pMsgControl;
1000 }
1001
IsCaptureMouse() const1002 FX_BOOL CPWL_Wnd::IsCaptureMouse() const
1003 {
1004 return IsWndCaptureMouse(this);
1005 }
1006
IsWndCaptureMouse(const CPWL_Wnd * pWnd) const1007 FX_BOOL CPWL_Wnd::IsWndCaptureMouse(const CPWL_Wnd * pWnd) const
1008 {
1009 if (CPWL_MsgControl * pCtrl = GetMsgControl())
1010 return pCtrl->IsWndCaptureMouse(pWnd);
1011
1012 return FALSE;
1013 }
1014
IsWndCaptureKeyboard(const CPWL_Wnd * pWnd) const1015 FX_BOOL CPWL_Wnd::IsWndCaptureKeyboard(const CPWL_Wnd * pWnd) const
1016 {
1017 if (CPWL_MsgControl * pCtrl = GetMsgControl())
1018 return pCtrl->IsWndCaptureKeyboard(pWnd);
1019
1020 return FALSE;
1021 }
1022
IsFocused() const1023 FX_BOOL CPWL_Wnd::IsFocused() const
1024 {
1025 if (CPWL_MsgControl * pCtrl = GetMsgControl())
1026 return pCtrl->IsMainCaptureKeyboard(this);
1027
1028 return FALSE;
1029 }
1030
GetFocusRect() const1031 CPDF_Rect CPWL_Wnd::GetFocusRect() const
1032 {
1033 return CPWL_Utils::InflateRect(this->GetWindowRect(),1);
1034 }
1035
GetFontSize() const1036 FX_FLOAT CPWL_Wnd::GetFontSize() const
1037 {
1038 return this->m_sPrivateParam.fFontSize;
1039 }
1040
SetFontSize(FX_FLOAT fFontSize)1041 void CPWL_Wnd::SetFontSize(FX_FLOAT fFontSize)
1042 {
1043 this->m_sPrivateParam.fFontSize = fFontSize;
1044 }
1045
GetSystemHandler() const1046 IFX_SystemHandler* CPWL_Wnd::GetSystemHandler() const
1047 {
1048 return m_sPrivateParam.pSystemHandler;
1049 }
1050
GetFocusHandler() const1051 IPWL_FocusHandler* CPWL_Wnd::GetFocusHandler() const
1052 {
1053 return m_sPrivateParam.pFocusHandler;
1054 }
1055
GetProvider() const1056 IPWL_Provider* CPWL_Wnd::GetProvider() const
1057 {
1058 return m_sPrivateParam.pProvider;
1059 }
1060
GetFontMap() const1061 IFX_Edit_FontMap* CPWL_Wnd::GetFontMap() const
1062 {
1063 return m_sPrivateParam.pFontMap;
1064 }
1065
GetBorderLeftTopColor(FX_INT32 nBorderStyle) const1066 CPWL_Color CPWL_Wnd::GetBorderLeftTopColor(FX_INT32 nBorderStyle) const
1067 {
1068 CPWL_Color color;
1069
1070 switch (nBorderStyle)
1071 {
1072 case PBS_SOLID:
1073 break;
1074 case PBS_DASH:
1075 break;
1076 case PBS_BEVELED:
1077 color = CPWL_Color(COLORTYPE_GRAY,1);
1078 break;
1079 case PBS_INSET:
1080 color = CPWL_Color(COLORTYPE_GRAY,0.5f);
1081 break;
1082 case PBS_UNDERLINED:
1083 break;
1084 }
1085
1086 return color;
1087 }
1088
GetBorderRightBottomColor(FX_INT32 nBorderStyle) const1089 CPWL_Color CPWL_Wnd::GetBorderRightBottomColor(FX_INT32 nBorderStyle) const
1090 {
1091 CPWL_Color color;
1092
1093 switch (nBorderStyle)
1094 {
1095 case PBS_SOLID:
1096 break;
1097 case PBS_DASH:
1098 break;
1099 case PBS_BEVELED:
1100 color = CPWL_Utils::DevideColor(GetBackgroundColor(),2);
1101 break;
1102 case PBS_INSET:
1103 color = CPWL_Color(COLORTYPE_GRAY,0.75f);
1104 break;
1105 case PBS_UNDERLINED:
1106 break;
1107 }
1108
1109 return color;
1110 }
1111
1112 /* ----------------------------------------------------------------- */
1113
GetTransparency()1114 FX_INT32 CPWL_Wnd::GetTransparency()
1115 {
1116 return m_sPrivateParam.nTransparency;
1117 }
1118
SetTransparency(FX_INT32 nTransparency)1119 void CPWL_Wnd::SetTransparency(FX_INT32 nTransparency)
1120 {
1121 for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
1122 {
1123 if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))
1124 {
1125 pChild->SetTransparency(nTransparency);
1126 }
1127 }
1128
1129 m_sPrivateParam.nTransparency = nTransparency;
1130 }
1131
GetWindowMatrix() const1132 CPDF_Matrix CPWL_Wnd::GetWindowMatrix() const
1133 {
1134 CPDF_Matrix mt = this->GetChildToRoot();
1135
1136 if (IPWL_Provider* pProvider = GetProvider())
1137 {
1138 mt.Concat(pProvider->GetWindowMatrix(GetAttachedData()));
1139 return mt;
1140 }
1141
1142 /*
1143 if (CReader_App* pApp = CPWL_Module::GetReaderApp())
1144 if (CReader_Document* pDocument = pApp->GetCurrentDocument())
1145 if (CReader_DocView* pDocView = pDocument->GetCurrentDocView())
1146 {
1147 CPDF_Matrix mtPageView;
1148 pDocView->GetCurrentMatrix(mtPageView);
1149 mt.Concat(mtPageView);
1150 return mt;
1151 }
1152
1153 */
1154
1155 return mt;
1156 }
1157
PWLtoWnd(const CPDF_Point & point,FX_INT32 & x,FX_INT32 & y) const1158 void CPWL_Wnd::PWLtoWnd(const CPDF_Point& point, FX_INT32& x, FX_INT32& y) const
1159 {
1160 CPDF_Matrix mt = GetWindowMatrix();
1161 CPDF_Point pt = point;
1162 mt.Transform(pt.x,pt.y);
1163 x = (FX_INT32)(pt.x+0.5);
1164 y = (FX_INT32)(pt.y+0.5);
1165 }
1166
PWLtoWnd(const CPDF_Rect & rect) const1167 FX_RECT CPWL_Wnd::PWLtoWnd(const CPDF_Rect & rect) const
1168 {
1169 CPDF_Rect rcTemp = rect;
1170 CPDF_Matrix mt = GetWindowMatrix();
1171 mt.TransformRect(rcTemp);
1172 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));
1173 }
1174
GetAttachedHWnd() const1175 FX_HWND CPWL_Wnd::GetAttachedHWnd() const
1176 {
1177 return m_sPrivateParam.hAttachedWnd;
1178 }
1179
ChildToParent(const CPDF_Point & point) const1180 CPDF_Point CPWL_Wnd::ChildToParent(const CPDF_Point& point) const
1181 {
1182 CPDF_Matrix mt = GetChildMatrix();
1183 if (mt.IsIdentity())
1184 return point;
1185 else
1186 {
1187 CPDF_Point pt = point;
1188 mt.Transform(pt.x,pt.y);
1189 return pt;
1190 }
1191 }
1192
ChildToParent(const CPDF_Rect & rect) const1193 CPDF_Rect CPWL_Wnd::ChildToParent(const CPDF_Rect& rect) const
1194 {
1195 CPDF_Matrix mt = GetChildMatrix();
1196 if (mt.IsIdentity())
1197 return rect;
1198 else
1199 {
1200 CPDF_Rect rc = rect;
1201 mt.TransformRect(rc);
1202 return rc;
1203 }
1204 }
1205
ParentToChild(const CPDF_Point & point) const1206 CPDF_Point CPWL_Wnd::ParentToChild(const CPDF_Point& point) const
1207 {
1208 CPDF_Matrix mt = GetChildMatrix();
1209 if (mt.IsIdentity())
1210 return point;
1211 else
1212 {
1213 mt.SetReverse(mt);
1214 CPDF_Point pt = point;
1215 mt.Transform(pt.x,pt.y);
1216 return pt;
1217 }
1218 }
1219
ParentToChild(const CPDF_Rect & rect) const1220 CPDF_Rect CPWL_Wnd::ParentToChild(const CPDF_Rect& rect) const
1221 {
1222 CPDF_Matrix mt = GetChildMatrix();
1223 if (mt.IsIdentity())
1224 return rect;
1225 else
1226 {
1227 mt.SetReverse(mt);
1228 CPDF_Rect rc = rect;
1229 mt.TransformRect(rc);
1230 return rc;
1231 }
1232 }
1233
GetChildToRoot() const1234 CPDF_Matrix CPWL_Wnd::GetChildToRoot() const
1235 {
1236 CPDF_Matrix mt(1,0,0,1,0,0);
1237
1238 if (HasFlag(PWS_CHILD))
1239 {
1240 const CPWL_Wnd* pParent = this;
1241 while (pParent)
1242 {
1243 mt.Concat(pParent->GetChildMatrix());
1244 pParent = pParent->GetParentWindow();
1245 }
1246 }
1247
1248 return mt;
1249 }
1250
GetChildMatrix() const1251 CPDF_Matrix CPWL_Wnd::GetChildMatrix() const
1252 {
1253 if (HasFlag(PWS_CHILD))
1254 return m_sPrivateParam.mtChild;
1255
1256 return CPDF_Matrix(1,0,0,1,0,0);
1257 }
1258
SetChildMatrix(const CPDF_Matrix & mt)1259 void CPWL_Wnd::SetChildMatrix(const CPDF_Matrix& mt)
1260 {
1261 m_sPrivateParam.mtChild = mt;
1262 }
1263
GetFocused() const1264 const CPWL_Wnd* CPWL_Wnd::GetFocused() const
1265 {
1266 if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())
1267 {
1268 return pMsgCtrl->m_pMainKeyboardWnd;
1269 }
1270
1271 return NULL;
1272 }
1273
EnableWindow(FX_BOOL bEnable)1274 void CPWL_Wnd::EnableWindow(FX_BOOL bEnable)
1275 {
1276 if (m_bEnabled != bEnable)
1277 {
1278 for (FX_INT32 i=0,sz=m_aChildren.GetSize(); i<sz; i++)
1279 {
1280 if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))
1281 {
1282 pChild->EnableWindow(bEnable);
1283 }
1284 }
1285
1286 this->m_bEnabled = bEnable;
1287
1288 if (bEnable)
1289 this->OnEnabled();
1290 else
1291 this->OnDisabled();
1292 }
1293 }
1294
IsEnabled()1295 FX_BOOL CPWL_Wnd::IsEnabled()
1296 {
1297 return m_bEnabled;
1298 }
1299
OnEnabled()1300 void CPWL_Wnd::OnEnabled()
1301 {
1302 }
1303
OnDisabled()1304 void CPWL_Wnd::OnDisabled()
1305 {
1306 }
1307
IsCTRLpressed(FX_DWORD nFlag) const1308 FX_BOOL CPWL_Wnd::IsCTRLpressed(FX_DWORD nFlag) const
1309 {
1310 if (IFX_SystemHandler* pSystemHandler = GetSystemHandler())
1311 {
1312 return pSystemHandler->IsCTRLKeyDown(nFlag);
1313 }
1314
1315 return FALSE;
1316 }
1317
IsSHIFTpressed(FX_DWORD nFlag) const1318 FX_BOOL CPWL_Wnd::IsSHIFTpressed(FX_DWORD nFlag) const
1319 {
1320 if (IFX_SystemHandler* pSystemHandler = GetSystemHandler())
1321 {
1322 return pSystemHandler->IsSHIFTKeyDown(nFlag);
1323 }
1324
1325 return FALSE;
1326 }
1327
IsALTpressed(FX_DWORD nFlag) const1328 FX_BOOL CPWL_Wnd::IsALTpressed(FX_DWORD nFlag) const
1329 {
1330 if (IFX_SystemHandler* pSystemHandler = GetSystemHandler())
1331 {
1332 return pSystemHandler->IsALTKeyDown(nFlag);
1333 }
1334
1335 return FALSE;
1336 }
1337
IsINSERTpressed(FX_DWORD nFlag) const1338 FX_BOOL CPWL_Wnd::IsINSERTpressed(FX_DWORD nFlag) const
1339 {
1340 if (IFX_SystemHandler* pSystemHandler = GetSystemHandler())
1341 {
1342 return pSystemHandler->IsINSERTKeyDown(nFlag);
1343 }
1344
1345 return FALSE;
1346 }
1347
1348