X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1b086de1460fd46c21a432ac3d8dec2759e5d05a..1978421a6d8b81c1f8a961da4b8ddf544fec7b1b:/src/os2/window.cpp?ds=sidebyside diff --git a/src/os2/window.cpp b/src/os2/window.cpp index f0f385d7b0..d638bce330 100644 --- a/src/os2/window.cpp +++ b/src/os2/window.cpp @@ -1,4 +1,3 @@ -///////////////////////////////////////////////////////////////////////////// // Name: windows.cpp // Purpose: wxWindow // Author: David Webster @@ -28,13 +27,22 @@ #include "wx/app.h" #include "wx/panel.h" #include "wx/layout.h" + #include "wx/checkbox.h" + #include "wx/combobox.h" #include "wx/dialog.h" #include "wx/frame.h" #include "wx/listbox.h" #include "wx/button.h" + #include "wx/bmpbuttn.h" #include "wx/msgdlg.h" #include "wx/scrolwin.h" - + #include "wx/radiobox.h" + #include "wx/radiobut.h" + #include "wx/slider.h" + #include "wx/statbox.h" + #include "wx/statusbr.h" + #include "wx/toolbar.h" + #include "wx/settings.h" #include #endif @@ -55,6 +63,10 @@ #include "wx/tooltip.h" #endif +#if wxUSE_NOTEBOOK + #include "wx/notebook.h" +#endif + #if wxUSE_CARET #include "wx/caret.h" #endif // wxUSE_CARET @@ -89,6 +101,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 // --------------------------------------------------------------------------- @@ -121,24 +147,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 // @@ -284,13 +302,14 @@ void wxWindowOS2::Init() // // PM specific // - m_bDoubleClickAllowed = 0; m_bWinCaptured = FALSE; - m_isBeingDeleted = FALSE; - m_fnOldWndProc = 0; - m_bUseCtl3D = FALSE; - m_bMouseInWindow = FALSE; + m_isBeingDeleted = FALSE; + m_fnOldWndProc = NULL; + m_bUseCtl3D = FALSE; + m_bMouseInWindow = FALSE; + m_bLastKeydownProcessed = FALSE; + m_pChildrenDisabled = NULL; // // wxWnd @@ -300,8 +319,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; @@ -329,12 +351,12 @@ wxWindowOS2::~wxWindowOS2() for (wxWindow* pWin = GetParent(); pWin; pWin = pWin->GetParent()) { - wxFrame* pFrame = wxDynamicCast(pWin, wxFrame); + wxTopLevelWindow* pFrame = wxDynamicCast(pWin, wxTopLevelWindow); if (pFrame) { if (pFrame->GetLastFocus() == this) - pFrame->SetLastFocus((wxWindow*)NULL); + pFrame->SetLastFocus(NULL); } } @@ -352,6 +374,7 @@ wxWindowOS2::~wxWindowOS2() // wxRemoveHandleAssociation(this); } + delete m_pChildrenDisabled; } // end of wxWindowOS2::~wxWindowOS2 // real construction (Init() must have been called before!) @@ -370,6 +393,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 @@ -398,59 +434,36 @@ bool wxWindowOS2::Create( // set in those class create procs. PM's basic windows styles are // very limited. // - ulCreateFlags |= WS_VISIBLE; + ulCreateFlags |= 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; } + else + { + ulCreateFlags |= WS_VISIBLE; + } // // Generic OS/2 Windows have no Control Data but other classes // that call OS2Create may have some. // - OS2Create( (PSZ)wxCanvasClassName - ,rName.c_str() - ,ulCreateFlags - ,rPos - ,rSize - ,NULL // Control Data - ,dwExStyle - ,TRUE // Child - ); - - return(TRUE); + return(OS2Create( (PSZ)wxCanvasClassName + ,rName.c_str() + ,ulCreateFlags + ,rPos + ,rSize + ,NULL // Control Data + ,dwExStyle + ,TRUE // Child + )); } // end of wxWindowOS2::Create // --------------------------------------------------------------------------- @@ -466,6 +479,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); @@ -489,15 +510,58 @@ bool wxWindowOS2::Enable( if ( hWnd ) ::WinEnableWindow(hWnd, (BOOL)bEnable); + // + // The logic below doesn't apply to the top level windows -- otherwise + // showing a modal dialog would result in total greying out (and ungreying + // out later) of everything which would be really ugly + // + if (IsTopLevel()) + return TRUE; + wxWindowList::Node* pNode = GetChildren().GetFirst(); while (pNode) { wxWindow* pChild = pNode->GetData(); - pChild->Enable(bEnable); + if (bEnable) + { + // + // Enable the child back unless it had been disabled before us + // + if (!m_pChildrenDisabled || !m_pChildrenDisabled->Find(pChild)) + pChild->Enable(); + } + else // we're being disabled + { + if (pChild->IsEnabled()) + { + // + // Disable it as children shouldn't stay enabled while the + // parent is not + // + pChild->Disable(); + } + else // child already disabled, remember it + { + // + // Have we created the list of disabled children already? + // + if (!m_pChildrenDisabled) + m_pChildrenDisabled = new wxWindowList; + m_pChildrenDisabled->Append(pChild); + } + } pNode = pNode->GetNext(); } + if (bEnable && m_pChildrenDisabled) + { + // + // We don't need this list any more, don't keep unused memory + // + delete m_pChildrenDisabled; + m_pChildrenDisabled = NULL; + } return TRUE; } // end of wxWindowOS2::Enable @@ -541,7 +605,7 @@ wxString wxWindowOS2::GetTitle() const return wxGetWindowText(GetHWND()); } // end of wxWindowOS2::GetTitle -void wxWindowOS2::CaptureMouse() +void wxWindowOS2::DoCaptureMouse() { HWND hWnd = GetHwnd(); @@ -552,7 +616,7 @@ void wxWindowOS2::CaptureMouse() } } // end of wxWindowOS2::GetTitle -void wxWindowOS2::ReleaseMouse() +void wxWindowOS2::DoReleaseMouse() { if (m_bWinCaptured) { @@ -579,77 +643,11 @@ bool wxWindowOS2::SetFont( HWND hWnd = GetHwnd(); - if (hWnd != 0) - { - char zFont[128]; - char zFacename[30]; - char zWeight[30]; - char zStyle[30]; - - // - // The fonts available for Presentation Params are just three - // outline fonts, the rest are available to the GPI, so we must - // map the families to one of these three - // - switch(rFont.GetFamily()) - { - case wxSCRIPT: - case wxDECORATIVE: - case wxROMAN: - strcpy(zFacename,"Times New Roman"); - break; - - case wxTELETYPE: - case wxMODERN: - strcpy(zFacename, "Courier"); - break; - - case wxSWISS: - case wxDEFAULT: - default: - strcpy(zFacename, "Helvetica"); - break; - } - - switch(rFont.GetWeight()) - { - default: - case wxNORMAL: - case wxLIGHT: - zWeight[0] = '\0'; - break; - - case wxBOLD: - case wxFONTWEIGHT_MAX: - strcpy(zWeight, "Bold"); - break; - } - switch(rFont.GetStyle()) - { - case wxITALIC: - case wxSLANT: - strcpy(zStyle, "Italic"); - break; - - default: - zStyle[0] = '\0'; - break; - } - sprintf(zFont, "%d.%s", rFont.GetPointSize(), zFacename); - if (zWeight[0] != '\0') - { - strcat(zFont, " "); - strcat(zFont, zWeight); - } - if (zStyle[0] != '\0') - { - strcat(zFont, " "); - strcat(zFont, zStyle); - } - ::WinSetPresParam(hWnd, PP_FONTNAMESIZE, strlen(zFont) + 1, (PVOID)zFont); - } + wxOS2SetFont( hWnd + ,rFont + ); return(TRUE); -} +} // end of wxWindowOS2::SetFont bool wxWindowOS2::SetCursor( const wxCursor& rCursor @@ -693,81 +691,11 @@ void wxWindowOS2::WarpPointer( ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY)); } // end of wxWindowOS2::WarpPointer -#if WXWIN_COMPATIBILITY -void wxWindowOS2::OS2DeviceToLogical (float *x, float *y) const -{ -} -#endif // WXWIN_COMPATIBILITY // --------------------------------------------------------------------------- // scrolling stuff // --------------------------------------------------------------------------- -#if WXWIN_COMPATIBILITY -void wxWindowOS2::SetScrollRange( - int nOrient -, int nRange -, bool bRefresh -) -{ - int nRange1 = nRange; - int nPageSize = GetScrollPage(nOrient); - - if (nPpageSize > 1 && nRange > 0) - { - nRange1 += (nPageSize - 1); - } - - if (nOrient == wxHORIZONTAL) - { - ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1)); - ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0); - } - else - { - ::WinSendMsg(m_hWndScrollBarVert, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1)); - ::WinSendMsg(m_hWndScrollBarVert, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0); - } -} // end of wxWindowOS2::SetScrollRange - -void wxWindowOS2::SetScrollPage( - int nOrient -, int nPage -, bool bRefresh -) -{ - if (nOrient == wxHORIZONTAL ) - m_nXThumbSize = nPage; - else - m_nYThumbSize = nPage; -} // end of wxWindowOS2::SetScrollPage - -int wxWindowOS2::OldGetScrollRange( - int nOrient -) const -{ - MRESULT mRc; - HWND hWnd = GetHwnd(); - - if (hWnd) - { - mRc = WinSendMsg(hWnd, SBM_QUERYRANGE, (MPARAM)0L, (MPARAM)0L); - return(SHORT2FROMMR(mRc)); - } - return 0; -} // end of wxWindowOS2::OldGetScrollRange - -int wxWindowOS2::GetScrollPage( - int nOrient -) const -{ - if (nOrient == wxHORIZONTAL) - return m_nXThumbSize; - else - return m_nYThumbSize; -} // end of wxWindowOS2::GetScrollPage -#endif // WXWIN_COMPATIBILITY - int wxWindowOS2::GetScrollPos( int nOrient ) const @@ -821,15 +749,39 @@ void wxWindowOS2::SetScrollbar( , bool WXUNUSED(bRefresh) ) { + HWND hWnd = GetHwnd(); int nOldRange = nRange - nThumbVisible; int nRange1 = nOldRange; int nPageSize = nThumbVisible; + SBCDATA vInfo; - HWND hWnd = GetHwnd(); ULONG ulStyle = WS_VISIBLE | WS_SYNCPAINT; + SWP vSwp; + SWP vSwpOwner; RECTL vRect; + HWND hWndParent; + HWND hWndClient; + wxWindow* pParent = GetParent(); + + if (pParent && pParent->IsKindOf(CLASSINFO(wxFrame))) + { + wxFrame* pFrame; + + pFrame = wxDynamicCast(pParent, wxFrame); + hWndParent = pFrame->GetFrame(); + hWndClient = GetHwndOf(pParent); + } + else + { + if (pParent) + hWndParent = GetHwndOf(pParent); + else + hWndParent = GetHwnd(); + hWndClient = hWndParent; + } + ::WinQueryWindowPos(hWndClient, &vSwp); + ::WinQueryWindowPos(hWnd, &vSwpOwner); - ::WinQueryWindowRect(hWnd, &vRect); if (nPageSize > 1 && nRange > 0) { nRange1 += (nPageSize - 1); @@ -846,53 +798,70 @@ void wxWindowOS2::SetScrollbar( if (m_hWndScrollBarHorz == 0L) { // - // We create the scrollbars with the desktop so that they are not - // registered as child windows of the window in order that child - // windows may be scrolled without scrolling the scrollbars themselves! + // 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( hWnd + m_hWndScrollBarHorz = ::WinCreateWindow( hWndParent ,WC_SCROLLBAR ,(PSZ)NULL ,ulStyle - ,vRect.xLeft - ,vRect.yBottom - ,vRect.xRight - vRect.xLeft + ,vSwp.x + ,vSwp.y + ,vSwp.cx - 20 ,20 ,hWnd ,HWND_TOP - ,FID_HORZSCROLL + ,60000 ,&vInfo ,NULL ); } else { - RECTL vRect2; - // - // Only want to resize the scrollbar if it changes, otherwise - // we'd probably end up in a recursive loop until we crash the call stack - // because this method is called in a ScrolledWindow OnSize event and SWP_MOVE | SWP_SIZE - // generates those events. + // 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. // - ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect2); - if (!(vRect2.xLeft == vRect.xLeft && - vRect2.xRight == vRect.xRight && - vRect2.yBottom == vRect.yBottom && - vRect2.yTop == vRect.yTop - ) ) + if (nRange1 >= nThumbVisible) { ::WinSetWindowPos( m_hWndScrollBarHorz ,HWND_TOP - ,vRect.xLeft - ,vRect.yBottom - ,vRect.xRight - vRect.xLeft + ,vSwp.x + vSwpOwner.x + ,(vSwp.y + vSwpOwner.y) - 20 + ,vSwpOwner.cx ,20 - ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW + ,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 + ); } - ::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 @@ -900,49 +869,75 @@ void wxWindowOS2::SetScrollbar( ulStyle |= SBS_VERT; if (m_hWndScrollBarVert == 0L) { - m_hWndScrollBarVert = ::WinCreateWindow( hWnd + // + // 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 ,ulStyle - ,vRect.xRight - 20 - ,vRect.yBottom + 20 + ,vSwp.x + vSwp.cx - 20 + ,vSwp.y + 20 ,20 - ,vRect.yTop - (vRect.yBottom + 20) + ,vSwp.cy - 20 ,hWnd ,HWND_TOP - ,FID_VERTSCROLL + ,60001 ,&vInfo ,NULL ); } else { - RECTL vRect2; - // - // Only want to resize the scrollbar if it changes, otherwise - // we'd probably end up in a recursive loop until we crash the call stack - // because this method is called in a ScrolledWindow OnSize event and SWP_MOVE | SWP_SIZE - // generates those events. + // 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. // - ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect2); - if (!(vRect2.xLeft == vRect.xLeft && - vRect2.xRight == vRect.xRight && - vRect2.yBottom == vRect.yBottom && - vRect2.yTop == vRect.yTop - ) ) + if (nRange1 >= nThumbVisible) { ::WinSetWindowPos( m_hWndScrollBarVert ,HWND_TOP - ,vRect.xRight - 20 - ,vRect.yBottom + 20 + ,vSwp.x + vSwpOwner.x + vSwpOwner.cx + ,vSwp.y + vSwpOwner.y ,20 - ,vRect.yTop - (vRect.yBottom + 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 + ); } - ::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; } @@ -955,86 +950,32 @@ void wxWindowOS2::ScrollWindow( ) { RECTL vRect; - RECTL vRect2; + RECTL vRectHorz; + RECTL vRectVert; + RECTL vRectChild; - nDy *= -1; // flip the sign of Dy as OS/2 is opposite wxWin. if (pRect) { - vRect2.xLeft = pRect->x; - vRect2.yTop = pRect->y + pRect->height; - vRect2.xRight = pRect->x + pRect->width; - vRect2.yBottom = pRect->y; + vRect.xLeft = pRect->x; + vRect.yTop = pRect->y + pRect->height; + vRect.xRight = pRect->x + pRect->width; + vRect.yBottom = pRect->y; } else { - ::WinQueryWindowRect(GetHwnd(), &vRect2); - ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect); - vRect2.yBottom += vRect.yTop - vRect.yBottom; - ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect); - vRect2.xRight -= vRect.xRight - vRect.xLeft; - - } - if (pRect) - ::WinScrollWindow( GetHwnd() - ,(LONG)nDx - ,(LONG)nDy - ,&vRect2 - ,NULL - ,NULLHANDLE - ,NULL - ,SW_INVALIDATERGN - ); - else - ::WinScrollWindow( GetHwnd() - ,nDx - ,nDy - ,NULL - ,NULL - ,NULLHANDLE - ,NULL - ,SW_INVALIDATERGN - ); - - // - // Move the children - wxWindowList::Node* pCurrent = GetChildren().GetFirst(); - SWP vSwp; - - while (pCurrent) - { - wxWindow* pChildWin = pCurrent->GetData(); - - if (pChildWin->GetHWND() != NULLHANDLE) - { - ::WinQueryWindowPos(pChildWin->GetHWND(), &vSwp); - ::WinQueryWindowRect(pChildWin->GetHWND(), &vRect); - if (pChildWin->GetHWND() == m_hWndScrollBarVert || - pChildWin->GetHWND() == m_hWndScrollBarHorz) - { - ::WinSetWindowPos( pChildWin->GetHWND() - ,HWND_TOP - ,vSwp.x + nDx - ,vSwp.y + nDy - ,0 - ,0 - ,SWP_MOVE | SWP_SHOW | SWP_ZORDER - ); - } - else - { - ::WinSetWindowPos( pChildWin->GetHWND() - ,HWND_BOTTOM - ,vSwp.x + nDx - ,vSwp.y + nDy - ,0 - ,0 - ,SWP_MOVE | SWP_ZORDER - ); - ::WinInvalidateRect(pChildWin->GetHWND(), &vRect, FALSE); - } - } - pCurrent = pCurrent->GetNext(); + ::WinQueryWindowRect(GetHwnd(), &vRect); } + nDy *= -1; // flip the sign of Dy as OS/2 is opposite Windows. + ::WinScrollWindow( GetHwnd() + ,(LONG)nDx + ,(LONG)nDy + ,&vRect + ,&vRect + ,NULLHANDLE + ,NULL + ,SW_SCROLLCHILDREN | SW_INVALIDATERGN + ); + Refresh(); } // end of wxWindowOS2::ScrollWindow // --------------------------------------------------------------------------- @@ -1047,9 +988,20 @@ void wxWindowOS2::SubclassWin( { HWND hwnd = (HWND)hWnd; - wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") ); wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") ); - m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc); + wxAssociateWinWithHandle( hWnd + ,(wxWindow*)this + ); + if (!wxCheckWindowWndProc( hWnd + ,(WXFARPROC)wxWndProc + )) + { + m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc); + } + else + { + m_fnOldWndProc = (WXFARPROC)NULL; + } } // end of wxWindowOS2::SubclassWin void wxWindowOS2::UnsubclassWin() @@ -1086,6 +1038,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 // @@ -1192,43 +1207,6 @@ WXDWORD wxWindowOS2::Determine3DEffects( return dwStyle; } // end of wxWindowOS2::Determine3DEffects -#if WXWIN_COMPATIBILITY -void wxWindowOS2::OnCommand( - wxWindow& rWin -, wxCommandEvent& rEvent -) -{ - if (GetEventHandler()->ProcessEvent(rEvent)) - return; - if (m_parent) - m_parent->GetEventHandler()->OnCommand( rWin - ,rEvent - ); -} // end of wxWindowOS2::OnCommand - -wxObject* wxWindowOS2::GetChild( - int nNumber -) const -{ - // - // Return a pointer to the Nth object in the Panel - // - wxNode* pNode = GetChildren().First(); - int n = nNumber; - - while (pNode && n--) - pNode = pNode->Next(); - if (pNode) - { - wxObject* pObj = (wxObject*)pNode->Data(); - return(pObj); - } - else - return NULL; -} // end of wxWindowOS2::GetChild - -#endif // WXWIN_COMPATIBILITY - // // Setup background and foreground colours correctly // @@ -1279,7 +1257,8 @@ void wxWindowOS2::OnIdle( (void)GetEventHandler()->ProcessEvent(rEvent); } } - UpdateWindowUI(); + if (wxUpdateUIEvent::CanUpdate(this)) + UpdateWindowUI(wxUPDATE_UI_FROMIDLE); } // end of wxWindowOS2::OnIdle // @@ -1299,17 +1278,6 @@ bool wxWindowOS2::Reparent( return TRUE; } // end of wxWindowOS2::Reparent -void wxWindowOS2::Clear() -{ - wxClientDC vDc((wxWindow*)this); - wxBrush vBrush( GetBackgroundColour() - ,wxSOLID - ); - - vDc.SetBackground(vBrush); - vDc.Clear(); -} // end of wxWindowOS2::Clear - void wxWindowOS2::Update() { ::WinUpdateWindow(GetHwnd()); @@ -1353,6 +1321,10 @@ void wxWindowOS2::Refresh( } else ::WinInvalidateRect(hWnd, NULL, bEraseBack); + if (m_hWndScrollBarHorz != NULLHANDLE) + ::WinInvalidateRect(m_hWndScrollBarHorz, NULL, TRUE); + if (m_hWndScrollBarVert != NULLHANDLE) + ::WinInvalidateRect(m_hWndScrollBarVert, NULL, TRUE); } } // end of wxWindowOS2::Refresh @@ -1365,14 +1337,7 @@ void wxWindowOS2::SetDropTarget( wxDropTarget* pDropTarget ) { - if (m_dropTarget != 0) - { - m_dropTarget->Revoke(m_hWnd); - delete m_dropTarget; - } m_dropTarget = pDropTarget; - if (m_dropTarget != 0) - m_dropTarget->Register(m_hWnd); } // end of wxWindowOS2::SetDropTarget #endif @@ -1527,10 +1492,65 @@ void wxWindowOS2::DoGetClientSize( RECTL vRect; ::WinQueryWindowRect(hWnd, &vRect); + if (IsKindOf(CLASSINFO(wxDialog))) + { + RECTL vTitle; + HWND hWndTitle; + // + // For a Dialog we have to explicitly request the client portion. + // For a Frame the hWnd IS the client window + // + hWndTitle = ::WinWindowFromID(hWnd, FID_TITLEBAR); + if (::WinQueryWindowRect(hWndTitle, &vTitle)) + { + if (vTitle.yTop - vTitle.yBottom == 0) + { + // + // Dialog has not been created yet, use a default + // + vTitle.yTop = 20; + } + vRect.yTop -= (vTitle.yTop - vTitle.yBottom); + } + + ULONG uStyle = ::WinQueryWindowULong(hWnd, QWL_STYLE); + + // + // Deal with borders + // + if (uStyle & FCF_DLGBORDER) + { + vRect.xLeft += 4; + vRect.xRight -= 4; + vRect.yTop -= 4; + vRect.yBottom += 4; + } + else if (uStyle & FCF_SIZEBORDER) + { + vRect.xLeft += 4; + vRect.xRight -= 4; + vRect.yTop -= 4; + vRect.yBottom += 4; + } + else if (uStyle & FCF_BORDER) + { + vRect.xLeft += 2; + vRect.xRight -= 2; + vRect.yTop -= 2; + vRect.yBottom += 2; + } + else // make some kind of adjustment or top sizers ram into the titlebar! + { + vRect.xLeft += 3; + vRect.xRight -= 3; + vRect.yTop -= 3; + vRect.yBottom += 3; + } + } if (pWidth) - *pWidth = vRect.xRight; + *pWidth = vRect.xRight - vRect.xLeft; if (pHeight) - *pHeight = vRect.yTop; + *pHeight = vRect.yTop - vRect.yBottom; } // end of wxWindowOS2::DoGetClientSize void wxWindowOS2::DoMoveWindow( @@ -1557,14 +1577,142 @@ void wxWindowOS2::DoMoveWindow( ::WinQueryWindowRect(HWND_DESKTOP, &vRect); nY = vRect.yTop - (nY + nHeight); } + + // + // In the case of a frame whose client is sized, the client cannot be + // large than its parent frame minus its borders! This usually happens + // when using an autosizer to size a frame to precisely hold client + // controls as in the notebook sample. + // + // In this case, we may need to resize both a frame and its client so we + // need a quick calc of the frame border size, then if the frame + // (less its borders) is smaller than the client, size the frame to + // encompass the client with the appropriate border size. + // + if (IsKindOf(CLASSINFO(wxFrame))) + { + RECTL vFRect; + HWND hWndFrame; + int nWidthFrameDelta = 0; + int nHeightFrameDelta = 0; + int nHeightFrame = 0; + int nWidthFrame = 0; + ULONG ulFLag = SWP_MOVE; + wxFrame* pFrame; + + pFrame = wxDynamicCast(this, wxFrame); + hWndFrame = pFrame->GetFrame(); + ::WinQueryWindowRect(hWndFrame, &vRect); + ::WinMapWindowPoints(hWndFrame, HWND_DESKTOP, (PPOINTL)&vRect, 2); + vFRect = vRect; + ::WinCalcFrameRect(hWndFrame, &vRect, TRUE); + nWidthFrameDelta = ((vRect.xLeft - vFRect.xLeft) + (vFRect.xRight - vRect.xRight)); + nHeightFrameDelta = ((vRect.yBottom - vFRect.yBottom) + (vFRect.yTop - vRect.yTop)); + nWidthFrame = vFRect.xRight - vFRect.xLeft; + nHeightFrame = vFRect.yTop - vFRect.yBottom; + + if (nWidth == vFRect.xRight - vFRect.xLeft && + nHeight == vFRect.yTop - vFRect.yBottom) + { + // + // In this case the caller is not aware of OS/2's need to size both + // the frame and it's client and is really only moving the window, + // not resizeing it. So move the frame, and back off the sizes + // for a proper client fit. + // + ::WinSetWindowPos( hWndFrame + ,HWND_TOP + ,(LONG)nX - (vRect.xLeft - vFRect.xLeft) + ,(LONG)nY - (vRect.yBottom - vFRect.yBottom) + ,(LONG)0 + ,(LONG)0 + ,SWP_MOVE + ); + nX += (vRect.xLeft - vFRect.xLeft); + nY += (vRect.yBottom - vFRect.yBottom); + nWidth -= nWidthFrameDelta; + nHeight -= nHeightFrameDelta; + } + else + { + if (nWidth > nWidthFrame - nHeightFrameDelta || + nHeight > nHeightFrame - nHeightFrameDelta) + { + ::WinSetWindowPos( hWndFrame + ,HWND_TOP + ,(LONG)nX - (vRect.xLeft - vFRect.xLeft) + ,(LONG)nY - (vRect.yBottom - vFRect.yBottom) + ,(LONG)nWidth + nWidthFrameDelta + ,(LONG)nHeight + nHeightFrameDelta + ,SWP_MOVE | SWP_SIZE + ); + } + } + } + ::WinSetWindowPos( GetHwnd() ,HWND_TOP ,(LONG)nX ,(LONG)nY ,(LONG)nWidth ,(LONG)nHeight - ,SWP_ZORDER | SWP_SIZE | SWP_MOVE | SWP_SHOW + ,SWP_SIZE | SWP_MOVE ); + 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 // @@ -1606,19 +1754,6 @@ void wxWindowOS2::DoSetSize( int nY2 = nY; wxWindow* pParent = (wxWindow*)GetParent(); - if (pParent && !IsKindOf(CLASSINFO(wxDialog))) - { - int nOS2Height = GetOS2ParentHeight(pParent); - - nY2 = nOS2Height - (nY2 + nHeight); - } - else - { - RECTL vRect; - - ::WinQueryWindowRect(HWND_DESKTOP, &vRect); - nY2 = vRect.yTop - (nY2 + nHeight); - } if (nX == nCurrentX && nY2 == nCurrentY && nWidth == nCurrentWidth && nHeight == nCurrentHeight) { @@ -1677,34 +1812,61 @@ void wxWindowOS2::DoSetClientSize( , int nHeight ) { - wxWindow* pParent = GetParent(); - HWND hWnd = GetHwnd(); - HWND hParentWnd = (HWND)0; POINTL vPoint; - RECTL vRect; - RECTL vRect2; - RECTL vRect3; - HWND hClientWnd = (HWND)0; + int nActualWidth; + int nActualHeight; + wxWindow* pParent = (wxWindow*)GetParent(); + HWND hParentWnd = (HWND)0; - hClientWnd = ::WinWindowFromID(hWnd, FID_CLIENT); - ::WinQueryWindowRect(hClientWnd, &vRect2); - ::WinQueryWindowRect(hWnd, &vRect); - ::WinQueryWindowRect(hParentWnd, &vRect3); + if (pParent) + hParentWnd = (HWND)pParent->GetHWND(); - int nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth; - int nActualHeight = vRect2.yTop - vRect2.yBottom - vRect.yTop + nHeight; + if (IsKindOf(CLASSINFO(wxFrame))) + { + wxFrame* pFrame = wxDynamicCast(this, wxFrame); + HWND hFrame = pFrame->GetFrame(); + RECTL vRect; + RECTL vRect2; + RECTL vRect3; - vPoint.x = vRect2.xLeft; - vPoint.y = vRect2.yBottom; - if (pParent) + ::WinQueryWindowRect(GetHwnd(), &vRect2); + ::WinQueryWindowRect(hFrame, &vRect); + ::WinQueryWindowRect(hParentWnd, &vRect3); + nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth; + nActualHeight = vRect2.yTop - vRect2.yBottom - vRect.yTop + nHeight; + + vPoint.x = vRect2.xLeft; + vPoint.y = vRect2.yBottom; + if (pParent) + { + vPoint.x -= vRect3.xLeft; + vPoint.y -= vRect3.yBottom; + } + } + else { - vPoint.x -= vRect3.xLeft; - vPoint.y -= vRect3.yBottom; + int nX; + int nY; + + GetPosition(&nX, &nY); + nActualWidth = nWidth; + nActualHeight = nHeight; + + vPoint.x = nX; + vPoint.y = nY; } + DoMoveWindow( vPoint.x + ,vPoint.y + ,nActualWidth + ,nActualHeight + ); - DoMoveWindow(vPoint.x, vPoint.y, nActualWidth, nActualHeight); + wxSizeEvent vEvent( wxSize( nWidth + ,nHeight + ) + ,m_windowId + ); - wxSizeEvent vEvent(wxSize(nWidth, nHeight), m_windowId); vEvent.SetEventObject(this); GetEventHandler()->ProcessEvent(vEvent); } // end of wxWindowOS2::DoSetClientSize @@ -1868,67 +2030,6 @@ bool wxWindowOS2::IsMouseInWindow() const return hWnd != NULL; } // end of wxWindowOS2::IsMouseInWindow -#if wxUSE_CARET && WXWIN_COMPATIBILITY -// --------------------------------------------------------------------------- -// Caret manipulation -// --------------------------------------------------------------------------- - -void wxWindowOS2::CreateCaret( - int nWidth -, int nHeight -) -{ - SetCaret(new wxCaret( this - ,nWidth - ,nHeight - )); -} // end of wxWindowOS2::CreateCaret - -void wxWindowOS2::CreateCaret( - const wxBitmap* pBitmap -) -{ - wxFAIL_MSG("not implemented"); -} // end of wxWindowOS2::CreateCaret - -void wxWindowOS2::ShowCaret( - bool bShow -) -{ - wxCHECK_RET( m_caret, "no caret to show" ); - - m_caret->Show(bShow); -} // end of wxWindowOS2::ShowCaret - -void wxWindowOS2::DestroyCaret() -{ - SetCaret(NULL); -} // end of wxWindowOS2::DestroyCaret - -void wxWindowOS2::SetCaretPos( - int nX -, int nY) -{ - wxCHECK_RET( m_caret, "no caret to move" ); - - m_caret->Move( nX - ,nY - ); -} // end of wxWindowOS2::SetCaretPos - -void wxWindowOS2::GetCaretPos( - int* pX -, int* pY -) const -{ - wxCHECK_RET( m_caret, "no caret to get position of" ); - - m_caret->GetPosition( pX - ,pY - ); -} // end of wxWindowOS2::GetCaretPos - -#endif //wxUSE_CARET // --------------------------------------------------------------------------- // popup menu @@ -1943,11 +2044,13 @@ static void wxYieldForCommandsOnly() // QMSG vMsg; - while (::WinPeekMsg(vHabmain, &vMsg, (HWND)0, WM_COMMAND, - WM_COMMAND,PM_REMOVE) && vMsg.msg != WM_QUIT) + while (::WinPeekMsg(vHabmain, &vMsg, (HWND)0, WM_COMMAND, WM_COMMAND, PM_REMOVE) + && vMsg.msg != WM_QUIT) { wxTheApp->DoMessage((WXMSG*)&vMsg); } + if (vMsg.msg == WM_QUIT) + ::WinPostMsg(NULL, WM_QUIT, 0, 0); } #endif // wxUSE_MENUS_NATIVE @@ -1958,9 +2061,10 @@ bool wxWindowOS2::DoPopupMenu( , int nY ) { - HWND hWnd = GetHwnd(); - HWND hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0; + HWND hWndOwner = GetHwnd(); + HWND hWndParent = GetHwnd(); HWND hMenu = GetHmenuOf(pMenu); + bool bIsWaiting = TRUE; pMenu->SetInvokingWindow(this); pMenu->UpdateUI(); @@ -1971,23 +2075,27 @@ bool wxWindowOS2::DoPopupMenu( wxCurrentPopupMenu = pMenu; ::WinPopupMenu( hWndParent - ,hWnd + ,hWndOwner ,hMenu ,nX ,nY ,0L - ,PU_MOUSEBUTTON2DOWN | PU_MOUSEBUTTON2 | PU_KEYBOARD + ,PU_HCONSTRAIN | PU_VCONSTRAIN | PU_MOUSEBUTTON1 | PU_KEYBOARD ); - // we need to do it righ now as otherwise the events are never going to be - // sent to wxCurrentPopupMenu from ;() - // - // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't - // help and we'd still need wxYieldForCommandsOnly() as the menu may be - // destroyed as soon as we return (it can be a local variable in the caller - // for example) and so we do need to process the event immediately - wxYieldForCommandsOnly(); - wxCurrentPopupMenu = NULL; + while(bIsWaiting) + { + QMSG vMsg; + BOOL bRc = ::WinGetMsg(vHabmain, &vMsg, HWND(NULL), 0, 0); + + if (vMsg.msg == WM_MENUEND || vMsg.msg == WM_COMMAND) + { + bIsWaiting = FALSE; + } + ::WinDispatchMsg(vHabmain, (PQMSG)&vMsg); + + } + wxCurrentPopupMenu = NULL; pMenu->SetInvokingWindow(NULL); return TRUE; } // end of wxWindowOS2::DoPopupMenu @@ -2136,6 +2244,14 @@ bool wxWindowOS2::OS2ProcessMessage( pBtn->OS2Command(BN_CLICKED, 0 /* unused */); return TRUE; } + else if (!IsTopLevel()) + { + // + // if not a top level window, let parent + // handle it + // + return FALSE; + } // else: but if it does not it makes sense to make // it work like a TAB - and that's what we do. // Note that Ctrl-Enter always works this way. @@ -2180,17 +2296,6 @@ bool wxWindowOS2::OS2ProcessMessage( pMsg = pMsg; // just shut up the compiler #endif // __WXUNIVERSAL__ -#if wxUSE_TOOLTIPS - if ( m_tooltip ) - { - // relay mouse move events to the tooltip control - QMSG* pQMsg = (QMSG*)pMsg; - - if (pQMsg->msg == WM_MOUSEMOVE ) - m_tooltip->RelayEvent(pMsg); - } -#endif // wxUSE_TOOLTIPS - return FALSE; } // end of wxWindowOS2::OS2ProcessMessage @@ -2206,6 +2311,14 @@ bool wxWindowOS2::OS2TranslateMessage( #endif //wxUSE_ACCEL } // end of wxWindowOS2::OS2TranslateMessage +bool wxWindowOS2::OS2ShouldPreProcessMessage( + WXMSG* pMsg +) +{ + // preprocess all messages by default + return TRUE; +} // end of wxWindowOS2::OS2ShouldPreProcessMessage + // --------------------------------------------------------------------------- // message params unpackers // --------------------------------------------------------------------------- @@ -2326,7 +2439,18 @@ MRESULT EXPENTRY wxWndProc( else { if (pWnd) + { rc = pWnd->OS2WindowProc(ulMsg, wParam, lParam); + if ( (pWnd->GetScrollBarHorz() != NULLHANDLE || + pWnd->GetScrollBarVert() != NULLHANDLE) && + ulMsg == WM_PAINT) + { + if (pWnd->GetScrollBarHorz() != NULLHANDLE) + ::WinInvalidateRect(pWnd->GetScrollBarHorz(), NULL, TRUE); + if (pWnd->GetScrollBarVert() != NULLHANDLE) + ::WinInvalidateRect(pWnd->GetScrollBarVert(), NULL, TRUE); + } + } else rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam); } @@ -2392,6 +2516,44 @@ MRESULT wxWindowOS2::OS2WindowProc( ); break; + case WM_WINDOWPOSCHANGED: + + // + // Dialogs under OS/2 do not get WM_SIZE events at all. + // Instead they get this, which can function much like WM_SIZE + // PSWP contains the new sizes and positioning, PSWP+1 the old + // We use this because ADJUSTWINDOWPOS comes BEFORE the new + // position is added and our auto layout does a WinQueryWindowRect + // to get the CURRENT client size. That is the size used to position + // child controls, so we need to already be sized + // in order to get the child controls positoned properly. + // + if (IsKindOf(CLASSINFO(wxDialog)) || IsKindOf(CLASSINFO(wxFrame))) + { + PSWP pSwp = (PSWP)PVOIDFROMMP(wParam); + PSWP pSwp2 = pSwp++; + + if (!(pSwp->cx == pSwp2->cx && + pSwp->cy == pSwp2->cy)) + bProcessed = HandleSize( pSwp->cx + ,pSwp->cy + ,(WXUINT)lParam + ); + if (IsKindOf(CLASSINFO(wxFrame))) + { + wxFrame* pFrame = wxDynamicCast(this, wxFrame); + + if (pFrame) + { + if (pFrame->GetStatusBar()) + pFrame->PositionStatusBar(); + if (pFrame->GetToolBar()) + pFrame->PositionToolBar(); + } + } + } + break; + case WM_ACTIVATE: { WXWORD wState; @@ -2455,12 +2617,43 @@ MRESULT wxWindowOS2::OS2WindowProc( case WM_BUTTON3MOTIONEND: case WM_BUTTON3MOTIONSTART: { - short x = LOWORD(lParam); - short y = HIWORD(lParam); + 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 + ); + if (!pWin->IsOfStandardClass()) + { + if (uMsg == WM_BUTTON1DOWN && pWin->AcceptsFocus() ) + pWin->SetFocus(); + } + bProcessed = pWin->HandleMouseEvent( uMsg + ,nX + ,nY + ,(WXUINT)SHORT1FROMMP(wParam) + ); + } } break; + case WM_SYSCOMMAND: bProcessed = HandleSysCommand(wParam, lParam); break; @@ -2490,8 +2683,9 @@ MRESULT wxWindowOS2::OS2WindowProc( } else { - bProcessed = OS2OnMeasureItem(nIdCtrl, - (WXMEASUREITEMSTRUCT *)lParam); + return MRFROMLONG(OS2OnMeasureItem( nIdCtrl + ,(WXMEASUREITEMSTRUCT *)lParam + )); } if ( bProcessed ) @@ -2500,10 +2694,13 @@ MRESULT wxWindowOS2::OS2WindowProc( break; case WM_QUERYDLGCODE: - if ( m_lDlgCode ) + if (!IsOfStandardClass()) { - mResult = (MRESULT)m_lDlgCode; - bProcessed = TRUE; + if ( m_lDlgCode ) + { + mResult = (MRESULT)m_lDlgCode; + bProcessed = TRUE; + } } // //else: get the dlg code from the DefWindowProc() @@ -2521,17 +2718,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); @@ -2539,18 +2737,20 @@ 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: - case VK_SPACE: case VK_ENTER: case VK_BACKSPACE: case VK_TAB: @@ -2560,19 +2760,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; + } } } } @@ -2590,18 +2799,169 @@ MRESULT wxWindowOS2::OS2WindowProc( ,&hWnd ); - bProcessed = OS2OnScroll( uMsg == WM_HSCROLL ? wxHORIZONTAL - : wxVERTICAL - ,wCode - ,wPos - ,hWnd - ); - } - break; + bProcessed = OS2OnScroll( uMsg == WM_HSCROLL ? wxHORIZONTAL + : wxVERTICAL + ,wCode + ,wPos + ,hWnd + ); + } + break; + + case WM_CONTROL: + switch(SHORT2FROMMP(wParam)) + { + case BN_PAINT: + { + HWND hWnd = ::WinWindowFromID((HWND)GetHwnd(), SHORT1FROMMP(wParam)); + wxWindowOS2* pWin = wxFindWinFromHandle(hWnd); + + if (!pWin) + { + bProcessed = FALSE; + break; + } + if (pWin->IsKindOf(CLASSINFO(wxBitmapButton))) + { + wxBitmapButton* pBitmapButton = wxDynamicCast(pWin, wxBitmapButton); + + pBitmapButton->OS2OnDraw((WXDRAWITEMSTRUCT *)lParam); + } + return 0; + } + break; + + case BKN_PAGESELECTEDPENDING: + { + PPAGESELECTNOTIFY pPage = (PPAGESELECTNOTIFY)lParam; + + if ((pPage->ulPageIdNew != pPage->ulPageIdCur) && + (pPage->ulPageIdNew > 0L && pPage->ulPageIdCur > 0L)) + { + wxWindowOS2* pWin = wxFindWinFromHandle(pPage->hwndBook); + wxNotebookEvent vEvent( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED + ,(int)SHORT1FROMMP(wParam) + ,(int)pPage->ulPageIdNew + ,(int)pPage->ulPageIdCur + ); + if (!pWin) + { + bProcessed = FALSE; + break; + } + if (pWin->IsKindOf(CLASSINFO(wxNotebook))) + { + wxNotebook* pNotebook = wxDynamicCast(pWin, wxNotebook); + + vEvent.SetEventObject(pWin); + pNotebook->OnSelChange(vEvent); + bProcessed = TRUE; + } + else + bProcessed = FALSE; + } + else + bProcessed = FALSE; + } + break; + + case BN_CLICKED: // Dups as LN_SELECT and CBN_LBSELECT + { + HWND hWnd = ::WinWindowFromID((HWND)GetHwnd(), SHORT1FROMMP(wParam)); + wxWindowOS2* pWin = wxFindWinFromHandle(hWnd); + + if (!pWin) + { + bProcessed = FALSE; + break; + } + // + // Simulate a WM_COMMAND here, as wxWindows expects all control + // button clicks to generate WM_COMMAND msgs, not WM_CONTROL + // + if (pWin->IsKindOf(CLASSINFO(wxRadioBox))) + { + wxRadioBox* pRadioBox = wxDynamicCast(pWin, wxRadioBox); + + pRadioBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + } + if (pWin->IsKindOf(CLASSINFO(wxRadioButton))) + { + wxRadioButton* pRadioButton = wxDynamicCast(pWin, wxRadioButton); + + pRadioButton->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + } + if (pWin->IsKindOf(CLASSINFO(wxCheckBox))) + { + wxCheckBox* pCheckBox = wxDynamicCast(pWin, wxCheckBox); + + pCheckBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + } + if (pWin->IsKindOf(CLASSINFO(wxListBox))) + { + wxListBox* pListBox = wxDynamicCast(pWin, wxListBox); + + pListBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + if (pListBox->GetWindowStyle() & wxLB_OWNERDRAW) + Refresh(); + } + if (pWin->IsKindOf(CLASSINFO(wxComboBox))) + { + wxComboBox* pComboBox = wxDynamicCast(pWin, wxComboBox); + + pComboBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + } + return 0; + } + break; + + case LN_ENTER: /* dups as CBN_EFCHANGE */ + { + HWND hWnd = HWNDFROMMP(lParam); + wxWindowOS2* pWin = wxFindWinFromHandle(hWnd); + + if (!pWin) + { + bProcessed = FALSE; + break; + } + // + // Simulate a WM_COMMAND here, as wxWindows expects all control + // button clicks to generate WM_COMMAND msgs, not WM_CONTROL + // + if (pWin->IsKindOf(CLASSINFO(wxListBox))) + { + wxListBox* pListBox = wxDynamicCast(pWin, wxListBox); + + pListBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + if (pListBox->GetWindowStyle() & wxLB_OWNERDRAW) + Refresh(); + + } + if (pWin->IsKindOf(CLASSINFO(wxComboBox))) + { + wxComboBox* pComboBox = wxDynamicCast(pWin, wxComboBox); + + pComboBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + } + return 0; + } + break; - case WM_CONTROL: - switch(SHORT2FROMMP(wParam)) - { case SPBN_UPARROW: case SPBN_DOWNARROW: case SPBN_CHANGE: @@ -2630,6 +2990,11 @@ MRESULT wxWindowOS2::OS2WindowProc( HWND hWnd = ::WinWindowFromID(GetHWND(), SHORT1FROMMP(wParam)); wxWindowOS2* pChild = wxFindWinFromHandle(hWnd); + if (!pChild) + { + bProcessed = FALSE; + break; + } if (pChild->IsKindOf(CLASSINFO(wxSlider))) bProcessed = OS2OnScroll( wxVERTICAL ,(int)SHORT2FROMMP(wParam) @@ -2677,7 +3042,7 @@ MRESULT wxWindowOS2::OS2WindowProc( if ( bProcessed ) { // we never set focus from here - mResult = FALSE; + mResult = (MRESULT)FALSE; } break; @@ -2725,6 +3090,8 @@ MRESULT wxWindowOS2::OS2WindowProc( return mResult; } // end of wxWindowOS2::OS2WindowProc +#ifndef __EMX__ +// clashes with wxDlgProc in toplevel.cpp? // // Dialog window proc // @@ -2751,6 +3118,7 @@ MRESULT wxDlgProc( return (MRESULT)0; } } // end of wxDlgProc +#endif wxWindow* wxFindWinFromHandle( WXHWND hWnd @@ -2819,36 +3187,37 @@ bool wxWindowOS2::OS2GetCreateWindowCoords( ) const { bool bNonDefault = FALSE; + static const int DEFAULT_Y = 200; + static const int DEFAULT_H = 250; if (rPos.x == -1) { - // - // If set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can - // just as well set it to CW_USEDEFAULT as well rnX = rnY = CW_USEDEFAULT; } else { rnX = rPos.x; - rnY = rPos.y == -1 ? CW_USEDEFAULT : rPos.y; + rnY = rPos.y == -1 ? DEFAULT_Y : rPos.y; bNonDefault = TRUE; } if (rSize.x == -1) { - // - // As abobe, h is not used at all in this case anyhow - // rnWidth = rnHeight = CW_USEDEFAULT; } else { rnWidth = rSize.x; - rnHeight = rSize.y == -1 ? CW_USEDEFAULT : rSize.y; + rnHeight = rSize.y == -1 ? DEFAULT_H : rSize.y; bNonDefault = TRUE; } return bNonDefault; } // end of wxWindowOS2::OS2GetCreateWindowCoords +WXHWND wxWindowOS2::OS2GetParent() const +{ + return m_parent ? m_parent->GetHWND() : NULL; +} + bool wxWindowOS2::OS2Create( PSZ zClass , const char* zTitle @@ -2881,31 +3250,6 @@ bool wxWindowOS2::OS2Create( ,nHeight ); - if (GetWindowStyleFlag() & wxPOPUP_WINDOW) - hParent = HWND_DESKTOP; - else - { - if ((bIsChild || HasFlag(wxFRAME_TOOL_WINDOW)) && pParent ) - { - // - // This is either a normal child window or a top level window with - // wxFRAME_TOOL_WINDOW style (see below) - // - hParent = GetHwndOf(pParent); - } - else - { - // - // This is either a window for which no parent was specified (not - // much we can do then) or a frame without wxFRAME_TOOL_WINDOW - // style: we should use NULL parent HWND for it or it would be - // always on top of its parent which is not what we usually want - // (in fact, we only want it for frames with the special - // wxFRAME_TOOL_WINDOW as above) - // - hParent = NULL; - } - } if (bIsChild) { lControlId = GetId(); @@ -2923,46 +3267,20 @@ 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 (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 : "" - ,(ULONG)dwStyle - ,(LONG)0L - ,(LONG)0L - ,(LONG)0L - ,(LONG)0L - ,NULLHANDLE - ,HWND_TOP - ,(ULONG)lControlId - ,pCtlData - ,NULL - ); + m_hWnd = (WXHWND)::WinCreateWindow( (HWND)OS2GetParent() + ,(PSZ)sClassName.c_str() + ,(PSZ)zTitle ? zTitle : "" + ,(ULONG)dwStyle + ,(LONG)0L + ,(LONG)0L + ,(LONG)0L + ,(LONG)0L + ,NULLHANDLE + ,HWND_TOP + ,(ULONG)lControlId + ,pCtlData + ,NULL + ); if (!m_hWnd) { vError = ::WinGetLastError(wxGetInstance()); @@ -2971,6 +3289,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 @@ -3002,7 +3336,7 @@ bool wxWindowOS2::HandleCreate( bool wxWindowOS2::HandleDestroy() { wxWindowDestroyEvent vEvent((wxWindow*)this); - + vEvent.SetId(GetId()); (void)GetEventHandler()->ProcessEvent(vEvent); // @@ -3011,7 +3345,6 @@ bool wxWindowOS2::HandleDestroy() #if wxUSE_DRAG_AND_DROP if (m_dropTarget != NULL) { - m_dropTarget->Revoke(m_hWnd); delete m_dropTarget; m_dropTarget = NULL; } @@ -3050,6 +3383,13 @@ bool wxWindowOS2::HandleSetFocus( WXHWND WXUNUSED(hWnd) ) { + // + // Notify the parent keeping track of focus for the kbd navigation + // purposes that we got it + // + wxChildFocusEvent vEventFocus((wxWindow *)this); + (void)GetEventHandler()->ProcessEvent(vEventFocus); + #if wxUSE_CARET // // Deal with caret @@ -3076,7 +3416,7 @@ bool wxWindowOS2::HandleSetFocus( } // end of wxWindowOS2::HandleSetFocus bool wxWindowOS2::HandleKillFocus( - WXHWND WXUNUSED(hWnd) + WXHWND hWnd ) { #if wxUSE_CARET @@ -3089,11 +3429,38 @@ bool wxWindowOS2::HandleKillFocus( } #endif // wxUSE_CARET +#if wxUSE_TEXTCTRL + // + // If it's a wxTextCtrl don't send the event as it will be done + // after the control gets to process it. + // + wxTextCtrl* pCtrl = wxDynamicCastThis(wxTextCtrl); + + if (pCtrl) + { + return FALSE; + } +#endif + + // + // Don't send the event when in the process of being deleted. This can + // only cause problems if the event handler tries to access the object. + // + if ( m_isBeingDeleted ) + { + return FALSE; + } + wxFocusEvent vEvent( wxEVT_KILL_FOCUS ,m_windowId ); vEvent.SetEventObject(this); + + // + // wxFindWinFromHandle() may return NULL, it is ok + // + vEvent.SetWindow(wxFindWinFromHandle(hWnd)); return GetEventHandler()->ProcessEvent(vEvent); } // end of wxWindowOS2::HandleKillFocus @@ -3302,7 +3669,7 @@ bool wxWindowOS2::OS2OnDrawItem( return FALSE; } // end of wxWindowOS2::OS2OnDrawItem -bool wxWindowOS2::OS2OnMeasureItem( +long wxWindowOS2::OS2OnMeasureItem( int lId , WXMEASUREITEMSTRUCT* pItemStruct ) @@ -3328,20 +3695,26 @@ bool wxWindowOS2::OS2OnMeasureItem( ,&nHeight )) { + MRESULT mRc; + pMeasureStruct->rclItem.xRight = nWidth; pMeasureStruct->rclItem.xLeft = 0L; pMeasureStruct->rclItem.yTop = nHeight; pMeasureStruct->rclItem.yBottom = 0L; - return TRUE; + mRc = MRFROM2SHORT(nHeight, nWidth); + return LONGFROMMR(mRc); } - return FALSE; + return 0L; } } wxWindow* pItem = FindItem(lId); if (pItem && pItem->IsKindOf(CLASSINFO(wxControl))) { - return ((wxControl *)pItem)->OS2OnMeasure(pItemStruct); + OWNERITEM vItem; + + vItem.idItem = (LONG)pItemStruct; + return ((wxControl *)pItem)->OS2OnMeasure((WXMEASUREITEMSTRUCT*)&vItem); } #else lId = lId; @@ -3428,6 +3801,21 @@ void wxWindowOS2::OnSysColourChanged( // painting // --------------------------------------------------------------------------- +void wxWindow::OnPaint ( + wxPaintEvent& rEvent +) +{ + HDC hDC = (HDC)wxPaintDC::FindDCInCache((wxWindow*) rEvent.GetEventObject()); + + if (hDC != 0) + { + OS2DefWindowProc( (WXUINT)WM_PAINT + ,(WXWPARAM)hDC + ,(WXLPARAM)0 + ); + } +} // end of wxWindow::OnPaint + bool wxWindowOS2::HandlePaint() { HRGN hRgn; @@ -3452,7 +3840,111 @@ 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. + // For decorative panels that typically have no children, we draw + // borders. + // + 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 + ); + if (::WinIsWindowVisible(GetHWND())) + ::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; + } + else if (!bProcessed && + IsKindOf(CLASSINFO(wxPanel)) + ) + { + // + // Panel with children, usually fills a frame client so no borders. + // + 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 + ); + + if (::WinIsWindowVisible(GetHWND())) + ::WinFillRect(hPS, &vRect, GetBackgroundColour().GetPixel()); + } + ::WinEndPaint(hPS); + bProcessed = TRUE; + } + return bProcessed; } // end of wxWindowOS2::HandlePaint bool wxWindowOS2::HandleEraseBkgnd( @@ -3637,6 +4129,7 @@ void wxWindowOS2::InitMouseEvent( rEvent.m_rightDown = ((uFlags & VK_BUTTON2) != 0); rEvent.SetTimestamp(s_currentMsg.time); rEvent.m_eventObject = this; + rEvent.SetId(GetId()); #if wxUSE_MOUSEEVENT_HACK m_lastMouseX = nX; @@ -3652,6 +4145,8 @@ bool wxWindowOS2::HandleMouseEvent( , WXUINT uFlags ) { + bool bProcessed = FALSE; + // // The mouse events take consecutive IDs from WM_MOUSEFIRST to // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST @@ -3680,6 +4175,18 @@ bool wxWindowOS2::HandleMouseEvent( ,uFlags ); + bProcessed = GetEventHandler()->ProcessEvent(vEvent); + if (!bProcessed) + { + HPOINTER hPtr = ::WinQuerySysPointer(HWND_DESKTOP, SPTR_WAIT, FALSE); + HPOINTER hCursor = (HPOINTER)GetCursor().GetHCURSOR(); + + if (hCursor != NULLHANDLE) + { + ::WinSetPointer(HWND_DESKTOP, hCursor); + bProcessed = TRUE; + } + } return GetEventHandler()->ProcessEvent(vEvent); } // end of wxWindowOS2::HandleMouseEvent @@ -3725,6 +4232,7 @@ wxKeyEvent wxWindowOS2::CreateKeyEvent( wxEventType eType , int nId , WXLPARAM lParam +, WXWPARAM wParam ) const { wxKeyEvent vEvent(eType); @@ -3736,6 +4244,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); // @@ -3763,7 +4273,7 @@ wxKeyEvent wxWindowOS2::CreateKeyEvent( // WM_KEYDOWN one // bool wxWindowOS2::HandleChar( - WXDWORD wParam + WXWPARAM wParam , WXLPARAM lParam , bool isASCII ) @@ -3771,12 +4281,24 @@ 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. + // If 1 -> 26, translate to either special keycode or just set + // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and + // ControlDown() == TRUE. // - vId = wParam; + vId = SHORT1FROMMP(lParam); if ((vId > 0) && (vId < 27)) { switch (vId) @@ -3795,57 +4317,50 @@ bool wxWindowOS2::HandleChar( default: bCtrlDown = TRUE; - vId = vId + 96; + break; } } } - 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)SHORT2FROMMP(lParam)); + 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)SHORT2FROMMP(lParam)); if (!nId) { // // Normal ASCII char // - nId = wParam; + nId = SHORT1FROMMP(lParam); } if (nId != -1) { wxKeyEvent vEvent(CreateKeyEvent( wxEVT_KEY_DOWN ,nId - ,lParam + ,(MPARAM)lParam + ,(MPARAM)wParam )); if (GetEventHandler()->ProcessEvent(vEvent)) @@ -3857,18 +4372,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)SHORT2FROMMP(lParam)); if (!nId) { // // Normal ASCII char // - nId = wParam; + nId = (int)wParam; } if (nId != -1) @@ -3876,6 +4391,7 @@ bool wxWindowOS2::HandleKeyUp( wxKeyEvent vEvent(CreateKeyEvent( wxEVT_KEY_UP ,nId ,lParam + ,wParam )); if (GetEventHandler()->ProcessEvent(vEvent)) @@ -3953,63 +4469,75 @@ void wxWindowOS2::MoveChildren( int nDiff ) { - SWP vSwp; - - for (wxWindowList::Node* pNode = GetChildren().GetFirst(); - pNode; - pNode = pNode->GetNext()) + // + // We want to handle top levels ourself, manually + // + if (!IsTopLevel() && GetAutoLayout()) + { + Layout(); + } + else { - wxWindow* pWin = pNode->GetData(); + SWP vSwp; - ::WinQueryWindowPos( GetHwndOf(pWin) - ,&vSwp - ); - if (pWin->IsKindOf(CLASSINFO(wxControl))) + for (wxWindowList::Node* pNode = GetChildren().GetFirst(); + pNode; + pNode = pNode->GetNext()) { - wxControl* pCtrl; + wxWindow* pWin = pNode->GetData(); - // - // Must deal with controls that have margins like ENTRYFIELD. The SWP - // struct of such a control will have and origin offset from its intended - // position by the width of the margins. - // - pCtrl = wxDynamicCast(pWin, wxControl); - vSwp.y -= pCtrl->GetYComp(); - vSwp.x -= pCtrl->GetXComp(); - } - ::WinSetWindowPos( GetHwndOf(pWin) - ,HWND_TOP - ,vSwp.x - ,vSwp.y - nDiff - ,vSwp.cx - ,vSwp.cy - ,SWP_MOVE - ); - if (pWin->IsKindOf(CLASSINFO(wxRadioBox))) - { - wxRadioBox* pRadioBox; - - pRadioBox = wxDynamicCast(pWin, wxRadioBox); - pRadioBox->AdjustButtons( (int)vSwp.x - ,(int)vSwp.y - nDiff - ,(int)vSwp.cx - ,(int)vSwp.cy - ,pRadioBox->GetSizeFlags() - ); - } - if (pWin->IsKindOf(CLASSINFO(wxSlider))) - { - wxSlider* pSlider; - - pSlider = wxDynamicCast(pWin, wxSlider); - pSlider->AdjustSubControls( (int)vSwp.x - ,(int)vSwp.y - nDiff - ,(int)vSwp.cx - ,(int)vSwp.cy - ,(int)pSlider->GetSizeFlags() - ); + ::WinQueryWindowPos( GetHwndOf(pWin) + ,&vSwp + ); + if (pWin->IsKindOf(CLASSINFO(wxControl))) + { + wxControl* pCtrl; + + // + // Must deal with controls that have margins like ENTRYFIELD. The SWP + // struct of such a control will have and origin offset from its intended + // position by the width of the margins. + // + pCtrl = wxDynamicCast(pWin, wxControl); + vSwp.y -= pCtrl->GetYComp(); + vSwp.x -= pCtrl->GetXComp(); + } + ::WinSetWindowPos( GetHwndOf(pWin) + ,HWND_TOP + ,vSwp.x + ,vSwp.y - nDiff + ,vSwp.cx + ,vSwp.cy + ,SWP_MOVE | SWP_SHOW | SWP_ZORDER + ); + ::WinQueryWindowPos(GetHwndOf(pWin), pWin->GetSwp()); + if (pWin->IsKindOf(CLASSINFO(wxRadioBox))) + { + wxRadioBox* pRadioBox; + + pRadioBox = wxDynamicCast(pWin, wxRadioBox); + pRadioBox->AdjustButtons( (int)vSwp.x + ,(int)vSwp.y - nDiff + ,(int)vSwp.cx + ,(int)vSwp.cy + ,pRadioBox->GetSizeFlags() + ); + } + if (pWin->IsKindOf(CLASSINFO(wxSlider))) + { + wxSlider* pSlider; + + pSlider = wxDynamicCast(pWin, wxSlider); + pSlider->AdjustSubControls( (int)vSwp.x + ,(int)vSwp.y - nDiff + ,(int)vSwp.cx + ,(int)vSwp.cy + ,(int)pSlider->GetSizeFlags() + ); + } } } + Refresh(); } // end of wxWindowOS2::MoveChildren // @@ -4029,6 +4557,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 @@ -4051,7 +4581,7 @@ int wxWindowOS2::GetOS2ParentHeight( // Case 1 // if (pParent->IsKindOf(CLASSINFO(wxDialog))) - return(pParent->GetSize().y); + return(pParent->GetClientSize().y); // // Case 2 -- if we are one of the separately built standard Frame @@ -4065,46 +4595,39 @@ int wxWindowOS2::GetOS2ParentHeight( IsKindOf(CLASSINFO(wxMenuBar)) || IsKindOf(CLASSINFO(wxToolBar)) ) - return(pParent->GetSize().y); + { + if (IsKindOf(CLASSINFO(wxToolBar))) + { + wxFrame* pFrame = wxDynamicCast(GetParent(), wxFrame); + + if (pFrame->GetToolBar() == this) + return(pParent->GetSize().y); + else + return(pParent->GetClientSize().y); + } + else + return(pParent->GetSize().y); + } 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 +// +// OS/2 needs a lot extra manipulation to deal with layouts +// for canvas windows, particularly scrolled ones. +// wxWindowCreationHook::wxWindowCreationHook( wxWindow* pWinBeingCreated ) @@ -4182,6 +4705,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; @@ -4206,6 +4730,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: @@ -4826,3 +5361,108 @@ wxPoint wxGetMousePosition() return wxPoint(vPt.x, vPt.y); } +wxWindowOS2* FindWindowForMouseEvent( + wxWindow* pWin +, short* pnX +, short* pnY +) +{ + HWND hWnd = GetHwndOf(pWin); + HWND hWndUnderMouse; + POINTL vPoint; + BOOL rcEnabled = FALSE; + BOOL rcVisible = FALSE; + HWND hWndDesktop = HWND_DESKTOP; + + ::WinQueryPointerPos(HWND_DESKTOP, &vPoint); + hWndUnderMouse = ::WinWindowFromPoint(HWND_DESKTOP, &vPoint, TRUE); + if (hWndUnderMouse != HWND_DESKTOP) + { + wxWindow* pWinUnderMouse = wxFindWinFromHandle((WXHWND)hWndUnderMouse); + + if (pWinUnderMouse) + { + wxWindowList::Node* pCurrent = pWinUnderMouse->GetChildren().GetFirst(); + wxWindow* pChild = NULL; + wxWindow* pGrandChild = NULL; + RECTL vRect; + POINTL vPoint2; + + ::WinMapWindowPoints(HWND_DESKTOP, hWndUnderMouse, &vPoint, 1); + // + // Find a child window mouse might be under + // + while (pCurrent) + { + wxWindow* pChild = pCurrent->GetData(); + + vPoint2.x = vPoint.x; + vPoint2.y = vPoint.y; + ::WinMapWindowPoints(hWndUnderMouse, pChild->GetHWND(), &vPoint2, 1); + ::WinQueryWindowRect(pChild->GetHWND(), &vRect); + if (::WinPtInRect(vHabmain, &vRect, &vPoint2)) + { + if (pChild->IsTopLevel()) + { + POINTL vPoint3; + wxWindowList::Node* pCurrent2 =pChild->GetChildren().GetFirst(); + + while (pCurrent2) + { + wxWindow* pGrandChild = pCurrent2->GetData(); + + vPoint3.x = vPoint2.x; + vPoint3.y = vPoint2.y; + ::WinMapWindowPoints( pChild->GetHWND() + ,pGrandChild->GetHWND() + ,&vPoint3 + ,1 + ); + ::WinQueryWindowRect(pGrandChild->GetHWND(), &vRect); + if (::WinPtInRect(vHabmain, &vRect, &vPoint3)) + { + hWndUnderMouse = GetHwndOf(pGrandChild); + pWinUnderMouse = pGrandChild; + break; + } + pCurrent2 = pCurrent2->GetNext(); + } + if (pGrandChild) + break; + } + hWndUnderMouse = GetHwndOf(pChild); + pWinUnderMouse = pChild; + rcVisible = ::WinIsWindowVisible(hWndUnderMouse); + rcEnabled = ::WinIsWindowEnabled(hWndUnderMouse); + if (rcVisible && rcEnabled) + break; + } + pCurrent = pCurrent->GetNext(); + } + } + } + rcVisible = ::WinIsWindowVisible(hWndUnderMouse); + rcEnabled = ::WinIsWindowEnabled(hWndUnderMouse); + + + // + // 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 && + rcVisible && rcEnabled) + { + wxWindow* pWinUnderMouse = wxFindWinFromHandle((WXHWND)hWndUnderMouse); + + if (pWinUnderMouse) + { + // + // Translate the mouse coords to the other window coords + // + pWin = pWinUnderMouse; + } + } + return pWin; +} // end of FindWindowForMouseEvent +