X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e3bfcacf3aa7f7e94f28e09fc75510e894095f87..d289329218fb13e56c297fc27d82cb44cb849083:/src/os2/window.cpp?ds=sidebyside diff --git a/src/os2/window.cpp b/src/os2/window.cpp index 96e10ba3cd..977e27bc94 100644 --- a/src/os2/window.cpp +++ b/src/os2/window.cpp @@ -1,4 +1,3 @@ -///////////////////////////////////////////////////////////////////////////// // Name: windows.cpp // Purpose: wxWindow // Author: David Webster @@ -28,14 +27,19 @@ #include "wx/app.h" #include "wx/panel.h" #include "wx/layout.h" + #include "wx/checkbox.h" + #include "wx/combobox.h" #include "wx/dialog.h" #include "wx/frame.h" #include "wx/listbox.h" #include "wx/button.h" + #include "wx/bmpbuttn.h" #include "wx/msgdlg.h" #include "wx/scrolwin.h" #include "wx/radiobox.h" + #include "wx/radiobut.h" #include "wx/slider.h" + #include "wx/statbox.h" #include "wx/statusbr.h" #include "wx/toolbar.h" #include "wx/settings.h" @@ -59,6 +63,10 @@ #include "wx/tooltip.h" #endif +#if wxUSE_NOTEBOOK + #include "wx/notebook.h" +#endif + #if wxUSE_CARET #include "wx/caret.h" #endif // wxUSE_CARET @@ -93,6 +101,20 @@ # define CW_USEDEFAULT ((int)0x80000000) #endif +#ifndef VK_OEM_1 + #define VK_OEM_1 0xBA + #define VK_OEM_PLUS 0xBB + #define VK_OEM_COMMA 0xBC + #define VK_OEM_MINUS 0xBD + #define VK_OEM_PERIOD 0xBE + #define VK_OEM_2 0xBF + #define VK_OEM_3 0xC0 + #define VK_OEM_4 0xDB + #define VK_OEM_5 0xDC + #define VK_OEM_6 0xDD + #define VK_OEM_7 0xDE +#endif + // --------------------------------------------------------------------------- // global variables // --------------------------------------------------------------------------- @@ -106,8 +128,6 @@ QMSG s_currentMsg; wxMenu* wxCurrentPopupMenu = NULL; #endif // wxUSE_MENUS_NATIVE -wxList* wxWinHandleList = NULL; - // --------------------------------------------------------------------------- // private functions // --------------------------------------------------------------------------- @@ -125,24 +145,16 @@ MRESULT EXPENTRY wxWndProc( HWND hWnd const char *wxGetMessageName(int message); #endif //__WXDEBUG__ -void wxRemoveHandleAssociation(wxWindowOS2* pWin); -void wxAssociateWinWithHandle( HWND hWnd - ,wxWindowOS2* pWin - ); +wxWindowOS2* FindWindowForMouseEvent( wxWindow* pWin + ,short* pnX + ,short* pnY + ); +void wxRemoveHandleAssociation(wxWindowOS2* pWin); +void wxAssociateWinWithHandle( HWND hWnd + ,wxWindowOS2* pWin + ); 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 // @@ -166,7 +178,6 @@ static wxWindow* gpWinBeingCreated = NULL; 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() @@ -205,17 +216,17 @@ wxWindow* wxWindowOS2::FindItem( } #endif // wxUSE_CONTROLS - wxWindowList::Node* pCurrent = GetChildren().GetFirst(); + wxWindowList::compatibility_iterator current = GetChildren().GetFirst(); - while (pCurrent) + while (current) { - wxWindow* pChildWin = pCurrent->GetData(); + wxWindow* pChildWin = current->GetData(); wxWindow* pWnd = pChildWin->FindItem(lId); if (pWnd) return pWnd; - pCurrent = pCurrent->GetNext(); + current = current->GetNext(); } return(NULL); } // end of wxWindowOS2::FindItem @@ -228,11 +239,11 @@ wxWindow* wxWindowOS2::FindItemByHWND( , bool bControlOnly ) const { - wxWindowList::Node* pCurrent = GetChildren().GetFirst(); + wxWindowList::compatibility_iterator current = GetChildren().GetFirst(); - while (pCurrent) + while (current) { - wxWindow* pParent = pCurrent->GetData(); + wxWindow* pParent = current->GetData(); // // Do a recursive search. @@ -248,7 +259,7 @@ wxWindow* wxWindowOS2::FindItemByHWND( #endif // wxUSE_CONTROLS ) { - wxWindow* pItem = pCurrent->GetData(); + wxWindow* pItem = current->GetData(); if (pItem->GetHWND() == hWnd) return(pItem); @@ -258,7 +269,7 @@ wxWindow* wxWindowOS2::FindItemByHWND( return(pItem); } } - pCurrent = pCurrent->GetNext(); + current = current->GetNext(); } return(NULL); } // end of wxWindowOS2::FindItemByHWND @@ -280,21 +291,16 @@ bool wxWindowOS2::OS2Command( void wxWindowOS2::Init() { - // - // Generic - // - InitBase(); - // // PM specific // - m_bDoubleClickAllowed = 0; m_bWinCaptured = FALSE; - m_isBeingDeleted = FALSE; - m_fnOldWndProc = 0; - m_bUseCtl3D = FALSE; - m_bMouseInWindow = FALSE; + m_fnOldWndProc = NULL; + m_bUseCtl3D = FALSE; + m_bMouseInWindow = FALSE; + m_bLastKeydownProcessed = FALSE; + m_pChildrenDisabled = NULL; // // wxWnd @@ -304,8 +310,11 @@ void wxWindowOS2::Init() m_hWndScrollBarHorz = 0L; m_hWndScrollBarVert = 0L; + memset(&m_vWinSwp, '\0', sizeof (SWP)); + // // Pass WM_GETDLGCODE to DefWindowProc() + // m_lDlgCode = 0; m_nXThumbSize = 0; @@ -333,20 +342,17 @@ wxWindowOS2::~wxWindowOS2() for (wxWindow* pWin = GetParent(); pWin; pWin = pWin->GetParent()) { - wxFrame* pFrame = wxDynamicCast(pWin, wxFrame); + wxTopLevelWindow* pFrame = wxDynamicCast(pWin, wxTopLevelWindow); if (pFrame) { if (pFrame->GetLastFocus() == this) - pFrame->SetLastFocus((wxWindow*)NULL); + pFrame->SetLastFocus(NULL); } } DestroyChildren(); - if (m_parent) - m_parent->RemoveChild(this); - if (m_hWnd) { if(!::WinDestroyWindow(GetHWND())) @@ -356,6 +362,7 @@ wxWindowOS2::~wxWindowOS2() // wxRemoveHandleAssociation(this); } + delete m_pChildrenDisabled; } // end of wxWindowOS2::~wxWindowOS2 // real construction (Init() must have been called before!) @@ -374,6 +381,19 @@ bool wxWindowOS2::Create( wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent")); +#if wxUSE_STATBOX + // + // wxGTK doesn't allow to create controls with static box as the parent so + // this will result in a crash when the program is ported to wxGTK - warn + // about it + // + // the correct solution is to create the controls as siblings of the + // static box + // + wxASSERT_MSG( !wxDynamicCast(pParent, wxStaticBox), + _T("wxStaticBox can't be used as a window parent!") ); +#endif // wxUSE_STATBOX + if ( !CreateBase( pParent ,vId ,rPos @@ -386,8 +406,6 @@ bool wxWindowOS2::Create( if (pParent) { - int nTempy; - pParent->AddChild(this); hParent = GetWinHwnd(pParent); @@ -402,59 +420,36 @@ bool wxWindowOS2::Create( // set in those class create procs. PM's basic windows styles are // very limited. // - ulCreateFlags |= WS_VISIBLE; + ulCreateFlags |= OS2GetCreateWindowFlags(&dwExStyle); #ifdef __WXUNIVERSAL__ // no 3d effects, we draw them ourselves WXDWORD exStyle = 0; -#else // !wxUniversal - if (lStyle & wxCLIP_SIBLINGS) - ulCreateFlags |= WS_CLIPSIBLINGS; - - if (lStyle & wxCLIP_CHILDREN ) - ulCreateFlags |= WS_CLIPCHILDREN; - - // - // - // - bool bWant3D; - dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D); - -#endif - - // - // Add the simple border style as we'll use this to draw borders - // - if (lStyle & wxSIMPLE_BORDER) - dwExStyle |= wxSIMPLE_BORDER; - +#endif // !wxUniversal if (lStyle & wxPOPUP_WINDOW) { - // a popup window floats on top of everything -//TODO: fix this... -// exStyle |= WS_EX_TOPMOST | WS_EX_TOOLWINDOW; - - // it is also created hidden as other top level windows ulCreateFlags &= ~WS_VISIBLE; m_isShown = FALSE; } + else + { + ulCreateFlags |= WS_VISIBLE; + } // // Generic OS/2 Windows have no Control Data but other classes // that call OS2Create may have some. // - OS2Create( (PSZ)wxCanvasClassName - ,rName.c_str() - ,ulCreateFlags - ,rPos - ,rSize - ,NULL // Control Data - ,dwExStyle - ,TRUE // Child - ); - - return(TRUE); + return(OS2Create( (PSZ)wxCanvasClassName + ,rName.c_str() + ,ulCreateFlags + ,rPos + ,rSize + ,NULL // Control Data + ,dwExStyle + ,TRUE // Child + )); } // end of wxWindowOS2::Create // --------------------------------------------------------------------------- @@ -470,7 +465,15 @@ void wxWindowOS2::SetFocus() ::WinSetFocus(HWND_DESKTOP, hWnd); } // end of wxWindowOS2::SetFocus -wxWindow* wxWindowBase::FindFocus() +void wxWindowOS2::SetFocusFromKbd() +{ + // + // Nothing else to do under OS/2 + // + wxWindowBase::SetFocusFromKbd(); +} // end of wxWindowOS2::SetFocus + +wxWindow* wxWindowBase::DoFindFocus() { HWND hWnd = ::WinQueryFocus(HWND_DESKTOP); @@ -479,7 +482,7 @@ wxWindow* wxWindowBase::FindFocus() return wxFindWinFromHandle((WXHWND)hWnd); } return NULL; -} // wxWindowBase::FindFocus +} // wxWindowBase::DoFindFocus bool wxWindowOS2::Enable( bool bEnable @@ -493,14 +496,57 @@ bool wxWindowOS2::Enable( if ( hWnd ) ::WinEnableWindow(hWnd, (BOOL)bEnable); - wxWindowList::Node* pNode = GetChildren().GetFirst(); + // + // The logic below doesn't apply to the top level windows -- otherwise + // showing a modal dialog would result in total greying out (and ungreying + // out later) of everything which would be really ugly + // + if (IsTopLevel()) + return TRUE; + + wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); - while (pNode) + while (node) { - wxWindow* pChild = pNode->GetData(); + wxWindow* pChild = node->GetData(); - pChild->Enable(bEnable); - pNode = pNode->GetNext(); + if (bEnable) + { + // + // Enable the child back unless it had been disabled before us + // + if (!m_pChildrenDisabled || !m_pChildrenDisabled->Find(pChild)) + pChild->Enable(); + } + else // we're being disabled + { + if (pChild->IsEnabled()) + { + // + // Disable it as children shouldn't stay enabled while the + // parent is not + // + pChild->Disable(); + } + else // child already disabled, remember it + { + // + // Have we created the list of disabled children already? + // + if (!m_pChildrenDisabled) + m_pChildrenDisabled = new wxWindowList; + m_pChildrenDisabled->Append(pChild); + } + } + node = node->GetNext(); + } + if (bEnable && m_pChildrenDisabled) + { + // + // We don't need this list any more, don't keep unused memory + // + delete m_pChildrenDisabled; + m_pChildrenDisabled = NULL; } return TRUE; } // end of wxWindowOS2::Enable @@ -631,81 +677,11 @@ void wxWindowOS2::WarpPointer( ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY)); } // end of wxWindowOS2::WarpPointer -#if WXWIN_COMPATIBILITY -void wxWindowOS2::OS2DeviceToLogical (float *x, float *y) const -{ -} -#endif // WXWIN_COMPATIBILITY // --------------------------------------------------------------------------- // scrolling stuff // --------------------------------------------------------------------------- -#if WXWIN_COMPATIBILITY -void wxWindowOS2::SetScrollRange( - int nOrient -, int nRange -, bool bRefresh -) -{ - 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 wxWindowOS2::SetScrollPage( - int nOrient -, int nPage -, bool bRefresh -) -{ - if (nOrient == wxHORIZONTAL ) - m_nXThumbSize = nPage; - else - m_nYThumbSize = nPage; -} // end of wxWindowOS2::SetScrollPage - -int wxWindowOS2::OldGetScrollRange( - int nOrient -) const -{ - MRESULT mRc; - HWND hWnd = GetHwnd(); - - if (hWnd) - { - mRc = WinSendMsg(hWnd, SBM_QUERYRANGE, (MPARAM)0L, (MPARAM)0L); - return(SHORT2FROMMR(mRc)); - } - return 0; -} // end of wxWindowOS2::OldGetScrollRange - -int wxWindowOS2::GetScrollPage( - int nOrient -) const -{ - if (nOrient == wxHORIZONTAL) - return m_nXThumbSize; - else - return m_nYThumbSize; -} // end of wxWindowOS2::GetScrollPage -#endif // WXWIN_COMPATIBILITY - int wxWindowOS2::GetScrollPos( int nOrient ) const @@ -759,15 +735,38 @@ void wxWindowOS2::SetScrollbar( , bool WXUNUSED(bRefresh) ) { + HWND hWnd = GetHwnd(); int nOldRange = nRange - nThumbVisible; int nRange1 = nOldRange; int nPageSize = nThumbVisible; + SBCDATA vInfo; - HWND hWnd = GetHwnd(); ULONG ulStyle = WS_VISIBLE | WS_SYNCPAINT; - RECTL vRect; + SWP vSwp; + SWP vSwpOwner; + HWND hWndParent; + HWND hWndClient; + wxWindow* pParent = GetParent(); + + if (pParent && pParent->IsKindOf(CLASSINFO(wxFrame))) + { + wxFrame* pFrame; + + pFrame = wxDynamicCast(pParent, wxFrame); + hWndParent = pFrame->GetFrame(); + hWndClient = GetHwndOf(pParent); + } + else + { + if (pParent) + hWndParent = GetHwndOf(pParent); + else + hWndParent = GetHwnd(); + hWndClient = hWndParent; + } + ::WinQueryWindowPos(hWndClient, &vSwp); + ::WinQueryWindowPos(hWnd, &vSwpOwner); - ::WinQueryWindowRect(hWnd, &vRect); if (nPageSize > 1 && nRange > 0) { nRange1 += (nPageSize - 1); @@ -784,53 +783,70 @@ void wxWindowOS2::SetScrollbar( if (m_hWndScrollBarHorz == 0L) { // - // We create the scrollbars with the desktop so that they are not - // registered as child windows of the window in order that child - // windows may be scrolled without scrolling the scrollbars themselves! + // Since the scrollbars are usually created before the owner is + // sized either via an OnSize event directly or via sizers or + // layout constraints, we will initially just use the coords of + // the parent window (this is usually a frame client window). But + // the bars themselves, are children of the parent frame (i.e + // siblings of the frame client. The owner, however is the actual + // window being scrolled (or at least the one responsible for + // handling the scroll events). The owner will be resized later, + // as it is usually a child of a top level window, and when that + // is done its scrollbars will be resized and repositioned as well. // - m_hWndScrollBarHorz = ::WinCreateWindow( hWnd + m_hWndScrollBarHorz = ::WinCreateWindow( hWndParent ,WC_SCROLLBAR ,(PSZ)NULL ,ulStyle - ,vRect.xLeft - ,vRect.yBottom - ,vRect.xRight - vRect.xLeft + ,vSwp.x + ,vSwp.y + ,vSwp.cx - 20 ,20 ,hWnd ,HWND_TOP - ,FID_HORZSCROLL + ,60000 ,&vInfo ,NULL ); } else { - RECTL vRect2; - // - // Only want to resize the scrollbar if it changes, otherwise - // we'd probably end up in a recursive loop until we crash the call stack - // because this method is called in a ScrolledWindow OnSize event and SWP_MOVE | SWP_SIZE - // generates those events. + // The owner (the scrolled window) is a child of the Frame's + // client window, usually. The scrollbars are children of the + // frame, itself, and thus are positioned relative to the frame's + // origin, not the frame's client window origin. + // The starting x position is the same as the starting x position + // of the owner, but in terms of the parent frame. + // The starting y position is 20 pels below the origin of the + // owner in terms of the parent frame. + // The horz bar is the same width as the owner and 20 pels high. // - ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect2); - if (!(vRect2.xLeft == vRect.xLeft && - vRect2.xRight == vRect.xRight && - vRect2.yBottom == vRect.yBottom && - vRect2.yTop == vRect.yTop - ) ) + if (nRange1 >= nThumbVisible) { ::WinSetWindowPos( m_hWndScrollBarHorz ,HWND_TOP - ,vRect.xLeft - ,vRect.yBottom - ,vRect.xRight - vRect.xLeft + ,vSwp.x + vSwpOwner.x + ,(vSwp.y + vSwpOwner.y) - 20 + ,vSwpOwner.cx ,20 - ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW + ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER ); + ::WinSendMsg( m_hWndScrollBarHorz + ,SBM_SETSCROLLBAR + ,(MPARAM)nPos + ,MPFROM2SHORT(0, (SHORT)nRange1) + ); + ::WinSendMsg( m_hWndScrollBarHorz + ,SBM_SETTHUMBSIZE + ,MPFROM2SHORT( (SHORT)nThumbVisible + ,(SHORT)nRange1 + ) + ,(MPARAM)0 + ); } - ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1)); - ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0); + else + ::WinShowWindow(m_hWndScrollBarHorz, FALSE); } } else @@ -838,49 +854,75 @@ void wxWindowOS2::SetScrollbar( ulStyle |= SBS_VERT; if (m_hWndScrollBarVert == 0L) { - m_hWndScrollBarVert = ::WinCreateWindow( hWnd + // + // Since the scrollbars are usually created before the owner is + // sized either via an OnSize event directly or via sizers or + // layout constraints, we will initially just use the coords of + // the parent window (this is usually a frame client window). But + // the bars themselves, are children of the parent frame (i.e + // siblings of the frame client. The owner, however is the actual + // window being scrolled (or at least the one responsible for + // handling the scroll events). The owner will be resized later, + // as it is usually a child of a top level window, and when that + // is done its scrollbars will be resized and repositioned as well. + // + m_hWndScrollBarVert = ::WinCreateWindow( hWndParent ,WC_SCROLLBAR ,(PSZ)NULL ,ulStyle - ,vRect.xRight - 20 - ,vRect.yBottom + 20 + ,vSwp.x + vSwp.cx - 20 + ,vSwp.y + 20 ,20 - ,vRect.yTop - (vRect.yBottom + 20) + ,vSwp.cy - 20 ,hWnd ,HWND_TOP - ,FID_VERTSCROLL + ,60001 ,&vInfo ,NULL ); } else { - RECTL vRect2; - // - // Only want to resize the scrollbar if it changes, otherwise - // we'd probably end up in a recursive loop until we crash the call stack - // because this method is called in a ScrolledWindow OnSize event and SWP_MOVE | SWP_SIZE - // generates those events. + // The owner (the scrolled window) is a child of the Frame's + // client window, usually. The scrollbars are children of the + // frame, itself and thus are positioned relative to the frame's + // origin, not the frame's client window's origin. + // Thus, the x position will be frame client's x (usually a few + // pels inside the parent frame, plus the width of the owner. + // Since we may be using sizers or layout constraints for multiple + // child scrolled windows, the y position will be the frame client's + // y pos plus the scrolled windows y position, yielding the y + // position of the scrollbar relative to the parent frame (the vert + // scrollbar is on the right and starts at the bottom of the + // owner window). + // It is 20 pels wide and the same height as the owner. // - ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect2); - if (!(vRect2.xLeft == vRect.xLeft && - vRect2.xRight == vRect.xRight && - vRect2.yBottom == vRect.yBottom && - vRect2.yTop == vRect.yTop - ) ) + if (nRange1 >= nThumbVisible) { ::WinSetWindowPos( m_hWndScrollBarVert ,HWND_TOP - ,vRect.xRight - 20 - ,vRect.yBottom + 20 + ,vSwp.x + vSwpOwner.x + vSwpOwner.cx + ,vSwp.y + vSwpOwner.y ,20 - ,vRect.yTop - (vRect.yBottom + 20) + ,vSwpOwner.cy ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW ); + ::WinSendMsg( m_hWndScrollBarVert + ,SBM_SETSCROLLBAR + ,(MPARAM)nPos + ,MPFROM2SHORT(0, (SHORT)nRange1) + ); + ::WinSendMsg( m_hWndScrollBarVert + ,SBM_SETTHUMBSIZE + ,MPFROM2SHORT( (SHORT)nThumbVisible + ,(SHORT)nRange1 + ) + ,(MPARAM)0 + ); } - ::WinSendMsg(m_hWndScrollBarVert, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1)); - ::WinSendMsg(m_hWndScrollBarVert, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0); + else + ::WinShowWindow(m_hWndScrollBarVert, FALSE); } m_nYThumbSize = nThumbVisible; } @@ -893,86 +935,26 @@ void wxWindowOS2::ScrollWindow( ) { 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 + pRect->height; - vRect2.xRight = pRect->x + pRect->width; - vRect2.yBottom = pRect->y; - } - else - { - ::WinQueryWindowRect(GetHwnd(), &vRect2); - ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect); - vRect2.yBottom += vRect.yTop - vRect.yBottom; - ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect); - vRect2.xRight -= vRect.xRight - vRect.xLeft; - } + ::WinQueryWindowRect(GetHwnd(), &vRect); + int height = vRect.yTop; if (pRect) - ::WinScrollWindow( GetHwnd() - ,(LONG)nDx - ,(LONG)nDy - ,&vRect2 - ,NULL - ,NULLHANDLE - ,NULL - ,SW_INVALIDATERGN - ); - else - ::WinScrollWindow( GetHwnd() - ,nDx - ,nDy - ,NULL - ,NULL - ,NULLHANDLE - ,NULL - ,SW_INVALIDATERGN - ); - - // - // Move the children - wxWindowList::Node* pCurrent = GetChildren().GetFirst(); - SWP vSwp; - - while (pCurrent) { - wxWindow* pChildWin = pCurrent->GetData(); - - if (pChildWin->GetHWND() != NULLHANDLE) - { - ::WinQueryWindowPos(pChildWin->GetHWND(), &vSwp); - ::WinQueryWindowRect(pChildWin->GetHWND(), &vRect); - if (pChildWin->GetHWND() == m_hWndScrollBarVert || - pChildWin->GetHWND() == m_hWndScrollBarHorz) - { - ::WinSetWindowPos( pChildWin->GetHWND() - ,HWND_TOP - ,vSwp.x + nDx - ,vSwp.y + nDy - ,0 - ,0 - ,SWP_MOVE | SWP_SHOW | SWP_ZORDER - ); - } - else - { - ::WinSetWindowPos( pChildWin->GetHWND() - ,HWND_BOTTOM - ,vSwp.x + nDx - ,vSwp.y + nDy - ,0 - ,0 - ,SWP_MOVE | SWP_ZORDER - ); - ::WinInvalidateRect(pChildWin->GetHWND(), &vRect, FALSE); - } - } - pCurrent = pCurrent->GetNext(); + vRect.xLeft = pRect->x; + vRect.yTop = height - pRect->y; + vRect.xRight = pRect->x + pRect->width; + vRect.yBottom = vRect.yTop - pRect->height; } + nDy *= -1; // flip the sign of Dy as OS/2 is opposite Windows. + ::WinScrollWindow( GetHwnd() + ,(LONG)nDx + ,(LONG)nDy + ,&vRect + ,&vRect + ,NULL + ,NULL + ,SW_SCROLLCHILDREN | SW_INVALIDATERGN + ); } // end of wxWindowOS2::ScrollWindow // --------------------------------------------------------------------------- @@ -1035,8 +1017,71 @@ bool wxCheckWindowWndProc( return(fnWndProc == (WXFARPROC)vCls.pfnWindowProc); } // end of WinGuiBase_CheckWindowWndProc +void wxWindowOS2::SetWindowStyleFlag( + long lFlags +) +{ + long lFlagsOld = GetWindowStyleFlag(); + + if (lFlags == lFlagsOld) + return; + + // + // Update the internal variable + // + wxWindowBase::SetWindowStyleFlag(lFlags); + + // + // Now update the Windows style as well if needed - and if the window had + // been already created + // + if (!GetHwnd()) + return; + + WXDWORD dwExstyle; + WXDWORD dwExstyleOld; + long lStyle = OS2GetStyle( lFlags + ,&dwExstyle + ); + long lStyleOld = OS2GetStyle( lFlagsOld + ,&dwExstyleOld + ); + + if (lStyle != lStyleOld) + { + // + // Some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by + // this function so instead of simply setting the style to the new + // value we clear the bits which were set in styleOld but are set in + // the new one and set the ones which were not set before + // + long lStyleReal = ::WinQueryWindowULong(GetHwnd(), QWL_STYLE); + + lStyleReal &= ~lStyleOld; + lStyleReal |= lStyle; + + ::WinSetWindowULong(GetHwnd(), QWL_STYLE, lStyleReal); + } +} // end of wxWindowOS2::SetWindowStyleFlag + +WXDWORD wxWindowOS2::OS2GetStyle( + long lFlags +, WXDWORD* pdwExstyle +) const +{ + WXDWORD dwStyle = 0L; + + if (lFlags & wxCLIP_CHILDREN ) + dwStyle |= WS_CLIPCHILDREN; + + if (lFlags & wxCLIP_SIBLINGS ) + dwStyle |= WS_CLIPSIBLINGS; + + return dwStyle; +} // end of wxWindowMSW::MSWGetStyle + // -// Make a Windows extended style from the given wxWindows window style +// Make a Windows extended style from the given wxWidgets window style // WXDWORD wxWindowOS2::MakeExtendedStyle( long lStyle @@ -1066,118 +1111,6 @@ WXDWORD wxWindowOS2::MakeExtendedStyle( return dwStyle; } // end of wxWindowOS2::MakeExtendedStyle -// -// 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 OS2Create. -// -WXDWORD wxWindowOS2::Determine3DEffects( - WXDWORD dwDefaultBorderStyle -, bool* pbWant3D -) const -{ - WXDWORD dwStyle = 0L; - - // - // 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. - // - 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 wxWindowOS2::Determine3DEffects - -#if WXWIN_COMPATIBILITY -void wxWindowOS2::OnCommand( - wxWindow& rWin -, wxCommandEvent& rEvent -) -{ - if (GetEventHandler()->ProcessEvent(rEvent)) - return; - if (m_parent) - m_parent->GetEventHandler()->OnCommand( rWin - ,rEvent - ); -} // end of wxWindowOS2::OnCommand - -wxObject* wxWindowOS2::GetChild( - int nNumber -) const -{ - // - // Return a pointer to the Nth object in the Panel - // - wxNode* pNode = GetChildren().First(); - int n = nNumber; - - while (pNode && n--) - pNode = pNode->Next(); - if (pNode) - { - wxObject* pObj = (wxObject*)pNode->Data(); - return(pObj); - } - else - return NULL; -} // end of wxWindowOS2::GetChild - -#endif // WXWIN_COMPATIBILITY - // // Setup background and foreground colours correctly // @@ -1213,10 +1146,10 @@ void wxWindowOS2::OnIdle( // int nState = 0; - if (::WinGetKeyState(HWND_DESKTOP, VK_SHIFT) != 0) - nState |= VK_SHIFT; - if (::WinGetKeyState(HWND_DESKTOP, VK_CTRL) != 0); - nState |= VK_CTRL; + if (IsShiftDown()) + nState |= KC_SHIFT; + if (IsCtrlDown()) + nState |= KC_CTRL; wxMouseEvent rEvent(wxEVT_LEAVE_WINDOW); @@ -1228,7 +1161,8 @@ void wxWindowOS2::OnIdle( (void)GetEventHandler()->ProcessEvent(rEvent); } } - UpdateWindowUI(); + if (wxUpdateUIEvent::CanUpdate(this)) + UpdateWindowUI(wxUPDATE_UI_FROMIDLE); } // end of wxWindowOS2::OnIdle // @@ -1248,17 +1182,6 @@ bool wxWindowOS2::Reparent( return TRUE; } // end of wxWindowOS2::Reparent -void wxWindowOS2::Clear() -{ - wxClientDC vDc((wxWindow*)this); - wxBrush vBrush( GetBackgroundColour() - ,wxSOLID - ); - - vDc.SetBackground(vBrush); - vDc.Clear(); -} // end of wxWindowOS2::Clear - void wxWindowOS2::Update() { ::WinUpdateWindow(GetHwnd()); @@ -1292,16 +1215,23 @@ void wxWindowOS2::Refresh( if (pRect) { RECTL vOs2Rect; + int height; + ::WinQueryWindowRect(GetHwnd(), &vOs2Rect); + height = vOs2Rect.yTop; vOs2Rect.xLeft = pRect->x; - vOs2Rect.yTop = pRect->y; + vOs2Rect.yTop = height - pRect->y; vOs2Rect.xRight = pRect->x + pRect->width; - vOs2Rect.yBottom = pRect->y + pRect->height; + vOs2Rect.yBottom = vOs2Rect.yTop - pRect->height; ::WinInvalidateRect(hWnd, &vOs2Rect, bEraseBack); } else ::WinInvalidateRect(hWnd, NULL, bEraseBack); + if (m_hWndScrollBarHorz != NULLHANDLE) + ::WinInvalidateRect(m_hWndScrollBarHorz, NULL, TRUE); + if (m_hWndScrollBarVert != NULLHANDLE) + ::WinInvalidateRect(m_hWndScrollBarVert, NULL, TRUE); } } // end of wxWindowOS2::Refresh @@ -1314,14 +1244,7 @@ void wxWindowOS2::SetDropTarget( wxDropTarget* pDropTarget ) { - if (m_dropTarget != 0) - { - m_dropTarget->Revoke(m_hWnd); - delete m_dropTarget; - } m_dropTarget = pDropTarget; - if (m_dropTarget != 0) - m_dropTarget->Register(m_hWnd); } // end of wxWindowOS2::SetDropTarget #endif @@ -1545,9 +1468,18 @@ void wxWindowOS2::DoMoveWindow( ) { RECTL vRect; - HWND hParent; wxWindow* pParent = GetParent(); + /* Due to OS/2's inverted coordinate system, changing the height + of a window requires repositioning all it's children, e.g. if + you want a child of height 100 to be at the top left corner of + the parent you need to position the lower left corner of the + child at (0, (height of parent - 100)), so, obviously, if the + height of the parent changes, the child needs to be repositioned. */ + int nHeightDelta; + GetSize(0, &nHeightDelta); + nHeightDelta = nHeight - nHeightDelta; + if (pParent && !IsKindOf(CLASSINFO(wxDialog))) { int nOS2Height = GetOS2ParentHeight(pParent); @@ -1561,20 +1493,148 @@ void wxWindowOS2::DoMoveWindow( ::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, -// but if any of them is equal to -1, it means that we must find the value for -// it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in + // + // In the case of a frame whose client is sized, the client cannot be + // large than its parent frame minus its borders! This usually happens + // when using an autosizer to size a frame to precisely hold client + // controls as in the notebook sample. + // + // In this case, we may need to resize both a frame and its client so we + // need a quick calc of the frame border size, then if the frame + // (less its borders) is smaller than the client, size the frame to + // encompass the client with the appropriate border size. + // + if (IsKindOf(CLASSINFO(wxFrame))) + { + RECTL vFRect; + HWND hWndFrame; + int nWidthFrameDelta = 0; + int nHeightFrameDelta = 0; + int nHeightFrame = 0; + int nWidthFrame = 0; + wxFrame* pFrame; + + pFrame = wxDynamicCast(this, wxFrame); + hWndFrame = pFrame->GetFrame(); + ::WinQueryWindowRect(hWndFrame, &vRect); + ::WinMapWindowPoints(hWndFrame, HWND_DESKTOP, (PPOINTL)&vRect, 2); + vFRect = vRect; + ::WinCalcFrameRect(hWndFrame, &vRect, TRUE); + nWidthFrameDelta = ((vRect.xLeft - vFRect.xLeft) + (vFRect.xRight - vRect.xRight)); + nHeightFrameDelta = ((vRect.yBottom - vFRect.yBottom) + (vFRect.yTop - vRect.yTop)); + nWidthFrame = vFRect.xRight - vFRect.xLeft; + nHeightFrame = vFRect.yTop - vFRect.yBottom; + + if (nWidth == vFRect.xRight - vFRect.xLeft && + nHeight == vFRect.yTop - vFRect.yBottom) + { + // + // In this case the caller is not aware of OS/2's need to size both + // the frame and it's client and is really only moving the window, + // not resizeing it. So move the frame, and back off the sizes + // for a proper client fit. + // + ::WinSetWindowPos( hWndFrame + ,HWND_TOP + ,(LONG)nX - (vRect.xLeft - vFRect.xLeft) + ,(LONG)nY - (vRect.yBottom - vFRect.yBottom) + ,(LONG)0 + ,(LONG)0 + ,SWP_MOVE + ); + nX += (vRect.xLeft - vFRect.xLeft); + nY += (vRect.yBottom - vFRect.yBottom); + nWidth -= nWidthFrameDelta; + nHeight -= nHeightFrameDelta; + } + else + { + if (nWidth > nWidthFrame - nHeightFrameDelta || + nHeight > nHeightFrame - nHeightFrameDelta) + { + ::WinSetWindowPos( hWndFrame + ,HWND_TOP + ,(LONG)nX - (vRect.xLeft - vFRect.xLeft) + ,(LONG)nY - (vRect.yBottom - vFRect.yBottom) + ,(LONG)nWidth + nWidthFrameDelta + ,(LONG)nHeight + nHeightFrameDelta + ,SWP_MOVE | SWP_SIZE + ); + } + } + } + + ::WinSetWindowPos( GetHwnd() + ,HWND_TOP + ,(LONG)nX + ,(LONG)nY + ,(LONG)nWidth + ,(LONG)nHeight + ,SWP_SIZE | SWP_MOVE + ); + if (m_vWinSwp.cx == 0 && m_vWinSwp.cy == 0 && m_vWinSwp.fl == 0) + // + // Uninitialized + // + ::WinQueryWindowPos(GetHwnd(), &m_vWinSwp); + else + { + int nYDiff = m_vWinSwp.cy - nHeight; + + // + // Handle resizing of scrolled windows. The target or window to + // be scrolled is the owner (gets the scroll notificaitons). The + // parent is usually the parent frame of the scrolled panel window. + // In order to show the scrollbars the target window will be shrunk + // by the size of the scroll bar widths (20) and moved in the X and Y + // directon. That value will be computed as part of the diff for + // moving the children. Everytime the window is sized the + // toplevel OnSize is going to resize the panel to fit the client + // or the whole sizer and will need to me resized. This will send + // a WM_SIZE out which will be intercepted by the ScrollHelper + // which will cause the scrollbars to be displayed via the SetScrollbar + // call in CWindow. + // + if ( IsKindOf(CLASSINFO(wxGenericScrolledWindow)) || + IsKindOf(CLASSINFO(wxScrolledWindow)) + ) + { + int nAdjustWidth = 0; + int nAdjustHeight = 0; + SWP vSwpScroll; + + if (GetScrollBarHorz() == NULLHANDLE || + !WinIsWindowShowing(GetScrollBarHorz())) + nAdjustHeight = 0L; + else + nAdjustHeight = 20L; + if (GetScrollBarVert() == NULLHANDLE || + !WinIsWindowShowing(GetScrollBarVert())) + nAdjustWidth = 0L; + else + nAdjustWidth = 20L; + ::WinQueryWindowPos(GetHWND(), &vSwpScroll); + ::WinSetWindowPos( GetHWND() + ,HWND_TOP + ,vSwpScroll.x + ,vSwpScroll.y + nAdjustHeight + ,vSwpScroll.cx - nAdjustWidth + ,vSwpScroll.cy - nAdjustHeight + ,SWP_MOVE | SWP_SIZE + ); + nYDiff += nAdjustHeight; + } + MoveChildren(nYDiff); + ::WinQueryWindowPos(GetHwnd(), &m_vWinSwp); + } + MoveChildren(nHeightDelta); +} // end of wxWindowOS2::DoMoveWindow + +// +// Set the size of the window: if the dimensions are positive, just use them, +// but if any of them is equal to -1, it means that we must find the value for +// it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in // which case -1 is a valid value for x and y) // // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate @@ -1608,21 +1668,7 @@ void wxWindowOS2::DoSetSize( // Must convert Y coords to test for equality under OS/2 // int nY2 = nY; - wxWindow* pParent = (wxWindow*)GetParent(); - if (pParent && !IsKindOf(CLASSINFO(wxDialog))) - { - int nOS2Height = GetOS2ParentHeight(pParent); - - nY2 = nOS2Height - (nY2 + nHeight); - } - else - { - RECTL vRect; - - ::WinQueryWindowRect(HWND_DESKTOP, &vRect); - nY2 = vRect.yTop - (nY2 + nHeight); - } if (nX == nCurrentX && nY2 == nCurrentY && nWidth == nCurrentWidth && nHeight == nCurrentHeight) { @@ -1681,43 +1727,65 @@ void wxWindowOS2::DoSetClientSize( , int nHeight ) { - wxWindow* pParent = GetParent(); - HWND hWnd = GetHwnd(); - HWND hParentWnd = (HWND)0; POINTL vPoint; - RECTL vRect; - RECTL vRect2; - RECTL vRect3; - HWND hClientWnd = (HWND)0; + int nActualWidth; + int nActualHeight; + wxWindow* pParent = (wxWindow*)GetParent(); + HWND hParentWnd = (HWND)0; - hClientWnd = ::WinWindowFromID(hWnd, FID_CLIENT); - ::WinQueryWindowRect(hClientWnd, &vRect2); - ::WinQueryWindowRect(hWnd, &vRect); - ::WinQueryWindowRect(hParentWnd, &vRect3); + if (pParent) + hParentWnd = (HWND)pParent->GetHWND(); - int nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth; - int nActualHeight = vRect2.yTop - vRect2.yBottom - vRect.yTop + nHeight; + if (IsKindOf(CLASSINFO(wxFrame))) + { + wxFrame* pFrame = wxDynamicCast(this, wxFrame); + HWND hFrame = pFrame->GetFrame(); + RECTL vRect; + RECTL vRect2; + RECTL vRect3; - vPoint.x = vRect2.xLeft; - vPoint.y = vRect2.yBottom; - if (pParent) + ::WinQueryWindowRect(GetHwnd(), &vRect2); + ::WinQueryWindowRect(hFrame, &vRect); + ::WinQueryWindowRect(hParentWnd, &vRect3); + nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth; + nActualHeight = vRect2.yTop - vRect2.yBottom - vRect.yTop + nHeight; + + vPoint.x = vRect2.xLeft; + vPoint.y = vRect2.yBottom; + if (pParent) + { + vPoint.x -= vRect3.xLeft; + vPoint.y -= vRect3.yBottom; + } + } + else { - vPoint.x -= vRect3.xLeft; - vPoint.y -= vRect3.yBottom; + int nX; + int nY; + + GetPosition(&nX, &nY); + nActualWidth = nWidth; + nActualHeight = nHeight; + + vPoint.x = nX; + vPoint.y = nY; } + DoMoveWindow( vPoint.x + ,vPoint.y + ,nActualWidth + ,nActualHeight + ); - DoMoveWindow(vPoint.x, vPoint.y, nActualWidth, nActualHeight); + wxSizeEvent vEvent( wxSize( nWidth + ,nHeight + ) + ,m_windowId + ); - wxSizeEvent vEvent(wxSize(nWidth, nHeight), m_windowId); vEvent.SetEventObject(this); GetEventHandler()->ProcessEvent(vEvent); } // end of wxWindowOS2::DoSetClientSize -wxPoint wxWindowOS2::GetClientAreaOrigin() const -{ - return wxPoint(0, 0); -} // end of wxWindowOS2::GetClientAreaOrigin - // --------------------------------------------------------------------------- // text metrics // --------------------------------------------------------------------------- @@ -1769,9 +1837,8 @@ void wxWindowOS2::GetTextExtent( int i; int l; FONTMETRICS vFM; // metrics structure - BOOL bRc; + BOOL bRc = FALSE; char* pStr; - ERRORID vErrorCode; // last error id code HPS hPS; @@ -1872,89 +1939,11 @@ bool wxWindowOS2::IsMouseInWindow() const return hWnd != NULL; } // end of wxWindowOS2::IsMouseInWindow -#if wxUSE_CARET && WXWIN_COMPATIBILITY -// --------------------------------------------------------------------------- -// Caret manipulation -// --------------------------------------------------------------------------- - -void wxWindowOS2::CreateCaret( - int nWidth -, int nHeight -) -{ - SetCaret(new wxCaret( this - ,nWidth - ,nHeight - )); -} // end of wxWindowOS2::CreateCaret - -void wxWindowOS2::CreateCaret( - const wxBitmap* pBitmap -) -{ - wxFAIL_MSG("not implemented"); -} // end of wxWindowOS2::CreateCaret - -void wxWindowOS2::ShowCaret( - bool bShow -) -{ - wxCHECK_RET( m_caret, "no caret to show" ); - - m_caret->Show(bShow); -} // end of wxWindowOS2::ShowCaret - -void wxWindowOS2::DestroyCaret() -{ - SetCaret(NULL); -} // end of wxWindowOS2::DestroyCaret - -void wxWindowOS2::SetCaretPos( - int nX -, int nY) -{ - wxCHECK_RET( m_caret, "no caret to move" ); - - m_caret->Move( nX - ,nY - ); -} // end of wxWindowOS2::SetCaretPos - -void wxWindowOS2::GetCaretPos( - int* pX -, int* pY -) const -{ - wxCHECK_RET( m_caret, "no caret to get position of" ); - - m_caret->GetPosition( pX - ,pY - ); -} // 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 - #if wxUSE_MENUS_NATIVE bool wxWindowOS2::DoPopupMenu( wxMenu* pMenu @@ -1962,36 +1951,54 @@ bool wxWindowOS2::DoPopupMenu( , int nY ) { - HWND hWnd = GetHwnd(); - HWND hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0; + HWND hWndOwner = GetHwnd(); + HWND hWndParent = GetHwnd(); HWND hMenu = GetHmenuOf(pMenu); + bool bIsWaiting = TRUE; + int nHeight; + + // Protect against recursion + if (wxCurrentPopupMenu) + return false; pMenu->SetInvokingWindow(this); pMenu->UpdateUI(); - DoClientToScreen( &nX - ,&nY - ); + if ( nX == -1 && nY == -1 ) + { + wxPoint mouse = wxGetMousePosition(); + nX = mouse.x; nY = mouse.y; + } + else + { + DoClientToScreen( &nX + ,&nY + ); + DoGetSize(0,&nHeight); + nY = nHeight - nY; + } wxCurrentPopupMenu = pMenu; ::WinPopupMenu( hWndParent - ,hWnd + ,hWndOwner ,hMenu ,nX ,nY ,0L - ,PU_MOUSEBUTTON2DOWN | PU_MOUSEBUTTON2 | PU_KEYBOARD + ,PU_HCONSTRAIN | PU_VCONSTRAIN | PU_MOUSEBUTTON1 | PU_KEYBOARD ); - // we need to do it righ now as otherwise the events are never going to be - // sent to wxCurrentPopupMenu from ;() - // - // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't - // help and we'd still need wxYieldForCommandsOnly() as the menu may be - // destroyed as soon as we return (it can be a local variable in the caller - // for example) and so we do need to process the event immediately - wxYieldForCommandsOnly(); - wxCurrentPopupMenu = NULL; + while(bIsWaiting) + { + QMSG vMsg; + + ::WinGetMsg(vHabmain,&vMsg, (HWND)0, 0, 0); + if (vMsg.msg == WM_COMMAND) + bIsWaiting = FALSE; + ::WinDispatchMsg(vHabmain, (PQMSG)&vMsg); + } + + wxCurrentPopupMenu = NULL; pMenu->SetInvokingWindow(NULL); return TRUE; } // end of wxWindowOS2::DoPopupMenu @@ -2140,6 +2147,14 @@ bool wxWindowOS2::OS2ProcessMessage( pBtn->OS2Command(BN_CLICKED, 0 /* unused */); return TRUE; } + else if (!IsTopLevel()) + { + // + // if not a top level window, let parent + // handle it + // + return FALSE; + } // else: but if it does not it makes sense to make // it work like a TAB - and that's what we do. // Note that Ctrl-Enter always works this way. @@ -2184,17 +2199,6 @@ bool wxWindowOS2::OS2ProcessMessage( pMsg = pMsg; // just shut up the compiler #endif // __WXUNIVERSAL__ -#if wxUSE_TOOLTIPS - if ( m_tooltip ) - { - // relay mouse move events to the tooltip control - QMSG* pQMsg = (QMSG*)pMsg; - - if (pQMsg->msg == WM_MOUSEMOVE ) - m_tooltip->RelayEvent(pMsg); - } -#endif // wxUSE_TOOLTIPS - return FALSE; } // end of wxWindowOS2::OS2ProcessMessage @@ -2282,7 +2286,7 @@ void wxWindowOS2::UnpackMenuSelect( } // end of wxWindowOS2::UnpackMenuSelect // --------------------------------------------------------------------------- -// Main wxWindows window proc and the window proc for wxWindow +// Main wxWidgets window proc and the window proc for wxWindow // --------------------------------------------------------------------------- // @@ -2301,14 +2305,6 @@ MRESULT EXPENTRY wxWndProc( , MPARAM lParam ) { - // - // Trace all ulMsgs - useful for the debugging - // -#ifdef __WXDEBUG__ - wxLogTrace(wxTraceMessages, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"), - wxGetMessageName(ulMsg), wParam, lParam); -#endif // __WXDEBUG__ - wxWindowOS2* pWnd = wxFindWinFromHandle((WXHWND)hWnd); // @@ -2338,7 +2334,18 @@ MRESULT EXPENTRY wxWndProc( else { if (pWnd) + { rc = pWnd->OS2WindowProc(ulMsg, wParam, lParam); + if ( (pWnd->GetScrollBarHorz() != NULLHANDLE || + pWnd->GetScrollBarVert() != NULLHANDLE) && + ulMsg == WM_PAINT) + { + if (pWnd->GetScrollBarHorz() != NULLHANDLE) + ::WinInvalidateRect(pWnd->GetScrollBarHorz(), NULL, TRUE); + if (pWnd->GetScrollBarVert() != NULLHANDLE) + ::WinInvalidateRect(pWnd->GetScrollBarVert(), NULL, TRUE); + } + } else rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam); } @@ -2416,7 +2423,7 @@ MRESULT wxWindowOS2::OS2WindowProc( // child controls, so we need to already be sized // in order to get the child controls positoned properly. // - if (IsKindOf(CLASSINFO(wxDialog))) + if (IsKindOf(CLASSINFO(wxDialog)) || IsKindOf(CLASSINFO(wxFrame))) { PSWP pSwp = (PSWP)PVOIDFROMMP(wParam); PSWP pSwp2 = pSwp++; @@ -2427,6 +2434,18 @@ MRESULT wxWindowOS2::OS2WindowProc( ,pSwp->cy ,(WXUINT)lParam ); + if (IsKindOf(CLASSINFO(wxFrame))) + { + wxFrame* pFrame = wxDynamicCast(this, wxFrame); + + if (pFrame) + { + if (pFrame->GetStatusBar()) + pFrame->PositionStatusBar(); + if (pFrame->GetToolBar()) + pFrame->PositionToolBar(); + } + } } break; @@ -2493,12 +2512,43 @@ MRESULT wxWindowOS2::OS2WindowProc( case WM_BUTTON3MOTIONEND: case WM_BUTTON3MOTIONSTART: { - short x = LOWORD(lParam); - short y = HIWORD(lParam); + if (uMsg == WM_BUTTON1DOWN && AcceptsFocus()) + SetFocus(); - bProcessed = HandleMouseEvent(uMsg, x, y, (WXUINT)wParam); + short nX = LOWORD(wParam); + short nY = HIWORD(wParam); + + // + // Redirect the event to a static control if necessary + // + if (this == GetCapture()) + { + bProcessed = HandleMouseEvent( uMsg + ,nX + ,nY + ,(WXUINT)SHORT2FROMMP(lParam) + ); + } + else + { + wxWindow* pWin = FindWindowForMouseEvent( this + ,&nX + ,&nY + ); + if (!pWin->IsOfStandardClass()) + { + if (uMsg == WM_BUTTON1DOWN && pWin->AcceptsFocus() ) + pWin->SetFocus(); + } + bProcessed = pWin->HandleMouseEvent( uMsg + ,nX + ,nY + ,(WXUINT)SHORT2FROMMP(lParam) + ); + } } break; + case WM_SYSCOMMAND: bProcessed = HandleSysCommand(wParam, lParam); break; @@ -2528,8 +2578,9 @@ MRESULT wxWindowOS2::OS2WindowProc( } else { - bProcessed = OS2OnMeasureItem(nIdCtrl, - (WXMEASUREITEMSTRUCT *)lParam); + return MRFROMLONG(OS2OnMeasureItem( nIdCtrl + ,(WXMEASUREITEMSTRUCT *)lParam + )); } if ( bProcessed ) @@ -2538,10 +2589,13 @@ MRESULT wxWindowOS2::OS2WindowProc( break; case WM_QUERYDLGCODE: - if ( m_lDlgCode ) + if (!IsOfStandardClass()) { - mResult = (MRESULT)m_lDlgCode; - bProcessed = TRUE; + if ( m_lDlgCode ) + { + mResult = (MRESULT)m_lDlgCode; + bProcessed = TRUE; + } } // //else: get the dlg code from the DefWindowProc() @@ -2559,17 +2613,18 @@ MRESULT wxWindowOS2::OS2WindowProc( if (uKeyFlags & KC_KEYUP) { //TODO: check if the cast to WXWORD isn't causing trouble - bProcessed = HandleKeyUp((WXDWORD)wParam, lParam); + bProcessed = HandleKeyUp(wParam, lParam); break; } else // keydown event { + m_bLastKeydownProcessed = FALSE; // // If this has been processed by an event handler, // return 0 now (we've handled it). DON't RETURN // we still need to process further // - HandleKeyDown((WXDWORD)wParam, lParam); + m_bLastKeydownProcessed = HandleKeyDown(wParam, lParam); if (uKeyFlags & KC_VIRTUALKEY) { USHORT uVk = SHORT2FROMMP((MPARAM)lParam); @@ -2577,18 +2632,20 @@ MRESULT wxWindowOS2::OS2WindowProc( // // We consider these message "not interesting" to OnChar // - if (uVk == VK_SHIFT || uVk == VK_CTRL ) - { - bProcessed = TRUE; - break; - } switch(uVk) { - // + case VK_SHIFT: + case VK_CTRL: + case VK_MENU: + case VK_CAPSLOCK: + case VK_NUMLOCK: + case VK_SCRLLOCK: + bProcessed = TRUE; + break; + // Avoid duplicate messages to OnChar for these ASCII keys: they // will be translated by TranslateMessage() and received in WM_CHAR case VK_ESC: - case VK_SPACE: case VK_ENTER: case VK_BACKSPACE: case VK_TAB: @@ -2598,19 +2655,28 @@ MRESULT wxWindowOS2::OS2WindowProc( bProcessed = FALSE; break; - case VK_LEFT: - case VK_RIGHT: - case VK_DOWN: - case VK_UP: default: - bProcessed = HandleChar((WXDWORD)wParam, lParam); + bProcessed = HandleChar(wParam, lParam); } break; } else // WM_CHAR -- Always an ASCII character { - bProcessed = HandleChar((WXDWORD)wParam, lParam, TRUE); - break; + if (m_bLastKeydownProcessed) + { + // + // The key was handled in the EVT_KEY_DOWN and handling + // a key in an EVT_KEY_DOWN handler is meant, by + // design, to prevent EVT_CHARs from happening + // + m_bLastKeydownProcessed = FALSE; + bProcessed = TRUE; + } + else // do generate a CHAR event + { + bProcessed = HandleChar(wParam, lParam, TRUE); + break; + } } } } @@ -2640,6 +2706,157 @@ MRESULT wxWindowOS2::OS2WindowProc( case WM_CONTROL: switch(SHORT2FROMMP(wParam)) { + case BN_PAINT: + { + HWND hWnd = ::WinWindowFromID((HWND)GetHwnd(), SHORT1FROMMP(wParam)); + wxWindowOS2* pWin = wxFindWinFromHandle(hWnd); + + if (!pWin) + { + bProcessed = FALSE; + break; + } + if (pWin->IsKindOf(CLASSINFO(wxBitmapButton))) + { + wxBitmapButton* pBitmapButton = wxDynamicCast(pWin, wxBitmapButton); + + pBitmapButton->OS2OnDraw((WXDRAWITEMSTRUCT *)lParam); + } + return 0; + } + break; + + case BKN_PAGESELECTEDPENDING: + { + PPAGESELECTNOTIFY pPage = (PPAGESELECTNOTIFY)lParam; + + if ((pPage->ulPageIdNew != pPage->ulPageIdCur) && + (pPage->ulPageIdNew > 0L && pPage->ulPageIdCur > 0L)) + { + wxWindowOS2* pWin = wxFindWinFromHandle(pPage->hwndBook); + wxNotebookEvent vEvent( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED + ,(int)SHORT1FROMMP(wParam) + ,(int)pPage->ulPageIdNew + ,(int)pPage->ulPageIdCur + ); + if (!pWin) + { + bProcessed = FALSE; + break; + } + if (pWin->IsKindOf(CLASSINFO(wxNotebook))) + { + wxNotebook* pNotebook = wxDynamicCast(pWin, wxNotebook); + + vEvent.SetEventObject(pWin); + pNotebook->OnSelChange(vEvent); + bProcessed = TRUE; + } + else + bProcessed = FALSE; + } + else + bProcessed = FALSE; + } + break; + + case BN_CLICKED: // Dups as LN_SELECT and CBN_LBSELECT + { + HWND hWnd = ::WinWindowFromID((HWND)GetHwnd(), SHORT1FROMMP(wParam)); + wxWindowOS2* pWin = wxFindWinFromHandle(hWnd); + + if (!pWin) + { + bProcessed = FALSE; + break; + } + // + // Simulate a WM_COMMAND here, as wxWidgets expects all control + // button clicks to generate WM_COMMAND msgs, not WM_CONTROL + // + if (pWin->IsKindOf(CLASSINFO(wxRadioBox))) + { + wxRadioBox* pRadioBox = wxDynamicCast(pWin, wxRadioBox); + + pRadioBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + } + if (pWin->IsKindOf(CLASSINFO(wxRadioButton))) + { + wxRadioButton* pRadioButton = wxDynamicCast(pWin, wxRadioButton); + + pRadioButton->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + } + if (pWin->IsKindOf(CLASSINFO(wxCheckBox))) + { + wxCheckBox* pCheckBox = wxDynamicCast(pWin, wxCheckBox); + + pCheckBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + } + if (pWin->IsKindOf(CLASSINFO(wxListBox))) + { + wxListBox* pListBox = wxDynamicCast(pWin, wxListBox); + + pListBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + if (pListBox->GetWindowStyle() & wxLB_OWNERDRAW) + Refresh(); + } + if (pWin->IsKindOf(CLASSINFO(wxComboBox))) + { + wxComboBox* pComboBox = wxDynamicCast(pWin, wxComboBox); + + pComboBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + } + return 0; + } + break; + + case LN_ENTER: /* dups as CBN_EFCHANGE */ + { + HWND hWnd = HWNDFROMMP(lParam); + wxWindowOS2* pWin = wxFindWinFromHandle(hWnd); + + if (!pWin) + { + bProcessed = FALSE; + break; + } + // + // Simulate a WM_COMMAND here, as wxWidgets expects all control + // button clicks to generate WM_COMMAND msgs, not WM_CONTROL + // + if (pWin->IsKindOf(CLASSINFO(wxListBox))) + { + wxListBox* pListBox = wxDynamicCast(pWin, wxListBox); + + pListBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + if (pListBox->GetWindowStyle() & wxLB_OWNERDRAW) + Refresh(); + + } + if (pWin->IsKindOf(CLASSINFO(wxComboBox))) + { + wxComboBox* pComboBox = wxDynamicCast(pWin, wxComboBox); + + pComboBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam) + ,(WXUINT)SHORT1FROMMP(wParam) + ); + } + return 0; + } + break; + case SPBN_UPARROW: case SPBN_DOWNARROW: case SPBN_CHANGE: @@ -2668,6 +2885,11 @@ MRESULT wxWindowOS2::OS2WindowProc( HWND hWnd = ::WinWindowFromID(GetHWND(), SHORT1FROMMP(wParam)); wxWindowOS2* pChild = wxFindWinFromHandle(hWnd); + if (!pChild) + { + bProcessed = FALSE; + break; + } if (pChild->IsKindOf(CLASSINFO(wxSlider))) bProcessed = OS2OnScroll( wxVERTICAL ,(int)SHORT2FROMMP(wParam) @@ -2715,7 +2937,7 @@ MRESULT wxWindowOS2::OS2WindowProc( if ( bProcessed ) { // we never set focus from here - mResult = FALSE; + mResult = (MRESULT)FALSE; } break; @@ -2746,6 +2968,20 @@ MRESULT wxWindowOS2::OS2WindowProc( mResult = (MRESULT)TRUE; } break; + +#if wxUSE_MENUS_NATIVE + case WM_MENUEND: + if (wxCurrentPopupMenu) + { + if (GetHmenuOf(wxCurrentPopupMenu) == (HWND)lParam) + { + // Break out of msg loop in DoPopupMenu + ::WinPostMsg((HWND)lParam,WM_COMMAND,wParam,0); + } + } + break; +#endif // wxUSE_MENUS_NATIVE + } if (!bProcessed) { @@ -2763,45 +2999,17 @@ MRESULT wxWindowOS2::OS2WindowProc( return mResult; } // end of wxWindowOS2::OS2WindowProc -#ifndef __EMX__ -// clashes with wxDlgProc in toplevel.cpp? -// -// Dialog window proc -// -MRESULT wxDlgProc( - HWND WXUNUSED(hWnd) -, UINT uMsg -, MPARAM WXUNUSED(wParam) -, MPARAM WXUNUSED(lParam)) -{ - if (uMsg == WM_INITDLG) - { - // - // For this message, returning TRUE tells system to set focus to the - // first control in the dialog box - // - return (MRESULT)TRUE; - } - else - { - // - // For all the other ones, FALSE means that we didn't process the - // message - // - return (MRESULT)0; - } -} // end of wxDlgProc -#endif +// ---------------------------------------------------------------------------- +// wxWindow <-> HWND map +// ---------------------------------------------------------------------------- + +wxWinHashTable *wxWinHandleHash = NULL; wxWindow* wxFindWinFromHandle( WXHWND hWnd ) { - wxNode* pNode = wxWinHandleList->Find((long)hWnd); - - if (!pNode) - return NULL; - return (wxWindow *)pNode->Data(); + return (wxWindow *)wxWinHandleHash->Get((long)hWnd); } // end of wxFindWinFromHandle void wxAssociateWinWithHandle( @@ -2829,9 +3037,9 @@ void wxAssociateWinWithHandle( } else if (!pOldWin) { - wxWinHandleList->Append( (long)hWnd - ,pWin - ); + wxWinHandleHash->Put( (long)hWnd + ,(wxWindow *)pWin + ); } } // end of wxAssociateWinWithHandle @@ -2839,7 +3047,7 @@ void wxRemoveHandleAssociation( wxWindowOS2* pWin ) { - wxWinHandleList->DeleteObject(pWin); + wxWinHandleHash->Delete((long)pWin->GetHWND()); } // end of wxRemoveHandleAssociation // @@ -2860,36 +3068,37 @@ bool wxWindowOS2::OS2GetCreateWindowCoords( ) const { bool bNonDefault = FALSE; + static const int DEFAULT_Y = 200; + static const int DEFAULT_H = 250; if (rPos.x == -1) { - // - // If set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can - // just as well set it to CW_USEDEFAULT as well rnX = rnY = CW_USEDEFAULT; } else { rnX = rPos.x; - rnY = rPos.y == -1 ? CW_USEDEFAULT : rPos.y; + rnY = rPos.y == -1 ? DEFAULT_Y : rPos.y; bNonDefault = TRUE; } if (rSize.x == -1) { - // - // As abobe, h is not used at all in this case anyhow - // rnWidth = rnHeight = CW_USEDEFAULT; } else { rnWidth = rSize.x; - rnHeight = rSize.y == -1 ? CW_USEDEFAULT : rSize.y; + rnHeight = rSize.y == -1 ? DEFAULT_H : rSize.y; bNonDefault = TRUE; } return bNonDefault; } // end of wxWindowOS2::OS2GetCreateWindowCoords +WXHWND wxWindowOS2::OS2GetParent() const +{ + return m_parent ? m_parent->GetHWND() : NULL; +} + bool wxWindowOS2::OS2Create( PSZ zClass , const char* zTitle @@ -2907,9 +3116,6 @@ bool wxWindowOS2::OS2Create( int nY = 0L; int nWidth = 0L; int nHeight = 0L; - wxWindow* pParent = GetParent(); - HWND hWnd = NULLHANDLE; - HWND hParent; long lControlId = 0L; wxWindowCreationHook vHook(this); wxString sClassName((wxChar*)zClass); @@ -2922,31 +3128,6 @@ bool wxWindowOS2::OS2Create( ,nHeight ); - if (GetWindowStyleFlag() & wxPOPUP_WINDOW) - hParent = HWND_DESKTOP; - else - { - if ((bIsChild || HasFlag(wxFRAME_TOOL_WINDOW)) && pParent ) - { - // - // This is either a normal child window or a top level window with - // wxFRAME_TOOL_WINDOW style (see below) - // - hParent = GetHwndOf(pParent); - } - else - { - // - // This is either a window for which no parent was specified (not - // much we can do then) or a frame without wxFRAME_TOOL_WINDOW - // style: we should use NULL parent HWND for it or it would be - // always on top of its parent which is not what we usually want - // (in fact, we only want it for frames with the special - // wxFRAME_TOOL_WINDOW as above) - // - hParent = NULL; - } - } if (bIsChild) { lControlId = GetId(); @@ -2960,55 +3141,24 @@ bool wxWindowOS2::OS2Create( // which is the same but without CS_[HV]REDRAW class styles so using it // ensures that the window is not fully repainted on each resize // - if (GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE) + if (!HasFlag(wxFULL_REPAINT_ON_RESIZE)) { sClassName += wxT("NR"); } - - // - // If the window being created is a Frame's Statusbar we need to use - // the actual Frame's size, not its client - // - if (pParent) - { - if ( pParent->IsKindOf(CLASSINFO(wxGenericScrolledWindow)) || - pParent->IsKindOf(CLASSINFO(wxScrolledWindow)) - ) - { - if (IsKindOf(CLASSINFO(wxStatusBar)) && - pParent->IsKindOf(CLASSINFO(wxFrame))) - { - RECTL vRect; - wxFrame* pFrame = wxDynamicCast(pParent, wxFrame); - - ::WinQueryWindowRect((HWND)pFrame->GetFrame(), &vRect); - nY = vRect.yTop - (nY + nHeight); - } - else - nY = pParent->GetSize().y - (nY + nHeight); - } - } - else - { - RECTL vRect; - - ::WinQueryWindowRect(HWND_DESKTOP, &vRect); - nY = vRect.yTop - (nY + nHeight); - } - m_hWnd = (WXHWND)::WinCreateWindow( (HWND)hParent - ,(PSZ)sClassName.c_str() - ,(PSZ)zTitle ? zTitle : "" - ,(ULONG)dwStyle - ,(LONG)0L - ,(LONG)0L - ,(LONG)0L - ,(LONG)0L - ,NULLHANDLE - ,HWND_TOP - ,(ULONG)lControlId - ,pCtlData - ,NULL - ); + m_hWnd = (WXHWND)::WinCreateWindow( (HWND)OS2GetParent() + ,(PSZ)sClassName.c_str() + ,(PSZ)zTitle ? zTitle : "" + ,(ULONG)dwStyle + ,(LONG)0L + ,(LONG)0L + ,(LONG)0L + ,(LONG)0L + ,NULLHANDLE + ,HWND_TOP + ,(ULONG)lControlId + ,pCtlData + ,NULL + ); if (!m_hWnd) { vError = ::WinGetLastError(wxGetInstance()); @@ -3017,6 +3167,22 @@ bool wxWindowOS2::OS2Create( } SubclassWin(m_hWnd); SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT)); + + m_backgroundColour.Set(wxString("GREY")); + + LONG lColor = (LONG)m_backgroundColour.GetPixel(); + + if (!::WinSetPresParam( m_hWnd + ,PP_BACKGROUNDCOLOR + ,sizeof(LONG) + ,(PVOID)&lColor + )) + { + vError = ::WinGetLastError(vHabmain); + sError = wxPMErrorToStr(vError); + wxLogError("Error creating frame. Error: %s\n", sError.c_str()); + return FALSE; + } SetSize( nX ,nY ,nWidth @@ -3048,7 +3214,7 @@ bool wxWindowOS2::HandleCreate( bool wxWindowOS2::HandleDestroy() { wxWindowDestroyEvent vEvent((wxWindow*)this); - + vEvent.SetId(GetId()); (void)GetEventHandler()->ProcessEvent(vEvent); // @@ -3057,7 +3223,6 @@ bool wxWindowOS2::HandleDestroy() #if wxUSE_DRAG_AND_DROP if (m_dropTarget != NULL) { - m_dropTarget->Revoke(m_hWnd); delete m_dropTarget; m_dropTarget = NULL; } @@ -3129,7 +3294,7 @@ bool wxWindowOS2::HandleSetFocus( } // end of wxWindowOS2::HandleSetFocus bool wxWindowOS2::HandleKillFocus( - WXHWND WXUNUSED(hWnd) + WXHWND hWnd ) { #if wxUSE_CARET @@ -3142,11 +3307,38 @@ bool wxWindowOS2::HandleKillFocus( } #endif // wxUSE_CARET +#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. + // + wxTextCtrl* pCtrl = wxDynamicCastThis(wxTextCtrl); + + if (pCtrl) + { + return FALSE; + } +#endif + + // + // Don't send the event when in the process of being deleted. This can + // only cause problems if the event handler tries to access the object. + // + if ( m_isBeingDeleted ) + { + return FALSE; + } + wxFocusEvent vEvent( wxEVT_KILL_FOCUS ,m_windowId ); vEvent.SetEventObject(this); + + // + // wxFindWinFromHandle() may return NULL, it is ok + // + vEvent.SetWindow(wxFindWinFromHandle(hWnd)); return GetEventHandler()->ProcessEvent(vEvent); } // end of wxWindowOS2::HandleKillFocus @@ -3161,7 +3353,7 @@ bool wxWindowOS2::HandleShow( { wxShowEvent vEvent(GetId(), bShow); - vEvent.m_eventObject = this; + vEvent.SetEventObject(this); return GetEventHandler()->ProcessEvent(vEvent); } // end of wxWindowOS2::HandleShow @@ -3171,7 +3363,7 @@ bool wxWindowOS2::HandleInitDialog( { wxInitDialogEvent vEvent(GetId()); - vEvent.m_eventObject = this; + vEvent.SetEventObject(this); return GetEventHandler()->ProcessEvent(vEvent); } // end of wxWindowOS2::HandleInitDialog @@ -3227,7 +3419,7 @@ bool wxWindowOS2::OS2OnDrawItem( ); vDc.SetHPS(pMeasureStruct->hps); // - // Load the wxWindows Pallete and set to RGB mode + // Load the wxWidgets Pallete and set to RGB mode // if (!::GpiCreateLogColorTable( pMeasureStruct->hps ,0L @@ -3239,7 +3431,7 @@ bool wxWindowOS2::OS2OnDrawItem( { vError = ::WinGetLastError(vHabmain); sError = wxPMErrorToStr(vError); - wxLogError("Unable to set current color table. Error: %s\n", sError); + wxLogError("Unable to set current color table. Error: %s\n", sError.c_str()); } // // Set the color table to RGB mode @@ -3254,7 +3446,7 @@ bool wxWindowOS2::OS2OnDrawItem( { vError = ::WinGetLastError(vHabmain); sError = wxPMErrorToStr(vError); - wxLogError("Unable to set current color table. Error: %s\n", sError); + wxLogError("Unable to set current color table. Error: %s\n", sError.c_str()); } wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE ); @@ -3355,7 +3547,7 @@ bool wxWindowOS2::OS2OnDrawItem( return FALSE; } // end of wxWindowOS2::OS2OnDrawItem -bool wxWindowOS2::OS2OnMeasureItem( +long wxWindowOS2::OS2OnMeasureItem( int lId , WXMEASUREITEMSTRUCT* pItemStruct ) @@ -3381,20 +3573,26 @@ bool wxWindowOS2::OS2OnMeasureItem( ,&nHeight )) { + MRESULT mRc; + pMeasureStruct->rclItem.xRight = nWidth; pMeasureStruct->rclItem.xLeft = 0L; pMeasureStruct->rclItem.yTop = nHeight; pMeasureStruct->rclItem.yBottom = 0L; - return TRUE; + mRc = MRFROM2SHORT(nHeight, nWidth); + return LONGFROMMR(mRc); } - return FALSE; + return 0L; } } wxWindow* pItem = FindItem(lId); if (pItem && pItem->IsKindOf(CLASSINFO(wxControl))) { - return ((wxControl *)pItem)->OS2OnMeasure(pItemStruct); + OWNERITEM vItem; + + vItem.idItem = (LONG)pItemStruct; + return ((wxControl *)pItem)->OS2OnMeasure((WXMEASUREITEMSTRUCT*)&vItem); } #else lId = lId; @@ -3457,23 +3655,23 @@ void wxWindowOS2::OnSysColourChanged( wxSysColourChangedEvent& rEvent ) { - wxNode* pNode = GetChildren().First(); + wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); - while (pNode) + while (node) { // // Only propagate to non-top-level windows // - wxWindow* pWin = (wxWindow *)pNode->Data(); + wxWindow* pWin = (wxWindow *)node->GetData(); if (pWin->GetParent()) { wxSysColourChangedEvent vEvent; - rEvent.m_eventObject = pWin; + rEvent.SetEventObject(pWin); pWin->GetEventHandler()->ProcessEvent(vEvent); } - pNode = pNode->Next(); + node = node->GetNext(); } } // end of wxWindowOS2::OnSysColourChanged @@ -3481,12 +3679,26 @@ void wxWindowOS2::OnSysColourChanged( // painting // --------------------------------------------------------------------------- +void wxWindow::OnPaint ( + wxPaintEvent& rEvent +) +{ + HDC hDC = (HDC)wxPaintDC::FindDCInCache((wxWindow*) rEvent.GetEventObject()); + + if (hDC != 0) + { + OS2DefWindowProc( (WXUINT)WM_PAINT + ,(WXWPARAM)hDC + ,(WXLPARAM)0 + ); + } +} // end of wxWindow::OnPaint + bool wxWindowOS2::HandlePaint() { HRGN hRgn; wxPaintEvent vEvent(m_windowId); HPS hPS; - RECTL vRect; bool bProcessed; // Create empty region @@ -3500,12 +3712,157 @@ bool wxWindowOS2::HandlePaint() return FALSE; } + // Get all the rectangles from the region, convert the individual + // rectangles to "the other" coordinate system and reassemble a + // region from the rectangles, to be feed into m_updateRegion. + // + // FIXME: This is a bad hack since OS/2 API specifies that rectangles + // passed into GpiSetRegion must not have Bottom > Top, + // however, at first sight, it _seems_ to work nonetheless. + // + RGNRECT vRgnData; + PRECTL pUpdateRects = NULL; + vRgnData.ulDirection = RECTDIR_LFRT_TOPBOT; + if (::GpiQueryRegionRects( hPS // Pres space + ,hRgn // Handle of region to query + ,NULL // Return all RECTs + ,&vRgnData // Will contain number or RECTs in region + ,NULL // NULL to return number of RECTs + )) + { + pUpdateRects = new RECTL[vRgnData.crcReturned]; + vRgnData.crc = vRgnData.crcReturned; + vRgnData.ircStart = 1; + if (::GpiQueryRegionRects( hPS // Pres space of source + ,hRgn // Handle of source region + ,NULL // Return all RECTs + ,&vRgnData // Operations set to return rects + ,pUpdateRects // Will contain the actual RECTS + )) + { + int height; + RECT vRect; + ::WinQueryWindowRect(GetHwnd(), &vRect); + height = vRect.yTop; + + for(size_t i = 0; i < vRgnData.crc; i++) + { + int rectHeight; + rectHeight = pUpdateRects[i].yTop - pUpdateRects[i].yBottom; + pUpdateRects[i].yTop = height - pUpdateRects[i].yTop; + pUpdateRects[i].yBottom = pUpdateRects[i].yTop + rectHeight; + } + ::GpiSetRegion(hPS, hRgn, vRgnData.crc, pUpdateRects); + delete [] pUpdateRects; + } + } + m_updateRegion = wxRegion(hRgn, hPS); vEvent.SetEventObject(this); bProcessed = GetEventHandler()->ProcessEvent(vEvent); - return GetEventHandler()->ProcessEvent(vEvent); //bProcessed; + if (!bProcessed && + IsKindOf(CLASSINFO(wxPanel)) && + GetChildren().GetCount() == 0 + ) + { + // + // OS/2 needs to process this right here, not by the default proc + // Window's default proc correctly paints everything, OS/2 does not. + // For decorative panels that typically have no children, we draw + // borders. + // + HPS hPS; + RECTL vRect; + + 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 + ); + if (::WinIsWindowVisible(GetHWND())) + ::WinFillRect(hPS, &vRect, GetBackgroundColour().GetPixel()); + if (m_dwExStyle) + { + LINEBUNDLE vLineBundle; + + vLineBundle.lColor = 0x00000000; // Black + vLineBundle.usMixMode = FM_OVERPAINT; + vLineBundle.fxWidth = 1; + vLineBundle.lGeomWidth = 1; + vLineBundle.usType = LINETYPE_SOLID; + vLineBundle.usEnd = 0; + vLineBundle.usJoin = 0; + ::GpiSetAttrs( hPS + ,PRIM_LINE + ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE + ,0L + ,&vLineBundle + ); + ::WinQueryWindowRect(GetHwnd(), &vRect); + wxDrawBorder( hPS + ,vRect + ,m_dwExStyle + ); + } + } + ::WinEndPaint(hPS); + bProcessed = TRUE; + } + else if (!bProcessed && + IsKindOf(CLASSINFO(wxPanel)) + ) + { + // + // Panel with children, usually fills a frame client so no borders. + // + HPS hPS; + RECTL vRect; + + 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 + ); + + if (::WinIsWindowVisible(GetHWND())) + ::WinFillRect(hPS, &vRect, GetBackgroundColour().GetPixel()); + } + ::WinEndPaint(hPS); + bProcessed = TRUE; + } + return bProcessed; } // end of wxWindowOS2::HandlePaint bool wxWindowOS2::HandleEraseBkgnd( @@ -3596,7 +3953,6 @@ bool wxWindowOS2::HandleGetMinMaxInfo( PSWP pSwp ) { - bool bRc = FALSE; POINTL vPoint; switch(pSwp->fl) @@ -3681,15 +4037,23 @@ void wxWindowOS2::InitMouseEvent( , WXUINT uFlags ) { + int nHeight; + DoGetSize(0, &nHeight); rEvent.m_x = nX; - rEvent.m_y = nY; - rEvent.m_shiftDown = ((uFlags & VK_SHIFT) != 0); - rEvent.m_controlDown = ((uFlags & VK_CTRL) != 0); - rEvent.m_leftDown = ((uFlags & VK_BUTTON1) != 0); - rEvent.m_middleDown = ((uFlags & VK_BUTTON3) != 0); - rEvent.m_rightDown = ((uFlags & VK_BUTTON2) != 0); + // Convert to wxWidgets standard coordinate system! + rEvent.m_y = nHeight - nY; + rEvent.m_shiftDown = ((uFlags & KC_SHIFT) != 0); + rEvent.m_controlDown = ((uFlags & KC_CTRL) != 0); + rEvent.m_altDown = ((uFlags & KC_ALT) != 0); + rEvent.m_leftDown = (::WinGetKeyState(HWND_DESKTOP, VK_BUTTON1) & + 0x8000) != 0; + rEvent.m_middleDown = (::WinGetKeyState(HWND_DESKTOP, VK_BUTTON3) & + 0x8000) != 0; + rEvent.m_rightDown = (::WinGetKeyState(HWND_DESKTOP, VK_BUTTON2) & + 0x8000) != 0; rEvent.SetTimestamp(s_currentMsg.time); - rEvent.m_eventObject = this; + rEvent.SetEventObject(this); + rEvent.SetId(GetId()); #if wxUSE_MOUSEEVENT_HACK m_lastMouseX = nX; @@ -3705,9 +4069,11 @@ bool wxWindowOS2::HandleMouseEvent( , WXUINT uFlags ) { + bool bProcessed = FALSE; + // // The mouse events take consecutive IDs from WM_MOUSEFIRST to - // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST + // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST // from the message id and take the value in the table to get wxWin event // id // @@ -3725,15 +4091,30 @@ bool wxWindowOS2::HandleMouseEvent( wxEVT_MIDDLE_DCLICK }; - wxMouseEvent vEvent(eventsMouse[uMsg - WM_MOUSEMOVE]); + // Bounds check + if ((uMsg >= WM_MOUSEMOVE) && (uMsg <= WM_BUTTON3DBLCLK)) + { + wxMouseEvent vEvent(eventsMouse[uMsg - WM_MOUSEMOVE]); + + InitMouseEvent( vEvent + ,nX + ,nY + ,uFlags + ); - InitMouseEvent( vEvent - ,nX - ,nY - ,uFlags - ); + bProcessed = GetEventHandler()->ProcessEvent(vEvent); + if (!bProcessed) + { + HPOINTER hCursor = (HPOINTER)GetCursor().GetHCURSOR(); - return GetEventHandler()->ProcessEvent(vEvent); + if (hCursor != NULLHANDLE) + { + ::WinSetPointer(HWND_DESKTOP, hCursor); + bProcessed = TRUE; + } + } + } + return bProcessed; } // end of wxWindowOS2::HandleMouseEvent bool wxWindowOS2::HandleMouseMove( @@ -3778,6 +4159,7 @@ wxKeyEvent wxWindowOS2::CreateKeyEvent( wxEventType eType , int nId , WXLPARAM lParam +, WXWPARAM wParam ) const { wxKeyEvent vEvent(eType); @@ -3787,8 +4169,10 @@ wxKeyEvent wxWindowOS2::CreateKeyEvent( vEvent.m_controlDown = IsCtrlDown(); vEvent.m_altDown = (HIWORD(lParam) & KC_ALT) == KC_ALT; - vEvent.m_eventObject = (wxWindow *)this; // const_cast + vEvent.SetEventObject((wxWindow *)this); // const_cast vEvent.m_keyCode = nId; + vEvent.m_rawCode = (wxUint32)wParam; + vEvent.m_rawFlags = (wxUint32)lParam; vEvent.SetTimestamp(s_currentMsg.time); // @@ -3816,7 +4200,7 @@ wxKeyEvent wxWindowOS2::CreateKeyEvent( // WM_KEYDOWN one // bool wxWindowOS2::HandleChar( - WXDWORD wParam + WXWPARAM wParam , WXLPARAM lParam , bool isASCII ) @@ -3824,12 +4208,24 @@ bool wxWindowOS2::HandleChar( bool bCtrlDown = FALSE; int vId; + if (m_bLastKeydownProcessed) + { + // + // The key was handled in the EVT_KEY_DOWN. Handling a key in an + // EVT_KEY_DOWN handler is meant, by design, to prevent EVT_CHARs + // from happening, so just bail out at this point. + // + m_bLastKeydownProcessed = FALSE; + return TRUE; + } if (isASCII) { // - // If 1 -> 26, translate to CTRL plus a letter. + // If 1 -> 26, translate to either special keycode or just set + // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and + // ControlDown() == TRUE. // - vId = wParam; + vId = SHORT1FROMMP(lParam); if ((vId > 0) && (vId < 27)) { switch (vId) @@ -3848,57 +4244,50 @@ bool wxWindowOS2::HandleChar( default: bCtrlDown = TRUE; - vId = vId + 96; + break; } } } - else if ( (vId = wxCharCodeOS2ToWX(wParam)) == 0) + else // we're called from WM_KEYDOWN { - // - // It's ASCII and will be processed here only when called from - // WM_CHAR (i.e. when isASCII = TRUE), don't process it now - // - vId = -1; + vId = wxCharCodeOS2ToWX((int)SHORT2FROMMP(lParam)); + if (vId == 0) + return FALSE; } - if (vId != -1) - { - wxKeyEvent vEvent(CreateKeyEvent( wxEVT_CHAR + wxKeyEvent vEvent(CreateKeyEvent( wxEVT_CHAR ,vId ,lParam )); - if (bCtrlDown) - { - vEvent.m_controlDown = TRUE; - } - - if (GetEventHandler()->ProcessEvent(vEvent)) - return TRUE; + if (bCtrlDown) + { + vEvent.m_controlDown = TRUE; } - return FALSE; + return (GetEventHandler()->ProcessEvent(vEvent)); } bool wxWindowOS2::HandleKeyDown( - WXWORD wParam + WXWPARAM wParam , WXLPARAM lParam ) { - int nId = wxCharCodeOS2ToWX(wParam); + int nId = wxCharCodeOS2ToWX((int)SHORT2FROMMP(lParam)); if (!nId) { // // Normal ASCII char // - nId = wParam; + nId = SHORT1FROMMP(lParam); } if (nId != -1) { wxKeyEvent vEvent(CreateKeyEvent( wxEVT_KEY_DOWN ,nId - ,lParam + ,(MPARAM)lParam + ,(MPARAM)wParam )); if (GetEventHandler()->ProcessEvent(vEvent)) @@ -3910,18 +4299,18 @@ bool wxWindowOS2::HandleKeyDown( } // end of wxWindowOS2::HandleKeyDown bool wxWindowOS2::HandleKeyUp( - WXDWORD wParam + WXWPARAM wParam , WXLPARAM lParam ) { - int nId = wxCharCodeOS2ToWX(wParam); + int nId = wxCharCodeOS2ToWX((int)SHORT2FROMMP(lParam)); if (!nId) { // // Normal ASCII char // - nId = wParam; + nId = (int)wParam; } if (nId != -1) @@ -3929,6 +4318,7 @@ bool wxWindowOS2::HandleKeyUp( wxKeyEvent vEvent(CreateKeyEvent( wxEVT_KEY_UP ,nId ,lParam + ,wParam )); if (GetEventHandler()->ProcessEvent(vEvent)) @@ -3968,32 +4358,32 @@ bool wxWindowOS2::OS2OnScroll( vEvent.SetPosition(wPos); vEvent.SetOrientation(nOrientation); - vEvent.m_eventObject = this; + vEvent.SetEventObject(this); switch (wParam) { case SB_LINEUP: - vEvent.m_eventType = wxEVT_SCROLLWIN_LINEUP; + vEvent.SetEventType(wxEVT_SCROLLWIN_LINEUP); break; case SB_LINEDOWN: - vEvent.m_eventType = wxEVT_SCROLLWIN_LINEDOWN; + vEvent.SetEventType(wxEVT_SCROLLWIN_LINEDOWN); break; case SB_PAGEUP: - vEvent.m_eventType = wxEVT_SCROLLWIN_PAGEUP; + vEvent.SetEventType(wxEVT_SCROLLWIN_PAGEUP); break; case SB_PAGEDOWN: - vEvent.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN; + vEvent.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN); break; case SB_SLIDERPOSITION: - vEvent.m_eventType = wxEVT_SCROLLWIN_THUMBRELEASE; + vEvent.SetEventType(wxEVT_SCROLLWIN_THUMBRELEASE); break; case SB_SLIDERTRACK: - vEvent.m_eventType = wxEVT_SCROLLWIN_THUMBTRACK; + vEvent.SetEventType(wxEVT_SCROLLWIN_THUMBTRACK); break; default: @@ -4006,69 +4396,81 @@ void wxWindowOS2::MoveChildren( int nDiff ) { - SWP vSwp; - - for (wxWindowList::Node* pNode = GetChildren().GetFirst(); - pNode; - pNode = pNode->GetNext()) + // + // We want to handle top levels ourself, manually + // + if (!IsTopLevel() && GetAutoLayout()) + { + Layout(); + } + else { - wxWindow* pWin = pNode->GetData(); + SWP vSwp; - ::WinQueryWindowPos( GetHwndOf(pWin) - ,&vSwp - ); - if (pWin->IsKindOf(CLASSINFO(wxControl))) + for (wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); + node; + node = node->GetNext()) { - wxControl* pCtrl; + wxWindow* pWin = node->GetData(); - // - // Must deal with controls that have margins like ENTRYFIELD. The SWP - // struct of such a control will have and origin offset from its intended - // position by the width of the margins. - // - pCtrl = wxDynamicCast(pWin, wxControl); - vSwp.y -= pCtrl->GetYComp(); - vSwp.x -= pCtrl->GetXComp(); - } - ::WinSetWindowPos( GetHwndOf(pWin) - ,HWND_TOP - ,vSwp.x - ,vSwp.y - nDiff - ,vSwp.cx - ,vSwp.cy - ,SWP_MOVE - ); - if (pWin->IsKindOf(CLASSINFO(wxRadioBox))) - { - wxRadioBox* pRadioBox; - - pRadioBox = wxDynamicCast(pWin, wxRadioBox); - pRadioBox->AdjustButtons( (int)vSwp.x - ,(int)vSwp.y - nDiff - ,(int)vSwp.cx - ,(int)vSwp.cy - ,pRadioBox->GetSizeFlags() - ); - } - if (pWin->IsKindOf(CLASSINFO(wxSlider))) - { - wxSlider* pSlider; - - pSlider = wxDynamicCast(pWin, wxSlider); - pSlider->AdjustSubControls( (int)vSwp.x - ,(int)vSwp.y - nDiff - ,(int)vSwp.cx - ,(int)vSwp.cy - ,(int)pSlider->GetSizeFlags() - ); + ::WinQueryWindowPos( GetHwndOf(pWin) + ,&vSwp + ); + if (pWin->IsKindOf(CLASSINFO(wxControl))) + { + wxControl* pCtrl; + + // + // Must deal with controls that have margins like ENTRYFIELD. The SWP + // struct of such a control will have and origin offset from its intended + // position by the width of the margins. + // + pCtrl = wxDynamicCast(pWin, wxControl); + vSwp.y -= pCtrl->GetYComp(); + vSwp.x -= pCtrl->GetXComp(); + } + ::WinSetWindowPos( GetHwndOf(pWin) + ,HWND_TOP + ,vSwp.x + ,vSwp.y - nDiff + ,vSwp.cx + ,vSwp.cy + ,SWP_MOVE + ); + ::WinQueryWindowPos(GetHwndOf(pWin), pWin->GetSwp()); + if (pWin->IsKindOf(CLASSINFO(wxRadioBox))) + { + wxRadioBox* pRadioBox; + + pRadioBox = wxDynamicCast(pWin, wxRadioBox); + pRadioBox->AdjustButtons( (int)vSwp.x + ,(int)vSwp.y - nDiff + ,(int)vSwp.cx + ,(int)vSwp.cy + ,pRadioBox->GetSizeFlags() + ); + } + if (pWin->IsKindOf(CLASSINFO(wxSlider))) + { + wxSlider* pSlider; + + pSlider = wxDynamicCast(pWin, wxSlider); + pSlider->AdjustSubControls( (int)vSwp.x + ,(int)vSwp.y - nDiff + ,(int)vSwp.cx + ,(int)vSwp.cy + ,(int)pSlider->GetSizeFlags() + ); + } } } + Refresh(); } // end of wxWindowOS2::MoveChildren // // Getting the Y position for a window, like a control, is a real // pain. There are three sitatuions we must deal with in determining -// the OS2 to wxWindows Y coordinate. +// the OS2 to wxWidgets Y coordinate. // // 1) The controls are created in a dialog. // This is the easiest since a dialog is created with its original @@ -4082,6 +4484,8 @@ void wxWindowOS2::MoveChildren( // // 3) The controls are children of a panel, which in turn is a child of // a frame. +// The panel may be one of many, in which case the same treatment +// as 1 applies. It may be the only child, though. // This is the nastiest case. A panel is created as the only child of // the frame and as such, when a frame has only one child, the child is // expanded to fit the entire client area of the frame. Because the @@ -4098,8 +4502,6 @@ int wxWindowOS2::GetOS2ParentHeight( wxWindowOS2* pParent ) { - wxWindowOS2* pGrandParent = NULL; - // // Case 1 // @@ -4118,46 +4520,39 @@ int wxWindowOS2::GetOS2ParentHeight( IsKindOf(CLASSINFO(wxMenuBar)) || IsKindOf(CLASSINFO(wxToolBar)) ) - return(pParent->GetSize().y); + { + if (IsKindOf(CLASSINFO(wxToolBar))) + { + wxFrame* pFrame = wxDynamicCast(GetParent(), wxFrame); + + if (pFrame->GetToolBar() == this) + return(pParent->GetSize().y); + else + return(pParent->GetClientSize().y); + } + else + return(pParent->GetSize().y); + } else return(pParent->GetClientSize().y); } - // - // Case 3 -- this is for any window that is the sole child of a Frame. - // The grandparent must exist and it must be of type CFrame - // and it's height must be different. Otherwise the standard - // applies. + // Case -- this is for any window that is the sole child of a Frame. + // The grandparent must exist and it must be of type CFrame + // and it's height must be different. Otherwise the standard + // applies. // else { - pGrandParent = pParent->GetParent(); - if (pGrandParent && - pGrandParent->IsKindOf(CLASSINFO(wxFrame)) && - pGrandParent->GetClientSize().y != pParent->GetSize().y - ) - { - int nParentHeight = 0L; - int nStatusBarHeight = 0L; - wxFrame* pFrame = wxDynamicCast(pGrandParent, wxFrame); - wxStatusBar* pStatbar = pFrame->GetStatusBar(); - - nParentHeight = pGrandParent->GetClientSize().y; - if (pStatbar) - nStatusBarHeight = pStatbar->GetSize().y; - nParentHeight -= nStatusBarHeight; - return(nParentHeight); - } - else - // - // Panel is a child of some other kind of window so we'll - // just use it's original size - // - return(pParent->GetClientSize().y); + return(pParent->GetClientSize().y); } return(0L); } // end of wxWindowOS2::GetOS2ParentHeight +// +// OS/2 needs a lot extra manipulation to deal with layouts +// for canvas windows, particularly scrolled ones. +// wxWindowCreationHook::wxWindowCreationHook( wxWindow* pWinBeingCreated ) @@ -4235,6 +4630,7 @@ int wxCharCodeOS2ToWX( case VK_PRINTSCRN: nId = WXK_PRINT; break; case VK_INSERT: nId = WXK_INSERT; break; case VK_DELETE: nId = WXK_DELETE; break; + case VK_CAPSLOCK: nId = WXK_CAPITAL; break; case VK_F1: nId = WXK_F1; break; case VK_F2: nId = WXK_F2; break; case VK_F3: nId = WXK_F3; break; @@ -4259,6 +4655,17 @@ int wxCharCodeOS2ToWX( case VK_F22: nId = WXK_F22; break; case VK_F23: nId = WXK_F23; break; case VK_F24: nId = WXK_F24; break; + case VK_OEM_1: nId = ';'; break; + case VK_OEM_PLUS: nId = '+'; break; + case VK_OEM_COMMA: nId = ','; break; + case VK_OEM_MINUS: nId = '-'; break; + case VK_OEM_PERIOD: nId = '.'; break; + case VK_OEM_2: nId = '/'; break; + case VK_OEM_3: nId = '~'; break; + case VK_OEM_4: nId = '['; break; + case VK_OEM_5: nId = '\\'; break; + case VK_OEM_6: nId = ']'; break; + case VK_OEM_7: nId = '\''; break; case VK_NUMLOCK: nId = WXK_NUMLOCK; break; case VK_SCRLLOCK: nId = WXK_SCROLL; break; default: @@ -4575,7 +4982,7 @@ const char* wxGetMessageName( // Beginning of user defined messages case 0x1000: return "WM_USER"; - // wxWindows user defined types + // wxWidgets user defined types // listview // case 0x1000 + 0: return "LVM_GETBKCOLOR"; @@ -4879,3 +5286,106 @@ wxPoint wxGetMousePosition() return wxPoint(vPt.x, vPt.y); } +wxWindowOS2* FindWindowForMouseEvent( + wxWindow* pWin +, short* pnX +, short* pnY +) +{ + HWND hWnd = GetHwndOf(pWin); + HWND hWndUnderMouse; + POINTL vPoint; + BOOL rcEnabled = FALSE; + BOOL rcVisible = FALSE; + + ::WinQueryPointerPos(HWND_DESKTOP, &vPoint); + hWndUnderMouse = ::WinWindowFromPoint(HWND_DESKTOP, &vPoint, TRUE); + if (hWndUnderMouse != HWND_DESKTOP) + { + wxWindow* pWinUnderMouse = wxFindWinFromHandle((WXHWND)hWndUnderMouse); + + if (pWinUnderMouse) + { + wxWindowList::compatibility_iterator current = pWinUnderMouse->GetChildren().GetFirst(); + wxWindow* pGrandChild = NULL; + RECTL vRect; + POINTL vPoint2; + + ::WinMapWindowPoints(HWND_DESKTOP, hWndUnderMouse, &vPoint, 1); + // + // Find a child window mouse might be under + // + while (current) + { + wxWindow* pChild = current->GetData(); + + vPoint2.x = vPoint.x; + vPoint2.y = vPoint.y; + ::WinMapWindowPoints(hWndUnderMouse, pChild->GetHWND(), &vPoint2, 1); + ::WinQueryWindowRect(pChild->GetHWND(), &vRect); + if (::WinPtInRect(vHabmain, &vRect, &vPoint2)) + { + if (pChild->IsTopLevel()) + { + POINTL vPoint3; + wxWindowList::compatibility_iterator current2 =pChild->GetChildren().GetFirst(); + + while (current2) + { + wxWindow* pGrandChild = current2->GetData(); + + vPoint3.x = vPoint2.x; + vPoint3.y = vPoint2.y; + ::WinMapWindowPoints( pChild->GetHWND() + ,pGrandChild->GetHWND() + ,&vPoint3 + ,1 + ); + ::WinQueryWindowRect(pGrandChild->GetHWND(), &vRect); + if (::WinPtInRect(vHabmain, &vRect, &vPoint3)) + { + hWndUnderMouse = GetHwndOf(pGrandChild); + pWinUnderMouse = pGrandChild; + break; + } + current2 = current2->GetNext(); + } + if (pGrandChild) + break; + } + hWndUnderMouse = GetHwndOf(pChild); + pWinUnderMouse = pChild; + rcVisible = ::WinIsWindowVisible(hWndUnderMouse); + rcEnabled = ::WinIsWindowEnabled(hWndUnderMouse); + if (rcVisible && rcEnabled) + break; + } + current = current->GetNext(); + } + } + } + rcVisible = ::WinIsWindowVisible(hWndUnderMouse); + rcEnabled = ::WinIsWindowEnabled(hWndUnderMouse); + + + // + // Check that we have a child window which is susceptible to receive mouse + // events: for this it must be shown and enabled + // + if ( hWndUnderMouse && + hWndUnderMouse != hWnd && + rcVisible && rcEnabled) + { + wxWindow* pWinUnderMouse = wxFindWinFromHandle((WXHWND)hWndUnderMouse); + + if (pWinUnderMouse) + { + // + // Translate the mouse coords to the other window coords + // + pWin = pWinUnderMouse; + } + } + return pWin; +} // end of FindWindowForMouseEvent +