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