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