X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/45e0dc94770d598a1cc84d83730d470dd1cfbcca..f4bd67593eae8df6e9a9eb0b7e1374833dbc2a70:/src/os2/window.cpp diff --git a/src/os2/window.cpp b/src/os2/window.cpp index 935143f040..42c6c75783 100644 --- a/src/os2/window.cpp +++ b/src/os2/window.cpp @@ -1,4 +1,3 @@ -///////////////////////////////////////////////////////////////////////////// // Name: windows.cpp // Purpose: wxWindow // Author: David Webster @@ -93,6 +92,20 @@ # define CW_USEDEFAULT ((int)0x80000000) #endif +#ifndef VK_OEM_1 + #define VK_OEM_1 0xBA + #define VK_OEM_PLUS 0xBB + #define VK_OEM_COMMA 0xBC + #define VK_OEM_MINUS 0xBD + #define VK_OEM_PERIOD 0xBE + #define VK_OEM_2 0xBF + #define VK_OEM_3 0xC0 + #define VK_OEM_4 0xDB + #define VK_OEM_5 0xDC + #define VK_OEM_6 0xDD + #define VK_OEM_7 0xDE +#endif + // --------------------------------------------------------------------------- // global variables // --------------------------------------------------------------------------- @@ -125,24 +138,16 @@ MRESULT EXPENTRY wxWndProc( HWND hWnd const char *wxGetMessageName(int message); #endif //__WXDEBUG__ -void wxRemoveHandleAssociation(wxWindowOS2* pWin); -void wxAssociateWinWithHandle( HWND hWnd - ,wxWindowOS2* pWin - ); +wxWindowOS2* FindWindowForMouseEvent( wxWindow* pWin + ,short* pnX + ,short* pnY + ); +void wxRemoveHandleAssociation(wxWindowOS2* pWin); +void wxAssociateWinWithHandle( HWND hWnd + ,wxWindowOS2* pWin + ); wxWindow* wxFindWinFromHandle(WXHWND hWnd); -// -// This magical function is used to translate VK_APPS key presses to right -// mouse clicks -// -// Unused? -#if 0 -static void TranslateKbdEventToMouse( wxWindow* pWin - ,int* pX - ,int* pY - ,MPARAM* pFlags - ); -#endif // // get the current state of SHIFT/CTRL keys // @@ -291,10 +296,11 @@ void wxWindowOS2::Init() m_bDoubleClickAllowed = 0; m_bWinCaptured = FALSE; - m_isBeingDeleted = FALSE; - m_fnOldWndProc = 0; - m_bUseCtl3D = FALSE; - m_bMouseInWindow = FALSE; + m_isBeingDeleted = FALSE; + m_fnOldWndProc = 0; + m_bUseCtl3D = FALSE; + m_bMouseInWindow = FALSE; + m_bLastKeydownProcessed = FALSE; // // wxWnd @@ -304,8 +310,11 @@ void wxWindowOS2::Init() m_hWndScrollBarHorz = 0L; m_hWndScrollBarVert = 0L; + memset(&m_vWinSwp, '\0', sizeof (SWP)); + // // Pass WM_GETDLGCODE to DefWindowProc() + // m_lDlgCode = 0; m_nXThumbSize = 0; @@ -374,6 +383,19 @@ bool wxWindowOS2::Create( wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent")); +#if wxUSE_STATBOX + // + // wxGTK doesn't allow to create controls with static box as the parent so + // this will result in a crash when the program is ported to wxGTK - warn + // about it + // + // the correct solution is to create the controls as siblings of the + // static box + // + wxASSERT_MSG( !wxDynamicCast(pParent, wxStaticBox), + _T("wxStaticBox can't be used as a window parent!") ); +#endif // wxUSE_STATBOX + if ( !CreateBase( pParent ,vId ,rPos @@ -402,39 +424,16 @@ bool wxWindowOS2::Create( // set in those class create procs. PM's basic windows styles are // very limited. // - ulCreateFlags |= WS_VISIBLE; + ulCreateFlags |= WS_VISIBLE | OS2GetCreateWindowFlags(&dwExStyle); #ifdef __WXUNIVERSAL__ // no 3d effects, we draw them ourselves WXDWORD exStyle = 0; -#else // !wxUniversal - if (lStyle & wxCLIP_SIBLINGS) - ulCreateFlags |= WS_CLIPSIBLINGS; - - if (lStyle & wxCLIP_CHILDREN ) - ulCreateFlags |= WS_CLIPCHILDREN; - - // - // - // - bool bWant3D; - dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D); - -#endif - - // - // Add the simple border style as we'll use this to draw borders - // - if (lStyle & wxSIMPLE_BORDER) - dwExStyle |= wxSIMPLE_BORDER; - +#endif // !wxUniversal if (lStyle & wxPOPUP_WINDOW) { // a popup window floats on top of everything -//TODO: fix this... -// exStyle |= WS_EX_TOPMOST | WS_EX_TOOLWINDOW; - // it is also created hidden as other top level windows ulCreateFlags &= ~WS_VISIBLE; m_isShown = FALSE; @@ -470,6 +469,14 @@ void wxWindowOS2::SetFocus() ::WinSetFocus(HWND_DESKTOP, hWnd); } // end of wxWindowOS2::SetFocus +void wxWindowOS2::SetFocusFromKbd() +{ + // + // Nothing else to do under OS/2 + // + wxWindowBase::SetFocusFromKbd(); +} // end of wxWindowOS2::SetFocus + wxWindow* wxWindowBase::FindFocus() { HWND hWnd = ::WinQueryFocus(HWND_DESKTOP); @@ -767,6 +774,7 @@ void wxWindowOS2::SetScrollbar( SBCDATA vInfo; ULONG ulStyle = WS_VISIBLE | WS_SYNCPAINT; SWP vSwp; + SWP vSwpOwner; RECTL vRect; HWND hWndParent; HWND hWndClient; @@ -789,6 +797,7 @@ void wxWindowOS2::SetScrollbar( hWndClient = hWndParent; } ::WinQueryWindowPos(hWndClient, &vSwp); + ::WinQueryWindowPos(hWnd, &vSwpOwner); if (nPageSize > 1 && nRange > 0) { @@ -805,6 +814,18 @@ void wxWindowOS2::SetScrollbar( ulStyle |= SBS_HORZ; if (m_hWndScrollBarHorz == 0L) { + // + // Since the scrollbars are usually created before the owner is + // sized either via an OnSize event directly or via sizers or + // layout constraints, we will initially just use the coords of + // the parent window (this is usually a frame client window). But + // the bars themselves, are children of the parent frame (i.e + // siblings of the frame client. The owner, however is the actual + // window being scrolled (or at least the one responsible for + // handling the scroll events). The owner will be resized later, + // as it is usually a child of a top level window, and when that + // is done its scrollbars will be resized and repositioned as well. + // m_hWndScrollBarHorz = ::WinCreateWindow( hWndParent ,WC_SCROLLBAR ,(PSZ)NULL @@ -822,26 +843,42 @@ void wxWindowOS2::SetScrollbar( } else { - ::WinSetWindowPos( m_hWndScrollBarHorz - ,HWND_TOP - ,vSwp.x - ,vSwp.y - ,vSwp.cx - 20 - ,20 - ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER - ); - ::WinSendMsg( m_hWndScrollBarHorz - ,SBM_SETSCROLLBAR - ,(MPARAM)nPos - ,MPFROM2SHORT(0, (SHORT)nRange1) - ); - ::WinSendMsg( m_hWndScrollBarHorz - ,SBM_SETTHUMBSIZE - ,MPFROM2SHORT( (SHORT)nThumbVisible - ,(SHORT)nRange1 - ) - ,(MPARAM)0 - ); + // + // The owner (the scrolled window) is a child of the Frame's + // client window, usually. The scrollbars are children of the + // frame, itself, and thus are positioned relative to the frame's + // origin, not the frame's client window origin. + // The starting x position is the same as the starting x position + // of the owner, but in terms of the parent frame. + // The starting y position is 20 pels below the origin of the + // owner in terms of the parent frame. + // The horz bar is the same width as the owner and 20 pels high. + // + if (nRange1 >= nThumbVisible) + { + ::WinSetWindowPos( m_hWndScrollBarHorz + ,HWND_TOP + ,vSwp.x + vSwpOwner.x + ,(vSwp.y + vSwpOwner.y) - 20 + ,vSwpOwner.cx + ,20 + ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER + ); + ::WinSendMsg( m_hWndScrollBarHorz + ,SBM_SETSCROLLBAR + ,(MPARAM)nPos + ,MPFROM2SHORT(0, (SHORT)nRange1) + ); + ::WinSendMsg( m_hWndScrollBarHorz + ,SBM_SETTHUMBSIZE + ,MPFROM2SHORT( (SHORT)nThumbVisible + ,(SHORT)nRange1 + ) + ,(MPARAM)0 + ); + } + else + ::WinShowWindow(m_hWndScrollBarHorz, FALSE); } } else @@ -849,6 +886,18 @@ void wxWindowOS2::SetScrollbar( ulStyle |= SBS_VERT; if (m_hWndScrollBarVert == 0L) { + // + // Since the scrollbars are usually created before the owner is + // sized either via an OnSize event directly or via sizers or + // layout constraints, we will initially just use the coords of + // the parent window (this is usually a frame client window). But + // the bars themselves, are children of the parent frame (i.e + // siblings of the frame client. The owner, however is the actual + // window being scrolled (or at least the one responsible for + // handling the scroll events). The owner will be resized later, + // as it is usually a child of a top level window, and when that + // is done its scrollbars will be resized and repositioned as well. + // m_hWndScrollBarVert = ::WinCreateWindow( hWndParent ,WC_SCROLLBAR ,(PSZ)NULL @@ -866,26 +915,46 @@ void wxWindowOS2::SetScrollbar( } else { - ::WinSetWindowPos( m_hWndScrollBarVert - ,HWND_TOP - ,vSwp.x + vSwp.cx - 20 - ,vSwp.y + 20 - ,20 - ,vSwp.cy - 20 - ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW - ); - ::WinSendMsg( m_hWndScrollBarVert - ,SBM_SETSCROLLBAR - ,(MPARAM)nPos - ,MPFROM2SHORT(0, (SHORT)nRange1) - ); - ::WinSendMsg( m_hWndScrollBarVert - ,SBM_SETTHUMBSIZE - ,MPFROM2SHORT( (SHORT)nThumbVisible - ,(SHORT)nRange1 - ) - ,(MPARAM)0 - ); + // + // The owner (the scrolled window) is a child of the Frame's + // client window, usually. The scrollbars are children of the + // frame, itself and thus are positioned relative to the frame's + // origin, not the frame's client window's origin. + // Thus, the x position will be frame client's x (usually a few + // pels inside the parent frame, plus the width of the owner. + // Since we may be using sizers or layout constraints for multiple + // child scrolled windows, the y position will be the frame client's + // y pos plus the scrolled windows y position, yielding the y + // position of the scrollbar relative to the parent frame (the vert + // scrollbar is on the right and starts at the bottom of the + // owner window). + // It is 20 pels wide and the same height as the owner. + // + if (nRange1 >= nThumbVisible) + { + ::WinSetWindowPos( m_hWndScrollBarVert + ,HWND_TOP + ,vSwp.x + vSwpOwner.x + vSwpOwner.cx + ,vSwp.y + vSwpOwner.y + ,20 + ,vSwpOwner.cy + ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW + ); + ::WinSendMsg( m_hWndScrollBarVert + ,SBM_SETSCROLLBAR + ,(MPARAM)nPos + ,MPFROM2SHORT(0, (SHORT)nRange1) + ); + ::WinSendMsg( m_hWndScrollBarVert + ,SBM_SETTHUMBSIZE + ,MPFROM2SHORT( (SHORT)nThumbVisible + ,(SHORT)nRange1 + ) + ,(MPARAM)0 + ); + } + else + ::WinShowWindow(m_hWndScrollBarVert, FALSE); } m_nYThumbSize = nThumbVisible; } @@ -923,6 +992,7 @@ void wxWindowOS2::ScrollWindow( ,NULL ,SW_SCROLLCHILDREN | SW_INVALIDATERGN ); + Refresh(); } // end of wxWindowOS2::ScrollWindow // --------------------------------------------------------------------------- @@ -985,6 +1055,69 @@ bool wxCheckWindowWndProc( return(fnWndProc == (WXFARPROC)vCls.pfnWindowProc); } // end of WinGuiBase_CheckWindowWndProc +void wxWindowOS2::SetWindowStyleFlag( + long lFlags +) +{ + long lFlagsOld = GetWindowStyleFlag(); + + if (lFlags == lFlagsOld) + return; + + // + // Update the internal variable + // + wxWindowBase::SetWindowStyleFlag(lFlags); + + // + // Now update the Windows style as well if needed - and if the window had + // been already created + // + if (!GetHwnd()) + return; + + WXDWORD dwExstyle; + WXDWORD dwExstyleOld; + long lStyle = OS2GetStyle( lFlags + ,&dwExstyle + ); + long lStyleOld = OS2GetStyle( lFlagsOld + ,&dwExstyleOld + ); + + if (lStyle != lStyleOld) + { + // + // Some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by + // this function so instead of simply setting the style to the new + // value we clear the bits which were set in styleOld but are set in + // the new one and set the ones which were not set before + // + long lStyleReal = ::WinQueryWindowULong(GetHwnd(), QWL_STYLE); + + lStyleReal &= ~lStyleOld; + lStyleReal |= lStyle; + + ::WinSetWindowULong(GetHwnd(), QWL_STYLE, lStyleReal); + } +} // end of wxWindowOS2::SetWindowStyleFlag + +WXDWORD wxWindowOS2::OS2GetStyle( + long lFlags +, WXDWORD* pdwExstyle +) const +{ + WXDWORD dwStyle = 0L; + + if (lFlags & wxCLIP_CHILDREN ) + dwStyle |= WS_CLIPCHILDREN; + + if (lFlags & wxCLIP_SIBLINGS ) + dwStyle |= WS_CLIPSIBLINGS; + + return dwStyle; +} // end of wxWindowMSW::MSWGetStyle + // // Make a Windows extended style from the given wxWindows window style // @@ -1523,6 +1656,61 @@ void wxWindowOS2::DoMoveWindow( ,(LONG)nHeight ,SWP_ZORDER | SWP_SIZE | SWP_MOVE | SWP_SHOW ); + if (m_vWinSwp.cx == 0 && m_vWinSwp.cy == 0 && m_vWinSwp.fl == 0) + // + // Uninitialized + // + ::WinQueryWindowPos(GetHwnd(), &m_vWinSwp); + else + { + int nYDiff = m_vWinSwp.cy - nHeight; + + // + // Handle resizing of scrolled windows. The target or window to + // be scrolled is the owner (gets the scroll notificaitons). The + // parent is usually the parent frame of the scrolled panel window. + // In order to show the scrollbars the target window will be shrunk + // by the size of the scroll bar widths (20) and moved in the X and Y + // directon. That value will be computed as part of the diff for + // moving the children. Everytime the window is sized the + // toplevel OnSize is going to resize the panel to fit the client + // or the whole sizer and will need to me resized. This will send + // a WM_SIZE out which will be intercepted by the ScrollHelper + // which will cause the scrollbars to be displayed via the SetScrollbar + // call in CWindow. + // + if ( IsKindOf(CLASSINFO(wxGenericScrolledWindow)) || + IsKindOf(CLASSINFO(wxScrolledWindow)) + ) + { + int nAdjustWidth = 0; + int nAdjustHeight = 0; + SWP vSwpScroll; + + if (GetScrollBarHorz() == NULLHANDLE || + !WinIsWindowShowing(GetScrollBarHorz())) + nAdjustHeight = 0L; + else + nAdjustHeight = 20L; + if (GetScrollBarVert() == NULLHANDLE || + !WinIsWindowShowing(GetScrollBarVert())) + nAdjustWidth = 0L; + else + nAdjustWidth = 20L; + ::WinQueryWindowPos(GetHWND(), &vSwpScroll); + ::WinSetWindowPos( GetHWND() + ,HWND_TOP + ,vSwpScroll.x + ,vSwpScroll.y + nAdjustHeight + ,vSwpScroll.cx - nAdjustWidth + ,vSwpScroll.cy - nAdjustHeight + ,SWP_MOVE | SWP_SIZE + ); + nYDiff += nAdjustHeight; + } + MoveChildren(nYDiff); + ::WinQueryWindowPos(GetHwnd(), &m_vWinSwp); + } } // end of wxWindowOS2::DoMoveWindow // @@ -2473,12 +2661,38 @@ MRESULT wxWindowOS2::OS2WindowProc( case WM_BUTTON3MOTIONEND: case WM_BUTTON3MOTIONSTART: { - short x = LOWORD(wParam); - short y = HIWORD(wParam); + if (uMsg == WM_BUTTON1DOWN && AcceptsFocus()) + SetFocus(); - bProcessed = HandleMouseEvent(uMsg, x, y, (WXUINT)wParam); + short nX = LOWORD(wParam); + short nY = HIWORD(wParam); + + // + // Redirect the event to a static control if necessary + // + if (this == GetCapture()) + { + bProcessed = HandleMouseEvent( uMsg + ,nX + ,nY + ,(WXUINT)SHORT1FROMMP(wParam) + ); + } + else + { + wxWindow* pWin = FindWindowForMouseEvent( this + ,&nX + ,&nY + ); + bProcessed = pWin->HandleMouseEvent( uMsg + ,nX + ,nY + ,(WXUINT)SHORT1FROMMP(wParam) + ); + } } break; + case WM_SYSCOMMAND: bProcessed = HandleSysCommand(wParam, lParam); break; @@ -2539,17 +2753,18 @@ MRESULT wxWindowOS2::OS2WindowProc( if (uKeyFlags & KC_KEYUP) { //TODO: check if the cast to WXWORD isn't causing trouble - bProcessed = HandleKeyUp((WXDWORD)wParam, lParam); + bProcessed = HandleKeyUp(wParam, lParam); break; } else // keydown event { + m_bLastKeydownProcessed = FALSE; // // If this has been processed by an event handler, // return 0 now (we've handled it). DON't RETURN // we still need to process further // - HandleKeyDown((WXDWORD)wParam, lParam); + m_bLastKeydownProcessed = HandleKeyDown(wParam, lParam); if (uKeyFlags & KC_VIRTUALKEY) { USHORT uVk = SHORT2FROMMP((MPARAM)lParam); @@ -2557,14 +2772,17 @@ MRESULT wxWindowOS2::OS2WindowProc( // // We consider these message "not interesting" to OnChar // - if (uVk == VK_SHIFT || uVk == VK_CTRL ) - { - bProcessed = TRUE; - break; - } switch(uVk) { - // + case VK_SHIFT: + case VK_CTRL: + case VK_MENU: + case VK_CAPSLOCK: + case VK_NUMLOCK: + case VK_SCRLLOCK: + bProcessed = TRUE; + break; + // Avoid duplicate messages to OnChar for these ASCII keys: they // will be translated by TranslateMessage() and received in WM_CHAR case VK_ESC: @@ -2578,19 +2796,28 @@ MRESULT wxWindowOS2::OS2WindowProc( bProcessed = FALSE; break; - case VK_LEFT: - case VK_RIGHT: - case VK_DOWN: - case VK_UP: default: - bProcessed = HandleChar((WXDWORD)wParam, lParam); + bProcessed = HandleChar(wParam, lParam); } break; } else // WM_CHAR -- Always an ASCII character { - bProcessed = HandleChar((WXDWORD)wParam, lParam, TRUE); - break; + if (m_bLastKeydownProcessed) + { + // + // The key was handled in the EVT_KEY_DOWN and handling + // a key in an EVT_KEY_DOWN handler is meant, by + // design, to prevent EVT_CHARs from happening + // + m_bLastKeydownProcessed = FALSE; + bProcessed = TRUE; + } + else // do generate a CHAR event + { + bProcessed = HandleChar(wParam, lParam, TRUE); + break; + } } } } @@ -2944,37 +3171,6 @@ bool wxWindowOS2::OS2Create( { sClassName += wxT("NR"); } - - // - // If the window being created is a Frame's Statusbar we need to use - // the actual Frame's size, not its client - // - if (pParent) - { - if ( pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) || - pParent->IsKindOf(CLASSINFO(wxScrolledWindow)) - ) - { - if (IsKindOf(CLASSINFO(wxStatusBar)) && - pParent->IsKindOf(CLASSINFO(wxFrame))) - { - RECTL vRect; - wxFrame* pFrame = wxDynamicCast(pParent, wxFrame); - - ::WinQueryWindowRect((HWND)pFrame->GetFrame(), &vRect); - nY = vRect.yTop - (nY + nHeight); - } - else - nY = pParent->GetSize().y - (nY + nHeight); - } - } - else - { - RECTL vRect; - - ::WinQueryWindowRect(HWND_DESKTOP, &vRect); - nY = vRect.yTop - (nY + nHeight); - } m_hWnd = (WXHWND)::WinCreateWindow( (HWND)hParent ,(PSZ)sClassName.c_str() ,(PSZ)zTitle ? zTitle : "" @@ -2997,6 +3193,22 @@ bool wxWindowOS2::OS2Create( } SubclassWin(m_hWnd); SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT)); + + m_backgroundColour.Set(wxString("GREY")); + + LONG lColor = (LONG)m_backgroundColour.GetPixel(); + + if (!::WinSetPresParam( m_hWnd + ,PP_BACKGROUNDCOLOR + ,sizeof(LONG) + ,(PVOID)&lColor + )) + { + vError = ::WinGetLastError(vHabmain); + sError = wxPMErrorToStr(vError); + wxLogError("Error creating frame. Error: %s\n", sError); + return FALSE; + } SetSize( nX ,nY ,nWidth @@ -3485,7 +3697,71 @@ bool wxWindowOS2::HandlePaint() vEvent.SetEventObject(this); bProcessed = GetEventHandler()->ProcessEvent(vEvent); - return GetEventHandler()->ProcessEvent(vEvent); //bProcessed; + if (!bProcessed && + IsKindOf(CLASSINFO(wxPanel)) && + GetChildren().GetCount() == 0 + ) + { + // + // OS/2 needs to process this right here, not by the default proc + // Window's default proc correctly paints everything, OS/2 does not! + // + HPS hPS; + RECTL vRect; + wxFrame* pFrame; + wxWindow* pParent; + + hPS = ::WinBeginPaint( GetHwnd() + ,NULLHANDLE + ,&vRect + ); + if(hPS) + { + ::GpiCreateLogColorTable( hPS + ,0L + ,LCOLF_CONSECRGB + ,0L + ,(LONG)wxTheColourDatabase->m_nSize + ,(PLONG)wxTheColourDatabase->m_palTable + ); + ::GpiCreateLogColorTable( hPS + ,0L + ,LCOLF_RGB + ,0L + ,0L + ,NULL + ); + + ::WinFillRect(hPS, &vRect, GetBackgroundColour().GetPixel()); + if (m_dwExStyle) + { + LINEBUNDLE vLineBundle; + + vLineBundle.lColor = 0x00000000; // Black + vLineBundle.usMixMode = FM_OVERPAINT; + vLineBundle.fxWidth = 1; + vLineBundle.lGeomWidth = 1; + vLineBundle.usType = LINETYPE_SOLID; + vLineBundle.usEnd = 0; + vLineBundle.usJoin = 0; + ::GpiSetAttrs( hPS + ,PRIM_LINE + ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE + ,0L + ,&vLineBundle + ); + ::WinQueryWindowRect(GetHwnd(), &vRect); + wxDrawBorder( hPS + ,vRect + ,m_dwExStyle + ); + } + ::WinEndPaint(hPS); + } + bProcessed = TRUE; + } + + return bProcessed; } // end of wxWindowOS2::HandlePaint bool wxWindowOS2::HandleEraseBkgnd( @@ -3758,6 +4034,7 @@ wxKeyEvent wxWindowOS2::CreateKeyEvent( wxEventType eType , int nId , WXLPARAM lParam +, WXWPARAM wParam ) const { wxKeyEvent vEvent(eType); @@ -3769,6 +4046,8 @@ wxKeyEvent wxWindowOS2::CreateKeyEvent( vEvent.m_eventObject = (wxWindow *)this; // const_cast vEvent.m_keyCode = nId; + vEvent.m_rawCode = (wxUint32)wParam; + vEvent.m_rawFlags = (wxUint32)lParam; vEvent.SetTimestamp(s_currentMsg.time); // @@ -3796,7 +4075,7 @@ wxKeyEvent wxWindowOS2::CreateKeyEvent( // WM_KEYDOWN one // bool wxWindowOS2::HandleChar( - WXDWORD wParam + WXWPARAM wParam , WXLPARAM lParam , bool isASCII ) @@ -3804,12 +4083,22 @@ bool wxWindowOS2::HandleChar( bool bCtrlDown = FALSE; int vId; + if (m_bLastKeydownProcessed) + { + // + // The key was handled in the EVT_KEY_DOWN. Handling a key in an + // EVT_KEY_DOWN handler is meant, by design, to prevent EVT_CHARs + // from happening, so just bail out at this point. + // + m_bLastKeydownProcessed = FALSE; + return TRUE; + } if (isASCII) { // // If 1 -> 26, translate to CTRL plus a letter. // - vId = wParam; + vId = (int)wParam; if ((vId > 0) && (vId < 27)) { switch (vId) @@ -3828,57 +4117,50 @@ bool wxWindowOS2::HandleChar( default: bCtrlDown = TRUE; - vId = vId + 96; + vId = vId + 'a' - 1; } } } - else if ( (vId = wxCharCodeOS2ToWX(wParam)) == 0) + else // we're called from WM_KEYDOWN { - // - // It's ASCII and will be processed here only when called from - // WM_CHAR (i.e. when isASCII = TRUE), don't process it now - // - vId = -1; + vId = wxCharCodeOS2ToWX((int)wParam); + if (vId == 0) + return FALSE; } - if (vId != -1) - { - wxKeyEvent vEvent(CreateKeyEvent( wxEVT_CHAR + wxKeyEvent vEvent(CreateKeyEvent( wxEVT_CHAR ,vId ,lParam )); - if (bCtrlDown) - { - vEvent.m_controlDown = TRUE; - } - - if (GetEventHandler()->ProcessEvent(vEvent)) - return TRUE; + if (bCtrlDown) + { + vEvent.m_controlDown = TRUE; } - return FALSE; + return (GetEventHandler()->ProcessEvent(vEvent)); } bool wxWindowOS2::HandleKeyDown( - WXWORD wParam + WXWPARAM wParam , WXLPARAM lParam ) { - int nId = wxCharCodeOS2ToWX(wParam); + int nId = wxCharCodeOS2ToWX((int)wParam); if (!nId) { // // Normal ASCII char // - nId = wParam; + nId = (int)wParam; } if (nId != -1) { wxKeyEvent vEvent(CreateKeyEvent( wxEVT_KEY_DOWN ,nId - ,lParam + ,(MPARAM)lParam + ,(MPARAM)wParam )); if (GetEventHandler()->ProcessEvent(vEvent)) @@ -3890,18 +4172,18 @@ bool wxWindowOS2::HandleKeyDown( } // end of wxWindowOS2::HandleKeyDown bool wxWindowOS2::HandleKeyUp( - WXDWORD wParam + WXWPARAM wParam , WXLPARAM lParam ) { - int nId = wxCharCodeOS2ToWX(wParam); + int nId = wxCharCodeOS2ToWX((int)wParam); if (!nId) { // // Normal ASCII char // - nId = wParam; + nId = (int)wParam; } if (nId != -1) @@ -3909,6 +4191,7 @@ bool wxWindowOS2::HandleKeyUp( wxKeyEvent vEvent(CreateKeyEvent( wxEVT_KEY_UP ,nId ,lParam + ,wParam )); if (GetEventHandler()->ProcessEvent(vEvent)) @@ -4011,13 +4294,14 @@ void wxWindowOS2::MoveChildren( vSwp.x -= pCtrl->GetXComp(); } ::WinSetWindowPos( GetHwndOf(pWin) - ,HWND_BOTTOM + ,HWND_TOP ,vSwp.x ,vSwp.y - nDiff ,vSwp.cx ,vSwp.cy - ,SWP_MOVE | SWP_ZORDER + ,SWP_MOVE | SWP_SHOW | SWP_ZORDER ); + ::WinQueryWindowPos(GetHwndOf(pWin), pWin->GetSwp()); if (pWin->IsKindOf(CLASSINFO(wxRadioBox))) { wxRadioBox* pRadioBox; @@ -4043,6 +4327,7 @@ void wxWindowOS2::MoveChildren( ); } } + Refresh(); } // end of wxWindowOS2::MoveChildren // @@ -4062,6 +4347,8 @@ void wxWindowOS2::MoveChildren( // // 3) The controls are children of a panel, which in turn is a child of // a frame. +// The panel may be one of many, in which case the same treatment +// as 1 applies. It may be the only child, though. // This is the nastiest case. A panel is created as the only child of // the frame and as such, when a frame has only one child, the child is // expanded to fit the entire client area of the frame. Because the @@ -4102,38 +4389,15 @@ int wxWindowOS2::GetOS2ParentHeight( else return(pParent->GetClientSize().y); } - // - // Case 3 -- this is for any window that is the sole child of a Frame. - // The grandparent must exist and it must be of type CFrame - // and it's height must be different. Otherwise the standard - // applies. + // Case -- this is for any window that is the sole child of a Frame. + // The grandparent must exist and it must be of type CFrame + // and it's height must be different. Otherwise the standard + // applies. // else { - pGrandParent = pParent->GetParent(); - if (pGrandParent && - pGrandParent->IsKindOf(CLASSINFO(wxFrame)) && - pGrandParent->GetClientSize().y != pParent->GetSize().y - ) - { - int nParentHeight = 0L; - int nStatusBarHeight = 0L; - wxFrame* pFrame = wxDynamicCast(pGrandParent, wxFrame); - wxStatusBar* pStatbar = pFrame->GetStatusBar(); - - nParentHeight = pGrandParent->GetClientSize().y; - if (pStatbar) - nStatusBarHeight = pStatbar->GetSize().y; - nParentHeight -= nStatusBarHeight; - return(nParentHeight); - } - else - // - // Panel is a child of some other kind of window so we'll - // just use it's original size - // - return(pParent->GetClientSize().y); + return(pParent->GetClientSize().y); } return(0L); } // end of wxWindowOS2::GetOS2ParentHeight @@ -4142,111 +4406,6 @@ int wxWindowOS2::GetOS2ParentHeight( // OS/2 needs a lot extra manipulation to deal with layouts // for canvas windows, particularly scrolled ones. // -void wxWindowOS2::OS2Layout( - int nWidth -, int nHeight -) -{ - // - // Frames laying out canvas windows need the held. - // Dialogs or Frames laying out child controls do not. - // - if (IsKindOf(CLASSINFO(wxFrame))) - { - RECTL vRectFrame; - RECTL vRectClient; - RECTL vRectChild; - RECTL vRectHorz; - RECTL vRectVert; - SWP vSwpFrame; - SWP vSwpClient; - SWP vSwpChild; - SWP vSwpHorz; - SWP vSwpVert; - wxFrame* pFrame = wxDynamicCast(this, wxFrame); - bool bNewYSize = FALSE; - bool bNewXSize = FALSE; - - ::WinQueryWindowPos(pFrame->GetFrame(), &vSwpFrame); - ::WinQueryWindowPos(GetHwnd(), &vSwpClient); - - if (vSwpClient.cy != pFrame->GetSwpClient()->cy) - bNewYSize = TRUE; - if (vSwpClient.cx != pFrame->GetSwpClient()->cx) - bNewXSize = TRUE; - - for (wxWindowList::Node* pNode = GetChildren().GetFirst(); - pNode; - pNode = pNode->GetNext()) - { - wxWindow* pChild = pNode->GetData(); - int nWidthAdjust = 0; - int nHeightAdjust = 0; - - if ( pChild->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) || - pChild->IsKindOf(CLASSINFO(wxScrolledWindow)) - ) - { - if(bNewYSize) - { - // - // This is needed SetSize will mess up the OS/2 child window - // positioning because we position in wxWindows coordinates, - // not OS/2 coordinates. - // - pChild->MoveChildren(pFrame->GetSwpClient()->cy - vSwpClient.cy); - pChild->Refresh(); - } - ::WinQueryWindowPos(pChild->GetHWND(), &vSwpChild); - - // - // Reset the child window size to account for scrollbars - // - if (pChild->GetScrollBarHorz() != NULLHANDLE) - nHeightAdjust = 20; - if (pChild->GetScrollBarVert() != NULLHANDLE) - nWidthAdjust = 20; - ::WinSetWindowPos( pChild->GetHWND() - ,HWND_TOP - ,vSwpChild.x - ,vSwpChild.y + nHeightAdjust - ,vSwpChild.cx - nWidthAdjust - ,vSwpChild.cy - nHeightAdjust - ,SWP_MOVE | SWP_SIZE - ); - - // - // Reset the scrollbar sizes...they will be all messed up after - // auto layouts - // - if (pChild->GetScrollBarHorz() != NULLHANDLE) - { - ::WinSetWindowPos( pChild->GetScrollBarHorz() - ,HWND_TOP - ,vSwpClient.x + vSwpChild.x - ,vSwpClient.y + vSwpChild.y - ,vSwpChild.cx - 20 - ,20 - ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER - ); - } - if (pChild->GetScrollBarVert() != NULLHANDLE) - { - ::WinSetWindowPos( pChild->GetScrollBarVert() - ,HWND_TOP - ,vSwpClient.x + vSwpChild.x + vSwpChild.cx - 20 - ,vSwpClient.y + vSwpChild.y + 20 - ,20 - ,vSwpChild.cy - 20 - ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER - ); - } - } - } - ::WinQueryWindowPos(GetHwnd(), pFrame->GetSwpClient()); - } -} // end of wxWindowOS2::OS2Layout - wxWindowCreationHook::wxWindowCreationHook( wxWindow* pWinBeingCreated ) @@ -4324,6 +4483,7 @@ int wxCharCodeOS2ToWX( case VK_PRINTSCRN: nId = WXK_PRINT; break; case VK_INSERT: nId = WXK_INSERT; break; case VK_DELETE: nId = WXK_DELETE; break; + case VK_CAPSLOCK: nId = WXK_CAPITAL; break; case VK_F1: nId = WXK_F1; break; case VK_F2: nId = WXK_F2; break; case VK_F3: nId = WXK_F3; break; @@ -4348,6 +4508,17 @@ int wxCharCodeOS2ToWX( case VK_F22: nId = WXK_F22; break; case VK_F23: nId = WXK_F23; break; case VK_F24: nId = WXK_F24; break; + case VK_OEM_1: nId = ';'; break; + case VK_OEM_PLUS: nId = '+'; break; + case VK_OEM_COMMA: nId = ','; break; + case VK_OEM_MINUS: nId = '-'; break; + case VK_OEM_PERIOD: nId = '.'; break; + case VK_OEM_2: nId = '/'; break; + case VK_OEM_3: nId = '~'; break; + case VK_OEM_4: nId = '['; break; + case VK_OEM_5: nId = '\\'; break; + case VK_OEM_6: nId = ']'; break; + case VK_OEM_7: nId = '\''; break; case VK_NUMLOCK: nId = WXK_NUMLOCK; break; case VK_SCRLLOCK: nId = WXK_SCROLL; break; default: @@ -4968,3 +5139,59 @@ wxPoint wxGetMousePosition() return wxPoint(vPt.x, vPt.y); } +wxWindowOS2* FindWindowForMouseEvent( + wxWindow* pWin +, short* pnX +, short* pnY +) +{ + wxCHECK_MSG( pnX && pnY, pWin, _T("NULL pointer in FindWindowForMouseEvent") ); + POINTL vPoint = { *pnX, *pnY }; + HWND hWnd = GetHwndOf(pWin); + HWND hWndUnderMouse; + + // + // First try to find a non transparent child: this allows us to send events + // to a static text which is inside a static box, for example + // + + hWndUnderMouse = ::WinWindowFromPoint( hWnd + ,&vPoint + ,TRUE + ); + if (!hWndUnderMouse || hWndUnderMouse == hWnd) + { + // + // Now try any child window at all + // + hWndUnderMouse = ::WinWindowFromPoint( HWND_DESKTOP + ,&vPoint + ,TRUE + ); + + } + + // + // Check that we have a child window which is susceptible to receive mouse + // events: for this it must be shown and enabled + if ( hWndUnderMouse && + hWndUnderMouse != hWnd && + ::WinIsWindowVisible(hWndUnderMouse) && + ::WinIsWindowEnabled(hWndUnderMouse)) + { + wxWindow* pWinUnderMouse = wxFindWinFromHandle((WXHWND)hWndUnderMouse); + if (pWinUnderMouse) + { + // translate the mouse coords to the other window coords + pWin->ClientToScreen( (int*)pnX + ,(int*)pnY + ); + pWinUnderMouse->ScreenToClient( (int*)pnX + ,(int*)pnY + ); + pWin = pWinUnderMouse; + } + } + return pWin; +} // end of FindWindowForMouseEvent +