extern "C" AzPathRef AzPathBuilderFinish(AzPathBuilderRef aPathBuilder) { gfx::PathBuilder *gfxPathBuilder = static_cast<gfx::PathBuilder*>(aPathBuilder); RefPtr<gfx::Path> gfxPath = gfxPathBuilder->Finish(); gfxPath->AddRef(); return gfxPath; }
extern "C" AzDataSourceSurfaceRef AzSourceSurfaceGetDataSurface(AzSourceSurfaceRef aSurface) { gfx::SourceSurface *gfxSourceSurface = static_cast<gfx::SourceSurface*>(aSurface); RefPtr<gfx::DataSourceSurface> gfxDataSourceSurface = gfxSourceSurface->GetDataSurface(); gfxDataSourceSurface->AddRef(); return gfxDataSourceSurface; }
extern "C" AzSourceSurfaceRef AzDrawTargetGetSnapshot(AzDrawTargetRef aDrawTarget) { gfx::DrawTarget *gfxDrawTarget = static_cast<gfx::DrawTarget*>(aDrawTarget); RefPtr<gfx::SourceSurface> gfxSourceSurface = gfxDrawTarget->Snapshot(); gfxSourceSurface->AddRef(); return gfxSourceSurface; }
// FIXME: Needs to take a FillRule extern "C" AzPathBuilderRef AzCreatePathBuilder(AzDrawTargetRef aDrawTarget) { gfx::DrawTarget *gfxDrawTarget = static_cast<gfx::DrawTarget*>(aDrawTarget); RefPtr<gfx::PathBuilder> gfxPathBuilder = gfxDrawTarget->CreatePathBuilder(); gfxPathBuilder->AddRef(); return gfxPathBuilder; }
extern "C" AzScaledFontRef AzCreateScaledFontForNativeFont(AzNativeFont *aNativeFont, AzFloat aSize) { gfx::NativeFont *gfxNativeFont = reinterpret_cast<gfx::NativeFont*>(aNativeFont); RefPtr<gfx::ScaledFont> font = gfx::Factory::CreateScaledFontForNativeFont(*gfxNativeFont, aSize); font->AddRef(); return font; }
extern "C" AzPathBuilderRef AzCreatePathBuilder(AzDrawTargetRef aTarget, AzFillRule fillrule) { gfx::DrawTarget *gfxDrawTarget = static_cast<gfx::DrawTarget*>(aTarget); RefPtr<gfx::PathBuilder> pathBuilder = gfxDrawTarget->CreatePathBuilder(gfx::FillRule(fillrule)); pathBuilder->AddRef(); return pathBuilder; }
extern "C" AzPathBuilderRef AzPathCopyToBuilder(AzPathRef aPath,AzFillRule fillrule) { gfx::Path *gfxPath = reinterpret_cast<gfx::Path*>(aPath); RefPtr<gfx::PathBuilder> pathBuilder = gfxPath->CopyToBuilder(gfx::FillRule(fillrule)); pathBuilder->AddRef(); return pathBuilder; }
static gchar * wait_for_text(GtkClipboard *clipboard) { RefPtr<RetrievalContext> context = new RetrievalContext(); // Balanced by Release in clipboard_text_received context->AddRef(); gtk_clipboard_request_text(clipboard, clipboard_text_received, context.get()); return static_cast<gchar*>(context->Wait()); }
extern "C" AzScaledFontRef AzCreateScaledFontWithCairo(AzNativeFont *aNativeFont, AzFloat aSize, cairo_scaled_font_t *aScaledFont) { gfx::NativeFont *gfxNativeFont = reinterpret_cast<gfx::NativeFont*>(aNativeFont); RefPtr<gfx::ScaledFont> font = gfx::Factory::CreateScaledFontWithCairo(*gfxNativeFont, aSize, aScaledFont); font->AddRef(); return font; }
RefPtr<SourceSurface> gfxPlatform::GetSourceSurfaceForSurface(DrawTarget *aTarget, gfxASurface *aSurface) { void *userData = aSurface->GetData(&kSourceSurface); if (userData) { return static_cast<SourceSurface*>(userData); } SurfaceFormat format; if (aSurface->GetContentType() == gfxASurface::CONTENT_ALPHA) { format = FORMAT_A8; } else if (aSurface->GetContentType() == gfxASurface::CONTENT_COLOR) { format = FORMAT_B8G8R8X8; } else { format = FORMAT_B8G8R8A8; } RefPtr<SourceSurface> srcBuffer; #ifdef XP_WIN if (aSurface->GetType() == gfxASurface::SurfaceTypeD2D) { NativeSurface surf; surf.mFormat = format; surf.mType = NATIVE_SURFACE_D3D10_TEXTURE; surf.mSurface = static_cast<gfxD2DSurface*>(aSurface)->GetTexture(); mozilla::gfx::DrawTarget *dt = static_cast<mozilla::gfx::DrawTarget*>(aSurface->GetData(&kDrawTarget)); if (dt) { dt->Flush(); } srcBuffer = aTarget->CreateSourceSurfaceFromNativeSurface(surf); } #endif if (!srcBuffer) { nsRefPtr<gfxImageSurface> imgSurface = aSurface->GetAsImageSurface(); if (!imgSurface) { imgSurface = new gfxImageSurface(aSurface->GetSize(), gfxASurface::FormatFromContent(aSurface->GetContentType())); nsRefPtr<gfxContext> ctx = new gfxContext(imgSurface); ctx->SetSource(aSurface); ctx->SetOperator(gfxContext::OPERATOR_SOURCE); ctx->Paint(); } srcBuffer = aTarget->CreateSourceSurfaceFromData(imgSurface->Data(), IntSize(imgSurface->GetSize().width, imgSurface->GetSize().height), imgSurface->Stride(), format); } srcBuffer->AddRef(); aSurface->SetData(&kSourceSurface, srcBuffer, SourceBufferDestroy); return srcBuffer; }
static GtkSelectionData * wait_for_contents(GtkClipboard *clipboard, GdkAtom target) { RefPtr<RetrievalContext> context = new RetrievalContext(); // Balanced by Release in clipboard_contents_received context->AddRef(); gtk_clipboard_request_contents(clipboard, target, clipboard_contents_received, context.get()); return static_cast<GtkSelectionData*>(context->Wait()); }
extern "C" AzDrawTargetRef AzCreateDrawTarget(AzBackendType aBackend, AzIntSize *aSize, AzSurfaceFormat aFormat) { gfx::BackendType backendType = static_cast<gfx::BackendType>(aBackend); gfx::IntSize *size = reinterpret_cast<gfx::IntSize*>(aSize); gfx::SurfaceFormat surfaceFormat = static_cast<gfx::SurfaceFormat>(aFormat); RefPtr<gfx::DrawTarget> target = gfx::Factory::CreateDrawTarget(backendType, *size, surfaceFormat); target->AddRef(); return target; }
extern "C" AzSourceSurfaceRef AzDrawTargetCreateSourceSurfaceFromData(AzDrawTargetRef aDrawTarget, unsigned char *aData, AzIntSize *aSize, int32_t aStride, AzSurfaceFormat aFormat) { gfx::DrawTarget *gfxDrawTarget = static_cast<gfx::DrawTarget*>(aDrawTarget); gfx::IntSize *gfxSize = reinterpret_cast<gfx::IntSize*>(aSize); gfx::SurfaceFormat gfxSurfaceFormat = static_cast<gfx::SurfaceFormat>(aFormat); RefPtr<gfx::SourceSurface> gfxSourceSurface = gfxDrawTarget->CreateSourceSurfaceFromData(aData, *gfxSize, aStride, gfxSurfaceFormat); gfxSourceSurface->AddRef(); return gfxSourceSurface; }
extern "C" AzDrawTargetRef AzCreateSkiaDrawTargetForFBO(AzSkiaSharedGLContextRef aGLContext, AzIntSize *aSize, AzSurfaceFormat aFormat) { SkNativeSharedGLContext *sharedGLContext = static_cast<SkNativeSharedGLContext*>(aGLContext); GrContext *grContext = sharedGLContext->getGrContext(); grContext->AddRef(); gfx::IntSize *size = reinterpret_cast<gfx::IntSize*>(aSize); gfx::SurfaceFormat surfaceFormat = static_cast<gfx::SurfaceFormat>(aFormat); RefPtr<gfx::DrawTarget> target = gfx::Factory::CreateSkiaDrawTargetForFBO(sharedGLContext->getFBOID(), grContext, *size, surfaceFormat); target->AddRef(); return target; }
extern "C" AzDrawTargetRef AzCreateDrawTargetForData(AzBackendType aBackend, unsigned char *aData, AzIntSize *aSize, int32_t aStride, AzSurfaceFormat aFormat) { gfx::BackendType backendType = static_cast<gfx::BackendType>(aBackend); gfx::IntSize *size = reinterpret_cast<gfx::IntSize*>(aSize); gfx::SurfaceFormat surfaceFormat = static_cast<gfx::SurfaceFormat>(aFormat); RefPtr<gfx::DrawTarget> target = gfx::Factory::CreateDrawTargetForData(backendType, aData, *size, aStride, surfaceFormat); if (target != NULL) { target->AddRef(); } return target; }
/** * This method contains the core guts of the handling of QueryInterface calls * that are delegated to us from the ICallInterceptor. * * @param aIid ID of the desired interface * @param aOutInterceptor The resulting emulated vtable that corresponds to * the interface specified by aIid. */ HRESULT Interceptor::GetInterceptorForIID(REFIID aIid, void** aOutInterceptor) { if (!aOutInterceptor) { return E_INVALIDARG; } if (aIid == IID_IUnknown) { // Special case: When we see IUnknown, we just provide a reference to this *aOutInterceptor = static_cast<IInterceptor*>(this); AddRef(); return S_OK; } RefPtr<IUnknown> unkInterceptor; IUnknown* interfaceForQILog = nullptr; // (1) Check to see if we already have an existing interceptor for aIid. { // Scope for lock MutexAutoLock lock(mMutex); MapEntry* entry = Lookup(aIid); if (entry) { unkInterceptor = entry->mInterceptor; interfaceForQILog = entry->mTargetInterface; } } // (1a) A COM interceptor already exists for this interface, so all we need // to do is run a QI on it. if (unkInterceptor) { // Technically we didn't actually execute a QI on the target interface, but // for logging purposes we would like to record the fact that this interface // was requested. InterceptorLog::QI(S_OK, mTarget.get(), aIid, interfaceForQILog); return unkInterceptor->QueryInterface(aIid, aOutInterceptor); } // (2) Obtain a new target interface. // (2a) First, make sure that the target interface is available // NB: We *MUST* query the correct interface! ICallEvents::Invoke casts its // pvReceiver argument directly to the required interface! DO NOT assume // that COM will use QI or upcast/downcast! HRESULT hr; STAUniquePtr<IUnknown> targetInterface; IUnknown* rawTargetInterface = nullptr; hr = QueryInterfaceTarget(aIid, (void**)&rawTargetInterface); targetInterface.reset(rawTargetInterface); InterceptorLog::QI(hr, mTarget.get(), aIid, targetInterface.get()); MOZ_ASSERT(SUCCEEDED(hr) || hr == E_NOINTERFACE); if (FAILED(hr)) { return hr; } // We *really* shouldn't be adding interceptors to proxies MOZ_ASSERT(aIid != IID_IMarshal); // (3) Create a new COM interceptor to that interface that delegates its // IUnknown to |this|. // Raise the refcount for stabilization purposes during aggregation RefPtr<IUnknown> kungFuDeathGrip(static_cast<IUnknown*>( static_cast<WeakReferenceSupport*>(this))); hr = CreateInterceptor(aIid, kungFuDeathGrip, getter_AddRefs(unkInterceptor)); if (FAILED(hr)) { return hr; } // (4) Obtain the interceptor's ICallInterceptor interface and register our // event sink. RefPtr<ICallInterceptor> interceptor; hr = unkInterceptor->QueryInterface(IID_ICallInterceptor, (void**)getter_AddRefs(interceptor)); if (FAILED(hr)) { return hr; } hr = interceptor->RegisterSink(mEventSink); if (FAILED(hr)) { return hr; } // (5) Now that we have this new COM interceptor, insert it into the map. { // Scope for lock MutexAutoLock lock(mMutex); // We might have raced with another thread, so first check that we don't // already have an entry for this MapEntry* entry = Lookup(aIid); if (entry && entry->mInterceptor) { unkInterceptor = entry->mInterceptor; } else { // We're inserting unkInterceptor into the map but we still want to hang // onto it locally so that we can QI it below. unkInterceptor->AddRef(); // OTOH we must not touch the refcount for the target interface // because we are just moving it into the map and its refcounting might // not be thread-safe. IUnknown* rawTargetInterface = targetInterface.release(); mInterceptorMap.AppendElement(MapEntry(aIid, unkInterceptor, rawTargetInterface)); } } return unkInterceptor->QueryInterface(aIid, aOutInterceptor); }
extern "C" AzDrawTargetRef AzCreateDrawTargetForCairoSurface(cairo_surface_t* aSurface) { RefPtr<gfx::DrawTarget> target = gfx::Factory::CreateDrawTargetForCairoSurface(aSurface); target->AddRef(); return target; }
RefPtr<SourceSurface> gfxPlatform::GetSourceSurfaceForSurface(DrawTarget *aTarget, gfxASurface *aSurface) { void *userData = aSurface->GetData(&kSourceSurface); if (userData) { return static_cast<SourceSurface*>(userData); } SurfaceFormat format; if (aSurface->GetContentType() == gfxASurface::CONTENT_ALPHA) { format = FORMAT_A8; } else if (aSurface->GetContentType() == gfxASurface::CONTENT_COLOR) { format = FORMAT_B8G8R8X8; } else { format = FORMAT_B8G8R8A8; } RefPtr<SourceSurface> srcBuffer; #ifdef XP_WIN if (aSurface->GetType() == gfxASurface::SurfaceTypeD2D) { NativeSurface surf; surf.mFormat = format; surf.mType = NATIVE_SURFACE_D3D10_TEXTURE; surf.mSurface = static_cast<gfxD2DSurface*>(aSurface)->GetTexture(); mozilla::gfx::DrawTarget *dt = static_cast<mozilla::gfx::DrawTarget*>(aSurface->GetData(&kDrawTarget)); if (dt) { dt->Flush(); } srcBuffer = aTarget->CreateSourceSurfaceFromNativeSurface(surf); } #endif if (!srcBuffer) { nsRefPtr<gfxImageSurface> imgSurface = aSurface->GetAsImageSurface(); if (!imgSurface) { imgSurface = new gfxImageSurface(aSurface->GetSize(), gfxASurface::FormatFromContent(aSurface->GetContentType())); nsRefPtr<gfxContext> ctx = new gfxContext(imgSurface); ctx->SetSource(aSurface); ctx->SetOperator(gfxContext::OPERATOR_SOURCE); ctx->Paint(); } gfxImageFormat cairoFormat = imgSurface->Format(); switch(cairoFormat) { case gfxASurface::ImageFormatARGB32: format = FORMAT_B8G8R8A8; break; case gfxASurface::ImageFormatRGB24: format = FORMAT_B8G8R8X8; break; case gfxASurface::ImageFormatA8: format = FORMAT_A8; break; case gfxASurface::ImageFormatRGB16_565: format = FORMAT_R5G6B5; break; default: NS_RUNTIMEABORT("Invalid surface format!"); } srcBuffer = aTarget->CreateSourceSurfaceFromData(imgSurface->Data(), IntSize(imgSurface->GetSize().width, imgSurface->GetSize().height), imgSurface->Stride(), format); cairo_surface_t *nullSurf = cairo_null_surface_create(CAIRO_CONTENT_COLOR_ALPHA); cairo_surface_set_user_data(nullSurf, &kSourceSurface, imgSurface, NULL); cairo_surface_attach_snapshot(imgSurface->CairoSurface(), nullSurf, SourceSnapshotDetached); cairo_surface_destroy(nullSurf); } srcBuffer->AddRef(); aSurface->SetData(&kSourceSurface, srcBuffer, SourceBufferDestroy); return srcBuffer; }
RefPtr<SourceSurface> gfxPlatform::GetSourceSurfaceForSurface(DrawTarget *aTarget, gfxASurface *aSurface) { void *userData = aSurface->GetData(&kSourceSurface); if (userData) { return static_cast<SourceSurface*>(userData); } SurfaceFormat format; if (aSurface->GetContentType() == gfxASurface::CONTENT_ALPHA) { format = FORMAT_A8; } else if (aSurface->GetContentType() == gfxASurface::CONTENT_COLOR) { format = FORMAT_B8G8R8X8; } else { format = FORMAT_B8G8R8A8; } RefPtr<SourceSurface> srcBuffer; #ifdef XP_WIN if (aSurface->GetType() == gfxASurface::SurfaceTypeD2D) { NativeSurface surf; surf.mFormat = format; surf.mType = NATIVE_SURFACE_D3D10_TEXTURE; surf.mSurface = static_cast<gfxD2DSurface*>(aSurface)->GetTexture(); mozilla::gfx::DrawTarget *dt = static_cast<mozilla::gfx::DrawTarget*>(aSurface->GetData(&kDrawTarget)); if (dt) { dt->Flush(); } srcBuffer = aTarget->CreateSourceSurfaceFromNativeSurface(surf); } #endif if (!srcBuffer) { nsRefPtr<gfxImageSurface> imgSurface = aSurface->GetAsImageSurface(); bool isWin32ImageSurf = false; if (imgSurface && aSurface->GetType() != gfxASurface::SurfaceTypeWin32) { isWin32ImageSurf = true; } if (!imgSurface) { imgSurface = new gfxImageSurface(aSurface->GetSize(), OptimalFormatForContent(aSurface->GetContentType())); nsRefPtr<gfxContext> ctx = new gfxContext(imgSurface); ctx->SetSource(aSurface); ctx->SetOperator(gfxContext::OPERATOR_SOURCE); ctx->Paint(); } gfxImageFormat cairoFormat = imgSurface->Format(); switch(cairoFormat) { case gfxASurface::ImageFormatARGB32: format = FORMAT_B8G8R8A8; break; case gfxASurface::ImageFormatRGB24: format = FORMAT_B8G8R8X8; break; case gfxASurface::ImageFormatA8: format = FORMAT_A8; break; case gfxASurface::ImageFormatRGB16_565: format = FORMAT_R5G6B5; break; default: NS_RUNTIMEABORT("Invalid surface format!"); } IntSize size = IntSize(imgSurface->GetSize().width, imgSurface->GetSize().height); srcBuffer = aTarget->CreateSourceSurfaceFromData(imgSurface->Data(), size, imgSurface->Stride(), format); if (!srcBuffer) { // We need to check if our gfxASurface will keep the underlying data // alive! This is true if gfxASurface actually -is- an ImageSurface or // if it is a gfxWindowsSurface which supportes GetAsImageSurface. if (imgSurface != aSurface && !isWin32ImageSurf) { // This shouldn't happen for now, it can be easily supported by making // a copy. For now let's just abort. NS_RUNTIMEABORT("Attempt to create unsupported SourceSurface from" "non-image surface."); return nsnull; } srcBuffer = Factory::CreateWrappingDataSourceSurface(imgSurface->Data(), imgSurface->Stride(), size, format); } cairo_surface_t *nullSurf = cairo_null_surface_create(CAIRO_CONTENT_COLOR_ALPHA); cairo_surface_set_user_data(nullSurf, &kSourceSurface, imgSurface, NULL); cairo_surface_attach_snapshot(imgSurface->CairoSurface(), nullSurf, SourceSnapshotDetached); cairo_surface_destroy(nullSurf); } srcBuffer->AddRef(); aSurface->SetData(&kSourceSurface, srcBuffer, SourceBufferDestroy); return srcBuffer; }