]> git.saurik.com Git - wxWidgets.git/blob - src/os2/window.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Weekly catch-up
[wxWidgets.git] / src / os2 / window.cpp
1 // Name: windows.cpp
2 // Purpose: wxWindow
3 // Author: David Webster
4 // Modified by:
5 // Created: 10/12/99
6 // RCS-ID: $Id$
7 // Copyright: (c) David Webster
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
10
11 //
12 // For compilers that support precompilation, includes "wx.h".
13 //
14 #include "wx/wxprec.h"
15
16 #ifndef WX_PRECOMP
17 #define INCL_DOS
18 #define INCL_PM
19 #include <os2.h>
20 #include "wx/window.h"
21 #include "wx/accel.h"
22 #include "wx/setup.h"
23 #include "wx/menu.h"
24 #include "wx/dc.h"
25 #include "wx/dcclient.h"
26 #include "wx/utils.h"
27 #include "wx/app.h"
28 #include "wx/panel.h"
29 #include "wx/layout.h"
30 #include "wx/checkbox.h"
31 #include "wx/combobox.h"
32 #include "wx/dialog.h"
33 #include "wx/frame.h"
34 #include "wx/listbox.h"
35 #include "wx/button.h"
36 #include "wx/msgdlg.h"
37 #include "wx/scrolwin.h"
38 #include "wx/radiobox.h"
39 #include "wx/radiobut.h"
40 #include "wx/slider.h"
41 #include "wx/statbox.h"
42 #include "wx/statusbr.h"
43 #include "wx/toolbar.h"
44 #include "wx/settings.h"
45 #include <stdio.h>
46 #endif
47
48 #if wxUSE_OWNER_DRAWN
49 #include "wx/ownerdrw.h"
50 #endif
51
52 #if wxUSE_DRAG_AND_DROP
53 #include "wx/dnd.h"
54 #endif
55
56 #include "wx/menuitem.h"
57 #include "wx/log.h"
58
59 #include "wx/os2/private.h"
60
61 #if wxUSE_TOOLTIPS
62 #include "wx/tooltip.h"
63 #endif
64
65 #if wxUSE_NOTEBOOK
66 #include "wx/notebook.h"
67 #endif
68
69 #if wxUSE_CARET
70 #include "wx/caret.h"
71 #endif // wxUSE_CARET
72
73 #include "wx/intl.h"
74 #include "wx/log.h"
75
76
77 #include "wx/textctrl.h"
78
79 #include <string.h>
80
81 //
82 // Place compiler, OS specific includes here
83 //
84
85 //
86 // Standard macros -- these are for OS/2 PM, but most GUI's have something similar
87 //
88 #ifndef GET_X_LPARAM
89 //
90 // SHORT1FROMMP -- LOWORD
91 //
92 #define GET_X_LPARAM(mp) ((unsigned short)(unsigned long)(mp))
93 //
94 // SHORT2FROMMP -- HIWORD
95 //
96 #define GET_Y_LPARAM(mp) ((unsigned short)(unsigned long)(mp >> 16))
97 #endif // GET_X_LPARAM
98
99 #ifndef CW_USEDEFAULT
100 # define CW_USEDEFAULT ((int)0x80000000)
101 #endif
102
103 #ifndef VK_OEM_1
104 #define VK_OEM_1 0xBA
105 #define VK_OEM_PLUS 0xBB
106 #define VK_OEM_COMMA 0xBC
107 #define VK_OEM_MINUS 0xBD
108 #define VK_OEM_PERIOD 0xBE
109 #define VK_OEM_2 0xBF
110 #define VK_OEM_3 0xC0
111 #define VK_OEM_4 0xDB
112 #define VK_OEM_5 0xDC
113 #define VK_OEM_6 0xDD
114 #define VK_OEM_7 0xDE
115 #endif
116
117 // ---------------------------------------------------------------------------
118 // global variables
119 // ---------------------------------------------------------------------------
120
121 //
122 // The last PM message we got (MT-UNSAFE)
123 //
124 QMSG s_currentMsg;
125
126 #if wxUSE_MENUS_NATIVE
127 wxMenu* wxCurrentPopupMenu = NULL;
128 #endif // wxUSE_MENUS_NATIVE
129
130 wxList* wxWinHandleList = NULL;
131
132 // ---------------------------------------------------------------------------
133 // private functions
134 // ---------------------------------------------------------------------------
135
136 //
137 // the window proc for all our windows; most gui's have something similar
138 //
139 MRESULT EXPENTRY wxWndProc( HWND hWnd
140 ,ULONG message
141 ,MPARAM mp1
142 ,MPARAM mp2
143 );
144
145 #ifdef __WXDEBUG__
146 const char *wxGetMessageName(int message);
147 #endif //__WXDEBUG__
148
149 wxWindowOS2* FindWindowForMouseEvent( wxWindow* pWin
150 ,short* pnX
151 ,short* pnY
152 );
153 void wxRemoveHandleAssociation(wxWindowOS2* pWin);
154 void wxAssociateWinWithHandle( HWND hWnd
155 ,wxWindowOS2* pWin
156 );
157 wxWindow* wxFindWinFromHandle(WXHWND hWnd);
158
159 //
160 // get the current state of SHIFT/CTRL keys
161 //
162 static inline bool IsShiftDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_SHIFT) & 0x8000) != 0; }
163 static inline bool IsCtrlDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x8000) != 0; }
164
165 static wxWindow* gpWinBeingCreated = NULL;
166
167 // ---------------------------------------------------------------------------
168 // event tables
169 // ---------------------------------------------------------------------------
170
171 // in wxUniv-OS/2 this class is abstract because it doesn't have DoPopupMenu()
172 // method
173 #ifdef __WXUNIVERSAL__
174 IMPLEMENT_ABSTRACT_CLASS(wxWindowOS2, wxWindowBase)
175 #else // __WXPM__
176 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
177 #endif // __WXUNIVERSAL__/__WXPM__
178
179 BEGIN_EVENT_TABLE(wxWindowOS2, wxWindowBase)
180 EVT_ERASE_BACKGROUND(wxWindowOS2::OnEraseBackground)
181 EVT_SYS_COLOUR_CHANGED(wxWindowOS2::OnSysColourChanged)
182 EVT_INIT_DIALOG(wxWindowOS2::OnInitDialog)
183 EVT_IDLE(wxWindowOS2::OnIdle)
184 EVT_SET_FOCUS(wxWindowOS2::OnSetFocus)
185 END_EVENT_TABLE()
186
187 // ===========================================================================
188 // implementation
189 // ===========================================================================
190
191 // ---------------------------------------------------------------------------
192 // wxWindow utility functions
193 // ---------------------------------------------------------------------------
194
195 //
196 // Find an item given the PM Window id
197 //
198 wxWindow* wxWindowOS2::FindItem(
199 long lId
200 ) const
201 {
202 #if wxUSE_CONTROLS
203 wxControl* pItem = wxDynamicCast(this, wxControl);
204
205 if (pItem)
206 {
207 //
208 // I it we or one of our "internal" children?
209 //
210 if (pItem->GetId() == lId
211 #ifndef __WXUNIVERSAL__
212 || (pItem->GetSubcontrols().Index(lId) != wxNOT_FOUND)
213 #endif
214 )
215 {
216 return pItem;
217 }
218 }
219 #endif // wxUSE_CONTROLS
220
221 wxWindowList::Node* pCurrent = GetChildren().GetFirst();
222
223 while (pCurrent)
224 {
225 wxWindow* pChildWin = pCurrent->GetData();
226 wxWindow* pWnd = pChildWin->FindItem(lId);
227
228 if (pWnd)
229 return pWnd;
230
231 pCurrent = pCurrent->GetNext();
232 }
233 return(NULL);
234 } // end of wxWindowOS2::FindItem
235
236 //
237 // Find an item given the PM Window handle
238 //
239 wxWindow* wxWindowOS2::FindItemByHWND(
240 WXHWND hWnd
241 , bool bControlOnly
242 ) const
243 {
244 wxWindowList::Node* pCurrent = GetChildren().GetFirst();
245
246 while (pCurrent)
247 {
248 wxWindow* pParent = pCurrent->GetData();
249
250 //
251 // Do a recursive search.
252 //
253 wxWindow* pWnd = pParent->FindItemByHWND(hWnd);
254
255 if (pWnd)
256 return(pWnd);
257
258 if (!bControlOnly
259 #if wxUSE_CONTROLS
260 || pParent->IsKindOf(CLASSINFO(wxControl))
261 #endif // wxUSE_CONTROLS
262 )
263 {
264 wxWindow* pItem = pCurrent->GetData();
265
266 if (pItem->GetHWND() == hWnd)
267 return(pItem);
268 else
269 {
270 if (pItem->ContainsHWND(hWnd))
271 return(pItem);
272 }
273 }
274 pCurrent = pCurrent->GetNext();
275 }
276 return(NULL);
277 } // end of wxWindowOS2::FindItemByHWND
278
279 //
280 // Default command handler
281 //
282 bool wxWindowOS2::OS2Command(
283 WXUINT WXUNUSED(uParam)
284 , WXWORD WXUNUSED(uId)
285 )
286 {
287 return(FALSE);
288 }
289
290 // ----------------------------------------------------------------------------
291 // constructors and such
292 // ----------------------------------------------------------------------------
293
294 void wxWindowOS2::Init()
295 {
296 //
297 // Generic
298 //
299 InitBase();
300
301 //
302 // PM specific
303 //
304 m_bWinCaptured = FALSE;
305
306 m_isBeingDeleted = FALSE;
307 m_fnOldWndProc = NULL;
308 m_bUseCtl3D = FALSE;
309 m_bMouseInWindow = FALSE;
310 m_bLastKeydownProcessed = FALSE;
311 m_pChildrenDisabled = NULL;
312
313 //
314 // wxWnd
315 //
316 m_hMenu = 0L;
317 m_hWnd = 0L;
318 m_hWndScrollBarHorz = 0L;
319 m_hWndScrollBarVert = 0L;
320
321 memset(&m_vWinSwp, '\0', sizeof (SWP));
322
323 //
324 // Pass WM_GETDLGCODE to DefWindowProc()
325 //
326 m_lDlgCode = 0;
327
328 m_nXThumbSize = 0;
329 m_nYThumbSize = 0;
330 m_bBackgroundTransparent = FALSE;
331
332 //
333 // As all windows are created with WS_VISIBLE style...
334 //
335 m_isShown = TRUE;
336
337 #if wxUSE_MOUSEEVENT_HACK
338 m_lLastMouseX =
339 m_lLastMouseY = -1;
340 m_nLastMouseEvent = -1;
341 #endif // wxUSE_MOUSEEVENT_HACK
342 } // wxWindowOS2::Init
343
344 //
345 // Destructor
346 //
347 wxWindowOS2::~wxWindowOS2()
348 {
349 m_isBeingDeleted = TRUE;
350
351 for (wxWindow* pWin = GetParent(); pWin; pWin = pWin->GetParent())
352 {
353 wxTopLevelWindow* pFrame = wxDynamicCast(pWin, wxTopLevelWindow);
354
355 if (pFrame)
356 {
357 if (pFrame->GetLastFocus() == this)
358 pFrame->SetLastFocus(NULL);
359 }
360 }
361
362 DestroyChildren();
363
364 if (m_parent)
365 m_parent->RemoveChild(this);
366
367 if (m_hWnd)
368 {
369 if(!::WinDestroyWindow(GetHWND()))
370 wxLogLastError(wxT("DestroyWindow"));
371 //
372 // remove hWnd <-> wxWindow association
373 //
374 wxRemoveHandleAssociation(this);
375 }
376 delete m_pChildrenDisabled;
377 } // end of wxWindowOS2::~wxWindowOS2
378
379 // real construction (Init() must have been called before!)
380 bool wxWindowOS2::Create(
381 wxWindow* pParent
382 , wxWindowID vId
383 , const wxPoint& rPos
384 , const wxSize& rSize
385 , long lStyle
386 , const wxString& rName
387 )
388 {
389 HWND hParent = NULLHANDLE;
390 ULONG ulCreateFlags = 0;
391 WXDWORD dwExStyle = 0;
392
393 wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent"));
394
395 #if wxUSE_STATBOX
396 //
397 // wxGTK doesn't allow to create controls with static box as the parent so
398 // this will result in a crash when the program is ported to wxGTK - warn
399 // about it
400 //
401 // the correct solution is to create the controls as siblings of the
402 // static box
403 //
404 wxASSERT_MSG( !wxDynamicCast(pParent, wxStaticBox),
405 _T("wxStaticBox can't be used as a window parent!") );
406 #endif // wxUSE_STATBOX
407
408 if ( !CreateBase( pParent
409 ,vId
410 ,rPos
411 ,rSize
412 ,lStyle
413 ,wxDefaultValidator
414 ,rName
415 ))
416 return(FALSE);
417
418 if (pParent)
419 {
420 int nTempy;
421
422 pParent->AddChild(this);
423 hParent = GetWinHwnd(pParent);
424
425 if ( pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
426 pParent->IsKindOf(CLASSINFO(wxScrolledWindow))
427 )
428 ulCreateFlags |= WS_CLIPSIBLINGS;
429 }
430
431 //
432 // Most wxSTYLES are really PM Class specific styles and will be
433 // set in those class create procs. PM's basic windows styles are
434 // very limited.
435 //
436 ulCreateFlags |= OS2GetCreateWindowFlags(&dwExStyle);
437
438
439 #ifdef __WXUNIVERSAL__
440 // no 3d effects, we draw them ourselves
441 WXDWORD exStyle = 0;
442 #endif // !wxUniversal
443 if (lStyle & wxPOPUP_WINDOW)
444 {
445 ulCreateFlags &= ~WS_VISIBLE;
446 m_isShown = FALSE;
447 }
448 else
449 {
450 ulCreateFlags |= WS_VISIBLE;
451 }
452
453 //
454 // Generic OS/2 Windows have no Control Data but other classes
455 // that call OS2Create may have some.
456 //
457 return(OS2Create( (PSZ)wxCanvasClassName
458 ,rName.c_str()
459 ,ulCreateFlags
460 ,rPos
461 ,rSize
462 ,NULL // Control Data
463 ,dwExStyle
464 ,TRUE // Child
465 ));
466 } // end of wxWindowOS2::Create
467
468 // ---------------------------------------------------------------------------
469 // basic operations
470 // ---------------------------------------------------------------------------
471
472 void wxWindowOS2::SetFocus()
473 {
474 HWND hWnd = GetHwnd();
475 wxCHECK_RET( hWnd, _T("can't set focus to invalid window") );
476
477 if (hWnd)
478 ::WinSetFocus(HWND_DESKTOP, hWnd);
479 } // end of wxWindowOS2::SetFocus
480
481 void wxWindowOS2::SetFocusFromKbd()
482 {
483 //
484 // Nothing else to do under OS/2
485 //
486 wxWindowBase::SetFocusFromKbd();
487 } // end of wxWindowOS2::SetFocus
488
489 wxWindow* wxWindowBase::FindFocus()
490 {
491 HWND hWnd = ::WinQueryFocus(HWND_DESKTOP);
492
493 if (hWnd)
494 {
495 return wxFindWinFromHandle((WXHWND)hWnd);
496 }
497 return NULL;
498 } // wxWindowBase::FindFocus
499
500 bool wxWindowOS2::Enable(
501 bool bEnable
502 )
503 {
504 if (!wxWindowBase::Enable(bEnable))
505 return(FALSE);
506
507 HWND hWnd = GetHwnd();
508
509 if ( hWnd )
510 ::WinEnableWindow(hWnd, (BOOL)bEnable);
511
512 //
513 // The logic below doesn't apply to the top level windows -- otherwise
514 // showing a modal dialog would result in total greying out (and ungreying
515 // out later) of everything which would be really ugly
516 //
517 if (IsTopLevel())
518 return TRUE;
519
520 wxWindowList::Node* pNode = GetChildren().GetFirst();
521
522 while (pNode)
523 {
524 wxWindow* pChild = pNode->GetData();
525
526 if (bEnable)
527 {
528 //
529 // Enable the child back unless it had been disabled before us
530 //
531 if (!m_pChildrenDisabled || !m_pChildrenDisabled->Find(pChild))
532 pChild->Enable();
533 }
534 else // we're being disabled
535 {
536 if (pChild->IsEnabled())
537 {
538 //
539 // Disable it as children shouldn't stay enabled while the
540 // parent is not
541 //
542 pChild->Disable();
543 }
544 else // child already disabled, remember it
545 {
546 //
547 // Have we created the list of disabled children already?
548 //
549 if (!m_pChildrenDisabled)
550 m_pChildrenDisabled = new wxWindowList;
551 m_pChildrenDisabled->Append(pChild);
552 }
553 }
554 pNode = pNode->GetNext();
555 }
556 if (bEnable && m_pChildrenDisabled)
557 {
558 //
559 // We don't need this list any more, don't keep unused memory
560 //
561 delete m_pChildrenDisabled;
562 m_pChildrenDisabled = NULL;
563 }
564 return TRUE;
565 } // end of wxWindowOS2::Enable
566
567 bool wxWindowOS2::Show(
568 bool bShow
569 )
570 {
571 if (!wxWindowBase::Show(bShow))
572 return(FALSE);
573
574 HWND hWnd = GetHwnd();
575
576 ::WinShowWindow(hWnd, bShow);
577
578 if (bShow)
579 {
580 ::WinSetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE | SWP_ZORDER);
581 }
582 return TRUE;
583 } // end of wxWindowOS2::Show
584
585 void wxWindowOS2::Raise()
586 {
587 ::WinSetWindowPos(GetHwnd(), HWND_TOP, 0, 0, 0, 0, SWP_ZORDER | SWP_ACTIVATE);
588 } // end of wxWindowOS2::Raise
589
590 void wxWindowOS2::Lower()
591 {
592 ::WinSetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0, SWP_ZORDER | SWP_DEACTIVATE);
593 } // end of wxWindowOS2::Lower
594
595 void wxWindowOS2::SetTitle(
596 const wxString& rTitle
597 )
598 {
599 ::WinSetWindowText(GetHwnd(), rTitle.c_str());
600 } // end of wxWindowOS2::SetTitle
601
602 wxString wxWindowOS2::GetTitle() const
603 {
604 return wxGetWindowText(GetHWND());
605 } // end of wxWindowOS2::GetTitle
606
607 void wxWindowOS2::DoCaptureMouse()
608 {
609 HWND hWnd = GetHwnd();
610
611 if (hWnd && !m_bWinCaptured)
612 {
613 ::WinSetCapture(HWND_DESKTOP, hWnd);
614 m_bWinCaptured = TRUE;
615 }
616 } // end of wxWindowOS2::GetTitle
617
618 void wxWindowOS2::DoReleaseMouse()
619 {
620 if (m_bWinCaptured)
621 {
622 ::WinSetCapture(HWND_DESKTOP, NULLHANDLE);
623 m_bWinCaptured = FALSE;
624 }
625 } // end of wxWindowOS2::ReleaseMouse
626
627 /* static */ wxWindow* wxWindowBase::GetCapture()
628 {
629 HWND hwnd = ::WinQueryCapture(HWND_DESKTOP);
630 return hwnd ? wxFindWinFromHandle((WXHWND)hwnd) : (wxWindow *)NULL;
631 } // end of wxWindowBase::GetCapture
632
633 bool wxWindowOS2::SetFont(
634 const wxFont& rFont
635 )
636 {
637 if (!wxWindowBase::SetFont(rFont))
638 {
639 // nothing to do
640 return(FALSE);
641 }
642
643 HWND hWnd = GetHwnd();
644
645 wxOS2SetFont( hWnd
646 ,rFont
647 );
648 return(TRUE);
649 } // end of wxWindowOS2::SetFont
650
651 bool wxWindowOS2::SetCursor(
652 const wxCursor& rCursor
653 ) // check if base implementation is OK
654 {
655 if ( !wxWindowBase::SetCursor(rCursor))
656 {
657 // no change
658 return FALSE;
659 }
660
661 if ( m_cursor.Ok() ) {
662 HWND hWnd = GetHwnd();
663 POINTL vPoint;
664 RECTL vRect;
665
666 ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
667 ::WinQueryWindowRect(hWnd, &vRect);
668
669 if (::WinPtInRect(vHabmain, &vRect, &vPoint) && !wxIsBusy())
670 {
671 ::WinSetPointer(HWND_DESKTOP, (HPOINTER)m_cursor.GetHCURSOR());
672 }
673 }
674 return TRUE;
675 } // end of wxWindowOS2::SetCursor
676
677 void wxWindowOS2::WarpPointer(
678 int nXPos
679 , int nYPos
680 )
681 {
682 int nX = nXPos;
683 int nY = nYPos;
684 RECTL vRect;
685
686 ::WinQueryWindowRect(GetHwnd(), &vRect);
687 nX += vRect.xLeft;
688 nY += vRect.yBottom;
689
690 ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY));
691 } // end of wxWindowOS2::WarpPointer
692
693 #if WXWIN_COMPATIBILITY
694 void wxWindowOS2::OS2DeviceToLogical (float *x, float *y) const
695 {
696 }
697 #endif // WXWIN_COMPATIBILITY
698
699 // ---------------------------------------------------------------------------
700 // scrolling stuff
701 // ---------------------------------------------------------------------------
702
703 #if WXWIN_COMPATIBILITY
704 void wxWindowOS2::SetScrollRange(
705 int nOrient
706 , int nRange
707 , bool bRefresh
708 )
709 {
710 int nRange1 = nRange;
711 int nPageSize = GetScrollPage(nOrient);
712
713 if (nPpageSize > 1 && nRange > 0)
714 {
715 nRange1 += (nPageSize - 1);
716 }
717
718 if (nOrient == wxHORIZONTAL)
719 {
720 ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1));
721 ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
722 }
723 else
724 {
725 ::WinSendMsg(m_hWndScrollBarVert, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1));
726 ::WinSendMsg(m_hWndScrollBarVert, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
727 }
728 } // end of wxWindowOS2::SetScrollRange
729
730 void wxWindowOS2::SetScrollPage(
731 int nOrient
732 , int nPage
733 , bool bRefresh
734 )
735 {
736 if (nOrient == wxHORIZONTAL )
737 m_nXThumbSize = nPage;
738 else
739 m_nYThumbSize = nPage;
740 } // end of wxWindowOS2::SetScrollPage
741
742 int wxWindowOS2::OldGetScrollRange(
743 int nOrient
744 ) const
745 {
746 MRESULT mRc;
747 HWND hWnd = GetHwnd();
748
749 if (hWnd)
750 {
751 mRc = WinSendMsg(hWnd, SBM_QUERYRANGE, (MPARAM)0L, (MPARAM)0L);
752 return(SHORT2FROMMR(mRc));
753 }
754 return 0;
755 } // end of wxWindowOS2::OldGetScrollRange
756
757 int wxWindowOS2::GetScrollPage(
758 int nOrient
759 ) const
760 {
761 if (nOrient == wxHORIZONTAL)
762 return m_nXThumbSize;
763 else
764 return m_nYThumbSize;
765 } // end of wxWindowOS2::GetScrollPage
766 #endif // WXWIN_COMPATIBILITY
767
768 int wxWindowOS2::GetScrollPos(
769 int nOrient
770 ) const
771 {
772 if (nOrient == wxHORIZONTAL)
773 return((int)::WinSendMsg(m_hWndScrollBarHorz, SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
774 else
775 return((int)::WinSendMsg(m_hWndScrollBarVert, SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
776 } // end of wxWindowOS2::GetScrollPos
777
778 int wxWindowOS2::GetScrollRange(
779 int nOrient
780 ) const
781 {
782 MRESULT mr;
783
784 if (nOrient == wxHORIZONTAL)
785 mr = ::WinSendMsg(m_hWndScrollBarHorz, SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);
786 else
787 mr = ::WinSendMsg(m_hWndScrollBarVert, SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);
788 return((int)SHORT2FROMMR(mr));
789 } // end of wxWindowOS2::GetScrollRange
790
791 int wxWindowOS2::GetScrollThumb(
792 int nOrient
793 ) const
794 {
795 if (nOrient == wxHORIZONTAL )
796 return m_nXThumbSize;
797 else
798 return m_nYThumbSize;
799 } // end of wxWindowOS2::GetScrollThumb
800
801 void wxWindowOS2::SetScrollPos(
802 int nOrient
803 , int nPos
804 , bool WXUNUSED(bRefresh)
805 )
806 {
807 if (nOrient == wxHORIZONTAL )
808 ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
809 else
810 ::WinSendMsg(m_hWndScrollBarVert, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
811 } // end of wxWindowOS2::SetScrollPos
812
813 void wxWindowOS2::SetScrollbar(
814 int nOrient
815 , int nPos
816 , int nThumbVisible
817 , int nRange
818 , bool WXUNUSED(bRefresh)
819 )
820 {
821 HWND hWnd = GetHwnd();
822 int nOldRange = nRange - nThumbVisible;
823 int nRange1 = nOldRange;
824 int nPageSize = nThumbVisible;
825
826 SBCDATA vInfo;
827 ULONG ulStyle = WS_VISIBLE | WS_SYNCPAINT;
828 SWP vSwp;
829 SWP vSwpOwner;
830 RECTL vRect;
831 HWND hWndParent;
832 HWND hWndClient;
833 wxWindow* pParent = GetParent();
834
835 if (pParent && pParent->IsKindOf(CLASSINFO(wxFrame)))
836 {
837 wxFrame* pFrame;
838
839 pFrame = wxDynamicCast(pParent, wxFrame);
840 hWndParent = pFrame->GetFrame();
841 hWndClient = GetHwndOf(pParent);
842 }
843 else
844 {
845 if (pParent)
846 hWndParent = GetHwndOf(pParent);
847 else
848 hWndParent = GetHwnd();
849 hWndClient = hWndParent;
850 }
851 ::WinQueryWindowPos(hWndClient, &vSwp);
852 ::WinQueryWindowPos(hWnd, &vSwpOwner);
853
854 if (nPageSize > 1 && nRange > 0)
855 {
856 nRange1 += (nPageSize - 1);
857 }
858
859 vInfo.cb = sizeof(SBCDATA);
860 vInfo.posFirst = 0;
861 vInfo.posLast = (SHORT)nRange1;
862 vInfo.posThumb = nPos;
863
864 if (nOrient == wxHORIZONTAL )
865 {
866 ulStyle |= SBS_HORZ;
867 if (m_hWndScrollBarHorz == 0L)
868 {
869 //
870 // Since the scrollbars are usually created before the owner is
871 // sized either via an OnSize event directly or via sizers or
872 // layout constraints, we will initially just use the coords of
873 // the parent window (this is usually a frame client window). But
874 // the bars themselves, are children of the parent frame (i.e
875 // siblings of the frame client. The owner, however is the actual
876 // window being scrolled (or at least the one responsible for
877 // handling the scroll events). The owner will be resized later,
878 // as it is usually a child of a top level window, and when that
879 // is done its scrollbars will be resized and repositioned as well.
880 //
881 m_hWndScrollBarHorz = ::WinCreateWindow( hWndParent
882 ,WC_SCROLLBAR
883 ,(PSZ)NULL
884 ,ulStyle
885 ,vSwp.x
886 ,vSwp.y
887 ,vSwp.cx - 20
888 ,20
889 ,hWnd
890 ,HWND_TOP
891 ,60000
892 ,&vInfo
893 ,NULL
894 );
895 }
896 else
897 {
898 //
899 // The owner (the scrolled window) is a child of the Frame's
900 // client window, usually. The scrollbars are children of the
901 // frame, itself, and thus are positioned relative to the frame's
902 // origin, not the frame's client window origin.
903 // The starting x position is the same as the starting x position
904 // of the owner, but in terms of the parent frame.
905 // The starting y position is 20 pels below the origin of the
906 // owner in terms of the parent frame.
907 // The horz bar is the same width as the owner and 20 pels high.
908 //
909 if (nRange1 >= nThumbVisible)
910 {
911 ::WinSetWindowPos( m_hWndScrollBarHorz
912 ,HWND_TOP
913 ,vSwp.x + vSwpOwner.x
914 ,(vSwp.y + vSwpOwner.y) - 20
915 ,vSwpOwner.cx
916 ,20
917 ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER
918 );
919 ::WinSendMsg( m_hWndScrollBarHorz
920 ,SBM_SETSCROLLBAR
921 ,(MPARAM)nPos
922 ,MPFROM2SHORT(0, (SHORT)nRange1)
923 );
924 ::WinSendMsg( m_hWndScrollBarHorz
925 ,SBM_SETTHUMBSIZE
926 ,MPFROM2SHORT( (SHORT)nThumbVisible
927 ,(SHORT)nRange1
928 )
929 ,(MPARAM)0
930 );
931 }
932 else
933 ::WinShowWindow(m_hWndScrollBarHorz, FALSE);
934 }
935 }
936 else
937 {
938 ulStyle |= SBS_VERT;
939 if (m_hWndScrollBarVert == 0L)
940 {
941 //
942 // Since the scrollbars are usually created before the owner is
943 // sized either via an OnSize event directly or via sizers or
944 // layout constraints, we will initially just use the coords of
945 // the parent window (this is usually a frame client window). But
946 // the bars themselves, are children of the parent frame (i.e
947 // siblings of the frame client. The owner, however is the actual
948 // window being scrolled (or at least the one responsible for
949 // handling the scroll events). The owner will be resized later,
950 // as it is usually a child of a top level window, and when that
951 // is done its scrollbars will be resized and repositioned as well.
952 //
953 m_hWndScrollBarVert = ::WinCreateWindow( hWndParent
954 ,WC_SCROLLBAR
955 ,(PSZ)NULL
956 ,ulStyle
957 ,vSwp.x + vSwp.cx - 20
958 ,vSwp.y + 20
959 ,20
960 ,vSwp.cy - 20
961 ,hWnd
962 ,HWND_TOP
963 ,60001
964 ,&vInfo
965 ,NULL
966 );
967 }
968 else
969 {
970 //
971 // The owner (the scrolled window) is a child of the Frame's
972 // client window, usually. The scrollbars are children of the
973 // frame, itself and thus are positioned relative to the frame's
974 // origin, not the frame's client window's origin.
975 // Thus, the x position will be frame client's x (usually a few
976 // pels inside the parent frame, plus the width of the owner.
977 // Since we may be using sizers or layout constraints for multiple
978 // child scrolled windows, the y position will be the frame client's
979 // y pos plus the scrolled windows y position, yielding the y
980 // position of the scrollbar relative to the parent frame (the vert
981 // scrollbar is on the right and starts at the bottom of the
982 // owner window).
983 // It is 20 pels wide and the same height as the owner.
984 //
985 if (nRange1 >= nThumbVisible)
986 {
987 ::WinSetWindowPos( m_hWndScrollBarVert
988 ,HWND_TOP
989 ,vSwp.x + vSwpOwner.x + vSwpOwner.cx
990 ,vSwp.y + vSwpOwner.y
991 ,20
992 ,vSwpOwner.cy
993 ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW
994 );
995 ::WinSendMsg( m_hWndScrollBarVert
996 ,SBM_SETSCROLLBAR
997 ,(MPARAM)nPos
998 ,MPFROM2SHORT(0, (SHORT)nRange1)
999 );
1000 ::WinSendMsg( m_hWndScrollBarVert
1001 ,SBM_SETTHUMBSIZE
1002 ,MPFROM2SHORT( (SHORT)nThumbVisible
1003 ,(SHORT)nRange1
1004 )
1005 ,(MPARAM)0
1006 );
1007 }
1008 else
1009 ::WinShowWindow(m_hWndScrollBarVert, FALSE);
1010 }
1011 m_nYThumbSize = nThumbVisible;
1012 }
1013 } // end of wxWindowOS2::SetScrollbar
1014
1015 void wxWindowOS2::ScrollWindow(
1016 int nDx
1017 , int nDy
1018 , const wxRect* pRect
1019 )
1020 {
1021 RECTL vRect;
1022 RECTL vRectHorz;
1023 RECTL vRectVert;
1024 RECTL vRectChild;
1025
1026 if (pRect)
1027 {
1028 vRect.xLeft = pRect->x;
1029 vRect.yTop = pRect->y + pRect->height;
1030 vRect.xRight = pRect->x + pRect->width;
1031 vRect.yBottom = pRect->y;
1032 }
1033 else
1034 {
1035 ::WinQueryWindowRect(GetHwnd(), &vRect);
1036 }
1037 nDy *= -1; // flip the sign of Dy as OS/2 is opposite Windows.
1038 ::WinScrollWindow( GetHwnd()
1039 ,(LONG)nDx
1040 ,(LONG)nDy
1041 ,&vRect
1042 ,&vRect
1043 ,NULLHANDLE
1044 ,NULL
1045 ,SW_SCROLLCHILDREN | SW_INVALIDATERGN
1046 );
1047 Refresh();
1048 } // end of wxWindowOS2::ScrollWindow
1049
1050 // ---------------------------------------------------------------------------
1051 // subclassing
1052 // ---------------------------------------------------------------------------
1053
1054 void wxWindowOS2::SubclassWin(
1055 WXHWND hWnd
1056 )
1057 {
1058 HWND hwnd = (HWND)hWnd;
1059
1060 wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") );
1061 wxAssociateWinWithHandle( hWnd
1062 ,(wxWindow*)this
1063 );
1064 if (!wxCheckWindowWndProc( hWnd
1065 ,(WXFARPROC)wxWndProc
1066 ))
1067 {
1068 m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc);
1069 }
1070 else
1071 {
1072 m_fnOldWndProc = (WXFARPROC)NULL;
1073 }
1074 } // end of wxWindowOS2::SubclassWin
1075
1076 void wxWindowOS2::UnsubclassWin()
1077 {
1078 //
1079 // Restore old Window proc
1080 //
1081 HWND hwnd = GetHWND();
1082
1083 if (m_hWnd)
1084 {
1085 wxCHECK_RET( ::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in UnsubclassWin") );
1086
1087 PFNWP fnProc = (PFNWP)::WinQueryWindowPtr(hwnd, QWP_PFNWP);
1088
1089 if ( (m_fnOldWndProc != 0) && (fnProc != (PFNWP) m_fnOldWndProc))
1090 {
1091 WinSubclassWindow(hwnd, (PFNWP)m_fnOldWndProc);
1092 m_fnOldWndProc = 0;
1093 }
1094 }
1095 } // end of wxWindowOS2::UnsubclassWin
1096
1097 bool wxCheckWindowWndProc(
1098 WXHWND hWnd
1099 , WXFARPROC fnWndProc
1100 )
1101 {
1102 static char zBuffer[512];
1103 CLASSINFO vCls;
1104
1105 ::WinQueryClassName((HWND)hWnd, (LONG)512, (PCH)zBuffer);
1106 ::WinQueryClassInfo(wxGetInstance(), (PSZ)zBuffer, &vCls);
1107 return(fnWndProc == (WXFARPROC)vCls.pfnWindowProc);
1108 } // end of WinGuiBase_CheckWindowWndProc
1109
1110 void wxWindowOS2::SetWindowStyleFlag(
1111 long lFlags
1112 )
1113 {
1114 long lFlagsOld = GetWindowStyleFlag();
1115
1116 if (lFlags == lFlagsOld)
1117 return;
1118
1119 //
1120 // Update the internal variable
1121 //
1122 wxWindowBase::SetWindowStyleFlag(lFlags);
1123
1124 //
1125 // Now update the Windows style as well if needed - and if the window had
1126 // been already created
1127 //
1128 if (!GetHwnd())
1129 return;
1130
1131 WXDWORD dwExstyle;
1132 WXDWORD dwExstyleOld;
1133 long lStyle = OS2GetStyle( lFlags
1134 ,&dwExstyle
1135 );
1136 long lStyleOld = OS2GetStyle( lFlagsOld
1137 ,&dwExstyleOld
1138 );
1139
1140 if (lStyle != lStyleOld)
1141 {
1142 //
1143 // Some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1144 // this function so instead of simply setting the style to the new
1145 // value we clear the bits which were set in styleOld but are set in
1146 // the new one and set the ones which were not set before
1147 //
1148 long lStyleReal = ::WinQueryWindowULong(GetHwnd(), QWL_STYLE);
1149
1150 lStyleReal &= ~lStyleOld;
1151 lStyleReal |= lStyle;
1152
1153 ::WinSetWindowULong(GetHwnd(), QWL_STYLE, lStyleReal);
1154 }
1155 } // end of wxWindowOS2::SetWindowStyleFlag
1156
1157 WXDWORD wxWindowOS2::OS2GetStyle(
1158 long lFlags
1159 , WXDWORD* pdwExstyle
1160 ) const
1161 {
1162 WXDWORD dwStyle = 0L;
1163
1164 if (lFlags & wxCLIP_CHILDREN )
1165 dwStyle |= WS_CLIPCHILDREN;
1166
1167 if (lFlags & wxCLIP_SIBLINGS )
1168 dwStyle |= WS_CLIPSIBLINGS;
1169
1170 return dwStyle;
1171 } // end of wxWindowMSW::MSWGetStyle
1172
1173 //
1174 // Make a Windows extended style from the given wxWindows window style
1175 //
1176 WXDWORD wxWindowOS2::MakeExtendedStyle(
1177 long lStyle
1178 , bool bEliminateBorders
1179 )
1180 {
1181 //
1182 // Simply fill out with wxWindow extended styles. We'll conjure
1183 // something up in OS2Create and all window redrawing pieces later
1184 //
1185 WXDWORD dwStyle = 0;
1186
1187 if (lStyle & wxTRANSPARENT_WINDOW )
1188 dwStyle |= wxTRANSPARENT_WINDOW;
1189
1190 if (!bEliminateBorders)
1191 {
1192 if (lStyle & wxSUNKEN_BORDER)
1193 dwStyle |= wxSUNKEN_BORDER;
1194 if (lStyle & wxDOUBLE_BORDER)
1195 dwStyle |= wxDOUBLE_BORDER;
1196 if (lStyle & wxRAISED_BORDER )
1197 dwStyle |= wxRAISED_BORDER;
1198 if (lStyle & wxSTATIC_BORDER)
1199 dwStyle |= wxSTATIC_BORDER;
1200 }
1201 return dwStyle;
1202 } // end of wxWindowOS2::MakeExtendedStyle
1203
1204 //
1205 // Determines whether simulated 3D effects or CTL3D should be used,
1206 // applying a default border style if required, and returning an extended
1207 // style to pass to OS2Create.
1208 //
1209 WXDWORD wxWindowOS2::Determine3DEffects(
1210 WXDWORD dwDefaultBorderStyle
1211 , bool* pbWant3D
1212 ) const
1213 {
1214 WXDWORD dwStyle = 0L;
1215
1216 //
1217 // Native PM does not have any specialize 3D effects like WIN32 does,
1218 // so we have to try and invent them.
1219 //
1220
1221 //
1222 // If matches certain criteria, then assume no 3D effects
1223 // unless specifically requested (dealt with in MakeExtendedStyle)
1224 //
1225 if (!GetParent() ||
1226 !IsKindOf(CLASSINFO(wxControl)) ||
1227 (m_windowStyle & wxNO_BORDER)
1228 )
1229 {
1230 *pbWant3D = FALSE;
1231 return MakeExtendedStyle(m_windowStyle, FALSE);
1232 }
1233
1234 //
1235 // 1) App can specify global 3D effects
1236 //
1237 *pbWant3D = wxTheApp->GetAuto3D();
1238
1239 //
1240 // 2) If the parent is being drawn with user colours, or simple border
1241 // specified, switch effects off.
1242 //
1243 if (GetParent() &&
1244 (GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS) ||
1245 (m_windowStyle & wxSIMPLE_BORDER)
1246 )
1247 *pbWant3D = FALSE;
1248
1249 //
1250 // 3) Control can override this global setting by defining
1251 // a border style, e.g. wxSUNKEN_BORDER
1252 //
1253 if ((m_windowStyle & wxDOUBLE_BORDER) ||
1254 (m_windowStyle & wxRAISED_BORDER) ||
1255 (m_windowStyle & wxSTATIC_BORDER) ||
1256 (m_windowStyle & wxSUNKEN_BORDER)
1257 )
1258 *pbWant3D = TRUE;
1259
1260 dwStyle = MakeExtendedStyle( m_windowStyle
1261 ,FALSE
1262 );
1263
1264 //
1265 // If we want 3D, but haven't specified a border here,
1266 // apply the default border style specified.
1267 //
1268 if (dwDefaultBorderStyle && (*pbWant3D) &&
1269 !((m_windowStyle & wxDOUBLE_BORDER) ||
1270 (m_windowStyle & wxRAISED_BORDER) ||
1271 (m_windowStyle & wxSTATIC_BORDER) ||
1272 (m_windowStyle & wxSIMPLE_BORDER)
1273 )
1274 )
1275 dwStyle |= dwDefaultBorderStyle;
1276 return dwStyle;
1277 } // end of wxWindowOS2::Determine3DEffects
1278
1279 #if WXWIN_COMPATIBILITY
1280 void wxWindowOS2::OnCommand(
1281 wxWindow& rWin
1282 , wxCommandEvent& rEvent
1283 )
1284 {
1285 if (GetEventHandler()->ProcessEvent(rEvent))
1286 return;
1287 if (m_parent)
1288 m_parent->GetEventHandler()->OnCommand( rWin
1289 ,rEvent
1290 );
1291 } // end of wxWindowOS2::OnCommand
1292
1293 wxObject* wxWindowOS2::GetChild(
1294 int nNumber
1295 ) const
1296 {
1297 //
1298 // Return a pointer to the Nth object in the Panel
1299 //
1300 wxNode* pNode = GetChildren().First();
1301 int n = nNumber;
1302
1303 while (pNode && n--)
1304 pNode = pNode->Next();
1305 if (pNode)
1306 {
1307 wxObject* pObj = (wxObject*)pNode->Data();
1308 return(pObj);
1309 }
1310 else
1311 return NULL;
1312 } // end of wxWindowOS2::GetChild
1313
1314 #endif // WXWIN_COMPATIBILITY
1315
1316 //
1317 // Setup background and foreground colours correctly
1318 //
1319 void wxWindowOS2::SetupColours()
1320 {
1321 if ( GetParent() )
1322 SetBackgroundColour(GetParent()->GetBackgroundColour());
1323 } // end of wxWindowOS2::SetupColours
1324
1325 void wxWindowOS2::OnIdle(
1326 wxIdleEvent& WXUNUSED(rEvent)
1327 )
1328 {
1329 //
1330 // Check if we need to send a LEAVE event
1331 //
1332 if (m_bMouseInWindow)
1333 {
1334 POINTL vPoint;
1335
1336 ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
1337 if (::WinWindowFromPoint(HWND_DESKTOP, &vPoint, FALSE) != (HWND)GetHwnd())
1338 {
1339 //
1340 // Generate a LEAVE event
1341 //
1342 m_bMouseInWindow = FALSE;
1343
1344 //
1345 // Unfortunately the mouse button and keyboard state may have changed
1346 // by the time the OnIdle function is called, so 'state' may be
1347 // meaningless.
1348 //
1349 int nState = 0;
1350
1351 if (::WinGetKeyState(HWND_DESKTOP, VK_SHIFT) != 0)
1352 nState |= VK_SHIFT;
1353 if (::WinGetKeyState(HWND_DESKTOP, VK_CTRL) != 0);
1354 nState |= VK_CTRL;
1355
1356 wxMouseEvent rEvent(wxEVT_LEAVE_WINDOW);
1357
1358 InitMouseEvent( rEvent
1359 ,vPoint.x
1360 ,vPoint.y
1361 ,nState
1362 );
1363 (void)GetEventHandler()->ProcessEvent(rEvent);
1364 }
1365 }
1366 UpdateWindowUI();
1367 } // end of wxWindowOS2::OnIdle
1368
1369 //
1370 // Set this window to be the child of 'parent'.
1371 //
1372 bool wxWindowOS2::Reparent(
1373 wxWindow* pParent
1374 )
1375 {
1376 if (!wxWindowBase::Reparent(pParent))
1377 return FALSE;
1378
1379 HWND hWndChild = GetHwnd();
1380 HWND hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
1381
1382 ::WinSetParent(hWndChild, hWndParent, TRUE);
1383 return TRUE;
1384 } // end of wxWindowOS2::Reparent
1385
1386 void wxWindowOS2::Clear()
1387 {
1388 wxClientDC vDc((wxWindow*)this);
1389 wxBrush vBrush( GetBackgroundColour()
1390 ,wxSOLID
1391 );
1392
1393 vDc.SetBackground(vBrush);
1394 vDc.Clear();
1395 } // end of wxWindowOS2::Clear
1396
1397 void wxWindowOS2::Update()
1398 {
1399 ::WinUpdateWindow(GetHwnd());
1400 } // end of wxWindowOS2::Update
1401
1402 void wxWindowOS2::Freeze()
1403 {
1404 ::WinSendMsg(GetHwnd(), WM_VRNDISABLED, (MPARAM)0, (MPARAM)0);
1405 } // end of wxWindowOS2::Freeze
1406
1407 void wxWindowOS2::Thaw()
1408 {
1409 ::WinSendMsg(GetHwnd(), WM_VRNENABLED, (MPARAM)TRUE, (MPARAM)0);
1410
1411 //
1412 // We need to refresh everything or otherwise he invalidated area is not
1413 // repainted.
1414 //
1415 Refresh();
1416 } // end of wxWindowOS2::Thaw
1417
1418 void wxWindowOS2::Refresh(
1419 bool bEraseBack
1420 , const wxRect* pRect
1421 )
1422 {
1423 HWND hWnd = GetHwnd();
1424
1425 if (hWnd)
1426 {
1427 if (pRect)
1428 {
1429 RECTL vOs2Rect;
1430
1431 vOs2Rect.xLeft = pRect->x;
1432 vOs2Rect.yTop = pRect->y;
1433 vOs2Rect.xRight = pRect->x + pRect->width;
1434 vOs2Rect.yBottom = pRect->y + pRect->height;
1435
1436 ::WinInvalidateRect(hWnd, &vOs2Rect, bEraseBack);
1437 }
1438 else
1439 ::WinInvalidateRect(hWnd, NULL, bEraseBack);
1440 if (m_hWndScrollBarHorz != NULLHANDLE)
1441 ::WinInvalidateRect(m_hWndScrollBarHorz, NULL, TRUE);
1442 if (m_hWndScrollBarVert != NULLHANDLE)
1443 ::WinInvalidateRect(m_hWndScrollBarVert, NULL, TRUE);
1444 }
1445 } // end of wxWindowOS2::Refresh
1446
1447 // ---------------------------------------------------------------------------
1448 // drag and drop
1449 // ---------------------------------------------------------------------------
1450
1451 #if wxUSE_DRAG_AND_DROP
1452 void wxWindowOS2::SetDropTarget(
1453 wxDropTarget* pDropTarget
1454 )
1455 {
1456 if (m_dropTarget != 0)
1457 {
1458 m_dropTarget->Revoke(m_hWnd);
1459 delete m_dropTarget;
1460 }
1461 m_dropTarget = pDropTarget;
1462 if (m_dropTarget != 0)
1463 m_dropTarget->Register(m_hWnd);
1464 } // end of wxWindowOS2::SetDropTarget
1465 #endif
1466
1467 //
1468 // old style file-manager drag&drop support: we retain the old-style
1469 // DragAcceptFiles in parallel with SetDropTarget.
1470 //
1471 void wxWindowOS2::DragAcceptFiles(
1472 bool bAccept
1473 )
1474 {
1475 HWND hWnd = GetHwnd();
1476
1477 if (hWnd && bAccept)
1478 ::DrgAcceptDroppedFiles(hWnd, NULL, NULL, DO_COPY, 0L);
1479 } // end of wxWindowOS2::DragAcceptFiles
1480
1481 // ----------------------------------------------------------------------------
1482 // tooltips
1483 // ----------------------------------------------------------------------------
1484
1485 #if wxUSE_TOOLTIPS
1486
1487 void wxWindowOS2::DoSetToolTip(
1488 wxToolTip* pTooltip
1489 )
1490 {
1491 wxWindowBase::DoSetToolTip(pTooltip);
1492
1493 if (m_tooltip)
1494 m_tooltip->SetWindow(this);
1495 } // end of wxWindowOS2::DoSetToolTip
1496
1497 #endif // wxUSE_TOOLTIPS
1498
1499 // ---------------------------------------------------------------------------
1500 // moving and resizing
1501 // ---------------------------------------------------------------------------
1502
1503 // Get total size
1504 void wxWindowOS2::DoGetSize(
1505 int* pWidth
1506 , int* pHeight
1507 ) const
1508 {
1509 HWND hWnd;
1510 RECTL vRect;
1511
1512 if (IsKindOf(CLASSINFO(wxFrame)))
1513 {
1514 wxFrame* pFrame = wxDynamicCast(this, wxFrame);
1515 hWnd = pFrame->GetFrame();
1516 }
1517 else
1518 hWnd = GetHwnd();
1519
1520 ::WinQueryWindowRect(hWnd, &vRect);
1521
1522 if (pWidth)
1523 *pWidth = vRect.xRight - vRect.xLeft;
1524 if (pHeight )
1525 // OS/2 PM is backwards from windows
1526 *pHeight = vRect.yTop - vRect.yBottom;
1527 } // end of wxWindowOS2::DoGetSize
1528
1529 void wxWindowOS2::DoGetPosition(
1530 int* pX
1531 , int* pY
1532 ) const
1533 {
1534 HWND hWnd = GetHwnd();
1535 SWP vSwp;
1536 POINTL vPoint;
1537 wxWindow* pParent = GetParent();
1538
1539 //
1540 // It would seem that WinQueryWindowRect would be the correlary to
1541 // the WIN32 WinGetRect, but unlike WinGetRect which returns the window
1542 // origin position in screen coordinates, WinQueryWindowRect returns it
1543 // relative to itself, i.e. (0,0). To get the same under PM we must
1544 // us WinQueryWindowPos. This call, unlike the WIN32 call, however,
1545 // returns a position relative to it's parent, so no parent adujstments
1546 // are needed under OS/2. Also, windows should be created using
1547 // wxWindow coordinates, i.e 0,0 is the TOP left so vSwp will already
1548 // reflect that.
1549 //
1550 ::WinQueryWindowPos(hWnd, &vSwp);
1551
1552 vPoint.x = vSwp.x;
1553 vPoint.y = vSwp.y;
1554
1555 //
1556 // We may be faking the client origin. So a window that's really at (0,
1557 // 30) may appear (to wxWin apps) to be at (0, 0).
1558 //
1559 if (pParent)
1560 {
1561 wxPoint vPt(pParent->GetClientAreaOrigin());
1562
1563 vPoint.x -= vPt.x;
1564 vPoint.y -= vPt.y;
1565 }
1566
1567 if (pX)
1568 *pX = vPoint.x;
1569 if (pY)
1570 *pY = vPoint.y;
1571 } // end of wxWindowOS2::DoGetPosition
1572
1573 void wxWindowOS2::DoScreenToClient(
1574 int* pX
1575 , int* pY
1576 ) const
1577 {
1578 HWND hWnd = GetHwnd();
1579 SWP vSwp;
1580
1581 ::WinQueryWindowPos(hWnd, &vSwp);
1582
1583 if (pX)
1584 *pX += vSwp.x;
1585 if (pY)
1586 *pY += vSwp.y;
1587 } // end of wxWindowOS2::DoScreenToClient
1588
1589 void wxWindowOS2::DoClientToScreen(
1590 int* pX
1591 , int* pY
1592 ) const
1593 {
1594 HWND hWnd = GetHwnd();
1595 SWP vSwp;
1596
1597 ::WinQueryWindowPos(hWnd, &vSwp);
1598
1599 if (pX)
1600 *pX += vSwp.x;
1601 if (pY)
1602 *pY += vSwp.y;
1603 } // end of wxWindowOS2::DoClientToScreen
1604
1605 //
1606 // Get size *available for subwindows* i.e. excluding menu bar etc.
1607 // Must be a frame type window
1608 //
1609 void wxWindowOS2::DoGetClientSize(
1610 int* pWidth
1611 , int* pHeight
1612 ) const
1613 {
1614 HWND hWnd = GetHwnd();
1615 RECTL vRect;
1616
1617 ::WinQueryWindowRect(hWnd, &vRect);
1618 if (IsKindOf(CLASSINFO(wxDialog)))
1619 {
1620 RECTL vTitle;
1621 HWND hWndTitle;
1622 //
1623 // For a Dialog we have to explicitly request the client portion.
1624 // For a Frame the hWnd IS the client window
1625 //
1626 hWndTitle = ::WinWindowFromID(hWnd, FID_TITLEBAR);
1627 if (::WinQueryWindowRect(hWndTitle, &vTitle))
1628 {
1629 if (vTitle.yTop - vTitle.yBottom == 0)
1630 {
1631 //
1632 // Dialog has not been created yet, use a default
1633 //
1634 vTitle.yTop = 20;
1635 }
1636 vRect.yTop -= (vTitle.yTop - vTitle.yBottom);
1637 }
1638
1639 ULONG uStyle = ::WinQueryWindowULong(hWnd, QWL_STYLE);
1640
1641 //
1642 // Deal with borders
1643 //
1644 if (uStyle & FCF_DLGBORDER)
1645 {
1646 vRect.xLeft += 4;
1647 vRect.xRight -= 4;
1648 vRect.yTop -= 4;
1649 vRect.yBottom += 4;
1650 }
1651 else if (uStyle & FCF_SIZEBORDER)
1652 {
1653 vRect.xLeft += 4;
1654 vRect.xRight -= 4;
1655 vRect.yTop -= 4;
1656 vRect.yBottom += 4;
1657 }
1658 else if (uStyle & FCF_BORDER)
1659 {
1660 vRect.xLeft += 2;
1661 vRect.xRight -= 2;
1662 vRect.yTop -= 2;
1663 vRect.yBottom += 2;
1664 }
1665 else // make some kind of adjustment or top sizers ram into the titlebar!
1666 {
1667 vRect.xLeft += 3;
1668 vRect.xRight -= 3;
1669 vRect.yTop -= 3;
1670 vRect.yBottom += 3;
1671 }
1672 }
1673 if (pWidth)
1674 *pWidth = vRect.xRight - vRect.xLeft;
1675 if (pHeight)
1676 *pHeight = vRect.yTop - vRect.yBottom;
1677 } // end of wxWindowOS2::DoGetClientSize
1678
1679 void wxWindowOS2::DoMoveWindow(
1680 int nX
1681 , int nY
1682 , int nWidth
1683 , int nHeight
1684 )
1685 {
1686 RECTL vRect;
1687 HWND hParent;
1688 wxWindow* pParent = GetParent();
1689
1690 if (pParent && !IsKindOf(CLASSINFO(wxDialog)))
1691 {
1692 int nOS2Height = GetOS2ParentHeight(pParent);
1693
1694 nY = nOS2Height - (nY + nHeight);
1695 }
1696 else
1697 {
1698 RECTL vRect;
1699
1700 ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
1701 nY = vRect.yTop - (nY + nHeight);
1702 }
1703
1704 //
1705 // In the case of a frame whose client is sized, the client cannot be
1706 // large than its parent frame minus its borders! This usually happens
1707 // when using an autosizer to size a frame to precisely hold client
1708 // controls as in the notebook sample.
1709 //
1710 // In this case, we may need to resize both a frame and its client so we
1711 // need a quick calc of the frame border size, then if the frame
1712 // (less its borders) is smaller than the client, size the frame to
1713 // encompass the client with the appropriate border size.
1714 //
1715 if (IsKindOf(CLASSINFO(wxFrame)))
1716 {
1717 RECTL vFRect;
1718 HWND hWndFrame;
1719 int nWidthFrameDelta = 0;
1720 int nHeightFrameDelta = 0;
1721 int nHeightFrame = 0;
1722 int nWidthFrame = 0;
1723 ULONG ulFLag = SWP_MOVE;
1724 wxFrame* pFrame;
1725
1726 pFrame = wxDynamicCast(this, wxFrame);
1727 hWndFrame = pFrame->GetFrame();
1728 ::WinQueryWindowRect(hWndFrame, &vRect);
1729 ::WinMapWindowPoints(hWndFrame, HWND_DESKTOP, (PPOINTL)&vRect, 2);
1730 vFRect = vRect;
1731 ::WinCalcFrameRect(hWndFrame, &vRect, TRUE);
1732 nWidthFrameDelta = ((vRect.xLeft - vFRect.xLeft) + (vFRect.xRight - vRect.xRight));
1733 nHeightFrameDelta = ((vRect.yBottom - vFRect.yBottom) + (vFRect.yTop - vRect.yTop));
1734 nWidthFrame = vFRect.xRight - vFRect.xLeft;
1735 nHeightFrame = vFRect.yTop - vFRect.yBottom;
1736
1737 if (nWidth == vFRect.xRight - vFRect.xLeft &&
1738 nHeight == vFRect.yTop - vFRect.yBottom)
1739 {
1740 //
1741 // In this case the caller is not aware of OS/2's need to size both
1742 // the frame and it's client and is really only moving the window,
1743 // not resizeing it. So move the frame, and back off the sizes
1744 // for a proper client fit.
1745 //
1746 ::WinSetWindowPos( hWndFrame
1747 ,HWND_TOP
1748 ,(LONG)nX - (vRect.xLeft - vFRect.xLeft)
1749 ,(LONG)nY - (vRect.yBottom - vFRect.yBottom)
1750 ,(LONG)0
1751 ,(LONG)0
1752 ,SWP_MOVE
1753 );
1754 nX += (vRect.xLeft - vFRect.xLeft);
1755 nY += (vRect.yBottom - vFRect.yBottom);
1756 nWidth -= nWidthFrameDelta;
1757 nHeight -= nHeightFrameDelta;
1758 }
1759 else
1760 {
1761 if (nWidth > nWidthFrame - nHeightFrameDelta ||
1762 nHeight > nHeightFrame - nHeightFrameDelta)
1763 {
1764 ::WinSetWindowPos( hWndFrame
1765 ,HWND_TOP
1766 ,(LONG)nX - (vRect.xLeft - vFRect.xLeft)
1767 ,(LONG)nY - (vRect.yBottom - vFRect.yBottom)
1768 ,(LONG)nWidth + nWidthFrameDelta
1769 ,(LONG)nHeight + nHeightFrameDelta
1770 ,SWP_MOVE | SWP_SIZE
1771 );
1772 }
1773 }
1774 }
1775
1776 ::WinSetWindowPos( GetHwnd()
1777 ,HWND_TOP
1778 ,(LONG)nX
1779 ,(LONG)nY
1780 ,(LONG)nWidth
1781 ,(LONG)nHeight
1782 ,SWP_SIZE | SWP_MOVE
1783 );
1784 if (m_vWinSwp.cx == 0 && m_vWinSwp.cy == 0 && m_vWinSwp.fl == 0)
1785 //
1786 // Uninitialized
1787 //
1788 ::WinQueryWindowPos(GetHwnd(), &m_vWinSwp);
1789 else
1790 {
1791 int nYDiff = m_vWinSwp.cy - nHeight;
1792
1793 //
1794 // Handle resizing of scrolled windows. The target or window to
1795 // be scrolled is the owner (gets the scroll notificaitons). The
1796 // parent is usually the parent frame of the scrolled panel window.
1797 // In order to show the scrollbars the target window will be shrunk
1798 // by the size of the scroll bar widths (20) and moved in the X and Y
1799 // directon. That value will be computed as part of the diff for
1800 // moving the children. Everytime the window is sized the
1801 // toplevel OnSize is going to resize the panel to fit the client
1802 // or the whole sizer and will need to me resized. This will send
1803 // a WM_SIZE out which will be intercepted by the ScrollHelper
1804 // which will cause the scrollbars to be displayed via the SetScrollbar
1805 // call in CWindow.
1806 //
1807 if ( IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
1808 IsKindOf(CLASSINFO(wxScrolledWindow))
1809 )
1810 {
1811 int nAdjustWidth = 0;
1812 int nAdjustHeight = 0;
1813 SWP vSwpScroll;
1814
1815 if (GetScrollBarHorz() == NULLHANDLE ||
1816 !WinIsWindowShowing(GetScrollBarHorz()))
1817 nAdjustHeight = 0L;
1818 else
1819 nAdjustHeight = 20L;
1820 if (GetScrollBarVert() == NULLHANDLE ||
1821 !WinIsWindowShowing(GetScrollBarVert()))
1822 nAdjustWidth = 0L;
1823 else
1824 nAdjustWidth = 20L;
1825 ::WinQueryWindowPos(GetHWND(), &vSwpScroll);
1826 ::WinSetWindowPos( GetHWND()
1827 ,HWND_TOP
1828 ,vSwpScroll.x
1829 ,vSwpScroll.y + nAdjustHeight
1830 ,vSwpScroll.cx - nAdjustWidth
1831 ,vSwpScroll.cy - nAdjustHeight
1832 ,SWP_MOVE | SWP_SIZE
1833 );
1834 nYDiff += nAdjustHeight;
1835 }
1836 MoveChildren(nYDiff);
1837 ::WinQueryWindowPos(GetHwnd(), &m_vWinSwp);
1838 }
1839 } // end of wxWindowOS2::DoMoveWindow
1840
1841 //
1842 // Set the size of the window: if the dimensions are positive, just use them,
1843 // but if any of them is equal to -1, it means that we must find the value for
1844 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1845 // which case -1 is a valid value for x and y)
1846 //
1847 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1848 // the width/height to best suit our contents, otherwise we reuse the current
1849 // width/height
1850 //
1851 void wxWindowOS2::DoSetSize(
1852 int nX
1853 , int nY
1854 , int nWidth
1855 , int nHeight
1856 , int nSizeFlags
1857 )
1858 {
1859 //
1860 // Get the current size and position...
1861 //
1862 int nCurrentX;
1863 int nCurrentY;
1864 int nCurrentWidth;
1865 int nCurrentHeight;
1866 wxSize vSize(-1, -1);
1867
1868 GetPosition(&nCurrentX, &nCurrentY);
1869 GetSize(&nCurrentWidth, &nCurrentHeight);
1870
1871 //
1872 // ... and don't do anything (avoiding flicker) if it's already ok
1873 //
1874 //
1875 // Must convert Y coords to test for equality under OS/2
1876 //
1877 int nY2 = nY;
1878 wxWindow* pParent = (wxWindow*)GetParent();
1879
1880 if (nX == nCurrentX && nY2 == nCurrentY &&
1881 nWidth == nCurrentWidth && nHeight == nCurrentHeight)
1882 {
1883 return;
1884 }
1885
1886 if (nX == -1 && !(nSizeFlags & wxSIZE_ALLOW_MINUS_ONE))
1887 nX = nCurrentX;
1888 if (nY == -1 && !(nSizeFlags & wxSIZE_ALLOW_MINUS_ONE))
1889 nY = nCurrentY;
1890
1891 AdjustForParentClientOrigin(nX, nY, nSizeFlags);
1892
1893 if (nWidth == -1)
1894 {
1895 if (nSizeFlags & wxSIZE_AUTO_WIDTH)
1896 {
1897 vSize = DoGetBestSize();
1898 nWidth = vSize.x;
1899 }
1900 else
1901 {
1902 //
1903 // Just take the current one
1904 //
1905 nWidth = nCurrentWidth;
1906 }
1907 }
1908
1909 if (nHeight == -1)
1910 {
1911 if (nSizeFlags & wxSIZE_AUTO_HEIGHT)
1912 {
1913 if (vSize.x == -1)
1914 {
1915 vSize = DoGetBestSize();
1916 }
1917 nHeight = vSize.y;
1918 }
1919 else
1920 {
1921 // just take the current one
1922 nHeight = nCurrentHeight;
1923 }
1924 }
1925
1926 DoMoveWindow( nX
1927 ,nY
1928 ,nWidth
1929 ,nHeight
1930 );
1931 } // end of wxWindowOS2::DoSetSize
1932
1933 void wxWindowOS2::DoSetClientSize(
1934 int nWidth
1935 , int nHeight
1936 )
1937 {
1938 POINTL vPoint;
1939 int nActualWidth;
1940 int nActualHeight;
1941 wxWindow* pParent = (wxWindow*)GetParent();
1942 HWND hParentWnd = (HWND)0;
1943
1944 if (pParent)
1945 hParentWnd = (HWND)pParent->GetHWND();
1946
1947 if (IsKindOf(CLASSINFO(wxFrame)))
1948 {
1949 wxFrame* pFrame = wxDynamicCast(this, wxFrame);
1950 HWND hFrame = pFrame->GetFrame();
1951 RECTL vRect;
1952 RECTL vRect2;
1953 RECTL vRect3;
1954
1955 ::WinQueryWindowRect(GetHwnd(), &vRect2);
1956 ::WinQueryWindowRect(hFrame, &vRect);
1957 ::WinQueryWindowRect(hParentWnd, &vRect3);
1958 nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth;
1959 nActualHeight = vRect2.yTop - vRect2.yBottom - vRect.yTop + nHeight;
1960
1961 vPoint.x = vRect2.xLeft;
1962 vPoint.y = vRect2.yBottom;
1963 if (pParent)
1964 {
1965 vPoint.x -= vRect3.xLeft;
1966 vPoint.y -= vRect3.yBottom;
1967 }
1968 }
1969 else
1970 {
1971 int nX;
1972 int nY;
1973
1974 GetPosition(&nX, &nY);
1975 nActualWidth = nWidth;
1976 nActualHeight = nHeight;
1977
1978 vPoint.x = nX;
1979 vPoint.y = nY;
1980 }
1981 DoMoveWindow( vPoint.x
1982 ,vPoint.y
1983 ,nActualWidth
1984 ,nActualHeight
1985 );
1986
1987 wxSizeEvent vEvent( wxSize( nWidth
1988 ,nHeight
1989 )
1990 ,m_windowId
1991 );
1992
1993 vEvent.SetEventObject(this);
1994 GetEventHandler()->ProcessEvent(vEvent);
1995 } // end of wxWindowOS2::DoSetClientSize
1996
1997 wxPoint wxWindowOS2::GetClientAreaOrigin() const
1998 {
1999 return wxPoint(0, 0);
2000 } // end of wxWindowOS2::GetClientAreaOrigin
2001
2002 // ---------------------------------------------------------------------------
2003 // text metrics
2004 // ---------------------------------------------------------------------------
2005
2006 int wxWindowOS2::GetCharHeight() const
2007 {
2008 HPS hPs;
2009 FONTMETRICS vFontMetrics;
2010
2011 hPs = ::WinGetPS(GetHwnd());
2012
2013 if(!GpiQueryFontMetrics(hPs, sizeof(FONTMETRICS), &vFontMetrics))
2014 {
2015 ::WinReleasePS(hPs);
2016 return (0);
2017 }
2018 ::WinReleasePS(hPs);
2019 return(vFontMetrics.lMaxAscender + vFontMetrics.lMaxDescender);
2020 } // end of wxWindowOS2::GetCharHeight
2021
2022 int wxWindowOS2::GetCharWidth() const
2023 {
2024 HPS hPs;
2025 FONTMETRICS vFontMetrics;
2026
2027 hPs = ::WinGetPS(GetHwnd());
2028
2029 if(!GpiQueryFontMetrics(hPs, sizeof(FONTMETRICS), &vFontMetrics))
2030 {
2031 ::WinReleasePS(hPs);
2032 return (0);
2033 }
2034 ::WinReleasePS(hPs);
2035 return(vFontMetrics.lAveCharWidth);
2036 } // end of wxWindowOS2::GetCharWidth
2037
2038 void wxWindowOS2::GetTextExtent(
2039 const wxString& rString
2040 , int* pX
2041 , int* pY
2042 , int* pDescent
2043 , int* pExternalLeading
2044 , const wxFont* pTheFont
2045 ) const
2046 {
2047 POINTL avPoint[TXTBOX_COUNT];
2048 POINTL vPtMin;
2049 POINTL vPtMax;
2050 int i;
2051 int l;
2052 FONTMETRICS vFM; // metrics structure
2053 BOOL bRc;
2054 char* pStr;
2055 ERRORID vErrorCode; // last error id code
2056 HPS hPS;
2057
2058
2059 hPS = ::WinGetPS(GetHwnd());
2060
2061 l = rString.Length();
2062 if (l > 0L)
2063 {
2064 pStr = (PCH)rString.c_str();
2065
2066 //
2067 // In world coordinates.
2068 //
2069 bRc = ::GpiQueryTextBox( hPS
2070 ,l
2071 ,pStr
2072 ,TXTBOX_COUNT // return maximum information
2073 ,avPoint // array of coordinates points
2074 );
2075 if (bRc)
2076 {
2077 vPtMin.x = avPoint[0].x;
2078 vPtMax.x = avPoint[0].x;
2079 vPtMin.y = avPoint[0].y;
2080 vPtMax.y = avPoint[0].y;
2081 for (i = 1; i < 4; i++)
2082 {
2083 if(vPtMin.x > avPoint[i].x) vPtMin.x = avPoint[i].x;
2084 if(vPtMin.y > avPoint[i].y) vPtMin.y = avPoint[i].y;
2085 if(vPtMax.x < avPoint[i].x) vPtMax.x = avPoint[i].x;
2086 if(vPtMax.y < avPoint[i].y) vPtMax.y = avPoint[i].y;
2087 }
2088 bRc = ::GpiQueryFontMetrics( hPS
2089 ,sizeof(FONTMETRICS)
2090 ,&vFM
2091 );
2092 if (!bRc)
2093 {
2094 vPtMin.x = 0;
2095 vPtMin.y = 0;
2096 vPtMax.x = 0;
2097 vPtMax.y = 0;
2098 }
2099 }
2100 else
2101 {
2102 vPtMin.x = 0;
2103 vPtMin.y = 0;
2104 vPtMax.x = 0;
2105 vPtMax.y = 0;
2106 }
2107 }
2108 else
2109 {
2110 vPtMin.x = 0;
2111 vPtMin.y = 0;
2112 vPtMax.x = 0;
2113 vPtMax.y = 0;
2114 }
2115 if (pX)
2116 *pX = (vPtMax.x - vPtMin.x + 1);
2117 if (pY)
2118 *pY = (vPtMax.y - vPtMin.y + 1);
2119 if (pDescent)
2120 {
2121 if (bRc)
2122 *pDescent = vFM.lMaxDescender;
2123 else
2124 *pDescent = 0;
2125 }
2126 if (pExternalLeading)
2127 {
2128 if (bRc)
2129 *pExternalLeading = vFM.lExternalLeading;
2130 else
2131 *pExternalLeading = 0;
2132 }
2133 ::WinReleasePS(hPS);
2134 } // end of wxWindow::GetTextExtent
2135
2136 bool wxWindowOS2::IsMouseInWindow() const
2137 {
2138 //
2139 // Get the mouse position
2140 POINTL vPt;
2141
2142 ::WinQueryPointerPos(HWND_DESKTOP, &vPt);
2143
2144 //
2145 // Find the window which currently has the cursor and go up the window
2146 // chain until we find this window - or exhaust it
2147 //
2148 HWND hWnd = ::WinWindowFromPoint(HWND_DESKTOP, &vPt, TRUE);
2149
2150 while (hWnd && (hWnd != GetHwnd()))
2151 hWnd = ::WinQueryWindow(hWnd, QW_PARENT);
2152
2153 return hWnd != NULL;
2154 } // end of wxWindowOS2::IsMouseInWindow
2155
2156 #if wxUSE_CARET && WXWIN_COMPATIBILITY
2157 // ---------------------------------------------------------------------------
2158 // Caret manipulation
2159 // ---------------------------------------------------------------------------
2160
2161 void wxWindowOS2::CreateCaret(
2162 int nWidth
2163 , int nHeight
2164 )
2165 {
2166 SetCaret(new wxCaret( this
2167 ,nWidth
2168 ,nHeight
2169 ));
2170 } // end of wxWindowOS2::CreateCaret
2171
2172 void wxWindowOS2::CreateCaret(
2173 const wxBitmap* pBitmap
2174 )
2175 {
2176 wxFAIL_MSG("not implemented");
2177 } // end of wxWindowOS2::CreateCaret
2178
2179 void wxWindowOS2::ShowCaret(
2180 bool bShow
2181 )
2182 {
2183 wxCHECK_RET( m_caret, "no caret to show" );
2184
2185 m_caret->Show(bShow);
2186 } // end of wxWindowOS2::ShowCaret
2187
2188 void wxWindowOS2::DestroyCaret()
2189 {
2190 SetCaret(NULL);
2191 } // end of wxWindowOS2::DestroyCaret
2192
2193 void wxWindowOS2::SetCaretPos(
2194 int nX
2195 , int nY)
2196 {
2197 wxCHECK_RET( m_caret, "no caret to move" );
2198
2199 m_caret->Move( nX
2200 ,nY
2201 );
2202 } // end of wxWindowOS2::SetCaretPos
2203
2204 void wxWindowOS2::GetCaretPos(
2205 int* pX
2206 , int* pY
2207 ) const
2208 {
2209 wxCHECK_RET( m_caret, "no caret to get position of" );
2210
2211 m_caret->GetPosition( pX
2212 ,pY
2213 );
2214 } // end of wxWindowOS2::GetCaretPos
2215
2216 #endif //wxUSE_CARET
2217
2218 // ---------------------------------------------------------------------------
2219 // popup menu
2220 // ---------------------------------------------------------------------------
2221 //
2222 #if wxUSE_MENUS_NATIVE
2223 static void wxYieldForCommandsOnly()
2224 {
2225 //
2226 // Peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2227 // want to process it here)
2228 //
2229 QMSG vMsg;
2230
2231 while (::WinPeekMsg(vHabmain, &vMsg, (HWND)0, WM_COMMAND, WM_COMMAND, PM_REMOVE)
2232 && vMsg.msg != WM_QUIT)
2233 {
2234 wxTheApp->DoMessage((WXMSG*)&vMsg);
2235 }
2236 }
2237 #endif // wxUSE_MENUS_NATIVE
2238
2239 #if wxUSE_MENUS_NATIVE
2240 bool wxWindowOS2::DoPopupMenu(
2241 wxMenu* pMenu
2242 , int nX
2243 , int nY
2244 )
2245 {
2246 HWND hWndOwner = GetHwnd();
2247 HWND hWndParent = GetHwnd();
2248 HWND hMenu = GetHmenuOf(pMenu);
2249 bool bIsWaiting = TRUE;
2250
2251 pMenu->SetInvokingWindow(this);
2252 pMenu->UpdateUI();
2253
2254 DoClientToScreen( &nX
2255 ,&nY
2256 );
2257 wxCurrentPopupMenu = pMenu;
2258
2259 ::WinPopupMenu( hWndParent
2260 ,hWndOwner
2261 ,hMenu
2262 ,nX
2263 ,nY
2264 ,0L
2265 ,PU_HCONSTRAIN | PU_VCONSTRAIN | PU_MOUSEBUTTON1 | PU_KEYBOARD
2266 );
2267
2268 while(bIsWaiting)
2269 {
2270 QMSG vMsg;
2271 BOOL bRc = ::WinGetMsg(vHabmain, &vMsg, HWND(NULL), 0, 0);
2272
2273 if (vMsg.msg == WM_MENUEND || vMsg.msg == WM_COMMAND)
2274 {
2275 bIsWaiting = FALSE;
2276 }
2277 ::WinDispatchMsg(vHabmain, (PQMSG)&vMsg);
2278
2279 }
2280 wxCurrentPopupMenu = NULL;
2281 pMenu->SetInvokingWindow(NULL);
2282 return TRUE;
2283 } // end of wxWindowOS2::DoPopupMenu
2284 #endif // wxUSE_MENUS_NATIVE
2285
2286 // ===========================================================================
2287 // pre/post message processing
2288 // ===========================================================================
2289
2290 MRESULT wxWindowOS2::OS2DefWindowProc(
2291 WXUINT uMsg
2292 , WXWPARAM wParam
2293 , WXLPARAM lParam
2294 )
2295 {
2296 if (m_fnOldWndProc)
2297 return (MRESULT)m_fnOldWndProc(GetHWND(), uMsg, (MPARAM)wParam, (MPARAM)lParam);
2298 else
2299 return ::WinDefWindowProc(GetHWND(), uMsg, (MPARAM)wParam, (MPARAM)lParam);
2300 } // end of wxWindowOS2::OS2DefWindowProc
2301
2302 bool wxWindowOS2::OS2ProcessMessage(
2303 WXMSG* pMsg
2304 )
2305 {
2306 // wxUniversal implements tab traversal itself
2307 #ifndef __WXUNIVERSAL__
2308 QMSG* pQMsg = (QMSG*)pMsg;
2309
2310 if (m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL))
2311 {
2312 //
2313 // Intercept dialog navigation keys
2314 //
2315 bool bProcess = TRUE;
2316 USHORT uKeyFlags = SHORT1FROMMP(pQMsg->mp1);
2317
2318 if (uKeyFlags & KC_KEYUP)
2319 bProcess = FALSE;
2320
2321 if (uKeyFlags & KC_ALT)
2322 bProcess = FALSE;
2323
2324 if (!(uKeyFlags & KC_VIRTUALKEY))
2325 bProcess = FALSE;
2326
2327 if (bProcess)
2328 {
2329 bool bCtrlDown = IsCtrlDown();
2330 bool bShiftDown = IsShiftDown();
2331
2332 //
2333 // WM_QUERYDLGCODE: ask the control if it wants the key for itself,
2334 // don't process it if it's the case (except for Ctrl-Tab/Enter
2335 // combinations which are always processed)
2336 //
2337 ULONG ulDlgCode = 0;
2338
2339 if (!bCtrlDown)
2340 {
2341 ulDlgCode = (ULONG)::WinSendMsg(pQMsg->hwnd, WM_QUERYDLGCODE, pQMsg, 0);
2342 }
2343
2344 bool bForward = TRUE;
2345 bool bWindowChange = FALSE;
2346
2347 switch (SHORT2FROMMP(pQMsg->mp2))
2348 {
2349 //
2350 // Going to make certain assumptions about specific types of controls
2351 // here, so we may have to alter some things later if they prove invalid
2352 //
2353 case VK_TAB:
2354 //
2355 // Shift tabl will always be a nav-key but tabs may be wanted
2356 //
2357 if (!bShiftDown)
2358 {
2359 bProcess = FALSE;
2360 }
2361 else
2362 {
2363 //
2364 // Entry Fields want tabs for themselve usually
2365 //
2366 switch (ulDlgCode)
2367 {
2368 case DLGC_ENTRYFIELD:
2369 case DLGC_MLE:
2370 bProcess = TRUE;
2371 break;
2372
2373 default:
2374 bProcess = FALSE;
2375 }
2376
2377 //
2378 // Ctrl-Tab cycles thru notebook pages
2379 //
2380 bWindowChange = bCtrlDown;
2381 bForward = !bShiftDown;
2382 }
2383 break;
2384
2385 case VK_UP:
2386 case VK_LEFT:
2387 if (bCtrlDown)
2388 bProcess = FALSE;
2389 else
2390 bForward = FALSE;
2391 break;
2392
2393 case VK_DOWN:
2394 case VK_RIGHT:
2395 if (bCtrlDown)
2396 bProcess = FALSE;
2397 break;
2398
2399 case VK_ENTER:
2400 {
2401 if (bCtrlDown)
2402 {
2403 //
2404 // ctrl-enter is not processed
2405 //
2406 return FALSE;
2407 }
2408 else if (ulDlgCode & DLGC_BUTTON)
2409 {
2410 //
2411 // buttons want process Enter themselevs
2412 //
2413 bProcess = FALSE;
2414 }
2415 else
2416 {
2417 wxButton* pBtn = wxDynamicCast( GetDefaultItem()
2418 ,wxButton
2419 );
2420
2421 if (pBtn && pBtn->IsEnabled())
2422 {
2423 //
2424 // If we do have a default button, do press it
2425 //
2426 pBtn->OS2Command(BN_CLICKED, 0 /* unused */);
2427 return TRUE;
2428 }
2429 // else: but if it does not it makes sense to make
2430 // it work like a TAB - and that's what we do.
2431 // Note that Ctrl-Enter always works this way.
2432 }
2433 }
2434 break;
2435
2436 default:
2437 bProcess = FALSE;
2438 }
2439
2440 if (bProcess)
2441 {
2442 wxNavigationKeyEvent vEvent;
2443
2444 vEvent.SetDirection(bForward);
2445 vEvent.SetWindowChange(bWindowChange);
2446 vEvent.SetEventObject(this);
2447
2448 if (GetEventHandler()->ProcessEvent(vEvent))
2449 {
2450 wxButton* pBtn = wxDynamicCast(FindFocus(), wxButton);
2451
2452 if (pBtn)
2453 {
2454 //
2455 // The button which has focus should be default
2456 //
2457 pBtn->SetDefault();
2458 }
2459 return TRUE;
2460 }
2461 }
2462 }
2463 //
2464 // Let Dialogs process
2465 //
2466 if (::WinSendMsg(pQMsg->hwnd, WM_QUERYDLGCODE, pQMsg, 0));
2467 return TRUE;
2468 }
2469 #else
2470 pMsg = pMsg; // just shut up the compiler
2471 #endif // __WXUNIVERSAL__
2472
2473 return FALSE;
2474 } // end of wxWindowOS2::OS2ProcessMessage
2475
2476 bool wxWindowOS2::OS2TranslateMessage(
2477 WXMSG* pMsg
2478 )
2479 {
2480 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2481 return m_acceleratorTable.Translate(m_hWnd, pMsg);
2482 #else
2483 pMsg = pMsg;
2484 return FALSE;
2485 #endif //wxUSE_ACCEL
2486 } // end of wxWindowOS2::OS2TranslateMessage
2487
2488 bool wxWindowOS2::OS2ShouldPreProcessMessage(
2489 WXMSG* pMsg
2490 )
2491 {
2492 // preprocess all messages by default
2493 return TRUE;
2494 } // end of wxWindowOS2::OS2ShouldPreProcessMessage
2495
2496 // ---------------------------------------------------------------------------
2497 // message params unpackers
2498 // ---------------------------------------------------------------------------
2499
2500 void wxWindowOS2::UnpackCommand(
2501 WXWPARAM wParam
2502 , WXLPARAM lParam
2503 , WORD* pId
2504 , WXHWND* phWnd
2505 , WORD* pCmd
2506 )
2507 {
2508 *pId = LOWORD(wParam);
2509 *phWnd = NULL; // or may be GetHWND() ?
2510 *pCmd = LOWORD(lParam);
2511 } // end of wxWindowOS2::UnpackCommand
2512
2513 void wxWindowOS2::UnpackActivate(
2514 WXWPARAM wParam
2515 , WXLPARAM lParam
2516 , WXWORD* pState
2517 , WXHWND* phWnd
2518 )
2519 {
2520 *pState = LOWORD(wParam);
2521 *phWnd = (WXHWND)lParam;
2522 } // end of wxWindowOS2::UnpackActivate
2523
2524 void wxWindowOS2::UnpackScroll(
2525 WXWPARAM wParam
2526 , WXLPARAM lParam
2527 , WXWORD* pCode
2528 , WXWORD* pPos
2529 , WXHWND* phWnd
2530 )
2531 {
2532 ULONG ulId;
2533 HWND hWnd;
2534
2535 ulId = (ULONG)LONGFROMMP(wParam);
2536 hWnd = ::WinWindowFromID(GetHwnd(), ulId);
2537 if (hWnd == m_hWndScrollBarHorz || hWnd == m_hWndScrollBarVert)
2538 *phWnd = NULLHANDLE;
2539 else
2540 *phWnd = hWnd;
2541
2542 *pPos = SHORT1FROMMP(lParam);
2543 *pCode = SHORT2FROMMP(lParam);
2544 } // end of wxWindowOS2::UnpackScroll
2545
2546 void wxWindowOS2::UnpackMenuSelect(
2547 WXWPARAM wParam
2548 , WXLPARAM lParam
2549 , WXWORD* pItem
2550 , WXWORD* pFlags
2551 , WXHMENU* phMenu
2552 )
2553 {
2554 *pItem = (WXWORD)LOWORD(wParam);
2555 *pFlags = HIWORD(wParam);
2556 *phMenu = (WXHMENU)lParam;
2557 } // end of wxWindowOS2::UnpackMenuSelect
2558
2559 // ---------------------------------------------------------------------------
2560 // Main wxWindows window proc and the window proc for wxWindow
2561 // ---------------------------------------------------------------------------
2562
2563 //
2564 // Hook for new window just as it's being created, when the window isn't yet
2565 // associated with the handle
2566 //
2567 wxWindowOS2* wxWndHook = NULL;
2568
2569 //
2570 // Main window proc
2571 //
2572 MRESULT EXPENTRY wxWndProc(
2573 HWND hWnd
2574 , ULONG ulMsg
2575 , MPARAM wParam
2576 , MPARAM lParam
2577 )
2578 {
2579 //
2580 // Trace all ulMsgs - useful for the debugging
2581 //
2582 #ifdef __WXDEBUG__
2583 wxLogTrace(wxTraceMessages, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"),
2584 wxGetMessageName(ulMsg), wParam, lParam);
2585 #endif // __WXDEBUG__
2586
2587 wxWindowOS2* pWnd = wxFindWinFromHandle((WXHWND)hWnd);
2588
2589 //
2590 // When we get the first message for the HWND we just created, we associate
2591 // it with wxWindow stored in wxWndHook
2592 //
2593 if (!pWnd && wxWndHook)
2594 {
2595 wxAssociateWinWithHandle(hWnd, wxWndHook);
2596 pWnd = wxWndHook;
2597 wxWndHook = NULL;
2598 pWnd->SetHWND((WXHWND)hWnd);
2599 }
2600
2601 MRESULT rc = (MRESULT)0;
2602
2603
2604 //
2605 // Stop right here if we don't have a valid handle in our wxWindow object.
2606 //
2607 if (pWnd && !pWnd->GetHWND())
2608 {
2609 pWnd->SetHWND((WXHWND) hWnd);
2610 rc = pWnd->OS2DefWindowProc(ulMsg, wParam, lParam );
2611 pWnd->SetHWND(0);
2612 }
2613 else
2614 {
2615 if (pWnd)
2616 {
2617 rc = pWnd->OS2WindowProc(ulMsg, wParam, lParam);
2618 if ( (pWnd->GetScrollBarHorz() != NULLHANDLE ||
2619 pWnd->GetScrollBarVert() != NULLHANDLE) &&
2620 ulMsg == WM_PAINT)
2621 {
2622 if (pWnd->GetScrollBarHorz() != NULLHANDLE)
2623 ::WinInvalidateRect(pWnd->GetScrollBarHorz(), NULL, TRUE);
2624 if (pWnd->GetScrollBarVert() != NULLHANDLE)
2625 ::WinInvalidateRect(pWnd->GetScrollBarVert(), NULL, TRUE);
2626 }
2627 }
2628 else
2629 rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
2630 }
2631
2632 return rc;
2633 } // end of wxWndProc
2634
2635 //
2636 // We will add (or delete) messages we need to handle at this default
2637 // level as we go
2638 //
2639 MRESULT wxWindowOS2::OS2WindowProc(
2640 WXUINT uMsg
2641 , WXWPARAM wParam
2642 , WXLPARAM lParam
2643 )
2644 {
2645 //
2646 // Did we process the uMsg?
2647 //
2648 bool bProcessed = FALSE;
2649 MRESULT mResult;
2650
2651 //
2652 // For most messages we should return 0 when we do process the message
2653 //
2654 mResult = (MRESULT)0;
2655
2656 switch (uMsg)
2657 {
2658 case WM_CREATE:
2659 {
2660 bool bMayCreate;
2661
2662 bProcessed = HandleCreate( (WXLPCREATESTRUCT)lParam
2663 ,&bMayCreate
2664 );
2665 if (bProcessed)
2666 {
2667 //
2668 // Return 0 to bAllow window creation
2669 //
2670 mResult = (MRESULT)(bMayCreate ? 0 : -1);
2671 }
2672 }
2673 break;
2674
2675 case WM_DESTROY:
2676 HandleDestroy();
2677 bProcessed = TRUE;
2678 break;
2679
2680 case WM_MOVE:
2681 bProcessed = HandleMove( LOWORD(lParam)
2682 ,HIWORD(lParam)
2683 );
2684 break;
2685
2686 case WM_SIZE:
2687 bProcessed = HandleSize( LOWORD(lParam)
2688 ,HIWORD(lParam)
2689 ,(WXUINT)wParam
2690 );
2691 break;
2692
2693 case WM_WINDOWPOSCHANGED:
2694
2695 //
2696 // Dialogs under OS/2 do not get WM_SIZE events at all.
2697 // Instead they get this, which can function much like WM_SIZE
2698 // PSWP contains the new sizes and positioning, PSWP+1 the old
2699 // We use this because ADJUSTWINDOWPOS comes BEFORE the new
2700 // position is added and our auto layout does a WinQueryWindowRect
2701 // to get the CURRENT client size. That is the size used to position
2702 // child controls, so we need to already be sized
2703 // in order to get the child controls positoned properly.
2704 //
2705 if (IsKindOf(CLASSINFO(wxDialog)) || IsKindOf(CLASSINFO(wxFrame)))
2706 {
2707 PSWP pSwp = (PSWP)PVOIDFROMMP(wParam);
2708 PSWP pSwp2 = pSwp++;
2709
2710 if (!(pSwp->cx == pSwp2->cx &&
2711 pSwp->cy == pSwp2->cy))
2712 bProcessed = HandleSize( pSwp->cx
2713 ,pSwp->cy
2714 ,(WXUINT)lParam
2715 );
2716 if (IsKindOf(CLASSINFO(wxFrame)))
2717 {
2718 wxFrame* pFrame = wxDynamicCast(this, wxFrame);
2719
2720 if (pFrame)
2721 {
2722 if (pFrame->GetStatusBar())
2723 pFrame->PositionStatusBar();
2724 if (pFrame->GetToolBar())
2725 pFrame->PositionToolBar();
2726 }
2727 }
2728 }
2729 break;
2730
2731 case WM_ACTIVATE:
2732 {
2733 WXWORD wState;
2734 WXHWND hWnd;
2735
2736 UnpackActivate( wParam
2737 ,lParam
2738 ,&wState
2739 ,&hWnd
2740 );
2741
2742 bProcessed = HandleActivate( wState
2743 ,(WXHWND)hWnd
2744 );
2745 bProcessed = FALSE;
2746 }
2747 break;
2748
2749 case WM_SETFOCUS:
2750 if (SHORT1FROMMP((MPARAM)lParam) == TRUE)
2751 bProcessed = HandleSetFocus((WXHWND)(HWND)wParam);
2752 else
2753 bProcessed = HandleKillFocus((WXHWND)(HWND)wParam);
2754 break;
2755
2756 case WM_PAINT:
2757 bProcessed = HandlePaint();
2758 break;
2759
2760 case WM_CLOSE:
2761 //
2762 // Don't let the DefWindowProc() destroy our window - we'll do it
2763 // ourselves in ~wxWindow
2764 //
2765 bProcessed = TRUE;
2766 mResult = (MRESULT)TRUE;
2767 break;
2768
2769 case WM_SHOW:
2770 bProcessed = HandleShow(wParam != 0, (int)lParam);
2771 break;
2772
2773 //
2774 // Under OS2 PM Joysticks are treated just like mouse events
2775 // The "Motion" events will be prevelent in joysticks
2776 //
2777 case WM_MOUSEMOVE:
2778 case WM_BUTTON1DOWN:
2779 case WM_BUTTON1UP:
2780 case WM_BUTTON1DBLCLK:
2781 case WM_BUTTON1MOTIONEND:
2782 case WM_BUTTON1MOTIONSTART:
2783 case WM_BUTTON2DOWN:
2784 case WM_BUTTON2UP:
2785 case WM_BUTTON2DBLCLK:
2786 case WM_BUTTON2MOTIONEND:
2787 case WM_BUTTON2MOTIONSTART:
2788 case WM_BUTTON3DOWN:
2789 case WM_BUTTON3UP:
2790 case WM_BUTTON3DBLCLK:
2791 case WM_BUTTON3MOTIONEND:
2792 case WM_BUTTON3MOTIONSTART:
2793 {
2794 if (uMsg == WM_BUTTON1DOWN && AcceptsFocus())
2795 SetFocus();
2796
2797 short nX = LOWORD(wParam);
2798 short nY = HIWORD(wParam);
2799
2800 //
2801 // Redirect the event to a static control if necessary
2802 //
2803 if (this == GetCapture())
2804 {
2805 bProcessed = HandleMouseEvent( uMsg
2806 ,nX
2807 ,nY
2808 ,(WXUINT)SHORT1FROMMP(wParam)
2809 );
2810 }
2811 else
2812 {
2813 wxWindow* pWin = FindWindowForMouseEvent( this
2814 ,&nX
2815 ,&nY
2816 );
2817 bProcessed = pWin->HandleMouseEvent( uMsg
2818 ,nX
2819 ,nY
2820 ,(WXUINT)SHORT1FROMMP(wParam)
2821 );
2822 }
2823 }
2824 break;
2825
2826 case WM_SYSCOMMAND:
2827 bProcessed = HandleSysCommand(wParam, lParam);
2828 break;
2829
2830 case WM_COMMAND:
2831 {
2832 WORD id, cmd;
2833 WXHWND hwnd;
2834 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
2835
2836 bProcessed = HandleCommand(id, cmd, hwnd);
2837 }
2838 break;
2839
2840 //
2841 // For these messages we must return TRUE if process the message
2842 //
2843 case WM_DRAWITEM:
2844 case WM_MEASUREITEM:
2845 {
2846 int nIdCtrl = (UINT)wParam;
2847
2848 if ( uMsg == WM_DRAWITEM )
2849 {
2850 bProcessed = OS2OnDrawItem(nIdCtrl,
2851 (WXDRAWITEMSTRUCT *)lParam);
2852 }
2853 else
2854 {
2855 return MRFROMLONG(OS2OnMeasureItem( nIdCtrl
2856 ,(WXMEASUREITEMSTRUCT *)lParam
2857 ));
2858 }
2859
2860 if ( bProcessed )
2861 mResult = (MRESULT)TRUE;
2862 }
2863 break;
2864
2865 case WM_QUERYDLGCODE:
2866 if (!IsOfStandardClass())
2867 {
2868 if ( m_lDlgCode )
2869 {
2870 mResult = (MRESULT)m_lDlgCode;
2871 bProcessed = TRUE;
2872 }
2873 }
2874 //
2875 //else: get the dlg code from the DefWindowProc()
2876 //
2877 break;
2878
2879 //
2880 // In OS/2 PM all keyboard events are of the WM_CHAR type. Virtual key and key-up
2881 // and key-down events are obtained from the WM_CHAR params.
2882 //
2883 case WM_CHAR:
2884 {
2885 USHORT uKeyFlags = SHORT1FROMMP((MPARAM)wParam);
2886
2887 if (uKeyFlags & KC_KEYUP)
2888 {
2889 //TODO: check if the cast to WXWORD isn't causing trouble
2890 bProcessed = HandleKeyUp(wParam, lParam);
2891 break;
2892 }
2893 else // keydown event
2894 {
2895 m_bLastKeydownProcessed = FALSE;
2896 //
2897 // If this has been processed by an event handler,
2898 // return 0 now (we've handled it). DON't RETURN
2899 // we still need to process further
2900 //
2901 m_bLastKeydownProcessed = HandleKeyDown(wParam, lParam);
2902 if (uKeyFlags & KC_VIRTUALKEY)
2903 {
2904 USHORT uVk = SHORT2FROMMP((MPARAM)lParam);
2905
2906 //
2907 // We consider these message "not interesting" to OnChar
2908 //
2909 switch(uVk)
2910 {
2911 case VK_SHIFT:
2912 case VK_CTRL:
2913 case VK_MENU:
2914 case VK_CAPSLOCK:
2915 case VK_NUMLOCK:
2916 case VK_SCRLLOCK:
2917 bProcessed = TRUE;
2918 break;
2919
2920 // Avoid duplicate messages to OnChar for these ASCII keys: they
2921 // will be translated by TranslateMessage() and received in WM_CHAR
2922 case VK_ESC:
2923 case VK_ENTER:
2924 case VK_BACKSPACE:
2925 case VK_TAB:
2926 // But set processed to FALSE, not TRUE to still pass them to
2927 // the control's default window proc - otherwise built-in
2928 // keyboard handling won't work
2929 bProcessed = FALSE;
2930 break;
2931
2932 default:
2933 bProcessed = HandleChar(wParam, lParam);
2934 }
2935 break;
2936 }
2937 else // WM_CHAR -- Always an ASCII character
2938 {
2939 if (m_bLastKeydownProcessed)
2940 {
2941 //
2942 // The key was handled in the EVT_KEY_DOWN and handling
2943 // a key in an EVT_KEY_DOWN handler is meant, by
2944 // design, to prevent EVT_CHARs from happening
2945 //
2946 m_bLastKeydownProcessed = FALSE;
2947 bProcessed = TRUE;
2948 }
2949 else // do generate a CHAR event
2950 {
2951 bProcessed = HandleChar(wParam, lParam, TRUE);
2952 break;
2953 }
2954 }
2955 }
2956 }
2957
2958 case WM_HSCROLL:
2959 case WM_VSCROLL:
2960 {
2961 WXWORD wCode;
2962 WXWORD wPos;
2963 WXHWND hWnd;
2964 UnpackScroll( wParam
2965 ,lParam
2966 ,&wCode
2967 ,&wPos
2968 ,&hWnd
2969 );
2970
2971 bProcessed = OS2OnScroll( uMsg == WM_HSCROLL ? wxHORIZONTAL
2972 : wxVERTICAL
2973 ,wCode
2974 ,wPos
2975 ,hWnd
2976 );
2977 }
2978 break;
2979
2980 case WM_CONTROL:
2981 switch(SHORT2FROMMP(wParam))
2982 {
2983 case BN_PAINT:
2984 {
2985 HWND hWnd = ::WinWindowFromID((HWND)GetHwnd(), SHORT1FROMMP(wParam));
2986 wxWindowOS2* pWin = wxFindWinFromHandle(hWnd);
2987
2988 if (!pWin)
2989 {
2990 bProcessed = FALSE;
2991 break;
2992 }
2993 if (pWin->IsKindOf(CLASSINFO(wxBitmapButton)))
2994 {
2995 wxBitmapButton* pBitmapButton = wxDynamicCast(pWin, wxBitmapButton);
2996
2997 pBitmapButton->OS2OnDraw((WXDRAWITEMSTRUCT *)lParam);
2998 }
2999 return 0;
3000 }
3001 break;
3002
3003 case BKN_PAGESELECTEDPENDING:
3004 {
3005 PPAGESELECTNOTIFY pPage = (PPAGESELECTNOTIFY)lParam;
3006
3007 if ((pPage->ulPageIdNew != pPage->ulPageIdCur) &&
3008 (pPage->ulPageIdNew > 0L && pPage->ulPageIdCur > 0L))
3009 {
3010 wxWindowOS2* pWin = wxFindWinFromHandle(pPage->hwndBook);
3011 wxNotebookEvent vEvent( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED
3012 ,(int)SHORT1FROMMP(wParam)
3013 ,(int)pPage->ulPageIdNew
3014 ,(int)pPage->ulPageIdCur
3015 );
3016 if (!pWin)
3017 {
3018 bProcessed = FALSE;
3019 break;
3020 }
3021 if (pWin->IsKindOf(CLASSINFO(wxNotebook)))
3022 {
3023 wxNotebook* pNotebook = wxDynamicCast(pWin, wxNotebook);
3024
3025 vEvent.SetEventObject(pWin);
3026 pNotebook->OnSelChange(vEvent);
3027 bProcessed = TRUE;
3028 }
3029 else
3030 bProcessed = FALSE;
3031 }
3032 else
3033 bProcessed = FALSE;
3034 }
3035 break;
3036
3037 case BN_CLICKED: // Dups as LN_SELECT and CBN_LBSELECT
3038 {
3039 HWND hWnd = ::WinWindowFromID((HWND)GetHwnd(), SHORT1FROMMP(wParam));
3040 wxWindowOS2* pWin = wxFindWinFromHandle(hWnd);
3041
3042 if (!pWin)
3043 {
3044 bProcessed = FALSE;
3045 break;
3046 }
3047 //
3048 // Simulate a WM_COMMAND here, as wxWindows expects all control
3049 // button clicks to generate WM_COMMAND msgs, not WM_CONTROL
3050 //
3051 if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
3052 {
3053 wxRadioBox* pRadioBox = wxDynamicCast(pWin, wxRadioBox);
3054
3055 pRadioBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
3056 ,(WXUINT)SHORT1FROMMP(wParam)
3057 );
3058 }
3059 if (pWin->IsKindOf(CLASSINFO(wxRadioButton)))
3060 {
3061 wxRadioButton* pRadioButton = wxDynamicCast(pWin, wxRadioButton);
3062
3063 pRadioButton->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
3064 ,(WXUINT)SHORT1FROMMP(wParam)
3065 );
3066 }
3067 if (pWin->IsKindOf(CLASSINFO(wxCheckBox)))
3068 {
3069 wxCheckBox* pCheckBox = wxDynamicCast(pWin, wxCheckBox);
3070
3071 pCheckBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
3072 ,(WXUINT)SHORT1FROMMP(wParam)
3073 );
3074 }
3075 if (pWin->IsKindOf(CLASSINFO(wxListBox)))
3076 {
3077 wxListBox* pListBox = wxDynamicCast(pWin, wxListBox);
3078
3079 pListBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
3080 ,(WXUINT)SHORT1FROMMP(wParam)
3081 );
3082 if (pListBox->GetWindowStyle() & wxLB_OWNERDRAW)
3083 Refresh();
3084 }
3085 if (pWin->IsKindOf(CLASSINFO(wxComboBox)))
3086 {
3087 wxComboBox* pComboBox = wxDynamicCast(pWin, wxComboBox);
3088
3089 pComboBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
3090 ,(WXUINT)SHORT1FROMMP(wParam)
3091 );
3092 }
3093 return 0;
3094 }
3095 break;
3096
3097 case LN_ENTER: /* dups as CBN_EFCHANGE */
3098 {
3099 HWND hWnd = HWNDFROMMP(lParam);
3100 wxWindowOS2* pWin = wxFindWinFromHandle(hWnd);
3101
3102 if (!pWin)
3103 {
3104 bProcessed = FALSE;
3105 break;
3106 }
3107 //
3108 // Simulate a WM_COMMAND here, as wxWindows expects all control
3109 // button clicks to generate WM_COMMAND msgs, not WM_CONTROL
3110 //
3111 if (pWin->IsKindOf(CLASSINFO(wxListBox)))
3112 {
3113 wxListBox* pListBox = wxDynamicCast(pWin, wxListBox);
3114
3115 pListBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
3116 ,(WXUINT)SHORT1FROMMP(wParam)
3117 );
3118 if (pListBox->GetWindowStyle() & wxLB_OWNERDRAW)
3119 Refresh();
3120
3121 }
3122 if (pWin->IsKindOf(CLASSINFO(wxComboBox)))
3123 {
3124 wxComboBox* pComboBox = wxDynamicCast(pWin, wxComboBox);
3125
3126 pComboBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
3127 ,(WXUINT)SHORT1FROMMP(wParam)
3128 );
3129 }
3130 return 0;
3131 }
3132 break;
3133
3134 case SPBN_UPARROW:
3135 case SPBN_DOWNARROW:
3136 case SPBN_CHANGE:
3137 {
3138 char zVal[10];
3139 long lVal;
3140
3141 ::WinSendMsg( HWNDFROMMP(lParam)
3142 ,SPBM_QUERYVALUE
3143 ,&zVal
3144 ,MPFROM2SHORT( (USHORT)10
3145 ,(USHORT)SPBQ_UPDATEIFVALID
3146 )
3147 );
3148 lVal = atol(zVal);
3149 bProcessed = OS2OnScroll( wxVERTICAL
3150 ,(int)SHORT2FROMMP(wParam)
3151 ,(int)lVal
3152 ,HWNDFROMMP(lParam)
3153 );
3154 }
3155 break;
3156
3157 case SLN_SLIDERTRACK:
3158 {
3159 HWND hWnd = ::WinWindowFromID(GetHWND(), SHORT1FROMMP(wParam));
3160 wxWindowOS2* pChild = wxFindWinFromHandle(hWnd);
3161
3162 if (!pChild)
3163 {
3164 bProcessed = FALSE;
3165 break;
3166 }
3167 if (pChild->IsKindOf(CLASSINFO(wxSlider)))
3168 bProcessed = OS2OnScroll( wxVERTICAL
3169 ,(int)SHORT2FROMMP(wParam)
3170 ,(int)LONGFROMMP(lParam)
3171 ,hWnd
3172 );
3173 }
3174 break;
3175 }
3176 break;
3177
3178 #if defined(__VISAGECPP__) && (__IBMCPP__ >= 400)
3179 case WM_CTLCOLORCHANGE:
3180 {
3181 bProcessed = HandleCtlColor(&hBrush);
3182 }
3183 break;
3184 #endif
3185 case WM_ERASEBACKGROUND:
3186 //
3187 // Returning TRUE to requestw PM to paint the window background
3188 // in SYSCLR_WINDOW. We don't really want that
3189 //
3190 bProcessed = HandleEraseBkgnd((WXHDC)(HPS)wParam);
3191 mResult = (MRESULT)(FALSE);
3192 break;
3193
3194 // the return value for this message is ignored
3195 case WM_SYSCOLORCHANGE:
3196 bProcessed = HandleSysColorChange();
3197 break;
3198
3199 case WM_REALIZEPALETTE:
3200 bProcessed = HandlePaletteChanged();
3201 break;
3202
3203 // move all drag and drops to wxDrg
3204 case WM_ENDDRAG:
3205 bProcessed = HandleEndDrag(wParam);
3206 break;
3207
3208 case WM_INITDLG:
3209 bProcessed = HandleInitDialog((WXHWND)(HWND)wParam);
3210
3211 if ( bProcessed )
3212 {
3213 // we never set focus from here
3214 mResult = (MRESULT)FALSE;
3215 }
3216 break;
3217
3218 // wxFrame specific message
3219 case WM_MINMAXFRAME:
3220 bProcessed = HandleGetMinMaxInfo((PSWP)wParam);
3221 break;
3222
3223 case WM_SYSVALUECHANGED:
3224 // TODO: do something
3225 mResult = (MRESULT)TRUE;
3226 break;
3227
3228 //
3229 // Comparable to WM_SETPOINTER for windows, only for just controls
3230 //
3231 case WM_CONTROLPOINTER:
3232 bProcessed = HandleSetCursor( SHORT1FROMMP(wParam) // Control ID
3233 ,(HWND)lParam // Cursor Handle
3234 );
3235 if (bProcessed )
3236 {
3237 //
3238 // Returning TRUE stops the DefWindowProc() from further
3239 // processing this message - exactly what we need because we've
3240 // just set the cursor.
3241 //
3242 mResult = (MRESULT)TRUE;
3243 }
3244 break;
3245 }
3246 if (!bProcessed)
3247 {
3248 #ifdef __WXDEBUG__
3249 wxLogTrace(wxTraceMessages, wxT("Forwarding %s to DefWindowProc."),
3250 wxGetMessageName(uMsg));
3251 #endif // __WXDEBUG__
3252 if (IsKindOf(CLASSINFO(wxFrame)))
3253 mResult = ::WinDefWindowProc(m_hWnd, uMsg, wParam, lParam);
3254 else if (IsKindOf(CLASSINFO(wxDialog)))
3255 mResult = ::WinDefDlgProc( m_hWnd, uMsg, wParam, lParam);
3256 else
3257 mResult = OS2DefWindowProc(uMsg, wParam, lParam);
3258 }
3259 return mResult;
3260 } // end of wxWindowOS2::OS2WindowProc
3261
3262 #ifndef __EMX__
3263 // clashes with wxDlgProc in toplevel.cpp?
3264 //
3265 // Dialog window proc
3266 //
3267 MRESULT wxDlgProc(
3268 HWND WXUNUSED(hWnd)
3269 , UINT uMsg
3270 , MPARAM WXUNUSED(wParam)
3271 , MPARAM WXUNUSED(lParam))
3272 {
3273 if (uMsg == WM_INITDLG)
3274 {
3275 //
3276 // For this message, returning TRUE tells system to set focus to the
3277 // first control in the dialog box
3278 //
3279 return (MRESULT)TRUE;
3280 }
3281 else
3282 {
3283 //
3284 // For all the other ones, FALSE means that we didn't process the
3285 // message
3286 //
3287 return (MRESULT)0;
3288 }
3289 } // end of wxDlgProc
3290 #endif
3291
3292 wxWindow* wxFindWinFromHandle(
3293 WXHWND hWnd
3294 )
3295 {
3296 wxNode* pNode = wxWinHandleList->Find((long)hWnd);
3297
3298 if (!pNode)
3299 return NULL;
3300 return (wxWindow *)pNode->Data();
3301 } // end of wxFindWinFromHandle
3302
3303 void wxAssociateWinWithHandle(
3304 HWND hWnd
3305 , wxWindowOS2* pWin
3306 )
3307 {
3308 //
3309 // Adding NULL hWnd is (first) surely a result of an error and
3310 // (secondly) breaks menu command processing
3311 //
3312 wxCHECK_RET( hWnd != (HWND)NULL,
3313 wxT("attempt to add a NULL hWnd to window list ignored") );
3314
3315
3316 wxWindow* pOldWin = wxFindWinFromHandle((WXHWND) hWnd);
3317
3318 if (pOldWin && (pOldWin != pWin))
3319 {
3320 wxString str(pWin->GetClassInfo()->GetClassName());
3321 wxLogError( "Bug! Found existing HWND %X for new window of class %s"
3322 ,(int)hWnd
3323 ,(const char*)str
3324 );
3325 }
3326 else if (!pOldWin)
3327 {
3328 wxWinHandleList->Append( (long)hWnd
3329 ,pWin
3330 );
3331 }
3332 } // end of wxAssociateWinWithHandle
3333
3334 void wxRemoveHandleAssociation(
3335 wxWindowOS2* pWin
3336 )
3337 {
3338 wxWinHandleList->DeleteObject(pWin);
3339 } // end of wxRemoveHandleAssociation
3340
3341 //
3342 // Default destroyer - override if you destroy it in some other way
3343 // (e.g. with MDI child windows)
3344 //
3345 void wxWindowOS2::OS2DestroyWindow()
3346 {
3347 }
3348
3349 bool wxWindowOS2::OS2GetCreateWindowCoords(
3350 const wxPoint& rPos
3351 , const wxSize& rSize
3352 , int& rnX
3353 , int& rnY
3354 , int& rnWidth
3355 , int& rnHeight
3356 ) const
3357 {
3358 bool bNonDefault = FALSE;
3359 static const int DEFAULT_Y = 200;
3360 static const int DEFAULT_H = 250;
3361
3362 if (rPos.x == -1)
3363 {
3364 rnX = rnY = CW_USEDEFAULT;
3365 }
3366 else
3367 {
3368 rnX = rPos.x;
3369 rnY = rPos.y == -1 ? DEFAULT_Y : rPos.y;
3370 bNonDefault = TRUE;
3371 }
3372 if (rSize.x == -1)
3373 {
3374 rnWidth = rnHeight = CW_USEDEFAULT;
3375 }
3376 else
3377 {
3378 rnWidth = rSize.x;
3379 rnHeight = rSize.y == -1 ? DEFAULT_H : rSize.y;
3380 bNonDefault = TRUE;
3381 }
3382 return bNonDefault;
3383 } // end of wxWindowOS2::OS2GetCreateWindowCoords
3384
3385 WXHWND wxWindowOS2::OS2GetParent() const
3386 {
3387 return m_parent ? m_parent->GetHWND() : NULL;
3388 }
3389
3390 bool wxWindowOS2::OS2Create(
3391 PSZ zClass
3392 , const char* zTitle
3393 , WXDWORD dwStyle
3394 , const wxPoint& rPos
3395 , const wxSize& rSize
3396 , void* pCtlData
3397 , WXDWORD dwExStyle
3398 , bool bIsChild
3399 )
3400 {
3401 ERRORID vError;
3402 wxString sError;
3403 int nX = 0L;
3404 int nY = 0L;
3405 int nWidth = 0L;
3406 int nHeight = 0L;
3407 wxWindow* pParent = GetParent();
3408 HWND hWnd = NULLHANDLE;
3409 HWND hParent;
3410 long lControlId = 0L;
3411 wxWindowCreationHook vHook(this);
3412 wxString sClassName((wxChar*)zClass);
3413
3414 OS2GetCreateWindowCoords( rPos
3415 ,rSize
3416 ,nX
3417 ,nY
3418 ,nWidth
3419 ,nHeight
3420 );
3421
3422 if (bIsChild)
3423 {
3424 lControlId = GetId();
3425 if (GetWindowStyleFlag() & wxCLIP_SIBLINGS)
3426 {
3427 dwStyle |= WS_CLIPSIBLINGS;
3428 }
3429 }
3430 //
3431 // For each class "Foo" we have we also have "FooNR" ("no repaint") class
3432 // which is the same but without CS_[HV]REDRAW class styles so using it
3433 // ensures that the window is not fully repainted on each resize
3434 //
3435 if (GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE)
3436 {
3437 sClassName += wxT("NR");
3438 }
3439 m_hWnd = (WXHWND)::WinCreateWindow( (HWND)OS2GetParent()
3440 ,(PSZ)sClassName.c_str()
3441 ,(PSZ)zTitle ? zTitle : ""
3442 ,(ULONG)dwStyle
3443 ,(LONG)0L
3444 ,(LONG)0L
3445 ,(LONG)0L
3446 ,(LONG)0L
3447 ,NULLHANDLE
3448 ,HWND_TOP
3449 ,(ULONG)lControlId
3450 ,pCtlData
3451 ,NULL
3452 );
3453 if (!m_hWnd)
3454 {
3455 vError = ::WinGetLastError(wxGetInstance());
3456 sError = wxPMErrorToStr(vError);
3457 return FALSE;
3458 }
3459 SubclassWin(m_hWnd);
3460 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
3461
3462 m_backgroundColour.Set(wxString("GREY"));
3463
3464 LONG lColor = (LONG)m_backgroundColour.GetPixel();
3465
3466 if (!::WinSetPresParam( m_hWnd
3467 ,PP_BACKGROUNDCOLOR
3468 ,sizeof(LONG)
3469 ,(PVOID)&lColor
3470 ))
3471 {
3472 vError = ::WinGetLastError(vHabmain);
3473 sError = wxPMErrorToStr(vError);
3474 wxLogError("Error creating frame. Error: %s\n", sError);
3475 return FALSE;
3476 }
3477 SetSize( nX
3478 ,nY
3479 ,nWidth
3480 ,nHeight
3481 );
3482 return TRUE;
3483 } // end of WinGuiBase_Window::OS2Create
3484
3485 // ===========================================================================
3486 // OS2 PM message handlers
3487 // ===========================================================================
3488
3489 // ---------------------------------------------------------------------------
3490 // window creation/destruction
3491 // ---------------------------------------------------------------------------
3492
3493 bool wxWindowOS2::HandleCreate(
3494 WXLPCREATESTRUCT WXUNUSED(vCs)
3495 , bool* pbMayCreate
3496 )
3497 {
3498 wxWindowCreateEvent vEvent((wxWindow*)this);
3499
3500 (void)GetEventHandler()->ProcessEvent(vEvent);
3501 *pbMayCreate = TRUE;
3502 return TRUE;
3503 } // end of wxWindowOS2::HandleCreate
3504
3505 bool wxWindowOS2::HandleDestroy()
3506 {
3507 wxWindowDestroyEvent vEvent((wxWindow*)this);
3508
3509 (void)GetEventHandler()->ProcessEvent(vEvent);
3510
3511 //
3512 // Delete our drop target if we've got one
3513 //
3514 #if wxUSE_DRAG_AND_DROP
3515 if (m_dropTarget != NULL)
3516 {
3517 m_dropTarget->Revoke(m_hWnd);
3518 delete m_dropTarget;
3519 m_dropTarget = NULL;
3520 }
3521 #endif // wxUSE_DRAG_AND_DROP
3522
3523 //
3524 // WM_DESTROY handled
3525 //
3526 return TRUE;
3527 } // end of wxWindowOS2::HandleDestroy
3528
3529 // ---------------------------------------------------------------------------
3530 // activation/focus
3531 // ---------------------------------------------------------------------------
3532 void wxWindowOS2::OnSetFocus(
3533 wxFocusEvent& rEvent
3534 )
3535 {
3536 rEvent.Skip();
3537 } // end of wxWindowOS2::OnSetFocus
3538
3539 bool wxWindowOS2::HandleActivate(
3540 int nState
3541 , WXHWND WXUNUSED(hActivate)
3542 )
3543 {
3544 wxActivateEvent vEvent( wxEVT_ACTIVATE
3545 ,(bool)nState
3546 ,m_windowId
3547 );
3548 vEvent.SetEventObject(this);
3549 return GetEventHandler()->ProcessEvent(vEvent);
3550 } // end of wxWindowOS2::HandleActivate
3551
3552 bool wxWindowOS2::HandleSetFocus(
3553 WXHWND WXUNUSED(hWnd)
3554 )
3555 {
3556 //
3557 // Notify the parent keeping track of focus for the kbd navigation
3558 // purposes that we got it
3559 //
3560 wxChildFocusEvent vEventFocus((wxWindow *)this);
3561 (void)GetEventHandler()->ProcessEvent(vEventFocus);
3562
3563 #if wxUSE_CARET
3564 //
3565 // Deal with caret
3566 //
3567 if (m_caret)
3568 {
3569 m_caret->OnSetFocus();
3570 }
3571 #endif // wxUSE_CARET
3572
3573 #if wxUSE_TEXTCTRL
3574 // If it's a wxTextCtrl don't send the event as it will be done
3575 // after the control gets to process it from EN_FOCUS handler
3576 if ( wxDynamicCastThis(wxTextCtrl) )
3577 {
3578 return FALSE;
3579 }
3580 #endif // wxUSE_TEXTCTRL
3581
3582 wxFocusEvent vEvent(wxEVT_SET_FOCUS, m_windowId);
3583
3584 vEvent.SetEventObject(this);
3585 return GetEventHandler()->ProcessEvent(vEvent);
3586 } // end of wxWindowOS2::HandleSetFocus
3587
3588 bool wxWindowOS2::HandleKillFocus(
3589 WXHWND hWnd
3590 )
3591 {
3592 #if wxUSE_CARET
3593 //
3594 // Deal with caret
3595 //
3596 if (m_caret)
3597 {
3598 m_caret->OnKillFocus();
3599 }
3600 #endif // wxUSE_CARET
3601
3602 #if wxUSE_TEXTCTRL
3603 //
3604 // If it's a wxTextCtrl don't send the event as it will be done
3605 // after the control gets to process it.
3606 //
3607 wxTextCtrl* pCtrl = wxDynamicCastThis(wxTextCtrl);
3608
3609 if (pCtrl)
3610 {
3611 return FALSE;
3612 }
3613 #endif
3614
3615 //
3616 // Don't send the event when in the process of being deleted. This can
3617 // only cause problems if the event handler tries to access the object.
3618 //
3619 if ( m_isBeingDeleted )
3620 {
3621 return FALSE;
3622 }
3623
3624 wxFocusEvent vEvent( wxEVT_KILL_FOCUS
3625 ,m_windowId
3626 );
3627
3628 vEvent.SetEventObject(this);
3629
3630 //
3631 // wxFindWinFromHandle() may return NULL, it is ok
3632 //
3633 vEvent.SetWindow(wxFindWinFromHandle(hWnd));
3634 return GetEventHandler()->ProcessEvent(vEvent);
3635 } // end of wxWindowOS2::HandleKillFocus
3636
3637 // ---------------------------------------------------------------------------
3638 // miscellaneous
3639 // ---------------------------------------------------------------------------
3640
3641 bool wxWindowOS2::HandleShow(
3642 bool bShow
3643 , int WXUNUSED(nStatus)
3644 )
3645 {
3646 wxShowEvent vEvent(GetId(), bShow);
3647
3648 vEvent.m_eventObject = this;
3649 return GetEventHandler()->ProcessEvent(vEvent);
3650 } // end of wxWindowOS2::HandleShow
3651
3652 bool wxWindowOS2::HandleInitDialog(
3653 WXHWND WXUNUSED(hWndFocus)
3654 )
3655 {
3656 wxInitDialogEvent vEvent(GetId());
3657
3658 vEvent.m_eventObject = this;
3659 return GetEventHandler()->ProcessEvent(vEvent);
3660 } // end of wxWindowOS2::HandleInitDialog
3661
3662 bool wxWindowOS2::HandleEndDrag(WXWPARAM WXUNUSED(wParam))
3663 {
3664 // TODO: We'll handle drag and drop later
3665 return FALSE;
3666 }
3667
3668 bool wxWindowOS2::HandleSetCursor(
3669 USHORT WXUNUSED(vId)
3670 , WXHWND hPointer
3671 )
3672 {
3673 //
3674 // Under OS/2 PM this allows the pointer to be changed
3675 // as it passes over a control
3676 //
3677 ::WinSetPointer(HWND_DESKTOP, (HPOINTER)hPointer);
3678 return TRUE;
3679 } // end of wxWindowOS2::HandleSetCursor
3680
3681 // ---------------------------------------------------------------------------
3682 // owner drawn stuff
3683 // ---------------------------------------------------------------------------
3684 bool wxWindowOS2::OS2OnDrawItem(
3685 int vId
3686 , WXDRAWITEMSTRUCT* pItemStruct
3687 )
3688 {
3689 #if wxUSE_OWNER_DRAWN
3690 wxDC vDc;
3691
3692 #if wxUSE_MENUS_NATIVE
3693 //
3694 // Is it a menu item?
3695 //
3696 if (vId == 0)
3697 {
3698 ERRORID vError;
3699 wxString sError;
3700 POWNERITEM pMeasureStruct = (POWNERITEM)pItemStruct;
3701 wxFrame* pFrame = (wxFrame*)this;
3702 wxMenuItem* pMenuItem = pFrame->GetMenuBar()->FindItem(pMeasureStruct->idItem, pMeasureStruct->hItem);
3703 HDC hDC = ::GpiQueryDevice(pMeasureStruct->hps);
3704 wxRect vRect( pMeasureStruct->rclItem.xLeft
3705 ,pMeasureStruct->rclItem.yBottom
3706 ,pMeasureStruct->rclItem.xRight - pMeasureStruct->rclItem.xLeft
3707 ,pMeasureStruct->rclItem.yTop - pMeasureStruct->rclItem.yBottom
3708 );
3709 vDc.SetHDC( hDC
3710 ,FALSE
3711 );
3712 vDc.SetHPS(pMeasureStruct->hps);
3713 //
3714 // Load the wxWindows Pallete and set to RGB mode
3715 //
3716 if (!::GpiCreateLogColorTable( pMeasureStruct->hps
3717 ,0L
3718 ,LCOLF_CONSECRGB
3719 ,0L
3720 ,(LONG)wxTheColourDatabase->m_nSize
3721 ,(PLONG)wxTheColourDatabase->m_palTable
3722 ))
3723 {
3724 vError = ::WinGetLastError(vHabmain);
3725 sError = wxPMErrorToStr(vError);
3726 wxLogError("Unable to set current color table. Error: %s\n", sError);
3727 }
3728 //
3729 // Set the color table to RGB mode
3730 //
3731 if (!::GpiCreateLogColorTable( pMeasureStruct->hps
3732 ,0L
3733 ,LCOLF_RGB
3734 ,0L
3735 ,0L
3736 ,NULL
3737 ))
3738 {
3739 vError = ::WinGetLastError(vHabmain);
3740 sError = wxPMErrorToStr(vError);
3741 wxLogError("Unable to set current color table. Error: %s\n", sError);
3742 }
3743
3744 wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
3745
3746
3747 int eAction = 0;
3748 int eStatus = 0;
3749
3750 if (pMeasureStruct->fsAttribute == pMeasureStruct->fsAttributeOld)
3751 {
3752 //
3753 // Entire Item needs to be redrawn (either it has reappeared from
3754 // behind another window or is being displayed for the first time
3755 //
3756 eAction = wxOwnerDrawn::wxODDrawAll;
3757
3758 if (pMeasureStruct->fsAttribute & MIA_HILITED)
3759 {
3760 //
3761 // If it is currently selected we let the system handle it
3762 //
3763 eStatus |= wxOwnerDrawn::wxODSelected;
3764 }
3765 if (pMeasureStruct->fsAttribute & MIA_CHECKED)
3766 {
3767 //
3768 // If it is currently checked we draw our own
3769 //
3770 eStatus |= wxOwnerDrawn::wxODChecked;
3771 pMeasureStruct->fsAttributeOld = pMeasureStruct->fsAttribute &= ~MIA_CHECKED;
3772 }
3773 if (pMeasureStruct->fsAttribute & MIA_DISABLED)
3774 {
3775 //
3776 // If it is currently disabled we let the system handle it
3777 //
3778 eStatus |= wxOwnerDrawn::wxODDisabled;
3779 }
3780 //
3781 // Don't really care about framed (indicationg focus) or NoDismiss
3782 //
3783 }
3784 else
3785 {
3786 if (pMeasureStruct->fsAttribute & MIA_HILITED)
3787 {
3788 eAction = wxOwnerDrawn::wxODDrawAll;
3789 eStatus |= wxOwnerDrawn::wxODSelected;
3790 //
3791 // Keep the system from trying to highlight with its bogus colors
3792 //
3793 pMeasureStruct->fsAttributeOld = pMeasureStruct->fsAttribute &= ~MIA_HILITED;
3794 }
3795 else if (!(pMeasureStruct->fsAttribute & MIA_HILITED))
3796 {
3797 eAction = wxOwnerDrawn::wxODDrawAll;
3798 eStatus = 0;
3799 //
3800 // Keep the system from trying to highlight with its bogus colors
3801 //
3802 pMeasureStruct->fsAttribute = pMeasureStruct->fsAttributeOld &= ~MIA_HILITED;
3803 }
3804 else
3805 {
3806 //
3807 // For now we don't care about anything else
3808 // just ignore the entire message!
3809 //
3810 return TRUE;
3811 }
3812 }
3813 //
3814 // Now redraw the item
3815 //
3816 return(pMenuItem->OnDrawItem( vDc
3817 ,vRect
3818 ,(wxOwnerDrawn::wxODAction)eAction
3819 ,(wxOwnerDrawn::wxODStatus)eStatus
3820 ));
3821 //
3822 // leave the fsAttribute and fsOldAttribute unchanged. If different,
3823 // the system will do the highlight or fraeming or disabling for us,
3824 // otherwise, we'd have to do it ourselves.
3825 //
3826 }
3827 #endif // wxUSE_MENUS_NATIVE
3828
3829 wxWindow* pItem = FindItem(vId);
3830
3831 if (pItem && pItem->IsKindOf(CLASSINFO(wxControl)))
3832 {
3833 return ((wxControl *)pItem)->OS2OnDraw(pItemStruct);
3834 }
3835 #else
3836 vId = vId;
3837 pItemStruct = pItemStruct;
3838 #endif
3839 return FALSE;
3840 } // end of wxWindowOS2::OS2OnDrawItem
3841
3842 long wxWindowOS2::OS2OnMeasureItem(
3843 int lId
3844 , WXMEASUREITEMSTRUCT* pItemStruct
3845 )
3846 {
3847 #if wxUSE_OWNER_DRAWN
3848 //
3849 // Is it a menu item?
3850 //
3851 if (lId == 65536) // I really don't like this...has to be a better indicator
3852 {
3853 if (IsKindOf(CLASSINFO(wxFrame))) // we'll assume if Frame then a menu
3854 {
3855 size_t nWidth;
3856 size_t nHeight;
3857 POWNERITEM pMeasureStruct = (POWNERITEM)pItemStruct;
3858 wxFrame* pFrame = (wxFrame*)this;
3859 wxMenuItem* pMenuItem = pFrame->GetMenuBar()->FindItem(pMeasureStruct->idItem, pMeasureStruct->hItem);
3860
3861 wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
3862 nWidth = 0L;
3863 nHeight = 0L;
3864 if (pMenuItem->OnMeasureItem( &nWidth
3865 ,&nHeight
3866 ))
3867 {
3868 MRESULT mRc;
3869
3870 pMeasureStruct->rclItem.xRight = nWidth;
3871 pMeasureStruct->rclItem.xLeft = 0L;
3872 pMeasureStruct->rclItem.yTop = nHeight;
3873 pMeasureStruct->rclItem.yBottom = 0L;
3874 mRc = MRFROM2SHORT(nHeight, nWidth);
3875 return LONGFROMMR(mRc);
3876 }
3877 return 0L;
3878 }
3879 }
3880 wxWindow* pItem = FindItem(lId);
3881
3882 if (pItem && pItem->IsKindOf(CLASSINFO(wxControl)))
3883 {
3884 OWNERITEM vItem;
3885
3886 vItem.idItem = (LONG)pItemStruct;
3887 return ((wxControl *)pItem)->OS2OnMeasure((WXMEASUREITEMSTRUCT*)&vItem);
3888 }
3889 #else
3890 lId = lId;
3891 pItemStruct = pItemStruct;
3892 #endif // wxUSE_OWNER_DRAWN
3893 return FALSE;
3894 }
3895
3896 // ---------------------------------------------------------------------------
3897 // colours and palettes
3898 // ---------------------------------------------------------------------------
3899
3900 bool wxWindowOS2::HandleSysColorChange()
3901 {
3902 wxSysColourChangedEvent vEvent;
3903
3904 vEvent.SetEventObject(this);
3905 return GetEventHandler()->ProcessEvent(vEvent);
3906 } // end of wxWindowOS2::HandleSysColorChange
3907
3908 bool wxWindowOS2::HandleCtlColor(
3909 WXHBRUSH* WXUNUSED(phBrush)
3910 )
3911 {
3912 //
3913 // Not much provided with message. So not sure I can do anything with it
3914 //
3915 return TRUE;
3916 } // end of wxWindowOS2::HandleCtlColor
3917
3918
3919 // Define for each class of dialog and control
3920 WXHBRUSH wxWindowOS2::OnCtlColor(WXHDC WXUNUSED(hDC),
3921 WXHWND WXUNUSED(hWnd),
3922 WXUINT WXUNUSED(nCtlColor),
3923 WXUINT WXUNUSED(message),
3924 WXWPARAM WXUNUSED(wParam),
3925 WXLPARAM WXUNUSED(lParam))
3926 {
3927 return (WXHBRUSH)0;
3928 }
3929
3930 bool wxWindowOS2::HandlePaletteChanged()
3931 {
3932 // need to set this to something first
3933 WXHWND hWndPalChange = NULLHANDLE;
3934
3935 wxPaletteChangedEvent vEvent(GetId());
3936
3937 vEvent.SetEventObject(this);
3938 vEvent.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
3939
3940 return GetEventHandler()->ProcessEvent(vEvent);
3941 } // end of wxWindowOS2::HandlePaletteChanged
3942
3943 //
3944 // Responds to colour changes: passes event on to children.
3945 //
3946 void wxWindowOS2::OnSysColourChanged(
3947 wxSysColourChangedEvent& rEvent
3948 )
3949 {
3950 wxNode* pNode = GetChildren().First();
3951
3952 while (pNode)
3953 {
3954 //
3955 // Only propagate to non-top-level windows
3956 //
3957 wxWindow* pWin = (wxWindow *)pNode->Data();
3958
3959 if (pWin->GetParent())
3960 {
3961 wxSysColourChangedEvent vEvent;
3962
3963 rEvent.m_eventObject = pWin;
3964 pWin->GetEventHandler()->ProcessEvent(vEvent);
3965 }
3966 pNode = pNode->Next();
3967 }
3968 } // end of wxWindowOS2::OnSysColourChanged
3969
3970 // ---------------------------------------------------------------------------
3971 // painting
3972 // ---------------------------------------------------------------------------
3973
3974 bool wxWindowOS2::HandlePaint()
3975 {
3976 HRGN hRgn;
3977 wxPaintEvent vEvent(m_windowId);
3978 HPS hPS;
3979 RECTL vRect;
3980 bool bProcessed;
3981
3982 // Create empty region
3983 // TODO: get HPS somewhere else if possible
3984 hPS = ::WinGetPS(GetHwnd());
3985 hRgn = ::GpiCreateRegion(hPS, 0, NULL);
3986
3987 if (::WinQueryUpdateRegion(GetHwnd(), hRgn) == RGN_ERROR)
3988 {
3989 wxLogLastError("CreateRectRgn");
3990 return FALSE;
3991 }
3992
3993 m_updateRegion = wxRegion(hRgn, hPS);
3994
3995 vEvent.SetEventObject(this);
3996 bProcessed = GetEventHandler()->ProcessEvent(vEvent);
3997
3998 if (!bProcessed &&
3999 IsKindOf(CLASSINFO(wxPanel)) &&
4000 GetChildren().GetCount() == 0
4001 )
4002 {
4003 //
4004 // OS/2 needs to process this right here, not by the default proc
4005 // Window's default proc correctly paints everything, OS/2 does not.
4006 // For decorative panels that typically have no children, we draw
4007 // borders.
4008 //
4009 HPS hPS;
4010 RECTL vRect;
4011 wxFrame* pFrame;
4012 wxWindow* pParent;
4013
4014 hPS = ::WinBeginPaint( GetHwnd()
4015 ,NULLHANDLE
4016 ,&vRect
4017 );
4018 if(hPS)
4019 {
4020 ::GpiCreateLogColorTable( hPS
4021 ,0L
4022 ,LCOLF_CONSECRGB
4023 ,0L
4024 ,(LONG)wxTheColourDatabase->m_nSize
4025 ,(PLONG)wxTheColourDatabase->m_palTable
4026 );
4027 ::GpiCreateLogColorTable( hPS
4028 ,0L
4029 ,LCOLF_RGB
4030 ,0L
4031 ,0L
4032 ,NULL
4033 );
4034 if (::WinIsWindowVisible(GetHWND()))
4035 ::WinFillRect(hPS, &vRect, GetBackgroundColour().GetPixel());
4036 if (m_dwExStyle)
4037 {
4038 LINEBUNDLE vLineBundle;
4039
4040 vLineBundle.lColor = 0x00000000; // Black
4041 vLineBundle.usMixMode = FM_OVERPAINT;
4042 vLineBundle.fxWidth = 1;
4043 vLineBundle.lGeomWidth = 1;
4044 vLineBundle.usType = LINETYPE_SOLID;
4045 vLineBundle.usEnd = 0;
4046 vLineBundle.usJoin = 0;
4047 ::GpiSetAttrs( hPS
4048 ,PRIM_LINE
4049 ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE
4050 ,0L
4051 ,&vLineBundle
4052 );
4053 ::WinQueryWindowRect(GetHwnd(), &vRect);
4054 wxDrawBorder( hPS
4055 ,vRect
4056 ,m_dwExStyle
4057 );
4058 }
4059 }
4060 ::WinEndPaint(hPS);
4061 bProcessed = TRUE;
4062 }
4063 else if (!bProcessed &&
4064 IsKindOf(CLASSINFO(wxPanel))
4065 )
4066 {
4067 //
4068 // Panel with children, usually fills a frame client so no borders.
4069 //
4070 HPS hPS;
4071 RECTL vRect;
4072 wxFrame* pFrame;
4073 wxWindow* pParent;
4074
4075 hPS = ::WinBeginPaint( GetHwnd()
4076 ,NULLHANDLE
4077 ,&vRect
4078 );
4079 if(hPS)
4080 {
4081 ::GpiCreateLogColorTable( hPS
4082 ,0L
4083 ,LCOLF_CONSECRGB
4084 ,0L
4085 ,(LONG)wxTheColourDatabase->m_nSize
4086 ,(PLONG)wxTheColourDatabase->m_palTable
4087 );
4088 ::GpiCreateLogColorTable( hPS
4089 ,0L
4090 ,LCOLF_RGB
4091 ,0L
4092 ,0L
4093 ,NULL
4094 );
4095
4096 if (::WinIsWindowVisible(GetHWND()))
4097 ::WinFillRect(hPS, &vRect, GetBackgroundColour().GetPixel());
4098 }
4099 ::WinEndPaint(hPS);
4100 bProcessed = TRUE;
4101 }
4102 return bProcessed;
4103 } // end of wxWindowOS2::HandlePaint
4104
4105 bool wxWindowOS2::HandleEraseBkgnd(
4106 WXHDC hDC
4107 )
4108 {
4109 SWP vSwp;
4110 bool rc;
4111
4112 ::WinQueryWindowPos(GetHwnd(), &vSwp);
4113 if (vSwp.fl & SWP_MINIMIZE)
4114 return TRUE;
4115
4116 wxDC vDC;
4117
4118 vDC.m_hPS = (HPS)hDC; // this is really a PS
4119 vDC.SetWindow((wxWindow*)this);
4120 vDC.BeginDrawing();
4121
4122 wxEraseEvent vEvent(m_windowId, &vDC);
4123
4124 vEvent.SetEventObject(this);
4125
4126 rc = GetEventHandler()->ProcessEvent(vEvent);
4127
4128 vDC.EndDrawing();
4129 vDC.m_hPS = NULLHANDLE;
4130 return TRUE;
4131 } // end of wxWindowOS2::HandleEraseBkgnd
4132
4133 void wxWindowOS2::OnEraseBackground(
4134 wxEraseEvent& rEvent
4135 )
4136 {
4137 RECTL vRect;
4138 HPS hPS = rEvent.m_dc->m_hPS;
4139 APIRET rc;
4140 LONG lColor = m_backgroundColour.GetPixel();
4141
4142 rc = ::WinQueryWindowRect(GetHwnd(), &vRect);
4143 rc = ::WinFillRect(hPS, &vRect, lColor);
4144 } // end of wxWindowOS2::OnEraseBackground
4145
4146 // ---------------------------------------------------------------------------
4147 // moving and resizing
4148 // ---------------------------------------------------------------------------
4149
4150 bool wxWindowOS2::HandleMinimize()
4151 {
4152 wxIconizeEvent vEvent(m_windowId);
4153
4154 vEvent.SetEventObject(this);
4155 return GetEventHandler()->ProcessEvent(vEvent);
4156 } // end of wxWindowOS2::HandleMinimize
4157
4158 bool wxWindowOS2::HandleMaximize()
4159 {
4160 wxMaximizeEvent vEvent(m_windowId);
4161
4162 vEvent.SetEventObject(this);
4163 return GetEventHandler()->ProcessEvent(vEvent);
4164 } // end of wxWindowOS2::HandleMaximize
4165
4166 bool wxWindowOS2::HandleMove(
4167 int nX
4168 , int nY
4169 )
4170 {
4171 wxMoveEvent vEvent(wxPoint(nX, nY), m_windowId);
4172
4173 vEvent.SetEventObject(this);
4174 return GetEventHandler()->ProcessEvent(vEvent);
4175 } // end of wxWindowOS2::HandleMove
4176
4177 bool wxWindowOS2::HandleSize(
4178 int nWidth
4179 , int nHeight
4180 , WXUINT WXUNUSED(nFlag)
4181 )
4182 {
4183 wxSizeEvent vEvent(wxSize(nWidth, nHeight), m_windowId);
4184
4185 vEvent.SetEventObject(this);
4186 return GetEventHandler()->ProcessEvent(vEvent);
4187 } // end of wxWindowOS2::HandleSize
4188
4189 bool wxWindowOS2::HandleGetMinMaxInfo(
4190 PSWP pSwp
4191 )
4192 {
4193 bool bRc = FALSE;
4194 POINTL vPoint;
4195
4196 switch(pSwp->fl)
4197 {
4198 case SWP_MAXIMIZE:
4199 ::WinGetMaxPosition(GetHwnd(), pSwp);
4200 m_maxWidth = pSwp->cx;
4201 m_maxHeight = pSwp->cy;
4202 break;
4203
4204 case SWP_MINIMIZE:
4205 ::WinGetMinPosition(GetHwnd(), pSwp, &vPoint);
4206 m_minWidth = pSwp->cx;
4207 m_minHeight = pSwp->cy;
4208 break;
4209
4210 default:
4211 return FALSE;
4212 }
4213 return TRUE;
4214 } // end of wxWindowOS2::HandleGetMinMaxInfo
4215
4216 // ---------------------------------------------------------------------------
4217 // command messages
4218 // ---------------------------------------------------------------------------
4219 bool wxWindowOS2::HandleCommand(
4220 WXWORD wId
4221 , WXWORD wCmd
4222 , WXHWND hControl
4223 )
4224 {
4225 #if wxUSE_MENUS_NATIVE
4226 if (wxCurrentPopupMenu)
4227 {
4228 wxMenu* pPopupMenu = wxCurrentPopupMenu;
4229
4230 wxCurrentPopupMenu = NULL;
4231 return pPopupMenu->OS2Command(wCmd, wId);
4232 }
4233 #endif // wxUSE_MENUS_NATIVE
4234
4235 wxWindow* pWin = FindItem(wId);
4236
4237 if (!pWin)
4238 {
4239 pWin = wxFindWinFromHandle(hControl);
4240 }
4241
4242 if (pWin)
4243 return pWin->OS2Command(wCmd, wId);
4244
4245 return FALSE;
4246 } // end of wxWindowOS2::HandleCommand
4247
4248 bool wxWindowOS2::HandleSysCommand(
4249 WXWPARAM wParam
4250 , WXLPARAM WXUNUSED(lParam)
4251 )
4252 {
4253 //
4254 // 4 bits are reserved
4255 //
4256 switch (SHORT1FROMMP(wParam))
4257 {
4258 case SC_MAXIMIZE:
4259 return HandleMaximize();
4260
4261 case SC_MINIMIZE:
4262 return HandleMinimize();
4263 }
4264 return FALSE;
4265 } // end of wxWindowOS2::HandleSysCommand
4266
4267 // ---------------------------------------------------------------------------
4268 // mouse events
4269 // ---------------------------------------------------------------------------
4270 //TODO!!! check against MSW
4271 void wxWindowOS2::InitMouseEvent(
4272 wxMouseEvent& rEvent
4273 , int nX
4274 , int nY
4275 , WXUINT uFlags
4276 )
4277 {
4278 rEvent.m_x = nX;
4279 rEvent.m_y = nY;
4280 rEvent.m_shiftDown = ((uFlags & VK_SHIFT) != 0);
4281 rEvent.m_controlDown = ((uFlags & VK_CTRL) != 0);
4282 rEvent.m_leftDown = ((uFlags & VK_BUTTON1) != 0);
4283 rEvent.m_middleDown = ((uFlags & VK_BUTTON3) != 0);
4284 rEvent.m_rightDown = ((uFlags & VK_BUTTON2) != 0);
4285 rEvent.SetTimestamp(s_currentMsg.time);
4286 rEvent.m_eventObject = this;
4287 rEvent.SetId(GetId());
4288
4289 #if wxUSE_MOUSEEVENT_HACK
4290 m_lastMouseX = nX;
4291 m_lastMouseY = nY;
4292 m_lastMouseEvent = rEvent.GetEventType();
4293 #endif // wxUSE_MOUSEEVENT_HACK
4294 } // end of wxWindowOS2::InitMouseEvent
4295
4296 bool wxWindowOS2::HandleMouseEvent(
4297 WXUINT uMsg
4298 , int nX
4299 , int nY
4300 , WXUINT uFlags
4301 )
4302 {
4303 bool bProcessed = FALSE;
4304
4305 //
4306 // The mouse events take consecutive IDs from WM_MOUSEFIRST to
4307 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4308 // from the message id and take the value in the table to get wxWin event
4309 // id
4310 //
4311 static const wxEventType eventsMouse[] =
4312 {
4313 wxEVT_MOTION,
4314 wxEVT_LEFT_DOWN,
4315 wxEVT_LEFT_UP,
4316 wxEVT_LEFT_DCLICK,
4317 wxEVT_RIGHT_DOWN,
4318 wxEVT_RIGHT_UP,
4319 wxEVT_RIGHT_DCLICK,
4320 wxEVT_MIDDLE_DOWN,
4321 wxEVT_MIDDLE_UP,
4322 wxEVT_MIDDLE_DCLICK
4323 };
4324
4325 wxMouseEvent vEvent(eventsMouse[uMsg - WM_MOUSEMOVE]);
4326
4327 InitMouseEvent( vEvent
4328 ,nX
4329 ,nY
4330 ,uFlags
4331 );
4332
4333 bProcessed = GetEventHandler()->ProcessEvent(vEvent);
4334 if (!bProcessed)
4335 {
4336 HPOINTER hPtr = ::WinQuerySysPointer(HWND_DESKTOP, SPTR_WAIT, FALSE);
4337 HPOINTER hCursor = (HPOINTER)GetCursor().GetHCURSOR();
4338
4339 if (hCursor != NULLHANDLE)
4340 {
4341 ::WinSetPointer(HWND_DESKTOP, hCursor);
4342 bProcessed = TRUE;
4343 }
4344 }
4345 return GetEventHandler()->ProcessEvent(vEvent);
4346 } // end of wxWindowOS2::HandleMouseEvent
4347
4348 bool wxWindowOS2::HandleMouseMove(
4349 int nX
4350 , int nY
4351 , WXUINT uFlags
4352 )
4353 {
4354 if (!m_bMouseInWindow)
4355 {
4356 //
4357 // Generate an ENTER event
4358 //
4359 m_bMouseInWindow = TRUE;
4360
4361 wxMouseEvent vEvent(wxEVT_ENTER_WINDOW);
4362
4363 InitMouseEvent( vEvent
4364 ,nX
4365 ,nY
4366 ,uFlags
4367 );
4368
4369 (void)GetEventHandler()->ProcessEvent(vEvent);
4370 }
4371 return HandleMouseEvent( WM_MOUSEMOVE
4372 ,nX
4373 ,nY
4374 ,uFlags
4375 );
4376 } // end of wxWindowOS2::HandleMouseMove
4377
4378 // ---------------------------------------------------------------------------
4379 // keyboard handling
4380 // ---------------------------------------------------------------------------
4381
4382 //
4383 // Create the key event of the given type for the given key - used by
4384 // HandleChar and HandleKeyDown/Up
4385 //
4386 wxKeyEvent wxWindowOS2::CreateKeyEvent(
4387 wxEventType eType
4388 , int nId
4389 , WXLPARAM lParam
4390 , WXWPARAM wParam
4391 ) const
4392 {
4393 wxKeyEvent vEvent(eType);
4394
4395 vEvent.SetId(GetId());
4396 vEvent.m_shiftDown = IsShiftDown();
4397 vEvent.m_controlDown = IsCtrlDown();
4398 vEvent.m_altDown = (HIWORD(lParam) & KC_ALT) == KC_ALT;
4399
4400 vEvent.m_eventObject = (wxWindow *)this; // const_cast
4401 vEvent.m_keyCode = nId;
4402 vEvent.m_rawCode = (wxUint32)wParam;
4403 vEvent.m_rawFlags = (wxUint32)lParam;
4404 vEvent.SetTimestamp(s_currentMsg.time);
4405
4406 //
4407 // Translate the position to client coords
4408 //
4409 POINTL vPoint;
4410 RECTL vRect;
4411
4412 ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
4413 ::WinQueryWindowRect( GetHwnd()
4414 ,&vRect
4415 );
4416
4417 vPoint.x -= vRect.xLeft;
4418 vPoint.y -= vRect.yBottom;
4419
4420 vEvent.m_x = vPoint.x;
4421 vEvent.m_y = vPoint.y;
4422
4423 return vEvent;
4424 } // end of wxWindowOS2::CreateKeyEvent
4425
4426 //
4427 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4428 // WM_KEYDOWN one
4429 //
4430 bool wxWindowOS2::HandleChar(
4431 WXWPARAM wParam
4432 , WXLPARAM lParam
4433 , bool isASCII
4434 )
4435 {
4436 bool bCtrlDown = FALSE;
4437 int vId;
4438
4439 if (m_bLastKeydownProcessed)
4440 {
4441 //
4442 // The key was handled in the EVT_KEY_DOWN. Handling a key in an
4443 // EVT_KEY_DOWN handler is meant, by design, to prevent EVT_CHARs
4444 // from happening, so just bail out at this point.
4445 //
4446 m_bLastKeydownProcessed = FALSE;
4447 return TRUE;
4448 }
4449 if (isASCII)
4450 {
4451 //
4452 // If 1 -> 26, translate to either special keycode or just set
4453 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4454 // ControlDown() == TRUE.
4455 //
4456 vId = SHORT1FROMMP(lParam);
4457 if ((vId > 0) && (vId < 27))
4458 {
4459 switch (vId)
4460 {
4461 case 13:
4462 vId = WXK_RETURN;
4463 break;
4464
4465 case 8:
4466 vId = WXK_BACK;
4467 break;
4468
4469 case 9:
4470 vId = WXK_TAB;
4471 break;
4472
4473 default:
4474 bCtrlDown = TRUE;
4475 break;
4476 }
4477 }
4478 }
4479 else // we're called from WM_KEYDOWN
4480 {
4481 vId = wxCharCodeOS2ToWX((int)SHORT2FROMMP(lParam));
4482 if (vId == 0)
4483 return FALSE;
4484 }
4485
4486 wxKeyEvent vEvent(CreateKeyEvent( wxEVT_CHAR
4487 ,vId
4488 ,lParam
4489 ));
4490
4491 if (bCtrlDown)
4492 {
4493 vEvent.m_controlDown = TRUE;
4494 }
4495 return (GetEventHandler()->ProcessEvent(vEvent));
4496 }
4497
4498 bool wxWindowOS2::HandleKeyDown(
4499 WXWPARAM wParam
4500 , WXLPARAM lParam
4501 )
4502 {
4503 int nId = wxCharCodeOS2ToWX((int)SHORT2FROMMP(lParam));
4504
4505 if (!nId)
4506 {
4507 //
4508 // Normal ASCII char
4509 //
4510 nId = SHORT1FROMMP(lParam);
4511 }
4512
4513 if (nId != -1)
4514 {
4515 wxKeyEvent vEvent(CreateKeyEvent( wxEVT_KEY_DOWN
4516 ,nId
4517 ,(MPARAM)lParam
4518 ,(MPARAM)wParam
4519 ));
4520
4521 if (GetEventHandler()->ProcessEvent(vEvent))
4522 {
4523 return TRUE;
4524 }
4525 }
4526 return FALSE;
4527 } // end of wxWindowOS2::HandleKeyDown
4528
4529 bool wxWindowOS2::HandleKeyUp(
4530 WXWPARAM wParam
4531 , WXLPARAM lParam
4532 )
4533 {
4534 int nId = wxCharCodeOS2ToWX((int)SHORT2FROMMP(lParam));
4535
4536 if (!nId)
4537 {
4538 //
4539 // Normal ASCII char
4540 //
4541 nId = (int)wParam;
4542 }
4543
4544 if (nId != -1)
4545 {
4546 wxKeyEvent vEvent(CreateKeyEvent( wxEVT_KEY_UP
4547 ,nId
4548 ,lParam
4549 ,wParam
4550 ));
4551
4552 if (GetEventHandler()->ProcessEvent(vEvent))
4553 return TRUE;
4554 }
4555 return FALSE;
4556 } // end of wxWindowOS2::HandleKeyUp
4557
4558 // ---------------------------------------------------------------------------
4559 // joystick
4560 // ---------------------------------------------------------------------------
4561
4562 // ---------------------------------------------------------------------------
4563 // scrolling
4564 // ---------------------------------------------------------------------------
4565
4566 bool wxWindowOS2::OS2OnScroll(
4567 int nOrientation
4568 , WXWORD wParam
4569 , WXWORD wPos
4570 , WXHWND hControl
4571 )
4572 {
4573 if (hControl)
4574 {
4575 wxWindow* pChild = wxFindWinFromHandle(hControl);
4576
4577 if (pChild )
4578 return pChild->OS2OnScroll( nOrientation
4579 ,wParam
4580 ,wPos
4581 ,hControl
4582 );
4583 }
4584
4585 wxScrollWinEvent vEvent;
4586
4587 vEvent.SetPosition(wPos);
4588 vEvent.SetOrientation(nOrientation);
4589 vEvent.m_eventObject = this;
4590
4591 switch (wParam)
4592 {
4593 case SB_LINEUP:
4594 vEvent.m_eventType = wxEVT_SCROLLWIN_LINEUP;
4595 break;
4596
4597 case SB_LINEDOWN:
4598 vEvent.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
4599 break;
4600
4601 case SB_PAGEUP:
4602 vEvent.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
4603 break;
4604
4605 case SB_PAGEDOWN:
4606 vEvent.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
4607 break;
4608
4609 case SB_SLIDERPOSITION:
4610 vEvent.m_eventType = wxEVT_SCROLLWIN_THUMBRELEASE;
4611 break;
4612
4613 case SB_SLIDERTRACK:
4614 vEvent.m_eventType = wxEVT_SCROLLWIN_THUMBTRACK;
4615 break;
4616
4617 default:
4618 return FALSE;
4619 }
4620 return GetEventHandler()->ProcessEvent(vEvent);
4621 } // end of wxWindowOS2::OS2OnScroll
4622
4623 void wxWindowOS2::MoveChildren(
4624 int nDiff
4625 )
4626 {
4627 //
4628 // We want to handle top levels ourself, manually
4629 //
4630 if (!IsTopLevel() && GetAutoLayout())
4631 {
4632 Layout();
4633 }
4634 else
4635 {
4636 SWP vSwp;
4637
4638 for (wxWindowList::Node* pNode = GetChildren().GetFirst();
4639 pNode;
4640 pNode = pNode->GetNext())
4641 {
4642 wxWindow* pWin = pNode->GetData();
4643
4644 ::WinQueryWindowPos( GetHwndOf(pWin)
4645 ,&vSwp
4646 );
4647 if (pWin->IsKindOf(CLASSINFO(wxControl)))
4648 {
4649 wxControl* pCtrl;
4650
4651 //
4652 // Must deal with controls that have margins like ENTRYFIELD. The SWP
4653 // struct of such a control will have and origin offset from its intended
4654 // position by the width of the margins.
4655 //
4656 pCtrl = wxDynamicCast(pWin, wxControl);
4657 vSwp.y -= pCtrl->GetYComp();
4658 vSwp.x -= pCtrl->GetXComp();
4659 }
4660 ::WinSetWindowPos( GetHwndOf(pWin)
4661 ,HWND_TOP
4662 ,vSwp.x
4663 ,vSwp.y - nDiff
4664 ,vSwp.cx
4665 ,vSwp.cy
4666 ,SWP_MOVE | SWP_SHOW | SWP_ZORDER
4667 );
4668 ::WinQueryWindowPos(GetHwndOf(pWin), pWin->GetSwp());
4669 if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
4670 {
4671 wxRadioBox* pRadioBox;
4672
4673 pRadioBox = wxDynamicCast(pWin, wxRadioBox);
4674 pRadioBox->AdjustButtons( (int)vSwp.x
4675 ,(int)vSwp.y - nDiff
4676 ,(int)vSwp.cx
4677 ,(int)vSwp.cy
4678 ,pRadioBox->GetSizeFlags()
4679 );
4680 }
4681 if (pWin->IsKindOf(CLASSINFO(wxSlider)))
4682 {
4683 wxSlider* pSlider;
4684
4685 pSlider = wxDynamicCast(pWin, wxSlider);
4686 pSlider->AdjustSubControls( (int)vSwp.x
4687 ,(int)vSwp.y - nDiff
4688 ,(int)vSwp.cx
4689 ,(int)vSwp.cy
4690 ,(int)pSlider->GetSizeFlags()
4691 );
4692 }
4693 }
4694 }
4695 Refresh();
4696 } // end of wxWindowOS2::MoveChildren
4697
4698 //
4699 // Getting the Y position for a window, like a control, is a real
4700 // pain. There are three sitatuions we must deal with in determining
4701 // the OS2 to wxWindows Y coordinate.
4702 //
4703 // 1) The controls are created in a dialog.
4704 // This is the easiest since a dialog is created with its original
4705 // size so the standard: Y = ParentHeight - (Y + ControlHeight);
4706 //
4707 // 2) The controls are direct children of a frame
4708 // In this instance the controls are actually children of the Frame's
4709 // client. During creation the frame's client resizes several times
4710 // during creation of the status bar and toolbars. The CFrame class
4711 // will take care of this using its AlterChildPos proc.
4712 //
4713 // 3) The controls are children of a panel, which in turn is a child of
4714 // a frame.
4715 // The panel may be one of many, in which case the same treatment
4716 // as 1 applies. It may be the only child, though.
4717 // This is the nastiest case. A panel is created as the only child of
4718 // the frame and as such, when a frame has only one child, the child is
4719 // expanded to fit the entire client area of the frame. Because the
4720 // controls are created BEFORE this occurs their positions are totally
4721 // whacked and any call to WinQueryWindowPos will return invalid
4722 // coordinates. So for this situation we have to compare the size of
4723 // the panel at control creation time with that of the frame client. If
4724 // they are the same we can use the standard Y position equation. If
4725 // not, then we must use the Frame Client's dimensions to position them
4726 // as that will be the eventual size of the panel after the frame resizes
4727 // it!
4728 //
4729 int wxWindowOS2::GetOS2ParentHeight(
4730 wxWindowOS2* pParent
4731 )
4732 {
4733 wxWindowOS2* pGrandParent = NULL;
4734
4735 //
4736 // Case 1
4737 //
4738 if (pParent->IsKindOf(CLASSINFO(wxDialog)))
4739 return(pParent->GetClientSize().y);
4740
4741 //
4742 // Case 2 -- if we are one of the separately built standard Frame
4743 // children, like a statusbar, menubar, or toolbar we want to
4744 // use the frame, itself, for positioning. Otherwise we are
4745 // child window and want to use the Frame's client.
4746 //
4747 else if (pParent->IsKindOf(CLASSINFO(wxFrame)))
4748 {
4749 if (IsKindOf(CLASSINFO(wxStatusBar)) ||
4750 IsKindOf(CLASSINFO(wxMenuBar)) ||
4751 IsKindOf(CLASSINFO(wxToolBar))
4752 )
4753 {
4754 if (IsKindOf(CLASSINFO(wxToolBar)))
4755 {
4756 wxFrame* pFrame = wxDynamicCast(GetParent(), wxFrame);
4757
4758 if (pFrame->GetToolBar() == this)
4759 return(pParent->GetSize().y);
4760 else
4761 return(pParent->GetClientSize().y);
4762 }
4763 else
4764 return(pParent->GetSize().y);
4765 }
4766 else
4767 return(pParent->GetClientSize().y);
4768 }
4769 //
4770 // Case -- this is for any window that is the sole child of a Frame.
4771 // The grandparent must exist and it must be of type CFrame
4772 // and it's height must be different. Otherwise the standard
4773 // applies.
4774 //
4775 else
4776 {
4777 return(pParent->GetClientSize().y);
4778 }
4779 return(0L);
4780 } // end of wxWindowOS2::GetOS2ParentHeight
4781
4782 //
4783 // OS/2 needs a lot extra manipulation to deal with layouts
4784 // for canvas windows, particularly scrolled ones.
4785 //
4786 wxWindowCreationHook::wxWindowCreationHook(
4787 wxWindow* pWinBeingCreated
4788 )
4789 {
4790 gpWinBeingCreated = pWinBeingCreated;
4791 } // end of wxWindowCreationHook::wxWindowCreationHook
4792
4793 wxWindowCreationHook::~wxWindowCreationHook()
4794 {
4795 gpWinBeingCreated = NULL;
4796 } // end of wxWindowCreationHook::~wxWindowCreationHook
4797
4798 // ===========================================================================
4799 // global functions
4800 // ===========================================================================
4801
4802 void wxGetCharSize(
4803 WXHWND hWnd
4804 , int* pX
4805 , int* pY
4806 ,wxFont* WXUNUSED(pTheFont)
4807 )
4808 {
4809 FONTMETRICS vFM;
4810 HPS hPS;
4811 BOOL rc;
4812
4813 hPS =::WinGetPS(hWnd);
4814
4815 rc = ::GpiQueryFontMetrics(hPS, sizeof(FONTMETRICS), &vFM);
4816 if (rc)
4817 {
4818 if (pX)
4819 *pX = vFM.lAveCharWidth;
4820 if (pY)
4821 *pY = vFM.lEmHeight + vFM.lExternalLeading;
4822 }
4823 else
4824 {
4825 if (pX)
4826 *pX = 10;
4827 if (pY)
4828 *pY = 15;
4829 }
4830 ::WinReleasePS(hPS);
4831 } // end of wxGetCharSize
4832
4833 //
4834 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4835 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4836 //
4837 int wxCharCodeOS2ToWX(
4838 int nKeySym
4839 )
4840 {
4841 int nId = 0;
4842
4843 switch (nKeySym)
4844 {
4845 case VK_BACKTAB: nId = WXK_BACK; break;
4846 case VK_TAB: nId = WXK_TAB; break;
4847 case VK_CLEAR: nId = WXK_CLEAR; break;
4848 case VK_ENTER: nId = WXK_RETURN; break;
4849 case VK_SHIFT: nId = WXK_SHIFT; break;
4850 case VK_CTRL: nId = WXK_CONTROL; break;
4851 case VK_PAUSE: nId = WXK_PAUSE; break;
4852 case VK_SPACE: nId = WXK_SPACE; break;
4853 case VK_ESC: nId = WXK_ESCAPE; break;
4854 case VK_END: nId = WXK_END; break;
4855 case VK_HOME : nId = WXK_HOME; break;
4856 case VK_LEFT : nId = WXK_LEFT; break;
4857 case VK_UP: nId = WXK_UP; break;
4858 case VK_RIGHT: nId = WXK_RIGHT; break;
4859 case VK_DOWN : nId = WXK_DOWN; break;
4860 case VK_PRINTSCRN: nId = WXK_PRINT; break;
4861 case VK_INSERT: nId = WXK_INSERT; break;
4862 case VK_DELETE: nId = WXK_DELETE; break;
4863 case VK_CAPSLOCK: nId = WXK_CAPITAL; break;
4864 case VK_F1: nId = WXK_F1; break;
4865 case VK_F2: nId = WXK_F2; break;
4866 case VK_F3: nId = WXK_F3; break;
4867 case VK_F4: nId = WXK_F4; break;
4868 case VK_F5: nId = WXK_F5; break;
4869 case VK_F6: nId = WXK_F6; break;
4870 case VK_F7: nId = WXK_F7; break;
4871 case VK_F8: nId = WXK_F8; break;
4872 case VK_F9: nId = WXK_F9; break;
4873 case VK_F10: nId = WXK_F10; break;
4874 case VK_F11: nId = WXK_F11; break;
4875 case VK_F12: nId = WXK_F12; break;
4876 case VK_F13: nId = WXK_F13; break;
4877 case VK_F14: nId = WXK_F14; break;
4878 case VK_F15: nId = WXK_F15; break;
4879 case VK_F16: nId = WXK_F16; break;
4880 case VK_F17: nId = WXK_F17; break;
4881 case VK_F18: nId = WXK_F18; break;
4882 case VK_F19: nId = WXK_F19; break;
4883 case VK_F20: nId = WXK_F20; break;
4884 case VK_F21: nId = WXK_F21; break;
4885 case VK_F22: nId = WXK_F22; break;
4886 case VK_F23: nId = WXK_F23; break;
4887 case VK_F24: nId = WXK_F24; break;
4888 case VK_OEM_1: nId = ';'; break;
4889 case VK_OEM_PLUS: nId = '+'; break;
4890 case VK_OEM_COMMA: nId = ','; break;
4891 case VK_OEM_MINUS: nId = '-'; break;
4892 case VK_OEM_PERIOD: nId = '.'; break;
4893 case VK_OEM_2: nId = '/'; break;
4894 case VK_OEM_3: nId = '~'; break;
4895 case VK_OEM_4: nId = '['; break;
4896 case VK_OEM_5: nId = '\\'; break;
4897 case VK_OEM_6: nId = ']'; break;
4898 case VK_OEM_7: nId = '\''; break;
4899 case VK_NUMLOCK: nId = WXK_NUMLOCK; break;
4900 case VK_SCRLLOCK: nId = WXK_SCROLL; break;
4901 default:
4902 {
4903 return 0;
4904 }
4905 }
4906 return nId;
4907 } // end of wxCharCodeOS2ToWX
4908
4909 int wxCharCodeWXToOS2(
4910 int nId
4911 , bool* bIsVirtual
4912 )
4913 {
4914 int nKeySym = 0;
4915
4916 *bIsVirtual = TRUE;
4917 switch (nId)
4918 {
4919 case WXK_CLEAR: nKeySym = VK_CLEAR; break;
4920 case WXK_SHIFT: nKeySym = VK_SHIFT; break;
4921 case WXK_CONTROL: nKeySym = VK_CTRL; break;
4922 case WXK_PAUSE: nKeySym = VK_PAUSE; break;
4923 case WXK_END: nKeySym = VK_END; break;
4924 case WXK_HOME : nKeySym = VK_HOME; break;
4925 case WXK_LEFT : nKeySym = VK_LEFT; break;
4926 case WXK_UP: nKeySym = VK_UP; break;
4927 case WXK_RIGHT: nKeySym = VK_RIGHT; break;
4928 case WXK_DOWN : nKeySym = VK_DOWN; break;
4929 case WXK_PRINT: nKeySym = VK_PRINTSCRN; break;
4930 case WXK_INSERT: nKeySym = VK_INSERT; break;
4931 case WXK_DELETE: nKeySym = VK_DELETE; break;
4932 case WXK_F1: nKeySym = VK_F1; break;
4933 case WXK_F2: nKeySym = VK_F2; break;
4934 case WXK_F3: nKeySym = VK_F3; break;
4935 case WXK_F4: nKeySym = VK_F4; break;
4936 case WXK_F5: nKeySym = VK_F5; break;
4937 case WXK_F6: nKeySym = VK_F6; break;
4938 case WXK_F7: nKeySym = VK_F7; break;
4939 case WXK_F8: nKeySym = VK_F8; break;
4940 case WXK_F9: nKeySym = VK_F9; break;
4941 case WXK_F10: nKeySym = VK_F10; break;
4942 case WXK_F11: nKeySym = VK_F11; break;
4943 case WXK_F12: nKeySym = VK_F12; break;
4944 case WXK_F13: nKeySym = VK_F13; break;
4945 case WXK_F14: nKeySym = VK_F14; break;
4946 case WXK_F15: nKeySym = VK_F15; break;
4947 case WXK_F16: nKeySym = VK_F16; break;
4948 case WXK_F17: nKeySym = VK_F17; break;
4949 case WXK_F18: nKeySym = VK_F18; break;
4950 case WXK_F19: nKeySym = VK_F19; break;
4951 case WXK_F20: nKeySym = VK_F20; break;
4952 case WXK_F21: nKeySym = VK_F21; break;
4953 case WXK_F22: nKeySym = VK_F22; break;
4954 case WXK_F23: nKeySym = VK_F23; break;
4955 case WXK_F24: nKeySym = VK_F24; break;
4956 case WXK_NUMLOCK: nKeySym = VK_NUMLOCK; break;
4957 case WXK_SCROLL: nKeySym = VK_SCRLLOCK; break;
4958 default:
4959 {
4960 *bIsVirtual = FALSE;
4961 nKeySym = nId;
4962 break;
4963 }
4964 }
4965 return nKeySym;
4966 } // end of wxCharCodeWXToOS2
4967
4968 wxWindow* wxGetActiveWindow()
4969 {
4970 HWND hWnd = ::WinQueryActiveWindow(HWND_DESKTOP);
4971
4972 if (hWnd != 0)
4973 {
4974 return wxFindWinFromHandle((WXHWND)hWnd);
4975 }
4976 return NULL;
4977 } // end of wxGetActiveWindow
4978
4979 #ifdef __WXDEBUG__
4980 const char* wxGetMessageName(
4981 int nMessage)
4982 {
4983 switch (nMessage)
4984 {
4985 case 0x0000: return "WM_NULL";
4986 case 0x0001: return "WM_CREATE";
4987 case 0x0002: return "WM_DESTROY";
4988 case 0x0004: return "WM_ENABLE";
4989 case 0x0005: return "WM_SHOW";
4990 case 0x0006: return "WM_MOVE";
4991 case 0x0007: return "WM_SIZE";
4992 case 0x0008: return "WM_ADJUSTWINDOWPOS";
4993 case 0x0009: return "WM_CALCVALIDRECTS";
4994 case 0x000A: return "WM_SETWINDOWPARAMS";
4995 case 0x000B: return "WM_QUERYWINDOWPARAMS";
4996 case 0x000C: return "WM_HITTEST";
4997 case 0x000D: return "WM_ACTIVATE";
4998 case 0x000F: return "WM_SETFOCUS";
4999 case 0x0010: return "WM_SETSELECTION";
5000 case 0x0011: return "WM_PPAINT";
5001 case 0x0012: return "WM_PSETFOCUS";
5002 case 0x0013: return "WM_PSYSCOLORCHANGE";
5003 case 0x0014: return "WM_PSIZE";
5004 case 0x0015: return "WM_PACTIVATE";
5005 case 0x0016: return "WM_PCONTROL";
5006 case 0x0020: return "WM_COMMAND";
5007 case 0x0021: return "WM_SYSCOMMAND";
5008 case 0x0022: return "WM_HELP";
5009 case 0x0023: return "WM_PAINT";
5010 case 0x0024: return "WM_TIMER";
5011 case 0x0025: return "WM_SEM1";
5012 case 0x0026: return "WM_SEM2";
5013 case 0x0027: return "WM_SEM3";
5014 case 0x0028: return "WM_SEM4";
5015 case 0x0029: return "WM_CLOSE";
5016 case 0x002A: return "WM_QUIT";
5017 case 0x002B: return "WM_SYSCOLORCHANGE";
5018 case 0x002D: return "WM_SYSVALUECHANGE";
5019 case 0x002E: return "WM_APPTERMINATENOTIFY";
5020 case 0x002F: return "WM_PRESPARAMCHANGED";
5021 // Control notification messages
5022 case 0x0030: return "WM_CONTROL";
5023 case 0x0031: return "WM_VSCROLL";
5024 case 0x0032: return "WM_HSCROLL";
5025 case 0x0033: return "WM_INITMENU";
5026 case 0x0034: return "WM_MENUSELECT";
5027 case 0x0035: return "WM_MENUSEND";
5028 case 0x0036: return "WM_DRAWITEM";
5029 case 0x0037: return "WM_MEASUREITEM";
5030 case 0x0038: return "WM_CONTROLPOINTER";
5031 case 0x003A: return "WM_QUERYDLGCODE";
5032 case 0x003B: return "WM_INITDLG";
5033 case 0x003C: return "WM_SUBSTITUTESTRING";
5034 case 0x003D: return "WM_MATCHMNEMONIC";
5035 case 0x003E: return "WM_SAVEAPPLICATION";
5036 case 0x0129: return "WM_CTLCOLORCHANGE";
5037 case 0x0130: return "WM_QUERYCTLTYPE";
5038 // Frame messages
5039 case 0x0040: return "WM_FLASHWINDOW";
5040 case 0x0041: return "WM_FORMATFRAME";
5041 case 0x0042: return "WM_UPDATEFRAME";
5042 case 0x0043: return "WM_FOCUSCHANGE";
5043 case 0x0044: return "WM_SETBORDERSIZE";
5044 case 0x0045: return "WM_TRACKFRAME";
5045 case 0x0046: return "WM_MINMAXFRAME";
5046 case 0x0047: return "WM_SETICON";
5047 case 0x0048: return "WM_QUERYICON";
5048 case 0x0049: return "WM_SETACCELTABLE";
5049 case 0x004A: return "WM_QUERYACCELTABLE";
5050 case 0x004B: return "WM_TRANSLATEACCEL";
5051 case 0x004C: return "WM_QUERYTRACKINFO";
5052 case 0x004D: return "WM_QUERYBORDERSIZE";
5053 case 0x004E: return "WM_NEXTMENU";
5054 case 0x004F: return "WM_ERASEBACKGROUND";
5055 case 0x0050: return "WM_QUERYFRAMEINFO";
5056 case 0x0051: return "WM_QUERYFOCUSCHAIN";
5057 case 0x0052: return "WM_OWNERPOSCHANGE";
5058 case 0x0053: return "WM_CACLFRAMERECT";
5059 case 0x0055: return "WM_WINDOWPOSCHANGED";
5060 case 0x0056: return "WM_ADJUSTFRAMEPOS";
5061 case 0x0059: return "WM_QUERYFRAMECTLCOUNT";
5062 case 0x005B: return "WM_QUERYHELPINFO";
5063 case 0x005C: return "WM_SETHELPINFO";
5064 case 0x005D: return "WM_ERROR";
5065 case 0x005E: return "WM_REALIZEPALETTE";
5066 // Clipboard messages
5067 case 0x0060: return "WM_RENDERFMT";
5068 case 0x0061: return "WM_RENDERALLFMTS";
5069 case 0x0062: return "WM_DESTROYCLIPBOARD";
5070 case 0x0063: return "WM_PAINTCLIPBOARD";
5071 case 0x0064: return "WM_SIZECLIPBOARD";
5072 case 0x0065: return "WM_HSCROLLCLIPBOARD";
5073 case 0x0066: return "WM_VSCROLLCLIPBOARD";
5074 case 0x0067: return "WM_DRAWCLIPBOARD";
5075 // mouse messages
5076 case 0x0070: return "WM_MOUSEMOVE";
5077 case 0x0071: return "WM_BUTTON1DOWN";
5078 case 0x0072: return "WM_BUTTON1UP";
5079 case 0x0073: return "WM_BUTTON1DBLCLK";
5080 case 0x0074: return "WM_BUTTON2DOWN";
5081 case 0x0075: return "WM_BUTTON2UP";
5082 case 0x0076: return "WM_BUTTON2DBLCLK";
5083 case 0x0077: return "WM_BUTTON3DOWN";
5084 case 0x0078: return "WM_BUTTON3UP";
5085 case 0x0079: return "WM_BUTTON3DBLCLK";
5086 case 0x007D: return "WM_MOUSEMAP";
5087 case 0x007E: return "WM_VRNDISABLED";
5088 case 0x007F: return "WM_VRNENABLED";
5089 case 0x0410: return "WM_CHORD";
5090 case 0x0411: return "WM_BUTTON1MOTIONSTART";
5091 case 0x0412: return "WM_BUTTON1MOTIONEND";
5092 case 0x0413: return "WM_BUTTON1CLICK";
5093 case 0x0414: return "WM_BUTTON2MOTIONSTART";
5094 case 0x0415: return "WM_BUTTON2MOTIONEND";
5095 case 0x0416: return "WM_BUTTON2CLICK";
5096 case 0x0417: return "WM_BUTTON3MOTIONSTART";
5097 case 0x0418: return "WM_BUTTON3MOTIONEND";
5098 case 0x0419: return "WM_BUTTON3CLICK";
5099 case 0x0420: return "WM_BEGINDRAG";
5100 case 0x0421: return "WM_ENDDRAG";
5101 case 0x0422: return "WM_SINGLESELECT";
5102 case 0x0423: return "WM_OPEN";
5103 case 0x0424: return "WM_CONTEXTMENU";
5104 case 0x0425: return "WM_CONTEXTHELP";
5105 case 0x0426: return "WM_TEXTEDIT";
5106 case 0x0427: return "WM_BEGINSELECT";
5107 case 0x0228: return "WM_ENDSELECT";
5108 case 0x0429: return "WM_PICKUP";
5109 case 0x04C0: return "WM_PENFIRST";
5110 case 0x04FF: return "WM_PENLAST";
5111 case 0x0500: return "WM_MMPMFIRST";
5112 case 0x05FF: return "WM_MMPMLAST";
5113 case 0x0600: return "WM_STDDLGFIRST";
5114 case 0x06FF: return "WM_STDDLGLAST";
5115 case 0x0BD0: return "WM_BIDI_FIRST";
5116 case 0x0BFF: return "WM_BIDI_LAST";
5117 // keyboard input
5118 case 0x007A: return "WM_CHAR";
5119 case 0x007B: return "WM_VIOCHAR";
5120 // DDE messages
5121 case 0x00A0: return "WM_DDE_INITIATE";
5122 case 0x00A1: return "WM_DDE_REQUEST";
5123 case 0x00A2: return "WM_DDE_ACK";
5124 case 0x00A3: return "WM_DDE_DATA";
5125 case 0x00A4: return "WM_DDE_ADVISE";
5126 case 0x00A5: return "WM_DDE_UNADVISE";
5127 case 0x00A6: return "WM_DDE_POKE";
5128 case 0x00A7: return "WM_DDE_EXECUTE";
5129 case 0x00A8: return "WM_DDE_TERMINATE";
5130 case 0x00A9: return "WM_DDE_INITIATEACK";
5131 case 0x00AF: return "WM_DDE_LAST";
5132 // Buttons
5133 case 0x0120: return "BM_CLICK";
5134 case 0x0121: return "BM_QUERYCHECKINDEX";
5135 case 0x0122: return "BM_QUERYHILITE";
5136 case 0x0123: return "BM_SETHILITE";
5137 case 0x0124: return "BM_QUERYCHECK";
5138 case 0x0125: return "BM_SETCHECK";
5139 case 0x0126: return "BM_SETDEFAULT";
5140 case 0x0128: return "BM_AUTOSIZE";
5141 // Combo boxes
5142 case 0x029A: return "CBID_LIST";
5143 case 0x029B: return "CBID_EDIT";
5144 case 0x0170: return "CBM_SHOWLIST";
5145 case 0x0171: return "CBM_HILITE";
5146 case 0x0172: return "CBM_ISLISTSHOWING";
5147 // Edit fields
5148 case 0x0140: return "EM_QUERYCHANGED";
5149 case 0x0141: return "EM_QUERYSEL";
5150 case 0x0142: return "EM_SETSEL";
5151 case 0x0143: return "EM_SETTEXTLIMIT";
5152 case 0x0144: return "EM_CUT";
5153 case 0x0145: return "EM_COPY";
5154 case 0x0146: return "EM_CLEAR";
5155 case 0x0147: return "EM_PASTE";
5156 case 0x0148: return "EM_QUERYFIRSTCHAR";
5157 case 0x0149: return "EM_SETFIRSTCHAR";
5158 case 0x014A: return "EM_QUERYREADONLY";
5159 case 0x014B: return "EM_SETREADONLY";
5160 case 0x014C: return "EM_SETINSERTMODE";
5161 // Listboxes
5162 case 0x0160: return "LM_QUERYITEMCOUNT";
5163 case 0x0161: return "LM_INSERTITEM";
5164 case 0x0162: return "LM_SETOPENINDEX";
5165 case 0x0163: return "LM_DELETEITEM";
5166 case 0x0164: return "LM_SELECTITEM";
5167 case 0x0165: return "LM_QUERYSELECTION";
5168 case 0x0166: return "LM_SETITEMTEXT";
5169 case 0x0167: return "LM_QUERYITEMTEXTLENGTH";
5170 case 0x0168: return "LM_QUERYITEMTEXT";
5171 case 0x0169: return "LM_SETITEMHANDLE";
5172 case 0x016A: return "LM_QUERYITEMHANDLE";
5173 case 0x016B: return "LM_SEARCHSTRING";
5174 case 0x016C: return "LM_SETITEMHEIGHT";
5175 case 0x016D: return "LM_QUERYTOPINDEX";
5176 case 0x016E: return "LM_DELETEALL";
5177 case 0x016F: return "LM_INSERTMULITEMS";
5178 case 0x0660: return "LM_SETITEMWIDTH";
5179 // Menus
5180 case 0x0180: return "MM_INSERTITEM";
5181 case 0x0181: return "MM_DELETEITEM";
5182 case 0x0182: return "MM_QUERYITEM";
5183 case 0x0183: return "MM_SETITEM";
5184 case 0x0184: return "MM_QUERYITEMCOUNT";
5185 case 0x0185: return "MM_STARTMENUMODE";
5186 case 0x0186: return "MM_ENDMENUMODE";
5187 case 0x0188: return "MM_REMOVEITEM";
5188 case 0x0189: return "MM_SELECTITEM";
5189 case 0x018A: return "MM_QUERYSELITEMID";
5190 case 0x018B: return "MM_QUERYITEMTEXT";
5191 case 0x018C: return "MM_QUERYITEMTEXTLENGTH";
5192 case 0x018D: return "MM_SETITEMHANDLE";
5193 case 0x018E: return "MM_SETITEMTEXT";
5194 case 0x018F: return "MM_ITEMPOSITIONFROMID";
5195 case 0x0190: return "MM_ITEMIDFROMPOSITION";
5196 case 0x0191: return "MM_QUERYITEMATTR";
5197 case 0x0192: return "MM_SETITEMATTR";
5198 case 0x0193: return "MM_ISITEMVALID";
5199 case 0x0194: return "MM_QUERYITEMRECT";
5200 case 0x0431: return "MM_QUERYDEFAULTITEMID";
5201 case 0x0432: return "MM_SETDEFAULTITEMID";
5202 // Scrollbars
5203 case 0x01A0: return "SBM_SETSCROLLBAR";
5204 case 0x01A1: return "SBM_SETPOS";
5205 case 0x01A2: return "SBM_QUERYPOS";
5206 case 0x01A3: return "SBM_QUERYRANGE";
5207 case 0x01A6: return "SBM_SETTHUMBSIZE";
5208
5209 // Help messages
5210 case 0x0F00: return "WM_HELPBASE";
5211 case 0x0FFF: return "WM_HELPTOP";
5212 // Beginning of user defined messages
5213 case 0x1000: return "WM_USER";
5214
5215 // wxWindows user defined types
5216
5217 // listview
5218 // case 0x1000 + 0: return "LVM_GETBKCOLOR";
5219 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5220 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5221 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5222 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5223 case 0x1000 + 5: return "LVM_GETITEMA";
5224 case 0x1000 + 75: return "LVM_GETITEMW";
5225 case 0x1000 + 6: return "LVM_SETITEMA";
5226 case 0x1000 + 76: return "LVM_SETITEMW";
5227 case 0x1000 + 7: return "LVM_INSERTITEMA";
5228 case 0x1000 + 77: return "LVM_INSERTITEMW";
5229 case 0x1000 + 8: return "LVM_DELETEITEM";
5230 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5231 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5232 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5233 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5234 case 0x1000 + 13: return "LVM_FINDITEMA";
5235 case 0x1000 + 83: return "LVM_FINDITEMW";
5236 case 0x1000 + 14: return "LVM_GETITEMRECT";
5237 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5238 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5239 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5240 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5241 case 0x1000 + 18: return "LVM_HITTEST";
5242 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5243 case 0x1000 + 20: return "LVM_SCROLL";
5244 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5245 case 0x1000 + 22: return "LVM_ARRANGE";
5246 case 0x1000 + 23: return "LVM_EDITLABELA";
5247 case 0x1000 + 118: return "LVM_EDITLABELW";
5248 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5249 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5250 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5251 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5252 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5253 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5254 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5255 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5256 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5257 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5258 case 0x1000 + 31: return "LVM_GETHEADER";
5259 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5260 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5261 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5262 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5263 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5264 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5265 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5266 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5267 case 0x1000 + 41: return "LVM_GETORIGIN";
5268 case 0x1000 + 42: return "LVM_UPDATE";
5269 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5270 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5271 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5272 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5273 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5274 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5275 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5276 case 0x1000 + 48: return "LVM_SORTITEMS";
5277 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5278 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5279 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5280 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5281 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5282 case 0x1000 + 53: return "LVM_SETICONSPACING";
5283 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5284 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5285 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5286 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5287 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5288 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5289 case 0x1000 + 60: return "LVM_SETHOTITEM";
5290 case 0x1000 + 61: return "LVM_GETHOTITEM";
5291 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5292 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5293 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5294 case 0x1000 + 65: return "LVM_SETWORKAREA";
5295
5296 // tree view
5297 case 0x1100 + 0: return "TVM_INSERTITEMA";
5298 case 0x1100 + 50: return "TVM_INSERTITEMW";
5299 case 0x1100 + 1: return "TVM_DELETEITEM";
5300 case 0x1100 + 2: return "TVM_EXPAND";
5301 case 0x1100 + 4: return "TVM_GETITEMRECT";
5302 case 0x1100 + 5: return "TVM_GETCOUNT";
5303 case 0x1100 + 6: return "TVM_GETINDENT";
5304 case 0x1100 + 7: return "TVM_SETINDENT";
5305 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5306 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5307 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5308 case 0x1100 + 11: return "TVM_SELECTITEM";
5309 case 0x1100 + 12: return "TVM_GETITEMA";
5310 case 0x1100 + 62: return "TVM_GETITEMW";
5311 case 0x1100 + 13: return "TVM_SETITEMA";
5312 case 0x1100 + 63: return "TVM_SETITEMW";
5313 case 0x1100 + 14: return "TVM_EDITLABELA";
5314 case 0x1100 + 65: return "TVM_EDITLABELW";
5315 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5316 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5317 case 0x1100 + 17: return "TVM_HITTEST";
5318 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5319 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5320 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5321 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5322 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5323 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5324 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5325 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5326 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5327
5328 // header
5329 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5330 case 0x1200 + 1: return "HDM_INSERTITEMA";
5331 case 0x1200 + 10: return "HDM_INSERTITEMW";
5332 case 0x1200 + 2: return "HDM_DELETEITEM";
5333 case 0x1200 + 3: return "HDM_GETITEMA";
5334 case 0x1200 + 11: return "HDM_GETITEMW";
5335 case 0x1200 + 4: return "HDM_SETITEMA";
5336 case 0x1200 + 12: return "HDM_SETITEMW";
5337 case 0x1200 + 5: return "HDM_LAYOUT";
5338 case 0x1200 + 6: return "HDM_HITTEST";
5339 case 0x1200 + 7: return "HDM_GETITEMRECT";
5340 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5341 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5342 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5343 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5344 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5345 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5346 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5347
5348 // tab control
5349 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5350 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5351 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5352 case 0x1300 + 5: return "TCM_GETITEMA";
5353 case 0x1300 + 60: return "TCM_GETITEMW";
5354 case 0x1300 + 6: return "TCM_SETITEMA";
5355 case 0x1300 + 61: return "TCM_SETITEMW";
5356 case 0x1300 + 7: return "TCM_INSERTITEMA";
5357 case 0x1300 + 62: return "TCM_INSERTITEMW";
5358 case 0x1300 + 8: return "TCM_DELETEITEM";
5359 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5360 case 0x1300 + 10: return "TCM_GETITEMRECT";
5361 case 0x1300 + 11: return "TCM_GETCURSEL";
5362 case 0x1300 + 12: return "TCM_SETCURSEL";
5363 case 0x1300 + 13: return "TCM_HITTEST";
5364 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5365 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5366 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5367 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5368 case 0x1300 + 43: return "TCM_SETPADDING";
5369 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5370 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5371 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5372 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5373 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5374 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5375 case 0x1300 + 50: return "TCM_DESELECTALL";
5376
5377 // toolbar
5378 case WM_USER+1000+1: return "TB_ENABLEBUTTON";
5379 case WM_USER+1000+2: return "TB_CHECKBUTTON";
5380 case WM_USER+1000+3: return "TB_PRESSBUTTON";
5381 case WM_USER+1000+4: return "TB_HIDEBUTTON";
5382 case WM_USER+1000+5: return "TB_INDETERMINATE";
5383 case WM_USER+1000+9: return "TB_ISBUTTONENABLED";
5384 case WM_USER+1000+10: return "TB_ISBUTTONCHECKED";
5385 case WM_USER+1000+11: return "TB_ISBUTTONPRESSED";
5386 case WM_USER+1000+12: return "TB_ISBUTTONHIDDEN";
5387 case WM_USER+1000+13: return "TB_ISBUTTONINDETERMINATE";
5388 case WM_USER+1000+17: return "TB_SETSTATE";
5389 case WM_USER+1000+18: return "TB_GETSTATE";
5390 case WM_USER+1000+19: return "TB_ADDBITMAP";
5391 case WM_USER+1000+20: return "TB_ADDBUTTONS";
5392 case WM_USER+1000+21: return "TB_INSERTBUTTON";
5393 case WM_USER+1000+22: return "TB_DELETEBUTTON";
5394 case WM_USER+1000+23: return "TB_GETBUTTON";
5395 case WM_USER+1000+24: return "TB_BUTTONCOUNT";
5396 case WM_USER+1000+25: return "TB_COMMANDTOINDEX";
5397 case WM_USER+1000+26: return "TB_SAVERESTOREA";
5398 case WM_USER+1000+76: return "TB_SAVERESTOREW";
5399 case WM_USER+1000+27: return "TB_CUSTOMIZE";
5400 case WM_USER+1000+28: return "TB_ADDSTRINGA";
5401 case WM_USER+1000+77: return "TB_ADDSTRINGW";
5402 case WM_USER+1000+29: return "TB_GETITEMRECT";
5403 case WM_USER+1000+30: return "TB_BUTTONSTRUCTSIZE";
5404 case WM_USER+1000+31: return "TB_SETBUTTONSIZE";
5405 case WM_USER+1000+32: return "TB_SETBITMAPSIZE";
5406 case WM_USER+1000+33: return "TB_AUTOSIZE";
5407 case WM_USER+1000+35: return "TB_GETTOOLTIPS";
5408 case WM_USER+1000+36: return "TB_SETTOOLTIPS";
5409 case WM_USER+1000+37: return "TB_SETPARENT";
5410 case WM_USER+1000+39: return "TB_SETROWS";
5411 case WM_USER+1000+40: return "TB_GETROWS";
5412 case WM_USER+1000+42: return "TB_SETCMDID";
5413 case WM_USER+1000+43: return "TB_CHANGEBITMAP";
5414 case WM_USER+1000+44: return "TB_GETBITMAP";
5415 case WM_USER+1000+45: return "TB_GETBUTTONTEXTA";
5416 case WM_USER+1000+75: return "TB_GETBUTTONTEXTW";
5417 case WM_USER+1000+46: return "TB_REPLACEBITMAP";
5418 case WM_USER+1000+47: return "TB_SETINDENT";
5419 case WM_USER+1000+48: return "TB_SETIMAGELIST";
5420 case WM_USER+1000+49: return "TB_GETIMAGELIST";
5421 case WM_USER+1000+50: return "TB_LOADIMAGES";
5422 case WM_USER+1000+51: return "TB_GETRECT";
5423 case WM_USER+1000+52: return "TB_SETHOTIMAGELIST";
5424 case WM_USER+1000+53: return "TB_GETHOTIMAGELIST";
5425 case WM_USER+1000+54: return "TB_SETDISABLEDIMAGELIST";
5426 case WM_USER+1000+55: return "TB_GETDISABLEDIMAGELIST";
5427 case WM_USER+1000+56: return "TB_SETSTYLE";
5428 case WM_USER+1000+57: return "TB_GETSTYLE";
5429 case WM_USER+1000+58: return "TB_GETBUTTONSIZE";
5430 case WM_USER+1000+59: return "TB_SETBUTTONWIDTH";
5431 case WM_USER+1000+60: return "TB_SETMAXTEXTROWS";
5432 case WM_USER+1000+61: return "TB_GETTEXTROWS";
5433 case WM_USER+1000+41: return "TB_GETBITMAPFLAGS";
5434
5435 default:
5436 static char s_szBuf[128];
5437 sprintf(s_szBuf, "<unknown message = %d>", nMessage);
5438 return s_szBuf;
5439 }
5440 return NULL;
5441 } // end of wxGetMessageName
5442
5443 #endif // __WXDEBUG__
5444
5445 // Unused?
5446 #if 0
5447 static void TranslateKbdEventToMouse(
5448 wxWindow* pWin
5449 , int* pX
5450 , int* pY
5451 , ULONG* pFlags
5452 )
5453 {
5454 //
5455 // Construct the key mask
5456 ULONG& fwKeys = *pFlags;
5457
5458 fwKeys = VK_BUTTON2;
5459 if ((::WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x100) != 0)
5460 fwKeys |= VK_CTRL;
5461 if ((::WinGetKeyState(HWND_DESKTOP, VK_SHIFT) & 0x100) != 0)
5462 fwKeys |= VK_SHIFT;
5463
5464 //
5465 // Simulate right mouse button click
5466 //
5467 POINTL vPoint;
5468
5469 ::WinQueryMsgPos(vHabmain, &vPoint);
5470 *pX = vPoint.x;
5471 *pY = vPoint.y;
5472
5473 pWin->ScreenToClient(pX, pY);
5474 } // end of TranslateKbdEventToMouse
5475 #endif
5476
5477 // Find the wxWindow at the current mouse position, returning the mouse
5478 // position.
5479 wxWindow* wxFindWindowAtPointer(
5480 wxPoint& WXUNUSED(rPt)
5481 )
5482 {
5483 return wxFindWindowAtPoint(wxGetMousePosition());
5484 }
5485
5486 wxWindow* wxFindWindowAtPoint(
5487 const wxPoint& rPt
5488 )
5489 {
5490 POINTL vPt2;
5491
5492 vPt2.x = rPt.x;
5493 vPt2.y = rPt.y;
5494
5495 HWND hWndHit = ::WinWindowFromPoint(HWND_DESKTOP, &vPt2, FALSE);
5496 wxWindow* pWin = wxFindWinFromHandle((WXHWND)hWndHit) ;
5497 HWND hWnd = hWndHit;
5498
5499 //
5500 // Try to find a window with a wxWindow associated with it
5501 //
5502 while (!pWin && (hWnd != 0))
5503 {
5504 hWnd = ::WinQueryWindow(hWnd, QW_PARENT);
5505 pWin = wxFindWinFromHandle((WXHWND)hWnd) ;
5506 }
5507 return pWin;
5508 }
5509
5510 // Get the current mouse position.
5511 wxPoint wxGetMousePosition()
5512 {
5513 POINTL vPt;
5514
5515 ::WinQueryPointerPos(HWND_DESKTOP, &vPt);
5516 return wxPoint(vPt.x, vPt.y);
5517 }
5518
5519 wxWindowOS2* FindWindowForMouseEvent(
5520 wxWindow* pWin
5521 , short* pnX
5522 , short* pnY
5523 )
5524 {
5525 HWND hWnd = GetHwndOf(pWin);
5526 HWND hWndUnderMouse;
5527 POINTL vPoint;
5528 BOOL rcEnabled = FALSE;
5529 BOOL rcVisible = FALSE;
5530 HWND hWndDesktop = HWND_DESKTOP;
5531
5532 ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
5533 hWndUnderMouse = ::WinWindowFromPoint(HWND_DESKTOP, &vPoint, TRUE);
5534 if (hWndUnderMouse != HWND_DESKTOP)
5535 {
5536 wxWindow* pWinUnderMouse = wxFindWinFromHandle((WXHWND)hWndUnderMouse);
5537
5538 if (pWinUnderMouse)
5539 {
5540 wxWindowList::Node* pCurrent = pWinUnderMouse->GetChildren().GetFirst();
5541 wxWindow* pChild = NULL;
5542 wxWindow* pGrandChild = NULL;
5543 RECTL vRect;
5544 POINTL vPoint2;
5545
5546 ::WinMapWindowPoints(HWND_DESKTOP, hWndUnderMouse, &vPoint, 1);
5547 //
5548 // Find a child window mouse might be under
5549 //
5550 while (pCurrent)
5551 {
5552 wxWindow* pChild = pCurrent->GetData();
5553
5554 vPoint2.x = vPoint.x;
5555 vPoint2.y = vPoint.y;
5556 ::WinMapWindowPoints(hWndUnderMouse, pChild->GetHWND(), &vPoint2, 1);
5557 ::WinQueryWindowRect(pChild->GetHWND(), &vRect);
5558 if (::WinPtInRect(vHabmain, &vRect, &vPoint2))
5559 {
5560 if (pChild->IsTopLevel())
5561 {
5562 POINTL vPoint3;
5563 wxWindowList::Node* pCurrent2 =pChild->GetChildren().GetFirst();
5564
5565 while (pCurrent2)
5566 {
5567 wxWindow* pGrandChild = pCurrent2->GetData();
5568
5569 vPoint3.x = vPoint2.x;
5570 vPoint3.y = vPoint2.y;
5571 ::WinMapWindowPoints( pChild->GetHWND()
5572 ,pGrandChild->GetHWND()
5573 ,&vPoint3
5574 ,1
5575 );
5576 ::WinQueryWindowRect(pGrandChild->GetHWND(), &vRect);
5577 if (::WinPtInRect(vHabmain, &vRect, &vPoint3))
5578 {
5579 hWndUnderMouse = GetHwndOf(pGrandChild);
5580 pWinUnderMouse = pGrandChild;
5581 break;
5582 }
5583 pCurrent2 = pCurrent2->GetNext();
5584 }
5585 if (pGrandChild)
5586 break;
5587 }
5588 hWndUnderMouse = GetHwndOf(pChild);
5589 pWinUnderMouse = pChild;
5590 rcVisible = ::WinIsWindowVisible(hWndUnderMouse);
5591 rcEnabled = ::WinIsWindowEnabled(hWndUnderMouse);
5592 if (rcVisible && rcEnabled)
5593 break;
5594 }
5595 pCurrent = pCurrent->GetNext();
5596 }
5597 }
5598 }
5599 rcVisible = ::WinIsWindowVisible(hWndUnderMouse);
5600 rcEnabled = ::WinIsWindowEnabled(hWndUnderMouse);
5601
5602
5603 //
5604 // Check that we have a child window which is susceptible to receive mouse
5605 // events: for this it must be shown and enabled
5606 //
5607 if ( hWndUnderMouse &&
5608 hWndUnderMouse != hWnd &&
5609 rcVisible && rcEnabled)
5610 {
5611 wxWindow* pWinUnderMouse = wxFindWinFromHandle((WXHWND)hWndUnderMouse);
5612
5613 if (pWinUnderMouse)
5614 {
5615 //
5616 // Translate the mouse coords to the other window coords
5617 //
5618 pWin = pWinUnderMouse;
5619 }
5620 }
5621 return pWin;
5622 } // end of FindWindowForMouseEvent
5623
wxWidgets (Impactor)