#define GET_Y_LPARAM(mp) ((unsigned short)(unsigned long)(mp >> 16))
#endif // GET_X_LPARAM
+#ifndef CW_USEDEFAULT
+# define CW_USEDEFAULT ((int)0x80000000)
+#endif
+
// ---------------------------------------------------------------------------
// global variables
// ---------------------------------------------------------------------------
wxMenu* wxCurrentPopupMenu = NULL;
extern wxList WXDLLEXPORT wxPendingDelete;
-#if defined(__VISAGECPP__) && (__IBMCPP__ < 400)
-extern wxChar* wxCanvasClassName;
+#if !defined(__VISAGECPP__) || (__IBMCPP__ < 400)
+extern wxChar wxCanvasClassName[];
#endif
wxList* wxWinHandleList = NULL;
//
// the window proc for all our windows; most gui's have something similar
//
-MRESULT wxWndProc( HWND hWnd
- ,ULONG message
- ,MPARAM mp1
- ,MPARAM mp2
- );
+MRESULT EXPENTRY wxWndProc( HWND hWnd
+ ,ULONG message
+ ,MPARAM mp1
+ ,MPARAM mp2
+ );
#ifdef __WXDEBUG__
const char *wxGetMessageName(int message);
EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
EVT_INIT_DIALOG(wxWindow::OnInitDialog)
EVT_IDLE(wxWindow::OnIdle)
+ EVT_SET_FOCUS(wxWindow::OnSetFocus)
END_EVENT_TABLE()
// ===========================================================================
//
// wxWnd
//
- m_hMenu = 0;
- m_hWnd = 0;
+ m_hMenu = 0L;
+ m_hWnd = 0L;
+ m_hWndScrollBarHorz = 0L;
+ m_hWndScrollBarVert = 0L;
//
// Pass WM_GETDLGCODE to DefWindowProc()
m_isBeingDeleted = TRUE;
OS2DetachWindowMenu();
+ for (wxWindow* pWin = GetParent(); pWin; pWin = pWin->GetParent())
+ {
+ wxFrame* pFrame = wxDynamicCast(pWin, wxFrame);
+
+ if (pFrame)
+ {
+ if (pFrame->GetLastFocus() == this)
+ pFrame->SetLastFocus((wxWindow*)NULL);
+ break;
+ }
+ }
if (m_parent)
m_parent->RemoveChild(this);
DestroyChildren();
+
if (m_hWnd)
{
if(!::WinDestroyWindow(GetHWND()))
, const wxString& rName
)
{
+ HWND hParent = NULLHANDLE;
+ wxPoint vPos = rPos; // The OS/2 position
+ ULONG ulCreateFlags = 0L;
+
wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent"));
if ( !CreateBase( pParent
))
return(FALSE);
- pParent->AddChild(this);
+ if (pParent)
+ {
+ int nTempy;
- ULONG ulFlags = 0L;
+ pParent->AddChild(this);
+ hParent = GetWinHwnd(pParent);
+ //
+ // OS2 uses normal coordinates, no bassackwards Windows ones
+ //
+ if (pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
+ pParent->IsKindOf(CLASSINFO(wxScrolledWindow))
+ )
+ {
+ wxWindow* pGrandParent = NULL;
- //
- // Frame windows and their derivatives only
- //
- if (lStyle & wxBORDER)
- ulFlags |= FCF_BORDER;
- if (lStyle & wxTHICK_FRAME )
- ulFlags |= FCF_SIZEBORDER;
+ pGrandParent = pParent->GetParent();
+ if (pGrandParent)
+ nTempy = pGrandParent->GetSize().y - (vPos.y + rSize.y);
+ else
+ nTempy = pParent->GetSize().y - (vPos.y + rSize.y);
+ }
+ else
+ nTempy = pParent->GetSize().y - (vPos.y + rSize.y);
+ vPos.y = nTempy;
+ if ( pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
+ pParent->IsKindOf(CLASSINFO(wxScrolledWindow))
+ )
+ ulCreateFlags |= WS_CLIPSIBLINGS;
+ }
+ else
+ {
+ RECTL vRect;
+
+ ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
+ hParent = HWND_DESKTOP;
+ vPos.y = vRect.yTop - (vPos.y + rSize.y);
+ }
//
- // Some generic window styles
+ // Most wxSTYLES are really PM Class specific styles and will be
+ // set in those class create procs. PM's basic windows styles are
+ // very limited.
//
- ulFlags |= WS_VISIBLE;
+ ulCreateFlags |= WS_VISIBLE;
+
+
+ if (lStyle & wxCLIP_SIBLINGS)
+ ulCreateFlags |= WS_CLIPSIBLINGS;
+
if (lStyle & wxCLIP_CHILDREN )
- ulFlags |= WS_CLIPCHILDREN;
+ ulCreateFlags |= WS_CLIPCHILDREN;
+ //
+ //
+ //
bool bWant3D;
- WXDWORD dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D);
+ WXDWORD dwExStyle = Determine3DEffects( WS_EX_CLIENTEDGE
+ ,&bWant3D
+ );
//
- // OS/2 PM doesn't have "extended" styles but if the library specifies
- // them and we are creating a frame window then at least give it a border
+ // Add the simple border style as we'll use this to draw borders
//
- if ( bWant3D ||
- (m_windowStyle & wxSIMPLE_BORDER) ||
- (m_windowStyle & wxRAISED_BORDER ) ||
- (m_windowStyle & wxSUNKEN_BORDER) ||
- (m_windowStyle & wxDOUBLE_BORDER)
- )
- {
- ulFlags |= FCF_BORDER;
- }
- OS2Create( m_windowId
- ,pParent
- ,wxCanvasClassName
- ,this
- ,NULL
- ,rPos.x
- ,rPos.y
+ if (lStyle & wxSIMPLE_BORDER)
+ dwExStyle |= wxSIMPLE_BORDER;
+
+ //
+ // Generic OS/2 Windows are created with no owner, no Z Order, no Control data,
+ // and no presentation parameters
+ //
+ OS2Create( hParent
+ ,(PSZ)wxCanvasClassName
+ ,rName.c_str()
+ ,ulCreateFlags
+ ,vPos.x
+ ,vPos.y
,WidthDefault(rSize.x)
,HeightDefault(rSize.y)
- ,ulFlags
+ ,NULLHANDLE
+ ,NULLHANDLE
+ ,m_windowId
+ ,NULL
,NULL
,dwExStyle
);
+
return(TRUE);
} // end of wxWindow::Create
, bool bRefresh
)
{
- ::WinSendMsg(GetHwnd(), SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, nRange));
+ 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 wxWindow::SetScrollRange
void wxWindow::SetScrollPage(
, bool bRefresh
)
{
- if ( orient == wxHORIZONTAL )
- m_xThumbSize = page;
+ if (nOrient == wxHORIZONTAL )
+ m_nXThumbSize = nPage;
else
- m_yThumbSize = page;
-}
+ m_nYThumbSize = nPage;
+} // end of wxWindow::SetScrollPage
int wxWindow::OldGetScrollRange(
int nOrient
int nOrient
) const
{
- return((int)::WinSendMsg(GetHwnd(), SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
+ if (nOrient == wxHORIZONTAL)
+ return((int)::WinSendMsg(m_hWndScrollBarHorz, SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
+ else
+ return((int)::WinSendMsg(m_hWndScrollBarVert, SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL));
} // end of wxWindow::GetScrollPos
int wxWindow::GetScrollRange(
{
MRESULT mr;
- mr = ::WinSendMsg(GetHwnd(), SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);
+ if (nOrient == wxHORIZONTAL)
+ mr = ::WinSendMsg(m_hWndScrollBarHorz, SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);
+ else
+ mr = ::WinSendMsg(m_hWndScrollBarVert, SBM_QUERYRANGE, (MPARAM)NULL, (MPARAM)NULL);
return((int)SHORT2FROMMR(mr));
} // end of wxWindow::GetScrollRange
int nOrient
) const
{
- WNDPARAMS vWndParams;
- PSBCDATA pSbcd;
-
- ::WinSendMsg(GetHwnd(), WM_QUERYWINDOWPARAMS, (MPARAM)&vWndParams, (MPARAM)NULL);
- pSbcd = (PSBCDATA)vWndParams.pCtlData;
- return((int)pSbcd->posThumb);
+ if (nOrient == wxHORIZONTAL )
+ return m_nXThumbSize;
+ else
+ return m_nYThumbSize;
} // end of wxWindow::GetScrollThumb
void wxWindow::SetScrollPos(
, bool bRefresh
)
{
- ::WinSendMsg(GetHwnd(), SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
+ if (nOrient == wxHORIZONTAL )
+ ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
+ else
+ ::WinSendMsg(m_hWndScrollBarVert, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL);
} // end of wxWindow::SetScrollPos(
void wxWindow::SetScrollbar(
, bool bRefresh
)
{
- ::WinSendMsg(GetHwnd(), SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, nRange));
- if (nOrient == wxHORIZONTAL)
+ int nOldRange = nRange - nThumbVisible;
+ int nRange1 = nOldRange;
+ int nPageSize = nThumbVisible;
+ SBCDATA vInfo;
+ HWND hWnd = GetHwnd();
+ ULONG ulStyle = WS_VISIBLE | WS_SYNCPAINT;
+ RECTL vRect;
+
+ ::WinQueryWindowRect(hWnd, &vRect);
+ if (nPageSize > 1 && nRange > 0)
+ {
+ nRange1 += (nPageSize - 1);
+ }
+
+ vInfo.cb = sizeof(SBCDATA);
+ vInfo.posFirst = 0;
+ vInfo.posLast = (SHORT)nRange1;
+ vInfo.posThumb = nPos;
+
+ if (nOrient == wxHORIZONTAL )
{
- m_nXThumbSize = nThumbVisible;
+ ulStyle |= SBS_HORZ;
+ 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!
+ //
+ m_hWndScrollBarHorz = ::WinCreateWindow( hWnd
+ ,WC_SCROLLBAR
+ ,(PSZ)NULL
+ ,ulStyle
+ ,vRect.xLeft
+ ,vRect.yBottom
+ ,vRect.xRight - vRect.xLeft
+ ,20
+ ,hWnd
+ ,HWND_TOP
+ ,FID_HORZSCROLL
+ ,&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.
+ //
+ ::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
+ ,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);
+ }
}
else
{
+ ulStyle |= SBS_VERT;
+ if (m_hWndScrollBarVert == 0L)
+ {
+ m_hWndScrollBarVert = ::WinCreateWindow( hWnd
+ ,WC_SCROLLBAR
+ ,(PSZ)NULL
+ ,ulStyle
+ ,vRect.xRight - 20
+ ,vRect.yBottom + 20
+ ,20
+ ,vRect.yTop - (vRect.yBottom + 20)
+ ,hWnd
+ ,HWND_TOP
+ ,FID_VERTSCROLL
+ ,&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.
+ //
+ ::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);
+ }
m_nYThumbSize = nThumbVisible;
}
} // end of wxWindow::SetScrollbar
, const wxRect* pRect
)
{
+ RECTL vRect;
RECTL vRect2;
+ nDy *= -1; // flip the sign of Dy as OS/2 is opposite wxWin.
if (pRect)
{
vRect2.xLeft = pRect->x;
- vRect2.yTop = pRect->y;
+ vRect2.yTop = pRect->y + pRect->height;
vRect2.xRight = pRect->x + pRect->width;
- vRect2.yBottom = pRect->y + pRect->height;
+ 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;
+ }
if (pRect)
- ::WinScrollWindow(GetHwnd(), (LONG)nDx, (LONG)nDy, &vRect2, NULL, NULLHANDLE, NULL, 0L);
+ ::WinScrollWindow( GetHwnd()
+ ,(LONG)nDx
+ ,(LONG)nDy
+ ,&vRect2
+ ,NULL
+ ,NULLHANDLE
+ ,NULL
+ ,SW_INVALIDATERGN
+ );
else
- ::WinScrollWindow(GetHwnd(), nDx, nDy, NULL, NULL, NULLHANDLE, NULL, 0L);
+ ::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();
+ }
} // end of wxWindow::ScrollWindow
// ---------------------------------------------------------------------------
HWND hwnd = (HWND)hWnd;
wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") );
-
wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") );
-
- wxAssociateWinWithHandle(hwnd, this);
-
m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc);
- ::WinSetWindowULong(hwnd, QWS_USER, (ULONG)wxWndProc);
} // end of wxWindow::SubclassWin
void wxWindow::UnsubclassWin()
{
- wxRemoveHandleAssociation(this);
-
//
// Restore old Window proc
//
- HWND hwnd = GetHwnd();
+ HWND hwnd = GetHWND();
- if (hwnd)
+ if (m_hWnd)
{
- m_hWnd = 0;
-
wxCHECK_RET( ::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in UnsubclassWin") );
- PFNWP fnProc = (PFNWP)::WinQueryWindowULong(hwnd, QWS_USER);
+ PFNWP fnProc = (PFNWP)::WinQueryWindowPtr(hwnd, QWP_PFNWP);
+
if ( (m_fnOldWndProc != 0) && (fnProc != (PFNWP) m_fnOldWndProc))
{
WinSubclassWindow(hwnd, (PFNWP)m_fnOldWndProc);
)
{
//
- // PM does not support extended style
+ // Simply fill out with wxWindow extended styles. We'll conjure
+ // something up in OS2Create and all window redrawing pieces later
//
- WXDWORD exStyle = 0;
- return exStyle;
+ WXDWORD dwStyle = 0;
+
+ if (lStyle & wxTRANSPARENT_WINDOW )
+ dwStyle |= wxTRANSPARENT_WINDOW;
+
+ if (!bEliminateBorders)
+ {
+ if (lStyle & wxSUNKEN_BORDER)
+ dwStyle |= wxSUNKEN_BORDER;
+ if (lStyle & wxDOUBLE_BORDER)
+ dwStyle |= wxDOUBLE_BORDER;
+ if (lStyle & wxRAISED_BORDER )
+ dwStyle |= wxRAISED_BORDER;
+ if (lStyle & wxSTATIC_BORDER)
+ dwStyle |= wxSTATIC_BORDER;
+ }
+ return dwStyle;
} // end of wxWindow::MakeExtendedStyle
//
-// Determines whether native 3D effects or CTL3D should be used,
+// Determines whether simulated 3D effects or CTL3D should be used,
// applying a default border style if required, and returning an extended
-// style to pass to CreateWindowEx.
+// style to pass to OS2Create.
//
WXDWORD wxWindow::Determine3DEffects(
WXDWORD dwDefaultBorderStyle
WXDWORD dwStyle = 0L;
//
- // Native PM does not have any specialize 3D effects like WIN32 does
+ // Native PM does not have any specialize 3D effects like WIN32 does,
+ // so we have to try and invent them.
+ //
+
+ //
+ // If matches certain criteria, then assume no 3D effects
+ // unless specifically requested (dealt with in MakeExtendedStyle)
+ //
+ if (!GetParent() ||
+ !IsKindOf(CLASSINFO(wxControl)) ||
+ (m_windowStyle & wxNO_BORDER)
+ )
+ {
+ *pbWant3D = FALSE;
+ return MakeExtendedStyle(m_windowStyle, FALSE);
+ }
+
+ //
+ // 1) App can specify global 3D effects
+ //
+ *pbWant3D = wxTheApp->GetAuto3D();
+
+ //
+ // 2) If the parent is being drawn with user colours, or simple border
+ // specified, switch effects off.
+ //
+ if (GetParent() &&
+ (GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS) ||
+ (m_windowStyle & wxSIMPLE_BORDER)
+ )
+ *pbWant3D = FALSE;
+
+ //
+ // 3) Control can override this global setting by defining
+ // a border style, e.g. wxSUNKEN_BORDER
//
- *pbWant3D = FALSE;
+ if ((m_windowStyle & wxDOUBLE_BORDER) ||
+ (m_windowStyle & wxRAISED_BORDER) ||
+ (m_windowStyle & wxSTATIC_BORDER) ||
+ (m_windowStyle & wxSUNKEN_BORDER)
+ )
+ *pbWant3D = TRUE;
+
+ dwStyle = MakeExtendedStyle( m_windowStyle
+ ,FALSE
+ );
+
+ //
+ // If we want 3D, but haven't specified a border here,
+ // apply the default border style specified.
+ //
+ if (dwDefaultBorderStyle && (*pbWant3D) &&
+ !((m_windowStyle & wxDOUBLE_BORDER) ||
+ (m_windowStyle & wxRAISED_BORDER) ||
+ (m_windowStyle & wxSTATIC_BORDER) ||
+ (m_windowStyle & wxSIMPLE_BORDER)
+ )
+ )
+ dwStyle |= dwDefaultBorderStyle;
return dwStyle;
} // end of wxWindow::Determine3DEffects
HWND hWndClient;
RECTL vRect;
- hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
- ::WinQueryWindowRect(hWndClient, &vRect);
+ if (IsKindOf(CLASSINFO(wxFrame)))
+ hWndClient = ::WinWindowFromID(GetHwnd(), FID_CLIENT);
+ else
+ hWndClient = NULLHANDLE;
+ if( hWndClient == NULLHANDLE)
+ ::WinQueryWindowRect(GetHwnd(), &vRect);
+ else
+ ::WinQueryWindowRect(hWndClient, &vRect);
if (pWidth)
*pWidth = vRect.xRight;
hPs = ::WinGetPS(GetHwnd());
if(!GpiQueryFontMetrics(hPs, sizeof(FONTMETRICS), &vFontMetrics))
+ {
+ ::WinReleasePS(hPs);
return (0);
- else
- return(vFontMetrics.lMaxAscender + vFontMetrics.lMaxDescender);
+ }
::WinReleasePS(hPs);
+ return(vFontMetrics.lMaxAscender + vFontMetrics.lMaxDescender);
} // end of wxWindow::GetCharHeight
int wxWindow::GetCharWidth() const
hPs = ::WinGetPS(GetHwnd());
if(!GpiQueryFontMetrics(hPs, sizeof(FONTMETRICS), &vFontMetrics))
+ {
+ ::WinReleasePS(hPs);
return (0);
- else
- return(vFontMetrics.lAveCharWidth);
+ }
::WinReleasePS(hPs);
+ return(vFontMetrics.lAveCharWidth);
} // end of wxWindow::GetCharWidth
void wxWindow::GetTextExtent(
)
{
if (m_fnOldWndProc)
- return ((MRESULT)m_fnOldWndProc());
+ return (MRESULT)m_fnOldWndProc(GetHWND(), (ULONG)uMsg, (MPARAM)wParam, (MPARAM)lParam);
else
- return (::WinDefWindowProc(GetHwnd(), (ULONG)uMsg, (MPARAM)wParam, (MPARAM)lParam));
+ return ::WinDefWindowProc(GetHWND(), (ULONG)uMsg, (MPARAM)wParam, (MPARAM)lParam);
} // end of wxWindow::OS2DefWindowProc
bool wxWindow::OS2ProcessMessage(
}
}
}
+ //
+ // Let Dialogs process
+ //
+ if (::WinSendMsg(pQMsg->hwnd, WM_QUERYDLGCODE, pQMsg, 0));
+ return TRUE;
}
- //
- // Let Dialogs process
- //
- if (::WinSendMsg(pQMsg->hwnd, WM_QUERYDLGCODE, pQMsg, 0));
- return TRUE;
#if wxUSE_TOOLTIPS
if ( m_tooltip )
WXMSG* pMsg
)
{
- return m_acceleratorTable.Translate(this, pMsg);
+#if wxUSE_ACCEL
+ return m_acceleratorTable.Translate(m_hWnd, pMsg);
+#else
+ return FALSE;
+#endif //wxUSE_ACCEL
} // end of wxWindow::OS2TranslateMessage
// ---------------------------------------------------------------------------
)
{
*pId = LOWORD(wParam);
- *phWnd = (WXHWND)lParam;
- *pCmd = HIWORD(wParam);
+ *phWnd = NULL; // or may be GetHWND() ?
+ *pCmd = LOWORD(lParam);
} // end of wxWindow::UnpackCommand
void wxWindow::UnpackActivate(
, WXHWND* phWnd
)
{
- *pCode = LOWORD(wParam);
- *pPos = HIWORD(wParam);
- *phWnd = (WXHWND)lParam;
+ ULONG ulId;
+ HWND hWnd;
+
+ ulId = (ULONG)LONGFROMMP(wParam);
+ hWnd = ::WinWindowFromID(GetHwnd(), ulId);
+ if (hWnd == m_hWndScrollBarHorz || hWnd == m_hWndScrollBarVert)
+ *phWnd = NULLHANDLE;
+ else
+ *phWnd = hWnd;
+
+ *pPos = SHORT1FROMMP(lParam);
+ *pCode = SHORT2FROMMP(lParam);
} // end of wxWindow::UnpackScroll
void wxWindow::UnpackMenuSelect(
//
// Main window proc
//
-MRESULT wxWndProc(
+MRESULT EXPENTRY wxWndProc(
HWND hWnd
, ULONG ulMsg
, MPARAM wParam
pWnd->SetHWND((WXHWND)hWnd);
}
- MRESULT rc;
+ MRESULT rc = (MRESULT)0;
+
//
// Stop right here if we don't have a valid handle in our wxWindow object.
else
rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
}
+
return rc;
} // end of wxWndProc
// Did we process the uMsg?
//
bool bProcessed = FALSE;
-
- //
- // The return value
- //
- union
- {
- bool bAllow;
- MRESULT mResult;
- WXHICON hIcon;
- WXHBRUSH hBrush;
- } vRc;
+ bool bAllow;
+ MRESULT mResult;
+ WXHICON hIcon;
+ WXHBRUSH hBrush;
//
// For most messages we should return 0 when we do process the message
//
- vRc.mResult = (MRESULT)0;
+ mResult = (MRESULT)0;
switch (uMsg)
{
//
// Return 0 to bAllow window creation
//
- vRc.mResult = (MRESULT)(bMayCreate ? 0 : -1);
+ mResult = (MRESULT)(bMayCreate ? 0 : -1);
}
}
break;
case WM_DESTROY:
- bProcessed = HandleDestroy();
- break;
+ HandleDestroy();
+ bProcessed = TRUE;
+ break;
case WM_MOVE:
bProcessed = HandleMove( LOWORD(lParam)
bProcessed = HandleActivate( wState
,(WXHWND)hWnd
);
+ bProcessed = FALSE;
}
break;
// ourselves in ~wxWindow
//
bProcessed = TRUE;
- vRc.mResult = (MRESULT)TRUE;
+ mResult = (MRESULT)TRUE;
break;
case WM_SHOW:
bProcessed = HandleMouseEvent(uMsg, x, y, (WXUINT)wParam);
}
break;
-
case WM_SYSCOMMAND:
bProcessed = HandleSysCommand(wParam, lParam);
break;
case WM_DRAWITEM:
case WM_MEASUREITEM:
{
- int idCtrl = (UINT)wParam;
+ int nIdCtrl = (UINT)wParam;
+
if ( uMsg == WM_DRAWITEM )
{
- bProcessed = OS2OnDrawItem(idCtrl,
+ bProcessed = OS2OnDrawItem(nIdCtrl,
(WXDRAWITEMSTRUCT *)lParam);
}
else
{
- bProcessed = OS2OnMeasureItem(idCtrl,
+ bProcessed = OS2OnMeasureItem(nIdCtrl,
(WXMEASUREITEMSTRUCT *)lParam);
}
if ( bProcessed )
- vRc.mResult = (MRESULT)TRUE;
+ mResult = (MRESULT)TRUE;
}
break;
case WM_QUERYDLGCODE:
if ( m_lDlgCode )
{
- vRc.mResult = (MRESULT)m_lDlgCode;
+ mResult = (MRESULT)m_lDlgCode;
bProcessed = TRUE;
}
//
#if defined(__VISAGECPP__) && (__IBMCPP__ >= 400)
case WM_CTLCOLORCHANGE:
{
- bProcessed = HandleCtlColor(&vRc.hBrush);
+ bProcessed = HandleCtlColor(&hBrush);
}
break;
#endif
+ case WM_ERASEBACKGROUND:
+ //
+ // Returning TRUE to requestw PM to paint the window background
+ // in SYSCLR_WINDOW. We don't really want that
+ //
+ bProcessed = HandleEraseBkgnd((WXHDC)(HPS)wParam);
+ mResult = (MRESULT)(FALSE);
+ break;
+
//
// Instead of CTLCOLOR messages PM sends QUERYWINDOWPARAMS to
// things such as colors and fonts and such
bProcessed = HandlePresParamChanged(wParam);
break;
- // move this to wxFrame
- case WM_ERASEBACKGROUND:
- bProcessed = HandleEraseBkgnd((WXHDC)(HDC)wParam);
- if (bProcessed)
- {
- //
- // We processed the message, i.e. erased the background
- //
- vRc.mResult = (MRESULT)TRUE;
- }
- break;
// move all drag and drops to wxDrg
case WM_ENDDRAG:
if ( bProcessed )
{
// we never set focus from here
- vRc.mResult = FALSE;
+ mResult = FALSE;
}
break;
// wxFrame specific message
case WM_MINMAXFRAME:
- bProcessed = HandleGetMinMaxInfo((PSWP)lParam);
+ bProcessed = HandleGetMinMaxInfo((PSWP)wParam);
break;
case WM_SYSVALUECHANGED:
// TODO: do something
- vRc.mResult = (MRESULT)TRUE;
+ mResult = (MRESULT)TRUE;
break;
//
// processing this message - exactly what we need because we've
// just set the cursor.
//
- vRc.mResult = (MRESULT)TRUE;
+ mResult = (MRESULT)TRUE;
}
break;
}
-
if (!bProcessed)
{
#ifdef __WXDEBUG__
wxLogTrace(wxTraceMessages, wxT("Forwarding %s to DefWindowProc."),
wxGetMessageName(uMsg));
#endif // __WXDEBUG__
- vRc.mResult = OS2DefWindowProc(uMsg, wParam, lParam);
+ if (IsKindOf(CLASSINFO(wxFrame)))
+ mResult = ::WinDefWindowProc(m_hWnd, uMsg, wParam, lParam);
+ else
+ mResult = OS2DefWindowProc(uMsg, wParam, lParam);
}
- return vRc.mResult;
+ return mResult;
} // end of wxWindow::OS2WindowProc
//
} // end of wxWindow::OS2DetachWindowMenu
bool wxWindow::OS2Create(
- int vId
-, wxWindow* pParent
-, const wxChar* zWclass
-, wxWindow* pWxWin
+ WXHWND hParent
+, PSZ zClass
, const wxChar* zTitle
-, int nX
-, int nY
-, int nWidth
-, int nHeight
, WXDWORD dwStyle
-, const wxChar* zDialogTemplate
-, WXDWORD dwExtendedStyle // Port compatability only
+, long lX
+, long lY
+, long lWidth
+, long lHeight
+, WXHWND hOwner
+, WXHWND hZOrder
+, unsigned long ulId
+, void* pCtlData
+, void* pPresParams
+, WXDWORD dwExStyle
)
{
- int nX1 = CW_USEDEFAULT;
- int nY1 = 0;
- int nWidth1 = CW_USEDEFAULT;
- int nHeight1 = 100;
+ 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
RECTL vParentRect;
HWND hWndClient;
- HWND hParent = (HWND)NULL;
-
- if (pParent)
- {
- hParent = (HWND)pParent->GetHWND();
- hWndClient = ::WinWindowFromID(hParent, FID_CLIENT);
- ::WinQueryWindowRect(hWndClient, &vParentRect);
-
- nWidth1 = vParentRect.xRight - vParentRect.xLeft;
- nHeight1 = vParentRect.yTop - vParentRect.yBottom;
- }
-
- if (nX > -1)
- nX1 = nX;
- if (nY > -1)
- nY1 = nY;
- if (nWidth > -1)
- nWidth1 = nWidth;
- if (nHeight > -1)
- nHeight1 = nHeight;
+ lX1 = lX;
+ lY1 = lY;
+ if (lWidth > -1L)
+ lWidth1 = lWidth;
+ if (lHeight > -1L)
+ lHeight1 = lHeight;
wxWndHook = this;
- if (zDialogTemplate)
+ //
+ // 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
+ )
{
- //
- // We can use extended styles for custom default user config params
- // These can be processed in the dialog proc's WM_INITDLG
- // Dialog template is defined by vId and should be loaded from the
- // resource file in the current .exe
- //
- PDLGTEMPLATE pDlgt;
-
- ::DosGetResource(0L, RT_DIALOG, vId, (PPVOID)&pDlgt);
- m_hWnd = (WXHWND)::WinCreateDlg( pParent->GetHWND()
- ,NULLHANDLE
- ,(PFNWP)wxDlgProc
- ,pDlgt
- ,(PVOID)&dwExtendedStyle
- );
- if (m_hWnd == 0)
- {
- wxLogError(_("Can't find dummy dialog template!\n"
- "Check resource include path for finding wx.rc."));
- return FALSE;
- }
-
- //
- // Move the dialog to its initial position without forcing repainting
- //
- if (!::WinSetWindowPos( m_hWnd
- ,HWND_TOP
- ,nX1
- ,nY1
- ,nWidth1
- ,nHeight1
- ,SWP_MOVE | SWP_SIZE | SWP_NOREDRAW
- ));
- {
- wxLogLastError(wxT("MoveWindow"));
- }
+ nControlId = ulId;
}
else
{
- int nControlId = 0;
- WXDWORD dwClass = dwStyle | 0xffff0000;
-
- //
- // check to see if the new window is a standard control
- //
- if (dwClass & (ULONG)WC_BUTTON ||
- dwClass & (ULONG)WC_COMBOBOX ||
- dwClass & (ULONG)WC_CONTAINER ||
- dwClass & (ULONG)WC_ENTRYFIELD ||
- dwClass & (ULONG)WC_LISTBOX ||
- dwClass & (ULONG)WC_MENU ||
- dwClass & (ULONG)WC_NOTEBOOK ||
- dwClass & (ULONG)WC_SCROLLBAR ||
- dwClass & (ULONG)WC_SPINBUTTON ||
- dwClass & (ULONG)WC_STATIC ||
- dwClass & (ULONG)WC_TITLEBAR ||
- dwClass & (ULONG)WC_VALUESET
- )
- nControlId = vId;
-
- wxString sClassName(zWclass);
-
- if (GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE )
+ // no standard controls
+ if(wxString (wxT("wxFrameClass")) == wxString(zClass) )
{
- sClassName += wxT("NR");
+ pszClass = WC_FRAME;
+ nNeedsubclass = 1;
}
-
- m_hWnd = (WXHWND)::WinCreateWindow( hParent
- ,(PSZ)sClassName.c_str()
- ,zTitle ? zTitle : wxT("")
- ,dwStyle
- ,nX1
- ,nY1
- ,nWidth
- ,nHeight
- ,NULLHANDLE
- ,HWND_TOP
- ,vId
- ,NULL
- ,NULL
- );
- if (!m_hWnd)
+ else
{
- wxLogError("Can't create window of class %s!\n", zWclass);
- return FALSE;
+ nControlId = ulId;
+ if(nControlId < 0)
+ nControlId = FID_CLIENT;
}
}
+
+ //
+ // We will either have a registered class via string name or a standard PM Class via a long
+ //
+ m_hWnd = (WXHWND)::WinCreateWindow( (HWND)hParent
+ ,zClass
+ ,(PSZ)zTitle ? zTitle : wxT("")
+ ,(ULONG)dwStyle
+ ,(LONG)lX1
+ ,(LONG)lY1
+ ,(LONG)lWidth
+ ,(LONG)lHeight
+ ,hOwner
+ ,HWND_TOP
+ ,(ULONG)nControlId
+ ,pCtlData
+ ,pPresParams
+ );
+ if (!m_hWnd)
+ {
+ vError = ::WinGetLastError(vHabmain);
+ 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__
wxAssociateWinWithHandle((HWND)m_hWnd
,this
);
+ //
+ // Now need to subclass window.
+ //
+ if(!nNeedsubclass)
+ {
+ wxAssociateWinWithHandle((HWND)m_hWnd,this);
+ }
+ else
+ {
+ SubclassWin(GetHWND());
+ }
return TRUE;
} // end of wxWindow::OS2Create
, WXDRAWITEMSTRUCT* pItemStruct
)
{
- //
- // I'll get to owner drawn stuff later
- //
+ wxDC vDc;
+#if wxUSE_OWNER_DRAWN
//
- // is it a menu item or control?
+ // Is it a menu item?
//
- wxWindow* pItem = FindItem(vId);
-
-#if wxUSE_OWNER_DRAWN
- if (pItem && pItem->IsKindOf(CLASSINFO(wxControl)))
- {
- return ((wxControl *)pItem)->OS2OnDraw(pItemStruct);
- }
- else if (pItem && pItem->IsKindOf(CLASSINFO(wxMenu)))
+ if (vId == 0)
{
- /*
- // TODO: draw a menu item
+ ERRORID vError;
+ wxString sError;
+ POWNERITEM pMeasureStruct = (POWNERITEM)pItemStruct;
+ wxFrame* pFrame = (wxFrame*)this;
+ wxMenuItem* pMenuItem = pFrame->GetMenuBar()->FindItem(pMeasureStruct->idItem, pMeasureStruct->hItem);
+ HDC hDC = ::GpiQueryDevice(pMeasureStruct->hps);
+ wxRect vRect( pMeasureStruct->rclItem.xLeft
+ ,pMeasureStruct->rclItem.yBottom
+ ,pMeasureStruct->rclItem.xRight - pMeasureStruct->rclItem.xLeft
+ ,pMeasureStruct->rclItem.yTop - pMeasureStruct->rclItem.yBottom
+ );
+ vDc.SetHDC( hDC
+ ,FALSE
+ );
+ vDc.SetHPS(pMeasureStruct->hps);
+ //
+ // Load the wxWindows Pallete and set to RGB mode
+ //
+ if (!::GpiCreateLogColorTable( pMeasureStruct->hps
+ ,0L
+ ,LCOLF_CONSECRGB
+ ,0L
+ ,(LONG)wxTheColourDatabase->m_nSize
+ ,(PLONG)wxTheColourDatabase->m_palTable
+ ))
+ {
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ wxLogError("Unable to set current color table. Error: %s\n", sError);
+ }
+ //
+ // Set the color table to RGB mode
//
- POWNERITEM pDrawStruct = (OWNERITEM *)pItemStruct;
- wxMenuItem* pMenuItem = (wxMenuItem *)(pDrawStruct->pItemData);
+ if (!::GpiCreateLogColorTable( pMeasureStruct->hps
+ ,0L
+ ,LCOLF_RGB
+ ,0L
+ ,0L
+ ,NULL
+ ))
+ {
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ wxLogError("Unable to set current color table. Error: %s\n", sError);
+ }
+
+ wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
- wxCHECK(pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE);
+ int eAction = 0;
+ int eStatus = 0;
+
+ if (pMeasureStruct->fsAttribute == pMeasureStruct->fsAttributeOld)
+ {
+ //
+ // Entire Item needs to be redrawn (either it has reappeared from
+ // behind another window or is being displayed for the first time
+ //
+ eAction = wxOwnerDrawn::wxODDrawAll;
+
+ if (pMeasureStruct->fsAttribute & MIA_HILITED)
+ {
+ //
+ // If it is currently selected we let the system handle it
+ //
+ eStatus |= wxOwnerDrawn::wxODSelected;
+ }
+ if (pMeasureStruct->fsAttribute & MIA_CHECKED)
+ {
+ //
+ // If it is currently checked we draw our own
+ //
+ eStatus |= wxOwnerDrawn::wxODChecked;
+ pMeasureStruct->fsAttributeOld = pMeasureStruct->fsAttribute &= ~MIA_CHECKED;
+ }
+ if (pMeasureStruct->fsAttribute & MIA_DISABLED)
+ {
+ //
+ // If it is currently disabled we let the system handle it
+ //
+ eStatus |= wxOwnerDrawn::wxODDisabled;
+ }
+ //
+ // Don't really care about framed (indicationg focus) or NoDismiss
+ //
+ }
+ else
+ {
+ if (pMeasureStruct->fsAttribute & MIA_HILITED)
+ {
+ eAction = wxOwnerDrawn::wxODDrawAll;
+ eStatus |= wxOwnerDrawn::wxODSelected;
+ //
+ // Keep the system from trying to highlight with its bogus colors
+ //
+ pMeasureStruct->fsAttributeOld = pMeasureStruct->fsAttribute &= ~MIA_HILITED;
+ }
+ else if (!(pMeasureStruct->fsAttribute & MIA_HILITED))
+ {
+ eAction = wxOwnerDrawn::wxODDrawAll;
+ eStatus = 0;
+ //
+ // Keep the system from trying to highlight with its bogus colors
+ //
+ pMeasureStruct->fsAttribute = pMeasureStruct->fsAttributeOld &= ~MIA_HILITED;
+ }
+ else
+ {
+ //
+ // For now we don't care about anything else
+ // just ignore the entire message!
+ //
+ return TRUE;
+ }
+ }
//
- // Prepare to call OnDrawItem()
+ // Now redraw the item
+ //
+ return(pMenuItem->OnDrawItem( vDc
+ ,vRect
+ ,(wxOwnerDrawn::wxODAction)eAction
+ ,(wxOwnerDrawn::wxODStatus)eStatus
+ ));
+ //
+ // leave the fsAttribute and fsOldAttribute unchanged. If different,
+ // the system will do the highlight or fraeming or disabling for us,
+ // otherwise, we'd have to do it ourselves.
//
- HPSdc;
- dc.SetHDC((WXHDC)pDrawStruct->hDC, FALSE);
- wxRect rect(pDrawStruct->rcItem.left, pDrawStruct->rcItem.top,
- pDrawStruct->rcItem.right - pDrawStruct->rcItem.left,
- pDrawStruct->rcItem.bottom - pDrawStruct->rcItem.top);
-
- return pMenuItem->OnDrawItem
- (
- dc, rect,
- (wxOwnerDrawn::wxODAction)pDrawStruct->itemAction,
- (wxOwnerDrawn::wxODStatus)pDrawStruct->itemState
- );
- */
}
- else
- return FALSE;
+ wxWindow* pItem = FindItem(vId);
+
+ if (pItem && pItem->IsKindOf(CLASSINFO(wxControl)))
+ {
+ return ((wxControl *)pItem)->OS2OnDraw(pItemStruct);
+ }
#endif
- return TRUE;
+ return FALSE;
} // end of wxWindow::OS2OnDrawItem
-bool wxWindow::OS2OnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
+bool wxWindow::OS2OnMeasureItem(
+ int lId
+, WXMEASUREITEMSTRUCT* pItemStruct
+)
{
- // TODO: more owner drawn menu related stuff, get to it later
-/*
-#if wxUSE_OWNER_DRAWN
- // is it a menu item?
- if ( id == 0 )
+ //
+ // Is it a menu item?
+ //
+ if (lId == 65536) // I really don't like this...has to be a better indicator
{
- MEASUREITEMSTRUCT *pMeasureStruct = (MEASUREITEMSTRUCT *)itemStruct;
- wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
-
- wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
-
- return pMenuItem->OnMeasureItem(&pMeasureStruct->itemWidth,
- &pMeasureStruct->itemHeight);
+ if (IsKindOf(CLASSINFO(wxFrame))) // we'll assume if Frame then a menu
+ {
+ size_t nWidth;
+ size_t nHeight;
+ POWNERITEM pMeasureStruct = (POWNERITEM)pItemStruct;
+ wxFrame* pFrame = (wxFrame*)this;
+ wxMenuItem* pMenuItem = pFrame->GetMenuBar()->FindItem(pMeasureStruct->idItem, pMeasureStruct->hItem);
+
+ wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
+ nWidth = 0L;
+ nHeight = 0L;
+ if (pMenuItem->OnMeasureItem( &nWidth
+ ,&nHeight
+ ))
+ {
+ pMeasureStruct->rclItem.xRight = nWidth;
+ pMeasureStruct->rclItem.xLeft = 0L;
+ pMeasureStruct->rclItem.yTop = nHeight;
+ pMeasureStruct->rclItem.yBottom = 0L;
+ return TRUE;
+ }
+ return FALSE;
+ }
}
+ wxWindow* pItem = FindItem(lId);
- wxWindow *item = FindItem(id);
- if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
+ if (pItem && pItem->IsKindOf(CLASSINFO(wxControl)))
{
- return ((wxControl *)item)->MSWOnMeasure(itemStruct);
+ return ((wxControl *)pItem)->OS2OnMeasure(pItemStruct);
}
-#endif // owner-drawn menus
-*/
return FALSE;
}
bool wxWindow::HandlePaint()
{
HRGN hRgn = NULLHANDLE;
+ wxPaintEvent vEvent;
+ HPS hPS;
+ RECTL vRect;
if (::WinQueryUpdateRegion(GetHwnd(), hRgn) == RGN_NULL)
{
wxLogLastError("CreateRectRgn");
return FALSE;
}
+
m_updateRegion = wxRegion(hRgn);
+ vEvent.SetEventObject(this);
+ if (!GetEventHandler()->ProcessEvent(vEvent))
+ {
+ HPS hPS;
- wxPaintEvent vEvent;
+ 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
+ );
- vEvent.SetEventObject(this);
+ ::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);
+ }
+ }
return (GetEventHandler()->ProcessEvent(vEvent));
} // end of wxWindow::HandlePaint
-bool wxWindow::HandleEraseBkgnd(WXHDC hdc)
+bool wxWindow::HandleEraseBkgnd(
+ WXHDC hDC
+)
{
- // TODO: will have to worry about this later as part of
- // the handling of changed presentation parameters
- /*
- if ( ::IsIconic(GetHwnd()) )
+ SWP vSwp;
+
+ ::WinQueryWindowPos(GetHwnd(), &vSwp);
+ if (vSwp.fl & SWP_MINIMIZE)
return TRUE;
- wxDC dc;
+ wxDC vDC;
+
+ vDC.m_hPS = (HPS)hDC; // this is really a PS
+ vDC.SetWindow(this);
+ vDC.BeginDrawing();
+
+ wxEraseEvent vEvent(m_windowId, &vDC);
- dc.SetHDC(hdc);
- dc.SetWindow(this);
- dc.BeginDrawing();
+ vEvent.SetEventObject(this);
- wxEraseEvent event(m_windowId, &dc);
- event.SetEventObject(this);
- bool rc = GetEventHandler()->ProcessEvent(event);
+ bool rc = GetEventHandler()->ProcessEvent(vEvent);
- dc.EndDrawing();
- dc.SelectOldObjects(hdc);
- dc.SetHDC((WXHDC) NULL);
- */
+ vDC.EndDrawing();
+ vDC.m_hPS = NULLHANDLE;
return TRUE;
} // end of wxWindow::HandleEraseBkgnd
wxEraseEvent& rEvent
)
{
- // TODO:
+ RECTL vRect;
+ HPS hPS = rEvent.m_dc->m_hPS;
+
+ ::WinQueryWindowRect(GetHwnd(), &vRect);
+ ::WinFillRect(hPS, &vRect, m_backgroundColour.GetPixel());
} // end of wxWindow::OnEraseBackground
// ---------------------------------------------------------------------------
pWin->ScreenToClient(pX, pY);
} // end of TranslateKbdEventToMouse
+// Find the wxWindow at the current mouse position, returning the mouse
+// position.
+wxWindow* wxFindWindowAtPointer(
+ wxPoint& rPt
+)
+{
+ return wxFindWindowAtPoint(wxGetMousePosition());
+}
+
+wxWindow* wxFindWindowAtPoint(
+ const wxPoint& rPt
+)
+{
+ POINTL vPt2;
+
+ vPt2.x = rPt.x;
+ vPt2.y = rPt.y;
+
+ HWND hWndHit = ::WinWindowFromPoint(HWND_DESKTOP, &vPt2, FALSE);
+ wxWindow* pWin = wxFindWinFromHandle((WXHWND)hWndHit) ;
+ HWND hWnd = hWndHit;
+
+ //
+ // Try to find a window with a wxWindow associated with it
+ //
+ while (!pWin && (hWnd != 0))
+ {
+ hWnd = ::WinQueryWindow(hWnd, QW_PARENT);
+ pWin = wxFindWinFromHandle((WXHWND)hWnd) ;
+ }
+ return pWin;
+}
+
+// Get the current mouse position.
+wxPoint wxGetMousePosition()
+{
+ POINTL vPt;
+
+ ::WinQueryPointerPos(HWND_DESKTOP, &vPt);
+ return wxPoint(vPt.x, vPt.y);
+}
+
projects / wxWidgets.git / blobdiff