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;
}