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