X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0024ec50861d01a82bca4b2a2a9ad6502d945aa0..b50e6e416e2b4cdc849ea6f24181094c0957d904:/src/msw/graphics.cpp diff --git a/src/msw/graphics.cpp b/src/msw/graphics.cpp index dbed8ff5c2..62d56a1023 100644 --- a/src/msw/graphics.cpp +++ b/src/msw/graphics.cpp @@ -11,37 +11,40 @@ #include "wx/wxprec.h" -#include "wx/dc.h" - #ifdef __BORLANDC__ -#pragma hdrstop + #pragma hdrstop #endif +#include "wx/dc.h" + #if wxUSE_GRAPHICS_CONTEXT #ifndef WX_PRECOMP -#include "wx/msw/wrapcdlg.h" -#include "wx/image.h" -#include "wx/window.h" -#include "wx/dc.h" -#include "wx/utils.h" -#include "wx/dialog.h" -#include "wx/app.h" -#include "wx/bitmap.h" -#include "wx/dcmemory.h" -#include "wx/log.h" -#include "wx/icon.h" -#include "wx/dcprint.h" -#include "wx/module.h" + #include "wx/msw/wrapcdlg.h" + #include "wx/image.h" + #include "wx/window.h" + #include "wx/utils.h" + #include "wx/dialog.h" + #include "wx/app.h" + #include "wx/bitmap.h" + #include "wx/log.h" + #include "wx/icon.h" + #include "wx/module.h" + // include all dc types that are used as a param + #include "wx/dc.h" + #include "wx/dcclient.h" + #include "wx/dcmemory.h" + #include "wx/dcprint.h" #endif -#include "wx/graphics.h" - -#include +#include "wx/private/graphics.h" +#include "wx/msw/wrapgdip.h" +#include "wx/msw/dc.h" +#include "wx/dcgraph.h" -using namespace std; +#include "wx/stack.h" -#include "wx/msw/wrapgdip.h" +WX_DECLARE_STACK(GraphicsState, GraphicsStates); //----------------------------------------------------------------------------- // constants @@ -81,7 +84,7 @@ static inline double RadToDeg(double deg) { return (deg * 180.0) / M_PI; } #include #endif -class WXDLLIMPEXP_CORE wxGDIPlusPathData : public wxGraphicsPathData +class wxGDIPlusPathData : public wxGraphicsPathData { public : wxGDIPlusPathData(wxGraphicsRenderer* renderer, GraphicsPath* path = NULL); @@ -143,13 +146,13 @@ public : // gets the bounding box enclosing all points (possibly including control points) virtual void GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const; - virtual bool Contains( wxDouble x, wxDouble y, int fillStyle = wxODDEVEN_RULE) const; + virtual bool Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle = wxODDEVEN_RULE) const; private : GraphicsPath* m_path; }; -class WXDLLIMPEXP_CORE wxGDIPlusMatrixData : public wxGraphicsMatrixData +class wxGDIPlusMatrixData : public wxGraphicsMatrixData { public : wxGDIPlusMatrixData(wxGraphicsRenderer* renderer, Matrix* matrix = NULL) ; @@ -206,7 +209,7 @@ private: Matrix* m_matrix ; } ; -class WXDLLIMPEXP_CORE wxGDIPlusPenData : public wxGraphicsObjectRefData +class wxGDIPlusPenData : public wxGraphicsObjectRefData { public: wxGDIPlusPenData( wxGraphicsRenderer* renderer, const wxPen &pen ); @@ -225,7 +228,7 @@ protected : wxDouble m_width; }; -class WXDLLIMPEXP_CORE wxGDIPlusBrushData : public wxGraphicsObjectRefData +class wxGDIPlusBrushData : public wxGraphicsObjectRefData { public: wxGDIPlusBrushData( wxGraphicsRenderer* renderer ); @@ -247,7 +250,21 @@ private : GraphicsPath* m_brushPath; }; -class WXDLLIMPEXP_CORE wxGDIPlusFontData : public wxGraphicsObjectRefData +class WXDLLIMPEXP_CORE wxGDIPlusBitmapData : public wxGraphicsObjectRefData +{ +public: + wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, Bitmap* bitmap ); + wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, const wxBitmap &bmp ); + ~wxGDIPlusBitmapData (); + + virtual Bitmap* GetGDIPlusBitmap() { return m_bitmap; } + +private : + Bitmap* m_bitmap; + Bitmap* m_helper; +}; + +class wxGDIPlusFontData : public wxGraphicsObjectRefData { public: wxGDIPlusFontData( wxGraphicsRenderer* renderer, const wxFont &font, const wxColour& col ); @@ -260,10 +277,10 @@ private : Font* m_font; }; -class WXDLLIMPEXP_CORE wxGDIPlusContext : public wxGraphicsContext +class wxGDIPlusContext : public wxGraphicsContext { public: - wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc ); + wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc , wxDouble width, wxDouble height ); wxGDIPlusContext( wxGraphicsRenderer* renderer, HWND hwnd ); wxGDIPlusContext( wxGraphicsRenderer* renderer, Graphics* gr); wxGDIPlusContext(); @@ -280,7 +297,21 @@ public: virtual void * GetNativeContext(); virtual void StrokePath( const wxGraphicsPath& p ); - virtual void FillPath( const wxGraphicsPath& p , int fillStyle = wxODDEVEN_RULE ); + virtual void FillPath( const wxGraphicsPath& p , wxPolygonFillMode fillStyle = wxODDEVEN_RULE ); + + // stroke lines connecting each of the points + virtual void StrokeLines( size_t n, const wxPoint2DDouble *points); + + // draws a polygon + virtual void DrawLines( size_t n, const wxPoint2DDouble *points, wxPolygonFillMode fillStyle = wxODDEVEN_RULE ); + + virtual bool SetAntialiasMode(wxAntialiasMode antialias); + + virtual bool SetCompositionMode(wxCompositionMode op); + + virtual void BeginLayer(wxDouble opacity); + + virtual void EndLayer(); virtual void Translate( wxDouble dx , wxDouble dy ); virtual void Scale( wxDouble xScale , wxDouble yScale ); @@ -295,28 +326,58 @@ public: // gets the matrix of this context virtual wxGraphicsMatrix GetTransform() const; + virtual void DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h ); virtual void DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h ); virtual void DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h ); virtual void PushState(); virtual void PopState(); - virtual void DrawText( const wxString &str, wxDouble x, wxDouble y); virtual void GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height, wxDouble *descent, wxDouble *externalLeading ) const; virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const; + virtual bool ShouldOffset() const; + virtual void GetSize( wxDouble* width, wxDouble *height ); private: void Init(); void SetDefaults(); + virtual void DoDrawText(const wxString& str, wxDouble x, wxDouble y) + { DoDrawFilledText(str, x, y, wxNullGraphicsBrush); } + virtual void DoDrawFilledText(const wxString& str, wxDouble x, wxDouble y, + const wxGraphicsBrush& backgroundBrush); + Graphics* m_context; - vector m_stateStack; + GraphicsStates m_stateStack; GraphicsState m_state1; GraphicsState m_state2; + wxDouble m_width; + wxDouble m_height; + DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusContext) }; +class wxGDIPlusMeasuringContext : public wxGDIPlusContext +{ +public: + wxGDIPlusMeasuringContext( wxGraphicsRenderer* renderer ) : wxGDIPlusContext( renderer , m_hdc = GetDC(NULL), 1000, 1000 ) + { + } + wxGDIPlusMeasuringContext() + { + } + + virtual ~wxGDIPlusMeasuringContext() + { + ReleaseDC( NULL, m_hdc ); + } + +private: + HDC m_hdc ; + DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusMeasuringContext) +} ; + //----------------------------------------------------------------------------- // wxGDIPlusPen implementation //----------------------------------------------------------------------------- @@ -604,6 +665,115 @@ wxGDIPlusFontData::~wxGDIPlusFontData() delete m_font; } +// the built-in conversions functions create non-premultiplied bitmaps, while GDIPlus needs them in the +// premultiplied format, therefore in the failing cases we create a new bitmap using the non-premultiplied +// bytes as parameter, since there is no real copying of the data going in, only references are stored +// m_helper has to be kept alive as well + +//----------------------------------------------------------------------------- +// wxGDIPlusBitmapData implementation +//----------------------------------------------------------------------------- + +wxGDIPlusBitmapData::wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, Bitmap* bitmap ) : + wxGraphicsObjectRefData( renderer ), m_bitmap( bitmap ) +{ + m_helper = NULL; +} + +wxGDIPlusBitmapData::wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, + const wxBitmap &bmp) : wxGraphicsObjectRefData( renderer ) +{ + m_bitmap = NULL; + m_helper = NULL; + + Bitmap* image = NULL; + if ( bmp.GetMask() ) + { + Bitmap interim((HBITMAP)bmp.GetHBITMAP(),(HPALETTE)bmp.GetPalette()->GetHPALETTE()) ; + + size_t width = interim.GetWidth(); + size_t height = interim.GetHeight(); + Rect bounds(0,0,width,height); + + image = new Bitmap(width,height,PixelFormat32bppPARGB) ; + + Bitmap interimMask((HBITMAP)bmp.GetMask()->GetMaskBitmap(),NULL); + wxASSERT(interimMask.GetPixelFormat() == PixelFormat1bppIndexed); + + BitmapData dataMask ; + interimMask.LockBits(&bounds,ImageLockModeRead, + interimMask.GetPixelFormat(),&dataMask); + + + BitmapData imageData ; + image->LockBits(&bounds,ImageLockModeWrite, PixelFormat32bppPARGB, &imageData); + + BYTE maskPattern = 0 ; + BYTE maskByte = 0; + size_t maskIndex ; + + for ( size_t y = 0 ; y < height ; ++y) + { + maskIndex = 0 ; + for( size_t x = 0 ; x < width; ++x) + { + if ( x % 8 == 0) + { + maskPattern = 0x80; + maskByte = *((BYTE*)dataMask.Scan0 + dataMask.Stride*y + maskIndex); + maskIndex++; + } + else + maskPattern = maskPattern >> 1; + + ARGB *dest = (ARGB*)((BYTE*)imageData.Scan0 + imageData.Stride*y + x*4); + if ( (maskByte & maskPattern) == 0 ) + *dest = 0x00000000; + else + { + Color c ; + interim.GetPixel(x,y,&c) ; + *dest = (c.GetValue() | Color::AlphaMask); + } + } + } + + image->UnlockBits(&imageData); + + interimMask.UnlockBits(&dataMask); + interim.UnlockBits(&dataMask); + } + else + { + image = Bitmap::FromHBITMAP((HBITMAP)bmp.GetHBITMAP(),(HPALETTE)bmp.GetPalette()->GetHPALETTE()); + if ( bmp.HasAlpha() && GetPixelFormatSize(image->GetPixelFormat()) == 32 ) + { + size_t width = image->GetWidth(); + size_t height = image->GetHeight(); + Rect bounds(0,0,width,height); + static BitmapData data ; + + m_helper = image ; + image = NULL ; + m_helper->LockBits(&bounds, ImageLockModeRead, + m_helper->GetPixelFormat(),&data); + + image = new Bitmap(data.Width, data.Height, data.Stride, + PixelFormat32bppPARGB , (BYTE*) data.Scan0); + + m_helper->UnlockBits(&data); + } + } + if ( image ) + m_bitmap = image; +} + +wxGDIPlusBitmapData::~wxGDIPlusBitmapData() +{ + delete m_bitmap; + delete m_helper; +} + //----------------------------------------------------------------------------- // wxGDIPlusPath implementation //----------------------------------------------------------------------------- @@ -668,7 +838,7 @@ void wxGDIPlusPathData::GetCurrentPoint( wxDouble* x, wxDouble* y) const void wxGDIPlusPathData::AddArc( wxDouble x, wxDouble y, wxDouble r, double startAngle, double endAngle, bool clockwise ) { double sweepAngle = endAngle - startAngle ; - if( abs(sweepAngle) >= 2*M_PI) + if( fabs(sweepAngle) >= 2*M_PI) { sweepAngle = 2 * M_PI; } @@ -717,7 +887,7 @@ void wxGDIPlusPathData::GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble * *h = bounds.Height; } -bool wxGDIPlusPathData::Contains( wxDouble x, wxDouble y, int fillStyle ) const +bool wxGDIPlusPathData::Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle ) const { m_path->SetFillMode( fillStyle == wxODDEVEN_RULE ? FillModeAlternate : FillModeWinding); return m_path->IsVisible( (FLOAT) x,(FLOAT) y) == TRUE ; @@ -846,12 +1016,35 @@ void * wxGDIPlusMatrixData::GetNativeMatrix() const //----------------------------------------------------------------------------- IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusContext,wxGraphicsContext) +IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusMeasuringContext,wxGDIPlusContext) + +class wxGDIPlusOffsetHelper +{ +public : + wxGDIPlusOffsetHelper( Graphics* gr , bool offset ) + { + m_gr = gr; + m_offset = offset; + if ( m_offset ) + m_gr->TranslateTransform( 0.5, 0.5 ); + } + ~wxGDIPlusOffsetHelper( ) + { + if ( m_offset ) + m_gr->TranslateTransform( -0.5, -0.5 ); + } +public : + Graphics* m_gr; + bool m_offset; +} ; -wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc ) +wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc, wxDouble width, wxDouble height ) : wxGraphicsContext(renderer) { Init(); m_context = new Graphics( hdc); + m_width = width; + m_height = height; SetDefaults(); } @@ -860,6 +1053,9 @@ wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HWND hwnd ) { Init(); m_context = new Graphics( hwnd); + RECT rect = wxGetWindowRect(hwnd); + m_width = rect.right - rect.left; + m_height = rect.bottom - rect.top; SetDefaults(); } @@ -881,10 +1077,14 @@ void wxGDIPlusContext::Init() m_context = NULL; m_state1 = 0; m_state2= 0; + m_height = 0; + m_width = 0; } void wxGDIPlusContext::SetDefaults() { + m_context->SetTextRenderingHint(TextRenderingHintSystemDefault); + m_context->SetPixelOffsetMode(PixelOffsetModeHalf); m_context->SetSmoothingMode(SmoothingModeHighQuality); m_state1 = m_context->Save(); m_state2 = m_context->Save(); @@ -917,24 +1117,132 @@ void wxGDIPlusContext::ResetClip() m_context->ResetClip(); } +void wxGDIPlusContext::StrokeLines( size_t n, const wxPoint2DDouble *points) +{ + if (m_composition == wxCOMPOSITION_DEST) + return; + + if ( !m_pen.IsNull() ) + { + wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() ); + Point *cpoints = new Point[n]; + for (size_t i = 0; i < n; i++) + { + cpoints[i].X = (int)(points[i].m_x ); + cpoints[i].Y = (int)(points[i].m_y ); + + } // for (size_t i = 0; i < n; i++) + m_context->DrawLines( ((wxGDIPlusPenData*)m_pen.GetGraphicsData())->GetGDIPlusPen() , cpoints , n ) ; + delete[] cpoints; + } +} + +void wxGDIPlusContext::DrawLines( size_t n, const wxPoint2DDouble *points, wxPolygonFillMode WXUNUSED(fillStyle) ) +{ + if (m_composition == wxCOMPOSITION_DEST) + return; + + wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() ); + Point *cpoints = new Point[n]; + for (size_t i = 0; i < n; i++) + { + cpoints[i].X = (int)(points[i].m_x ); + cpoints[i].Y = (int)(points[i].m_y ); + + } // for (int i = 0; i < n; i++) + if ( !m_brush.IsNull() ) + m_context->FillPolygon( ((wxGDIPlusBrushData*)m_brush.GetRefData())->GetGDIPlusBrush() , cpoints , n ) ; + if ( !m_pen.IsNull() ) + m_context->DrawLines( ((wxGDIPlusPenData*)m_pen.GetGraphicsData())->GetGDIPlusPen() , cpoints , n ) ; + delete[] cpoints; +} + void wxGDIPlusContext::StrokePath( const wxGraphicsPath& path ) { + if (m_composition == wxCOMPOSITION_DEST) + return; + if ( !m_pen.IsNull() ) { + wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() ); m_context->DrawPath( ((wxGDIPlusPenData*)m_pen.GetGraphicsData())->GetGDIPlusPen() , (GraphicsPath*) path.GetNativePath() ); } } -void wxGDIPlusContext::FillPath( const wxGraphicsPath& path , int fillStyle ) +void wxGDIPlusContext::FillPath( const wxGraphicsPath& path , wxPolygonFillMode fillStyle ) { + if (m_composition == wxCOMPOSITION_DEST) + return; + if ( !m_brush.IsNull() ) { + wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() ); ((GraphicsPath*) path.GetNativePath())->SetFillMode( fillStyle == wxODDEVEN_RULE ? FillModeAlternate : FillModeWinding); m_context->FillPath( ((wxGDIPlusBrushData*)m_brush.GetRefData())->GetGDIPlusBrush() , (GraphicsPath*) path.GetNativePath()); } } +bool wxGDIPlusContext::SetAntialiasMode(wxAntialiasMode antialias) +{ + if (m_antialias == antialias) + return true; + + m_antialias = antialias; + + SmoothingMode antialiasMode; + switch (antialias) + { + case wxANTIALIAS_DEFAULT: + antialiasMode = SmoothingModeHighQuality; + break; + case wxANTIALIAS_NONE: + antialiasMode = SmoothingModeNone; + break; + default: + return false; + } + m_context->SetSmoothingMode(antialiasMode); + return true; +} + +bool wxGDIPlusContext::SetCompositionMode(wxCompositionMode op) +{ + if ( m_composition == op ) + return true; + + m_composition = op; + + if (m_composition == wxCOMPOSITION_DEST) + return true; + + CompositingMode cop; + switch (op) + { + case wxCOMPOSITION_SOURCE: + cop = CompositingModeSourceCopy; + break; + case wxCOMPOSITION_OVER: + cop = CompositingModeSourceOver; + break; + default: + return false; + } + + m_context->SetCompositingMode(cop); + return true; +} + +void wxGDIPlusContext::BeginLayer(wxDouble /* opacity */) +{ + // TODO +} + +void wxGDIPlusContext::EndLayer() +{ + // TODO +} + void wxGDIPlusContext::Rotate( wxDouble angle ) { m_context->RotateTransform( RadToDeg(angle) ); @@ -953,121 +1261,61 @@ void wxGDIPlusContext::Scale( wxDouble xScale , wxDouble yScale ) void wxGDIPlusContext::PushState() { GraphicsState state = m_context->Save(); - m_stateStack.push_back(state); + m_stateStack.push(state); } void wxGDIPlusContext::PopState() { - GraphicsState state = m_stateStack.back(); - m_stateStack.pop_back(); + GraphicsState state = m_stateStack.top(); + m_stateStack.pop(); m_context->Restore(state); } -// the built-in conversions functions create non-premultiplied bitmaps, while GDIPlus needs them in the -// premultiplied format, therefore in the failing cases we create a new bitmap using the non-premultiplied -// bytes as parameter - -void wxGDIPlusContext::DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) +void wxGDIPlusContext::DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) { - Bitmap* image = NULL; - Bitmap* helper = NULL; - if ( bmp.GetMask() ) - { - Bitmap interim((HBITMAP)bmp.GetHBITMAP(),(HPALETTE)bmp.GetPalette()->GetHPALETTE()) ; - - size_t width = interim.GetWidth(); - size_t height = interim.GetHeight(); - Rect bounds(0,0,width,height); - - image = new Bitmap(width,height,PixelFormat32bppPARGB) ; - - Bitmap interimMask((HBITMAP)bmp.GetMask()->GetMaskBitmap(),NULL); - wxASSERT(interimMask.GetPixelFormat() == PixelFormat1bppIndexed); - - BitmapData dataMask ; - interimMask.LockBits(&bounds,ImageLockModeRead, - interimMask.GetPixelFormat(),&dataMask); - - - BitmapData imageData ; - image->LockBits(&bounds,ImageLockModeWrite, PixelFormat32bppPARGB, &imageData); - - BYTE maskPattern = 0 ; - BYTE maskByte = 0; - size_t maskIndex ; - - for ( size_t y = 0 ; y < height ; ++y) - { - maskIndex = 0 ; - for( size_t x = 0 ; x < width; ++x) - { - if ( x % 8 == 0) - { - maskPattern = 0x80; - maskByte = *((BYTE*)dataMask.Scan0 + dataMask.Stride*y + maskIndex); - maskIndex++; - } - else - maskPattern = maskPattern >> 1; - - ARGB *dest = (ARGB*)((BYTE*)imageData.Scan0 + imageData.Stride*y + x*4); - if ( (maskByte & maskPattern) == 0 ) - *dest = 0x00000000; - else - { - Color c ; - interim.GetPixel(x,y,&c) ; - *dest = (c.GetValue() | Color::AlphaMask); - } - } - } - - image->UnlockBits(&imageData); + if (m_composition == wxCOMPOSITION_DEST) + return; - interimMask.UnlockBits(&dataMask); - interim.UnlockBits(&dataMask); - } - else + Bitmap* image = static_cast(bmp.GetRefData())->GetGDIPlusBitmap(); + if ( image ) { - image = Bitmap::FromHBITMAP((HBITMAP)bmp.GetHBITMAP(),(HPALETTE)bmp.GetPalette()->GetHPALETTE()); - if ( GetPixelFormatSize(image->GetPixelFormat()) == 32 ) + if( image->GetWidth() != (UINT) w || image->GetHeight() != (UINT) h ) { - size_t width = image->GetWidth(); - size_t height = image->GetHeight(); - Rect bounds(0,0,width,height); - BitmapData data ; - - helper = image ; - image = NULL ; - helper->LockBits(&bounds, ImageLockModeRead, - helper->GetPixelFormat(),&data); - - image = new Bitmap(data.Width, data.Height, data.Stride, - PixelFormat32bppARGB , (BYTE*) data.Scan0); - - helper->UnlockBits(&data); + Rect drawRect((REAL) x, (REAL)y, (REAL)w, (REAL)h); + m_context->SetPixelOffsetMode( PixelOffsetModeNone ); + m_context->DrawImage(image, drawRect, 0 , 0 , image->GetWidth()-1, image->GetHeight()-1, UnitPixel ) ; + m_context->SetPixelOffsetMode( PixelOffsetModeHalf ); } + else + m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ; } - if ( image ) - m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ; - delete image ; - delete helper ; +} + +void wxGDIPlusContext::DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) +{ + wxGraphicsBitmap bitmap = GetRenderer()->CreateBitmap(bmp); + DrawBitmap(bitmap, x, y, w, h); } void wxGDIPlusContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) { + if (m_composition == wxCOMPOSITION_DEST) + return; + + // the built-in conversion fails when there is alpha in the HICON (eg XP style icons), we can only + // find out by looking at the bitmap data whether there really was alpha in it HICON hIcon = (HICON)icon.GetHICON(); ICONINFO iconInfo ; // IconInfo creates the bitmaps for color and mask, we must dispose of them after use if (!GetIconInfo(hIcon,&iconInfo)) return; - BITMAP iconBmpData ; - GetObject(iconInfo.hbmColor,sizeof(BITMAP),&iconBmpData); Bitmap interim(iconInfo.hbmColor,NULL); Bitmap* image = NULL ; + // if it's not 32 bit, it doesn't have an alpha channel, note that since the conversion doesn't + // work correctly, asking IsAlphaPixelFormat at this point fails as well if( GetPixelFormatSize(interim.GetPixelFormat())!= 32 ) { image = Bitmap::FromHICON(hIcon); @@ -1081,8 +1329,28 @@ void wxGDIPlusContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxD interim.LockBits(&bounds, ImageLockModeRead, interim.GetPixelFormat(),&data); + + bool hasAlpha = false; + for ( size_t y = 0 ; y < height && !hasAlpha ; ++y) + { + for( size_t x = 0 ; x < width && !hasAlpha; ++x) + { + ARGB *dest = (ARGB*)((BYTE*)data.Scan0 + data.Stride*y + x*4); + if ( ( *dest & Color::AlphaMask ) != 0 ) + hasAlpha = true; + } + } + + if ( hasAlpha ) + { image = new Bitmap(data.Width, data.Height, data.Stride, PixelFormat32bppARGB , (BYTE*) data.Scan0); + } + else + { + image = Bitmap::FromHICON(hIcon); + } + interim.UnlockBits(&data); } @@ -1093,20 +1361,41 @@ void wxGDIPlusContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxD DeleteObject(iconInfo.hbmMask); } -void wxGDIPlusContext::DrawText( const wxString &str, wxDouble x, wxDouble y ) +void wxGDIPlusContext::DoDrawFilledText(const wxString& str, + wxDouble x, wxDouble y, + const wxGraphicsBrush& brush) { - if ( m_font.IsNull() || str.IsEmpty()) + if (m_composition == wxCOMPOSITION_DEST) + return; + + wxCHECK_RET( !m_font.IsNull(), + wxT("wxGDIPlusContext::DrawText - no valid font set") ); + + if ( str.IsEmpty()) return ; - wxWCharBuffer s = str.wc_str( *wxConvUI ); - m_context->DrawString( s , -1 , ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusFont() , - PointF( x , y ) , ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusBrush() ); - // TODO m_backgroundMode == wxSOLID + wxGDIPlusFontData * const + fontData = (wxGDIPlusFontData *)m_font.GetRefData(); + wxGDIPlusBrushData * const + brushData = (wxGDIPlusBrushData *)brush.GetRefData(); + + m_context->DrawString + ( + str.wc_str(*wxConvUI), // string to draw, always Unicode + -1, // length: string is NUL-terminated + fontData->GetGDIPlusFont(), + PointF(x, y), + StringFormat::GenericTypographic(), + brushData ? brushData->GetGDIPlusBrush() + : fontData->GetGDIPlusBrush() + ); } void wxGDIPlusContext::GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height, wxDouble *descent, wxDouble *externalLeading ) const { + wxCHECK_RET( !m_font.IsNull(), wxT("wxGDIPlusContext::GetTextExtent - no valid font set") ); + wxWCharBuffer s = str.wc_str( *wxConvUI ); FontFamily ffamily ; Font* f = ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusFont(); @@ -1123,11 +1412,11 @@ void wxGDIPlusContext::GetTextExtent( const wxString &str, wxDouble *width, wxDo f->GetSize() / ffamily.GetEmHeight(FontStyleRegular); if ( height ) - *height = rHeight * factorY + 0.5 ; + *height = rHeight * factorY; if ( descent ) - *descent = rDescent * factorY + 0.5 ; + *descent = rDescent * factorY; if ( externalLeading ) - *externalLeading = (rHeight - rAscent - rDescent) * factorY + 0.5 ; + *externalLeading = (rHeight - rAscent - rDescent) * factorY; // measuring empty strings is not guaranteed, so do it by hand if ( str.IsEmpty()) { @@ -1136,18 +1425,14 @@ void wxGDIPlusContext::GetTextExtent( const wxString &str, wxDouble *width, wxDo } else { - // MeasureString does return a rectangle that is way too large, so it is - // not usable here RectF layoutRect(0,0, 100000.0f, 100000.0f); - StringFormat strFormat; - CharacterRange strRange(0,wcslen(s)); - strFormat.SetMeasurableCharacterRanges(1,&strRange); - Region region ; - m_context->MeasureCharacterRanges(s, -1 , f,layoutRect, &strFormat,1,®ion) ; - RectF bbox ; - region.GetBounds(&bbox,m_context); + StringFormat strFormat( StringFormat::GenericTypographic() ); + strFormat.SetFormatFlags( StringFormatFlagsMeasureTrailingSpaces | strFormat.GetFormatFlags() ); + + RectF bounds ; + m_context->MeasureString((const wchar_t *) s , wcslen(s) , f, layoutRect, &strFormat, &bounds ) ; if ( width ) - *width = bbox.GetRight()-bbox.GetLeft()+0.5; + *width = bounds.Width; } } @@ -1156,6 +1441,8 @@ void wxGDIPlusContext::GetPartialTextExtents(const wxString& text, wxArrayDouble widths.Empty(); widths.Add(0, text.length()); + wxCHECK_RET( !m_font.IsNull(), wxT("wxGDIPlusContext::GetPartialTextExtents - no valid font set") ); + if (text.empty()) return; @@ -1165,24 +1452,51 @@ void wxGDIPlusContext::GetPartialTextExtents(const wxString& text, wxArrayDouble wxASSERT_MSG(text.length() == len , wxT("GetPartialTextExtents not yet implemented for multichar situations")); RectF layoutRect(0,0, 100000.0f, 100000.0f); - StringFormat strFormat; + StringFormat strFormat( StringFormat::GenericTypographic() ); - CharacterRange* ranges = new CharacterRange[len] ; - Region* regions = new Region[len]; - for( size_t i = 0 ; i < len ; ++i) + size_t startPosition = 0; + size_t remainder = len; + const size_t maxSpan = 32; + CharacterRange* ranges = new CharacterRange[maxSpan] ; + Region* regions = new Region[maxSpan]; + + while( remainder > 0 ) { - ranges[i].First = i ; - ranges[i].Length = 1 ; + size_t span = wxMin( maxSpan, remainder ); + + for( size_t i = 0 ; i < span ; ++i) + { + ranges[i].First = 0 ; + ranges[i].Length = startPosition+i+1 ; + } + strFormat.SetMeasurableCharacterRanges(span,ranges); + strFormat.SetFormatFlags( StringFormatFlagsMeasureTrailingSpaces | strFormat.GetFormatFlags() ); + m_context->MeasureCharacterRanges(ws, -1 , f,layoutRect, &strFormat,span,regions) ; + + RectF bbox ; + for ( size_t i = 0 ; i < span ; ++i) + { + regions[i].GetBounds(&bbox,m_context); + widths[startPosition+i] = bbox.Width; + } + remainder -= span; + startPosition += span; } - strFormat.SetMeasurableCharacterRanges(len,ranges); - m_context->MeasureCharacterRanges(ws, -1 , f,layoutRect, &strFormat,1,regions) ; - RectF bbox ; - for ( size_t i = 0 ; i < len ; ++i) + delete[] ranges; + delete[] regions; +} + +bool wxGDIPlusContext::ShouldOffset() const +{ + int penwidth = 0 ; + if ( !m_pen.IsNull() ) { - regions[i].GetBounds(&bbox,m_context); - widths[i] = bbox.GetRight()-bbox.GetLeft(); + penwidth = (int)((wxGDIPlusPenData*)m_pen.GetRefData())->GetWidth(); + if ( penwidth == 0 ) + penwidth = 1; } + return ( penwidth % 2 ) == 1; } void* wxGDIPlusContext::GetNativeContext() @@ -1209,22 +1523,28 @@ wxGraphicsMatrix wxGDIPlusContext::GetTransform() const m_context->GetTransform((Matrix*) matrix.GetNativeMatrix()); return matrix; } + +void wxGDIPlusContext::GetSize( wxDouble* width, wxDouble *height ) +{ + *width = m_width; + *height = m_height; +} //----------------------------------------------------------------------------- // wxGDIPlusRenderer declaration //----------------------------------------------------------------------------- -class WXDLLIMPEXP_CORE wxGDIPlusRenderer : public wxGraphicsRenderer +class wxGDIPlusRenderer : public wxGraphicsRenderer { public : wxGDIPlusRenderer() { - m_loaded = false; + m_loaded = -1; m_gditoken = 0; } virtual ~wxGDIPlusRenderer() { - if (m_loaded) + if ( m_loaded == 1 ) { Unload(); } @@ -1236,6 +1556,8 @@ public : virtual wxGraphicsContext * CreateContext( const wxMemoryDC& dc); + virtual wxGraphicsContext * CreateContext( const wxPrinterDC& dc); + virtual wxGraphicsContext * CreateContextFromNativeContext( void * context ); virtual wxGraphicsContext * CreateContextFromNativeWindow( void * window ); @@ -1269,13 +1591,24 @@ public : // sets the font virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) ; + + // create a native bitmap representation + virtual wxGraphicsBitmap CreateBitmap( const wxBitmap &bitmap ); + + // create a graphics bitmap from a native bitmap + virtual wxGraphicsBitmap CreateBitmapFromNativeBitmap( void* bitmap ); + + // create a subimage from a native image representation + virtual wxGraphicsBitmap CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h ); + protected : - void EnsureIsLoaded(); + bool EnsureIsLoaded(); void Load(); void Unload(); + friend class wxGDIPlusRendererModule; private : - bool m_loaded; + int m_loaded; ULONG_PTR m_gditoken; DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusRenderer) @@ -1294,64 +1627,98 @@ wxGraphicsRenderer* wxGraphicsRenderer::GetDefaultRenderer() return &gs_GDIPlusRenderer; } -void wxGDIPlusRenderer::EnsureIsLoaded() +bool wxGDIPlusRenderer::EnsureIsLoaded() { - if (!m_loaded) + // load gdiplus.dll if not yet loaded, but don't bother doing it again + // if we already tried and failed (we don't want to spend lot of time + // returning NULL from wxGraphicsContext::Create(), which may be called + // relatively frequently): + if ( m_loaded == -1 ) { Load(); } + + return m_loaded == 1; } +// call EnsureIsLoaded() and return returnOnFail value if it fails +#define ENSURE_LOADED_OR_RETURN(returnOnFail) \ + if ( !EnsureIsLoaded() ) \ + return (returnOnFail) + + void wxGDIPlusRenderer::Load() { GdiplusStartupInput input; GdiplusStartupOutput output; - GdiplusStartup(&m_gditoken,&input,&output); - m_loaded = true; + if ( GdiplusStartup(&m_gditoken,&input,&output) == Gdiplus::Ok ) + { + wxLogTrace("gdiplus", "successfully initialized GDI+"); + m_loaded = 1; + } + else + { + wxLogTrace("gdiplus", "failed to initialize GDI+, missing gdiplus.dll?"); + m_loaded = 0; + } } void wxGDIPlusRenderer::Unload() { if ( m_gditoken ) + { GdiplusShutdown(m_gditoken); + m_gditoken = NULL; + } + m_loaded = -1; // next Load() will try again } wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxWindowDC& dc) { - EnsureIsLoaded(); - return new wxGDIPlusContext(this,(HDC) dc.GetHDC()); + ENSURE_LOADED_OR_RETURN(NULL); + wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl ); + wxSize sz = dc.GetSize(); + return new wxGDIPlusContext(this,(HDC) msw->GetHDC(), sz.x, sz.y); +} + +wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxPrinterDC& dc) +{ + ENSURE_LOADED_OR_RETURN(NULL); + wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl ); + wxSize sz = dc.GetSize(); + return new wxGDIPlusContext(this,(HDC) msw->GetHDC(), sz.x, sz.y); } wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxMemoryDC& dc) { - EnsureIsLoaded(); - return new wxGDIPlusContext(this,(HDC) dc.GetHDC()); + ENSURE_LOADED_OR_RETURN(NULL); + wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl ); + wxSize sz = dc.GetSize(); + return new wxGDIPlusContext(this,(HDC) msw->GetHDC(), sz.x, sz.y); } wxGraphicsContext * wxGDIPlusRenderer::CreateMeasuringContext() { - EnsureIsLoaded(); - return NULL; - // TODO use GetDC(NULL) but then we have to release it from the context - //return new wxGDIPlusContext(this,(HDC) dc.GetHDC()); + ENSURE_LOADED_OR_RETURN(NULL); + return new wxGDIPlusMeasuringContext(this); } wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeContext( void * context ) { - EnsureIsLoaded(); + ENSURE_LOADED_OR_RETURN(NULL); return new wxGDIPlusContext(this,(Graphics*) context); } wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeWindow( void * window ) { - EnsureIsLoaded(); + ENSURE_LOADED_OR_RETURN(NULL); return new wxGDIPlusContext(this,(HWND) window); } wxGraphicsContext * wxGDIPlusRenderer::CreateContext( wxWindow* window ) { - EnsureIsLoaded(); + ENSURE_LOADED_OR_RETURN(NULL); return new wxGDIPlusContext(this, (HWND) window->GetHWND() ); } @@ -1359,7 +1726,7 @@ wxGraphicsContext * wxGDIPlusRenderer::CreateContext( wxWindow* window ) wxGraphicsPath wxGDIPlusRenderer::CreatePath() { - EnsureIsLoaded(); + ENSURE_LOADED_OR_RETURN(wxNullGraphicsPath); wxGraphicsPath m; m.SetRefData( new wxGDIPlusPathData(this)); return m; @@ -1372,7 +1739,7 @@ wxGraphicsMatrix wxGDIPlusRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDoub wxDouble tx, wxDouble ty) { - EnsureIsLoaded(); + ENSURE_LOADED_OR_RETURN(wxNullGraphicsMatrix); wxGraphicsMatrix m; wxGDIPlusMatrixData* data = new wxGDIPlusMatrixData( this ); data->Set( a,b,c,d,tx,ty ) ; @@ -1382,7 +1749,7 @@ wxGraphicsMatrix wxGDIPlusRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDoub wxGraphicsPen wxGDIPlusRenderer::CreatePen(const wxPen& pen) { - EnsureIsLoaded(); + ENSURE_LOADED_OR_RETURN(wxNullGraphicsPen); if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT ) return wxNullGraphicsPen; else @@ -1395,7 +1762,7 @@ wxGraphicsPen wxGDIPlusRenderer::CreatePen(const wxPen& pen) wxGraphicsBrush wxGDIPlusRenderer::CreateBrush(const wxBrush& brush ) { - EnsureIsLoaded(); + ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush); if ( !brush.Ok() || brush.GetStyle() == wxTRANSPARENT ) return wxNullGraphicsBrush; else @@ -1410,7 +1777,7 @@ wxGraphicsBrush wxGDIPlusRenderer::CreateBrush(const wxBrush& brush ) wxGraphicsBrush wxGDIPlusRenderer::CreateLinearGradientBrush( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2, const wxColour&c1, const wxColour&c2) { - EnsureIsLoaded(); + ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush); wxGraphicsBrush p; wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this ); d->CreateLinearGradientBrush(x1, y1, x2, y2, c1, c2); @@ -1423,7 +1790,7 @@ wxGraphicsBrush wxGDIPlusRenderer::CreateLinearGradientBrush( wxDouble x1, wxDou wxGraphicsBrush wxGDIPlusRenderer::CreateRadialGradientBrush( wxDouble xo, wxDouble yo, wxDouble xc, wxDouble yc, wxDouble radius, const wxColour &oColor, const wxColour &cColor) { - EnsureIsLoaded(); + ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush); wxGraphicsBrush p; wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this ); d->CreateRadialGradientBrush(xo,yo,xc,yc,radius,oColor,cColor); @@ -1434,7 +1801,7 @@ wxGraphicsBrush wxGDIPlusRenderer::CreateRadialGradientBrush( wxDouble xo, wxDou // sets the font wxGraphicsFont wxGDIPlusRenderer::CreateFont( const wxFont &font , const wxColour &col ) { - EnsureIsLoaded(); + ENSURE_LOADED_OR_RETURN(wxNullGraphicsFont); if ( font.Ok() ) { wxGraphicsFont p; @@ -1445,4 +1812,85 @@ wxGraphicsFont wxGDIPlusRenderer::CreateFont( const wxFont &font , const wxColou return wxNullGraphicsFont; } +wxGraphicsBitmap wxGDIPlusRenderer::CreateBitmap( const wxBitmap &bitmap ) +{ + ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap); + if ( bitmap.Ok() ) + { + wxGraphicsBitmap p; + p.SetRefData(new wxGDIPlusBitmapData( this , bitmap )); + return p; + } + else + return wxNullGraphicsBitmap; +} + +wxGraphicsBitmap wxGDIPlusRenderer::CreateBitmapFromNativeBitmap( void *bitmap ) +{ + ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap); + if ( bitmap != NULL ) + { + wxGraphicsBitmap p; + p.SetRefData(new wxGDIPlusBitmapData( this , (Bitmap*) bitmap )); + return p; + } + else + return wxNullGraphicsBitmap; +} + +wxGraphicsBitmap wxGDIPlusRenderer::CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h ) +{ + ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap); + Bitmap* image = static_cast(bitmap.GetRefData())->GetGDIPlusBitmap(); + if ( image ) + { + wxGraphicsBitmap p; + p.SetRefData(new wxGDIPlusBitmapData( this , image->Clone( (REAL) x , (REAL) y , (REAL) w , (REAL) h , PixelFormat32bppPARGB) )); + return p; + } + else + return wxNullGraphicsBitmap; +} + +// Shutdown GDI+ at app exit, before possible dll unload +class wxGDIPlusRendererModule : public wxModule +{ +public: + virtual bool OnInit() { return true; } + virtual void OnExit() { gs_GDIPlusRenderer.Unload(); } + +private: + DECLARE_DYNAMIC_CLASS(wxGDIPlusRendererModule) +}; + +IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusRendererModule, wxModule) + +// ---------------------------------------------------------------------------- +// wxMSW-specific parts of wxGCDC +// ---------------------------------------------------------------------------- + +WXHDC wxGCDC::AcquireHDC() +{ + wxGraphicsContext * const gc = GetGraphicsContext(); + if ( !gc ) + return NULL; + + Graphics * const g = static_cast(gc->GetNativeContext()); + return g ? g->GetHDC() : NULL; +} + +void wxGCDC::ReleaseHDC(WXHDC hdc) +{ + if ( !hdc ) + return; + + wxGraphicsContext * const gc = GetGraphicsContext(); + wxCHECK_RET( gc, "can't release HDC because there is no wxGraphicsContext" ); + + Graphics * const g = static_cast(gc->GetNativeContext()); + wxCHECK_RET( g, "can't release HDC because there is no Graphics" ); + + g->ReleaseHDC((HDC)hdc); +} + #endif // wxUSE_GRAPHICS_CONTEXT