-/////////////////////////////////////////////////////////////////////////////
// Name: windows.cpp
// Purpose: wxWindow
// Author: David Webster
m_hWndScrollBarHorz = 0L;
m_hWndScrollBarVert = 0L;
+ memset(&m_vWinSwp, '\0', sizeof (SWP));
+
//
// Pass WM_GETDLGCODE to DefWindowProc()
+ //
m_lDlgCode = 0;
m_nXThumbSize = 0;
, 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;
- RECTL vRect;
+ 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);
ulStyle |= SBS_HORZ;
if (m_hWndScrollBarHorz == 0L)
{
- m_hWndScrollBarHorz = ::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_hWndScrollBarHorz = ::WinCreateWindow( hWndParent
,WC_SCROLLBAR
,(PSZ)NULL
,ulStyle
- ,vRect.xLeft
- ,vRect.yBottom
- ,vRect.xRight - vRect.xLeft - 20
+ ,vSwp.x
+ ,vSwp.y
+ ,vSwp.cx - 20
,20
,hWnd
,HWND_TOP
}
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
- ) )
- {
- ::WinSetWindowPos( m_hWndScrollBarHorz
- ,HWND_TOP
- ,vRect.xLeft
- ,vRect.yBottom
- ,vRect.xRight - vRect.xLeft - 20
- ,20
- ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW
- );
- }
- ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1));
- ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
+ ::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
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
,60001
}
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
- ) )
- {
- ::WinSetWindowPos( m_hWndScrollBarVert
- ,HWND_TOP
- ,vRect.xRight - 20
- ,vRect.yBottom + 20
- ,20
- ,vRect.yTop - (vRect.yBottom + 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);
+ ::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
+ );
}
m_nYThumbSize = nThumbVisible;
}
, const wxRect* pRect
)
{
- nDy *= -1; // flip the sign of Dy as OS/2 is opposite Windows.
RECTL vRect;
RECTL vRectHorz;
RECTL vRectVert;
else
{
::WinQueryWindowRect(GetHwnd(), &vRect);
- ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRectHorz);
- vRect.yBottom += vRectHorz.yTop - vRectHorz.yBottom;
- ::WinQueryWindowRect(m_hWndScrollBarVert, &vRectVert);
- vRect.xRight -= vRectVert.xRight - vRectVert.xLeft;
-
}
+ nDy *= -1; // flip the sign of Dy as OS/2 is opposite Windows.
::WinScrollWindow( GetHwnd()
,(LONG)nDx
,(LONG)nDy
,&vRect
- ,NULL
+ ,&vRect
,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->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(pChildWin, wxControl);
- vSwp.y -= pCtrl->GetYComp();
- vSwp.x -= pCtrl->GetXComp();
- }
- ::WinSetWindowPos( pChildWin->GetHWND()
- ,HWND_BOTTOM
- ,vSwp.x + nDx
- ,vSwp.y + nDy
- ,0
- ,0
- ,SWP_MOVE
- );
- if (pChildWin->IsKindOf(CLASSINFO(wxRadioBox)))
- {
- wxRadioBox* pRadioBox;
-
- pRadioBox = wxDynamicCast(pChildWin, wxRadioBox);
- pRadioBox->AdjustButtons( (int)vSwp.x + nDx
- ,(int)vSwp.y + nDy
- ,(int)vSwp.cx
- ,(int)vSwp.cy
- ,pRadioBox->GetSizeFlags()
- );
- }
- if (pChildWin->IsKindOf(CLASSINFO(wxSlider)))
- {
- wxSlider* pSlider;
-
- pSlider = wxDynamicCast(pChildWin, wxSlider);
- pSlider->AdjustSubControls( (int)vSwp.x + nDx
- ,(int)vSwp.y + nDy
- ,(int)vSwp.cx
- ,(int)vSwp.cy
- ,pSlider->GetSizeFlags()
- );
- }
- ::WinInvalidateRect(pChildWin->GetHWND(), &vRectChild, FALSE);
- }
- pCurrent = pCurrent->GetNext();
- }
- if (GetChildren().GetCount() > 0)
- {
- //
- // Clean up child window slop
- //
- ::WinQueryWindowRect(GetHwnd(), &vRect);
- vRect.xRight -= 20;
- vRect.yBottom += 20;
- ::WinInvalidateRect(GetHwnd(), &vRect, TRUE);
- }
-
- //
- // Takes a lot to keep the scrollbars on top of everything
- //
- ::WinSetWindowPos( m_hWndScrollBarHorz
- ,HWND_TOP
- ,0
- ,0
- ,0
- ,0
- ,SWP_ZORDER
+ ,SW_SCROLLCHILDREN | SW_INVALIDATERGN
);
- ::WinSetWindowPos( m_hWndScrollBarVert
- ,HWND_TOP
- ,0
- ,0
- ,0
- ,0
- ,SWP_ZORDER
- );
- ::WinInvalidateRect(m_hWndScrollBarHorz, &vRectHorz, FALSE);
- ::WinInvalidateRect(m_hWndScrollBarVert, &vRectVert, FALSE);
+ Refresh();
} // end of wxWindowOS2::ScrollWindow
// ---------------------------------------------------------------------------
}
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
,(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)
+ nAdjustHeight = 20L;
+ if (GetScrollBarVert() != NULLHANDLE)
+ 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 += 20;
+ }
+ MoveChildren(nYDiff);
+ ::WinQueryWindowPos(GetHwnd(), &m_vWinSwp);
+ }
} // end of wxWindowOS2::DoMoveWindow
//
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);
}
{
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 : ""
}
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
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;
,(int)pSlider->GetSizeFlags()
);
}
- //
- // Originally created before Panel was properly sized, most likely.
- // So now the the panel is sized correctly, resize the scrollbars
- // and bring them to the top of all the other panel children
- //
- if (m_hWndScrollBarVert != NULLHANDLE ||
- m_hWndScrollBarHorz != NULLHANDLE)
- {
- RECTL vRect;
-
- ::WinQueryWindowRect(GetHwnd(), &vRect);
- ::WinQueryWindowPos(m_hWndScrollBarHorz, &vSwp);
- if ( (vRect.xRight - vRect.xLeft) - vSwp.cx != 20)
- {
- ::WinSetWindowPos( m_hWndScrollBarHorz
- ,HWND_TOP
- ,0
- ,0
- ,(vRect.xRight - vRect.xLeft) - 20
- ,vSwp.cy
- ,SWP_ZORDER | SWP_SIZE
- );
- }
- else
- {
- ::WinSetWindowPos( m_hWndScrollBarHorz
- ,HWND_TOP
- ,0
- ,0
- ,0
- ,0
- ,SWP_ZORDER
- );
- }
- ::WinQueryWindowPos(m_hWndScrollBarVert, &vSwp);
- if ( (vRect.yTop - vRect.yBottom) - vSwp.cy != 20)
- {
- ::WinSetWindowPos( m_hWndScrollBarVert
- ,HWND_TOP
- ,vSwp.x
- ,vSwp.y + 20
- ,vSwp.cx
- ,(vRect.yTop - vRect.yBottom) - 20
- ,SWP_ZORDER | SWP_SIZE | SWP_MOVE
- );
- }
- else
- {
- ::WinSetWindowPos( m_hWndScrollBarVert
- ,HWND_TOP
- ,0
- ,0
- ,0
- ,0
- ,SWP_ZORDER
- );
- }
- ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect);
- ::WinInvalidateRect(m_hWndScrollBarHorz, &vRect, FALSE);
- ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect);
- ::WinInvalidateRect(m_hWndScrollBarVert, &vRect, FALSE);
- }
}
+ Refresh();
} // end of 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
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
)
projects / wxWidgets.git / blobdiff