X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/45e0dc94770d598a1cc84d83730d470dd1cfbcca..8912d7eb182ef5a5f95026a9ed239c9ad6c75915:/src/os2/window.cpp?ds=sidebyside diff --git a/src/os2/window.cpp b/src/os2/window.cpp index 935143f040..c5000c0f47 100644 --- a/src/os2/window.cpp +++ b/src/os2/window.cpp @@ -1,4 +1,3 @@ -///////////////////////////////////////////////////////////////////////////// // Name: windows.cpp // Purpose: wxWindow // Author: David Webster @@ -131,18 +130,6 @@ 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 // @@ -291,10 +278,11 @@ void wxWindowOS2::Init() m_bDoubleClickAllowed = 0; m_bWinCaptured = FALSE; - m_isBeingDeleted = FALSE; - m_fnOldWndProc = 0; - m_bUseCtl3D = FALSE; - m_bMouseInWindow = FALSE; + m_isBeingDeleted = FALSE; + m_fnOldWndProc = 0; + m_bUseCtl3D = FALSE; + m_bMouseInWindow = FALSE; + m_bLastKeydownProcessed = FALSE; // // wxWnd @@ -304,8 +292,11 @@ void wxWindowOS2::Init() m_hWndScrollBarHorz = 0L; m_hWndScrollBarVert = 0L; + memset(&m_vWinSwp, '\0', sizeof (SWP)); + // // Pass WM_GETDLGCODE to DefWindowProc() + // m_lDlgCode = 0; m_nXThumbSize = 0; @@ -374,6 +365,19 @@ bool wxWindowOS2::Create( wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent")); +#if wxUSE_STATBOX + // + // wxGTK doesn't allow to create controls with static box as the parent so + // this will result in a crash when the program is ported to wxGTK - warn + // about it + // + // the correct solution is to create the controls as siblings of the + // static box + // + wxASSERT_MSG( !wxDynamicCast(pParent, wxStaticBox), + _T("wxStaticBox can't be used as a window parent!") ); +#endif // wxUSE_STATBOX + if ( !CreateBase( pParent ,vId ,rPos @@ -402,39 +406,16 @@ bool wxWindowOS2::Create( // set in those class create procs. PM's basic windows styles are // very limited. // - ulCreateFlags |= WS_VISIBLE; + ulCreateFlags |= WS_VISIBLE | OS2GetCreateWindowFlags(&dwExStyle); #ifdef __WXUNIVERSAL__ // no 3d effects, we draw them ourselves WXDWORD exStyle = 0; -#else // !wxUniversal - if (lStyle & wxCLIP_SIBLINGS) - ulCreateFlags |= WS_CLIPSIBLINGS; - - if (lStyle & wxCLIP_CHILDREN ) - ulCreateFlags |= WS_CLIPCHILDREN; - - // - // - // - bool bWant3D; - dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D); - -#endif - - // - // Add the simple border style as we'll use this to draw borders - // - if (lStyle & wxSIMPLE_BORDER) - dwExStyle |= wxSIMPLE_BORDER; - +#endif // !wxUniversal if (lStyle & wxPOPUP_WINDOW) { // a popup window floats on top of everything -//TODO: fix this... -// exStyle |= WS_EX_TOPMOST | WS_EX_TOOLWINDOW; - // it is also created hidden as other top level windows ulCreateFlags &= ~WS_VISIBLE; m_isShown = FALSE; @@ -767,6 +748,7 @@ void wxWindowOS2::SetScrollbar( SBCDATA vInfo; ULONG ulStyle = WS_VISIBLE | WS_SYNCPAINT; SWP vSwp; + SWP vSwpOwner; RECTL vRect; HWND hWndParent; HWND hWndClient; @@ -789,6 +771,7 @@ void wxWindowOS2::SetScrollbar( hWndClient = hWndParent; } ::WinQueryWindowPos(hWndClient, &vSwp); + ::WinQueryWindowPos(hWnd, &vSwpOwner); if (nPageSize > 1 && nRange > 0) { @@ -805,6 +788,18 @@ void wxWindowOS2::SetScrollbar( ulStyle |= SBS_HORZ; if (m_hWndScrollBarHorz == 0L) { + // + // Since the scrollbars are usually created before the owner is + // sized either via an OnSize event directly or via sizers or + // layout constraints, we will initially just use the coords of + // the parent window (this is usually a frame client window). But + // the bars themselves, are children of the parent frame (i.e + // siblings of the frame client. The owner, however is the actual + // window being scrolled (or at least the one responsible for + // handling the scroll events). The owner will be resized later, + // as it is usually a child of a top level window, and when that + // is done its scrollbars will be resized and repositioned as well. + // m_hWndScrollBarHorz = ::WinCreateWindow( hWndParent ,WC_SCROLLBAR ,(PSZ)NULL @@ -822,26 +817,42 @@ void wxWindowOS2::SetScrollbar( } else { - ::WinSetWindowPos( m_hWndScrollBarHorz - ,HWND_TOP - ,vSwp.x - ,vSwp.y - ,vSwp.cx - 20 - ,20 - ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER - ); - ::WinSendMsg( m_hWndScrollBarHorz - ,SBM_SETSCROLLBAR - ,(MPARAM)nPos - ,MPFROM2SHORT(0, (SHORT)nRange1) - ); - ::WinSendMsg( m_hWndScrollBarHorz - ,SBM_SETTHUMBSIZE - ,MPFROM2SHORT( (SHORT)nThumbVisible - ,(SHORT)nRange1 - ) - ,(MPARAM)0 - ); + // + // The owner (the scrolled window) is a child of the Frame's + // client window, usually. The scrollbars are children of the + // frame, itself, and thus are positioned relative to the frame's + // origin, not the frame's client window origin. + // The starting x position is the same as the starting x position + // of the owner, but in terms of the parent frame. + // The starting y position is 20 pels below the origin of the + // owner in terms of the parent frame. + // The horz bar is the same width as the owner and 20 pels high. + // + if (nRange1 >= nThumbVisible) + { + ::WinSetWindowPos( m_hWndScrollBarHorz + ,HWND_TOP + ,vSwp.x + vSwpOwner.x + ,(vSwp.y + vSwpOwner.y) - 20 + ,vSwpOwner.cx + ,20 + ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER + ); + ::WinSendMsg( m_hWndScrollBarHorz + ,SBM_SETSCROLLBAR + ,(MPARAM)nPos + ,MPFROM2SHORT(0, (SHORT)nRange1) + ); + ::WinSendMsg( m_hWndScrollBarHorz + ,SBM_SETTHUMBSIZE + ,MPFROM2SHORT( (SHORT)nThumbVisible + ,(SHORT)nRange1 + ) + ,(MPARAM)0 + ); + } + else + ::WinShowWindow(m_hWndScrollBarHorz, FALSE); } } else @@ -849,6 +860,18 @@ void wxWindowOS2::SetScrollbar( ulStyle |= SBS_VERT; if (m_hWndScrollBarVert == 0L) { + // + // Since the scrollbars are usually created before the owner is + // sized either via an OnSize event directly or via sizers or + // layout constraints, we will initially just use the coords of + // the parent window (this is usually a frame client window). But + // the bars themselves, are children of the parent frame (i.e + // siblings of the frame client. The owner, however is the actual + // window being scrolled (or at least the one responsible for + // handling the scroll events). The owner will be resized later, + // as it is usually a child of a top level window, and when that + // is done its scrollbars will be resized and repositioned as well. + // m_hWndScrollBarVert = ::WinCreateWindow( hWndParent ,WC_SCROLLBAR ,(PSZ)NULL @@ -866,26 +889,46 @@ void wxWindowOS2::SetScrollbar( } else { - ::WinSetWindowPos( m_hWndScrollBarVert - ,HWND_TOP - ,vSwp.x + vSwp.cx - 20 - ,vSwp.y + 20 - ,20 - ,vSwp.cy - 20 - ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW - ); - ::WinSendMsg( m_hWndScrollBarVert - ,SBM_SETSCROLLBAR - ,(MPARAM)nPos - ,MPFROM2SHORT(0, (SHORT)nRange1) - ); - ::WinSendMsg( m_hWndScrollBarVert - ,SBM_SETTHUMBSIZE - ,MPFROM2SHORT( (SHORT)nThumbVisible - ,(SHORT)nRange1 - ) - ,(MPARAM)0 - ); + // + // The owner (the scrolled window) is a child of the Frame's + // client window, usually. The scrollbars are children of the + // frame, itself and thus are positioned relative to the frame's + // origin, not the frame's client window's origin. + // Thus, the x position will be frame client's x (usually a few + // pels inside the parent frame, plus the width of the owner. + // Since we may be using sizers or layout constraints for multiple + // child scrolled windows, the y position will be the frame client's + // y pos plus the scrolled windows y position, yielding the y + // position of the scrollbar relative to the parent frame (the vert + // scrollbar is on the right and starts at the bottom of the + // owner window). + // It is 20 pels wide and the same height as the owner. + // + if (nRange1 >= nThumbVisible) + { + ::WinSetWindowPos( m_hWndScrollBarVert + ,HWND_TOP + ,vSwp.x + vSwpOwner.x + vSwpOwner.cx + ,vSwp.y + vSwpOwner.y + ,20 + ,vSwpOwner.cy + ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW + ); + ::WinSendMsg( m_hWndScrollBarVert + ,SBM_SETSCROLLBAR + ,(MPARAM)nPos + ,MPFROM2SHORT(0, (SHORT)nRange1) + ); + ::WinSendMsg( m_hWndScrollBarVert + ,SBM_SETTHUMBSIZE + ,MPFROM2SHORT( (SHORT)nThumbVisible + ,(SHORT)nRange1 + ) + ,(MPARAM)0 + ); + } + else + ::WinShowWindow(m_hWndScrollBarVert, FALSE); } m_nYThumbSize = nThumbVisible; } @@ -923,6 +966,7 @@ void wxWindowOS2::ScrollWindow( ,NULL ,SW_SCROLLCHILDREN | SW_INVALIDATERGN ); + Refresh(); } // end of wxWindowOS2::ScrollWindow // --------------------------------------------------------------------------- @@ -985,6 +1029,69 @@ bool wxCheckWindowWndProc( return(fnWndProc == (WXFARPROC)vCls.pfnWindowProc); } // end of WinGuiBase_CheckWindowWndProc +void wxWindowOS2::SetWindowStyleFlag( + long lFlags +) +{ + long lFlagsOld = GetWindowStyleFlag(); + + if (lFlags == lFlagsOld) + return; + + // + // Update the internal variable + // + wxWindowBase::SetWindowStyleFlag(lFlags); + + // + // Now update the Windows style as well if needed - and if the window had + // been already created + // + if (!GetHwnd()) + return; + + WXDWORD dwExstyle; + WXDWORD dwExstyleOld; + long lStyle = OS2GetStyle( lFlags + ,&dwExstyle + ); + long lStyleOld = OS2GetStyle( lFlagsOld + ,&dwExstyleOld + ); + + if (lStyle != lStyleOld) + { + // + // Some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by + // this function so instead of simply setting the style to the new + // value we clear the bits which were set in styleOld but are set in + // the new one and set the ones which were not set before + // + long lStyleReal = ::WinQueryWindowULong(GetHwnd(), QWL_STYLE); + + lStyleReal &= ~lStyleOld; + lStyleReal |= lStyle; + + ::WinSetWindowULong(GetHwnd(), QWL_STYLE, lStyleReal); + } +} // end of wxWindowOS2::SetWindowStyleFlag + +WXDWORD wxWindowOS2::OS2GetStyle( + long lFlags +, WXDWORD* pdwExstyle +) const +{ + WXDWORD dwStyle = 0L; + + if (lFlags & wxCLIP_CHILDREN ) + dwStyle |= WS_CLIPCHILDREN; + + if (lFlags & wxCLIP_SIBLINGS ) + dwStyle |= WS_CLIPSIBLINGS; + + return dwStyle; +} // end of wxWindowMSW::MSWGetStyle + // // Make a Windows extended style from the given wxWindows window style // @@ -1523,6 +1630,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 // @@ -2544,12 +2706,14 @@ MRESULT wxWindowOS2::OS2WindowProc( } 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 = TRUE; if (uKeyFlags & KC_VIRTUALKEY) { USHORT uVk = SHORT2FROMMP((MPARAM)lParam); @@ -2944,37 +3108,6 @@ bool wxWindowOS2::OS2Create( { sClassName += wxT("NR"); } - - // - // If the window being created is a Frame's Statusbar we need to use - // the actual Frame's size, not its client - // - if (pParent) - { - if ( pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) || - pParent->IsKindOf(CLASSINFO(wxScrolledWindow)) - ) - { - if (IsKindOf(CLASSINFO(wxStatusBar)) && - pParent->IsKindOf(CLASSINFO(wxFrame))) - { - RECTL vRect; - wxFrame* pFrame = wxDynamicCast(pParent, wxFrame); - - ::WinQueryWindowRect((HWND)pFrame->GetFrame(), &vRect); - nY = vRect.yTop - (nY + nHeight); - } - else - nY = pParent->GetSize().y - (nY + nHeight); - } - } - else - { - RECTL vRect; - - ::WinQueryWindowRect(HWND_DESKTOP, &vRect); - nY = vRect.yTop - (nY + nHeight); - } m_hWnd = (WXHWND)::WinCreateWindow( (HWND)hParent ,(PSZ)sClassName.c_str() ,(PSZ)zTitle ? zTitle : "" @@ -2997,6 +3130,22 @@ bool wxWindowOS2::OS2Create( } SubclassWin(m_hWnd); SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT)); + + m_backgroundColour.Set(wxString("GREY")); + + LONG lColor = (LONG)m_backgroundColour.GetPixel(); + + if (!::WinSetPresParam( m_hWnd + ,PP_BACKGROUNDCOLOR + ,sizeof(LONG) + ,(PVOID)&lColor + )) + { + vError = ::WinGetLastError(vHabmain); + sError = wxPMErrorToStr(vError); + wxLogError("Error creating frame. Error: %s\n", sError); + return FALSE; + } SetSize( nX ,nY ,nWidth @@ -3485,7 +3634,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( @@ -3804,6 +4017,16 @@ 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) { // @@ -4011,13 +4234,14 @@ void wxWindowOS2::MoveChildren( vSwp.x -= pCtrl->GetXComp(); } ::WinSetWindowPos( GetHwndOf(pWin) - ,HWND_BOTTOM + ,HWND_TOP ,vSwp.x ,vSwp.y - nDiff ,vSwp.cx ,vSwp.cy - ,SWP_MOVE | SWP_ZORDER + ,SWP_MOVE | SWP_SHOW | SWP_ZORDER ); + ::WinQueryWindowPos(GetHwndOf(pWin), pWin->GetSwp()); if (pWin->IsKindOf(CLASSINFO(wxRadioBox))) { wxRadioBox* pRadioBox; @@ -4043,6 +4267,7 @@ void wxWindowOS2::MoveChildren( ); } } + Refresh(); } // end of wxWindowOS2::MoveChildren // @@ -4062,6 +4287,8 @@ void wxWindowOS2::MoveChildren( // // 3) The controls are children of a panel, which in turn is a child of // a frame. +// The panel may be one of many, in which case the same treatment +// as 1 applies. It may be the only child, though. // This is the nastiest case. A panel is created as the only child of // the frame and as such, when a frame has only one child, the child is // expanded to fit the entire client area of the frame. Because the @@ -4102,38 +4329,15 @@ int wxWindowOS2::GetOS2ParentHeight( else return(pParent->GetClientSize().y); } - // - // Case 3 -- this is for any window that is the sole child of a Frame. - // The grandparent must exist and it must be of type CFrame - // and it's height must be different. Otherwise the standard - // applies. + // Case -- this is for any window that is the sole child of a Frame. + // The grandparent must exist and it must be of type CFrame + // and it's height must be different. Otherwise the standard + // applies. // else { - pGrandParent = pParent->GetParent(); - if (pGrandParent && - pGrandParent->IsKindOf(CLASSINFO(wxFrame)) && - pGrandParent->GetClientSize().y != pParent->GetSize().y - ) - { - int nParentHeight = 0L; - int nStatusBarHeight = 0L; - wxFrame* pFrame = wxDynamicCast(pGrandParent, wxFrame); - wxStatusBar* pStatbar = pFrame->GetStatusBar(); - - nParentHeight = pGrandParent->GetClientSize().y; - if (pStatbar) - nStatusBarHeight = pStatbar->GetSize().y; - nParentHeight -= nStatusBarHeight; - return(nParentHeight); - } - else - // - // Panel is a child of some other kind of window so we'll - // just use it's original size - // - return(pParent->GetClientSize().y); + return(pParent->GetClientSize().y); } return(0L); } // end of wxWindowOS2::GetOS2ParentHeight @@ -4142,111 +4346,6 @@ int wxWindowOS2::GetOS2ParentHeight( // OS/2 needs a lot extra manipulation to deal with layouts // for canvas windows, particularly scrolled ones. // -void wxWindowOS2::OS2Layout( - int nWidth -, int nHeight -) -{ - // - // Frames laying out canvas windows need the held. - // Dialogs or Frames laying out child controls do not. - // - if (IsKindOf(CLASSINFO(wxFrame))) - { - RECTL vRectFrame; - RECTL vRectClient; - RECTL vRectChild; - RECTL vRectHorz; - RECTL vRectVert; - SWP vSwpFrame; - SWP vSwpClient; - SWP vSwpChild; - SWP vSwpHorz; - SWP vSwpVert; - wxFrame* pFrame = wxDynamicCast(this, wxFrame); - bool bNewYSize = FALSE; - bool bNewXSize = FALSE; - - ::WinQueryWindowPos(pFrame->GetFrame(), &vSwpFrame); - ::WinQueryWindowPos(GetHwnd(), &vSwpClient); - - if (vSwpClient.cy != pFrame->GetSwpClient()->cy) - bNewYSize = TRUE; - if (vSwpClient.cx != pFrame->GetSwpClient()->cx) - bNewXSize = TRUE; - - for (wxWindowList::Node* pNode = GetChildren().GetFirst(); - pNode; - pNode = pNode->GetNext()) - { - wxWindow* pChild = pNode->GetData(); - int nWidthAdjust = 0; - int nHeightAdjust = 0; - - if ( pChild->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) || - pChild->IsKindOf(CLASSINFO(wxScrolledWindow)) - ) - { - if(bNewYSize) - { - // - // This is needed SetSize will mess up the OS/2 child window - // positioning because we position in wxWindows coordinates, - // not OS/2 coordinates. - // - pChild->MoveChildren(pFrame->GetSwpClient()->cy - vSwpClient.cy); - pChild->Refresh(); - } - ::WinQueryWindowPos(pChild->GetHWND(), &vSwpChild); - - // - // Reset the child window size to account for scrollbars - // - if (pChild->GetScrollBarHorz() != NULLHANDLE) - nHeightAdjust = 20; - if (pChild->GetScrollBarVert() != NULLHANDLE) - nWidthAdjust = 20; - ::WinSetWindowPos( pChild->GetHWND() - ,HWND_TOP - ,vSwpChild.x - ,vSwpChild.y + nHeightAdjust - ,vSwpChild.cx - nWidthAdjust - ,vSwpChild.cy - nHeightAdjust - ,SWP_MOVE | SWP_SIZE - ); - - // - // Reset the scrollbar sizes...they will be all messed up after - // auto layouts - // - if (pChild->GetScrollBarHorz() != NULLHANDLE) - { - ::WinSetWindowPos( pChild->GetScrollBarHorz() - ,HWND_TOP - ,vSwpClient.x + vSwpChild.x - ,vSwpClient.y + vSwpChild.y - ,vSwpChild.cx - 20 - ,20 - ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER - ); - } - if (pChild->GetScrollBarVert() != NULLHANDLE) - { - ::WinSetWindowPos( pChild->GetScrollBarVert() - ,HWND_TOP - ,vSwpClient.x + vSwpChild.x + vSwpChild.cx - 20 - ,vSwpClient.y + vSwpChild.y + 20 - ,20 - ,vSwpChild.cy - 20 - ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER - ); - } - } - } - ::WinQueryWindowPos(GetHwnd(), pFrame->GetSwpClient()); - } -} // end of wxWindowOS2::OS2Layout - wxWindowCreationHook::wxWindowCreationHook( wxWindow* pWinBeingCreated )