void wxCheckBox::SetLabel( const wxString& rsLabel ) { wxString sLabel=::wxPMTextToLabel(rsLabel); ::WinSetWindowText(GetHwnd(), (PSZ)sLabel.c_str()); } // end of wxCheckBox::SetLabel
bool wxGauge::Create( wxWindowOS2* pParent, wxWindowID vId, int nRange, const wxPoint& rPos, const wxSize& rSize, long lStyle, const wxValidator& rValidator, const wxString& rsName ) { int nX = rPos.x; int nY = rPos.y; int nWidth = rSize.x; int nHeight = rSize.y; long lMsStyle = 0L; SWP vSwp; SetName(rsName); #if wxUSE_VALIDATORS SetValidator(rValidator); #endif if (pParent) pParent->AddChild(this); m_backgroundColour.Set(wxString(wxT("LIGHT GREY"))); m_foregroundColour.Set(wxString(wxT("NAVY"))); m_nRangeMax = nRange; m_nGaugePos = 0; m_windowStyle = lStyle; if (vId == wxID_ANY) m_windowId = (int)NewControlId(); else m_windowId = vId; if (m_windowStyle & wxCLIP_SIBLINGS ) lMsStyle |= WS_CLIPSIBLINGS; // // OS/2 will use an edit control for this, since there is not a native gauge // Other choices include using an armless slider but they are more difficult // to control and manipulate // lMsStyle = WS_VISIBLE | ES_MARGIN | ES_LEFT | ES_READONLY; if (m_windowStyle & wxCLIP_SIBLINGS) lMsStyle |= WS_CLIPSIBLINGS; m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle ,WC_ENTRYFIELD // Window class ,(PSZ)NULL // Initial Text ,(ULONG)lMsStyle // Style flags ,0L, 0L, 0L, 0L // Origin -- 0 size ,(HWND)GetHwndOf(pParent) // owner window handle (same as parent ,HWND_TOP // initial z position ,(HMENU)m_windowId // Window identifier ,NULL // Slider control data ,NULL // no Presentation parameters ); wxAssociateWinWithHandle( m_hWnd ,(wxWindowOS2*)this ); ::WinSetWindowULong(GetHwnd(), QWL_USER, (LONG)this); fnWndProcGauge = (WXFARPROC)::WinSubclassWindow(m_hWnd, (PFNWP)wxGaugeWndProc); ::WinQueryWindowPos(m_hWnd, &vSwp); SetXComp(vSwp.x); SetYComp(vSwp.y); wxFont* pTextFont = new wxFont( 10 ,wxMODERN ,wxNORMAL ,wxNORMAL ); SetFont(*pTextFont); if (nWidth == -1L) nWidth = 50L; if (nHeight == -1L) nHeight = 28L; SetSize( nX ,nY ,nWidth ,nHeight ); m_nWidth = nWidth; // Save for GetBestSize m_nHeight = nHeight; ::WinShowWindow((HWND)GetHWND(), TRUE); delete pTextFont; return true; } // end of wxGauge::Create
void wxFrame::Raise() { ::SetForegroundWindow(GetHwnd()); }
// --------------------------------------------------------------------------- // our private (non virtual) message handlers // --------------------------------------------------------------------------- bool wxFrame::HandlePaint() { RECTL vRect; if (::WinQueryUpdateRect(GetHWND(), &vRect)) { if (m_bIconized) { // // Icons in PM are the same as "pointers" // const wxIcon& vIcon = GetIcon(); HPOINTER hIcon; if (vIcon.IsOk()) hIcon = (HPOINTER)::WinSendMsg(m_hFrame, WM_QUERYICON, 0L, 0L); else hIcon = (HPOINTER)m_hDefaultIcon; // // Hold a pointer to the dc so long as the OnPaint() message // is being processed // RECTL vRect2; HPS hPs = ::WinBeginPaint(GetHwnd(), NULLHANDLE, &vRect2); // // Erase background before painting or we get white background // OS2DefWindowProc(WM_ERASEBACKGROUND, (MPARAM)hPs, (MPARAM)&vRect2); if (hIcon) { RECTL vRect3; ::WinQueryWindowRect(GetHwnd(), &vRect3); static const int nIconWidth = 32; static const int nIconHeight = 32; int nIconX = (int)((vRect3.xRight - nIconWidth)/2); int nIconY = (int)((vRect3.yBottom + nIconHeight)/2); ::WinDrawPointer(hPs, nIconX, nIconY, hIcon, DP_NORMAL); } ::WinEndPaint(hPs); } else { if (!wxWindow::HandlePaint()) { 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 ); ::WinFillRect( hPS ,&vRect ,GetBackgroundColour().GetPixel() ); ::WinEndPaint(hPS); } } } } return true; } // end of wxFrame::HandlePaint
wxGLCanvas::~wxGLCanvas() { ::ReleaseDC(GetHwnd(), m_hDC); }
// Windows-only at present. Also, you must use the wxNB_FIXEDWIDTH // style. void wxNotebook::SetTabSize(const wxSize& sz) { ::SendMessage(GetHwnd(), TCM_SETITEMSIZE, 0, MAKELPARAM(sz.x, sz.y)); }
void wxNotebook::OnSize(wxSizeEvent& event) { if ( GetPageCount() == 0 ) { // Prevents droppings on resize, but does cause some flicker // when there are no pages. Refresh(); event.Skip(); return; } #ifndef __WXWINCE__ else { // Without this, we can sometimes get droppings at the edges // of a notebook, for example a notebook in a splitter window. // This needs to be reconciled with the RefreshRect calls // at the end of this function, which weren't enough to prevent // the droppings. wxSize sz = GetClientSize(); // Refresh right side wxRect rect(sz.x-4, 0, 4, sz.y); RefreshRect(rect); // Refresh bottom side rect = wxRect(0, sz.y-4, sz.x, 4); RefreshRect(rect); // Refresh left side rect = wxRect(0, 0, 4, sz.y); RefreshRect(rect); } #endif // !__WXWINCE__ // fit all the notebook pages to the tab control's display area RECT rc; rc.left = rc.top = 0; GetSize((int *)&rc.right, (int *)&rc.bottom); // save the total size, we'll use it below int widthNbook = rc.right - rc.left, heightNbook = rc.bottom - rc.top; // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it // returns completely false values for multiline tab controls after the tabs // are added but before getting the first WM_SIZE (off by ~50 pixels, see // // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863 // // and the only work around I could find was this ugly hack... without it // simply toggling the "multiline" checkbox in the notebook sample resulted // in a noticeable page displacement if ( HasFlag(wxNB_MULTILINE) ) { // avoid an infinite recursion: we get another notification too! static bool s_isInOnSize = false; if ( !s_isInOnSize ) { s_isInOnSize = true; SendMessage(GetHwnd(), WM_SIZE, SIZE_RESTORED, MAKELPARAM(rc.right, rc.bottom)); s_isInOnSize = false; } // The best size depends on the number of rows of tabs, which can // change when the notepad is resized. InvalidateBestSize(); } #if wxUSE_UXTHEME // background bitmap size has changed, update the brush using it too UpdateBgBrush(); #endif // wxUSE_UXTHEME TabCtrl_AdjustRect(GetHwnd(), false, &rc); int width = rc.right - rc.left, height = rc.bottom - rc.top; size_t nCount = m_pages.Count(); for ( size_t nPage = 0; nPage < nCount; nPage++ ) { wxNotebookPage *pPage = m_pages[nPage]; pPage->SetSize(rc.left, rc.top, width, height); } // unless we had already repainted everything, we now need to refresh if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) ) { // invalidate areas not covered by pages RefreshRect(wxRect(0, 0, widthNbook, rc.top), false); RefreshRect(wxRect(0, rc.top, rc.left, height), false); RefreshRect(wxRect(0, rc.bottom, widthNbook, heightNbook - rc.bottom), false); RefreshRect(wxRect(rc.right, rc.top, widthNbook - rc.right, height), false); } #if USE_NOTEBOOK_ANTIFLICKER // subclass the spin control used by the notebook to scroll pages to // prevent it from flickering on resize if ( !m_hasSubclassedUpdown ) { // iterate over all child windows to find spin button for ( HWND child = ::GetWindow(GetHwnd(), GW_CHILD); child; child = ::GetWindow(child, GW_HWNDNEXT) ) { wxWindow *childWindow = wxFindWinFromHandle((WXHWND)child); // see if it exists, if no wxWindow found then assume it's the spin // btn if ( !childWindow ) { // subclass the spin button to override WM_ERASEBKGND if ( !gs_wndprocNotebookSpinBtn ) gs_wndprocNotebookSpinBtn = (WXFARPROC)wxGetWindowProc(child); wxSetWindowProc(child, wxNotebookSpinBtnWndProc); m_hasSubclassedUpdown = true; break; } } } // Probably because of the games we play above to avoid flicker sometimes // the text controls inside notebook pages are not shown correctly (they // don't have their borders) when the notebook is shown for the first time. // It's not really clear why does this happen and maybe the bug is in // wxTextCtrl itself and not here but updating the page when it's about to // be shown doesn't cost much and works around the problem so do it here // for now. if ( !m_doneUpdateHack && IsShownOnScreen() ) { m_doneUpdateHack = true; wxWindow* const page = GetCurrentPage(); if ( page ) page->Update(); } #endif // USE_NOTEBOOK_ANTIFLICKER event.Skip(); }
void wxChoice::DoSetSize(int x, int y, int width, int height, int sizeFlags) { int heightOrig = height; // the height which we must pass to Windows should be the total height of // the control including the drop down list while the height given to us // is, of course, just the height of the permanently visible part of it if ( height != wxDefaultCoord ) { // don't make the drop down list too tall, arbitrarily limit it to 40 // items max and also don't leave it empty size_t nItems = GetCount(); if ( !nItems ) nItems = 9; else if ( nItems > 24 ) nItems = 24; // add space for the drop down list const int hItem = SendMessage(GetHwnd(), CB_GETITEMHEIGHT, 0, 0); height += hItem*(nItems + 1); } else { // We cannot pass wxDefaultCoord as height to wxControl. wxControl uses // wxGetWindowRect() to determine the current height of the combobox, // and then again sets the combobox's height to that value. Unfortunately, // wxGetWindowRect doesn't include the dropdown list's height (at least // on Win2K), so this would result in a combobox with dropdown height of // 1 pixel. We have to determine the default height ourselves and call // wxControl with that value instead. int w, h; RECT r; DoGetSize(&w, &h); if (::SendMessage(GetHwnd(), CB_GETDROPPEDCONTROLRECT, 0, (LPARAM) &r) != 0) { height = h + r.bottom - r.top; } } wxControl::DoSetSize(x, y, width, height, sizeFlags); // If we're storing a pending size, make sure we store // the original size for reporting back to the app. if (m_pendingSize != wxDefaultSize) m_pendingSize = wxSize(width, heightOrig); // This solution works on XP, but causes choice/combobox lists to be // too short on W2K and earlier. #if 0 int widthCurrent, heightCurrent; DoGetSize(&widthCurrent, &heightCurrent); // the height which we must pass to Windows should be the total height of // the control including the drop down list while the height given to us // is, of course, just the height of the permanently visible part of it if ( height != wxDefaultCoord && height != heightCurrent ) { // don't make the drop down list too tall, arbitrarily limit it to 40 // items max and also don't leave it empty unsigned int nItems = GetCount(); if ( !nItems ) nItems = 9; else if ( nItems > 24 ) nItems = 24; // add space for the drop down list const int hItem = SendMessage(GetHwnd(), CB_GETITEMHEIGHT, 0, 0); height += hItem*(nItems + 1); } else // keep the same height as now { // normally wxWindow::DoSetSize() checks if we set the same size as the // window already has and does nothing in this case, but for us the // check fails as the size we pass to it includes the dropdown while // the size returned by our GetSize() does not, so test if the size // didn't really change ourselves here if ( width == wxDefaultCoord || width == widthCurrent ) { // size doesn't change, what about position? int xCurrent, yCurrent; DoGetPosition(&xCurrent, &yCurrent); const bool defMeansUnchanged = !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE); if ( ((x == wxDefaultCoord && defMeansUnchanged) || x == xCurrent) && ((y == wxDefaultCoord && defMeansUnchanged) || y == yCurrent) ) { // nothing changes, nothing to do return; } } // We cannot pass wxDefaultCoord as height to wxControl. wxControl uses // wxGetWindowRect() to determine the current height of the combobox, // and then again sets the combobox's height to that value. Unfortunately, // wxGetWindowRect doesn't include the dropdown list's height (at least // on Win2K), so this would result in a combobox with dropdown height of // 1 pixel. We have to determine the default height ourselves and call // wxControl with that value instead. // // Also notice that sometimes CB_GETDROPPEDCONTROLRECT seems to return // wildly incorrect values (~32000) which looks like a bug in it, just // ignore them in this case RECT r; if ( ::SendMessage(GetHwnd(), CB_GETDROPPEDCONTROLRECT, 0, (LPARAM) &r) && r.bottom < 30000 ) { height = heightCurrent + r.bottom - r.top; } } wxControl::DoSetSize(x, y, width, height, sizeFlags); #endif }
void *wxListBox::DoGetItemClientData(unsigned int n) const { return (void *)SendMessage(GetHwnd(), LB_GETITEMDATA, n, 0); }
void wxChoice::SetSelection(int n) { SendMessage(GetHwnd(), CB_SETCURSEL, n, 0); }
unsigned int wxChoice::GetCount() const { return (unsigned int)SendMessage(GetHwnd(), CB_GETCOUNT, 0, 0); }
int wxChoice::GetCurrentSelection() const { return (int)SendMessage(GetHwnd(), CB_GETCURSEL, 0, 0); }
bool wxSpinButton::Create( wxWindow* pParent , wxWindowID vId , const wxPoint& rPos , const wxSize& rSize , long lStyle , const wxString& rsName ) { int nX = rPos.x; int nY = rPos.y; int nWidth = rSize.x; int nHeight = rSize.y; SWP vSwp; m_min = 0; m_max = 100; if (vId == -1) m_windowId = NewControlId(); else m_windowId = vId; m_backgroundColour = pParent->GetBackgroundColour(); m_foregroundColour = pParent->GetForegroundColour(); SetName(rsName); SetParent(pParent); m_windowStyle = lStyle; // // Get the right size for the control // if (nWidth <= 0 || nHeight <= 0 ) { wxSize vSize = DoGetBestSize(); if (nWidth <= 0 ) nWidth = vSize.x; if (nHeight <= 0 ) nHeight = vSize.y; } if (nX < 0 ) nX = 0; if (nY < 0 ) nY = 0; long lSstyle = 0L; lSstyle = WS_VISIBLE | WS_TABSTOP | SPBS_MASTER | // We use only single field spin buttons SPBS_NUMERICONLY; // We default to numeric data if (m_windowStyle & wxCLIP_SIBLINGS ) lSstyle |= WS_CLIPSIBLINGS; m_hWnd = (WXHWND)::WinCreateWindow( GetWinHwnd(pParent) ,WC_SPINBUTTON ,(PSZ)NULL ,lSstyle ,0L, 0L, 0L, 0L ,GetWinHwnd(pParent) ,HWND_TOP ,(HMENU)vId ,NULL ,NULL ); if (m_hWnd == 0) { return FALSE; } SetRange(m_min, m_max); if(pParent) pParent->AddChild((wxSpinButton *)this); ::WinQueryWindowPos(m_hWnd, &vSwp); SetXComp(vSwp.x); SetYComp(vSwp.y-5); // compensate for the associated TextControl border SetFont(*wxSMALL_FONT); // // For OS/2 we want to hide the text portion so we can substitute an // independent text ctrl in its place. // Therefore we must override any user given width with our best guess. // SetSize( nX - GetXComp() ,nY - GetYComp() ,nWidth ,nHeight ); wxAssociateWinWithHandle( m_hWnd ,(wxWindowOS2*)this ); #if 0 // FIXME: // Apparently, this does not work, as it crashes in setvalue/setrange calls // What's it supposed to do anyway? ::WinSetWindowULong(GetHwnd(), QWL_USER, (LONG)this); fnWndProcSpinCtrl = (WXFARPROC)::WinSubclassWindow(m_hWnd, (PFNWP)wxSpinCtrlWndProc); #endif return TRUE; } // end of wxSpinButton::Create
void wxSpinButton::SetValue( int nValue ) { ::WinSendMsg(GetHwnd(), SPBM_SETCURRENTVALUE, MPFROMLONG(nValue), MPARAM(0)); } // end of wxSpinButton::SetValue
int wxNotebook::GetRowCount() const { return TabCtrl_GetRowCount(GetHwnd()); }
void CMemoryView::InfoProc(ePipeline& Info) { SendChildMessage(GetHwnd(),INFO_PROC,(int64)&Info,0); }
void wxNotebook::SetPadding(const wxSize& padding) { TabCtrl_SetPadding(GetHwnd(), padding.x, padding.y); }
bool wxSkinWindow::SetShape(const wxRegion& region) { #if defined(__WXMSW__) && !defined(__WXWINCE__) // The empty region signifies that the shape should be removed from the // window. if ( region.IsEmpty() ) { if (::SetWindowRgn(GetHwnd(), NULL, TRUE) == 0) { wxLogLastError(_T("SetWindowRgn")); return false; } return true; } DWORD noBytes = ::GetRegionData(GetHrgnOf(region), 0, NULL); RGNDATA *rgnData = (RGNDATA*) new char[noBytes]; ::GetRegionData(GetHrgnOf(region), noBytes, rgnData); HRGN hrgn = ::ExtCreateRegion(NULL, noBytes, rgnData); delete[] (char*) rgnData; RECT rect; DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE); DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE); ::GetClientRect(GetHwnd(), &rect); ::AdjustWindowRectEx(&rect, dwStyle, FALSE, dwExStyle); ::OffsetRgn(hrgn, -rect.left, -rect.top); if (::SetWindowRgn(GetHwnd(), hrgn, TRUE) == 0) { wxLogLastError(_T("SetWindowRgn")); return false; } return true; #elif defined(__WXMAC__) if ( region.IsEmpty() ) { wxSize sz = GetClientSize(); wxRegion rgn(0, 0, sz.x, sz.y); return SetShape(rgn); } // Make a copy of the region RgnHandle shapeRegion = NewRgn(); CopyRgn( (RgnHandle)region.GetWXHRGN(), shapeRegion ); // Dispose of any shape region we may already have RgnHandle oldRgn = (RgnHandle)GetWRefCon( (WindowRef)GetHandle() ); if ( oldRgn ) DisposeRgn(oldRgn); // Save the region so we can use it later SetWRefCon((WindowRef)GetHandle(), (SInt32)shapeRegion); // Tell the window manager that the window has changed shape ReshapeCustomWindow((WindowRef)GetHandle()); return true; #elif defined(__WXGTK__) if(region.IsEmpty()) { if(m_wxwindow && !GTK_WIDGET_NO_WINDOW(m_wxwindow)) gtk_widget_shape_combine_mask(m_wxwindow,NULL,0,0); if(m_widget && !GTK_WIDGET_NO_WINDOW(m_widget)) gtk_widget_shape_combine_mask(m_widget,NULL,0,0); } else { wxBitmap bmp = region.ConvertToBitmap(); bmp.SetMask(new wxMask(bmp, *wxBLACK)); GdkBitmap* mask = bmp.GetMask()->GetBitmap(); if(m_wxwindow && !GTK_WIDGET_NO_WINDOW(m_wxwindow)) gtk_widget_shape_combine_mask(m_wxwindow,mask,0,0); if(m_widget && !GTK_WIDGET_NO_WINDOW(m_widget)) gtk_widget_shape_combine_mask(m_widget,mask,0,0); } return true; #else return false; #endif }
// same as AddPage() but does it at given position bool wxNotebook::InsertPage(size_t nPage, wxNotebookPage *pPage, const wxString& strText, bool bSelect, int imageId) { wxCHECK_MSG( pPage != NULL, false, wxT("NULL page in wxNotebook::InsertPage") ); wxCHECK_MSG( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false, wxT("invalid index in wxNotebook::InsertPage") ); wxASSERT_MSG( pPage->GetParent() == this, wxT("notebook pages must have notebook as parent") ); // add a new tab to the control // ---------------------------- // init all fields to 0 TC_ITEM tcItem; wxZeroMemory(tcItem); // set the image, if any if ( imageId != -1 ) { tcItem.mask |= TCIF_IMAGE; tcItem.iImage = imageId; } // and the text if ( !strText.empty() ) { tcItem.mask |= TCIF_TEXT; tcItem.pszText = const_cast<wxChar *>(strText.wx_str()); } // hide the page: unless it is selected, it shouldn't be shown (and if it // is selected it will be shown later) HWND hwnd = GetWinHwnd(pPage); SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE); // this updates internal flag too -- otherwise it would get out of sync // with the real state pPage->Show(false); // fit the notebook page to the tab control's display area: this should be // done before adding it to the notebook or TabCtrl_InsertItem() will // change the notebooks size itself! AdjustPageSize(pPage); // finally do insert it if ( TabCtrl_InsertItem(GetHwnd(), nPage, &tcItem) == -1 ) { wxLogError(wxT("Can't create the notebook page '%s'."), strText.c_str()); return false; } // need to update the bg brush when the first page is added // so the first panel gets the correct themed background if ( m_pages.empty() ) { #if wxUSE_UXTHEME UpdateBgBrush(); #endif // wxUSE_UXTHEME } // succeeded: save the pointer to the page m_pages.Insert(pPage, nPage); // we may need to adjust the size again if the notebook size changed: // normally this only happens for the first page we add (the tabs which // hadn't been there before are now shown) but for a multiline notebook it // can happen for any page at all as a new row could have been started if ( m_pages.GetCount() == 1 || HasFlag(wxNB_MULTILINE) ) { AdjustPageSize(pPage); } // now deal with the selection // --------------------------- // if the inserted page is before the selected one, we must update the // index of the selected page if ( int(nPage) <= m_selection ) { // one extra page added m_selection++; } DoSetSelectionAfterInsertion(nPage, bSelect); InvalidateBestSize(); return true; }
bool wxToolMenuBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool) { // Skip over the menus if (GetMenuBar()) pos += GetMenuBar()->GetMenuCount(); // the main difficulty we have here is with the controls in the toolbars: // as we (sometimes) use several separators to cover up the space used by // them, the indices are not the same for us and the toolbar // first determine the position of the first button to delete: it may be // different from pos if we use several separators to cover the space used // by a control wxToolBarToolsList::compatibility_iterator node; for ( node = m_tools.GetFirst(); node; node = node->GetNext() ) { wxToolBarToolBase *tool2 = node->GetData(); if ( tool2 == tool ) { // let node point to the next node in the list node = node->GetNext(); break; } if ( tool2->IsControl() ) { pos += ((wxToolMenuBarTool *)tool2)->GetSeparatorsCount() - 1; } } // now determine the number of buttons to delete and the area taken by them size_t nButtonsToDelete = 1; // get the size of the button we're going to delete RECT r; if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT, pos, (LPARAM)&r) ) { wxLogLastError(_T("TB_GETITEMRECT")); } int width = r.right - r.left; if ( tool->IsControl() ) { nButtonsToDelete = ((wxToolMenuBarTool *)tool)->GetSeparatorsCount(); width *= nButtonsToDelete; } // do delete all buttons m_nButtons -= nButtonsToDelete; while ( nButtonsToDelete-- > 0 ) { if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, pos, 0) ) { wxLogLastError(wxT("TB_DELETEBUTTON")); return false; } } tool->Detach(); // and finally reposition all the controls after this button (the toolbar // takes care of all normal items) for ( /* node -> first after deleted */ ; node; node = node->GetNext() ) { wxToolBarToolBase *tool2 = node->GetData(); if ( tool2->IsControl() ) { int x; wxControl *control = tool2->GetControl(); control->GetPosition(&x, NULL); control->Move(x - width, wxDefaultCoord); } } return true; }
void EMFPreviewWindow::DrawEMF(const wxString &file) { m_meta = ReadEnhMetaFile(file.c_str(), GetHwnd()); Refresh(); }
bool wxToolMenuBar::Realize() { const size_t nTools = GetToolsCount(); if ( nTools == 0 ) { // nothing to do return true; } #if 0 // delete all old buttons, if any for ( size_t pos = 0; pos < m_nButtons; pos++ ) { if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, 0, 0) ) { wxLogDebug(wxT("TB_DELETEBUTTON failed")); } } #endif // 0 bool lastWasRadio = false; wxToolBarToolsList::Node* node; for ( node = m_tools.GetFirst(); node; node = node->GetNext() ) { wxToolMenuBarTool *tool = (wxToolMenuBarTool*) node->GetData(); TBBUTTON buttons[1] ; TBBUTTON& button = buttons[0]; wxZeroMemory(button); bool isRadio = false; switch ( tool->GetStyle() ) { case wxTOOL_STYLE_CONTROL: button.idCommand = tool->GetId(); // fall through: create just a separator too // TODO: controls are not yet supported on wxToolMenuBar. case wxTOOL_STYLE_SEPARATOR: button.fsState = TBSTATE_ENABLED; button.fsStyle = TBSTYLE_SEP; break; case wxTOOL_STYLE_BUTTON: if ( HasFlag(wxTB_TEXT) ) { const wxString& label = tool->GetLabel(); if ( !label.empty() ) { button.iString = (int)label.c_str(); } } const wxBitmap& bmp = tool->GetNormalBitmap(); wxBitmap bmpToUse = bmp; if (bmp.GetWidth() < 16 || bmp.GetHeight() < 16 || bmp.GetMask() != NULL) { wxMemoryDC memDC; wxBitmap b(16,16); memDC.SelectObject(b); wxColour col = wxColour(192,192,192); memDC.SetBackground(wxBrush(col)); memDC.Clear(); int x = (16 - bmp.GetWidth())/2; int y = (16 - bmp.GetHeight())/2; memDC.DrawBitmap(bmp, x, y, true); memDC.SelectObject(wxNullBitmap); bmpToUse = b; tool->SetNormalBitmap(b); } int n = 0; if ( bmpToUse.Ok() ) { n = ::CommandBar_AddBitmap( (HWND) GetHWND(), NULL, (int) (HBITMAP) bmpToUse.GetHBITMAP(), 1, 16, 16 ); } button.idCommand = tool->GetId(); button.iBitmap = n; if ( tool->IsEnabled() ) button.fsState |= TBSTATE_ENABLED; if ( tool->IsToggled() ) button.fsState |= TBSTATE_CHECKED; switch ( tool->GetKind() ) { case wxITEM_RADIO: button.fsStyle = TBSTYLE_CHECKGROUP; if ( !lastWasRadio ) { // the first item in the radio group is checked by // default to be consistent with wxGTK and the menu // radio items button.fsState |= TBSTATE_CHECKED; tool->Toggle(true); } isRadio = true; break; case wxITEM_CHECK: button.fsStyle = TBSTYLE_CHECK; break; default: wxFAIL_MSG( _T("unexpected toolbar button kind") ); // fall through case wxITEM_NORMAL: button.fsStyle = TBSTYLE_BUTTON; } break; } if ( !::CommandBar_AddButtons( (HWND) GetHWND(), 1, buttons ) ) { wxFAIL_MSG( wxT("Could not add toolbar button.")); } lastWasRadio = isRadio; } return true; }
void CTitleView::SetTitle(const TCHAR* Text){ BorderItem* TitleSpace = (BorderItem*)m_NcBorderList[0]; TextItem* TextLabel = (TextItem*)TitleSpace->FindSpace(ID_TITLETEXT); if(TextLabel)TextLabel->m_Text = Text; if(GetHwnd())Invalidate(); }
void RenderSystem::v_OnMouseDown(WPARAM btnState, int x, int y) { m_Camera.OnMouseDown(btnState, x, y, GetHwnd()); }
bool wxGLCanvas::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxString& name, const int *attribList, const wxPalette& palette) { // Create the window first: we will either use it as is or use it to query // for multisampling support and recreate it later with another pixel format if ( !CreateWindow(parent, id, pos, size, style, name) ) return false; PIXELFORMATDESCRIPTOR pfd; const int setupVal = DoSetup(pfd, attribList); if ( setupVal == 0 ) // PixelFormat error return false; if ( setupVal == -1 ) // FSAA requested { // now that we have a valid OpenGL window, query it for FSAA support int pixelFormat; { wxGLContext ctx(this); ctx.SetCurrent(*this); pixelFormat = ::ChoosePixelFormatARB(m_hDC, attribList); } if ( pixelFormat > 0 ) { // from http://msdn.microsoft.com/en-us/library/ms537559(VS.85).aspx: // // Setting the pixel format of a window more than once can // lead to significant complications for the Window Manager // and for multithread applications, so it is not allowed. An // application can only set the pixel format of a window one // time. Once a window's pixel format is set, it cannot be // changed. // // so we need to delete the old window and create the new one // destroy Window ::ReleaseDC(GetHwnd(), m_hDC); m_hDC = 0; parent->RemoveChild(this); const HWND hwnd = GetHwnd(); DissociateHandle(); // will do SetHWND(0); ::DestroyWindow(hwnd); // now recreate with FSAA pixelFormat if ( !CreateWindow(parent, id, pos, size, style, name) ) return false; if ( !::SetPixelFormat(m_hDC, pixelFormat, &pfd) ) { wxLogLastError(_T("SetPixelFormat")); return false; } } } #if wxUSE_PALETTE if ( !SetupPalette(palette) ) return false; #else // !wxUSE_PALETTE wxUnusedVar(palette); #endif // wxUSE_PALETTE/!wxUSE_PALETTE return true; }
void RenderSystem::init_device() { ////////////////////////Create buffer desc//////////////////////////// DXGI_MODE_DESC bufferDesc; ZeroMemory(&bufferDesc, sizeof(DXGI_MODE_DESC)); bufferDesc.Width = m_ScreenWidth; bufferDesc.Height = m_ScreenHeight; bufferDesc.RefreshRate.Numerator = 60; bufferDesc.RefreshRate.Denominator = 1; bufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; bufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; bufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; //Create swapChain Desc DXGI_SWAP_CHAIN_DESC swapChainDesc; ZeroMemory(&swapChainDesc, sizeof(DXGI_SWAP_CHAIN_DESC)); swapChainDesc.BufferDesc = bufferDesc; swapChainDesc.SampleDesc.Count = 1; swapChainDesc.SampleDesc.Quality = 0; swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swapChainDesc.BufferCount = 1; swapChainDesc.OutputWindow = GetHwnd(); swapChainDesc.Windowed = TRUE; swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; /////////////////////////////////////////////////////////////////////////// HRESULT hr; //Create the double buffer chain hr = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, NULL, NULL, NULL, D3D11_SDK_VERSION, &swapChainDesc, &m_pSwapChain, &m_pD3D11Device, NULL, &m_pD3D11DeviceContext); //DebugHR(hr); //Create back buffer, buffer also is a texture ID3D11Texture2D *pBackBuffer; hr = m_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&pBackBuffer); hr = m_pD3D11Device->CreateRenderTargetView(pBackBuffer, NULL, &m_pRenderTargetView); pBackBuffer->Release(); //DebugHR(hr); //////////////////////////// Initialize the description of the stencil state./////////////////////////////////////////////// D3D11_TEXTURE2D_DESC depthBufferDesc; ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc)); depthBufferDesc.Width = m_ScreenWidth; depthBufferDesc.Height = m_ScreenHeight; depthBufferDesc.MipLevels = 1; depthBufferDesc.ArraySize = 1; depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; depthBufferDesc.SampleDesc.Count = 1; depthBufferDesc.SampleDesc.Quality = 0; depthBufferDesc.Usage = D3D11_USAGE_DEFAULT; depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL; depthBufferDesc.CPUAccessFlags = 0; depthBufferDesc.MiscFlags = 0; // Create the texture for the depth buffer using the filled out description. hr = m_pD3D11Device->CreateTexture2D(&depthBufferDesc, NULL, &m_pDepthStencilBuffer); D3D11_DEPTH_STENCIL_DESC depthStencilDesc; ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc)); // Set up the description of the stencil state. depthStencilDesc.DepthEnable = true; depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL; depthStencilDesc.StencilEnable = true; depthStencilDesc.StencilReadMask = 0xFF; depthStencilDesc.StencilWriteMask = 0xFF; // Stencil operations if pixel is front-facing. depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR; depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS; // Stencil operations if pixel is back-facing. depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR; depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS; // Create the depth stencil state. hr = m_pD3D11Device->CreateDepthStencilState(&depthStencilDesc, &m_pDepthStencilState); // Set the depth stencil state. //DebugHR(hr); D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc; // Initialize the depth stencil view. ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc)); // Set up the depth stencil view description. depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; depthStencilViewDesc.Texture2D.MipSlice = 0; // Create the depth stencil view. hr = m_pD3D11Device->CreateDepthStencilView(m_pDepthStencilBuffer.Get(), &depthStencilViewDesc, &m_pDepthStencilView); //DebugHR(hr); // ////////////Clear the second depth stencil state before setting the parameters.////////////////////// D3D11_DEPTH_STENCIL_DESC depthDisabledStencilDesc; ZeroMemory(&depthDisabledStencilDesc, sizeof(depthDisabledStencilDesc)); // Now create a second depth stencil state which turns off the Z buffer for 2D rendering. The only difference is // that DepthEnable is set to false, all other parameters are the same as the other depth stencil state. depthDisabledStencilDesc.DepthEnable = false; depthDisabledStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; depthDisabledStencilDesc.DepthFunc = D3D11_COMPARISON_LESS; depthDisabledStencilDesc.StencilEnable = true; depthDisabledStencilDesc.StencilReadMask = 0xFF; depthDisabledStencilDesc.StencilWriteMask = 0xFF; depthDisabledStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; depthDisabledStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR; depthDisabledStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; depthDisabledStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS; depthDisabledStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; depthDisabledStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR; depthDisabledStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; depthDisabledStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS; // Create the state using the device. hr = m_pD3D11Device->CreateDepthStencilState(&depthDisabledStencilDesc, &m_pDepthDisabledStencilState); //DebugHR(hr); // Setup the raster description which will determine how and what polygons will be drawn. D3D11_RASTERIZER_DESC rasterDesc; rasterDesc.AntialiasedLineEnable = false; rasterDesc.CullMode = D3D11_CULL_BACK; rasterDesc.DepthBias = 0; rasterDesc.DepthBiasClamp = 0.0f; rasterDesc.DepthClipEnable = true; rasterDesc.FillMode = D3D11_FILL_SOLID; rasterDesc.FrontCounterClockwise = false; rasterDesc.MultisampleEnable = false; rasterDesc.ScissorEnable = false; rasterDesc.SlopeScaledDepthBias = 0.0f; // Create the rasterizer state from the description we just filled out. hr = m_pD3D11Device->CreateRasterizerState(&rasterDesc, &m_pRasterState); //DebugHR(hr); /////////////////////////////////////////////////////////////////////////////// unsigned int numModes, i, numerator, denominator, stringLength; IDXGIFactory* factory; IDXGIAdapter* adapter; IDXGISurface *surface; DXGI_ADAPTER_DESC adapterDesc; // Create a DirectX graphics interface factory. CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory); // Use the factory to create an adapter for the primary graphics interface (video card). factory->EnumAdapters(0, &adapter); adapter->GetDesc(&adapterDesc); m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024); // Convert the name of the video card to a character array and store it. m_videoCardInfo = std::wstring(L"Video Card :") + adapterDesc.Description; }
bool wxChoice::CreateAndInit(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, int n, const wxString choices[], long style, const wxValidator& validator, const wxString& name) { if ( !(style & wxSP_VERTICAL) ) style |= wxSP_HORIZONTAL; if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT ) style |= wxBORDER_SIMPLE; style |= wxSP_ARROW_KEYS; SetWindowStyle(style); WXDWORD exStyle = 0; WXDWORD msStyle = MSWGetStyle(GetWindowStyle(), & exStyle) ; wxSize sizeText(size), sizeBtn(size); sizeBtn.x = GetBestSpinnerSize(IsVertical(style)).x; if ( sizeText.x == wxDefaultCoord ) { // DEFAULT_ITEM_WIDTH is the default width for the text control sizeText.x = DEFAULT_ITEM_WIDTH + MARGIN_BETWEEN + sizeBtn.x; } sizeText.x -= sizeBtn.x + MARGIN_BETWEEN; if ( sizeText.x <= 0 ) { wxLogDebug(wxT("not enough space for wxSpinCtrl!")); } wxPoint posBtn(pos); posBtn.x += sizeText.x + MARGIN_BETWEEN; // we must create the list control before the spin button for the purpose // of the dialog navigation: if there is a static text just before the spin // control, activating it by Alt-letter should give focus to the text // control, not the spin and the dialog navigation code will give focus to // the next control (at Windows level), not the one after it // create the text window m_hwndBuddy = (WXHWND)::CreateWindowEx ( exStyle, // sunken border wxT("LISTBOX"), // window class NULL, // no window title msStyle, // style (will be shown later) pos.x, pos.y, // position 0, 0, // size (will be set later) GetHwndOf(parent), // parent (HMENU)-1, // control id wxGetInstance(), // app instance NULL // unused client data ); if ( !m_hwndBuddy ) { wxLogLastError(wxT("CreateWindow(buddy text window)")); return false; } // initialize wxControl if ( !CreateControl(parent, id, posBtn, sizeBtn, style, validator, name) ) return false; // now create the real HWND WXDWORD spiner_style = WS_VISIBLE | UDS_ALIGNRIGHT | UDS_ARROWKEYS | UDS_SETBUDDYINT | UDS_EXPANDABLE; if ( !IsVertical(style) ) spiner_style |= UDS_HORZ; if ( style & wxSP_WRAP ) spiner_style |= UDS_WRAP; if ( !MSWCreateControl(UPDOWN_CLASS, spiner_style, posBtn, sizeBtn, wxEmptyString, 0) ) return false; // subclass the text ctrl to be able to intercept some events wxSetWindowUserData(GetBuddyHwnd(), this); m_wndProcBuddy = (WXFARPROC)wxSetWindowProc(GetBuddyHwnd(), wxBuddyChoiceWndProc); // set up fonts and colours (This is nomally done in MSWCreateControl) InheritAttributes(); if (!m_hasFont) SetFont(GetDefaultAttributes().font); // set the size of the text window - can do it only now, because we // couldn't call DoGetBestSize() before as font wasn't set if ( sizeText.y <= 0 ) { int cx, cy; wxGetCharSize(GetHWND(), &cx, &cy, GetFont()); sizeText.y = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy); } SetInitialSize(size); (void)::ShowWindow(GetBuddyHwnd(), SW_SHOW); // associate the list window with the spin button (void)::SendMessage(GetHwnd(), UDM_SETBUDDY, (WPARAM)GetBuddyHwnd(), 0); // do it after finishing with m_hwndBuddy creation to avoid generating // initial wxEVT_COMMAND_TEXT_UPDATED message ms_allChoiceSpins.Add(this); // initialize the controls contents for ( int i = 0; i < n; i++ ) { Append(choices[i]); } return true; }
// Create() function bool wxNotebook::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxString& name) { if ( (style & wxBK_ALIGN_MASK) == wxBK_DEFAULT ) { #if defined(__POCKETPC__) style |= wxBK_BOTTOM | wxNB_FLAT; #else style |= wxBK_TOP; #endif } #ifdef __WXWINCE__ // Not sure why, but without this style, there is no border // around the notebook tabs. if (style & wxNB_FLAT) style |= wxBORDER_SUNKEN; #endif #if !wxUSE_UXTHEME // ComCtl32 notebook tabs simply don't work unless they're on top if we // have uxtheme, we can work around it later (after control creation), but // if we have been compiled without uxtheme support, we have to clear those // styles if ( HasTroubleWithNonTopTabs() ) { style &= ~(wxBK_BOTTOM | wxBK_LEFT | wxBK_RIGHT); } #endif //wxUSE_UXTHEME #if defined(__WINE__) && wxUSE_UNICODE LPCTSTR className = L"SysTabControl32"; #else LPCTSTR className = WC_TABCONTROL; #endif #if USE_NOTEBOOK_ANTIFLICKER // SysTabCtl32 class has natively CS_HREDRAW and CS_VREDRAW enabled and it // causes horrible flicker when resizing notebook, so get rid of it by // using a class without these styles (but otherwise identical to it) if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) ) { static ClassRegistrar s_clsNotebook; if ( !s_clsNotebook.IsInitialized() ) { // get a copy of standard class and modify it WNDCLASS wc; if ( ::GetClassInfo(NULL, WC_TABCONTROL, &wc) ) { gs_wndprocNotebook = reinterpret_cast<WXFARPROC>(wc.lpfnWndProc); wc.lpszClassName = wxT("_wx_SysTabCtl32"); wc.style &= ~(CS_HREDRAW | CS_VREDRAW); wc.hInstance = wxGetInstance(); wc.lpfnWndProc = wxNotebookWndProc; s_clsNotebook.Register(wc); } else { wxLogLastError(wxT("GetClassInfoEx(SysTabCtl32)")); } } // use our custom class if available but fall back to the standard // notebook if we failed to register it if ( s_clsNotebook.IsRegistered() ) { // it's ok to use c_str() here as the static s_clsNotebook object // has sufficiently long lifetime className = s_clsNotebook.GetName().c_str(); } } #endif // USE_NOTEBOOK_ANTIFLICKER if ( !CreateControl(parent, id, pos, size, style | wxTAB_TRAVERSAL, wxDefaultValidator, name) ) return false; if ( !MSWCreateControl(className, wxEmptyString, pos, size) ) return false; #if wxUSE_UXTHEME if ( HasFlag(wxNB_NOPAGETHEME) || wxSystemOptions::IsFalse(wxT("msw.notebook.themed-background")) ) { SetBackgroundColour(GetThemeBackgroundColour()); } else // use themed background by default { // create backing store UpdateBgBrush(); } // comctl32.dll 6.0 doesn't support non-top tabs with visual styles (the // control is simply not rendered correctly), so we disable themes // if possible, otherwise we simply clear the styles. if ( HasTroubleWithNonTopTabs() && (style & (wxBK_BOTTOM | wxBK_LEFT | wxBK_RIGHT)) ) { // check if we use themes at all -- if we don't, we're still okay if ( wxUxThemeEngine::GetIfActive() ) { wxUxThemeEngine::GetIfActive()->SetWindowTheme(GetHwnd(), L"", L""); // correct the background color for the new non-themed control SetBackgroundColour(GetThemeBackgroundColour()); } } #endif // wxUSE_UXTHEME // Undocumented hack to get flat notebook style // In fact, we should probably only do this in some // curcumstances, i.e. if we know we will have a border // at the bottom (the tab control doesn't draw it itself) #if defined(__POCKETPC__) || defined(__SMARTPHONE__) if (HasFlag(wxNB_FLAT)) { SendMessage(GetHwnd(), CCM_SETVERSION, COMCTL32_VERSION, 0); if (!m_hasBgCol) SetBackgroundColour(*wxWHITE); } #endif return true; }
void wxFrame::AttachMenuBar(wxMenuBar *menubar) { #if defined(__SMARTPHONE__) && defined(__WXWINCE__) wxMenu *autoMenu = NULL; if( menubar->GetMenuCount() == 1 ) { autoMenu = wxTopLevelWindowMSW::ButtonMenu::DuplicateMenu(menubar->GetMenu(0)); SetRightMenu(wxID_ANY, menubar->GetMenuLabel(0), autoMenu); } else { autoMenu = new wxMenu; for( size_t n = 0; n < menubar->GetMenuCount(); n++ ) { wxMenu *item = menubar->GetMenu(n); wxString label = menubar->GetMenuLabel(n); wxMenu *new_item = wxTopLevelWindowMSW::ButtonMenu::DuplicateMenu(item); autoMenu->Append(wxID_ANY, label, new_item); } SetRightMenu(wxID_ANY, _("Menu"), autoMenu); } #elif defined(WINCE_WITHOUT_COMMANDBAR) if (!GetToolBar()) { wxToolMenuBar* toolBar = new wxToolMenuBar(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE | wxTB_HORIZONTAL, wxToolBarNameStr, menubar); SetToolBar(toolBar); menubar->SetToolBar(toolBar); } // When the main window is created using CW_USEDEFAULT the height of the // menubar is not taken into account, so we resize it afterwards if a // menubar is present HWND hwndMenuBar = SHFindMenuBar(GetHwnd()); if ( hwndMenuBar ) { RECT mbRect; ::GetWindowRect(hwndMenuBar, &mbRect); const int menuHeight = mbRect.bottom - mbRect.top; RECT rc; ::GetWindowRect(GetHwnd(), &rc); // adjust for menu / titlebar height rc.bottom -= (2*menuHeight-1); ::MoveWindow(Gethwnd(), rc.left, rc.top, rc.right, rc.bottom, FALSE); } #endif wxFrameBase::AttachMenuBar(menubar); if ( !menubar ) { // actually remove the menu from the frame m_hMenu = (WXHMENU)0; InternalSetMenuBar(); } else // set new non NULL menu bar { #if !defined(__WXWINCE__) || defined(WINCE_WITH_COMMANDBAR) // Can set a menubar several times. if ( menubar->GetHMenu() ) { m_hMenu = menubar->GetHMenu(); } else // no HMENU yet { m_hMenu = menubar->Create(); if ( !m_hMenu ) { wxFAIL_MSG( wxT("failed to create menu bar") ); return; } } #endif InternalSetMenuBar(); } }
bool wxCheckBox::GetValue() const { return((LONGFROMMR(::WinSendMsg(GetHwnd(), BM_QUERYCHECK, (MPARAM)0, (MPARAM)0)) == 1L)); } // end of wxCheckBox::GetValue