+//
+// transformation
+//
+
+// add the translation to this matrix
+void wxGDIPlusMatrixData::Translate( wxDouble dx , wxDouble dy )
+{
+ m_matrix->Translate(dx,dy);
+}
+
+// add the scale to this matrix
+void wxGDIPlusMatrixData::Scale( wxDouble xScale , wxDouble yScale )
+{
+ m_matrix->Scale(xScale,yScale);
+}
+
+// add the rotation to this matrix (radians)
+void wxGDIPlusMatrixData::Rotate( wxDouble angle )
+{
+ m_matrix->Rotate( RadToDeg(angle) );
+}
+
+//
+// apply the transforms
+//
+
+// applies that matrix to the point
+void wxGDIPlusMatrixData::TransformPoint( wxDouble *x, wxDouble *y ) const
+{
+ PointF pt(*x,*y);
+ m_matrix->TransformPoints(&pt);
+ *x = pt.X;
+ *y = pt.Y;
+}
+
+// applies the matrix except for translations
+void wxGDIPlusMatrixData::TransformDistance( wxDouble *dx, wxDouble *dy ) const
+{
+ PointF pt(*dx,*dy);
+ m_matrix->TransformVectors(&pt);
+ *dx = pt.X;
+ *dy = pt.Y;
+}
+
+// returns the native representation
+void * wxGDIPlusMatrixData::GetNativeMatrix() const
+{
+ return m_matrix;
+}
+
+//-----------------------------------------------------------------------------
+// wxGDIPlusContext implementation
+//-----------------------------------------------------------------------------
+
+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, wxDouble width, wxDouble height )
+ : wxGraphicsContext(renderer)
+{
+ Init();
+ m_context = new Graphics( hdc);
+ m_width = width;
+ m_height = height;
+ SetDefaults();
+}
+
+wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, const wxDC& dc )
+ : wxGraphicsContext(renderer)
+{
+ Init();
+
+ wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
+ HDC hdc = (HDC) msw->GetHDC();
+
+ m_context = new Graphics(hdc);
+ wxSize sz = dc.GetSize();
+ m_width = sz.x;
+ m_height = sz.y;
+
+ SetDefaults();
+}
+
+wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HWND hwnd )
+ : wxGraphicsContext(renderer)
+{
+ Init();
+ m_enableOffset = true;
+ m_context = new Graphics( hwnd);
+ RECT rect = wxGetWindowRect(hwnd);
+ m_width = rect.right - rect.left;
+ m_height = rect.bottom - rect.top;
+ SetDefaults();
+}
+
+wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, Graphics* gr )
+ : wxGraphicsContext(renderer)
+{
+ Init();
+ m_context = gr;
+ SetDefaults();
+}
+
+wxGDIPlusContext::wxGDIPlusContext() : wxGraphicsContext(NULL)
+{
+ Init();
+}
+
+void wxGDIPlusContext::Init()
+{
+ m_context = NULL;
+ m_state1 = 0;
+ m_state2= 0;
+ m_height = 0;
+ m_width = 0;
+ m_fontScaleRatio = 1.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();
+}
+
+wxGDIPlusContext::~wxGDIPlusContext()
+{
+ if ( m_context )
+ {
+ m_context->Restore( m_state2 );
+ m_context->Restore( m_state1 );
+ delete m_context;
+ }
+}
+
+
+void wxGDIPlusContext::Clip( const wxRegion ®ion )
+{
+ Region rgn((HRGN)region.GetHRGN());
+ m_context->SetClip(&rgn,CombineModeIntersect);
+}
+
+void wxGDIPlusContext::Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
+{
+ m_context->SetClip(RectF(x,y,w,h),CombineModeIntersect);
+}
+
+void wxGDIPlusContext::ResetClip()
+{
+ m_context->ResetClip();
+}
+
+void wxGDIPlusContext::DrawRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
+{
+ if (m_composition == wxCOMPOSITION_DEST)
+ return;
+
+ wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() );
+ Brush *brush = m_brush.IsNull() ? NULL : ((wxGDIPlusBrushData*)m_brush.GetRefData())->GetGDIPlusBrush();
+ Pen *pen = m_pen.IsNull() ? NULL : ((wxGDIPlusPenData*)m_pen.GetGraphicsData())->GetGDIPlusPen();
+
+ if ( brush )
+ {
+ // the offset is used to fill only the inside of the rectangle and not paint underneath
+ // its border which may influence a transparent Pen
+ REAL offset = 0;
+ if ( pen )
+ offset = pen->GetWidth();
+ m_context->FillRectangle( brush, (REAL)x + offset/2, (REAL)y + offset/2, (REAL)w - offset, (REAL)h - offset);
+ }
+
+ if ( pen )
+ {
+ m_context->DrawRectangle( pen, (REAL)x, (REAL)y, (REAL)w, (REAL)h );
+ }
+}
+
+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 , 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::SetInterpolationQuality(wxInterpolationQuality WXUNUSED(interpolation))
+{
+ // placeholder
+ return false;
+}
+
+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) );
+}
+
+void wxGDIPlusContext::Translate( wxDouble dx , wxDouble dy )
+{
+ m_context->TranslateTransform( dx , dy );
+}
+
+void wxGDIPlusContext::Scale( wxDouble xScale , wxDouble yScale )
+{
+ m_context->ScaleTransform(xScale,yScale);
+}
+
+void wxGDIPlusContext::PushState()
+{
+ GraphicsState state = m_context->Save();
+ m_stateStack.push(state);
+}
+
+void wxGDIPlusContext::PopState()
+{
+ wxCHECK_RET( !m_stateStack.empty(), wxT("No state to pop") );
+
+ GraphicsState state = m_stateStack.top();
+ m_stateStack.pop();
+ m_context->Restore(state);
+}
+
+void wxGDIPlusContext::DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
+{
+ if (m_composition == wxCOMPOSITION_DEST)
+ return;
+
+ Bitmap* image = static_cast<wxGDIPlusBitmapData*>(bmp.GetRefData())->GetGDIPlusBitmap();
+ if ( image )
+ {
+ if( image->GetWidth() != (UINT) w || image->GetHeight() != (UINT) h )
+ {
+ Rect drawRect((REAL) x, (REAL)y, (REAL)w, (REAL)h);
+ m_context->SetPixelOffsetMode( PixelOffsetModeNone );
+ m_context->DrawImage(image, drawRect, 0 , 0 , image->GetWidth(), image->GetHeight(), UnitPixel ) ;
+ m_context->SetPixelOffsetMode( PixelOffsetModeHalf );
+ }
+ else
+ m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ;
+ }
+}
+
+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 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);
+ }
+ else
+ {
+ size_t width = interim.GetWidth();
+ size_t height = interim.GetHeight();
+ Rect bounds(0,0,width,height);
+ BitmapData data ;
+
+ 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);
+ }
+
+ m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ;
+
+ delete image ;
+ DeleteObject(iconInfo.hbmColor);
+ DeleteObject(iconInfo.hbmMask);
+}
+
+wxGraphicsFont wxGDIPlusContext::CreateFont( const wxFont &font,
+ const wxColour &col ) const
+{
+ wxGDIPlusRenderer* renderer =
+ static_cast<wxGDIPlusRenderer*>(GetRenderer());
+ return renderer->CreateGDIPlusFont(this, font, col);
+}
+
+void wxGDIPlusContext::DoDrawFilledText(const wxString& str,
+ wxDouble x, wxDouble y,
+ const wxGraphicsBrush& brush)
+{
+ if (m_composition == wxCOMPOSITION_DEST)
+ return;
+
+ wxCHECK_RET( !m_font.IsNull(),
+ wxT("wxGDIPlusContext::DrawText - no valid font set") );
+
+ if ( str.IsEmpty())
+ return ;
+
+ 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();
+
+ f->GetFamily(&ffamily) ;
+
+ REAL factorY = m_fontScaleRatio;
+
+ REAL rDescent = ffamily.GetCellDescent(FontStyleRegular) *
+ f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
+ REAL rAscent = ffamily.GetCellAscent(FontStyleRegular) *
+ f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
+ REAL rHeight = ffamily.GetLineSpacing(FontStyleRegular) *
+ f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
+
+ if ( height )
+ *height = rHeight * factorY;
+ if ( descent )
+ *descent = rDescent * factorY;
+ if ( externalLeading )
+ *externalLeading = (rHeight - rAscent - rDescent) * factorY;
+ // measuring empty strings is not guaranteed, so do it by hand
+ if ( str.IsEmpty())
+ {
+ if ( width )
+ *width = 0 ;
+ }
+ else
+ {
+ RectF layoutRect(0,0, 100000.0f, 100000.0f);
+ 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 = bounds.Width;
+ if ( height )
+ *height = bounds.Height;
+ }
+}
+
+void wxGDIPlusContext::GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const
+{
+ widths.Empty();
+ widths.Add(0, text.length());
+
+ wxCHECK_RET( !m_font.IsNull(), wxT("wxGDIPlusContext::GetPartialTextExtents - no valid font set") );
+
+ if (text.empty())
+ return;
+
+ Font* f = ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusFont();
+ wxWCharBuffer ws = text.wc_str( *wxConvUI );
+ size_t len = wcslen( ws ) ;
+ wxASSERT_MSG(text.length() == len , wxT("GetPartialTextExtents not yet implemented for multichar situations"));
+
+ RectF layoutRect(0,0, 100000.0f, 100000.0f);
+ StringFormat strFormat( StringFormat::GenericTypographic() );
+
+ 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 )
+ {
+ 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;
+ }
+
+ delete[] ranges;
+ delete[] regions;
+}
+
+bool wxGDIPlusContext::ShouldOffset() const
+{
+ if ( !m_enableOffset )
+ return false;
+
+ int penwidth = 0 ;
+ if ( !m_pen.IsNull() )
+ {
+ penwidth = (int)((wxGDIPlusPenData*)m_pen.GetRefData())->GetWidth();
+ if ( penwidth == 0 )
+ penwidth = 1;
+ }
+ return ( penwidth % 2 ) == 1;
+}
+
+void* wxGDIPlusContext::GetNativeContext()
+{
+ return m_context;
+}
+
+// concatenates this transform with the current transform of this context
+void wxGDIPlusContext::ConcatTransform( const wxGraphicsMatrix& matrix )
+{
+ m_context->MultiplyTransform((Matrix*) matrix.GetNativeMatrix());
+}
+
+// sets the transform of this context
+void wxGDIPlusContext::SetTransform( const wxGraphicsMatrix& matrix )
+{
+ m_context->SetTransform((Matrix*) matrix.GetNativeMatrix());
+}
+
+// gets the matrix of this context
+wxGraphicsMatrix wxGDIPlusContext::GetTransform() const
+{
+ wxGraphicsMatrix matrix = CreateMatrix();
+ m_context->GetTransform((Matrix*) matrix.GetNativeMatrix());
+ return matrix;
+}
+
+void wxGDIPlusContext::GetSize( wxDouble* width, wxDouble *height )
+{
+ *width = m_width;
+ *height = m_height;
+}
+
+//-----------------------------------------------------------------------------
+// wxGDIPlusPrintingContext implementation
+//-----------------------------------------------------------------------------
+
+wxGDIPlusPrintingContext::wxGDIPlusPrintingContext( wxGraphicsRenderer* renderer,
+ const wxDC& dc )
+ : wxGDIPlusContext(renderer, dc)
+{
+ Graphics* context = GetGraphics();
+
+ //m_context->SetPageUnit(UnitDocument);
+
+ // Setup page scale, based on DPI ratio.
+ // Antecedent should be 100dpi when the default page unit
+ // (UnitDisplay) is used. Page unit UnitDocument would require 300dpi
+ // instead. Note that calling SetPageScale() does not have effect on
+ // non-printing DCs (that is, any other than wxPrinterDC or
+ // wxEnhMetaFileDC).
+ REAL dpiRatio = 100.0 / context->GetDpiY();
+ context->SetPageScale(dpiRatio);
+
+ // We use this modifier when measuring fonts. It is needed because the
+ // page scale is modified above.
+ m_fontScaleRatio = context->GetDpiY() / 72.0;
+}
+
+//-----------------------------------------------------------------------------
+// wxGDIPlusRenderer implementation
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusRenderer,wxGraphicsRenderer)
+
+static wxGDIPlusRenderer gs_GDIPlusRenderer;
+
+wxGraphicsRenderer* wxGraphicsRenderer::GetDefaultRenderer()
+{
+ return &gs_GDIPlusRenderer;
+}
+
+bool wxGDIPlusRenderer::EnsureIsLoaded()
+{
+ // 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;
+ 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 = 0;
+ }
+ m_loaded = -1; // next Load() will try again
+}
+
+wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxWindowDC& dc)
+{
+ ENSURE_LOADED_OR_RETURN(NULL);
+ wxGDIPlusContext* context = new wxGDIPlusContext(this, dc);
+ context->EnableOffset(true);
+ return context;
+}
+
+#if wxUSE_PRINTING_ARCHITECTURE
+wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxPrinterDC& dc)
+{
+ ENSURE_LOADED_OR_RETURN(NULL);
+ wxGDIPlusContext* context = new wxGDIPlusPrintingContext(this, dc);
+ return context;
+}
+#endif
+
+#if wxUSE_ENH_METAFILE
+wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxEnhMetaFileDC& dc)
+{
+ ENSURE_LOADED_OR_RETURN(NULL);
+ wxGDIPlusContext* context = new wxGDIPlusPrintingContext(this, dc);
+ return context;
+}
+#endif
+
+wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxMemoryDC& dc)
+{
+ ENSURE_LOADED_OR_RETURN(NULL);
+ wxGDIPlusContext* context = new wxGDIPlusContext(this, dc);
+ context->EnableOffset(true);
+ return context;
+}
+
+wxGraphicsContext * wxGDIPlusRenderer::CreateMeasuringContext()
+{
+ ENSURE_LOADED_OR_RETURN(NULL);
+ return new wxGDIPlusMeasuringContext(this);
+}
+
+wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeContext( void * context )
+{
+ ENSURE_LOADED_OR_RETURN(NULL);
+ return new wxGDIPlusContext(this,(Graphics*) context);
+}
+
+
+wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeWindow( void * window )
+{
+ ENSURE_LOADED_OR_RETURN(NULL);
+ return new wxGDIPlusContext(this,(HWND) window);
+}
+
+wxGraphicsContext * wxGDIPlusRenderer::CreateContext( wxWindow* window )
+{
+ ENSURE_LOADED_OR_RETURN(NULL);
+ return new wxGDIPlusContext(this, (HWND) window->GetHWND() );
+}
+
+// Path
+
+wxGraphicsPath wxGDIPlusRenderer::CreatePath()
+{
+ ENSURE_LOADED_OR_RETURN(wxNullGraphicsPath);
+ wxGraphicsPath m;
+ m.SetRefData( new wxGDIPlusPathData(this));
+ return m;
+}
+
+
+// Matrix
+
+wxGraphicsMatrix wxGDIPlusRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDouble c, wxDouble d,
+ wxDouble tx, wxDouble ty)
+
+{
+ ENSURE_LOADED_OR_RETURN(wxNullGraphicsMatrix);
+ wxGraphicsMatrix m;
+ wxGDIPlusMatrixData* data = new wxGDIPlusMatrixData( this );
+ data->Set( a,b,c,d,tx,ty ) ;
+ m.SetRefData(data);
+ return m;
+}
+
+wxGraphicsPen wxGDIPlusRenderer::CreatePen(const wxPen& pen)
+{
+ ENSURE_LOADED_OR_RETURN(wxNullGraphicsPen);
+ if ( !pen.IsOk() || pen.GetStyle() == wxTRANSPARENT )
+ return wxNullGraphicsPen;
+ else
+ {
+ wxGraphicsPen p;
+ p.SetRefData(new wxGDIPlusPenData( this, pen ));
+ return p;
+ }
+}
+
+wxGraphicsBrush wxGDIPlusRenderer::CreateBrush(const wxBrush& brush )
+{
+ ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);
+ if ( !brush.IsOk() || brush.GetStyle() == wxTRANSPARENT )
+ return wxNullGraphicsBrush;
+ else
+ {
+ wxGraphicsBrush p;
+ p.SetRefData(new wxGDIPlusBrushData( this, brush ));
+ return p;
+ }
+}
+
+wxGraphicsBrush
+wxGDIPlusRenderer::CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
+ wxDouble x2, wxDouble y2,
+ const wxGraphicsGradientStops& stops)
+{
+ ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);
+ wxGraphicsBrush p;
+ wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this );
+ d->CreateLinearGradientBrush(x1, y1, x2, y2, stops);
+ p.SetRefData(d);
+ return p;
+ }
+
+wxGraphicsBrush
+wxGDIPlusRenderer::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
+ wxDouble xc, wxDouble yc,
+ wxDouble radius,
+ const wxGraphicsGradientStops& stops)
+{
+ ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);
+ wxGraphicsBrush p;
+ wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this );
+ d->CreateRadialGradientBrush(xo,yo,xc,yc,radius,stops);
+ p.SetRefData(d);
+ return p;
+}
+
+wxGraphicsFont
+wxGDIPlusRenderer::CreateGDIPlusFont( const wxGDIPlusContext* gc,
+ const wxFont &font,
+ const wxColour &col )
+{
+ ENSURE_LOADED_OR_RETURN(wxNullGraphicsFont);
+ if ( font.IsOk() )
+ {
+ wxGraphicsFont p;
+ p.SetRefData(new wxGDIPlusFontData( this, gc, font, col ));
+ return p;
+ }
+ else
+ return wxNullGraphicsFont;
+}
+
+wxGraphicsBitmap wxGDIPlusRenderer::CreateBitmap( const wxBitmap &bitmap )
+{
+ ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);
+ if ( bitmap.IsOk() )
+ {
+ 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<wxGDIPlusBitmapData*>(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<Graphics *>(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<Graphics *>(gc->GetNativeContext());
+ wxCHECK_RET( g, "can't release HDC because there is no Graphics" );
+
+ g->ReleaseHDC((HDC)hdc);
+}
projects / wxWidgets.git / blobdiff