//---------------------------------------------------------
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;
}
}
