X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/61243a510fe15e04996a986daaa53ed9fee75484..6433f6d3165a3f8633f42c59694a9104a7b37a93:/src/os2/window.cpp?ds=sidebyside diff --git a/src/os2/window.cpp b/src/os2/window.cpp index 01e0e83c30..846ed5696f 100644 --- a/src/os2/window.cpp +++ b/src/os2/window.cpp @@ -33,6 +33,7 @@ #include "wx/listbox.h" #include "wx/button.h" #include "wx/msgdlg.h" + #include "wx/scrolwin.h" #include #endif @@ -84,19 +85,25 @@ #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 // --------------------------------------------------------------------------- // -// The last Windows message we got (MT-UNSAFE) +// The last PM message we got (MT-UNSAFE) // QMSG s_currentMsg; +#if wxUSE_MENUS_NATIVE wxMenu* wxCurrentPopupMenu = NULL; -extern wxList WXDLLEXPORT wxPendingDelete; -#if defined(__VISAGECPP__) && (__IBMCPP__ < 400) -extern wxChar* wxCanvasClassName; +#endif // wxUSE_MENUS_NATIVE + +#if !defined(__VISAGECPP__) || (__IBMCPP__ < 400) +extern wxChar wxCanvasClassName[]; #endif wxList* wxWinHandleList = NULL; @@ -107,19 +114,19 @@ 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); #endif //__WXDEBUG__ -void wxRemoveHandleAssociation(wxWindow* pWin); -void wxAssociateWinWithHandle( HWND hWnd - ,wxWindow* pWin +void wxRemoveHandleAssociation(wxWindowOS2* pWin); +void wxAssociateWinWithHandle( HWND hWnd + ,wxWindowOS2* pWin ); wxWindow* wxFindWinFromHandle(WXHWND hWnd); @@ -127,12 +134,14 @@ 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 // @@ -142,41 +151,55 @@ static inline bool IsCtrlDown() { return (::WinGetKeyState(HWND_DESKTOP, VK_CTRL // event tables // --------------------------------------------------------------------------- +// in wxUniv-OS/2 this class is abstract because it doesn't have DoPopupMenu() +// method +#ifdef __WXUNIVERSAL__ + IMPLEMENT_ABSTRACT_CLASS(wxWindowOS2, wxWindowBase) +#else // __WXPM__ IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase) - -BEGIN_EVENT_TABLE(wxWindow, wxWindowBase) - EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground) - EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged) - EVT_INIT_DIALOG(wxWindow::OnInitDialog) - EVT_IDLE(wxWindow::OnIdle) +#endif // __WXUNIVERSAL__/__WXPM__ + +BEGIN_EVENT_TABLE(wxWindowOS2, wxWindowBase) + EVT_ERASE_BACKGROUND(wxWindowOS2::OnEraseBackground) + EVT_SYS_COLOUR_CHANGED(wxWindowOS2::OnSysColourChanged) + EVT_INIT_DIALOG(wxWindowOS2::OnInitDialog) + EVT_IDLE(wxWindowOS2::OnIdle) + EVT_SET_FOCUS(wxWindowOS2::OnSetFocus) END_EVENT_TABLE() // =========================================================================== // implementation // =========================================================================== +// --------------------------------------------------------------------------- +// wxWindow utility functions +// --------------------------------------------------------------------------- + // // Find an item given the PM Window id // -wxWindow* wxWindow::FindItem( +wxWindow* wxWindowOS2::FindItem( long lId ) const { - wxControl* pItem = wxDynamicCast( this - ,wxControl - ); +#if wxUSE_CONTROLS + wxControl* pItem = wxDynamicCast(this, wxControl); if (pItem) { // // I it we or one of our "internal" children? // - if (pItem->GetId() == lId || - (pItem->GetSubcontrols().Index(lId) != wxNOT_FOUND)) + if (pItem->GetId() == lId +#ifndef __WXUNIVERSAL__ + || (pItem->GetSubcontrols().Index(lId) != wxNOT_FOUND) +#endif + ) { return pItem; } } +#endif // wxUSE_CONTROLS wxWindowList::Node* pCurrent = GetChildren().GetFirst(); @@ -191,12 +214,12 @@ wxWindow* wxWindow::FindItem( pCurrent = pCurrent->GetNext(); } return(NULL); -} // end of wxWindow::FindItem +} // end of wxWindowOS2::FindItem // // Find an item given the PM Window handle // -wxWindow* wxWindow::FindItemByHWND( +wxWindow* wxWindowOS2::FindItemByHWND( WXHWND hWnd , bool bControlOnly ) const @@ -215,7 +238,11 @@ wxWindow* wxWindow::FindItemByHWND( if (pWnd) return(pWnd); - if (!bControlOnly || pParent->IsKindOf(CLASSINFO(wxControl))) + if (!bControlOnly +#if wxUSE_CONTROLS + || pParent->IsKindOf(CLASSINFO(wxControl)) +#endif // wxUSE_CONTROLS + ) { wxWindow* pItem = pCurrent->GetData(); @@ -230,12 +257,12 @@ wxWindow* wxWindow::FindItemByHWND( pCurrent = pCurrent->GetNext(); } return(NULL); -} // end of wxWindow::FindItemByHWND +} // end of wxWindowOS2::FindItemByHWND // // Default command handler // -bool wxWindow::OS2Command( +bool wxWindowOS2::OS2Command( WXUINT WXUNUSED(uParam) , WXWORD WXUNUSED(uId) ) @@ -247,7 +274,7 @@ bool wxWindow::OS2Command( // constructors and such // ---------------------------------------------------------------------------- -void wxWindow::Init() +void wxWindowOS2::Init() { // // Generic @@ -268,8 +295,10 @@ void wxWindow::Init() // // wxWnd // - m_hMenu = 0; - m_hWnd = 0; + m_hMenu = 0L; + m_hWnd = 0L; + m_hWndScrollBarHorz = 0L; + m_hWndScrollBarVert = 0L; // // Pass WM_GETDLGCODE to DefWindowProc() @@ -289,19 +318,32 @@ void wxWindow::Init() m_lLastMouseY = -1; m_nLastMouseEvent = -1; #endif // wxUSE_MOUSEEVENT_HACK -} // wxWindow::Init +} // wxWindowOS2::Init // // Destructor // -wxWindow::~wxWindow() +wxWindowOS2::~wxWindowOS2() { 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); + } + } + + DestroyChildren(); + if (m_parent) m_parent->RemoveChild(this); - DestroyChildren(); + if (m_hWnd) { if(!::WinDestroyWindow(GetHWND())) @@ -311,9 +353,10 @@ wxWindow::~wxWindow() // wxRemoveHandleAssociation(this); } -} // end of wxWindow::~wxWindow +} // end of wxWindowOS2::~wxWindowOS2 -bool wxWindow::Create( +// real construction (Init() must have been called before!) +bool wxWindowOS2::Create( wxWindow* pParent , wxWindowID vId , const wxPoint& rPos @@ -322,6 +365,11 @@ bool wxWindow::Create( , const wxString& rName ) { + 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 ( !CreateBase( pParent @@ -334,68 +382,97 @@ bool wxWindow::Create( )) return(FALSE); - pParent->AddChild(this); + if (pParent) + { + int nTempy; + + pParent->AddChild(this); + hParent = GetWinHwnd(pParent); - ULONG ulFlags = 0L; + if ( pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) || + pParent->IsKindOf(CLASSINFO(wxScrolledWindow)) + ) + ulCreateFlags |= WS_CLIPSIBLINGS; + } // - // Frame windows and their derivatives only + // 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. // - if (lStyle & wxBORDER) - ulFlags |= FCF_BORDER; - if (lStyle & wxTHICK_FRAME ) - ulFlags |= FCF_SIZEBORDER; + ulCreateFlags |= WS_VISIBLE; + + +#ifdef __WXUNIVERSAL__ + // no 3d effects, we draw them ourselves + WXDWORD exStyle = 0; +#else // !wxUniversal + if (lStyle & wxCLIP_SIBLINGS) + ulCreateFlags |= WS_CLIPSIBLINGS; - // - // Some generic window styles - // - ulFlags |= WS_VISIBLE; if (lStyle & wxCLIP_CHILDREN ) - ulFlags |= WS_CLIPCHILDREN; + ulCreateFlags |= WS_CLIPCHILDREN; + // + // + // bool bWant3D; - WXDWORD dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D); + dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D); + +#endif // - // 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) - ) + if (lStyle & wxSIMPLE_BORDER) + dwExStyle |= wxSIMPLE_BORDER; + + if (lStyle & wxPOPUP_WINDOW) { - ulFlags |= FCF_BORDER; + // 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; } - OS2Create( m_windowId - ,pParent - ,wxCanvasClassName - ,this - ,NULL - ,rPos.x - ,rPos.y + + // + // 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 +} // end of wxWindowOS2::Create // --------------------------------------------------------------------------- // basic operations // --------------------------------------------------------------------------- -void wxWindow::SetFocus() +void wxWindowOS2::SetFocus() { HWND hWnd = GetHwnd(); + wxCHECK_RET( hWnd, _T("can't set focus to invalid window") ); if (hWnd) ::WinSetFocus(HWND_DESKTOP, hWnd); -} // end of wxWindow::SetFocus +} // end of wxWindowOS2::SetFocus wxWindow* wxWindowBase::FindFocus() { @@ -408,7 +485,7 @@ wxWindow* wxWindowBase::FindFocus() return NULL; } // wxWindowBase::FindFocus -bool wxWindow::Enable( +bool wxWindowOS2::Enable( bool bEnable ) { @@ -429,10 +506,10 @@ bool wxWindow::Enable( pChild->Enable(bEnable); pNode = pNode->GetNext(); } - return(TRUE); -} // end of wxWindow::Enable + return TRUE; +} // end of wxWindowOS2::Enable -bool wxWindow::Show( +bool wxWindowOS2::Show( bool bShow ) { @@ -447,32 +524,32 @@ bool wxWindow::Show( { ::WinSetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE | SWP_ZORDER); } - return(TRUE); -} // end of wxWindow::Show + return TRUE; +} // end of wxWindowOS2::Show -void wxWindow::Raise() +void wxWindowOS2::Raise() { ::WinSetWindowPos(GetHwnd(), HWND_TOP, 0, 0, 0, 0, SWP_ZORDER | SWP_ACTIVATE); -} // end of wxWindow::Raise +} // end of wxWindowOS2::Raise -void wxWindow::Lower() +void wxWindowOS2::Lower() { ::WinSetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0, SWP_ZORDER | SWP_DEACTIVATE); -} // end of wxWindow::Lower +} // end of wxWindowOS2::Lower -void wxWindow::SetTitle( +void wxWindowOS2::SetTitle( const wxString& rTitle ) { ::WinSetWindowText(GetHwnd(), rTitle.c_str()); -} // end of wxWindow::SetTitle +} // end of wxWindowOS2::SetTitle -wxString wxWindow::GetTitle() const +wxString wxWindowOS2::GetTitle() const { return wxGetWindowText(GetHWND()); -} // end of wxWindow::GetTitle +} // end of wxWindowOS2::GetTitle -void wxWindow::CaptureMouse() +void wxWindowOS2::CaptureMouse() { HWND hWnd = GetHwnd(); @@ -481,18 +558,24 @@ void wxWindow::CaptureMouse() ::WinSetCapture(HWND_DESKTOP, hWnd); m_bWinCaptured = TRUE; } -} // end of wxWindow::GetTitle +} // end of wxWindowOS2::GetTitle -void wxWindow::ReleaseMouse() +void wxWindowOS2::ReleaseMouse() { if (m_bWinCaptured) { ::WinSetCapture(HWND_DESKTOP, NULLHANDLE); m_bWinCaptured = FALSE; } -} // end of wxWindow::ReleaseMouse +} // end of wxWindowOS2::ReleaseMouse -bool wxWindow::SetFont( +/* static */ wxWindow* wxWindowBase::GetCapture() +{ + HWND hwnd = ::WinQueryCapture(HWND_DESKTOP); + return hwnd ? wxFindWinFromHandle((WXHWND)hwnd) : (wxWindow *)NULL; +} // end of wxWindowBase::GetCapture + +bool wxWindowOS2::SetFont( const wxFont& rFont ) { @@ -506,15 +589,77 @@ bool wxWindow::SetFont( if (hWnd != 0) { - wxChar zFont[128]; + 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; - sprintf(zFont, "%d.%s", rFont.GetPointSize(), rFont.GetFaceName().c_str()); - return(::WinSetPresParam(hWnd, PP_FONTNAMESIZE, strlen(zFont), (PVOID)zFont)); + 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); } return(TRUE); } -bool wxWindow::SetCursor( +bool wxWindowOS2::SetCursor( const wxCursor& rCursor ) // check if base implementation is OK { @@ -524,30 +669,23 @@ bool wxWindow::SetCursor( return FALSE; } - wxASSERT_MSG( m_cursor.Ok(), - wxT("cursor must be valid after call to the base version")); + if ( m_cursor.Ok() ) { + HWND hWnd = GetHwnd(); + POINTL vPoint; + RECTL vRect; - HWND hWnd = GetHwnd(); - POINTL vPoint; - RECTL vRect; - HPS hPS; - HRGN hRGN; - - hPS = ::WinGetPS(hWnd); - - ::WinQueryPointerPos(HWND_DESKTOP, &vPoint); - ::WinQueryWindowRect(hWnd, &vRect); - - hRGN = ::GpiCreateRegion(hPS, 1L, &vRect); + ::WinQueryPointerPos(HWND_DESKTOP, &vPoint); + ::WinQueryWindowRect(hWnd, &vRect); - if ((::GpiPtInRegion(hPS, hRGN, &vPoint) == PRGN_INSIDE) && !wxIsBusy()) - { - ::WinSetPointer(HWND_DESKTOP, (HPOINTER)m_cursor.GetHCURSOR()); + if (::WinPtInRect(vHabmain, &vRect, &vPoint) && !wxIsBusy()) + { + ::WinSetPointer(HWND_DESKTOP, (HPOINTER)m_cursor.GetHCURSOR()); + } } return TRUE; -} // end of wxWindow::SetCursor +} // end of wxWindowOS2::SetCursor -void wxWindow::WarpPointer( +void wxWindowOS2::WarpPointer( int nXPos , int nYPos ) @@ -561,10 +699,10 @@ void wxWindow::WarpPointer( nY += vRect.yBottom; ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY)); -} // end of wxWindow::WarpPointer +} // end of wxWindowOS2::WarpPointer #if WXWIN_COMPATIBILITY -void wxWindow::OS2DeviceToLogical (float *x, float *y) const +void wxWindowOS2::OS2DeviceToLogical (float *x, float *y) const { } #endif // WXWIN_COMPATIBILITY @@ -574,28 +712,45 @@ void wxWindow::OS2DeviceToLogical (float *x, float *y) const // --------------------------------------------------------------------------- #if WXWIN_COMPATIBILITY -void wxWindow::SetScrollRange( +void wxWindowOS2::SetScrollRange( int nOrient , int nRange , bool bRefresh ) { - ::WinSendMsg(GetHwnd(), SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, nRange)); -} // end of wxWindow::SetScrollRange + int nRange1 = nRange; + int nPageSize = GetScrollPage(nOrient); + + if (nPpageSize > 1 && nRange > 0) + { + nRange1 += (nPageSize - 1); + } + + if (nOrient == wxHORIZONTAL) + { + ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1)); + ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0); + } + else + { + ::WinSendMsg(m_hWndScrollBarVert, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1)); + ::WinSendMsg(m_hWndScrollBarVert, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0); + } +} // end of wxWindowOS2::SetScrollRange -void wxWindow::SetScrollPage( +void wxWindowOS2::SetScrollPage( int nOrient , int nPage , bool bRefresh ) { - if ( orient == wxHORIZONTAL ) - m_xThumbSize = page; + if (nOrient == wxHORIZONTAL ) + m_nXThumbSize = nPage; else - m_yThumbSize = page; -} + m_nYThumbSize = nPage; +} // end of wxWindowOS2::SetScrollPage -int wxWindow::OldGetScrollRange( +int wxWindowOS2::OldGetScrollRange( int nOrient ) const { @@ -608,9 +763,9 @@ int wxWindow::OldGetScrollRange( return(SHORT2FROMMR(mRc)); } return 0; -} // end of wxWindow::OldGetScrollRange +} // end of wxWindowOS2::OldGetScrollRange -int wxWindow::GetScrollPage( +int wxWindowOS2::GetScrollPage( int nOrient ) const { @@ -618,153 +773,351 @@ int wxWindow::GetScrollPage( return m_nXThumbSize; else return m_nYThumbSize; -} // end of wxWindow::GetScrollPage +} // end of wxWindowOS2::GetScrollPage #endif // WXWIN_COMPATIBILITY -int wxWindow::GetScrollPos( +int wxWindowOS2::GetScrollPos( int nOrient ) const { - return((int)::WinSendMsg(GetHwnd(), SBM_QUERYPOS, (MPARAM)NULL, (MPARAM)NULL)); -} // end of wxWindow::GetScrollPos + 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 wxWindowOS2::GetScrollPos -int wxWindow::GetScrollRange( +int wxWindowOS2::GetScrollRange( int nOrient ) const { 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 +} // end of wxWindowOS2::GetScrollRange -int wxWindow::GetScrollThumb( +int wxWindowOS2::GetScrollThumb( int nOrient ) const { - WNDPARAMS vWndParams; - PSBCDATA pSbcd; - - ::WinSendMsg(GetHwnd(), WM_QUERYWINDOWPARAMS, (MPARAM)&vWndParams, (MPARAM)NULL); - pSbcd = (PSBCDATA)vWndParams.pCtlData; - return((int)pSbcd->posThumb); -} // end of wxWindow::GetScrollThumb + if (nOrient == wxHORIZONTAL ) + return m_nXThumbSize; + else + return m_nYThumbSize; +} // end of wxWindowOS2::GetScrollThumb -void wxWindow::SetScrollPos( +void wxWindowOS2::SetScrollPos( int nOrient , int nPos -, bool bRefresh +, bool WXUNUSED(bRefresh) ) { - ::WinSendMsg(GetHwnd(), SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL); -} // end of wxWindow::SetScrollPos( + if (nOrient == wxHORIZONTAL ) + ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL); + else + ::WinSendMsg(m_hWndScrollBarVert, SBM_SETPOS, (MPARAM)nPos, (MPARAM)NULL); +} // end of wxWindowOS2::SetScrollPos -void wxWindow::SetScrollbar( +void wxWindowOS2::SetScrollbar( int nOrient , int nPos , int nThumbVisible , int nRange -, bool bRefresh +, bool WXUNUSED(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 +} // end of wxWindowOS2::SetScrollbar -void wxWindow::ScrollWindow( +void wxWindowOS2::ScrollWindow( int nDx , int nDy , 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); -} // end of wxWindow::ScrollWindow + ::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 wxWindowOS2::ScrollWindow // --------------------------------------------------------------------------- // subclassing // --------------------------------------------------------------------------- -void wxWindow::SubclassWin( +void wxWindowOS2::SubclassWin( WXHWND hWnd ) { 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 +} // end of wxWindowOS2::SubclassWin -void wxWindow::UnsubclassWin() +void wxWindowOS2::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); m_fnOldWndProc = 0; } } -} // end of wxWindow::UnsubclassWin +} // end of wxWindowOS2::UnsubclassWin // // Make a Windows extended style from the given wxWindows window style // -WXDWORD wxWindow::MakeExtendedStyle( +WXDWORD wxWindowOS2::MakeExtendedStyle( long lStyle , bool bEliminateBorders ) { // - // 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; -} // end of wxWindow::MakeExtendedStyle + 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 wxWindowOS2::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 wxWindowOS2::Determine3DEffects( WXDWORD dwDefaultBorderStyle , bool* pbWant3D ) const @@ -772,14 +1125,70 @@ WXDWORD wxWindow::Determine3DEffects( 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 + // + 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. // - *pbWant3D = FALSE; + 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 +} // end of wxWindowOS2::Determine3DEffects #if WXWIN_COMPATIBILITY -void wxWindow::OnCommand( +void wxWindowOS2::OnCommand( wxWindow& rWin , wxCommandEvent& rEvent ) @@ -790,9 +1199,9 @@ void wxWindow::OnCommand( m_parent->GetEventHandler()->OnCommand( rWin ,rEvent ); -} // end of wxWindow::OnCommand +} // end of wxWindowOS2::OnCommand -wxObject* wxWindow::GetChild( +wxObject* wxWindowOS2::GetChild( int nNumber ) const { @@ -811,21 +1220,21 @@ wxObject* wxWindow::GetChild( } else return NULL; -} // end of wxWindow::GetChild +} // end of wxWindowOS2::GetChild #endif // WXWIN_COMPATIBILITY // // Setup background and foreground colours correctly // -void wxWindow::SetupColours() +void wxWindowOS2::SetupColours() { if ( GetParent() ) SetBackgroundColour(GetParent()->GetBackgroundColour()); -} // end of wxWindow::SetupColours +} // end of wxWindowOS2::SetupColours -void wxWindow::OnIdle( - wxIdleEvent& rEvent +void wxWindowOS2::OnIdle( + wxIdleEvent& WXUNUSED(rEvent) ) { // @@ -866,12 +1275,12 @@ void wxWindow::OnIdle( } } UpdateWindowUI(); -} // end of wxWindow::OnIdle +} // end of wxWindowOS2::OnIdle // // Set this window to be the child of 'parent'. // -bool wxWindow::Reparent( +bool wxWindowOS2::Reparent( wxWindow* pParent ) { @@ -883,20 +1292,20 @@ bool wxWindow::Reparent( ::WinSetParent(hWndChild, hWndParent, TRUE); return TRUE; -} // end of wxWindow::Reparent +} // end of wxWindowOS2::Reparent -void wxWindow::Clear() +void wxWindowOS2::Clear() { - wxClientDC vDc(this); + wxClientDC vDc((wxWindow*)this); wxBrush vBrush( GetBackgroundColour() ,wxSOLID ); vDc.SetBackground(vBrush); vDc.Clear(); -} // end of wxWindow::Clear +} // end of wxWindowOS2::Clear -void wxWindow::Refresh( +void wxWindowOS2::Refresh( bool bEraseBack , const wxRect* pRect ) @@ -919,14 +1328,14 @@ void wxWindow::Refresh( else ::WinInvalidateRect(hWnd, NULL, bEraseBack); } -} // end of wxWindow::Refresh +} // end of wxWindowOS2::Refresh // --------------------------------------------------------------------------- // drag and drop // --------------------------------------------------------------------------- #if wxUSE_DRAG_AND_DROP -void wxWindow::SetDropTarget( +void wxWindowOS2::SetDropTarget( wxDropTarget* pDropTarget ) { @@ -938,14 +1347,14 @@ void wxWindow::SetDropTarget( m_dropTarget = pDropTarget; if (m_dropTarget != 0) m_dropTarget->Register(m_hWnd); -} // end of wxWindow::SetDropTarget +} // end of wxWindowOS2::SetDropTarget #endif // // old style file-manager drag&drop support: we retain the old-style // DragAcceptFiles in parallel with SetDropTarget. // -void wxWindow::DragAcceptFiles( +void wxWindowOS2::DragAcceptFiles( bool bAccept ) { @@ -953,7 +1362,7 @@ void wxWindow::DragAcceptFiles( if (hWnd && bAccept) ::DrgAcceptDroppedFiles(hWnd, NULL, NULL, DO_COPY, 0L); -} // end of wxWindow::DragAcceptFiles +} // end of wxWindowOS2::DragAcceptFiles // ---------------------------------------------------------------------------- // tooltips @@ -961,7 +1370,7 @@ void wxWindow::DragAcceptFiles( #if wxUSE_TOOLTIPS -void wxWindow::DoSetToolTip( +void wxWindowOS2::DoSetToolTip( wxToolTip* pTooltip ) { @@ -969,7 +1378,7 @@ void wxWindow::DoSetToolTip( if (m_tooltip) m_tooltip->SetWindow(this); -} // end of wxWindow::DoSetToolTip +} // end of wxWindowOS2::DoSetToolTip #endif // wxUSE_TOOLTIPS @@ -978,7 +1387,7 @@ void wxWindow::DoSetToolTip( // --------------------------------------------------------------------------- // Get total size -void wxWindow::DoGetSize( +void wxWindowOS2::DoGetSize( int* pWidth , int* pHeight ) const @@ -993,51 +1402,40 @@ void wxWindow::DoGetSize( if (pHeight ) // OS/2 PM is backwards from windows *pHeight = vRect.yTop - vRect.yBottom; -} // end of wxWindow::DoGetSize +} // end of wxWindowOS2::DoGetSize -void wxWindow::DoGetPosition( +void wxWindowOS2::DoGetPosition( int* pX , int* pY ) const { HWND hWnd = GetHwnd(); - RECT vRect; + SWP vSwp; POINTL vPoint; + wxWindow* pParent = GetParent(); - ::WinQueryWindowRect(hWnd, &vRect); + // + // It would seem that WinQueryWindowRect would be the correlary to + // the WIN32 WinGetRect, but unlike WinGetRect which returns the window + // origin position in screen coordinates, WinQueryWindowRect returns it + // relative to itself, i.e. (0,0). To get the same under PM we must + // us WinQueryWindowPos. This call, unlike the WIN32 call, however, + // returns a position relative to it's parent, so no parent adujstments + // are needed under OS/2. Also, windows should be created using + // wxWindow coordinates, i.e 0,0 is the TOP left so vSwp will already + // reflect that. + // + ::WinQueryWindowPos(hWnd, &vSwp); - vPoint.x = vRect.xLeft; - vPoint.y = vRect.yBottom; + vPoint.x = vSwp.x; + vPoint.y = vSwp.y; // - // We do the adjustments with respect to the parent only for the "real" - // children, not for the dialogs/frames + // We may be faking the client origin. So a window that's really at (0, + // 30) may appear (to wxWin apps) to be at (0, 0). // - if (!IsTopLevel()) + if (pParent) { - HWND hParentWnd = 0; - wxWindow* pParent = GetParent(); - - if (pParent) - hParentWnd = GetWinHwnd(pParent); - - // - // Since we now have the absolute screen coords, if there's a parent we - // must subtract its bottom left corner - // - if (hParentWnd) - { - RECTL vRect2; - - ::WinQueryWindowRect(hParentWnd, &vRect2); - vPoint.x -= vRect.xLeft; - vPoint.y -= vRect.yBottom; - } - - // - // We may be faking the client origin. So a window that's really at (0, - // 30) may appear (to wxWin apps) to be at (0, 0). - // wxPoint vPt(pParent->GetClientAreaOrigin()); vPoint.x -= vPt.x; @@ -1048,9 +1446,9 @@ void wxWindow::DoGetPosition( *pX = vPoint.x; if (pY) *pY = vPoint.y; -} // end of wxWindow::DoGetPosition +} // end of wxWindowOS2::DoGetPosition -void wxWindow::DoScreenToClient( +void wxWindowOS2::DoScreenToClient( int* pX , int* pY ) const @@ -1061,12 +1459,12 @@ void wxWindow::DoScreenToClient( ::WinQueryWindowPos(hWnd, &vSwp); if (pX) - *pX -= vSwp.x; + *pX += vSwp.x; if (pY) - *pY -= vSwp.y; -} // end of wxWindow::DoScreenToClient + *pY += vSwp.y; +} // end of wxWindowOS2::DoScreenToClient -void wxWindow::DoClientToScreen( +void wxWindowOS2::DoClientToScreen( int* pX , int* pY ) const @@ -1080,13 +1478,13 @@ void wxWindow::DoClientToScreen( *pX += vSwp.x; if (pY) *pY += vSwp.y; -} // end of wxWindow::DoClientToScreen +} // end of wxWindowOS2::DoClientToScreen // // Get size *available for subwindows* i.e. excluding menu bar etc. // Must be a frame type window // -void wxWindow::DoGetClientSize( +void wxWindowOS2::DoGetClientSize( int* pWidth , int* pHeight ) const @@ -1095,34 +1493,64 @@ void wxWindow::DoGetClientSize( 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; if (pHeight) *pHeight = vRect.yTop; -} // end of wxWindow::DoGetClientSize +} // end of wxWindowOS2::DoGetClientSize -void wxWindow::DoMoveWindow( +void wxWindowOS2::DoMoveWindow( int nX , int nY , int nWidth , int nHeight ) { - if ( !::WinSetWindowPos( GetHwnd() - ,HWND_TOP - ,(LONG)nX - ,(LONG)nY - ,(LONG)nWidth - ,(LONG)nHeight - ,SWP_SIZE | SWP_MOVE - )) + RECTL vRect; + HWND hParent; + wxWindow* pParent = GetParent(); + + if (pParent) { - wxLogLastError("MoveWindow"); + 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); } -} // end of wxWindow::DoMoveWindow + else + { + RECTL vRect; + + ::WinQueryWindowRect(HWND_DESKTOP, &vRect); + nY = vRect.yTop - (nY + nHeight); + } + ::WinSetWindowPos( GetHwnd() + ,HWND_TOP + ,(LONG)nX + ,(LONG)nY + ,(LONG)nWidth + ,(LONG)nHeight + ,SWP_ZORDER | SWP_SIZE | SWP_MOVE | SWP_SHOW + ); +} // end of wxWindowOS2::DoMoveWindow // // Set the size of the window: if the dimensions are positive, just use them, @@ -1134,7 +1562,7 @@ void wxWindow::DoMoveWindow( // the width/height to best suit our contents, otherwise we reuse the current // width/height // -void wxWindow::DoSetSize( +void wxWindowOS2::DoSetSize( int nX , int nY , int nWidth @@ -1151,21 +1579,12 @@ void wxWindow::DoSetSize( int nCurrentHeight; wxSize vSize(-1, -1); - GetPosition( &nCurrentX - ,&nCurrentY - ); - GetSize( &nCurrentWidth - ,&nCurrentHeight - ); + GetPosition(&nCurrentX, &nCurrentY); + GetSize(&nCurrentWidth, &nCurrentHeight); - // // ... and don't do anything (avoiding flicker) if it's already ok - // - if ( nX == nCurrentX && - nY == nCurrentY && - nWidth == nCurrentWidth && - nHeight == nCurrentHeight - ) + if (nX == nCurrentX && nY == nCurrentY && + nWidth == nCurrentWidth && nHeight == nCurrentHeight) { return; } @@ -1175,10 +1594,7 @@ void wxWindow::DoSetSize( if (nY == -1 && !(nSizeFlags & wxSIZE_ALLOW_MINUS_ONE)) nY = nCurrentY; - AdjustForParentClientOrigin( nX - ,nY - ,nSizeFlags - ); + AdjustForParentClientOrigin(nX, nY, nSizeFlags); if (nWidth == -1) { @@ -1218,9 +1634,9 @@ void wxWindow::DoSetSize( ,nWidth ,nHeight ); -} // end of wxWindow::DoSetSize +} // end of wxWindowOS2::DoSetSize -void wxWindow::DoSetClientSize( +void wxWindowOS2::DoSetClientSize( int nWidth , int nHeight ) @@ -1228,33 +1644,20 @@ void wxWindow::DoSetClientSize( wxWindow* pParent = GetParent(); HWND hWnd = GetHwnd(); HWND hParentWnd = (HWND)0; - HWND hClientWnd = (HWND)0; + POINTL vPoint; RECTL vRect; - RECT vRect2; - RECT vRect3; + RECTL vRect2; + RECTL vRect3; + HWND hClientWnd = (HWND)0; - hClientWnd = ::WinWindowFromID(GetHwnd(), FID_CLIENT); + hClientWnd = ::WinWindowFromID(hWnd, FID_CLIENT); ::WinQueryWindowRect(hClientWnd, &vRect2); - - if (pParent) - hParentWnd = (HWND) pParent->GetHWND(); - ::WinQueryWindowRect(hWnd, &vRect); ::WinQueryWindowRect(hParentWnd, &vRect3); - // - // Find the difference between the entire window (title bar and all) - // and the client area; add this to the new client size to move the - // window. OS/2 is backward from windows on height - // + int nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth; int nActualHeight = vRect2.yTop - vRect2.yBottom - vRect.yTop + nHeight; - // - // If there's a parent, must subtract the parent's bottom left corner - // since MoveWindow moves relative to the parent - // - POINTL vPoint; - vPoint.x = vRect2.xLeft; vPoint.y = vRect2.yBottom; if (pParent) @@ -1263,70 +1666,39 @@ void wxWindow::DoSetClientSize( vPoint.y -= vRect3.yBottom; } - DoMoveWindow( vPoint.x - ,vPoint.y - ,nActualWidth - ,nActualHeight - ); - - wxSizeEvent vEvent( wxSize( nWidth - ,nHeight - ) - ,m_windowId - ); + DoMoveWindow(vPoint.x, vPoint.y, nActualWidth, nActualHeight); + wxSizeEvent vEvent(wxSize(nWidth, nHeight), m_windowId); vEvent.SetEventObject(this); GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::DoSetClientSize +} // end of wxWindowOS2::DoSetClientSize -wxPoint wxWindow::GetClientAreaOrigin() const +wxPoint wxWindowOS2::GetClientAreaOrigin() const { return wxPoint(0, 0); -} // end of wxWindow::GetClientAreaOrigin - -void wxWindow::AdjustForParentClientOrigin( - int& rX -, int& rY -, int nSizeFlags -) -{ - // - // Don't do it for the dialogs/frames - they float independently of their - // parent - // - if (!IsTopLevel()) - { - wxWindow* pParent = GetParent(); - - if (!(nSizeFlags & wxSIZE_NO_ADJUSTMENTS) && pParent) - { - wxPoint vPoint(pParent->GetClientAreaOrigin()); - rX += vPoint.x; - rY += vPoint.y; - } - } -} // end of wxWindow::AdjustForParentClientOrigin +} // end of wxWindowOS2::GetClientAreaOrigin // --------------------------------------------------------------------------- // text metrics // --------------------------------------------------------------------------- -int wxWindow::GetCharHeight() const +int wxWindowOS2::GetCharHeight() const { HPS hPs; FONTMETRICS vFontMetrics; - BOOL bRc; hPs = ::WinGetPS(GetHwnd()); if(!GpiQueryFontMetrics(hPs, sizeof(FONTMETRICS), &vFontMetrics)) + { + ::WinReleasePS(hPs); return (0); - else - return(vFontMetrics.lMaxAscender + vFontMetrics.lMaxDescender); + } ::WinReleasePS(hPs); -} // end of wxWindow::GetCharHeight + return(vFontMetrics.lMaxAscender + vFontMetrics.lMaxDescender); +} // end of wxWindowOS2::GetCharHeight -int wxWindow::GetCharWidth() const +int wxWindowOS2::GetCharWidth() const { HPS hPs; FONTMETRICS vFontMetrics; @@ -1334,13 +1706,15 @@ int wxWindow::GetCharWidth() const hPs = ::WinGetPS(GetHwnd()); if(!GpiQueryFontMetrics(hPs, sizeof(FONTMETRICS), &vFontMetrics)) + { + ::WinReleasePS(hPs); return (0); - else - return(vFontMetrics.lAveCharWidth); + } ::WinReleasePS(hPs); -} // end of wxWindow::GetCharWidth + return(vFontMetrics.lAveCharWidth); +} // end of wxWindowOS2::GetCharWidth -void wxWindow::GetTextExtent( +void wxWindowOS2::GetTextExtent( const wxString& rString , int* pX , int* pY @@ -1349,55 +1723,101 @@ void wxWindow::GetTextExtent( , const wxFont* pTheFont ) const { - const wxFont* pFontToUse = pTheFont; - HPS hPs; + POINTL avPoint[TXTBOX_COUNT]; + POINTL vPtMin; + POINTL vPtMax; + int i; + int l; + FONTMETRICS vFM; // metrics structure + BOOL bRc; + char* pStr; + ERRORID vErrorCode; // last error id code + HPS hPS; - hPs = ::WinGetPS(GetHwnd()); -/* -// TODO: Will have to play with fonts later - if (!pFontToUse) - pFontToUse = &m_font; + hPS = ::WinGetPS(GetHwnd()); - HFONT hFnt = 0; - HFONT hFfontOld = 0; + l = rString.Length(); + if (l > 0L) + { + pStr = (PCH)rString.c_str(); - if (pFontToUse && pFontToUse->Ok()) + // + // In world coordinates. + // + bRc = ::GpiQueryTextBox( hPS + ,l + ,pStr + ,TXTBOX_COUNT // return maximum information + ,avPoint // array of coordinates points + ); + if (bRc) + { + vPtMin.x = avPoint[0].x; + vPtMax.x = avPoint[0].x; + vPtMin.y = avPoint[0].y; + vPtMax.y = avPoint[0].y; + for (i = 1; i < 4; i++) + { + if(vPtMin.x > avPoint[i].x) vPtMin.x = avPoint[i].x; + if(vPtMin.y > avPoint[i].y) vPtMin.y = avPoint[i].y; + if(vPtMax.x < avPoint[i].x) vPtMax.x = avPoint[i].x; + if(vPtMax.y < avPoint[i].y) vPtMax.y = avPoint[i].y; + } + bRc = ::GpiQueryFontMetrics( hPS + ,sizeof(FONTMETRICS) + ,&vFM + ); + if (!bRc) + { + vPtMin.x = 0; + vPtMin.y = 0; + vPtMax.x = 0; + vPtMax.y = 0; + } + } + else + { + vPtMin.x = 0; + vPtMin.y = 0; + vPtMax.x = 0; + vPtMax.y = 0; + } + } + else { - ::GpiCreateLog - hFnt = (HFONT)((wxFont *)pFontToUse)->GetResourceHandle(); // const_cast - if (hFnt) - hFontOld = (HFONT)SelectObject(dc,fnt); + vPtMin.x = 0; + vPtMin.y = 0; + vPtMax.x = 0; + vPtMax.y = 0; } - - SIZE sizeRect; - TEXTMETRIC tm; - GetTextExtentPoint(dc, string, (int)string.Length(), &sizeRect); - GetTextMetrics(dc, &tm); - - if ( fontToUse && fnt && hfontOld ) - SelectObject(dc, hfontOld); - - ReleaseDC(hWnd, dc); - - if ( x ) - *x = sizeRect.cx; - if ( y ) - *y = sizeRect.cy; - if ( descent ) - *descent = tm.tmDescent; - if ( externalLeading ) - *externalLeading = tm.tmExternalLeading; -*/ - ::WinReleasePS(hPs); -} + if (pX) + *pX = (vPtMax.x - vPtMin.x + 1); + if (pY) + *pY = (vPtMax.y - vPtMin.y + 1); + if (pDescent) + { + if (bRc) + *pDescent = vFM.lMaxDescender; + else + *pDescent = 0; + } + if (pExternalLeading) + { + if (bRc) + *pExternalLeading = vFM.lExternalLeading; + else + *pExternalLeading = 0; + } + ::WinReleasePS(hPS); +} // end of wxWindow::GetTextExtent #if wxUSE_CARET && WXWIN_COMPATIBILITY // --------------------------------------------------------------------------- // Caret manipulation // --------------------------------------------------------------------------- -void wxWindow::CreateCaret( +void wxWindowOS2::CreateCaret( int nWidth , int nHeight ) @@ -1406,30 +1826,30 @@ void wxWindow::CreateCaret( ,nWidth ,nHeight )); -} // end of wxWindow::CreateCaret +} // end of wxWindowOS2::CreateCaret -void wxWindow::CreateCaret( +void wxWindowOS2::CreateCaret( const wxBitmap* pBitmap ) { wxFAIL_MSG("not implemented"); -} // end of wxWindow::CreateCaret +} // end of wxWindowOS2::CreateCaret -void wxWindow::ShowCaret( +void wxWindowOS2::ShowCaret( bool bShow ) { wxCHECK_RET( m_caret, "no caret to show" ); m_caret->Show(bShow); -} // end of wxWindow::ShowCaret +} // end of wxWindowOS2::ShowCaret -void wxWindow::DestroyCaret() +void wxWindowOS2::DestroyCaret() { SetCaret(NULL); -} // end of wxWindow::DestroyCaret +} // end of wxWindowOS2::DestroyCaret -void wxWindow::SetCaretPos( +void wxWindowOS2::SetCaretPos( int nX , int nY) { @@ -1438,9 +1858,9 @@ void wxWindow::SetCaretPos( m_caret->Move( nX ,nY ); -} // end of wxWindow::SetCaretPos +} // end of wxWindowOS2::SetCaretPos -void wxWindow::GetCaretPos( +void wxWindowOS2::GetCaretPos( int* pX , int* pY ) const @@ -1450,15 +1870,33 @@ void wxWindow::GetCaretPos( m_caret->GetPosition( pX ,pY ); -} // end of wxWindow::GetCaretPos +} // end of wxWindowOS2::GetCaretPos #endif //wxUSE_CARET // --------------------------------------------------------------------------- // popup menu // --------------------------------------------------------------------------- +// +#if wxUSE_MENUS_NATIVE +static void wxYieldForCommandsOnly() +{ + // + // Peek all WM_COMMANDs (it will always return WM_QUIT too but we don't + // want to process it here) + // + QMSG vMsg; + + while (::WinPeekMsg(vHabmain, &vMsg, (HWND)0, WM_COMMAND, + WM_COMMAND,PM_REMOVE) && vMsg.msg != WM_QUIT) + { + wxTheApp->DoMessage((WXMSG*)&vMsg); + } +} +#endif // wxUSE_MENUS_NATIVE -bool wxWindow::DoPopupMenu( +#if wxUSE_MENUS_NATIVE +bool wxWindowOS2::DoPopupMenu( wxMenu* pMenu , int nX , int nY @@ -1484,33 +1922,43 @@ bool wxWindow::DoPopupMenu( ,0L ,PU_MOUSEBUTTON2DOWN | PU_MOUSEBUTTON2 | PU_KEYBOARD ); - wxYield(); + // 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; pMenu->SetInvokingWindow(NULL); return TRUE; -} // end of wxWindow::DoPopupMenu +} // end of wxWindowOS2::DoPopupMenu +#endif // wxUSE_MENUS_NATIVE // =========================================================================== // pre/post message processing // =========================================================================== -MRESULT wxWindow::OS2DefWindowProc( +MRESULT wxWindowOS2::OS2DefWindowProc( WXUINT uMsg , WXWPARAM wParam , WXLPARAM lParam ) { if (m_fnOldWndProc) - return ((MRESULT)m_fnOldWndProc()); + return (MRESULT)m_fnOldWndProc(GetHWND(), uMsg, (MPARAM)wParam, (MPARAM)lParam); else - return (::WinDefWindowProc(GetHwnd(), (ULONG)uMsg, (MPARAM)wParam, (MPARAM)lParam)); -} // end of wxWindow::OS2DefWindowProc + return ::WinDefWindowProc(GetHWND(), uMsg, (MPARAM)wParam, (MPARAM)lParam); +} // end of wxWindowOS2::OS2DefWindowProc -bool wxWindow::OS2ProcessMessage( +bool wxWindowOS2::OS2ProcessMessage( WXMSG* pMsg ) { +// wxUniversal implements tab traversal itself +#ifndef __WXUNIVERSAL__ QMSG* pQMsg = (QMSG*)pMsg; if (m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL)) @@ -1620,17 +2068,9 @@ bool wxWindow::OS2ProcessMessage( } else { - wxPanel* pPanel = wxDynamicCast(this, wxPanel); - wxButton* pBtn = NULL; - - if (pPanel) - { - // - // Panel may have a default button which should - // be activated by Enter - // - pBtn = pPanel->GetDefaultItem(); - } + wxButton* pBtn = wxDynamicCast( GetDefaultItem() + ,wxButton + ); if (pBtn && pBtn->IsEnabled()) { @@ -1674,12 +2114,15 @@ 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; +#else + pMsg = pMsg; // just shut up the compiler +#endif // __WXUNIVERSAL__ #if wxUSE_TOOLTIPS if ( m_tooltip ) @@ -1693,20 +2136,25 @@ bool wxWindow::OS2ProcessMessage( #endif // wxUSE_TOOLTIPS return FALSE; -} // end of wxWindow::OS2ProcessMessage +} // end of wxWindowOS2::OS2ProcessMessage -bool wxWindow::OS2TranslateMessage( +bool wxWindowOS2::OS2TranslateMessage( WXMSG* pMsg ) { - return m_acceleratorTable.Translate(this, pMsg); -} // end of wxWindow::OS2TranslateMessage +#if wxUSE_ACCEL && !defined(__WXUNIVERSAL__) + return m_acceleratorTable.Translate(m_hWnd, pMsg); +#else + pMsg = pMsg; + return FALSE; +#endif //wxUSE_ACCEL +} // end of wxWindowOS2::OS2TranslateMessage // --------------------------------------------------------------------------- // message params unpackers // --------------------------------------------------------------------------- -void wxWindow::UnpackCommand( +void wxWindowOS2::UnpackCommand( WXWPARAM wParam , WXLPARAM lParam , WORD* pId @@ -1715,11 +2163,11 @@ void wxWindow::UnpackCommand( ) { *pId = LOWORD(wParam); - *phWnd = (WXHWND)lParam; - *pCmd = HIWORD(wParam); -} // end of wxWindow::UnpackCommand + *phWnd = NULL; // or may be GetHWND() ? + *pCmd = LOWORD(lParam); +} // end of wxWindowOS2::UnpackCommand -void wxWindow::UnpackActivate( +void wxWindowOS2::UnpackActivate( WXWPARAM wParam , WXLPARAM lParam , WXWORD* pState @@ -1728,9 +2176,9 @@ void wxWindow::UnpackActivate( { *pState = LOWORD(wParam); *phWnd = (WXHWND)lParam; -} // end of wxWindow::UnpackActivate +} // end of wxWindowOS2::UnpackActivate -void wxWindow::UnpackScroll( +void wxWindowOS2::UnpackScroll( WXWPARAM wParam , WXLPARAM lParam , WXWORD* pCode @@ -1738,12 +2186,21 @@ void wxWindow::UnpackScroll( , WXHWND* phWnd ) { - *pCode = LOWORD(wParam); - *pPos = HIWORD(wParam); - *phWnd = (WXHWND)lParam; -} // end of wxWindow::UnpackScroll + 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 wxWindowOS2::UnpackScroll -void wxWindow::UnpackMenuSelect( +void wxWindowOS2::UnpackMenuSelect( WXWPARAM wParam , WXLPARAM lParam , WXWORD* pItem @@ -1754,7 +2211,7 @@ void wxWindow::UnpackMenuSelect( *pItem = (WXWORD)LOWORD(wParam); *pFlags = HIWORD(wParam); *phMenu = (WXHMENU)lParam; -} // end of wxWindow::UnpackMenuSelect +} // end of wxWindowOS2::UnpackMenuSelect // --------------------------------------------------------------------------- // Main wxWindows window proc and the window proc for wxWindow @@ -1764,12 +2221,12 @@ void wxWindow::UnpackMenuSelect( // Hook for new window just as it's being created, when the window isn't yet // associated with the handle // -wxWindow* wxWndHook = NULL; +wxWindowOS2* wxWndHook = NULL; // // Main window proc // -MRESULT wxWndProc( +MRESULT EXPENTRY wxWndProc( HWND hWnd , ULONG ulMsg , MPARAM wParam @@ -1784,7 +2241,7 @@ MRESULT wxWndProc( wxGetMessageName(ulMsg), wParam, lParam); #endif // __WXDEBUG__ - wxWindow* pWnd = wxFindWinFromHandle((WXHWND)hWnd); + wxWindowOS2* pWnd = wxFindWinFromHandle((WXHWND)hWnd); // // When we get the first message for the HWND we just created, we associate @@ -1798,7 +2255,8 @@ MRESULT wxWndProc( 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. @@ -1816,6 +2274,7 @@ MRESULT wxWndProc( else rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam); } + return rc; } // end of wxWndProc @@ -1823,7 +2282,7 @@ MRESULT wxWndProc( // We will add (or delete) messages we need to handle at this default // level as we go // -MRESULT wxWindow::OS2WindowProc( +MRESULT wxWindowOS2::OS2WindowProc( WXUINT uMsg , WXWPARAM wParam , WXLPARAM lParam @@ -1833,22 +2292,12 @@ MRESULT wxWindow::OS2WindowProc( // Did we process the uMsg? // bool bProcessed = FALSE; - - // - // The return value - // - union - { - bool bAllow; - MRESULT mResult; - WXHICON hIcon; - WXHBRUSH hBrush; - } vRc; + MRESULT mResult; // // For most messages we should return 0 when we do process the message // - vRc.mResult = (MRESULT)0; + mResult = (MRESULT)0; switch (uMsg) { @@ -1864,14 +2313,15 @@ MRESULT wxWindow::OS2WindowProc( // // 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) @@ -1900,6 +2350,7 @@ MRESULT wxWindow::OS2WindowProc( bProcessed = HandleActivate( wState ,(WXHWND)hWnd ); + bProcessed = FALSE; } break; @@ -1920,7 +2371,7 @@ MRESULT wxWindow::OS2WindowProc( // ourselves in ~wxWindow // bProcessed = TRUE; - vRc.mResult = (MRESULT)TRUE; + mResult = (MRESULT)TRUE; break; case WM_SHOW: @@ -1954,7 +2405,6 @@ MRESULT wxWindow::OS2WindowProc( bProcessed = HandleMouseEvent(uMsg, x, y, (WXUINT)wParam); } break; - case WM_SYSCOMMAND: bProcessed = HandleSysCommand(wParam, lParam); break; @@ -1975,27 +2425,28 @@ MRESULT wxWindow::OS2WindowProc( 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; } // @@ -2013,6 +2464,7 @@ MRESULT wxWindow::OS2WindowProc( if (uKeyFlags & KC_KEYUP) { + //TODO: check if the cast to WXWORD isn't causing trouble bProcessed = HandleKeyUp((WXDWORD)wParam, lParam); break; } @@ -2094,22 +2546,17 @@ MRESULT wxWindow::OS2WindowProc( #if defined(__VISAGECPP__) && (__IBMCPP__ >= 400) case WM_CTLCOLORCHANGE: { - bProcessed = HandleCtlColor(&vRc.hBrush); + bProcessed = HandleCtlColor(&hBrush); } break; #endif - // - // Instead of CTLCOLOR messages PM sends QUERYWINDOWPARAMS to - // things such as colors and fonts and such - // - case WM_QUERYWINDOWPARAMS: - { - PWNDPARAMS pWndParams = (PWNDPARAMS)wParam; - - bProcessed = HandleWindowParams( pWndParams - ,lParam - ); - } + 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; // the return value for this message is ignored @@ -2121,22 +2568,6 @@ MRESULT wxWindow::OS2WindowProc( bProcessed = HandlePaletteChanged(); break; - case WM_PRESPARAMCHANGED: - 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: bProcessed = HandleEndDrag(wParam); @@ -2148,18 +2579,18 @@ MRESULT wxWindow::OS2WindowProc( 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; // @@ -2176,30 +2607,32 @@ MRESULT wxWindow::OS2WindowProc( // 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; -} // end of wxWindow::OS2WindowProc + return mResult; +} // end of wxWindowOS2::OS2WindowProc // // Dialog window proc // MRESULT wxDlgProc( - HWND hWnd + HWND WXUNUSED(hWnd) , UINT uMsg -, MPARAM wParam -, MPARAM lParam) +, MPARAM WXUNUSED(wParam) +, MPARAM WXUNUSED(lParam)) { if (uMsg == WM_INITDLG) { @@ -2232,7 +2665,7 @@ wxWindow* wxFindWinFromHandle( void wxAssociateWinWithHandle( HWND hWnd -, wxWindow* pWin +, wxWindowOS2* pWin ) { // @@ -2262,7 +2695,7 @@ void wxAssociateWinWithHandle( } // end of wxAssociateWinWithHandle void wxRemoveHandleAssociation( - wxWindow* pWin + wxWindowOS2* pWin ) { wxWinHandleList->DeleteObject(pWin); @@ -2272,12 +2705,13 @@ void wxRemoveHandleAssociation( // Default destroyer - override if you destroy it in some other way // (e.g. with MDI child windows) // -void wxWindow::OS2DestroyWindow() +void wxWindowOS2::OS2DestroyWindow() { } -void wxWindow::OS2DetachWindowMenu() +void wxWindowOS2::OS2DetachWindowMenu() { +#ifndef __WXUNIVERSAL__ if (m_hMenu) { HMENU hMenu = (HMENU)m_hMenu; @@ -2306,147 +2740,120 @@ void wxWindow::OS2DetachWindowMenu() } } } -} // end of wxWindow::OS2DetachWindowMenu +#endif // __WXUNIVERSAL__ +} // end of wxWindowOS2::OS2DetachWindowMenu -bool wxWindow::OS2Create( - int vId -, wxWindow* pParent -, const wxChar* zWclass -, wxWindow* pWxWin +bool wxWindowOS2::OS2Create( + 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 WXUNUSED(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 // panel size the size of the parent window // - RECTL vParentRect; - HWND hWndClient; + lX1 = lX; + lY1 = lY; + if (lWidth > -1L) + lWidth1 = lWidth; + if (lHeight > -1L) + lHeight1 = lHeight; - HWND hParent = (HWND)NULL; + wxWndHook = this; - if (pParent) + // + // 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 + ) { - hParent = (HWND)pParent->GetHWND(); - hWndClient = ::WinWindowFromID(hParent, FID_CLIENT); - ::WinQueryWindowRect(hWndClient, &vParentRect); - - nWidth1 = vParentRect.xRight - vParentRect.xLeft; - nHeight1 = vParentRect.yTop - vParentRect.yBottom; + nControlId = ulId; } - - if (nX > -1) - nX1 = nX; - if (nY > -1) - nY1 = nY; - if (nWidth > -1) - nWidth1 = nWidth; - if (nHeight > -1) - nHeight1 = nHeight; - - wxWndHook = this; - - if (zDialogTemplate) + else { - // - // 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) + // no standard controls + if(wxString (wxT("wxFrameClass")) == wxString(zClass) ) { - wxLogError(_("Can't find dummy dialog template!\n" - "Check resource include path for finding wx.rc.")); - return FALSE; + pszClass = WC_FRAME; + nNeedsubclass = 1; } - - // - // 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 - )); + else { - wxLogLastError(wxT("MoveWindow")); + nControlId = ulId; + if(nControlId < 0) + nControlId = FID_CLIENT; } } - 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); + 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; + } - if (GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE ) - { - sClassName += wxT("NR"); - } + // + // We will either have a registered class via string name or a standard PM Class via a long + // + m_hWnd = (WXHWND)::WinCreateWindow(parent, zClass, + (PSZ)zTitle ? zTitle : wxT(""), + dwStyle, lX1, lY1, lWidth, lHeight, + hOwner, HWND_TOP, (ULONG)nControlId, + pCtlData, pPresParams); - 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) - { - wxLogError("Can't create window of class %s!\n", zWclass); - return FALSE; - } + 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__ @@ -2466,8 +2873,19 @@ bool wxWindow::OS2Create( 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 +} // end of wxWindowOS2::OS2Create // =========================================================================== // OS2 PM message handlers @@ -2477,21 +2895,21 @@ bool wxWindow::OS2Create( // window creation/destruction // --------------------------------------------------------------------------- -bool wxWindow::HandleCreate( - WXLPCREATESTRUCT vCs +bool wxWindowOS2::HandleCreate( + WXLPCREATESTRUCT WXUNUSED(vCs) , bool* pbMayCreate ) { - wxWindowCreateEvent vEvent(this); + wxWindowCreateEvent vEvent((wxWindow*)this); (void)GetEventHandler()->ProcessEvent(vEvent); *pbMayCreate = TRUE; return TRUE; -} // end of wxWindow::HandleCreate +} // end of wxWindowOS2::HandleCreate -bool wxWindow::HandleDestroy() +bool wxWindowOS2::HandleDestroy() { - wxWindowDestroyEvent vEvent(this); + wxWindowDestroyEvent vEvent((wxWindow*)this); (void)GetEventHandler()->ProcessEvent(vEvent); @@ -2511,45 +2929,19 @@ bool wxWindow::HandleDestroy() // WM_DESTROY handled // return TRUE; -} // end of wxWindow::HandleDestroy +} // end of wxWindowOS2::HandleDestroy // --------------------------------------------------------------------------- // activation/focus // --------------------------------------------------------------------------- -void wxWindow::OnSetFocus( +void wxWindowOS2::OnSetFocus( wxFocusEvent& rEvent ) { - // - // Panel wants to track the window which was the last to have focus in it, - // so we want to set ourselves as the window which last had focus - // - // Notice that it's also important to do it upwards the tree becaus - // otherwise when the top level panel gets focus, it won't set it back to - // us, but to some other sibling - // - wxWindow* pWin = this; - - while (pWin) - { - wxWindow* pParent = pWin->GetParent(); - wxPanel* pPanel = wxDynamicCast( pParent - ,wxPanel - ); - if (pPanel) - { - pPanel->SetLastFocus(pWin); - } - pWin = pParent; - } - - wxLogTrace(_T("focus"), _T("%s (0x%08x) gets focus"), - GetClassInfo()->GetClassName(), GetHandle()); - rEvent.Skip(); -} // end of wxWindow::OnSetFocus +} // end of wxWindowOS2::OnSetFocus -bool wxWindow::HandleActivate( +bool wxWindowOS2::HandleActivate( int nState , WXHWND WXUNUSED(hActivate) ) @@ -2560,9 +2952,9 @@ bool wxWindow::HandleActivate( ); vEvent.SetEventObject(this); return GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::HandleActivate +} // end of wxWindowOS2::HandleActivate -bool wxWindow::HandleSetFocus( +bool wxWindowOS2::HandleSetFocus( WXHWND WXUNUSED(hWnd) ) { @@ -2576,24 +2968,22 @@ bool wxWindow::HandleSetFocus( } #endif // wxUSE_CARET - // - // Panel wants to track the window which was the last to have focus in it - // - wxPanel* pPanel = wxDynamicCast( GetParent() - ,wxPanel - ); - if (pPanel) +#if wxUSE_TEXTCTRL + // If it's a wxTextCtrl don't send the event as it will be done + // after the control gets to process it from EN_FOCUS handler + if ( wxDynamicCastThis(wxTextCtrl) ) { - pPanel->SetLastFocus(this); + return FALSE; } +#endif // wxUSE_TEXTCTRL wxFocusEvent vEvent(wxEVT_SET_FOCUS, m_windowId); vEvent.SetEventObject(this); return GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::HandleSetFocus +} // end of wxWindowOS2::HandleSetFocus -bool wxWindow::HandleKillFocus( +bool wxWindowOS2::HandleKillFocus( WXHWND WXUNUSED(hWnd) ) { @@ -2613,26 +3003,24 @@ bool wxWindow::HandleKillFocus( vEvent.SetEventObject(this); return GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::HandleKillFocus +} // end of wxWindowOS2::HandleKillFocus // --------------------------------------------------------------------------- // miscellaneous // --------------------------------------------------------------------------- -bool wxWindow::HandleShow( +bool wxWindowOS2::HandleShow( bool bShow -, int nStatus +, int WXUNUSED(nStatus) ) { - wxShowEvent vEvent( GetId() - ,bShow - ); + wxShowEvent vEvent(GetId(), bShow); vEvent.m_eventObject = this; return GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::HandleShow +} // end of wxWindowOS2::HandleShow -bool wxWindow::HandleInitDialog( +bool wxWindowOS2::HandleInitDialog( WXHWND WXUNUSED(hWndFocus) ) { @@ -2640,16 +3028,16 @@ bool wxWindow::HandleInitDialog( vEvent.m_eventObject = this; return GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::HandleInitDialog +} // end of wxWindowOS2::HandleInitDialog -bool wxWindow::HandleEndDrag(WXWPARAM wParam) +bool wxWindowOS2::HandleEndDrag(WXWPARAM WXUNUSED(wParam)) { // TODO: We'll handle drag and drop later return FALSE; } -bool wxWindow::HandleSetCursor( - USHORT vId +bool wxWindowOS2::HandleSetCursor( + USHORT WXUNUSED(vId) , WXHWND hPointer ) { @@ -2659,88 +3047,214 @@ bool wxWindow::HandleSetCursor( // ::WinSetPointer(HWND_DESKTOP, (HPOINTER)hPointer); return TRUE; -} // end of wxWindow::HandleSetCursor +} // end of wxWindowOS2::HandleSetCursor // --------------------------------------------------------------------------- // owner drawn stuff // --------------------------------------------------------------------------- -bool wxWindow::OS2OnDrawItem( +bool wxWindowOS2::OS2OnDrawItem( int vId , WXDRAWITEMSTRUCT* pItemStruct ) { - // - // I'll get to owner drawn stuff later - // +#if wxUSE_OWNER_DRAWN + wxDC vDc; +#if wxUSE_MENUS_NATIVE // - // 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 - ); - */ } +#endif // wxUSE_MENUS_NATIVE - else - return FALSE; + wxWindow* pItem = FindItem(vId); + + if (pItem && pItem->IsKindOf(CLASSINFO(wxControl))) + { + return ((wxControl *)pItem)->OS2OnDraw(pItemStruct); + } +#else + vId = vId; + pItemStruct = pItemStruct; #endif - return TRUE; -} // end of wxWindow::OS2OnDrawItem + return FALSE; +} // end of wxWindowOS2::OS2OnDrawItem -bool wxWindow::OS2OnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct) +bool wxWindowOS2::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 -*/ +#else + lId = lId; + pItemStruct = pItemStruct; +#endif // wxUSE_OWNER_DRAWN return FALSE; } @@ -2748,45 +3262,37 @@ bool wxWindow::OS2OnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct) // colours and palettes // --------------------------------------------------------------------------- -bool wxWindow::HandleSysColorChange() +bool wxWindowOS2::HandleSysColorChange() { wxSysColourChangedEvent vEvent; vEvent.SetEventObject(this); return GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::HandleSysColorChange +} // end of wxWindowOS2::HandleSysColorChange -bool wxWindow::HandleCtlColor( - WXHBRUSH* phBrush +bool wxWindowOS2::HandleCtlColor( + WXHBRUSH* WXUNUSED(phBrush) ) { // // Not much provided with message. So not sure I can do anything with it // return TRUE; -} // end of wxWindow::HandleCtlColor +} // end of wxWindowOS2::HandleCtlColor -bool wxWindow::HandleWindowParams( - PWNDPARAMS pWndParams -, WXLPARAM lParam -) -{ -// TODO: I'll do something here, just not sure what yet - return TRUE; -} // Define for each class of dialog and control -WXHBRUSH wxWindow::OnCtlColor(WXHDC hDC, - WXHWND hWnd, - WXUINT nCtlColor, - WXUINT message, - WXWPARAM wParam, - WXLPARAM lParam) +WXHBRUSH wxWindowOS2::OnCtlColor(WXHDC WXUNUSED(hDC), + WXHWND WXUNUSED(hWnd), + WXUINT WXUNUSED(nCtlColor), + WXUINT WXUNUSED(message), + WXWPARAM WXUNUSED(wParam), + WXLPARAM WXUNUSED(lParam)) { return (WXHBRUSH)0; } -bool wxWindow::HandlePaletteChanged() +bool wxWindowOS2::HandlePaletteChanged() { // need to set this to something first WXHWND hWndPalChange = NULLHANDLE; @@ -2797,27 +3303,12 @@ bool wxWindow::HandlePaletteChanged() vEvent.SetChangedWindow(wxFindWinFromHandle(hWndPalChange)); return GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::HandlePaletteChanged - -bool wxWindow::HandlePresParamChanged( - WXWPARAM wParam -) -{ - // - // TODO: Once again I'll do something here when I need it - // - //wxQueryNewPaletteEvent event(GetId()); - //event.SetEventObject(this); - // if the background is erased -// bProcessed = HandleEraseBkgnd((WXHDC)(HDC)wParam); - - return FALSE; //GetEventHandler()->ProcessEvent(event) && event.GetPaletteRealized(); -} +} // end of wxWindowOS2::HandlePaletteChanged // // Responds to colour changes: passes event on to children. // -void wxWindow::OnSysColourChanged( +void wxWindowOS2::OnSysColourChanged( wxSysColourChangedEvent& rEvent ) { @@ -2839,113 +3330,124 @@ void wxWindow::OnSysColourChanged( } pNode = pNode->Next(); } -} // end of wxWindow::OnSysColourChanged +} // end of wxWindowOS2::OnSysColourChanged // --------------------------------------------------------------------------- // painting // --------------------------------------------------------------------------- -bool wxWindow::HandlePaint() +bool wxWindowOS2::HandlePaint() { - HRGN hRgn = NULLHANDLE; + HRGN hRgn; + wxPaintEvent vEvent(m_windowId); + HPS hPS; + RECTL vRect; + bool bProcessed; - if (::WinQueryUpdateRegion(GetHwnd(), hRgn) == RGN_NULL) + // Create empty region + // TODO: get HPS somewhere else if possible + hPS = ::WinGetPS(GetHwnd()); + hRgn = ::GpiCreateRegion(hPS, 0, NULL); + + if (::WinQueryUpdateRegion(GetHwnd(), hRgn) == RGN_ERROR) { wxLogLastError("CreateRectRgn"); return FALSE; } - m_updateRegion = wxRegion(hRgn); - wxPaintEvent vEvent; + m_updateRegion = wxRegion(hRgn, hPS); vEvent.SetEventObject(this); - return (GetEventHandler()->ProcessEvent(vEvent)); -} // end of wxWindow::HandlePaint + bProcessed = GetEventHandler()->ProcessEvent(vEvent); + + return GetEventHandler()->ProcessEvent(vEvent); //bProcessed; +} // end of wxWindowOS2::HandlePaint -bool wxWindow::HandleEraseBkgnd(WXHDC hdc) +bool wxWindowOS2::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; + bool rc; + + ::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((wxWindow*)this); + vDC.BeginDrawing(); - dc.SetHDC(hdc); - dc.SetWindow(this); - dc.BeginDrawing(); + wxEraseEvent vEvent(m_windowId, &vDC); + + vEvent.SetEventObject(this); - wxEraseEvent event(m_windowId, &dc); - event.SetEventObject(this); - bool rc = GetEventHandler()->ProcessEvent(event); + 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 +} // end of wxWindowOS2::HandleEraseBkgnd -void wxWindow::OnEraseBackground( +void wxWindowOS2::OnEraseBackground( wxEraseEvent& rEvent ) { - // TODO: -} // end of wxWindow::OnEraseBackground + RECTL vRect; + HPS hPS = rEvent.m_dc->m_hPS; + APIRET rc; + LONG lColor = m_backgroundColour.GetPixel(); + + rc = ::WinQueryWindowRect(GetHwnd(), &vRect); + rc = ::WinFillRect(hPS, &vRect, lColor); +} // end of wxWindowOS2::OnEraseBackground // --------------------------------------------------------------------------- // moving and resizing // --------------------------------------------------------------------------- -bool wxWindow::HandleMinimize() +bool wxWindowOS2::HandleMinimize() { wxIconizeEvent vEvent(m_windowId); vEvent.SetEventObject(this); return GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::HandleMinimize +} // end of wxWindowOS2::HandleMinimize -bool wxWindow::HandleMaximize() +bool wxWindowOS2::HandleMaximize() { wxMaximizeEvent vEvent(m_windowId); vEvent.SetEventObject(this); return GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::HandleMaximize +} // end of wxWindowOS2::HandleMaximize -bool wxWindow::HandleMove( +bool wxWindowOS2::HandleMove( int nX , int nY ) { - wxMoveEvent vEvent( wxPoint( nX - ,nY - ) - ,m_windowId - ); + wxMoveEvent vEvent(wxPoint(nX, nY), m_windowId); vEvent.SetEventObject(this); return GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::HandleMove +} // end of wxWindowOS2::HandleMove -bool wxWindow::HandleSize( +bool wxWindowOS2::HandleSize( int nWidth , int nHeight , WXUINT WXUNUSED(nFlag) ) { - wxSizeEvent vEvent( wxSize( nWidth - ,nHeight - ) - ,m_windowId - ); + wxSizeEvent vEvent(wxSize(nWidth, nHeight), m_windowId); vEvent.SetEventObject(this); return GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::HandleSize +} // end of wxWindowOS2::HandleSize -bool wxWindow::HandleGetMinMaxInfo( +bool wxWindowOS2::HandleGetMinMaxInfo( PSWP pSwp ) { @@ -2970,17 +3472,18 @@ bool wxWindow::HandleGetMinMaxInfo( return FALSE; } return TRUE; -} // end of wxWindow::HandleGetMinMaxInfo +} // end of wxWindowOS2::HandleGetMinMaxInfo // --------------------------------------------------------------------------- // command messages // --------------------------------------------------------------------------- -bool wxWindow::HandleCommand( +bool wxWindowOS2::HandleCommand( WXWORD wId , WXWORD wCmd , WXHWND hControl ) { +#if wxUSE_MENUS_NATIVE if (wxCurrentPopupMenu) { wxMenu* pPopupMenu = wxCurrentPopupMenu; @@ -2988,6 +3491,7 @@ bool wxWindow::HandleCommand( wxCurrentPopupMenu = NULL; return pPopupMenu->OS2Command(wCmd, wId); } +#endif // wxUSE_MENUS_NATIVE wxWindow* pWin = FindItem(wId); @@ -2997,15 +3501,14 @@ bool wxWindow::HandleCommand( } if (pWin) - return pWin->OS2Command( wCmd - ,wId - ); + return pWin->OS2Command(wCmd, wId); + return FALSE; -} // end of wxWindow::HandleCommand +} // end of wxWindowOS2::HandleCommand -bool wxWindow::HandleSysCommand( +bool wxWindowOS2::HandleSysCommand( WXWPARAM wParam -, WXLPARAM lParam +, WXLPARAM WXUNUSED(lParam) ) { // @@ -3020,13 +3523,13 @@ bool wxWindow::HandleSysCommand( return HandleMinimize(); } return FALSE; -} // end of wxWindow::HandleSysCommand +} // end of wxWindowOS2::HandleSysCommand // --------------------------------------------------------------------------- // mouse events // --------------------------------------------------------------------------- - -void wxWindow::InitMouseEvent( +//TODO!!! check against MSW +void wxWindowOS2::InitMouseEvent( wxMouseEvent& rEvent , int nX , int nY @@ -3048,9 +3551,9 @@ void wxWindow::InitMouseEvent( m_lastMouseY = nY; m_lastMouseEvent = rEvent.GetEventType(); #endif // wxUSE_MOUSEEVENT_HACK -} // end of wxWindow::InitMouseEvent +} // end of wxWindowOS2::InitMouseEvent -bool wxWindow::HandleMouseEvent( +bool wxWindowOS2::HandleMouseEvent( WXUINT uMsg , int nX , int nY @@ -3086,9 +3589,9 @@ bool wxWindow::HandleMouseEvent( ); return GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::HandleMouseEvent +} // end of wxWindowOS2::HandleMouseEvent -bool wxWindow::HandleMouseMove( +bool wxWindowOS2::HandleMouseMove( int nX , int nY , WXUINT uFlags @@ -3116,7 +3619,7 @@ bool wxWindow::HandleMouseMove( ,nY ,uFlags ); -} // end of wxWindow::HandleMouseMove +} // end of wxWindowOS2::HandleMouseMove // --------------------------------------------------------------------------- // keyboard handling @@ -3126,7 +3629,7 @@ bool wxWindow::HandleMouseMove( // Create the key event of the given type for the given key - used by // HandleChar and HandleKeyDown/Up // -wxKeyEvent wxWindow::CreateKeyEvent( +wxKeyEvent wxWindowOS2::CreateKeyEvent( wxEventType eType , int nId , WXLPARAM lParam @@ -3161,14 +3664,14 @@ wxKeyEvent wxWindow::CreateKeyEvent( vEvent.m_y = vPoint.y; return vEvent; -} // end of wxWindow::CreateKeyEvent +} // end of wxWindowOS2::CreateKeyEvent // // isASCII is TRUE only when we're called from WM_CHAR handler and not from // WM_KEYDOWN one // -bool wxWindow::HandleChar( - WXWORD wParam +bool wxWindowOS2::HandleChar( + WXDWORD wParam , WXLPARAM lParam , bool isASCII ) @@ -3231,7 +3734,7 @@ bool wxWindow::HandleChar( return FALSE; } -bool wxWindow::HandleKeyDown( +bool wxWindowOS2::HandleKeyDown( WXWORD wParam , WXLPARAM lParam ) @@ -3259,10 +3762,10 @@ bool wxWindow::HandleKeyDown( } } return FALSE; -} // end of wxWindow::HandleKeyDown +} // end of wxWindowOS2::HandleKeyDown -bool wxWindow::HandleKeyUp( - WXWORD wParam +bool wxWindowOS2::HandleKeyUp( + WXDWORD wParam , WXLPARAM lParam ) { @@ -3287,7 +3790,7 @@ bool wxWindow::HandleKeyUp( return TRUE; } return FALSE; -} // end of wxWindow::HandleKeyUp +} // end of wxWindowOS2::HandleKeyUp // --------------------------------------------------------------------------- // joystick @@ -3297,7 +3800,7 @@ bool wxWindow::HandleKeyUp( // scrolling // --------------------------------------------------------------------------- -bool wxWindow::OS2OnScroll( +bool wxWindowOS2::OS2OnScroll( int nOrientation , WXWORD wParam , WXWORD wPos @@ -3352,7 +3855,7 @@ bool wxWindow::OS2OnScroll( return FALSE; } return GetEventHandler()->ProcessEvent(vEvent); -} // end of wxWindow::OS2OnScroll +} // end of wxWindowOS2::OS2OnScroll // =========================================================================== // global functions @@ -3362,10 +3865,31 @@ void wxGetCharSize( WXHWND hWnd , int* pX , int* pY -,wxFont* pTheFont +,wxFont* WXUNUSED(pTheFont) ) { - // TODO: we'll do this later + FONTMETRICS vFM; + HPS hPS; + BOOL rc; + + hPS =::WinGetPS(hWnd); + + rc = ::GpiQueryFontMetrics(hPS, sizeof(FONTMETRICS), &vFM); + if (rc) + { + if (pX) + *pX = vFM.lAveCharWidth; + if (pY) + *pY = vFM.lEmHeight + vFM.lExternalLeading; + } + else + { + if (pX) + *pX = 10; + if (pY) + *pY = 15; + } + ::WinReleasePS(hPS); } // end of wxGetCharSize // @@ -3968,6 +4492,8 @@ const char* wxGetMessageName( #endif // __WXDEBUG__ +// Unused? +#if 0 static void TranslateKbdEventToMouse( wxWindow* pWin , int* pX @@ -3996,4 +4522,47 @@ static void TranslateKbdEventToMouse( pWin->ScreenToClient(pX, pY); } // end of TranslateKbdEventToMouse +#endif + +// Find the wxWindow at the current mouse position, returning the mouse +// position. +wxWindow* wxFindWindowAtPointer( + wxPoint& WXUNUSED(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); +}