void wxImageComboBox::OnDrawBackground (wxDC &dc, const wxRect &rect, int item, int flags) const
{
if ( item == wxNOT_FOUND ) return;
const ImageHandle& image = images[item];
wxBitmap* bmp = ConvertImageToBitmap( image.Resolve(), "" );
if( !bmp ) return;
dc.DrawBitmap( *bmp, rect.GetTopLeft() );
if( flags & wxODCB_PAINTING_SELECTED )
dc.DrawRectangle( rect );
delete bmp;
}
void wxPDFViewPage::DrawPrint(wxDC& dc, const wxRect& rect, bool forceBitmap)
{
FPDF_PAGE page = GetPage();
int renderFlags = FPDF_ANNOT | FPDF_PRINTING;
#ifdef wxPDFVIEW_USE_RENDER_TO_DC
if (!forceBitmap)
{
FPDF_RenderPage(dc.GetHDC(), page, rect.x, rect.y, rect.width, rect.height, 0, renderFlags);
} else
#endif
{
wxBitmap bmp = CreateBitmap(page, m_pages->form(), rect.GetSize(), renderFlags);
dc.DrawBitmap(bmp, wxPoint(0, 0));
}
}
void CustomGrid::DrawCornerLabel( wxDC& dc )
{
dc.SetPen(GetDefaultGridLinePen());
dc.SetBrush( wxBrush( m_labelBackgroundColour, wxBRUSHSTYLE_SOLID ) );
wxRect rect( 0, 0, m_rowLabelWidth, m_colLabelHeight );
dc.DrawRectangle(rect);
////scale bitmap to near col label height
double hc = m_colLabelHeight;
double hb = wxBitmap(now).GetHeight();
double scfac = ((hc / hb) *4) /4;
wxBitmap bmp = m_gParent->GetScaledBitmap(wxBitmap(now), _T("now"), scfac );
//center bitmap
int x = (m_rowLabelWidth - bmp.GetWidth()) / 2;
int y = (m_colLabelHeight == bmp.GetHeight())? 0: wxMax( 0, (m_colLabelHeight - bmp.GetHeight()) / 2 );
dc.DrawBitmap( bmp, x, y );
}
bool wxGenericImageList::Draw( int index, wxDC &dc, int x, int y,
int flags, bool WXUNUSED(solidBackground) )
{
wxObjectList::compatibility_iterator node = m_images.Item( index );
wxCHECK_MSG( node, false, wxT("wrong index in image list") );
wxBitmap *bm = (wxBitmap*)node->GetData();
if (bm->IsKindOf(wxCLASSINFO(wxIcon)))
dc.DrawIcon( * ((wxIcon*) bm), x, y);
else
dc.DrawBitmap( *bm, x, y, (flags & wxIMAGELIST_DRAW_TRANSPARENT) > 0 );
return true;
}
void wxBitmapComboBox::OnDrawItem(wxDC& dc,
const wxRect& rect,
int item,
int flags) const
{
wxString text;
int imgAreaWidth = m_imgAreaWidth;
bool drawText;
if ( imgAreaWidth == 0 )
{
wxOwnerDrawnComboBox::OnDrawItem(dc, rect, item, flags);
return;
}
if ( flags & wxODCB_PAINTING_CONTROL )
{
text = GetValue();
if ( HasFlag(wxCB_READONLY) )
drawText = true;
else
drawText = false;
}
else
{
text = GetString(item);
drawText = true;
}
const wxBitmap& bmp = *GetBitmapPtr(item);
if ( bmp.Ok() )
{
wxCoord w = bmp.GetWidth();
wxCoord h = bmp.GetHeight();
// Draw the image centered
dc.DrawBitmap(bmp,
rect.x + (m_usedImgSize.x-w)/2 + IMAGE_SPACING_LEFT,
rect.y + (rect.height-h)/2,
true);
}
if ( drawText )
dc.DrawText(GetString(item),
rect.x + imgAreaWidth + 1,
rect.y + (rect.height-dc.GetCharHeight())/2);
}
void BenchmarkRawBitmaps(const wxString& msg, wxDC& dc)
{
if ( !opts.testRawBitmaps )
return;
if ( opts.mapMode != 0 )
dc.SetMapMode((wxMappingMode)opts.mapMode);
wxPrintf("Benchmarking %s: ", msg);
fflush(stdout);
wxBitmap bitmap(opts.width, opts.height, 24);
wxNativePixelData data(bitmap);
wxStopWatch sw;
for ( int n = 0; n < opts.numIters; n++ )
{
unsigned char c = n % 256;
{
wxNativePixelData::Iterator p(data);
for ( int y = 0; y < opts.height; ++y )
{
wxNativePixelData::Iterator rowStart = p;
for ( int x = 0; x < opts.width; ++x )
{
p.Red() =
p.Green() =
p.Blue() = c;
++p;
}
p = rowStart;
p.OffsetY(data, 1);
c++;
}
}
dc.DrawBitmap(bitmap, 0, 0);
}
const long t = sw.Time();
wxPrintf("%ld raw bitmaps done in %ldms = %gus/bitmap or %ld FPS\n",
opts.numIters, t, (1000. * t)/opts.numIters,
(1000*opts.numIters + t - 1)/t);
}
/**
* Render the event in the bitmap
*/
void WhileEvent::Render(wxDC & dc, int x, int y, unsigned int width, gd::EventsEditorItemsAreas & areas, gd::EventsEditorSelection & selection, const gd::Platform & platform)
{
#if !defined(GD_NO_WX_GUI)
gd::EventsRenderingHelper * renderingHelper = gd::EventsRenderingHelper::Get();
int border = renderingHelper->instructionsListBorder;
const int repeatHeight = 20;
//Draw header rectangle
int whileConditionsHeight = renderingHelper->GetRenderedConditionsListHeight(whileConditions, width-80-border*2, platform)+border*2;
if (!infiniteLoopWarning && whileConditionsHeight < 32 ) whileConditionsHeight = 32;
wxRect headerRect(x, y, width, whileConditionsHeight+repeatHeight);
renderingHelper->DrawNiceRectangle(dc, headerRect);
//While text
dc.SetFont( renderingHelper->GetNiceFont().Bold() );
dc.SetTextForeground(wxColour(0,0,0));
dc.DrawText( _("While :"), x+5, y+5 );
//Draw icon if infinite loop warning is deactivated.
if (!infiniteLoopWarning)
{
if ( gd::CommonBitmapManager::Get()->noProtection.IsOk() )
dc.DrawBitmap(gd::CommonBitmapManager::Get()->noProtection, wxPoint(x+5,y+5+18), /*useMask=*/true);
}
//Draw "while conditions"
renderingHelper->DrawConditionsList(whileConditions, dc, x+80+border, y+border, width-80-border*2, this, areas, selection, platform);
dc.SetFont( renderingHelper->GetNiceFont().Bold() );
dc.SetTextForeground(wxColour(0,0,0));
dc.DrawText( _("Repeat :"), x+4, y+whileConditionsHeight+3);
whileConditionsHeight += repeatHeight;
//Draw conditions rectangle
wxRect rect(x, y+whileConditionsHeight, renderingHelper->GetConditionsColumnWidth()+border, GetRenderedHeight(width, platform)-whileConditionsHeight);
renderingHelper->DrawNiceRectangle(dc, rect);
renderingHelper->DrawConditionsList(conditions, dc,
x+border,
y+whileConditionsHeight+border,
renderingHelper->GetConditionsColumnWidth()-border, this, areas, selection, platform);
renderingHelper->DrawActionsList(actions, dc,
x+renderingHelper->GetConditionsColumnWidth()+border,
y+whileConditionsHeight+border,
width-renderingHelper->GetConditionsColumnWidth()-border*2, this, areas, selection, platform);
#endif
}
// Draws any shapes in the model to the provided DC (draw context)
void PaintModel::DrawShapes(wxDC& dc, bool showSelection) {
// Draw background
if (mBitmap.IsOk()) {
// The image's top left corner should be asigned with the canvas' top left corner, (0,0)
dc.DrawBitmap(mBitmap, 0, 0);
}
// Draw all shapes
for (auto it = mShapes.begin(); it != mShapes.end(); ++it) {
(*it)->Draw(dc);
}
// Draw a box around the selected shape, if present
if (showSelection && mSelectedShape) {
mSelectedShape->DrawSelection(dc);
}
}
void wxCustomStatusBarBitmapField::Render(wxDC& dc, const wxRect& rect, wxCustomStatusBarArt::Ptr_t art)
{
m_rect = rect;
// draw border line
art->DrawFieldSeparator(dc, rect);
// Center bitmap
if(m_bitmap.IsOk()) {
int bmpHeight = m_bitmap.GetScaledHeight();
int bmpWidth = m_bitmap.GetScaledWidth();
wxCoord bmpY = (rect.GetHeight() - bmpHeight) / 2 + rect.y;
wxCoord bmpX = (rect.GetWidth() - bmpWidth) / 2 + rect.x;
// Draw the bitmap
dc.DrawBitmap(m_bitmap, bmpX, bmpY + 1);
}
}
void PDFPanel::render(wxDC& dc)
{
it = selectedItems.begin();
if(bitmap->IsOk() && bitmap!=NULL)
{
dc.DrawBitmap( *bitmap,0 ,0, false );
grid.DrawGrid(dc);
while(it!=selectedItems.end())
{
wxRect rect = (it->rect);
dc.SetPen(pen);
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRectangle(rect);
it++;
}
}
}
void wxGridCtrl::DrawRowLabel(wxDC& dc, int row)
{
if (GetRowHeight(row) <= 0 || m_rowLabelWidth <= 0)
return;
wxRect rect;
int rowTop = GetRowTop(row), rowBottom = GetRowBottom(row) - 1;
dc.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID));
dc.DrawLine(m_rowLabelWidth - 1, rowTop, m_rowLabelWidth - 1, rowBottom);
dc.DrawLine(0, rowTop, 0, rowBottom);
dc.DrawLine(0, rowBottom, m_rowLabelWidth, rowBottom);
dc.SetPen(*wxWHITE_PEN);
dc.DrawLine(1, rowTop, 1, rowBottom);
dc.DrawLine(1, rowTop, m_rowLabelWidth - 1, rowTop);
if (row == GetGridCursorRow())
{
dc.DrawBitmap(wxBitmap(small_arrow_xpm), 0, GetRowTop(row), true);
}
}
virtual void OnDraw(wxDC& dc)
{
if (m_bitmap.IsOk())
{
dc.DrawBitmap(m_bitmap, 0, 0);
}
else if (!m_imageError.IsNull())
{
dc.SetPen(wxPen(wxColor(255, 255, 255)));
dc.SetBrush(*wxWHITE_BRUSH);
dc.DrawRectangle(0, 0, m_w, m_h);
dc.SetPen(*wxRED_PEN);
dc.DrawLine(0, 0, m_w - 1, m_h - 1);
dc.DrawLine(0, m_h - 1, m_w - 1, m_h - 1);
dc.SetPen(*wxBLACK_PEN);
dc.DrawText(m_imageError.GetMessage(), 0 , 0);
}
}
/* not virtual in wxGrid, so code copied and modified her for painting sorting icons */
void CBOINCGridCtrl::DrawColLabel( wxDC& dc, int col )
{
if ( GetColWidth(col) <= 0 || m_colLabelHeight <= 0 )
return;
int colLeft = GetColLeft(col);
wxRect rect;
int colRight = GetColRight(col) - 1;
dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW),1, wxSOLID) );
dc.DrawLine( colRight, 0,
colRight, m_colLabelHeight-1 );
dc.DrawLine( colLeft, 0, colRight, 0 );
dc.DrawLine( colLeft, m_colLabelHeight-1,
colRight+1, m_colLabelHeight-1 );
dc.SetPen( *wxWHITE_PEN );
dc.DrawLine( colLeft, 1, colLeft, m_colLabelHeight-1 );
dc.DrawLine( colLeft, 1, colRight, 1 );
dc.SetBackgroundMode( wxTRANSPARENT );
dc.SetTextForeground( GetLabelTextColour() );
dc.SetFont( GetLabelFont() );
int hAlign, vAlign, orient;
GetColLabelAlignment( &hAlign, &vAlign );
orient = GetColLabelTextOrientation();
rect.SetX( colLeft + 2 );
rect.SetY( 2 );
rect.SetWidth( GetColWidth(col) - 4 );
rect.SetHeight( m_colLabelHeight - 4 );
DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign, orient );
//paint sorting indicators, if needed
if(col == sortColumn) {
int x = rect.GetRight() - ascBitmap.GetWidth() - 2;
int y = rect.GetY();
dc.DrawBitmap(this->sortAscending ? descBitmap : ascBitmap,x,y,true);
}
}
void AudioRenderer::Render(wxDC &dc, wxPoint origin, const int start, const int length, const AudioRenderingStyle style)
{
assert(start >= 0);
if (!provider) return;
if (!renderer) return;
if (length <= 0) return;
// One past last absolute pixel strip to render
const int end = start + length;
// One past last X coordinate to render on
const int lastx = origin.x + length;
// Figure out which range of bitmaps are required
const int firstbitmap = start / cache_bitmap_width;
// And the offset in it to start its use at
const int firstbitmapoffset = start % cache_bitmap_width;
// The last bitmap required
const int lastbitmap = std::min<int>(end / cache_bitmap_width, NumBlocks(provider->GetDecodedSamples()) - 1);
// Set a clipping region so that the first and last bitmaps don't draw
// outside the requested range
const wxDCClipper clipper(dc, wxRect(origin, wxSize(length, pixel_height)));
origin.x -= firstbitmapoffset;
for (int i = firstbitmap; i <= lastbitmap; ++i)
{
dc.DrawBitmap(GetCachedBitmap(i, style), origin);
origin.x += cache_bitmap_width;
}
// Now render blank audio from origin to end
if (origin.x < lastx)
renderer->RenderBlank(dc, wxRect(origin.x-1, origin.y, lastx-origin.x+1, pixel_height), style);
if (needs_age)
{
bitmaps[style].Age(cache_bitmap_maxsize);
renderer->AgeCache(cache_renderer_maxsize);
needs_age = false;
}
}
void ExplainShape::OnDraw(wxDC& dc)
{
wxBitmap &bmp=GetBitmap();
if (!bmp.Ok())
return;
int x, y;
x = WXROUND(m_xpos - bmp.GetWidth() / 2.0);
y = WXROUND(m_ypos - GetHeight() / 2.0);
dc.DrawBitmap(bmp, x, y, true);
int w, h;
dc.SetFont(GetCanvas()->GetFont());
dc.GetTextExtent(label, &w, &h);
x = WXROUND(m_xpos - w / 2.0);
y +=bmp.GetHeight() + BMP_BORDER;
dc.DrawText(label, x, y);
}
void PhotoFrame::Draw(wxDC& dc, wxPoint& origin) {
dc.SetBrush(BACKGROUND_BRUSH);
dc.SetPen(BACKGROUND_PEN);
dc.DrawRoundedRectangle(origin, SMALL_SIZE, CORNER_RADIUS);
wxRect rect(
origin.x + (SMALL_SIZE.x - SMALL_BITMAP_SIZE.x) / 2,
origin.y + (SMALL_SIZE.y - SMALL_BITMAP_SIZE.y) / 2,
SMALL_BITMAP_SIZE.x,
SMALL_BITMAP_SIZE.y);
if (!m_path.IsEmpty()) {
wxBitmap* bitmap = m_cache.Get(m_path);
if (bitmap != NULL) {
rect.SetSize(wxSize(bitmap->GetWidth(), bitmap->GetHeight()));
rect.x += (SMALL_BITMAP_SIZE.x - rect.width) / 2;
rect.y += (SMALL_BITMAP_SIZE.y - rect.height) / 2;
dc.DrawBitmap(*bitmap, rect.GetPosition());
}
}
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
}
BOOL FontDropDown::DrawIcon(void * ItemData, wxDC& dc, wxRect& IconRect, BOOL Disabled, INT32 flags)
{
ResourceID BitmapID = 0;
FontClass Type;
if ((ItemData==&TheTopItem) || !ItemData)
Type = TheTopItem.Type;
else
Type = ((FontDropItem *)ItemData)->Type;
switch(Type)
{
case FC_TRUETYPE:
BitmapID = _R(IDB_TTF_SYMBOL);
break;
case FC_ATM:
BitmapID = _R(IDB_ATM_SYMBOL);
break;
case FC_UNDEFINED:
BitmapID = _R(IDB_UNKNOWNFONT_SYMBOL);
break;
default:
BitmapID = 0;
break;
}
if(BitmapID == 0)
return FALSE;
wxBitmap * pBitmap = CamArtProvider::Get()->FindBitmap(BitmapID, (CamArtFlags)(CAF_DEFAULT|(Disabled?CAF_GREYED:0)));
if (!pBitmap)
return FALSE;
dc.DrawBitmap(*pBitmap, IconRect.GetLeft(), IconRect.GetTop(), TRUE);
return TRUE;
}
//---------------------------------------------------------
void CWKSP_Layer_Legend::_Draw_Box_Image(wxDC &dc, int ay, CSG_Grid *pGrid)
{
int x, y, nx, ny, Color;
double d, dx, dy;
wxImage img;
//-----------------------------------------------------
if( pGrid->Get_NX() > pGrid->Get_NY() )
{
nx = m_dxBox;
d = (int)(pGrid->Get_NX() / nx);
ny = (int)(pGrid->Get_NY() / d);
}
else
{
ny = m_dxBox;
d = (int)(pGrid->Get_NY() / ny);
nx = (int)(pGrid->Get_NX() / d);
}
img.Create(nx, ny);
for(y=0, dy=0.0; y<ny; y++, dy+=d)
{
for(x=0, dx=0.0; x<nx; x++, dx+=d)
{
Color = m_pClassify->Get_Class_Color_byValue(pGrid->asDouble((int)dx, (int)dy));
img.SetRGB(x, ny - 1 - y, SG_GET_R(Color), SG_GET_G(Color), SG_GET_B(Color));
}
}
dc.DrawBitmap(wxBitmap(img), m_xBox, ay, false);
Draw_Edge(dc, EDGE_STYLE_SIMPLE, m_xBox, ay, m_xBox + nx, ay + ny);
//-----------------------------------------------------
_Set_Size(0, ny);
ny += BOX_SPACE;
}
// -------------------------------------------------------------------------------- //
void guAlListBox::DrawItem( wxDC &dc, const wxRect &rect, const int row, const int col ) const
{
m_Attr.m_Font->SetPointSize( 10 );
guAlbumItem * Item = &( * ( guAlbumItems * ) m_Items )[ row ];
dc.SetFont( * m_Attr.m_Font );
dc.SetBackgroundMode( wxTRANSPARENT );
dc.SetTextForeground( IsSelected( row ) ? m_Attr.m_SelFgColor : m_Attr.m_TextFgColor );
dc.DrawText( Item->m_Name, rect.x + 45, rect.y + 4 );
if( Item->m_Year )
{
int Pos;
dc.GetTextExtent( Item->m_Name, &Pos, NULL );
Pos += rect.x + 45;
m_Attr.m_Font->SetPointSize( 7 );
dc.SetFont( * m_Attr.m_Font );
dc.DrawText( wxString::Format( wxT( " (%4u)" ), Item->m_Year ), Pos, rect.y + 7 );
}
if( !Item->m_ArtistName.IsEmpty() )
{
m_Attr.m_Font->SetPointSize( 8 );
dc.SetFont( * m_Attr.m_Font );
dc.DrawText( _( "by " ) + Item->m_ArtistName, rect.x + 45, rect.y + 22 );
}
if( Item->m_Thumb )
{
dc.DrawBitmap( * Item->m_Thumb, rect.x + 1, rect.y + 1, false );
}
// else if( Item->m_Thumb )
// {
// guLogError( wxT( "Thumb image corrupt or not correctly loaded" ) );
// }
}
bool wxImageList::Draw(
int index, wxDC &dc, int x, int y,
int flags, bool WXUNUSED(solidBackground) )
{
wxList::compatibility_iterator node = m_images.Item( index );
wxCHECK_MSG( node, false, wxT("wrong index in image list") );
wxObject *obj = (wxObject*)node->GetData();
if (obj->IsKindOf(CLASSINFO(wxIcon)))
{
wxIcon *bm = static_cast< wxIcon* >(obj ) ;
dc.DrawIcon( *bm , x, y );
}
else
{
wxBitmap *bm = static_cast< wxBitmap* >(obj ) ;
dc.DrawBitmap( *bm, x, y, (flags & wxIMAGELIST_DRAW_TRANSPARENT) > 0 );
}
return true;
}
void wxRibbonMetroArtProvider::DrawMinimisedPanel(wxDC& dc, wxRibbonPanel* wnd, const wxRect& rect, wxBitmap& bitmap)
{
DrawPartialPageBackground(dc, wnd, rect, false);
wxRect true_rect(rect);
// RemovePanelPadding(&true_rect);
wxRect client_rect(true_rect);
client_rect.width -= 2;
client_rect.y++;
client_rect.height -= 2;
if(wnd->GetExpandedPanel() != NULL) {
dc.SetPen(m_button_bar_active_border_pen);
dc.SetBrush(m_button_bar_active_background_colour);
dc.DrawRectangle(client_rect);
} else if(wnd->IsHovered()) {
dc.SetPen(m_button_bar_hover_border_pen);
dc.SetBrush(m_panel_active_background_colour);
dc.DrawRectangle(client_rect);
} else {
dc.SetPen(m_button_bar_hover_border_pen);
dc.SetBrush(m_button_bar_hover_background_colour);
dc.DrawRectangle(client_rect);
}
wxRect preview;
DrawMinimisedPanelCommon(dc, wnd, true_rect, &preview);
dc.SetBrush(m_panel_active_background_colour);
dc.SetPen(m_button_bar_hover_border_pen);
dc.DrawRectangle(preview);
if(bitmap.IsOk()) {
dc.DrawBitmap(bitmap, preview.x + (preview.width - bitmap.GetWidth()) / 2,
preview.y + (preview.height - 7 - bitmap.GetHeight()) / 2, true);
}
DrawPanelBorder(dc, true_rect, m_panel_border_pen, m_panel_border_gradient_pen);
}
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 wxStdRenderer::DrawFrameButton(wxDC& dc,
wxCoord x, wxCoord y,
int button,
int flags)
{
FrameButtonType idx;
switch (button)
{
case wxTOPLEVEL_BUTTON_CLOSE: idx = FrameButton_Close; break;
case wxTOPLEVEL_BUTTON_MAXIMIZE: idx = FrameButton_Maximize; break;
case wxTOPLEVEL_BUTTON_ICONIZE: idx = FrameButton_Minimize; break;
case wxTOPLEVEL_BUTTON_RESTORE: idx = FrameButton_Restore; break;
case wxTOPLEVEL_BUTTON_HELP: idx = FrameButton_Help; break;
default:
wxFAIL_MSG(wxT("incorrect button specification"));
return;
}
wxBitmap bmp = GetFrameButtonBitmap(idx);
if ( !bmp.Ok() )
return;
wxRect rectBtn(x, y, FRAME_BUTTON_WIDTH, FRAME_BUTTON_HEIGHT);
if ( flags & wxCONTROL_PRESSED )
{
DrawSunkenBorder(dc, &rectBtn);
rectBtn.Offset(1, 1);
}
else
{
DrawRaisedBorder(dc, &rectBtn);
}
DrawBackground(dc, wxSCHEME_COLOUR(m_scheme, CONTROL), rectBtn);
wxRect rectBmp(0, 0, bmp.GetWidth(), bmp.GetHeight());
dc.DrawBitmap(bmp, rectBmp.CentreIn(rectBtn).GetPosition(), true);
}
////////////////////////////////////////////////////////////////////
// Method: Draw
// Class: CCamView
// Purose: camera drawing
// Input: reference to dc
// Output: nothing
////////////////////////////////////////////////////////////////////
void CCamView::Draw( wxDC& dc )
{
// check if dc available
if( !dc.IsOk( ) || m_bDrawing == true ){ return; }
m_bDrawing = true;
int x,y,w,h;
dc.GetClippingBox( &x, &y, &w, &h );
// if there is a new image to draw
if( m_bNewImage )
{
dc.DrawBitmap( *m_pBitmap, x, y );
m_bNewImage = false;
} else
{
// draw inter frame ?
}
m_bDrawing = false;
return;
}
void SjVisImgBg::DrawBackground(wxDC& dc)
{
wxASSERT( wxThread::IsMain() );
if( m_scaledImage.IsOk() )
{
if( m_scaledBitmap == NULL )
{
m_scaledBitmap = new wxBitmap(m_scaledImage);
}
if( m_scaledBitmap->IsOk() )
{
dc.DrawBitmap(*m_scaledBitmap, 0, 0);
return;
}
}
// error
wxSize size = dc.GetSize();
dc.SetBrush(*wxBLACK_BRUSH);
dc.SetPen(*wxTRANSPARENT_PEN);
dc.DrawRectangle(0, 0, size.x, size.y);
}
void wxBitmapComboBoxBase::DrawItem(wxDC& dc,
const wxRect& rect,
int item,
const wxString& text,
int WXUNUSED(flags)) const
{
const wxBitmap& bmp = *GetBitmapPtr(item);
if ( bmp.IsOk() )
{
wxCoord w = bmp.GetWidth();
wxCoord h = bmp.GetHeight();
// Draw the image centered
dc.DrawBitmap(bmp,
rect.x + (m_usedImgSize.x-w)/2 + IMAGE_SPACING_LEFT,
rect.y + (rect.height-h)/2,
true);
}
if ( text.length() )
dc.DrawText(text,
rect.x + m_imgAreaWidth + 1,
rect.y + (rect.height-dc.GetCharHeight())/2);
}
void wxAuiGenericTabArt::DrawButton(wxDC& dc,
wxWindow* WXUNUSED(wnd),
const wxRect& in_rect,
int bitmap_id,
int button_state,
int orientation,
wxRect* out_rect)
{
wxBitmap bmp;
wxRect rect;
switch (bitmap_id)
{
case wxAUI_BUTTON_CLOSE:
if (button_state & wxAUI_BUTTON_STATE_DISABLED)
bmp = m_disabledCloseBmp;
else
bmp = m_activeCloseBmp;
break;
case wxAUI_BUTTON_LEFT:
if (button_state & wxAUI_BUTTON_STATE_DISABLED)
bmp = m_disabledLeftBmp;
else
bmp = m_activeLeftBmp;
break;
case wxAUI_BUTTON_RIGHT:
if (button_state & wxAUI_BUTTON_STATE_DISABLED)
bmp = m_disabledRightBmp;
else
bmp = m_activeRightBmp;
break;
case wxAUI_BUTTON_WINDOWLIST:
if (button_state & wxAUI_BUTTON_STATE_DISABLED)
bmp = m_disabledWindowListBmp;
else
bmp = m_activeWindowListBmp;
break;
}
if (!bmp.IsOk())
return;
rect = in_rect;
if (orientation == wxLEFT)
{
rect.SetX(in_rect.x);
rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
rect.SetWidth(bmp.GetWidth());
rect.SetHeight(bmp.GetHeight());
}
else
{
rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
bmp.GetWidth(), bmp.GetHeight());
}
IndentPressedBitmap(&rect, button_state);
dc.DrawBitmap(bmp, rect.x, rect.y, true);
*out_rect = rect;
}
void CLMainAuiTBArt::DrawButton(wxDC& dc, wxWindow* wnd, const wxAuiToolBarItem& item, const wxRect& rect)
{
wxAuiDefaultToolBarArt::DrawButton(dc, wnd, item, rect);
#if 0
// if(!DrawingUtils::IsThemeDark()) {
// wxAuiDefaultToolBarArt::DrawButton(dc, wnd, item, rect);
// return;
// }
int textWidth = 0, textHeight = 0;
if(m_flags & wxAUI_TB_TEXT) {
dc.SetFont(m_font);
int tx, ty;
dc.GetTextExtent(wxT("ABCDHgj"), &tx, &textHeight);
textWidth = 0;
dc.GetTextExtent(item.GetLabel(), &textWidth, &ty);
}
int bmpX = 0, bmpY = 0;
int textX = 0, textY = 0;
if(m_textOrientation == wxAUI_TBTOOL_TEXT_BOTTOM) {
bmpX = rect.x + (rect.width / 2) - (item.GetBitmap().GetWidth() / 2);
bmpY = rect.y + ((rect.height - textHeight) / 2) - (item.GetBitmap().GetHeight() / 2);
textX = rect.x + (rect.width / 2) - (textWidth / 2) + 1;
textY = rect.y + rect.height - textHeight - 1;
} else if(m_textOrientation == wxAUI_TBTOOL_TEXT_RIGHT) {
bmpX = rect.x + 3;
bmpY = rect.y + (rect.height / 2) - (item.GetBitmap().GetHeight() / 2);
textX = bmpX + 3 + item.GetBitmap().GetWidth();
textY = rect.y + (rect.height / 2) - (textHeight / 2);
}
if(!(item.GetState() & wxAUI_BUTTON_STATE_DISABLED)) {
if(item.GetState() & wxAUI_BUTTON_STATE_PRESSED) {
dc.SetPen(wxPen(m_highlightColour));
dc.SetBrush(wxBrush(m_highlightColour.ChangeLightness(150)));
dc.DrawRectangle(rect);
} else if((item.GetState() & wxAUI_BUTTON_STATE_HOVER) || item.IsSticky()) {
dc.SetPen(wxPen(m_highlightColour));
dc.SetBrush(wxBrush(m_highlightColour.ChangeLightness(170)));
// draw an even lighter background for checked item hovers (since
// the hover background is the same color as the check background)
if(item.GetState() & wxAUI_BUTTON_STATE_CHECKED)
dc.SetBrush(wxBrush(m_highlightColour.ChangeLightness(180)));
dc.DrawRectangle(rect);
} else if(item.GetState() & wxAUI_BUTTON_STATE_CHECKED) {
// it's important to put this code in an else statement after the
// hover, otherwise hovers won't draw properly for checked items
dc.SetPen(wxPen(m_highlightColour));
dc.SetBrush(wxBrush(m_highlightColour.ChangeLightness(170)));
dc.DrawRectangle(rect);
}
}
wxBitmap bmp;
if(item.GetState() & wxAUI_BUTTON_STATE_DISABLED) {
bmp = CreateDisabledBitmap(item.GetBitmap());
} else
bmp = item.GetBitmap();
if(bmp.IsOk()) dc.DrawBitmap(bmp, bmpX, bmpY, true);
// set the item's text color based on if it is disabled
dc.SetTextForeground(*wxBLACK);
if(item.GetState() & wxAUI_BUTTON_STATE_DISABLED) dc.SetTextForeground(DISABLED_TEXT_COLOR);
if((m_flags & wxAUI_TB_TEXT) && !item.GetLabel().empty()) {
dc.DrawText(item.GetLabel(), textX, textY);
}
#endif
}
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 wxImagePanel::render(wxDC& dc) {
dc.DrawBitmap( image, 0, 0, false );
}
