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