void CDragBar::AddTool(int id, const wxBitmap& bmp, const wxString& tooltip /*= wxEmptyString*/,
const wxBitmap& bmpDisabled /*= wxNullBitmap*/)
{
//all bitmaps must be same size
if (m_bmpWidth == 0)
m_bmpWidth = bmp.GetWidth();
else {
wxASSERT(m_bmpWidth == bmp.GetWidth());
}
if (m_bmpHeight == 0)
m_bmpHeight = bmp.GetHeight();
else {
wxASSERT(m_bmpHeight == bmp.GetHeight());
}
if (bmpDisabled.IsOk()) {
wxASSERT(m_bmpWidth == bmpDisabled.GetWidth());
wxASSERT(m_bmpHeight == bmpDisabled.GetHeight());
}
DragBarItem item;
item.id = id;
item.bmp = bmp;
item.bmpDisabled = bmpDisabled;
item.tooltip = tooltip;
item.enabled = true;
m_items.push_back( item );
}
void wxRibbonMetroArtProvider::DrawButtonBarButtonForeground(wxDC& dc, const wxRect& rect, wxRibbonButtonKind kind,
long state, const wxString& label,
const wxBitmap& bitmap_large, const wxBitmap& bitmap_small)
{
switch(state & wxRIBBON_BUTTONBAR_BUTTON_SIZE_MASK) {
case wxRIBBON_BUTTONBAR_BUTTON_LARGE: {
const int padding = 2;
dc.DrawBitmap(bitmap_large, rect.x + (rect.width - bitmap_large.GetWidth()) / 2, rect.y + padding, true);
int ypos = rect.y + padding + bitmap_large.GetHeight() + padding;
int arrow_width = kind == wxRIBBON_BUTTON_NORMAL ? 0 : 8;
wxCoord label_w, label_h;
dc.GetTextExtent(label, &label_w, &label_h);
if(label_w + 2 * padding <= rect.width) {
dc.DrawText(label, rect.x + (rect.width - label_w) / 2, ypos);
if(arrow_width != 0) {
DrawDropdownArrow(dc, rect.x + rect.width / 2, ypos + (label_h * 3) / 2, m_button_bar_label_colour);
}
} else {
size_t breaki = label.Len();
do {
--breaki;
if(wxRibbonCanLabelBreakAtPosition(label, breaki)) {
wxString label_top = label.Mid(0, breaki);
dc.GetTextExtent(label_top, &label_w, &label_h);
if(label_w + 2 * padding <= rect.width) {
dc.DrawText(label_top, rect.x + (rect.width - label_w) / 2, ypos);
ypos += label_h;
wxString label_bottom = label.Mid(breaki + 1);
dc.GetTextExtent(label_bottom, &label_w, &label_h);
label_w += arrow_width;
int iX = rect.x + (rect.width - label_w) / 2;
dc.DrawText(label_bottom, iX, ypos);
if(arrow_width != 0) {
DrawDropdownArrow(dc, iX + 2 + label_w - arrow_width, ypos + label_h / 2 + 1,
m_button_bar_label_colour);
}
break;
}
}
} while(breaki > 0);
}
} break;
case wxRIBBON_BUTTONBAR_BUTTON_MEDIUM: {
int x_cursor = rect.x + 2;
dc.DrawBitmap(bitmap_small, x_cursor, rect.y + (rect.height - bitmap_small.GetHeight()) / 2, true);
x_cursor += bitmap_small.GetWidth() + 2;
wxCoord label_w, label_h;
dc.GetTextExtent(label, &label_w, &label_h);
dc.DrawText(label, x_cursor, rect.y + (rect.height - label_h) / 2);
x_cursor += label_w + 3;
if(kind != wxRIBBON_BUTTON_NORMAL) {
DrawDropdownArrow(dc, x_cursor, rect.y + rect.height / 2, m_button_bar_label_colour);
}
break;
}
default:
// TODO
break;
}
}
wxBitmap clSplashScreen::CreateSplashScreenBitmap(const wxBitmap& origBmp)
{
wxBitmap bmp;
wxMemoryDC memDC;
bmp = wxBitmap(origBmp.GetWidth(), origBmp.GetHeight());
memDC.SelectObject(bmp);
memDC.SetBrush(wxColour(63, 80, 24));
memDC.SetPen(wxColour(63, 80, 24));
memDC.DrawRectangle(0, 0, origBmp.GetWidth(), origBmp.GetHeight());
memDC.DrawBitmap(origBmp, 0, 0, true);
memDC.SetPen(*wxWHITE);
memDC.SetBrush(*wxTRANSPARENT_BRUSH);
memDC.DrawRectangle(0, 0, origBmp.GetWidth(), origBmp.GetHeight());
wxFont font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
font.SetPointSize(14);
font.SetWeight(wxFONTWEIGHT_BOLD);
memDC.SetFont(font);
wxString versionString;
versionString << "v" << CODELITE_VERSION_STRING;
wxSize textSize = memDC.GetTextExtent(versionString);
wxCoord textx, texty;
textx = (bmp.GetWidth() - textSize.GetWidth()) - 5;
texty = 5;
memDC.DrawText(versionString, textx, texty);
memDC.SelectObject(wxNullBitmap);
return bmp;
}
void setImage(wxString path)
{
m_image_path = path;
if(path.EndsWith(wxT(".icns"))) {
wxExecute(wxT("sips -s format png '") + path + wxT("' --out /tmp/tmpicon.png"), wxEXEC_SYNC);
path = wxT("/tmp/tmpicon.png");
}
m_image.LoadFile(path, wxBITMAP_TYPE_ANY);
if(m_image.IsOk()) {
if(m_image.GetWidth() > 50 or m_image.GetHeight() > 50) {
wxImage tmp = m_image.ConvertToImage();
tmp.Rescale(50, 50, wxIMAGE_QUALITY_HIGH);
m_image = wxBitmap(tmp);
}
const int w = m_image.GetWidth();
const int h = m_image.GetHeight();
SetMinSize(wxSize(w + 20, h + 20));
SetMaxSize(wxSize(w + 20, h + 20));
Refresh(); // repaint needed to see change
} else {
wxMessageBox(_("Failed to load image"));
}
}
void wxHtmlImageCell::Draw(wxDC& dc, int x, int y,
int WXUNUSED(view_y1), int WXUNUSED(view_y2),
wxHtmlRenderingInfo& WXUNUSED(info))
{
if ( m_showFrame )
{
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.SetPen(*wxBLACK_PEN);
dc.DrawRectangle(x + m_PosX, y + m_PosY, m_Width, m_Height);
x++, y++;
}
if ( m_bitmap )
{
// We add in the scaling from the desired bitmap width
// and height, so we only do the scaling once.
double imageScaleX = 1.0;
double imageScaleY = 1.0;
if (m_Width != m_bitmap->GetWidth())
imageScaleX = (double) m_Width / (double) m_bitmap->GetWidth();
if (m_Height != m_bitmap->GetHeight())
imageScaleY = (double) m_Height / (double) m_bitmap->GetHeight();
double us_x, us_y;
dc.GetUserScale(&us_x, &us_y);
dc.SetUserScale(us_x * imageScaleX, us_y * imageScaleY);
dc.DrawBitmap(*m_bitmap, (int) ((x + m_PosX) / (imageScaleX)),
(int) ((y + m_PosY) / (imageScaleY)), true);
dc.SetUserScale(us_x, us_y);
}
}
int wxImageList::Add( const wxBitmap &bitmap )
{
wxASSERT_MSG( (bitmap.GetWidth() >= m_width && bitmap.GetHeight() == m_height)
|| (m_width == 0 && m_height == 0),
_T("invalid bitmap size in wxImageList: this might work ")
_T("on this platform but definitely won't under Windows.") );
// Mimic behavior of Windows ImageList_Add that automatically breaks up the added
// bitmap into sub-images of the correct size
if (m_width > 0 && bitmap.GetWidth() > m_width && bitmap.GetHeight() >= m_height)
{
int numImages = bitmap.GetWidth() / m_width;
for (int subIndex = 0; subIndex < numImages; subIndex++)
{
wxRect rect(m_width * subIndex, 0, m_width, m_height);
wxBitmap tmpBmp = bitmap.GetSubBitmap(rect);
m_images.Append( new wxBitmap(tmpBmp) );
}
}
else
{
m_images.Append( new wxBitmap(bitmap) );
}
if (m_width == 0 && m_height == 0)
{
m_width = bitmap.GetWidth();
m_height = bitmap.GetHeight();
}
return m_images.GetCount() - 1;
}
bool wxWizard::ResizeBitmap(wxBitmap& bmp)
{
if (!GetBitmapPlacement())
return false;
if (bmp.Ok())
{
wxSize pageSize = m_sizerPage->GetSize();
if (pageSize == wxSize(0,0))
pageSize = GetPageSize();
int bitmapWidth = wxMax(bmp.GetWidth(), GetMinimumBitmapWidth());
int bitmapHeight = pageSize.y;
if (!m_statbmp->GetBitmap().Ok() || m_statbmp->GetBitmap().GetHeight() != bitmapHeight)
{
wxBitmap bitmap(bitmapWidth, bitmapHeight);
{
wxMemoryDC dc;
dc.SelectObject(bitmap);
dc.SetBackground(wxBrush(m_bitmapBackgroundColour));
dc.Clear();
if (GetBitmapPlacement() & wxWIZARD_TILE)
{
TileBitmap(wxRect(0, 0, bitmapWidth, bitmapHeight), dc, bmp);
}
else
{
int x, y;
if (GetBitmapPlacement() & wxWIZARD_HALIGN_LEFT)
x = 0;
else if (GetBitmapPlacement() & wxWIZARD_HALIGN_RIGHT)
x = bitmapWidth - bmp.GetWidth();
else
x = (bitmapWidth - bmp.GetWidth())/2;
if (GetBitmapPlacement() & wxWIZARD_VALIGN_TOP)
y = 0;
else if (GetBitmapPlacement() & wxWIZARD_VALIGN_BOTTOM)
y = bitmapHeight - bmp.GetHeight();
else
y = (bitmapHeight - bmp.GetHeight())/2;
dc.DrawBitmap(bmp, x, y, true);
dc.SelectObject(wxNullBitmap);
}
}
bmp = bitmap;
}
}
return true;
}
virtual wxSize GetSize() const {
int xx, yy;
wxBitmap bmp(1, 1);
wxMemoryDC dc;
dc.SelectObject(bmp);
wxString s = m_value.GetString();
wxFont f = m_font;
dc.GetTextExtent(s, &xx, &yy, NULL, NULL, &f);
// Adjust the height to fit the bitmap height at least
yy < m_errorBmp.GetHeight() ? yy = m_errorBmp.GetHeight() : yy = yy;
return wxSize(xx, yy);
}
static void OverlaySymlink(wxBitmap& bmp)
{
// This is ugly, but apparently needed so that the data is _really_ in the right internal format
bmp = bmp.ConvertToImage();
wxBitmap symlink = wxArtProvider::GetBitmap(_T("ART_SYMLINK"), wxART_OTHER, wxSize(bmp.GetWidth(), bmp.GetHeight())).ConvertToImage();
wxAlphaPixelData target(bmp);
wxAlphaPixelData source(symlink);
int sx = bmp.GetWidth();
if (symlink.GetWidth() < sx)
sx = symlink.GetWidth();
int sy = bmp.GetHeight();
if (symlink.GetHeight() < sy)
sy = symlink.GetHeight();
// Do some rudimentary alpha copying
wxAlphaPixelData::Iterator t(target);
wxAlphaPixelData::Iterator s(source);
for (int y = 0; y < sy; y++)
{
s.MoveTo(source, 0, y);
t.MoveTo(target, 0, y);
for (int x = 0; x < sx; x++, s++, t++)
AlphaComposite_Over_Inplace(t, s);
}
}
void wxMemoryDCImpl::DoSelect( const wxBitmap& bitmap )
{
if ( m_selected.Ok() )
{
m_selected.EndRawAccess() ;
wxDELETE(m_graphicContext);
}
m_selected = bitmap;
if (m_selected.Ok())
{
if ( m_selected.GetDepth() != 1 )
m_selected.UseAlpha() ;
m_selected.BeginRawAccess() ;
m_width = bitmap.GetWidth();
m_height = bitmap.GetHeight();
CGColorSpaceRef genericColorSpace = wxMacGetGenericRGBColorSpace();
CGContextRef bmCtx = (CGContextRef) m_selected.GetHBITMAP();
if ( bmCtx )
{
CGContextSetFillColorSpace( bmCtx, genericColorSpace );
CGContextSetStrokeColorSpace( bmCtx, genericColorSpace );
SetGraphicsContext( wxGraphicsContext::CreateFromNative( bmCtx ) );
}
m_ok = (m_graphicContext != NULL) ;
}
else
{
m_ok = false;
}
}
bool wxBitmapComboBox::OnAddBitmap(const wxBitmap& bitmap)
{
if ( bitmap.Ok() )
{
int width = bitmap.GetWidth();
int height = bitmap.GetHeight();
if ( m_usedImgSize.x <= 0 )
{
//
// If size not yet determined, get it from this image.
m_usedImgSize.x = width;
m_usedImgSize.y = height;
InvalidateBestSize();
wxSize newSz = GetBestSize();
wxSize sz = GetSize();
if ( newSz.y > sz.y )
SetSize(sz.x, newSz.y);
else
DetermineIndent();
}
wxCHECK_MSG(width == m_usedImgSize.x && height == m_usedImgSize.y,
false,
wxT("you can only add images of same size"));
}
return true;
}
bool BM2CMP_FRAME::OpenProjectFiles( const std::vector<wxString>& aFileSet, int aCtl )
{
// Prj().MaybeLoadProjectSettings();
m_BitmapFileName = aFileSet[0];
if( !m_Pict_Image.LoadFile( m_BitmapFileName ) )
{
// LoadFile has its own UI, no need for further failure notification here
return false;
}
m_Pict_Bitmap = wxBitmap( m_Pict_Image );
int h = m_Pict_Bitmap.GetHeight();
int w = m_Pict_Bitmap.GetWidth();
// Determine image resolution in DPI (does not existing in all formats).
// the resolution can be given in bit per inches or bit per cm in file
m_imageDPI.x = m_Pict_Image.GetOptionInt( wxIMAGE_OPTION_RESOLUTIONX );
m_imageDPI.y = m_Pict_Image.GetOptionInt( wxIMAGE_OPTION_RESOLUTIONY );
if( m_imageDPI.x > 1 && m_imageDPI.y > 1 )
{
if( m_Pict_Image.GetOptionInt( wxIMAGE_OPTION_RESOLUTIONUNIT ) == wxIMAGE_RESOLUTION_CM )
{
// When the initial resolution is given in bits per cm,
// experience shows adding 1.27 to the resolution converted in dpi
// before convert to int value reduce the conversion error
// but it is not perfect
m_imageDPI.x = m_imageDPI.x * 2.54 + 1.27;
m_imageDPI.y = m_imageDPI.y * 2.54 + 1.27;
}
}
else // fallback to the default value
m_imageDPI.x = m_imageDPI.y = DEFAULT_DPI;
// Display image info:
// We are using ChangeValue here to avoid generating a wxEVT_TEXT event.
m_DPIValueX->ChangeValue( wxString::Format( wxT( "%d" ), m_imageDPI.x ) );
m_DPIValueY->ChangeValue( wxString::Format( wxT( "%d" ), m_imageDPI.y ) );
updateImageInfo();
m_InitialPicturePanel->SetVirtualSize( w, h );
m_GreyscalePicturePanel->SetVirtualSize( w, h );
m_BNPicturePanel->SetVirtualSize( w, h );
m_Greyscale_Image.Destroy();
m_Greyscale_Image = m_Pict_Image.ConvertToGreyscale( );
if( m_rbOptions->GetSelection() > 0 )
NegateGreyscaleImage( );
m_Greyscale_Bitmap = wxBitmap( m_Greyscale_Image );
m_NB_Image = m_Greyscale_Image;
Binarize( (double) m_sliderThreshold->GetValue()/m_sliderThreshold->GetMax() );
return true;
}
void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap)
{
m_bitmap = bitmap;
InvalidateBestSize();
SetSize(wxSize(bitmap.GetWidth(), bitmap.GetHeight()));
Refresh() ;
}
bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos,
const wxSize& s,
long style,
const wxString& name)
{
SetName(name);
wxSize size = s ;
if ( bitmap.Ok() )
{
if ( size.x == -1 )
size.x = bitmap.GetWidth() ;
if ( size.y == -1 )
size.y = bitmap.GetHeight() ;
}
m_backgroundColour = parent->GetBackgroundColour() ;
m_foregroundColour = parent->GetForegroundColour() ;
m_bitmap = bitmap;
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
m_windowStyle = style;
bool ret = wxControl::Create( parent, id, pos, size, style , wxDefaultValidator , name );
SetBestSize( size ) ;
return ret;
}
bool wxBitmapComboBoxBase::OnAddBitmap(const wxBitmap& bitmap)
{
if ( bitmap.IsOk() )
{
int width = bitmap.GetWidth();
int height = bitmap.GetHeight();
if ( m_usedImgSize.x < 0 )
{
// If size not yet determined, get it from this image.
m_usedImgSize.x = width;
m_usedImgSize.y = height;
// Adjust control size to vertically fit the bitmap
wxWindow* ctrl = GetControl();
ctrl->InvalidateBestSize();
wxSize newSz = ctrl->GetBestSize();
wxSize sz = ctrl->GetSize();
if ( newSz.y > sz.y )
ctrl->SetSize(sz.x, newSz.y);
else
DetermineIndent();
}
wxCHECK_MSG( width == m_usedImgSize.x && height == m_usedImgSize.y,
false,
"you can only add images of same size" );
return true;
}
return false;
}
wxBitmap ConvertTo24Bit( wxColor bgColor, wxBitmap front ) {
if( front.GetDepth() == 24 ) return front;
wxBitmap result( front.GetWidth(), front.GetHeight(), 24 );
front.UseAlpha();
wxImage im_front = front.ConvertToImage();
wxImage im_result = result.ConvertToImage();
unsigned char *presult = im_result.GetData();
unsigned char *pfront = im_front.GetData();
unsigned char *afront = NULL;
if( im_front.HasAlpha() )
afront = im_front.GetAlpha();
for( int i = 0; i < result.GetWidth(); i++ ) {
for( int j = 0; j < result.GetHeight(); j++ ) {
double alphaF = (double) ( *afront++ ) / 256.0;
unsigned char r = *pfront++ * alphaF + bgColor.Red() * ( 1.0 - alphaF );
*presult++ = r;
unsigned char g = *pfront++ * alphaF + bgColor.Green() * ( 1.0 - alphaF );
*presult++ = g;
unsigned char b = *pfront++ * alphaF + bgColor.Blue() * ( 1.0 - alphaF );
*presult++ = b;
}
}
result = wxBitmap( im_result );
return result;
}
static void wxDrawSplashBitmap(wxDC& dc, const wxBitmap& bitmap, int WXUNUSED(x), int WXUNUSED(y))
{
wxMemoryDC dcMem;
#ifdef USE_PALETTE_IN_SPLASH
bool hiColour = (wxDisplayDepth() >= 16) ;
if (bitmap.GetPalette() && !hiColour)
{
dcMem.SetPalette(* bitmap.GetPalette());
}
#endif // USE_PALETTE_IN_SPLASH
dcMem.SelectObjectAsSource(bitmap);
dc.Blit(0, 0, bitmap.GetWidth(), bitmap.GetHeight(), &dcMem, 0, 0, wxCOPY,
true /* use mask */);
dcMem.SelectObject(wxNullBitmap);
#ifdef USE_PALETTE_IN_SPLASH
if (bitmap.GetPalette() && !hiColour)
{
dcMem.SetPalette(wxNullPalette);
}
#endif // USE_PALETTE_IN_SPLASH
}
void wxBitmapComboBox::SetItemBitmap(unsigned int n, const wxBitmap& bitmap)
{
if ( bitmap.IsOk() )
{
if ( m_bitmapSize.x < 0 )
{
m_bitmapSize.x = bitmap.GetWidth();
m_bitmapSize.y = bitmap.GetHeight();
}
GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
GtkTreeModel *model = gtk_combo_box_get_model( combobox );
GtkTreeIter iter;
if ( gtk_tree_model_iter_nth_child( model, &iter, NULL, n ) )
{
GValue value0 = { 0, };
g_value_init( &value0, G_TYPE_OBJECT );
g_value_set_object( &value0, bitmap.GetPixbuf() );
gtk_list_store_set_value( GTK_LIST_STORE(model), &iter,
m_bitmapCellIndex, &value0 );
g_value_unset( &value0 );
}
}
}
int OutputViewControlBarButton::DoCalcButtonHeight(wxWindow *win, const wxString &text, const wxBitmap &bmp, int spacer)
{
int text_height(0);
int bmp_height (0);
int height (0);
wxUnusedVar(text);
// Calculate the text height
int xx;
wxString stam(wxT("Tp"));
wxFont font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
win->GetTextExtent(stam, &xx, &text_height, NULL, NULL, &font);
// bitmap
if ( bmp.IsOk() ) {
bmp_height += bmp.GetHeight();
}
height += spacer;
text_height > bmp_height ? height += text_height : height += bmp_height;
height += spacer;
return height;
}
void wxGCDCImpl::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y,
bool useMask )
{
wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid DC") );
wxCHECK_RET( bmp.IsOk(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid bitmap") );
int w = bmp.GetWidth();
int h = bmp.GetHeight();
if ( bmp.GetDepth() == 1 )
{
m_graphicContext->SetPen(*wxTRANSPARENT_PEN);
m_graphicContext->SetBrush( wxBrush( m_textBackgroundColour , wxSOLID ) );
m_graphicContext->DrawRectangle( x, y, w, h );
m_graphicContext->SetBrush( wxBrush( m_textForegroundColour , wxSOLID ) );
m_graphicContext->DrawBitmap( bmp, x, y, w, h );
m_graphicContext->SetBrush( m_graphicContext->CreateBrush(m_brush));
m_graphicContext->SetPen( m_graphicContext->CreatePen(m_pen));
}
else // not a monochrome bitmap, handle it normally
{
// make a copy in case we need to remove its mask, if we don't modify
// it the copy is cheap as bitmaps are reference-counted
wxBitmap bmpCopy(bmp);
if ( !useMask && bmp.GetMask() )
bmpCopy.SetMask(NULL);
m_graphicContext->DrawBitmap( bmpCopy, x, y, w, h );
}
}
void wxHtmlImageCell::Layout(int w)
{
if (m_bmpWpercent)
{
m_Width = w*m_bmpW/100;
if (!m_bmpHpresent && m_bitmap != NULL)
m_Height = m_bitmap->GetHeight()*m_Width/m_bitmap->GetWidth();
else
m_Height = static_cast<int>(m_scale*m_bmpH);
} else
{
m_Width = static_cast<int>(m_scale*m_bmpW);
m_Height = static_cast<int>(m_scale*m_bmpH);
}
switch (m_align)
{
case wxHTML_ALIGN_TOP :
m_Descent = m_Height;
break;
case wxHTML_ALIGN_CENTER :
m_Descent = m_Height / 2;
break;
case wxHTML_ALIGN_BOTTOM :
default :
m_Descent = 0;
break;
}
wxHtmlCell::Layout(w);
m_physX = m_physY = wxDefaultCoord;
}
void OverlayIcons(wxBitmap& bitmap) const
{
// To do this, we need to draw into a memory dc.
wxMemoryDC dc;
dc.SelectObject(bitmap);
wxBitmap icon(mIconImage);
icon.SetMask(new wxMask(icon, SKIN.Element(shIconTransparent)));
wxInt32 w = mIconImage.GetWidth();
wxInt32 h = mIconImage.GetHeight();
wxInt32 width = bitmap.GetWidth();
wxInt32 height = bitmap.GetHeight();
// Start in the lower right corner and draw up until we run out of
// room.
wxInt32 x = width - w;
wxInt32 y = height - h;
for(wxInt32 i = 0; i < mNumIcons; ++i)
{
dc.DrawBitmap(icon, x, y, true);
y -= h;
if(0 > y)
{
y = height - h;
x -= w;
}
}
dc.SelectObject(wxNullBitmap);
}
wxBuildBitmap(wxWindow* parent, wxWindowID id, const wxBitmap& bitmap)
: wxBaseBitmapButton(parent, id, wxPoint(1, 1),
wxSize(bitmap.GetWidth(), bitmap.GetHeight()))
, BuildPopup(this)
{
SetBitmaps(bitmap, bitmap);
}
wxSize wxAuiMSWTabArt::GetTabSize(wxDC& dc,
wxWindow* wnd,
const wxString& caption,
const wxBitmap& bitmap,
bool active,
int close_button_state,
int* x_extent)
{
if ( !IsThemed() )
return wxAuiGenericTabArt::GetTabSize(dc, wnd, caption, bitmap, active, close_button_state, x_extent);
if ( !m_closeBtnSize.IsFullySpecified() )
InitSizes(wnd, dc);
wxCoord textWidth, textHeight, tmp;
dc.SetFont(wnd->GetFont());
dc.GetTextExtent(caption, &textWidth, &tmp);
dc.GetTextExtent("ABCDEFXj", &tmp, &textHeight);
wxCoord tabWidth = wxMax(m_tabSize.x, textWidth);
wxCoord tabHeight = wxMax(m_tabSize.y, textHeight);
// if the close button is showing, add space for it
if ( close_button_state != wxAUI_BUTTON_STATE_HIDDEN )
{
tabWidth += m_closeBtnSize.x;
tabHeight = wxMax(tabHeight, m_closeBtnSize.y);
}
// if there's a bitmap, add space for it
if ( bitmap.IsOk() )
{
tabWidth += bitmap.GetWidth() + wnd->FromDIP(3); // bitmap padding
tabHeight = wxMax(tabHeight, bitmap.GetHeight() + wnd->FromDIP(2));
}
// add padding
tabWidth += wnd->FromDIP(12);
tabHeight += wnd->FromDIP(3);
if ( m_flags & wxAUI_NB_TAB_FIXED_WIDTH )
{
tabWidth = m_fixedTabWidth;
}
else
{
int minTabWidth = wnd->FromDIP(46);
if (tabWidth < minTabWidth)
tabWidth = minTabWidth;
}
*x_extent = tabWidth;
if (tabHeight > m_maxTabHeight)
m_maxTabHeight = tabHeight;
return wxSize(tabWidth, tabHeight);
}
void wxGCDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool WXUNUSED(useMask) )
{
wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid DC") );
wxCHECK_RET( bmp.Ok(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid bitmap") );
if ( bmp.GetDepth() == 1 )
{
m_graphicContext->SetPen(*wxTRANSPARENT_PEN);
m_graphicContext->SetBrush( wxBrush( m_textBackgroundColour , wxSOLID ) );
m_graphicContext->DrawRectangle( x , y , bmp.GetWidth() , bmp.GetHeight() );
m_graphicContext->SetBrush( wxBrush( m_textForegroundColour , wxSOLID ) );
m_graphicContext->DrawBitmap( bmp, x , y , bmp.GetWidth() , bmp.GetHeight() );
m_graphicContext->SetBrush( m_graphicContext->CreateBrush(m_brush));
m_graphicContext->SetPen( m_graphicContext->CreatePen(m_pen));
}
else
m_graphicContext->DrawBitmap( bmp, x , y , bmp.GetWidth() , bmp.GetHeight() );
}
void wxDC::DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask)
{
wxCHECK_RET( Ok(), wxT("invalid dc") );
wxCHECK_RET( bmp.Ok(), wxT("invalid bitmap") );
DoDrawSubBitmap(bmp,
0, 0, bmp.GetWidth(), bmp.GetHeight(),
x, y,
m_logicalFunction, useMask);
}
void ImageLoader::LoadImage(wxBitmap image)
{
int width = image.GetWidth();
int height = image.GetHeight();
Bitmap = image;
SetSize(width, height);
if ( centerOnParent ) {
CentreOnParent();
}
}
bool wxWizard::TileBitmap(const wxRect& rect, wxDC& dc, const wxBitmap& bitmap)
{
int w = bitmap.GetWidth();
int h = bitmap.GetHeight();
wxMemoryDC dcMem;
dcMem.SelectObjectAsSource(bitmap);
int i, j;
for (i = rect.x; i < rect.x + rect.width; i += w)
{
for (j = rect.y; j < rect.y + rect.height; j+= h)
dc.Blit(i, j, bitmap.GetWidth(), bitmap.GetHeight(), & dcMem, 0, 0);
}
dcMem.SelectObject(wxNullBitmap);
return true;
}
void wxPen::SetStipple(const wxBitmap& stipple)
{
wxCHECK_RET( stipple.Ok(), wxT("invalid bitmap") );
wxCHECK_RET( stipple.GetWidth() == 8 && stipple.GetHeight() == 8,
wxT("stipple bitmap must be 8x8") );
AllocExclusive();
M_PENDATA->m_stipple = stipple;
wxBitmapToPixPattern(stipple, &(M_PENDATA->m_pixPattern), NULL);
}
// Creates a bitmap with transparent areas drawn in
// the given colour.
wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, wxColour& colour)
{
wxBitmap newBitmap(bitmap.GetWidth(),
bitmap.GetHeight(),
bitmap.GetDepth());
wxMemoryDC destDC;
wxMemoryDC srcDC;
srcDC.SelectObject(bitmap);
destDC.SelectObject(newBitmap);
wxBrush brush(colour, wxSOLID);
destDC.SetBackground(brush);
destDC.Clear();
destDC.Blit(0, 0, bitmap.GetWidth(), bitmap.GetHeight(),
&srcDC, 0, 0, wxCOPY, true);
return newBitmap;
}