X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/3c299c3ab663257429983c24e6fb71450f3cf9f1..8b3fddc49326c0b6019cd7082218726aa17a5727:/src/os2/window.cpp diff --git a/src/os2/window.cpp b/src/os2/window.cpp index 2c16e35794..fd71c44b76 100644 --- a/src/os2/window.cpp +++ b/src/os2/window.cpp @@ -1,4 +1,3 @@ -///////////////////////////////////////////////////////////////////////////// // Name: windows.cpp // Purpose: wxWindow // Author: David Webster @@ -34,7 +33,11 @@ #include "wx/button.h" #include "wx/msgdlg.h" #include "wx/scrolwin.h" - + #include "wx/radiobox.h" + #include "wx/slider.h" + #include "wx/statusbr.h" + #include "wx/toolbar.h" + #include "wx/settings.h" #include #endif @@ -102,9 +105,6 @@ QMSG s_currentMsg; wxMenu* wxCurrentPopupMenu = NULL; #endif // wxUSE_MENUS_NATIVE -#if !defined(__VISAGECPP__) || (__IBMCPP__ < 400) -extern wxChar wxCanvasClassName[]; -#endif wxList* wxWinHandleList = NULL; // --------------------------------------------------------------------------- @@ -130,23 +130,14 @@ void wxAssociateWinWithHandle( HWND hWnd ); 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 // static inline bool IsShiftDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_SHIFT) & 0x8000) != 0; } static inline bool IsCtrlDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x8000) != 0; } + +static wxWindow* gpWinBeingCreated = NULL; + // --------------------------------------------------------------------------- // event tables // --------------------------------------------------------------------------- @@ -300,8 +291,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; @@ -327,7 +321,6 @@ wxWindowOS2::~wxWindowOS2() { m_isBeingDeleted = TRUE; - OS2DetachWindowMenu(); for (wxWindow* pWin = GetParent(); pWin; pWin = pWin->GetParent()) { wxFrame* pFrame = wxDynamicCast(pWin, wxFrame); @@ -366,12 +359,24 @@ bool wxWindowOS2::Create( ) { HWND hParent = NULLHANDLE; - wxPoint vPos = rPos; // The OS/2 position ULONG ulCreateFlags = 0; WXDWORD dwExStyle = 0; 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 @@ -400,62 +405,33 @@ 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; } // - // Generic OS/2 Windows are created with no owner, no Z Order, no Control data, - // and no presentation parameters + // Generic OS/2 Windows have no Control Data but other classes + // that call OS2Create may have some. // - OS2Create( hParent - ,(PSZ)wxCanvasClassName + OS2Create( (PSZ)wxCanvasClassName ,rName.c_str() ,ulCreateFlags - ,vPos.x - ,vPos.y - ,WidthDefault(rSize.x) - ,HeightDefault(rSize.y) - ,NULLHANDLE - ,NULLHANDLE - ,m_windowId - ,NULL - ,NULL + ,rPos + ,rSize + ,NULL // Control Data ,dwExStyle + ,TRUE // Child ); return(TRUE); @@ -549,7 +525,7 @@ wxString wxWindowOS2::GetTitle() const return wxGetWindowText(GetHWND()); } // end of wxWindowOS2::GetTitle -void wxWindowOS2::CaptureMouse() +void wxWindowOS2::DoCaptureMouse() { HWND hWnd = GetHwnd(); @@ -560,7 +536,7 @@ void wxWindowOS2::CaptureMouse() } } // end of wxWindowOS2::GetTitle -void wxWindowOS2::ReleaseMouse() +void wxWindowOS2::DoReleaseMouse() { if (m_bWinCaptured) { @@ -587,77 +563,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 @@ -829,15 +739,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); @@ -854,53 +788,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 @@ -908,49 +859,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; } @@ -963,86 +940,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; - } - else - { - ::WinQueryWindowRect(GetHwnd(), &vRect2); - ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect); - vRect2.yBottom += vRect.yTop - vRect.yBottom; - ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect); - vRect2.xRight -= vRect.xRight - vRect.xLeft; - + vRect.xLeft = pRect->x; + vRect.yTop = pRect->y + pRect->height; + vRect.xRight = pRect->x + pRect->width; + vRect.yBottom = pRect->y; } - 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 // --------------------------------------------------------------------------- @@ -1055,9 +978,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() @@ -1081,6 +1015,82 @@ void wxWindowOS2::UnsubclassWin() } } // end of wxWindowOS2::UnsubclassWin +bool wxCheckWindowWndProc( + WXHWND hWnd +, WXFARPROC fnWndProc +) +{ + static char zBuffer[512]; + CLASSINFO vCls; + + ::WinQueryClassName((HWND)hWnd, (LONG)512, (PCH)zBuffer); + ::WinQueryClassInfo(wxGetInstance(), (PSZ)zBuffer, &vCls); + 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 // @@ -1305,6 +1315,27 @@ void wxWindowOS2::Clear() vDc.Clear(); } // end of wxWindowOS2::Clear +void wxWindowOS2::Update() +{ + ::WinUpdateWindow(GetHwnd()); +} // end of wxWindowOS2::Update + +void wxWindowOS2::Freeze() +{ + ::WinSendMsg(GetHwnd(), WM_VRNDISABLED, (MPARAM)0, (MPARAM)0); +} // end of wxWindowOS2::Freeze + +void wxWindowOS2::Thaw() +{ + ::WinSendMsg(GetHwnd(), WM_VRNENABLED, (MPARAM)TRUE, (MPARAM)0); + + // + // We need to refresh everything or otherwise he invalidated area is not + // repainted. + // + Refresh(); +} // end of wxWindowOS2::Thaw + void wxWindowOS2::Refresh( bool bEraseBack , const wxRect* pRect @@ -1327,6 +1358,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 @@ -1392,9 +1427,17 @@ void wxWindowOS2::DoGetSize( , int* pHeight ) const { - HWND hWnd = GetHwnd(); + HWND hWnd; RECTL vRect; + if (IsKindOf(CLASSINFO(wxFrame))) + { + wxFrame* pFrame = wxDynamicCast(this, wxFrame); + hWnd = pFrame->GetFrame(); + } + else + hWnd = GetHwnd(); + ::WinQueryWindowRect(hWnd, &vRect); if (pWidth) @@ -1490,22 +1533,68 @@ void wxWindowOS2::DoGetClientSize( ) const { HWND hWnd = GetHwnd(); - HWND hWndClient; RECTL vRect; - if (IsKindOf(CLASSINFO(wxFrame))) - hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT); - else - hWndClient = NULLHANDLE; - if( hWndClient == NULLHANDLE) - ::WinQueryWindowRect(GetHwnd(), &vRect); - else - ::WinQueryWindowRect(hWndClient, &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( @@ -1519,21 +1608,11 @@ void wxWindowOS2::DoMoveWindow( HWND hParent; wxWindow* pParent = GetParent(); - if (pParent) + if (pParent && !IsKindOf(CLASSINFO(wxDialog))) { - hParent = GetWinHwnd(pParent); - if (pParent->IsKindOf(CLASSINFO(wxFrame))) - { - if (IsKindOf(CLASSINFO(wxStatusBar)) || - IsKindOf(CLASSINFO(wxMenuBar)) || - IsKindOf(CLASSINFO(wxToolBar)) - ) - nY = pParent->GetSize().y - (nY + nHeight); - else - nY = pParent->GetClientSize().y - (nY + nHeight); - } - else - nY = pParent->GetSize().y - (nY + nHeight); + int nOS2Height = GetOS2ParentHeight(pParent); + + nY = nOS2Height - (nY + nHeight); } else { @@ -1550,6 +1629,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 // @@ -1582,8 +1716,29 @@ void wxWindowOS2::DoSetSize( GetPosition(&nCurrentX, &nCurrentY); GetSize(&nCurrentWidth, &nCurrentHeight); + // // ... and don't do anything (avoiding flicker) if it's already ok - if (nX == nCurrentX && nY == nCurrentY && + // + // + // Must convert Y coords to test for equality under OS/2 + // + 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) { return; @@ -1812,6 +1967,26 @@ void wxWindowOS2::GetTextExtent( ::WinReleasePS(hPS); } // end of wxWindow::GetTextExtent +bool wxWindowOS2::IsMouseInWindow() const +{ + // + // Get the mouse position + POINTL vPt; + + ::WinQueryPointerPos(HWND_DESKTOP, &vPt); + + // + // Find the window which currently has the cursor and go up the window + // chain until we find this window - or exhaust it + // + HWND hWnd = ::WinWindowFromPoint(HWND_DESKTOP, &vPt, TRUE); + + while (hWnd && (hWnd != GetHwnd())) + hWnd = ::WinQueryWindow(hWnd, QW_PARENT); + + return hWnd != NULL; +} // end of wxWindowOS2::IsMouseInWindow + #if wxUSE_CARET && WXWIN_COMPATIBILITY // --------------------------------------------------------------------------- // Caret manipulation @@ -1887,8 +2062,8 @@ 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); } @@ -1902,9 +2077,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(); @@ -1915,23 +2091,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 @@ -2150,6 +2330,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 // --------------------------------------------------------------------------- @@ -2270,7 +2458,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); } @@ -2336,6 +2535,42 @@ 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(); + } + } + } + break; + case WM_ACTIVATE: { WXWORD wState; @@ -2399,8 +2634,8 @@ MRESULT wxWindowOS2::OS2WindowProc( case WM_BUTTON3MOTIONEND: case WM_BUTTON3MOTIONSTART: { - short x = LOWORD(lParam); - short y = HIWORD(lParam); + short x = LOWORD(wParam); + short y = HIWORD(wParam); bProcessed = HandleMouseEvent(uMsg, x, y, (WXUINT)wParam); } @@ -2661,12 +2896,16 @@ MRESULT wxWindowOS2::OS2WindowProc( #endif // __WXDEBUG__ if (IsKindOf(CLASSINFO(wxFrame))) mResult = ::WinDefWindowProc(m_hWnd, uMsg, wParam, lParam); + else if (IsKindOf(CLASSINFO(wxDialog))) + mResult = ::WinDefDlgProc( m_hWnd, uMsg, wParam, lParam); else mResult = OS2DefWindowProc(uMsg, wParam, lParam); } return mResult; } // end of wxWindowOS2::OS2WindowProc +#ifndef __EMX__ +// clashes with wxDlgProc in toplevel.cpp? // // Dialog window proc // @@ -2693,6 +2932,7 @@ MRESULT wxDlgProc( return (MRESULT)0; } } // end of wxDlgProc +#endif wxWindow* wxFindWinFromHandle( WXHWND hWnd @@ -2751,183 +2991,165 @@ void wxWindowOS2::OS2DestroyWindow() { } -void wxWindowOS2::OS2DetachWindowMenu() +bool wxWindowOS2::OS2GetCreateWindowCoords( + const wxPoint& rPos +, const wxSize& rSize +, int& rnX +, int& rnY +, int& rnWidth +, int& rnHeight +) const { -#ifndef __WXUNIVERSAL__ - if (m_hMenu) - { - HMENU hMenu = (HMENU)m_hMenu; - - int nN = (int)::WinSendMsg(hMenu, MM_QUERYITEMCOUNT, 0, 0); - int i; - - for (i = 0; i < nN; i++) - { - wxChar zBuf[100]; - int nChars = (int)::WinSendMsg( hMenu - ,MM_QUERYITEMTEXT - ,MPFROM2SHORT(i, nN) - ,zBuf - ); - if (!nChars) - { - wxLogLastError(wxT("GetMenuString")); - continue; - } + bool bNonDefault = FALSE; - if (wxStrcmp(zBuf, wxT("&Window")) == 0) - { - ::WinSendMsg(hMenu, MM_DELETEITEM, MPFROM2SHORT(i, TRUE), 0); - break; - } - } + 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; } -#endif // __WXUNIVERSAL__ -} // end of wxWindowOS2::OS2DetachWindowMenu + else + { + rnX = rPos.x; + rnY = rPos.y == -1 ? CW_USEDEFAULT : 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; + bNonDefault = TRUE; + } + return bNonDefault; +} // end of wxWindowOS2::OS2GetCreateWindowCoords bool wxWindowOS2::OS2Create( - WXHWND hParent -, PSZ zClass -, const wxChar* zTitle + PSZ zClass +, const char* zTitle , WXDWORD dwStyle -, long lX -, long lY -, long lWidth -, long lHeight -, WXHWND hOwner -, WXHWND WXUNUSED(hZOrder) -, unsigned long ulId +, const wxPoint& rPos +, const wxSize& rSize , void* pCtlData -, void* pPresParams , WXDWORD dwExStyle +, bool bIsChild ) { ERRORID vError; wxString sError; - long lX1 = 0L; - long lY1 = 0L; - long lWidth1 = 20L; - long lHeight1 = 20L; - int nControlId = 0; - int nNeedsubclass = 0; - PCSZ pszClass = zClass; - - // - // Find parent's size, if it exists, to set up a possible default - // panel size the size of the parent window - // - lX1 = lX; - lY1 = lY; - if (lWidth > -1L) - lWidth1 = lWidth; - if (lHeight > -1L) - lHeight1 = lHeight; - - wxWndHook = this; + int nX = 0L; + int nY = 0L; + int nWidth = 0L; + int nHeight = 0L; + wxWindow* pParent = GetParent(); + HWND hWnd = NULLHANDLE; + HWND hParent; + long lControlId = 0L; + wxWindowCreationHook vHook(this); + wxString sClassName((wxChar*)zClass); + + OS2GetCreateWindowCoords( rPos + ,rSize + ,nX + ,nY + ,nWidth + ,nHeight + ); - // - // check to see if the new window is a standard control - // - if ((ULONG)zClass == (ULONG)WC_BUTTON || - (ULONG)zClass == (ULONG)WC_COMBOBOX || - (ULONG)zClass == (ULONG)WC_CONTAINER || - (ULONG)zClass == (ULONG)WC_ENTRYFIELD || - (ULONG)zClass == (ULONG)WC_FRAME || - (ULONG)zClass == (ULONG)WC_LISTBOX || - (ULONG)zClass == (ULONG)WC_MENU || - (ULONG)zClass == (ULONG)WC_NOTEBOOK || - (ULONG)zClass == (ULONG)WC_SCROLLBAR || - (ULONG)zClass == (ULONG)WC_SPINBUTTON || - (ULONG)zClass == (ULONG)WC_STATIC || - (ULONG)zClass == (ULONG)WC_TITLEBAR || - (ULONG)zClass == (ULONG)WC_VALUESET - ) - { - nControlId = ulId; - } + if (GetWindowStyleFlag() & wxPOPUP_WINDOW) + hParent = HWND_DESKTOP; else { - // no standard controls - if(wxString (wxT("wxFrameClass")) == wxString(zClass) ) + if ((bIsChild || HasFlag(wxFRAME_TOOL_WINDOW)) && pParent ) { - pszClass = WC_FRAME; - nNeedsubclass = 1; + // + // This is either a normal child window or a top level window with + // wxFRAME_TOOL_WINDOW style (see below) + // + hParent = GetHwndOf(pParent); } else { - nControlId = ulId; - if(nControlId < 0) - nControlId = FID_CLIENT; + // + // 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(); + if (GetWindowStyleFlag() & wxCLIP_SIBLINGS) + { + dwStyle |= WS_CLIPSIBLINGS; } } - - HWND parent; - if ( GetWindowStyleFlag() & wxPOPUP_WINDOW ) - { - // popup windows should have desktop as parent because they shouldn't - // be limited to the parents client area as child windows usually are - parent = HWND_DESKTOP; - } - else if ( hParent ) - { - parent = hParent; - } - else - { - // top level window - parent = NULL; - } - // - // We will either have a registered class via string name or a standard PM Class via a long + // For each class "Foo" we have we also have "FooNR" ("no repaint") class + // which is the same but without CS_[HV]REDRAW class styles so using it + // ensures that the window is not fully repainted on each resize // - m_hWnd = (WXHWND)::WinCreateWindow(parent, zClass, - (PSZ)zTitle ? zTitle : wxT(""), - dwStyle, lX1, lY1, lWidth, lHeight, - hOwner, HWND_TOP, (ULONG)nControlId, - pCtlData, pPresParams); - + if (GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE) + { + sClassName += wxT("NR"); + } + 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 + ); if (!m_hWnd) { - vError = ::WinGetLastError(vHabmain); + vError = ::WinGetLastError(wxGetInstance()); sError = wxPMErrorToStr(vError); - wxLogError("Can't create window of class %s!. Error: %s\n", zClass, sError); return FALSE; } - m_dwExStyle = dwExStyle; - ::WinSetWindowULong(m_hWnd, QWL_USER, (ULONG) this); - wxWndHook = NULL; - -#ifdef __WXDEBUG__ - wxNode* pNode = wxWinHandleList->Member(this); + SubclassWin(m_hWnd); + SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT)); - if (pNode) - { - HWND hWnd = (HWND)pNode->GetKeyInteger(); + m_backgroundColour.Set(wxString("GREY")); - if (hWnd != (HWND)m_hWnd) + LONG lColor = (LONG)m_backgroundColour.GetPixel(); - { - wxLogError("A second HWND association is being added for the same window!"); - } - } -#endif - wxAssociateWinWithHandle((HWND)m_hWnd - ,this - ); - // - // Now need to subclass window. - // - if(!nNeedsubclass) - { - wxAssociateWinWithHandle((HWND)m_hWnd,this); - } - else + if (!::WinSetPresParam( m_hWnd + ,PP_BACKGROUNDCOLOR + ,sizeof(LONG) + ,(PVOID)&lColor + )) { - SubclassWin(GetHWND()); + vError = ::WinGetLastError(vHabmain); + sError = wxPMErrorToStr(vError); + wxLogError("Error creating frame. Error: %s\n", sError); + return FALSE; } + SetSize( nX + ,nY + ,nWidth + ,nHeight + ); return TRUE; -} // end of wxWindowOS2::OS2Create +} // end of WinGuiBase_Window::OS2Create // =========================================================================== // OS2 PM message handlers @@ -3000,6 +3222,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 @@ -3402,7 +3631,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( @@ -3899,6 +4192,159 @@ bool wxWindowOS2::OS2OnScroll( return GetEventHandler()->ProcessEvent(vEvent); } // end of wxWindowOS2::OS2OnScroll +void wxWindowOS2::MoveChildren( + int nDiff +) +{ + SWP vSwp; + + for (wxWindowList::Node* pNode = GetChildren().GetFirst(); + pNode; + pNode = pNode->GetNext()) + { + wxWindow* pWin = pNode->GetData(); + + ::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 + +// +// Getting the Y position for a window, like a control, is a real +// pain. There are three sitatuions we must deal with in determining +// the OS2 to wxWindows Y coordinate. +// +// 1) The controls are created in a dialog. +// This is the easiest since a dialog is created with its original +// size so the standard: Y = ParentHeight - (Y + ControlHeight); +// +// 2) The controls are direct children of a frame +// In this instance the controls are actually children of the Frame's +// client. During creation the frame's client resizes several times +// during creation of the status bar and toolbars. The CFrame class +// will take care of this using its AlterChildPos proc. +// +// 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 +// controls are created BEFORE this occurs their positions are totally +// whacked and any call to WinQueryWindowPos will return invalid +// coordinates. So for this situation we have to compare the size of +// the panel at control creation time with that of the frame client. If +// they are the same we can use the standard Y position equation. If +// not, then we must use the Frame Client's dimensions to position them +// as that will be the eventual size of the panel after the frame resizes +// it! +// +int wxWindowOS2::GetOS2ParentHeight( + wxWindowOS2* pParent +) +{ + wxWindowOS2* pGrandParent = NULL; + + // + // Case 1 + // + if (pParent->IsKindOf(CLASSINFO(wxDialog))) + return(pParent->GetClientSize().y); + + // + // Case 2 -- if we are one of the separately built standard Frame + // children, like a statusbar, menubar, or toolbar we want to + // use the frame, itself, for positioning. Otherwise we are + // child window and want to use the Frame's client. + // + else if (pParent->IsKindOf(CLASSINFO(wxFrame))) + { + if (IsKindOf(CLASSINFO(wxStatusBar)) || + IsKindOf(CLASSINFO(wxMenuBar)) || + IsKindOf(CLASSINFO(wxToolBar)) + ) + return(pParent->GetSize().y); + else + return(pParent->GetClientSize().y); + } + // + // 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 + { + 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 +) +{ + gpWinBeingCreated = pWinBeingCreated; +} // end of wxWindowCreationHook::wxWindowCreationHook + +wxWindowCreationHook::~wxWindowCreationHook() +{ + gpWinBeingCreated = NULL; +} // end of wxWindowCreationHook::~wxWindowCreationHook + // =========================================================================== // global functions // ===========================================================================