static DFBResult
IDirectFBWindow_CreateEventBuffer( IDirectFBWindow *thiz,
IDirectFBEventBuffer **buffer )
{
IDirectFBEventBuffer *b;
DIRECT_INTERFACE_GET_DATA(IDirectFBWindow)
D_DEBUG_AT( IDirectFB_Window, "%s()\n", __FUNCTION__ );
if (data->destroyed)
return DFB_DESTROYED;
DIRECT_ALLOCATE_INTERFACE( b, IDirectFBEventBuffer );
IDirectFBEventBuffer_Construct( b, NULL, NULL );
IDirectFBEventBuffer_AttachWindow( b, data->window );
dfb_window_send_configuration( data->window );
*buffer = b;
return DFB_OK;
}
DFBResult
IImageProvider_Real::RenderTo(
CoreSurface *destination,
const DFBRectangle *rect
)
{
DFBResult ret;
IDirectFBSurface *surface;
D_MAGIC_ASSERT( obj, ImageProviderDispatch );
DIRECT_ALLOCATE_INTERFACE( surface, IDirectFBSurface );
if (!surface)
return (DFBResult) D_OOM();
ret = IDirectFBSurface_Construct( surface, NULL, NULL, NULL, NULL, destination, DSCAPS_NONE, core, obj->idirectfb );
if (ret)
return ret;
ret = obj->provider->RenderTo( obj->provider, surface, rect );
surface->Release( surface );
return ret;
}
static DFBResult
IDirectFBSurface_Layer_GetSubSurface( IDirectFBSurface *thiz,
const DFBRectangle *rect,
IDirectFBSurface **surface )
{
DFBResult ret;
DIRECT_INTERFACE_GET_DATA(IDirectFBSurface_Layer)
D_DEBUG_AT( Surface, "%s( %p )\n", __FUNCTION__, thiz );
/* Check arguments */
if (!data->base.surface)
return DFB_DESTROYED;
if (!surface)
return DFB_INVARG;
/* Allocate interface */
DIRECT_ALLOCATE_INTERFACE( *surface, IDirectFBSurface );
if (rect || data->base.limit_set) {
DFBRectangle wanted, granted;
/* Compute wanted rectangle */
if (rect) {
wanted = *rect;
wanted.x += data->base.area.wanted.x;
wanted.y += data->base.area.wanted.y;
if (wanted.w <= 0 || wanted.h <= 0) {
wanted.w = 0;
wanted.h = 0;
}
}
else {
wanted = data->base.area.wanted;
}
/* Compute granted rectangle */
granted = wanted;
dfb_rectangle_intersect( &granted, &data->base.area.granted );
/* Construct */
ret = IDirectFBSurface_Layer_Construct( *surface, thiz, &wanted, &granted,
data->region, data->base.caps |
DSCAPS_SUBSURFACE, data->base.core );
}
else {
/* Construct */
ret = IDirectFBSurface_Layer_Construct( *surface, thiz, NULL, NULL,
data->region, data->base.caps |
DSCAPS_SUBSURFACE, data->base.core );
}
return ret;
}
static DFBResult
IDirectFBDisplayLayer_GetSurface( IDirectFBDisplayLayer *thiz,
IDirectFBSurface **interface )
{
DFBResult ret;
CoreLayerRegion *region;
IDirectFBSurface *surface;
D_DEBUG_AT( Layer, "%s( %p )\n", __FUNCTION__, thiz );
DIRECT_INTERFACE_GET_DATA(IDirectFBDisplayLayer)
if (!interface)
return DFB_INVARG;
if (data->level == DLSCL_SHARED) {
D_WARN( "letting unprivileged IDirectFBDisplayLayer::GetSurface() "
"call pass until cooperative level handling is finished" );
}
ret = CoreLayerContext_GetPrimaryRegion( data->context, true, ®ion );
if (ret)
return ret;
DIRECT_ALLOCATE_INTERFACE( surface, IDirectFBSurface );
ret = IDirectFBSurface_Layer_Construct( surface, NULL, NULL, NULL,
region, DSCAPS_NONE, data->core, data->idirectfb );
// Fix to only perform single buffered clearing using a background when
// configured to do so AND the display layer region is frozen. Also
// added support for this behavior when the cooperative level is
// DLSCL_ADMINISTRATIVE.
if (region->config.buffermode == DLBM_FRONTONLY &&
data->level != DLSCL_SHARED &&
D_FLAGS_IS_SET( region->state, CLRSF_FROZEN )) {
// If a window stack is available, give it the opportunity to
// render the background (optionally based on configuration) and
// flip the display layer so it is visible. Otherwise, just
// directly flip the display layer and make it visible.
if (data->stack) {
CoreWindowStack_RepaintAll( data->stack );
}
else {
CoreLayerRegion_FlipUpdate2( region, NULL, NULL, DSFLIP_NONE, -1 );
}
}
*interface = ret ? NULL : surface;
dfb_layer_region_unref( region );
return ret;
}
DFBResult
IDirectFBImageProvider_CreateFromBuffer( IDirectFBDataBuffer *buffer,
IDirectFBImageProvider **interface )
{
DFBResult ret;
DirectInterfaceFuncs *funcs = NULL;
IDirectFBDataBuffer_data *buffer_data;
IDirectFBImageProvider *imageprovider;
IDirectFBImageProvider_ProbeContext ctx;
/* Get the private information of the data buffer. */
buffer_data = (IDirectFBDataBuffer_data*) buffer->priv;
if (!buffer_data)
return DFB_DEAD;
/* Provide a fallback for image providers without data buffer support. */
ctx.filename = buffer_data->filename;
/* Wait until 32 bytes are available. */
ret = buffer->WaitForData( buffer, 32 );
if (ret)
return ret;
/* Read the first 32 bytes. */
ret = buffer->PeekData( buffer, 32, 0, ctx.header, NULL );
if (ret)
return ret;
/* Find a suitable implementation. */
ret = DirectGetInterface( &funcs, "IDirectFBImageProvider", NULL, DirectProbeInterface, &ctx );
if (ret)
return ret;
DIRECT_ALLOCATE_INTERFACE( imageprovider, IDirectFBImageProvider );
/* Construct the interface. */
ret = funcs->Construct( imageprovider, buffer );
if (ret)
return ret;
*interface = imageprovider;
return DFB_OK;
}
DFBResult
ICore_Real::CreateImageProvider(
u32 buffer_call,
u32 *ret_call
)
{
DFBResult ret;
IDirectFBDataBuffer *buffer;
IDirectFBImageProvider *provider;
ImageProviderDispatch *dispatch;
D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Real::%s()\n", __FUNCTION__ );
D_MAGIC_ASSERT( obj, CoreDFB );
D_ASSERT( ret_call != NULL );
DIRECT_ALLOCATE_INTERFACE( buffer, IDirectFBDataBuffer );
if (!buffer)
return (DFBResult) D_OOM();
/* Construct data buffer client */
ret = IDirectFBDataBuffer_Client_Construct( buffer, core, buffer_call );
if (ret)
return ret;
/* Create image provider */
ret = buffer->CreateImageProvider( buffer, &provider );
if (ret) {
buffer->Release( buffer );
return ret;
}
/* Create dispatch object */
ret = ImageProviderDispatch_Create( idirectfb_singleton, buffer, provider, &dispatch );
if (ret) {
provider->Release( provider );
buffer->Release( buffer );
return ret;
}
*ret_call = dispatch->call.call_id;
return DFB_OK;
}
static DFBResult
IDirectFBDisplayLayer_GetScreen( IDirectFBDisplayLayer *thiz,
IDirectFBScreen **interface )
{
DFBResult ret;
IDirectFBScreen *screen;
D_DEBUG_AT( Layer, "%s( %p )\n", __FUNCTION__, thiz );
DIRECT_INTERFACE_GET_DATA(IDirectFBDisplayLayer)
if (!interface)
return DFB_INVARG;
DIRECT_ALLOCATE_INTERFACE( screen, IDirectFBScreen );
ret = IDirectFBScreen_Construct( screen, data->screen );
*interface = ret ? NULL : screen;
return ret;
}
static DFBResult
ICoreResourceManager_test_CreateClient( ICoreResourceManager *thiz,
FusionID identity,
ICoreResourceClient **ret_client )
{
DFBResult ret;
ICoreResourceClient *client;
DIRECT_INTERFACE_GET_DATA(ICoreResourceManager_test)
D_DEBUG_AT( ICoreResourceManager_test, "%s( %p )\n", __FUNCTION__, thiz );
DIRECT_ALLOCATE_INTERFACE( client, ICoreResourceClient );
ret = ICoreResourceClient_test_Construct( client, thiz, identity );
if (ret)
return ret;
*ret_client = client;
return DFB_OK;
}
static DFBResult
IDirectFBWindow_GetSurface( IDirectFBWindow *thiz,
IDirectFBSurface **surface )
{
DIRECT_INTERFACE_GET_DATA(IDirectFBWindow)
D_DEBUG_AT( IDirectFB_Window, "%s()\n", __FUNCTION__ );
if (data->destroyed)
return DFB_DESTROYED;
if (!surface)
return DFB_INVARG;
if (data->window->caps & (DWCAPS_INPUTONLY | DWCAPS_COLOR))
return DFB_UNSUPPORTED;
if (!data->surface) {
DFBResult ret;
DIRECT_ALLOCATE_INTERFACE( *surface, IDirectFBSurface );
ret = IDirectFBSurface_Window_Construct( *surface, NULL,
NULL, NULL, data->window,
DSCAPS_DOUBLE, data->core, data->idirectfb );
if (ret)
return ret;
data->surface = *surface;
}
else
*surface = data->surface;
data->surface->AddRef( data->surface );
return DFB_OK;
}
DFBResult
IDirectFBFont_CreateFromBuffer( IDirectFBDataBuffer *buffer,
CoreDFB *core,
const DFBFontDescription *desc,
IDirectFBFont **interface )
{
DFBResult ret;
DirectInterfaceFuncs *funcs = NULL;
IDirectFBDataBuffer_data *buffer_data;
IDirectFBFont *ifont;
IDirectFBFont_ProbeContext ctx = {0};
/* Get the private information of the data buffer. */
buffer_data = (IDirectFBDataBuffer_data*) buffer->priv;
if (!buffer_data)
return DFB_DEAD;
/* Provide a fallback for image providers without data buffer support. */
ctx.filename = buffer_data->filename;
/* try to map the "file" content first */
if (try_map_file( buffer_data, &ctx ) != DFB_OK) {
/* try to load the "file" content from the buffer */
/* we need to be able to seek (this implies non-streamed,
so we also know the size) so we can reuse the buffer */
if (buffer->SeekTo( buffer, 0 ) == DFB_OK) {
unsigned int size, got;
/* get the "file" length */
buffer->GetLength( buffer, &size );
ctx.content = D_MALLOC( size );
if (!ctx.content)
return DR_NOLOCALMEMORY;
ctx.content_size = 0;
while (ctx.content_size < size) {
unsigned int get = size - ctx.content_size;
if (get > 8192)
get = 8192;
ret = buffer->WaitForData( buffer, get );
if (ret) {
D_DERROR( ret, "%s: WaitForData failed!\n", __FUNCTION__ );
break;
}
ret = buffer->GetData( buffer, get, ctx.content + ctx.content_size, &got );
if (ret) {
D_DERROR( ret, "%s: GetData failed!\n", __FUNCTION__ );
break;
}
if (!got)
break;
ctx.content_size += got;
}
if (ctx.content_size != size) {
D_ERROR( "%s: Got size %u differs from supposed %u!\n", __FUNCTION__, ctx.content_size, size );
D_FREE( ctx.content );
return DFB_FAILURE;
}
}
}
/* Find a suitable implementation. */
ret = DirectGetInterface( &funcs, "IDirectFBFont", NULL, DirectProbeInterface, &ctx );
if (ret) {
unmap_or_free( &ctx );
return ret;
}
DIRECT_ALLOCATE_INTERFACE( ifont, IDirectFBFont );
/* Construct the interface. */
ret = funcs->Construct( ifont, core, &ctx, desc );
if (ret) {
unmap_or_free( &ctx );
return ret;
}
/* store pointer for deletion at destroy */
{
IDirectFBFont_data *data = (IDirectFBFont_data*)(ifont->priv);
data->content = ctx.content;
data->content_size = ctx.content_size;
data->content_mapped = ctx.content_mapped;
}
*interface = ifont;
return DFB_OK;
}
/*
* Programs have to call this to get the super interface
* which is needed to access other functions
*/
DFBResult
DirectFBCreate( IDirectFB **interface )
{
DFBResult ret;
IDirectFB *dfb;
CoreDFB *core_dfb;
if (!dfb_config) {
/* don't use D_ERROR() here, it uses dfb_config */
direct_log_printf( NULL, "(!) DirectFBCreate: DirectFBInit "
"has to be called before DirectFBCreate!\n" );
return DFB_INIT;
}
if (!interface)
return DFB_INVARG;
if (idirectfb_singleton) {
idirectfb_singleton->AddRef( idirectfb_singleton );
*interface = idirectfb_singleton;
return DFB_OK;
}
direct_initialize();
if ( !(direct_config->quiet & DMT_BANNER) && dfb_config->banner) {
direct_log_printf( NULL,
"\n"
" ~~~~~~~~~~~~~~~~~~~~~~~~~~| DirectFB " DIRECTFB_VERSION " |~~~~~~~~~~~~~~~~~~~~~~~~~~\n"
" (c) 2001-2009 The world wide DirectFB Open Source Community\n"
" (c) 2000-2004 Convergence (integrated media) GmbH\n"
" ----------------------------------------------------------------\n"
"\n" );
}
if (dfb_config->remote.host)
return CreateRemote( dfb_config->remote.host, dfb_config->remote.session, interface );
ret = dfb_core_create( &core_dfb );
if (ret)
return ret;
DIRECT_ALLOCATE_INTERFACE( dfb, IDirectFB );
ret = IDirectFB_Construct( dfb, core_dfb );
if (ret) {
dfb_core_destroy( core_dfb, false );
return ret;
}
if (dfb_core_is_master( core_dfb )) {
/* not fatal */
ret = dfb_wm_post_init( core_dfb );
if (ret)
D_DERROR( ret, "DirectFBCreate: Post initialization of WM failed!\n" );
dfb_core_activate( core_dfb );
}
*interface = idirectfb_singleton = dfb;
return DFB_OK;
}
