void cbBarHintsPlugin::DrawGrooves( wxDC& dc, const wxPoint& pos, int length )
{
int ofs = 0;
int i;
for ( i = 0; i != mGrooveCount; ++i, ofs += ( GROOVE_WIDTH + GROOVE_TO_GROOVE_GAP ) )
{
if ( mpPane->IsHorizontal() )
{
dc.SetPen( mpLayout->mLightPen );
dc.DrawLine( pos.x + ofs, pos.y, pos.x + ofs, pos.y + length - 1 );
dc.DrawPoint( pos.x + ofs + 1, pos.y );
dc.SetPen( mpLayout->mDarkPen );
dc.DrawLine( pos.x + ofs + 2, pos.y, pos.x + ofs + 2, pos.y + length );
dc.DrawPoint( pos.x + ofs + 1, pos.y + length - 1 );
dc.DrawPoint( pos.x + ofs, pos.y + length - 1 );
}
else
{
dc.SetPen( mpLayout->mLightPen );
dc.DrawLine( pos.x, pos.y + ofs, pos.x + length - 1, pos.y + ofs );
dc.DrawPoint( pos.x, pos.y + ofs + 1 );
dc.SetPen( mpLayout->mDarkPen );
dc.DrawLine( pos.x, pos.y + ofs + 2, pos.x + length, pos.y + ofs + 2 );
dc.DrawPoint( pos.x + length - 1, pos.y + ofs + 1 );
dc.DrawPoint( pos.x + length - 1, pos.y + ofs );
}
}
}
//
// 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 cbRowDragPlugin::Draw3DPattern( wxRect& inRect, wxDC& dc )
{
for( int y = inRect.y; y < inRect.y + inRect.height; y+=3 )
for( int x = inRect.x; x < inRect.x + inRect.width; x+=3 )
{
dc.SetPen( mpLayout->mLightPen );
dc.DrawPoint( x,y );
dc.SetPen( mpLayout->mBlackPen );
dc.DrawPoint( x+1, y+1 );
}
}
void gray_out_image_on_dc( wxDC& dc, int width, int height )
{
// assuming the pixels along the edges are of the background color
wxColour bgCol;
dc.GetPixel( 0, 0, &bgCol );
wxPen darkPen ( wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW),1, wxSOLID );
wxPen lightPen( wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT),1, wxSOLID );
wxPen bgPen ( bgCol, 1, wxSOLID );
int* src = create_array( width, height, MASK_BG );
int* dest = create_array( width, height, MASK_BG );
int x, y;
for ( y = 0; y != height; ++y )
{
for ( x = 0; x != width; ++x )
{
wxColour col;
dc.GetPixel( x,y, &col );
GET_ELEM(src,x,y) = MAKE_INT_COLOR( col.Red(), col.Green(), col.Blue() );
}
}
gray_out_pixmap( src, dest, width, height );
for ( y = 0; y != height; ++y )
{
for ( x = 0; x != width; ++x )
{
int mask = GET_ELEM(dest,x,y);
switch (mask)
{
case MASK_BG : { dc.SetPen( bgPen );
dc.DrawPoint( x,y ); break;
}
case MASK_DARK : { dc.SetPen( darkPen );
dc.DrawPoint( x,y ); break;
}
case MASK_LIGHT : { dc.SetPen( lightPen );
dc.DrawPoint( x,y ); break;
}
default : break;
}
}
}
delete [] src;
delete [] dest;
}
void wxAuiDefaultDockArt::DrawGripper(wxDC& dc, wxWindow *WXUNUSED(window),
const wxRect& rect,
wxAuiPaneInfo& pane)
{
dc.SetPen(*wxTRANSPARENT_PEN);
dc.SetBrush(m_gripperBrush);
dc.DrawRectangle(rect.x, rect.y, rect.width,rect.height);
if (!pane.HasGripperTop())
{
int y = 5;
while (1)
{
dc.SetPen(m_gripperPen1);
dc.DrawPoint(rect.x+3, rect.y+y);
dc.SetPen(m_gripperPen2);
dc.DrawPoint(rect.x+3, rect.y+y+1);
dc.DrawPoint(rect.x+4, rect.y+y);
dc.SetPen(m_gripperPen3);
dc.DrawPoint(rect.x+5, rect.y+y+1);
dc.DrawPoint(rect.x+5, rect.y+y+2);
dc.DrawPoint(rect.x+4, rect.y+y+2);
y += 4;
if (y > rect.GetHeight()-5)
break;
}
}
else
{
int x = 5;
while (1)
{
dc.SetPen(m_gripperPen1);
dc.DrawPoint(rect.x+x, rect.y+3);
dc.SetPen(m_gripperPen2);
dc.DrawPoint(rect.x+x+1, rect.y+3);
dc.DrawPoint(rect.x+x, rect.y+4);
dc.SetPen(m_gripperPen3);
dc.DrawPoint(rect.x+x+1, rect.y+5);
dc.DrawPoint(rect.x+x+2, rect.y+5);
dc.DrawPoint(rect.x+x+2, rect.y+4);
x += 4;
if (x > rect.GetWidth()-5)
break;
}
}
}
//
// Draw a line while accounting for differences in wxWidgets versions
//
void AColor::Line(wxDC & dc, wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
{
// As of 2.8.9 (possibly earlier), wxDC::DrawLine() on the Mac draws the
// last point since it is now based on the NEW wxGraphicsContext system.
// Make the other platforms do the same thing since the other platforms
// "may" follow they get wxGraphicsContext going.
#if defined(__WXMAC__) || defined(__WXGTK3__)
dc.DrawLine(x1, y1, x2, y2);
#else
bool point = false;
if (x1 == x2) {
if (y1 < y2) {
y2++;
}
else if (y2 < y1) {
y1++;
}
else {
point = true;
}
}
else if (y1 == y2) {
if (x1 < x2) {
x2++;
}
else if (x2 < x1) {
x1++;
}
else {
point = true;
}
}
else {
dc.DrawPoint(x2, y2);
}
if (point) {
dc.DrawPoint(x2, y2);
}
else {
dc.DrawLine(x1, y1, x2, y2);
}
#endif
}
void SeqPlot::drawDottedLine ( wxDC &dc , int x1 , int y1 , int x2 , int y2 )
{
if ( can->isPrinting() )
{
dc.DrawLine ( x1 , y1 , x2 , y2 ) ;
return ;
}
int i ;
if ( x1 == x2 )
{
for ( i = y1 ; i <= y2 ; i++ )
if ( i & 1 ) dc.DrawPoint ( x1 , i ) ;
}
else
{
for ( i = x1 ; i <= x2 ; i++ )
if ( i & 1 ) dc.DrawPoint ( i , y1 ) ;
}
}
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 SeqPlot::myRect ( wxDC &dc , int x , int y , int w , int h )
{
if ( can->isPrinting() )
{
for ( int i = 0 ; i <= h ; i++ )
dc.DrawLine ( x , y+i , x+w , y+i ) ;
return ;
}
for ( int i = 0 ; i < w ; i++ )
{
for ( int j = 0 ; j < h ; j++ )
{
if ( ( x+i + y+j ) & 1 ) dc.DrawPoint ( x + i , y + j ) ;
}
}
}
void LifeCanvas::DrawCell(wxInt32 i, wxInt32 j, wxDC &dc)
{
wxCoord x = CellToX(i);
wxCoord y = CellToY(j);
// if cellsize is 1 or 2, there will be no grid
switch (m_cellsize)
{
case 1:
dc.DrawPoint(x, y);
break;
case 2:
dc.DrawRectangle(x, y, 2, 2);
break;
default:
dc.DrawRectangle(x + 1, y + 1, m_cellsize - 1, m_cellsize - 1);
}
}
void wxTabControl::OnDraw(wxDC& dc, bool lastInRow)
{
// Old, but in some ways better (drawing opaque tabs)
#ifndef wxUSE_NEW_METHOD
if (!m_view)
return;
// Top-left of tab view area
int viewX = m_view->GetViewRect().x;
int viewY = m_view->GetViewRect().y;
// Top-left of tab control
int tabX = GetX() + viewX;
int tabY = GetY() + viewY;
int tabHeightInc = 0;
if (m_isSelected)
{
tabHeightInc = (m_view->GetTabSelectionHeight() - m_view->GetTabHeight());
tabY -= tabHeightInc;
}
dc.SetPen(*wxTRANSPARENT_PEN);
// Draw grey background
if (m_view->GetTabStyle() & wxTAB_STYLE_COLOUR_INTERIOR)
{
if(m_view->GetBackgroundBrush())
dc.SetBrush(*m_view->GetBackgroundBrush());
// Add 1 because the pen is transparent. Under Motif, may be different.
#ifdef __WXMOTIF__
dc.DrawRectangle(tabX, tabY, (GetWidth()+1), (GetHeight() + tabHeightInc));
#else
dc.DrawRectangle(tabX, tabY, (GetWidth()+1), (GetHeight() + 1 + tabHeightInc));
#endif
}
// Draw highlight and shadow
dc.SetPen(*m_view->GetHighlightPen());
// Calculate the top of the tab beneath. It's the height of the tab, MINUS
// a bit if the tab below happens to be selected. Check.
wxTabControl *tabBeneath = NULL;
int subtractThis = 0;
if (GetColPosition() > 0)
tabBeneath = m_view->FindTabControlForPosition(GetColPosition() - 1, GetRowPosition());
if (tabBeneath && tabBeneath->IsSelected())
subtractThis = (m_view->GetTabSelectionHeight() - m_view->GetTabHeight());
// Vertical highlight: if first tab, draw to bottom of view
if (tabX == m_view->GetViewRect().x && (m_view->GetTabStyle() & wxTAB_STYLE_DRAW_BOX))
dc.DrawLine(tabX, tabY, tabX, (m_view->GetViewRect().y + m_view->GetViewRect().height));
else if (tabX == m_view->GetViewRect().x)
// Not box drawing, just to top of view.
dc.DrawLine(tabX, tabY, tabX, (m_view->GetViewRect().y));
else
dc.DrawLine(tabX, tabY, tabX, (tabY + GetHeight() + tabHeightInc - subtractThis));
dc.DrawLine(tabX, tabY, (tabX + GetWidth()), tabY);
dc.SetPen(*m_view->GetShadowPen());
// Test if we're outside the right-hand edge of the view area
if (((tabX + GetWidth()) >= m_view->GetViewRect().x + m_view->GetViewRect().width) && (m_view->GetTabStyle() & wxTAB_STYLE_DRAW_BOX))
{
int bottomY = m_view->GetViewRect().y + m_view->GetViewRect().height + GetY() + m_view->GetTabHeight() + m_view->GetTopMargin();
// Add a tab height since we wish to draw to the bottom of the view.
dc.DrawLine((tabX + GetWidth()), tabY,
(tabX + GetWidth()), bottomY);
// Calculate the far-right of the view, since we don't wish to
// draw inside that
int rightOfView = m_view->GetViewRect().x + m_view->GetViewRect().width + 1;
// Draw the horizontal bit to connect to the view rectangle
dc.DrawLine((wxMax((tabX + GetWidth() - m_view->GetHorizontalTabOffset()), rightOfView)), (bottomY-1),
(tabX + GetWidth()), (bottomY-1));
// Draw black line to emphasize shadow
dc.SetPen(*wxBLACK_PEN);
dc.DrawLine((tabX + GetWidth() + 1), (tabY+1),
(tabX + GetWidth() + 1), bottomY);
// Draw the horizontal bit to connect to the view rectangle
dc.DrawLine((wxMax((tabX + GetWidth() - m_view->GetHorizontalTabOffset()), rightOfView)), (bottomY),
(tabX + GetWidth() + 1), (bottomY));
}
else
{
if (lastInRow)
{
// 25/5/97 UNLESS it's less than the max number of positions in this row
int topY = m_view->GetViewRect().y - m_view->GetTopMargin();
int maxPositions = ((wxTabLayer *)m_view->GetLayers().Item(0)->GetData())->GetCount();
// Only down to the bottom of the tab, not to the top of the view
if ( GetRowPosition() < (maxPositions - 1) )
topY = tabY + GetHeight() + tabHeightInc;
#ifdef __WXMOTIF__
topY -= 1;
#endif
// Shadow
dc.DrawLine((tabX + GetWidth()), tabY, (tabX + GetWidth()), topY);
// Draw black line to emphasize shadow
dc.SetPen(*wxBLACK_PEN);
dc.DrawLine((tabX + GetWidth() + 1), (tabY+1), (tabX + GetWidth() + 1),
topY);
}
else
{
// Calculate the top of the tab beneath. It's the height of the tab, MINUS
// a bit if the tab below (and next col along) happens to be selected. Check.
wxTabControl *tabBeneath = NULL;
int subtractThis = 0;
if (GetColPosition() > 0)
tabBeneath = m_view->FindTabControlForPosition(GetColPosition() - 1, GetRowPosition() + 1);
if (tabBeneath && tabBeneath->IsSelected())
subtractThis = (m_view->GetTabSelectionHeight() - m_view->GetTabHeight());
#ifdef __WXMOTIF__
subtractThis += 1;
#endif
// Draw only to next tab down.
dc.DrawLine((tabX + GetWidth()), tabY,
(tabX + GetWidth()), (tabY + GetHeight() + tabHeightInc - subtractThis));
// Draw black line to emphasize shadow
dc.SetPen(*wxBLACK_PEN);
dc.DrawLine((tabX + GetWidth() + 1), (tabY+1), (tabX + GetWidth() + 1),
(tabY + GetHeight() + tabHeightInc - subtractThis));
}
}
// Draw centered text
int textY = tabY + m_view->GetVerticalTabTextSpacing() + tabHeightInc;
if (m_isSelected)
dc.SetFont(* m_view->GetSelectedTabFont());
else
dc.SetFont(* GetFont());
wxColour col(m_view->GetTextColour());
dc.SetTextForeground(col);
dc.SetBackgroundMode(wxTRANSPARENT);
wxCoord textWidth, textHeight;
dc.GetTextExtent(GetLabel(), &textWidth, &textHeight);
int textX = (int)(tabX + (GetWidth() - textWidth)/2.0);
if (textX < (tabX + 2))
textX = (tabX + 2);
dc.SetClippingRegion(tabX, tabY, GetWidth(), GetHeight());
dc.DrawText(GetLabel(), textX, textY);
dc.DestroyClippingRegion();
if (m_isSelected)
{
dc.SetPen(*m_view->GetHighlightPen());
// Draw white highlight from the tab's left side to the left hand edge of the view
dc.DrawLine(m_view->GetViewRect().x, (tabY + GetHeight() + tabHeightInc),
tabX, (tabY + GetHeight() + tabHeightInc));
// Draw white highlight from the tab's right side to the right hand edge of the view
dc.DrawLine((tabX + GetWidth()), (tabY + GetHeight() + tabHeightInc),
m_view->GetViewRect().x + m_view->GetViewRect().width, (tabY + GetHeight() + tabHeightInc));
}
#else
// New HEL version with rounder tabs
if (!m_view) return;
int tabInc = 0;
if (m_isSelected)
{
tabInc = m_view->GetTabSelectionHeight() - m_view->GetTabHeight();
}
int tabLeft = GetX() + m_view->GetViewRect().x;
int tabTop = GetY() + m_view->GetViewRect().y - tabInc;
int tabRight = tabLeft + m_view->GetTabWidth();
int left = m_view->GetViewRect().x;
int top = tabTop + m_view->GetTabHeight() + tabInc;
int right = left + m_view->GetViewRect().width;
int bottom = top + m_view->GetViewRect().height;
if (m_isSelected)
{
// TAB is selected - draw TAB and the View's full outline
dc.SetPen(*(m_view->GetHighlightPen()));
wxPoint pnts[10];
int n = 0;
pnts[n].x = left; pnts[n++].y = bottom;
pnts[n].x = left; pnts[n++].y = top;
pnts[n].x = tabLeft; pnts[n++].y = top;
pnts[n].x = tabLeft; pnts[n++].y = tabTop + 2;
pnts[n].x = tabLeft + 2; pnts[n++].y = tabTop;
pnts[n].x = tabRight - 1; pnts[n++].y = tabTop;
dc.DrawLines(n, pnts);
if (!lastInRow)
{
dc.DrawLine(
(tabRight + 2),
top,
right,
top
);
}
dc.SetPen(*(m_view->GetShadowPen()));
dc.DrawLine(
tabRight,
tabTop + 2,
tabRight,
top
);
dc.DrawLine(
right,
top,
right,
bottom
);
dc.DrawLine(
right,
bottom,
left,
bottom
);
dc.SetPen(*wxBLACK_PEN);
dc.DrawPoint(
tabRight,
tabTop + 1
);
dc.DrawPoint(
tabRight + 1,
tabTop + 2
);
if (lastInRow)
{
dc.DrawLine(
tabRight + 1,
bottom,
tabRight + 1,
tabTop + 1
);
}
else
{
dc.DrawLine(
tabRight + 1,
tabTop + 2,
tabRight + 1,
top
);
dc.DrawLine(
right + 1,
top,
right + 1,
bottom + 1
);
}
dc.DrawLine(
right + 1,
bottom + 1,
left + 1,
bottom + 1
);
}
else
{
// TAB is not selected - just draw TAB outline and RH edge
// if the TAB is the last in the row
int maxPositions = ((wxTabLayer*)m_view->GetLayers().Item(0)->GetData())->GetCount();
wxTabControl* tabBelow = 0;
wxTabControl* tabBelowRight = 0;
if (GetColPosition() > 0)
{
tabBelow = m_view->FindTabControlForPosition(
GetColPosition() - 1,
GetRowPosition()
);
}
if (!lastInRow && GetColPosition() > 0)
{
tabBelowRight = m_view->FindTabControlForPosition(
GetColPosition() - 1,
GetRowPosition() + 1
);
}
float raisedTop = top - m_view->GetTabSelectionHeight() +
m_view->GetTabHeight();
dc.SetPen(*(m_view->GetHighlightPen()));
wxPoint pnts[10];
int n = 0;
pnts[n].x = tabLeft;
if (tabBelow && tabBelow->IsSelected())
{
pnts[n++].y = (long)raisedTop;
}
else
{
pnts[n++].y = top;
}
pnts[n].x = tabLeft; pnts[n++].y = tabTop + 2;
pnts[n].x = tabLeft + 2; pnts[n++].y = tabTop;
pnts[n].x = tabRight - 1; pnts[n++].y = tabTop;
dc.DrawLines(n, pnts);
dc.SetPen(*(m_view->GetShadowPen()));
if (GetRowPosition() >= maxPositions - 1)
{
dc.DrawLine(
tabRight,
(tabTop + 2),
tabRight,
bottom
);
dc.DrawLine(
tabRight,
bottom,
(tabRight - m_view->GetHorizontalTabOffset()),
bottom
);
}
else
{
if (tabBelowRight && tabBelowRight->IsSelected())
{
dc.DrawLine(
tabRight,
(long)raisedTop,
tabRight,
tabTop + 1
);
}
else
{
dc.DrawLine(
tabRight,
top - 1,
tabRight,
tabTop + 1
);
}
}
dc.SetPen(*wxBLACK_PEN);
dc.DrawPoint(
tabRight,
tabTop + 1
);
dc.DrawPoint(
tabRight + 1,
tabTop + 2
);
if (GetRowPosition() >= maxPositions - 1)
{
// draw right hand edge to bottom of view
dc.DrawLine(
tabRight + 1,
bottom + 1,
tabRight + 1,
tabTop + 2
);
dc.DrawLine(
tabRight + 1,
bottom + 1,
(tabRight - m_view->GetHorizontalTabOffset()),
bottom + 1
);
}
else
{
// draw right hand edge of TAB
if (tabBelowRight && tabBelowRight->IsSelected())
{
dc.DrawLine(
tabRight + 1,
(long)(raisedTop - 1),
tabRight + 1,
tabTop + 2
);
}
else
{
dc.DrawLine(
tabRight + 1,
top - 1,
tabRight + 1,
tabTop + 2
);
}
}
}
// Draw centered text
dc.SetPen(*wxBLACK_PEN);
if (m_isSelected)
{
dc.SetFont(*(m_view->GetSelectedTabFont()));
}
else
{
dc.SetFont(*(GetFont()));
}
wxColour col(m_view->GetTextColour());
dc.SetTextForeground(col);
dc.SetBackgroundMode(wxTRANSPARENT);
long textWidth, textHeight;
dc.GetTextExtent(GetLabel(), &textWidth, &textHeight);
float textX = (tabLeft + tabRight - textWidth) / 2;
float textY = (tabInc + tabTop + m_view->GetVerticalTabTextSpacing());
dc.DrawText(GetLabel(), (long)textX, (long)textY);
#endif
}
bool SjOscStar::Draw(wxDC& dc, const wxSize& clientSize, double rot, wxPen& pen, wxBrush& brush)
{
double xfloat, yfloat;
int x, y, hh, vv;
int d, intensity;
m_z -= 2;
if( m_z < -63 )
{
m_z = STAR_DEPTH;
m_doDraw = !m_exitRequest;
}
hh = (m_x*64)/(64+m_z);
vv = (m_y*64)/(64+m_z);
// check position
x = hh + 500;
y = vv + 500;
if( x < -300 || x > 1300 || y < -300 || y > 1300 )
{
m_z = STAR_DEPTH;
m_doDraw = !m_exitRequest;
hh = (m_x*64)/(64+m_z);
vv = (m_y*64)/(64+m_z);
}
// calculate position
xfloat = (hh*cos(rot))-(vv*sin(rot));
yfloat = (hh*sin(rot))+(vv*cos(rot));
x = (int)xfloat + 500;
y = (int)yfloat + 500;
// use star?
if( !m_doDraw )
{
if( m_exitRequest || x < 450 || x > 550 || y < 450 || y > 550 )
{
return FALSE;
}
else
{
m_doDraw = TRUE;
}
}
// map star position to client size, keep aspect ratio
d = clientSize.x;
if( clientSize.y > d )
{
d = clientSize.y;
}
if( d == 0 )
{
d = 10;
}
x = (x * d) / 1000 - (d-clientSize.x)/2;
y = (y * d) / 1000 - (d-clientSize.y)/2;
// calculate size
d = (STAR_DEPTH-m_z) / (38400/d);
if( d == 0 ) d = 1;
// calculate light intensity
intensity = STAR_DEPTH-m_z;
intensity = 55 + ((intensity * 200) / STAR_DEPTH);
//if( intensity < light ) intensity = light + 10;
if( intensity < 0 ) intensity = 0;
if( intensity > 255 ) intensity = 255;
// draw star
if( d==1 )
{
pen.SetColour(intensity, intensity, intensity);
dc.SetPen(pen);
dc.DrawPoint(x, y);
}
else
{
dc.SetPen(*wxTRANSPARENT_PEN);
brush.SetColour(intensity, intensity, intensity);
dc.SetBrush(brush);
dc.DrawRectangle(x, y, d, d);
}
return TRUE;
}
// Define the repainting behaviour
void MyCanvas::OnDraw(wxDC& dc)
{
// vars to use ...
#if wxUSE_STATUSBAR
wxString s;
#endif // wxUSE_STATUSBAR
wxPen wP;
wxBrush wB;
wxPoint points[6];
wxColour wC;
wxFont wF;
dc.SetFont(*wxSWISS_FONT);
dc.SetPen(*wxGREEN_PEN);
switch (m_index)
{
default:
case 0:
// draw lines to make a cross
dc.DrawLine(0, 0, 200, 200);
dc.DrawLine(200, 0, 0, 200);
// draw point colored line and spline
wP = *wxCYAN_PEN;
wP.SetWidth(3);
dc.SetPen(wP);
dc.DrawPoint (25,15);
dc.DrawLine(50, 30, 200, 30);
dc.DrawSpline(50, 200, 50, 100, 200, 10);
#if wxUSE_STATUSBAR
s = wxT("Green Cross, Cyan Line and spline");
#endif // wxUSE_STATUSBAR
break;
case 1:
// draw standard shapes
dc.SetBrush(*wxCYAN_BRUSH);
dc.SetPen(*wxRED_PEN);
dc.DrawRectangle(10, 10, 100, 70);
wB = wxBrush (wxT("DARK ORCHID"), wxBRUSHSTYLE_TRANSPARENT);
dc.SetBrush (wB);
dc.DrawRoundedRectangle(50, 50, 100, 70, 20);
dc.SetBrush (wxBrush(wxT("GOLDENROD")) );
dc.DrawEllipse(100, 100, 100, 50);
points[0].x = 100; points[0].y = 200;
points[1].x = 70; points[1].y = 260;
points[2].x = 160; points[2].y = 230;
points[3].x = 40; points[3].y = 230;
points[4].x = 130; points[4].y = 260;
points[5].x = 100; points[5].y = 200;
dc.DrawPolygon(5, points);
dc.DrawLines (6, points, 160);
#if wxUSE_STATUSBAR
s = wxT("Blue rectangle, red edge, clear rounded rectangle, gold ellipse, gold and clear stars");
#endif // wxUSE_STATUSBAR
break;
case 2:
// draw text in Arial or similar font
dc.DrawLine(50,25,50,35);
dc.DrawLine(45,30,55,30);
dc.DrawText(wxT("This is a Swiss-style string"), 50, 30);
wC = dc.GetTextForeground();
dc.SetTextForeground (wxT("FIREBRICK"));
// no effect in msw ??
dc.SetTextBackground (wxT("WHEAT"));
dc.DrawText(wxT("This is a Red string"), 50, 200);
dc.DrawRotatedText(wxT("This is a 45 deg string"), 50, 200, 45);
dc.DrawRotatedText(wxT("This is a 90 deg string"), 50, 200, 90);
wF = wxFont ( 18, wxROMAN, wxITALIC, wxBOLD, false, wxT("Times New Roman"));
dc.SetFont(wF);
dc.SetTextForeground (wC);
dc.DrawText(wxT("This is a Times-style string"), 50, 60);
#if wxUSE_STATUSBAR
s = wxT("Swiss, Times text; red text, rotated and colored orange");
#endif // wxUSE_STATUSBAR
break;
case 3 :
// four arcs start and end points, center
dc.SetBrush(*wxGREEN_BRUSH);
dc.DrawArc ( 200,300, 370,230, 300,300 );
dc.SetBrush(*wxBLUE_BRUSH);
dc.DrawArc ( 270-50, 270-86, 270-86, 270-50, 270,270 );
dc.SetDeviceOrigin(-10,-10);
dc.DrawArc ( 270-50, 270-86, 270-86, 270-50, 270,270 );
dc.SetDeviceOrigin(0,0);
wP.SetColour (wxT("CADET BLUE"));
dc.SetPen(wP);
dc.DrawArc ( 75,125, 110, 40, 75, 75 );
wP.SetColour (wxT("SALMON"));
dc.SetPen(wP);
dc.SetBrush(*wxRED_BRUSH);
//top left corner, width and height, start and end angle
// 315 same center and x-radius as last pie-arc, half Y radius
dc.DrawEllipticArc(25,50,100,50,180.0,45.0);
wP = *wxCYAN_PEN;
wP.SetWidth(3);
dc.SetPen(wP);
//wxTRANSPARENT));
dc.SetBrush (wxBrush (wxT("SALMON")));
dc.DrawEllipticArc(300, 0,200,100, 0.0,145.0);
//same end point
dc.DrawEllipticArc(300, 50,200,100,90.0,145.0);
dc.DrawEllipticArc(300,100,200,100,90.0,345.0);
#if wxUSE_STATUSBAR
s = wxT("This is an arc test page");
#endif // wxUSE_STATUSBAR
break;
case 4:
dc.DrawCheckMark ( 30,30,25,25);
dc.SetBrush (wxBrush (wxT("SALMON"),wxBRUSHSTYLE_TRANSPARENT));
dc.DrawCheckMark ( 80,50,75,75);
dc.DrawRectangle ( 80,50,75,75);
#if wxUSE_STATUSBAR
s = wxT("Two check marks");
#endif // wxUSE_STATUSBAR
break;
case 5:
wF = wxFont ( 18, wxROMAN, wxITALIC, wxBOLD, false, wxT("Times New Roman"));
dc.SetFont(wF);
dc.DrawLine(0, 0, 200, 200);
dc.DrawLine(200, 0, 0, 200);
dc.DrawText(wxT("This is an 18pt string"), 50, 60);
// rescale and draw in blue
wP = *wxCYAN_PEN;
dc.SetPen(wP);
dc.SetUserScale (2.0,0.5);
dc.SetDeviceOrigin(200,0);
dc.DrawLine(0, 0, 200, 200);
dc.DrawLine(200, 0, 0, 200);
dc.DrawText(wxT("This is an 18pt string 2 x 0.5 UserScaled"), 50, 60);
dc.SetUserScale (2.0,2.0);
dc.SetDeviceOrigin(200,200);
dc.DrawText(wxT("This is an 18pt string 2 x 2 UserScaled"), 50, 60);
wP = *wxRED_PEN;
dc.SetPen(wP);
dc.SetUserScale (1.0,1.0);
dc.SetDeviceOrigin(0,10);
dc.SetMapMode (wxMM_METRIC); //svg ignores this
dc.DrawLine(0, 0, 200, 200);
dc.DrawLine(200, 0, 0, 200);
dc.DrawText(wxT("This is an 18pt string in MapMode"), 50, 60);
#if wxUSE_STATUSBAR
s = wxT("Scaling test page");
#endif // wxUSE_STATUSBAR
break;
case 6:
dc.DrawIcon( wxICON(sample), 10, 10 );
dc.DrawBitmap ( wxBitmap(svgbitmap_xpm), 50,15);
#if wxUSE_STATUSBAR
s = wxT("Icon and Bitmap ");
#endif // wxUSE_STATUSBAR
break;
case 7:
dc.SetTextForeground(wxT("RED"));
dc.DrawText(wxT("Red = Clipping Off"), 30, 5);
dc.SetTextForeground(wxT("GREEN"));
dc.DrawText(wxT("Green = Clipping On"), 30, 25);
dc.SetTextForeground(wxT("BLACK"));
dc.SetPen(*wxRED_PEN);
dc.SetBrush (wxBrush (wxT("SALMON"),wxBRUSHSTYLE_TRANSPARENT));
dc.DrawCheckMark ( 80,50,75,75);
dc.DrawRectangle ( 80,50,75,75);
dc.SetPen(*wxGREEN_PEN);
// Clipped checkmarks
dc.DrawRectangle(180,50,75,75);
dc.SetClippingRegion(180,50,75,75); // x,y,width,height version
dc.DrawCheckMark ( 180,50,75,75);
dc.DestroyClippingRegion();
dc.DrawRectangle(wxRect(80,150,75,75));
dc.SetClippingRegion(wxPoint(80,150),wxSize(75,75)); // pt,size version
dc.DrawCheckMark ( 80,150,75,75);
dc.DestroyClippingRegion();
dc.DrawRectangle(wxRect(180,150,75,75));
dc.SetClippingRegion(wxRect(180,150,75,75)); // rect version
dc.DrawCheckMark ( 180,150,75,75);
dc.DestroyClippingRegion();
dc.DrawRectangle(wxRect( 80,250,50,65));
dc.DrawRectangle(wxRect(105,260,50,65));
dc.SetClippingRegion(wxRect( 80,250,50,65)); // second call to SetClippingRegion
dc.SetClippingRegion(wxRect(105,260,50,65)); // forms intersection with previous
dc.DrawCheckMark(80,250,75,75);
dc.DestroyClippingRegion(); // only one call to destroy (there's no stack)
/*
** Clipping by wxRegion not implemented for SVG. Should be
** possible, but need to access points that define the wxRegion
** from inside DoSetDeviceClippingRegion() and wxRegion does not
** implement anything like getPoints().
points[0].x = 180; points[0].y = 250;
points[1].x = 255; points[1].y = 250;
points[2].x = 180; points[2].y = 325;
points[3].x = 255; points[3].y = 325;
points[4].x = 180; points[4].y = 250;
dc.DrawLines (5, points);
wxRegion reg = wxRegion(5,points);
dc.SetClippingRegion(reg);
dc.DrawCheckMark ( 180,250,75,75);
dc.DestroyClippingRegion();
*/
#if wxUSE_STATUSBAR
s = wxT("Clipping region");
#endif // wxUSE_STATUSBAR
break;
case 8:
wxString txtStr;
wxCoord txtX, txtY, txtW, txtH, txtDescent, txtEL;
wxCoord txtPad = 0;
wP = *wxRED_PEN;
dc.SetPen(wP);
//dc.SetBackgroundMode(wxBRUSHSTYLE_SOLID);
//dc.SetTextBackground(*wxBLUE);
// Horizontal text
txtStr = wxT("Horizontal string");
dc.GetTextExtent(txtStr, &txtW, &txtH, &txtDescent, &txtEL);
txtX = 50;
txtY = 300;
dc.DrawRectangle(txtX, txtY, txtW + 2*txtPad, txtH + 2*txtPad);
dc.DrawText(txtStr, txtX + txtPad, txtY + txtPad);
// Vertical text
txtStr = wxT("Vertical string");
dc.GetTextExtent(txtStr, &txtW, &txtH, &txtDescent, &txtEL);
txtX = 50;
txtY = 250;
dc.DrawRectangle(txtX, txtY - (txtW + 2*txtPad), txtH + 2*txtPad, txtW + 2*txtPad);
dc.DrawRotatedText(txtStr, txtX + txtPad, txtY - txtPad, 90);
// 45 degree text
txtStr = wxT("45 deg string");
dc.GetTextExtent(txtStr, &txtW, &txtH, &txtDescent, &txtEL);
double lenW = (double)(txtW + 2*txtPad) / sqrt(2.0);
double lenH = (double)(txtH + 2*txtPad) / sqrt(2.0);
double padding = (double)txtPad / sqrt(2.0);
txtX = 150;
txtY = 200;
dc.DrawLine(txtX - padding, txtY, txtX + lenW, txtY - lenW); // top
dc.DrawLine(txtX + lenW, txtY - lenW, txtX - padding + lenH + lenW, txtY + (lenH - lenW));
dc.DrawLine(txtX - padding, txtY, txtX - padding + lenH, txtY + lenH);
dc.DrawLine(txtX - padding + lenH, txtY + lenH, txtX - padding + lenH + lenW, txtY + (lenH - lenW)); // bottom
dc.DrawRotatedText(txtStr, txtX, txtY, 45);
#if wxUSE_STATUSBAR
s = wxT("Text position test page");
#endif // wxUSE_STATUSBAR
break;
}
#if wxUSE_STATUSBAR
m_child->SetStatusText(s);
#endif // wxUSE_STATUSBAR
}
//void simple_vector_layer::Draw(wxDC &dc, wxCoord x, wxCoord y, bool transparent, double zoomFactor, double translationX, double translationY, double resolution) const
void simple_vector_layer::draw(wxDC &dc, wxCoord x, wxCoord y, bool transparent) const
{
wxPen pen;
wxBrush brush;
// 2D
pen.SetWidth(m_polygon_border_width);
pen.SetColour(m_polygon_border_color);
pen.SetStyle(m_polygon_border_style);
brush.SetColour(m_polygon_inner_color);
brush.SetStyle(m_polygon_inner_style);
dc.SetPen(pen);
dc.SetBrush(brush);
for (unsigned int i = 0; i < m_circles.size(); i++)
{
wxPoint p = transform().from_local_int(m_circles[i]);
wxCoord r = static_cast<wxCoord>(m_circles[i].radius / transform().zoom_factor());
dc.DrawCircle(p, r);
}
// Ellipses alignees
for (unsigned int i=0;i<m_ellipses.size();++i)
{
wxPoint p = transform().from_local_int(m_ellipses[i]);
wxSize s(
static_cast<wxCoord>(2*m_ellipses[i].a/transform().zoom_factor()),
static_cast<wxCoord>(2*m_ellipses[i].b/transform().zoom_factor())
);
dc.DrawEllipse(p,s);
//dc.DrawEllipticArc(p,s,0.,90.);
//dc.DrawEllipticArcRot(p,s,0.,90.);
}
// Ellipses non alignees
for (unsigned int i=0;i<m_rotatedellipses.size();++i)
{
std::vector<wxPoint> points;
points.reserve( m_rotatedellipses[i].controlPoints.size() );
for (unsigned int j=0;j<m_rotatedellipses[i].controlPoints.size();++j)
points.push_back(transform().from_local_int(m_rotatedellipses[i].controlPoints[j]));
dc.DrawSpline(static_cast<int>(points.size()),&points.front());
}
for (unsigned int i=0;i<m_polygons.size();++i)
{
std::vector<wxPoint> points;
points.reserve( m_polygons[i].size() );
for (unsigned int j=0;j<m_polygons[i].size();++j)
points.push_back(transform().from_local_int(m_polygons[i][j]));
dc.DrawPolygon( static_cast<int>(points.size()) , &(points.front()) );
}
// 1D
pen.SetColour(m_line_color);
pen.SetWidth(m_line_width);
pen.SetStyle(m_line_style);
dc.SetPen(pen);
for (unsigned int i = 0; i < m_arcs.size(); i++)
{
const arc_type &local_tab = m_arcs[i];
for (unsigned int j = 0; j < local_tab.arc_points.size() - 1; ++j)
{
wxPoint p = transform().from_local_int(local_tab.arc_points[j ]);
wxPoint q = transform().from_local_int(local_tab.arc_points[j+1]);
dc.DrawLine(p,q);
}
}
// Splines
for (unsigned int i=0;i<m_splines.size();++i)
{
const spline_type& spline = m_splines[i];
std::vector<wxPoint> points;
unsigned int n = static_cast<int>(spline.size());
for (unsigned int j=0;j<n;++j)
{
wxPoint p = transform().from_local_int(spline[j]);
points.push_back(p);
}
dc.DrawSpline(n,&points.front());
}
// 0D
pen.SetColour(m_point_color);
pen.SetWidth(m_point_width);
dc.SetPen(pen);
for (unsigned int i = 0; i < m_points.size(); i++)
{
wxPoint p = transform().from_local_int(m_points[i]);
//dc.DrawLine(p);
dc.DrawPoint(p);
}
// Text
if(text_visibility())
{
pen.SetColour(m_text_color);
dc.SetPen(pen);
for (unsigned int i = 0; i < m_texts.size(); i++)
{
wxPoint p = transform().from_local_int(m_texts[i].first);
//dc.DrawLine(p);
dc.DrawText(wxString(m_texts[i].second.c_str(),*wxConvCurrent),p);
}
}
}
void GraphPane::FullRefresh(wxDC& dc)
{
// Erase Background
wxCoord width, height;
this->GetSize(&width, &height);
dc.SetPen((BlackBG ? *wxBLACK_PEN : *wxWHITE_PEN));
dc.SetBrush(BlackBG ? *wxBLACK_BRUSH : *wxWHITE_BRUSH);
dc.DrawRectangle(0, 0, width, height);
// Set the origin at the centre
dc.SetDeviceOrigin(wxCoord(width/2), wxCoord(height/2));
wxPen pen((BlackBG ? *wxWHITE : *wxBLACK), 1);
wxBrush brush((BlackBG ? *wxBLACK_BRUSH : *wxWHITE_BRUSH));
dc.SetPen(pen);
if (GraphInfoVector != NULL && !(GraphInfoVector->empty())) {
// Declare iterators for each set of coordinates --> Loop through all trails/sets of coordinates
std::vector<GraphInfo*>::const_iterator CoordSetIt;
// Declare iterators for each trail
std::deque<double>::const_iterator XCoordIt;
std::deque<double>::const_iterator YCoordIt;
//Begin iterating
CoordSetIt = GraphInfoVector->begin();
while (CoordSetIt != GraphInfoVector->end()) {
// Set Colour
if ((*CoordSetIt)->TrailColour == *wxBLACK && BlackBG) {
pen = wxPen(*wxWHITE, 1);
} else {
pen = wxPen((*CoordSetIt)->TrailColour, 1);
}
dc.SetPen(pen);
// Iterate through all coordinates
if ((*CoordSetIt)->XCoordinate.size() > unsigned(NewPoints)) {
XCoordIt = (*CoordSetIt)->XCoordinate.begin() + NewPoints - 1;
YCoordIt = (*CoordSetIt)->YCoordinate.begin() + NewPoints - 1;
}
else {
XCoordIt = (*CoordSetIt)->XCoordinate.begin();
YCoordIt = (*CoordSetIt)->YCoordinate.begin();
}
while (XCoordIt != (*CoordSetIt)->XCoordinate.end()) {
dc.DrawPoint(wxCoord((*XCoordIt) * ScalingFactor), wxCoord((*YCoordIt) * ScalingFactor* (-1)));
XCoordIt++;
YCoordIt++;
}
// If terminator size > 0, draw circle terminator at last coordinate.
if ((*CoordSetIt)->TermSize > 0) {
XCoordIt--;
YCoordIt--;
if ((*CoordSetIt)->TrailColour == *wxBLACK && BlackBG) {
brush.SetColour(*wxWHITE);
} else {
brush.SetColour((*CoordSetIt)->TrailColour);
}
dc.SetBrush(brush);
dc.DrawEllipse(wxCoord((*XCoordIt) * ScalingFactor - (*CoordSetIt)->TermSize),
wxCoord((*YCoordIt) * ScalingFactor* (-1) - (*CoordSetIt)->TermSize),
(*CoordSetIt)->TermSize * 2, (*CoordSetIt)->TermSize * 2);
}
++CoordSetIt;
}
}
}
void wxAuiGenericTabArt::DrawTab(wxDC& dc,
wxWindow* wnd,
const wxAuiNotebookPage& page,
const wxRect& in_rect,
int close_button_state,
wxRect* out_tab_rect,
wxRect* out_button_rect,
int* x_extent)
{
wxCoord normal_textx, normal_texty;
wxCoord selected_textx, selected_texty;
wxCoord texty;
// if the caption is empty, measure some temporary text
wxString caption = page.caption;
if (caption.empty())
caption = wxT("Xj");
dc.SetFont(m_selectedFont);
dc.GetTextExtent(caption, &selected_textx, &selected_texty);
dc.SetFont(m_normalFont);
dc.GetTextExtent(caption, &normal_textx, &normal_texty);
// figure out the size of the tab
wxSize tab_size = GetTabSize(dc,
wnd,
page.caption,
page.bitmap,
page.active,
close_button_state,
x_extent);
wxCoord tab_height = m_tabCtrlHeight - 3;
wxCoord tab_width = tab_size.x;
wxCoord tab_x = in_rect.x;
wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
caption = page.caption;
// select pen, brush and font for the tab to be drawn
if (page.active)
{
dc.SetFont(m_selectedFont);
texty = selected_texty;
}
else
{
dc.SetFont(m_normalFont);
texty = normal_texty;
}
// create points that will make the tab outline
int clip_width = tab_width;
if (tab_x + clip_width > in_rect.x + in_rect.width)
clip_width = (in_rect.x + in_rect.width) - tab_x;
/*
wxPoint clip_points[6];
clip_points[0] = wxPoint(tab_x, tab_y+tab_height-3);
clip_points[1] = wxPoint(tab_x, tab_y+2);
clip_points[2] = wxPoint(tab_x+2, tab_y);
clip_points[3] = wxPoint(tab_x+clip_width-1, tab_y);
clip_points[4] = wxPoint(tab_x+clip_width+1, tab_y+2);
clip_points[5] = wxPoint(tab_x+clip_width+1, tab_y+tab_height-3);
// FIXME: these ports don't provide wxRegion ctor from array of points
#if !defined(__WXDFB__) && !defined(__WXCOCOA__)
// set the clipping region for the tab --
wxRegion clipping_region(WXSIZEOF(clip_points), clip_points);
dc.SetClippingRegion(clipping_region);
#endif // !wxDFB && !wxCocoa
*/
// since the above code above doesn't play well with WXDFB or WXCOCOA,
// we'll just use a rectangle for the clipping region for now --
dc.SetClippingRegion(tab_x, tab_y, clip_width+1, tab_height-3);
wxPoint border_points[6];
if (m_flags &wxAUI_NB_BOTTOM)
{
border_points[0] = wxPoint(tab_x, tab_y);
border_points[1] = wxPoint(tab_x, tab_y+tab_height-6);
border_points[2] = wxPoint(tab_x+2, tab_y+tab_height-4);
border_points[3] = wxPoint(tab_x+tab_width-2, tab_y+tab_height-4);
border_points[4] = wxPoint(tab_x+tab_width, tab_y+tab_height-6);
border_points[5] = wxPoint(tab_x+tab_width, tab_y);
}
else //if (m_flags & wxAUI_NB_TOP) {}
{
border_points[0] = wxPoint(tab_x, tab_y+tab_height-4);
border_points[1] = wxPoint(tab_x, tab_y+2);
border_points[2] = wxPoint(tab_x+2, tab_y);
border_points[3] = wxPoint(tab_x+tab_width-2, tab_y);
border_points[4] = wxPoint(tab_x+tab_width, tab_y+2);
border_points[5] = wxPoint(tab_x+tab_width, tab_y+tab_height-4);
}
// TODO: else if (m_flags &wxAUI_NB_LEFT) {}
// TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
int drawn_tab_yoff = border_points[1].y;
int drawn_tab_height = border_points[0].y - border_points[1].y;
if (page.active)
{
// draw active tab
// draw base background color
wxRect r(tab_x, tab_y, tab_width, tab_height);
dc.SetPen(wxPen(m_activeColour));
dc.SetBrush(wxBrush(m_activeColour));
dc.DrawRectangle(r.x+1, r.y+1, r.width-1, r.height-4);
// this white helps fill out the gradient at the top of the tab
dc.SetPen(*wxWHITE_PEN);
dc.SetBrush(*wxWHITE_BRUSH);
dc.DrawRectangle(r.x+2, r.y+1, r.width-3, r.height-4);
// these two points help the rounded corners appear more antialiased
dc.SetPen(wxPen(m_activeColour));
dc.DrawPoint(r.x+2, r.y+1);
dc.DrawPoint(r.x+r.width-2, r.y+1);
// set rectangle down a bit for gradient drawing
r.SetHeight(r.GetHeight()/2);
r.x += 2;
r.width -= 3;
r.y += r.height;
r.y -= 2;
// draw gradient background
wxColor top_color = *wxWHITE;
wxColor bottom_color = m_activeColour;
dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
}
else
{
// draw inactive tab
wxRect r(tab_x, tab_y+1, tab_width, tab_height-3);
// start the gradent up a bit and leave the inside border inset
// by a pixel for a 3D look. Only the top half of the inactive
// tab will have a slight gradient
r.x += 3;
r.y++;
r.width -= 4;
r.height /= 2;
r.height--;
// -- draw top gradient fill for glossy look
wxColor top_color = m_baseColour;
wxColor bottom_color = top_color.ChangeLightness(160);
dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
r.y += r.height;
r.y--;
// -- draw bottom fill for glossy look
top_color = m_baseColour;
bottom_color = m_baseColour;
dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
}
// draw tab outline
dc.SetPen(m_borderPen);
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawPolygon(WXSIZEOF(border_points), border_points);
// there are two horizontal grey lines at the bottom of the tab control,
// this gets rid of the top one of those lines in the tab control
if (page.active)
{
if (m_flags &wxAUI_NB_BOTTOM)
dc.SetPen(wxPen(m_baseColour.ChangeLightness(170)));
// TODO: else if (m_flags &wxAUI_NB_LEFT) {}
// TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
else //for wxAUI_NB_TOP
dc.SetPen(m_baseColourPen);
dc.DrawLine(border_points[0].x+1,
border_points[0].y,
border_points[5].x,
border_points[5].y);
}
int text_offset = tab_x + 8;
int close_button_width = 0;
if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
{
close_button_width = m_activeCloseBmp.GetWidth();
}
int bitmap_offset = 0;
if (page.bitmap.IsOk())
{
bitmap_offset = tab_x + 8;
// draw bitmap
dc.DrawBitmap(page.bitmap,
bitmap_offset,
drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
true);
text_offset = bitmap_offset + page.bitmap.GetWidth();
text_offset += 3; // bitmap padding
}
else
{
text_offset = tab_x + 8;
}
wxString draw_text = wxAuiChopText(dc,
caption,
tab_width - (text_offset-tab_x) - close_button_width);
// draw tab text
dc.DrawText(draw_text,
text_offset,
drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1);
// draw focus rectangle
if (page.active && (wnd->FindFocus() == wnd))
{
wxRect focusRectText(text_offset, (drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1),
selected_textx, selected_texty);
wxRect focusRect;
wxRect focusRectBitmap;
if (page.bitmap.IsOk())
focusRectBitmap = wxRect(bitmap_offset, drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
page.bitmap.GetWidth(), page.bitmap.GetHeight());
if (page.bitmap.IsOk() && draw_text.IsEmpty())
focusRect = focusRectBitmap;
else if (!page.bitmap.IsOk() && !draw_text.IsEmpty())
focusRect = focusRectText;
else if (page.bitmap.IsOk() && !draw_text.IsEmpty())
focusRect = focusRectText.Union(focusRectBitmap);
focusRect.Inflate(2, 2);
wxRendererNative::Get().DrawFocusRect(wnd, dc, focusRect, 0);
}
// draw close button if necessary
if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
{
wxBitmap bmp = m_disabledCloseBmp;
if (close_button_state == wxAUI_BUTTON_STATE_HOVER ||
close_button_state == wxAUI_BUTTON_STATE_PRESSED)
{
bmp = m_activeCloseBmp;
}
int offsetY = tab_y-1;
if (m_flags & wxAUI_NB_BOTTOM)
offsetY = 1;
wxRect rect(tab_x + tab_width - close_button_width - 1,
offsetY + (tab_height/2) - (bmp.GetHeight()/2),
close_button_width,
tab_height);
IndentPressedBitmap(&rect, close_button_state);
dc.DrawBitmap(bmp, rect.x, rect.y, true);
*out_button_rect = rect;
}
*out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
dc.DestroyClippingRegion();
}
void FPlot::draw_data_by_activity(wxDC& dc, wxPoint2DDouble *pp,
const vector<bool>& aa, bool state)
{
int len = aa.size();
int count_state = count(aa.begin(), aa.end(), state);
if (count_state == 0)
return;
wxGCDC* gdc = wxDynamicCast(&dc, wxGCDC);
wxGraphicsContext *gc = gdc ? gdc->GetGraphicsContext() : NULL;
if (line_between_points) {
int start = (aa[0] == state ? 0 : -1);
for (int i = 1; i != len; ++i) {
if (aa[i] == state && start == -1)
start = i;
else if (aa[i] != state && start != -1) {
wxPoint2DDouble start_bak = pp[start];
wxPoint2DDouble i_bak = pp[i];
if (start > 0) {
// draw half of the line between points start-1 and start
--start;
start_bak = pp[start];
pp[start] = (pp[start] + pp[start+1]) / 2;
}
// draw half of the line between points i-1 and i
pp[i] = (pp[i-1] + pp[i]) / 2;
stroke_lines(dc, gc, i - start + 1, pp + start);
pp[i] = i_bak;
pp[start] = start_bak;
start = -1;
}
}
if (start != -1) {
wxPoint2DDouble start_bak = pp[start];
if (start > 0) {
// draw half of the line between points start-1 and start
--start;
start_bak = pp[start];
pp[start] = (pp[start] + pp[start+1]) / 2;
}
stroke_lines(dc, gc, len - start, pp + start);
pp[start] = start_bak;
}
}
if (point_radius > 1) {
int r = (point_radius - 1) * pen_width;
if (gc) {
for (int i = 0; i != len; ++i)
if (aa[i] == state)
gc->DrawEllipse(pp[i].m_x - r/2., pp[i].m_y - r/2., r, r);
}
else
for (int i = 0; i != len; ++i)
if (aa[i] == state)
dc.DrawEllipse(pp[i].m_x - r/2, pp[i].m_y - r/2, r, r);
}
else if (!line_between_points) { // if we are here, point_radius == 1
if (gc) {
wxGraphicsPath path = gc->CreatePath();
for (int i = 0; i != len; ++i)
if (aa[i] == state) {
double rx = iround(pp[i].m_x);
double ry = iround(pp[i].m_y);
path.MoveToPoint(rx, ry - 0.1);
path.AddLineToPoint(rx, ry + 0.1);
}
gc->SetAntialiasMode(wxANTIALIAS_NONE);
gc->StrokePath(path);
gc->SetAntialiasMode(wxANTIALIAS_DEFAULT);
}
else
for (int i = 0; i != len; ++i)
if (aa[i] == state)
dc.DrawPoint(iround(pp[i].m_x), iround(pp[i].m_y));
}
}
// Define the repainting behaviour
void MyCanvas::OnDraw(wxDC& dc)
{
// vars to use ...
#if wxUSE_STATUSBAR
wxString s ;
#endif // wxUSE_STATUSBAR
wxPen wP ;
wxBrush wB ;
wxPoint points[6];
wxColour wC;
wxFont wF ;
dc.SetFont(*wxSWISS_FONT);
dc.SetPen(*wxGREEN_PEN);
switch (m_index)
{
default:
case 0:
// draw lines to make a cross
dc.DrawLine(0, 0, 200, 200);
dc.DrawLine(200, 0, 0, 200);
// draw point colored line and spline
wP = *wxCYAN_PEN ;
wP.SetWidth(3);
dc.SetPen(wP);
dc.DrawPoint (25,15) ;
dc.DrawLine(50, 30, 200, 30);
dc.DrawSpline(50, 200, 50, 100, 200, 10);
#if wxUSE_STATUSBAR
s = wxT("Green Cross, Cyan Line and spline");
#endif // wxUSE_STATUSBAR
break ;
case 1:
// draw standard shapes
dc.SetBrush(*wxCYAN_BRUSH);
dc.SetPen(*wxRED_PEN);
dc.DrawRectangle(10, 10, 100, 70);
wB = wxBrush (_T("DARK ORCHID"), wxTRANSPARENT);
dc.SetBrush (wB);
dc.DrawRoundedRectangle(50, 50, 100, 70, 20);
dc.SetBrush (wxBrush(_T("GOLDENROD"), wxSOLID) );
dc.DrawEllipse(100, 100, 100, 50);
points[0].x = 100; points[0].y = 200;
points[1].x = 70; points[1].y = 260;
points[2].x = 160; points[2].y = 230;
points[3].x = 40; points[3].y = 230;
points[4].x = 130; points[4].y = 260;
points[5].x = 100; points[5].y = 200;
dc.DrawPolygon(5, points);
dc.DrawLines (6, points, 160);
#if wxUSE_STATUSBAR
s = wxT("Blue rectangle, red edge, clear rounded rectangle, gold ellipse, gold and clear stars");
#endif // wxUSE_STATUSBAR
break ;
case 2:
// draw text in Arial or similar font
dc.DrawLine(50,25,50,35);
dc.DrawLine(45,30,55,30);
dc.DrawText(wxT("This is a Swiss-style string"), 50, 30);
wC = dc.GetTextForeground() ;
dc.SetTextForeground (_T("FIREBRICK"));
// no effect in msw ??
dc.SetTextBackground (_T("WHEAT"));
dc.DrawText(wxT("This is a Red string"), 50, 200);
dc.DrawRotatedText(wxT("This is a 45 deg string"), 50, 200, 45);
dc.DrawRotatedText(wxT("This is a 90 deg string"), 50, 200, 90);
wF = wxFont ( 18, wxROMAN, wxITALIC, wxBOLD, false, wxT("Times New Roman"));
dc.SetFont(wF);
dc.SetTextForeground (wC) ;
dc.DrawText(wxT("This is a Times-style string"), 50, 60);
#if wxUSE_STATUSBAR
s = wxT("Swiss, Times text; red text, rotated and colored orange");
#endif // wxUSE_STATUSBAR
break ;
case 3 :
// four arcs start and end points, center
dc.SetBrush(*wxGREEN_BRUSH);
dc.DrawArc ( 200,300, 370,230, 300,300 );
dc.SetBrush(*wxBLUE_BRUSH);
dc.DrawArc ( 270-50, 270-86, 270-86, 270-50, 270,270 );
dc.SetDeviceOrigin(-10,-10);
dc.DrawArc ( 270-50, 270-86, 270-86, 270-50, 270,270 );
dc.SetDeviceOrigin(0,0);
wP.SetColour (_T("CADET BLUE"));
dc.SetPen(wP);
dc.DrawArc ( 75,125, 110, 40, 75, 75 );
wP.SetColour (_T("SALMON"));
dc.SetPen(wP);
dc.SetBrush(*wxRED_BRUSH);
//top left corner, width and height, start and end angle
// 315 same center and x-radius as last pie-arc, half Y radius
dc.DrawEllipticArc(25,50,100,50,180.0,45.0) ;
wP = *wxCYAN_PEN ;
wP.SetWidth(3);
dc.SetPen(wP);
//wxTRANSPARENT));
dc.SetBrush (wxBrush (_T("SALMON"),wxSOLID)) ;
dc.DrawEllipticArc(300, 0,200,100, 0.0,145.0) ;
//same end point
dc.DrawEllipticArc(300, 50,200,100,90.0,145.0) ;
dc.DrawEllipticArc(300,100,200,100,90.0,345.0) ;
#if wxUSE_STATUSBAR
s = wxT("This is an arc test page");
#endif // wxUSE_STATUSBAR
break ;
case 4:
dc.DrawCheckMark ( 30,30,25,25);
dc.SetBrush (wxBrush (_T("SALMON"),wxTRANSPARENT));
dc.DrawCheckMark ( 80,50,75,75);
dc.DrawRectangle ( 80,50,75,75);
#if wxUSE_STATUSBAR
s = wxT("Two check marks");
#endif // wxUSE_STATUSBAR
break ;
case 5:
wF = wxFont ( 18, wxROMAN, wxITALIC, wxBOLD, false, wxT("Times New Roman"));
dc.SetFont(wF);
dc.DrawLine(0, 0, 200, 200);
dc.DrawLine(200, 0, 0, 200);
dc.DrawText(wxT("This is an 18pt string"), 50, 60);
// rescale and draw in blue
wP = *wxCYAN_PEN ;
dc.SetPen(wP);
dc.SetUserScale (2.0,0.5);
dc.SetDeviceOrigin(200,0);
dc.DrawLine(0, 0, 200, 200);
dc.DrawLine(200, 0, 0, 200);
dc.DrawText(wxT("This is an 18pt string 2 x 0.5 UserScaled"), 50, 60);
dc.SetUserScale (2.0,2.0);
dc.SetDeviceOrigin(200,200);
dc.DrawText(wxT("This is an 18pt string 2 x 2 UserScaled"), 50, 60);
wP = *wxRED_PEN ;
dc.SetPen(wP);
dc.SetUserScale (1.0,1.0);
dc.SetDeviceOrigin(0,10);
dc.SetMapMode (wxMM_METRIC) ; //svg ignores this
dc.DrawLine(0, 0, 200, 200);
dc.DrawLine(200, 0, 0, 200);
dc.DrawText(wxT("This is an 18pt string in MapMode"), 50, 60);
#if wxUSE_STATUSBAR
s = wxT("Scaling test page");
#endif // wxUSE_STATUSBAR
break ;
case 6:
dc.DrawIcon( wxIcon(mondrian_xpm), 10, 10 );
dc.DrawBitmap ( wxBitmap(svgbitmap_xpm), 50,15);
#if wxUSE_STATUSBAR
s = wxT("Icon and Bitmap ");
#endif // wxUSE_STATUSBAR
break ;
}
#if wxUSE_STATUSBAR
m_child->SetStatusText(s);
#endif // wxUSE_STATUSBAR
}
