//--------------------------------------------------------- void CVIEW_ScatterPlot::_Draw(wxDC &dc, wxRect r) { r = _Draw_Get_rDiagram(r); if( m_Trend.Get_Data_Count() > 1 ) { //------------------------------------------------- if( m_Options("DISPLAY")->asInt() == 1 ) { if( m_Options("DENSITY_LEG")->asBool() ) { r.SetRight(r.GetRight() - 40); _Draw_Legend(dc, wxRect(r.GetRight() + 10, r.GetTop(), 40 - 20, r.GetHeight())); } _Draw_Image (dc, r); } else { _Draw_Points(dc, r); } //------------------------------------------------- _Draw_Frame(dc, r); } else { Draw_Text(dc, TEXTALIGN_CENTER, r.GetLeft() + r.GetWidth() / 2, r.GetTop() + r.GetHeight() / 2, _TL("Invalid data!")); } }
void MyHtmlListBox::OnDrawSeparator(wxDC& dc, wxRect& rect, size_t) const { if ( ((MyFrame *)GetParent())-> GetMenuBar()->IsChecked(HtmlLbox_DrawSeparator) ) { dc.SetPen(*wxBLACK_DASHED_PEN); dc.DrawLine(rect.x, rect.y, rect.GetRight(), rect.y); dc.DrawLine(rect.x, rect.GetBottom(), rect.GetRight(), rect.GetBottom()); } }
void wxRibbonAUIArtProvider::DrawPageBackground( wxDC& dc, wxWindow* WXUNUSED(wnd), const wxRect& rect) { dc.SetPen(*wxTRANSPARENT_PEN); dc.SetBrush(m_background_brush); dc.DrawRectangle(rect.x + 1, rect.y, rect.width - 2, rect.height - 1); dc.SetPen(m_page_border_pen); dc.DrawLine(rect.x, rect.y, rect.x, rect.y + rect.height); dc.DrawLine(rect.GetRight(), rect.y, rect.GetRight(), rect.y +rect.height); dc.DrawLine(rect.x, rect.GetBottom(), rect.GetRight()+1, rect.GetBottom()); }
// // Draws a focus rectangle (Taken directly from wxWidgets source) // void AColor::DrawFocus(wxDC & dc, wxRect & rect) { // draw the pixels manually: note that to behave in the same manner as // DrawRect(), we must exclude the bottom and right borders from the // rectangle wxCoord x1 = rect.GetLeft(), y1 = rect.GetTop(), x2 = rect.GetRight(), y2 = rect.GetBottom(); dc.SetPen(wxPen(wxT("MEDIUM GREY"), 0, wxSOLID)); // this seems to be closer than what Windows does than wxINVERT although // I'm still not sure if it's correct dc.SetLogicalFunction(wxAND_REVERSE); wxCoord z; for ( z = x1 + 1; z < x2; z += 2 ) dc.DrawPoint(z, y1); wxCoord shift = z == x2 ? 0 : 1; for ( z = y1 + shift; z < y2; z += 2 ) dc.DrawPoint(x2, z); shift = z == y2 ? 0 : 1; for ( z = x2 - shift; z > x1; z -= 2 ) dc.DrawPoint(z, y2); shift = z == x1 ? 0 : 1; for ( z = y2 - shift; z > y1; z -= 2 ) dc.DrawPoint(x1, z); dc.SetLogicalFunction(wxCOPY); }
void wxWindowDFB::DoRefreshRect(const wxRect& rect) { wxWindow *parent = GetParent(); wxCHECK_RET( parent, "no parent" ); // don't overlap outside of the window (NB: 'rect' is in window coords): wxRect r(rect); r.Intersect(wxRect(GetSize())); if ( r.IsEmpty() ) return; wxLogTrace(TRACE_PAINT, "%p ('%s'): refresh rect [%i,%i,%i,%i]", this, GetName().c_str(), rect.x, rect.y, rect.GetRight(), rect.GetBottom()); // convert the refresh rectangle to parent's coordinates and // recursively refresh the parent: r.Offset(GetPosition()); r.Offset(parent->GetClientAreaOrigin()); // normal windows cannot extend out of its parent's client area, so don't // refresh any hidden parts: if ( !CanBeOutsideClientArea() ) r.Intersect(parent->GetClientRect()); parent->DoRefreshRect(r); }
void Stage::InvalidateRect(const wxRect &inRect) { wxLogTrace(TRACE_STAGE_DRAWING, wxT("Invalidating: %d %d %d %d"), inRect.x, inRect.y, inRect.GetRight(), inRect.GetBottom()); // We want to make sure that we never try to do any drawing off // the edges of the screen. Certain platforms, (like wxMac) get // very upset when you try to draw from or to rects that lie off // the screen. Since this is how all of the dirty regions enter // the system, we clip our dirty rect to the screen and make sure // we have something left before continuing. wxRect r(inRect.Intersect(wxRect(wxPoint(0, 0), GetSize()))); if (r.IsEmpty()) return; // It's a little bit inelegant to maintain two different dirty lists, // but they get cleared by different actions. mRectsToComposite.MergeRect(r); // Trigger screen repaint events--and update our manual refresh // list--but only if Quake 2 is not being displayed. (Quake 2 covers // the entire stage, and if we repaint the screen, it will flicker.) // The entire screen will automatically be refreshed when Quake 2 // is hidden. if (!GameEngineIsDisplayed()) { mRectsToRefresh.MergeRect(r); Refresh(FALSE, &r); } }
//--------------------------------------------------------- wxRect CVIEW_ScatterPlot::_Draw_Get_rDiagram(wxRect r) { return( wxRect( wxPoint(r.GetLeft () + 45, r.GetTop () + 20), wxPoint(r.GetRight() - 20, r.GetBottom() - 40) )); }
void wxGridCellIconRenderer::Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc, const wxRect& rectCell, int row, int col, bool isSelected) { wxGridCellRenderer::Draw(grid, attr, dc, rectCell, row, col, isSelected); const char** psz=NULL; // if (grid.GetCellValue(row, col) == wxT("IDI_PC")) // psz = szIconPC; // else psz = szIconNomad; wxIcon icon(psz); icon.SetHeight(16); icon.SetWidth(16); // wxColour colourBackGround = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE); // dc.SetBrush(wxBrush(colourBackGround, wxSOLID)); // dc.SetPen(wxPen(colourBackGround, 1, wxSOLID)); // dc.DrawRectangle(rectCell); int nMargin = (rectCell.GetHeight() - icon.GetHeight()) /2; if (nMargin < 0) nMargin = 0; dc.DrawIcon(icon, rectCell.x, rectCell.y+nMargin); if (m_border == wxLAYOUT_TOP) { dc.SetPen(wxPen(*wxBLACK, 1, wxDOT)); dc.DrawLine(rectCell.GetRight(), rectCell.GetTop(), rectCell.GetLeft(), rectCell.GetTop()); } // dc.DrawIcon(icon, 16, 0); }
/// Gets a rectangle from within another image, INCLUDING the alpha channel /// \bug in wxWidgets, wxImage::GetSubImage should do this itself. wxImage GetSubImageWithAlpha( const wxImage & Src, const wxRect &rect ) { //First part of this code is lifted from wxImage::GetSubImage() source code. wxImage image; wxCHECK_MSG( Src.Ok(), image, wxT("invalid image") ); wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) && ( rect.GetRight()<=Src.GetWidth()) && (rect.GetBottom()<=Src.GetHeight()), image, wxT("invalid subimage size") ); int subwidth=rect.GetWidth(); const int subheight=rect.GetHeight(); image.Create( subwidth, subheight, false ); unsigned char *subdata = image.GetData(), *data=Src.GetData(); wxCHECK_MSG( subdata, image, wxT("unable to create image") ); // JKC: Quick hack - don't deal with masks - need to understand macro M_IMGDATA first. // if (Src.M_IMGDATA->m_hasMask) // image.SetMaskColour( Src.M_IMGDATA->m_maskRed, Src.M_IMGDATA->m_maskGreen, Src.M_IMGDATA->m_maskBlue ); int subleft=3*rect.GetLeft(); int width=3*Src.GetWidth(); subwidth*=3; data+=rect.GetTop()*width+subleft; for (long j = 0; j < subheight; ++j) { memcpy( subdata, data, subwidth); subdata+=subwidth; data+=width; } // OK, so we've copied the RGB data. // Now do the Alpha channel. wxASSERT( Src.HasAlpha() ); image.InitAlpha(); subleft/=3; width/=3; subwidth/=3; data =Src.GetAlpha(); subdata =image.GetAlpha(); data+=rect.GetTop()*width+subleft; for (long j = 0; j < subheight; ++j) { memcpy( subdata, data, subwidth); subdata+=subwidth; data+=width; } return image; }
bool MathCell::InUpdateRegion(wxRect rect) { return (rect.GetRight() >= m_updateRegion.GetLeft() ) && (rect.GetLeft() <= m_updateRegion.GetRight() ) && (rect.GetBottom() >= m_updateRegion.GetTop() ) && (rect.GetTop() <= m_updateRegion.GetBottom()); }
void configuration_visitor::set_bbox(const wxRect& r) { boost::shared_ptr<vector_layer_ghost> ghost = m_panel->vectorlayerghost(); if(!ghost) return; ghost->reset<vector_layer_ghost::Rectangle>(); ghost->add_point(wxRealPoint(r.GetLeft (),r.GetTop ())); ghost->add_point(wxRealPoint(r.GetRight(),r.GetBottom())); ghost->m_penRectangle = wxPen(*wxRED, 2, wxDOT); ghost->m_brushRectangle = wxBrush(*wxRED, wxTRANSPARENT); }
// Calculate the area that contains both rectangles static wxRect CombineRectangles(const wxRect& rect1, const wxRect& rect2) { wxRect rect; int right1 = rect1.GetRight(); int bottom1 = rect1.GetBottom(); int right2 = rect2.GetRight(); int bottom2 = rect2.GetBottom(); wxPoint topLeft = wxPoint(wxMin(rect1.x, rect2.x), wxMin(rect1.y, rect2.y)); wxPoint bottomRight = wxPoint(wxMax(right1, right2), wxMax(bottom1, bottom2)); rect.x = topLeft.x; rect.y = topLeft.y; rect.SetRight(bottomRight.x); rect.SetBottom(bottomRight.y); return rect; }
void wxStdRenderer::DrawFrameWithoutLabel(wxDC& dc, const wxRect& rectFrame, const wxRect& rectLabel) { // draw left, bottom and right lines entirely DrawVerticalLine(dc, rectFrame.GetLeft(), rectFrame.GetTop(), rectFrame.GetBottom() - 2); DrawHorizontalLine(dc, rectFrame.GetBottom() - 1, rectFrame.GetLeft(), rectFrame.GetRight()); DrawVerticalLine(dc, rectFrame.GetRight() - 1, rectFrame.GetTop(), rectFrame.GetBottom() - 1); // and 2 parts of the top line DrawHorizontalLine(dc, rectFrame.GetTop(), rectFrame.GetLeft() + 1, rectLabel.GetLeft()); DrawHorizontalLine(dc, rectFrame.GetTop(), rectLabel.GetRight(), rectFrame.GetRight() - 2); }
//--------------------------------------------------------- void CVIEW_ScatterPlot::_Draw_Legend(wxDC &dc, wxRect r) { CSG_Colors Colors(*m_Options("DENSITY_PAL")->asColors()); Colors.Set_Count(r.GetHeight()); for(int i=0, y=r.GetBottom(); i<Colors.Get_Count(); i++, y--) { Draw_FillRect(dc, Get_Color_asWX(Colors.Get_Color(i)), r.GetLeft(), y, r.GetRight(), y + 1); } // r.Offset(0, -r.GetHeight()); Draw_Edge(dc, EDGE_STYLE_SIMPLE, r); Draw_Text(dc, TEXTALIGN_BOTTOMLEFT, 2 + r.GetRight(), r.GetBottom(), "0"); Draw_Text(dc, TEXTALIGN_TOPLEFT , 2 + r.GetRight(), r.GetTop (), wxString::Format("%d", (int)m_Count.Get_Max())); }
bool EditorPrintout::OnPrintPage(int pageNum) { wxASSERT(m_line && m_lineList); if (m_pages.empty()) return true; unsigned int page_ndx = pageNum-1; // page numbers start from one const unsigned int lastline = m_pages[page_ndx]; unsigned int line_id = page_ndx ? m_pages[page_ndx-1]+1 : 0; // Make page size scale with screen resolution MapScreenSizeToPage(); const wxRect rect = GetLogicalPageRect(); unsigned int ypos = rect.y; // We may have gotten a new dc, so we need a new line wxDC& dc = *GetDC(); const wxFont& font = m_theme.font; dc.SetFont(font); FixedLine line(dc, m_printDoc.GetDocument(), s_sel, s_brackets, s_lastpos, s_isShadow, m_theme); line.SetPrintMode(); line.Init(); line.SetWordWrap(cxWRAP_SMART); line.SetWidth(rect.width - m_gutter_width); // Draw gutter separator const unsigned int sep_xpos = m_gutter_width - 5; const unsigned int number_right = m_gutter_width - 8; dc.DrawLine(sep_xpos, rect.y, sep_xpos, rect.y + m_page_height); // Draw lines while (line_id <= lastline) { // Draw line number const wxString linenumber = wxString::Format(wxT("%u"), line_id+1); const wxSize ln_ext = dc.GetTextExtent(linenumber); dc.DrawText(linenumber, number_right - ln_ext.x, ypos); // Draw line line.SetLine(m_lineList->offset(line_id), m_lineList->end(line_id)); line.DrawLine(rect.x + m_gutter_width, ypos, rect, false); ypos += line.GetHeight(); ++line_id; } // Draw footer title ypos = rect.GetBottom() - m_line->GetCharHeight(); dc.DrawText(m_printDoc.GetName(), 0, ypos); // Draw footer pagenum const wxString pagefooter = wxString::Format(wxT("%d / %d"), pageNum, m_pages.size()); const wxSize extent = dc.GetTextExtent(pagefooter); dc.DrawText(pagefooter, rect.GetRight() - extent.x, ypos); return true; }
void wxRibbonMetroArtProvider::DrawToolGroupBackground(wxDC& dc, wxWindow* WXUNUSED(wnd), const wxRect& rect) { // TODO: there is no DrawToolGroupSeparator method currently wxRect line; line.x = rect.GetRight() + 4; line.y = rect.GetY() + 5; line.width = 1; line.height = rect.GetHeight() - 10; dc.GradientFillLinear(line, wxColour(232, 234, 237), wxColour(178, 183, 189), wxSOUTH); }
wxDCOverlay::wxDCOverlay(wxOverlay &overlay, wxDC *dc) : m_overlay(overlay) { const wxRect device(wxPoint(0, 0), dc->GetSize()); Init(dc, dc->DeviceToLogicalX(device.GetLeft()), dc->DeviceToLogicalY(device.GetTop()), dc->DeviceToLogicalX(device.GetRight()), dc->DeviceToLogicalY(device.GetBottom())); }
//----------------------------------------------------------------------- CEGUI::Imageset* EditorDocument::generateRealImageset(const wxString& pathName) { const String imagesetName ( CEGUIHelper::ToCEGUIString( m_imagesetName ) ); const String imageFilename ( CEGUIHelper::ToCEGUIString( pathName + m_imageFilename ) ); ImagesetManager& isMgr = ImagesetManager::getSingleton(); if ( isMgr.isImagesetPresent( imagesetName ) ) // TODO: Maybe ask user whether to continue here? isMgr.destroyImageset( imagesetName ); // create the imageset Imageset* imageset = isMgr.createImagesetFromImageFile( imagesetName, imageFilename ); // auto-scale options imageset->setAutoScalingEnabled( m_autoScaled ); imageset->setNativeResolution( CEGUI::Size( m_nativeResolution.x, m_nativeResolution.y ) ); // iterate over all the elements in the class mapNamedRegion::iterator it; for( it = m_mapSetRectangles.begin(); it != m_mapSetRectangles.end(); ++it ) { const String imageName = CEGUIHelper::ToCEGUIString( wxString( it->first ) ); if ( !imageset->isImageDefined( imageName ) ) { const wxRect r( it->second ); const CEGUI::Rect newDim( ( ( r.GetLeft() > 0 ) ? r.GetLeft() : 0 ), ( ( r.GetTop() > 0 ) ? r.GetTop() : 0 ), ( ( r.GetRight() + 1 > 0 ) ? r.GetRight() + 1 : 0 ), ( ( r.GetBottom() + 1 > 0 ) ? r.GetBottom() + 1 : 0 ) ); const CEGUI::Point p ( 0.0f, 0.0f ); imageset->defineImage( imageName, newDim, p ); } } if ( imageset->isImageDefined ( "full_image" ) ) imageset->undefineImage( "full_image" ); return imageset; }
wxRect MathCell::CropToUpdateRegion(wxRect rect) { int left =rect.GetLeft(); int top =rect.GetTop (); int right =rect.GetRight(); int bottom=rect.GetBottom(); if (left < m_updateRegion.GetLeft()) left = m_updateRegion.GetLeft(); if (right > m_updateRegion.GetRight()) right = m_updateRegion.GetRight(); if (top < m_updateRegion.GetTop()) top = m_updateRegion.GetTop(); if (bottom > m_updateRegion.GetBottom()) bottom = m_updateRegion.GetBottom(); return wxRect(wxPoint(left,top),wxPoint(right,bottom)); }
void wxRibbonAUIArtProvider::DrawTabCtrlBackground( wxDC& dc, wxWindow* WXUNUSED(wnd), const wxRect& rect) { wxRect gradient_rect(rect); gradient_rect.height--; dc.GradientFillLinear(gradient_rect, m_tab_ctrl_background_colour, m_tab_ctrl_background_gradient_colour, wxSOUTH); dc.SetPen(m_tab_border_pen); dc.DrawLine(rect.x, rect.GetBottom(), rect.GetRight()+1, rect.GetBottom()); }
void TGraphScale::DrawMark ( wxDC &dc , float p , wxRect &ir , wxString text , bool big ) { int x , y , z ; if ( horizontal ) { x = GetRealCoord ( p , ir ) ; y = ir.y + ir.height / 2 ; z = big ? 0 : ir.height / 4 ; if ( x < ir.x || x > ir.GetRight() ) return ; } else { x = ir.x + ir.width / 2 ; y = GetRealCoord ( p , ir ) ; z = big ? 0 : ir.width / 4 ; if ( y < ir.y || y > ir.GetBottom() ) return ; } while ( text.Last() == '0' ) text = text.Left ( text.length() - 1 ) ; while ( text.Last() == '.' ) text = text.Left ( text.length() - 1 ) ; int tw , th ; dc.GetTextExtent ( text , &tw , &th ) ; if ( horizontal ) { if ( left ) dc.DrawLine ( x , y-z , x , ir.y ) ; else dc.DrawLine ( x , y+z , x , ir.GetBottom() ) ; x -= tw / 2 ; y = left ? ir.GetBottom() - th : ir.y ; } else { if ( left ) dc.DrawLine ( ir.x , y , x-z , y ) ; else dc.DrawLine ( x+z , y , ir.GetRight() , y ) ; y -= th / 2 ; x = left ? ir.GetRight() - tw : ir.x ; } if ( big ) dc.DrawText ( text , x , y ) ; }
void wxStdRenderer::DrawCheckOrRadioButton(wxDC& dc, const wxString& label, const wxBitmap& bitmap, const wxRect& rect, int flags, wxAlignment align, int indexAccel) { // calculate the position of the bitmap and of the label wxCoord heightBmp = bitmap.GetHeight(); wxCoord xBmp, yBmp = rect.y + (rect.height - heightBmp) / 2; wxRect rectLabel; dc.GetMultiLineTextExtent(label, NULL, &rectLabel.height); rectLabel.y = rect.y + (rect.height - rectLabel.height) / 2; // align label vertically with the bitmap - looks nicer like this rectLabel.y -= (rectLabel.height - heightBmp) % 2; // calc horz position if ( align == wxALIGN_RIGHT ) { xBmp = rect.GetRight() - bitmap.GetWidth(); rectLabel.x = rect.x + 3; rectLabel.SetRight(xBmp); } else // normal (checkbox to the left of the text) case { xBmp = rect.x; rectLabel.x = xBmp + bitmap.GetWidth() + 5; rectLabel.SetRight(rect.GetRight()); } dc.DrawBitmap(bitmap, xBmp, yBmp, true /* use mask */); DrawLabel(dc, label, rectLabel, flags, wxALIGN_LEFT | wxALIGN_TOP, indexAccel); }
//--------------------------------------------------------- void CDLG_Parameters::Set_Position(wxRect r) { if( m_pInfo && m_pInfo->IsShown() ) { r.SetWidth(r.GetWidth() / 2 - 4); m_pInfo->SetSize(r); r.SetLeft(r.GetRight() + 9); m_pControl->SetSize(r); } else { m_pControl->SetSize(r); } }
void wxNonOwnedWindow::DoRefreshRect(const wxRect& rect) { // don't overlap outside of the window (NB: 'rect' is in window coords): wxRect r(rect); r.Intersect(wxRect(GetSize())); if ( r.IsEmpty() ) return; wxLogTrace(TRACE_PAINT, "%p ('%s'): [TLW] refresh rect [%i,%i,%i,%i]", this, GetName().c_str(), rect.x, rect.y, rect.GetRight(), rect.GetBottom()); // defer painting until idle time or until Update() is called: m_toPaint->Add(rect); }
wxToolInfo(HWND hwndOwner, unsigned int id, const wxRect& rc) { // initialize all members ::ZeroMemory(this, sizeof(TOOLINFO)); // the structure TOOLINFO has been extended with a 4 byte field in // version 4.70 of comctl32.dll and another one in 5.01 but we don't // use these extended fields so use the old struct size to ensure that // the tooltips work on old (Windows 95) systems too cbSize = TTTOOLINFO_V1_SIZE; hwnd = hwndOwner; if (rc.IsEmpty()) { uFlags = TTF_IDISHWND; uId = (UINT_PTR)hwndOwner; } else { // this tooltip must be shown only if the mouse hovers a specific rect // of the hwnd parameter! rect.left = rc.GetLeft(); rect.right = rc.GetRight(); rect.top = rc.GetTop(); rect.bottom = rc.GetBottom(); // note that not setting TTF_IDISHWND from the uFlags member means that the // ti.uId field should not contain the HWND but rather as MSDN says an // "Application-defined identifier of the tool"; this is used internally by // Windows to distinguish the different tooltips attached to the same window uId = id; } // we use TTF_TRANSPARENT to fix a problem which arises at least with // the text controls but may presumably happen with other controls // which display the tooltip at mouse position: it can start flashing // then as the control gets "focus lost" events and dismisses the // tooltip which then reappears because mouse remains hovering over the // control, see SF patch 1821229 if ( wxApp::GetComCtl32Version() >= 470 ) { uFlags |= TTF_TRANSPARENT; } }
vector< wxRect > GetCoverage( const wxRect& viewport, const wxRect& canvas, const wxSize& gridSize ) { const wxRect clippedViewport( canvas.Intersect( viewport ) ); vector< wxRect > coverage; const int top = clippedViewport.GetTop() / gridSize.y; const int bottom = clippedViewport.GetBottom() / gridSize.y; const int left = clippedViewport.GetLeft() / gridSize.x; const int right = clippedViewport.GetRight() / gridSize.x; for( int y = top; y <= bottom; ++y ) { for( int x = left; x <= right; ++x ) { const wxRect candidate( x * gridSize.x, y * gridSize.y, gridSize.x, gridSize.y ); const wxRect clipped( canvas.Intersect( candidate ) ); coverage.push_back( clipped ); } } return coverage; }
void wxStdRenderer::DrawFocusRect(wxWindow* WXUNUSED(win), wxDC& dc, const wxRect& rect, int WXUNUSED(flags)) { // draw the pixels manually because the "dots" in wxPen with wxDOT style // may be short traits and not really dots // // note that to behave in the same manner as DrawRect(), we must exclude // the bottom and right borders from the rectangle wxCoord x1 = rect.GetLeft(), y1 = rect.GetTop(), x2 = rect.GetRight(), y2 = rect.GetBottom(); dc.SetPen(m_penBlack); // this seems to be closer than what Windows does than wxINVERT although // I'm still not sure if it's correct dc.SetLogicalFunction(wxAND_REVERSE); wxCoord z; for ( z = x1 + 1; z < x2; z += 2 ) dc.DrawPoint(z, rect.GetTop()); wxCoord shift = z == x2 ? 0 : 1; for ( z = y1 + shift; z < y2; z += 2 ) dc.DrawPoint(x2, z); shift = z == y2 ? 0 : 1; for ( z = x2 - shift; z > x1; z -= 2 ) dc.DrawPoint(z, y2); shift = z == x1 ? 0 : 1; for ( z = y2 - shift; z > y1; z -= 2 ) dc.DrawPoint(x1, z); dc.SetLogicalFunction(wxCOPY); }
void wxWindowDFB::PaintWindow(const wxRect& rect) { wxCHECK_RET( !IsFrozen() && IsShown(), "shouldn't be called" ); wxLogTrace(TRACE_PAINT, "%p ('%s'): painting region [%i,%i,%i,%i]", this, GetName().c_str(), rect.x, rect.y, rect.GetRight(), rect.GetBottom()); m_updateRegion = rect; // FIXME_DFB: don't waste time rendering the area if it's fully covered // by some children, go directly to rendering the children // (unless some child has HasTransparentBackground()=true!) // NB: unconditionally send wxEraseEvent, because our implementation of // wxWindow::Refresh() ignores the eraseBack argument wxWindowDC dc((wxWindow*)this); wxEraseEvent eventEr(m_windowId, &dc); eventEr.SetEventObject(this); HandleWindowEvent(eventEr); wxRect clientRect(GetClientRect()); // only send wxNcPaintEvent if drawing at least part of nonclient area: if ( !clientRect.Contains(rect) ) { wxNcPaintEvent eventNc(GetId()); eventNc.SetEventObject(this); HandleWindowEvent(eventNc); } else { wxLogTrace(TRACE_PAINT, "%p ('%s'): not sending wxNcPaintEvent", this, GetName().c_str()); } // only send wxPaintEvent if drawing at least part of client area: if ( rect.Intersects(clientRect) ) { wxPaintEvent eventPt(GetId()); eventPt.SetEventObject(this); HandleWindowEvent(eventPt); } else { wxLogTrace(TRACE_PAINT, "%p ('%s'): not sending wxPaintEvent", this, GetName().c_str()); } // draw window's overlays on top of the painted window, if we have any: PaintOverlays(rect); m_updateRegion.Clear(); // client area portion of 'rect': wxRect rectClientOnly(rect); rectClientOnly.Intersect(clientRect); // paint the children: wxPoint origin = GetClientAreaOrigin(); wxWindowList& children = GetChildren(); for ( wxWindowList::iterator i = children.begin(); i != children.end(); ++i ) { wxWindow *child = *i; if ( child->IsFrozen() || !child->IsShown() ) continue; // don't paint anything if the window is frozen or hidden // compute child's area to repaint wxRect childrect(child->GetRect()); childrect.Offset(origin); if ( child->CanBeOutsideClientArea() ) childrect.Intersect(rect); else childrect.Intersect(rectClientOnly); if ( childrect.IsEmpty() ) continue; // and repaint it: childrect.Offset(-child->GetPosition()); childrect.Offset(-origin); child->PaintWindow(childrect); } }
void wxTopLevelWindowBase::DoCentre(int dir) { // on some platforms centering top level windows is impossible // because they are always maximized by guidelines or limitations // // and centering a maximized window doesn't make sense as its position // can't change if ( IsAlwaysMaximized() || IsMaximized() ) return; // we need the display rect anyhow so store it first: notice that we should // be centered on the same display as our parent window, the display of // this window itself is not really defined yet int nDisplay = wxDisplay::GetFromWindow(GetParent() ? GetParent() : this); wxDisplay dpy(nDisplay == wxNOT_FOUND ? 0 : nDisplay); const wxRect rectDisplay(dpy.GetClientArea()); // what should we centre this window on? wxRect rectParent; if ( !(dir & wxCENTRE_ON_SCREEN) && GetParent() ) { // centre on parent window: notice that we need screen coordinates for // positioning this TLW rectParent = GetParent()->GetScreenRect(); // if the parent is entirely off screen (happens at least with MDI // parent frame under Mac but could happen elsewhere too if the frame // was hidden/moved away for some reason), don't use it as otherwise // this window wouldn't be visible at all if ( !rectParent.Intersects(rectDisplay) ) { // just centre on screen then rectParent = rectDisplay; } } else { // we were explicitly asked to centre this window on the entire screen // or if we have no parent anyhow and so can't centre on it rectParent = rectDisplay; } if ( !(dir & wxBOTH) ) dir |= wxBOTH; // if neither is specified, center in both directions // the new window rect candidate wxRect rect = GetRect().CentreIn(rectParent, dir & ~wxCENTRE_ON_SCREEN); // we don't want to place the window off screen if Centre() is called as // this is (almost?) never wanted and it would be very difficult to prevent // it from happening from the user code if we didn't check for it here if ( !rectDisplay.Contains(rect.GetTopLeft()) ) { // move the window just enough to make the corner visible int dx = rectDisplay.GetLeft() - rect.GetLeft(); int dy = rectDisplay.GetTop() - rect.GetTop(); rect.Offset(dx > 0 ? dx : 0, dy > 0 ? dy : 0); } if ( !rectDisplay.Contains(rect.GetBottomRight()) ) { // do the same for this corner too int dx = rectDisplay.GetRight() - rect.GetRight(); int dy = rectDisplay.GetBottom() - rect.GetBottom(); rect.Offset(dx < 0 ? dx : 0, dy < 0 ? dy : 0); } // the window top left and bottom right corner are both visible now and // although the window might still be not entirely on screen (with 2 // staggered displays for example) we wouldn't be able to improve the // layout much in such case, so we stop here // -1 could be valid coordinate here if there are several displays SetSize(rect, wxSIZE_ALLOW_MINUS_ONE); }
void wxSFGridShape::FitShapeToRect(wxSFShapeBase *shape, const wxRect& rct) { wxRect shapeBB = shape->GetBoundingBox(); wxRealPoint prevPos = shape->GetRelativePosition(); // do vertical alignment switch( shape->GetVAlign() ) { case valignTOP: shape->SetRelativePosition( prevPos.x, rct.GetTop() + shape->GetVBorder() ); break; case valignMIDDLE: shape->SetRelativePosition( prevPos.x, rct.GetTop() + (rct.GetHeight()/2 - shapeBB.GetHeight()/2) ); break; case valignBOTTOM: shape->SetRelativePosition( prevPos.x, rct.GetBottom() - shapeBB.GetHeight() - shape->GetVBorder() ); break; case valignEXPAND: if( shape->ContainsStyle( sfsSIZE_CHANGE ) ) { shape->SetRelativePosition( prevPos.x, rct.GetTop() + shape->GetVBorder() ); shape->Scale( 1.f, double(rct.GetHeight() - 2*shape->GetVBorder())/shapeBB.GetHeight() ); } break; default: shape->SetRelativePosition( prevPos.x, rct.GetTop() ); break; } prevPos = shape->GetRelativePosition(); // do horizontal alignment switch( shape->GetHAlign() ) { case halignLEFT: shape->SetRelativePosition( rct.GetLeft() + shape->GetHBorder(), prevPos.y ); break; case halignCENTER: shape->SetRelativePosition( rct.GetLeft() + (rct.GetWidth()/2 - shapeBB.GetWidth()/2), prevPos.y ); break; case halignRIGHT: shape->SetRelativePosition( rct.GetRight() - shapeBB.GetWidth() - shape->GetHBorder(), prevPos.y ); break; case halignEXPAND: if( shape->ContainsStyle( sfsSIZE_CHANGE ) ) { shape->SetRelativePosition( rct.GetLeft() + shape->GetHBorder(), prevPos.y ); shape->Scale( double(rct.GetWidth() - 2*shape->GetHBorder())/shapeBB.GetWidth(), 1.f ); } break; default: shape->SetRelativePosition( rct.GetLeft(), prevPos.y ); break; } }