bool
cct_check_args_eq(const char *file, int line, const char *expression,
struct args *expected, struct args *actual,
bool free1, bool free2)
{
bool result;
if (expected && actual && args_equal(actual, expected)) {
cct_check_passed(file, line, expression);
result = true;
} else {
char *exp_str = expected ? args_to_string(expected) : x_strdup("(null)");
char *act_str = actual ? args_to_string(actual) : x_strdup("(null)");
cct_check_failed(file, line, expression, exp_str, act_str);
free(exp_str);
free(act_str);
result = false;
}
if (free1) {
args_free(expected);
}
if (free2) {
args_free(actual);
}
return result;
}
DFBResult
ILayerRegion_Requestor::FlipUpdateStereo(
const DFBRegion *left,
const DFBRegion *right,
DFBSurfaceFlipFlags flags
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreLayerRegionFlipUpdateStereo *args = (CoreLayerRegionFlipUpdateStereo*) args_alloc( args_static, sizeof(CoreLayerRegionFlipUpdateStereo) );
CoreLayerRegionFlipUpdateStereoReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreLayerRegionFlipUpdateStereoReturn*) args_alloc( return_args_static, sizeof(CoreLayerRegionFlipUpdateStereoReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreLayerRegion, "ILayerRegion_Requestor::%s()\n", __FUNCTION__ );
if (left) {
args->left = *left;
args->left_set = true;
}
else
args->left_set = false;
if (right) {
args->right = *right;
args->right_set = true;
}
else
args->right_set = false;
args->flags = flags;
ret = (DFBResult) CoreLayerRegion_Call( obj, FCEF_NONE, CoreLayerRegion_FlipUpdateStereo, args, sizeof(CoreLayerRegionFlipUpdateStereo), return_args, sizeof(CoreLayerRegionFlipUpdateStereoReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreLayerRegion_Call( CoreLayerRegion_FlipUpdateStereo ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreLayerRegion_FlipUpdateStereo failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
ILayer_Requestor::GetPrimaryContext(
bool activate,
CoreLayerContext **ret_context
)
{
DFBResult ret = DFB_OK;
CoreLayerContext *context = NULL;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreLayerGetPrimaryContext *args = (CoreLayerGetPrimaryContext*) args_alloc( args_static, sizeof(CoreLayerGetPrimaryContext) );
CoreLayerGetPrimaryContextReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreLayerGetPrimaryContextReturn*) args_alloc( return_args_static, sizeof(CoreLayerGetPrimaryContextReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreLayer, "ILayer_Requestor::%s()\n", __FUNCTION__ );
D_ASSERT( ret_context != NULL );
args->activate = activate;
ret = (DFBResult) CoreLayer_Call( obj, FCEF_NONE, CoreLayer_GetPrimaryContext, args, sizeof(CoreLayerGetPrimaryContext), return_args, sizeof(CoreLayerGetPrimaryContextReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreLayer_Call( CoreLayer_GetPrimaryContext ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreLayer_GetPrimaryContext failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
ret = (DFBResult) CoreLayerContext_Catch( core, return_args->context_ptr, &context );
if (ret) {
D_DERROR( ret, "%s: Catching context by ID %u failed!\n", __FUNCTION__, return_args->context_id );
goto out;
}
*ret_context = context;
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
ICore_Requestor::GetSurface(
u32 surface_id,
CoreSurface **ret_surface
)
{
DFBResult ret = DFB_OK;
CoreSurface *surface = NULL;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreDFBGetSurface *args = (CoreDFBGetSurface*) args_alloc( args_static, sizeof(CoreDFBGetSurface) );
CoreDFBGetSurfaceReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreDFBGetSurfaceReturn*) args_alloc( return_args_static, sizeof(CoreDFBGetSurfaceReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
D_ASSERT( ret_surface != NULL );
args->surface_id = surface_id;
ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, CoreDFB_GetSurface, args, sizeof(CoreDFBGetSurface), return_args, sizeof(CoreDFBGetSurfaceReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_GetSurface ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreDFB_GetSurface failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
ret = (DFBResult) CoreSurface_Catch( core, return_args->surface_ptr, &surface );
if (ret) {
D_DERROR( ret, "%s: Catching surface by ID %u failed!\n", __FUNCTION__, return_args->surface_id );
goto out;
}
*ret_surface = surface;
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
/* Insert all arguments in src into dest at position index.
* If replace is true, the element at dest->argv[index] is replaced
* with the contents of src and everything past it is shifted.
* Otherwise, dest->argv[index] is also shifted.
*
* src is consumed by this operation and should not be freed or used
* again by the caller */
void
args_insert(struct args *dest, int index, struct args *src, bool replace)
{
int offset;
int i;
/* Adjustments made if we are replacing or shifting the element
* currently at dest->argv[index] */
offset = replace ? 1 : 0;
if (replace) {
free(dest->argv[index]);
}
if (src->argc == 0) {
if (replace) {
/* Have to shift everything down by 1 since
* we replaced with an empty list */
for (i = index; i < dest->argc; i++) {
dest->argv[i] = dest->argv[i + 1];
}
dest->argc--;
}
args_free(src);
return;
}
if (src->argc == 1 && replace) {
/* Trivial case; replace with 1 element */
dest->argv[index] = src->argv[0];
src->argc = 0;
args_free(src);
return;
}
dest->argv = (char **)x_realloc(
dest->argv,
(src->argc + dest->argc + 1 - offset) *
sizeof(char *));
/* Shift arguments over */
for (i = dest->argc; i >= index + offset; i--) {
dest->argv[i + src->argc - offset] = dest->argv[i];
}
/* Copy the new arguments into place */
for (i = 0; i < src->argc; i++) {
dest->argv[i + index] = src->argv[i];
}
dest->argc += src->argc - offset;
src->argc = 0;
args_free(src);
}
DFBResult
ICore_Requestor::ClipboardSet(
const char *mime_type,
u32 mime_type_size,
const char *data,
u32 data_size,
u64 timestamp_us
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreDFBClipboardSet *args = (CoreDFBClipboardSet*) args_alloc( args_static, sizeof(CoreDFBClipboardSet) + mime_type_size * sizeof(char) + data_size * sizeof(char) );
CoreDFBClipboardSetReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreDFBClipboardSetReturn*) args_alloc( return_args_static, sizeof(CoreDFBClipboardSetReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
args->mime_type_size = mime_type_size;
args->data_size = data_size;
args->timestamp_us = timestamp_us;
direct_memcpy( (char*) (args + 1), mime_type, mime_type_size * sizeof(char) );
direct_memcpy( (char*) (args + 1) + mime_type_size * sizeof(char), data, data_size * sizeof(char) );
ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, CoreDFB_ClipboardSet, args, sizeof(CoreDFBClipboardSet) + mime_type_size * sizeof(char) + data_size * sizeof(char), return_args, sizeof(CoreDFBClipboardSetReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_ClipboardSet ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreDFB_ClipboardSet failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
IImageProvider_Requestor::RenderTo(
CoreSurface *destination,
const DFBRectangle *rect
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
ImageProviderRenderTo *args = (ImageProviderRenderTo*) args_alloc( args_static, sizeof(ImageProviderRenderTo) );
ImageProviderRenderToReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (ImageProviderRenderToReturn*) args_alloc( return_args_static, sizeof(ImageProviderRenderToReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_ImageProvider, "IImageProvider_Requestor::%s()\n", __FUNCTION__ );
D_ASSERT( destination != NULL );
args->destination_id = CoreSurface_GetID( destination );
if (rect) {
args->rect = *rect;
args->rect_set = true;
}
else
args->rect_set = false;
ret = (DFBResult) ImageProvider_Call( obj, FCEF_NONE, ImageProvider_RenderTo, args, sizeof(ImageProviderRenderTo), return_args, sizeof(ImageProviderRenderToReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: ImageProvider_Call( ImageProvider_RenderTo ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: ImageProvider_RenderTo failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
ICore_Requestor::ClipboardGet(
char *ret_mime_type,
u32 *ret_mime_type_size,
char *ret_data,
u32 *ret_data_size
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreDFBClipboardGet *args = (CoreDFBClipboardGet*) args_alloc( args_static, sizeof(CoreDFBClipboardGet) );
CoreDFBClipboardGetReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreDFBClipboardGetReturn*) args_alloc( return_args_static, sizeof(CoreDFBClipboardGetReturn) + MAX_CLIPBOARD_MIME_TYPE_SIZE * sizeof(char) + MAX_CLIPBOARD_DATA_SIZE * sizeof(char) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, CoreDFB_ClipboardGet, args, sizeof(CoreDFBClipboardGet), return_args, sizeof(CoreDFBClipboardGetReturn) + MAX_CLIPBOARD_MIME_TYPE_SIZE * sizeof(char) + MAX_CLIPBOARD_DATA_SIZE * sizeof(char), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_ClipboardGet ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreDFB_ClipboardGet failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
*ret_mime_type_size = return_args->mime_type_size;
*ret_data_size = return_args->data_size;
direct_memcpy( ret_mime_type, (char*) (return_args + 1), return_args->mime_type_size * sizeof(char) );
direct_memcpy( ret_data, (char*) (return_args + 1) + return_args->mime_type_size * sizeof(char), return_args->data_size * sizeof(char) );
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
IPalette_Requestor::SetEntriesYUV(
const DFBColorYUV *colors,
u32 num,
u32 offset
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CorePaletteSetEntriesYUV *args = (CorePaletteSetEntriesYUV*) args_alloc( args_static, sizeof(CorePaletteSetEntriesYUV) + num * sizeof(DFBColorYUV) );
CorePaletteSetEntriesYUVReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CorePaletteSetEntriesYUVReturn*) args_alloc( return_args_static, sizeof(CorePaletteSetEntriesYUVReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CorePalette, "IPalette_Requestor::%s()\n", __FUNCTION__ );
D_ASSERT( colors != NULL );
args->num = num;
args->offset = offset;
direct_memcpy( (char*) (args + 1), colors, num * sizeof(DFBColorYUV) );
ret = (DFBResult) CorePalette_Call( obj, FCEF_NONE, CorePalette_SetEntriesYUV, args, sizeof(CorePaletteSetEntriesYUV) + num * sizeof(DFBColorYUV), return_args, sizeof(CorePaletteSetEntriesYUVReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CorePalette_Call( CorePalette_SetEntriesYUV ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CorePalette_SetEntriesYUV failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
ICore_Requestor::AllowSurface(
CoreSurface *surface,
const char *executable,
u32 executable_length
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreDFBAllowSurface *args = (CoreDFBAllowSurface*) args_alloc( args_static, sizeof(CoreDFBAllowSurface) + executable_length * sizeof(char) );
CoreDFBAllowSurfaceReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreDFBAllowSurfaceReturn*) args_alloc( return_args_static, sizeof(CoreDFBAllowSurfaceReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
D_ASSERT( surface != NULL );
args->surface_id = CoreSurface_GetID( surface );
args->executable_length = executable_length;
direct_memcpy( (char*) (args + 1), executable, executable_length * sizeof(char) );
ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, CoreDFB_AllowSurface, args, sizeof(CoreDFBAllowSurface) + executable_length * sizeof(char), return_args, sizeof(CoreDFBAllowSurfaceReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_AllowSurface ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreDFB_AllowSurface failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
IInputDevice_Requestor::SetKeymapEntry(
s32 key_code,
const DFBInputDeviceKeymapEntry *entry
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreInputDeviceSetKeymapEntry *args = (CoreInputDeviceSetKeymapEntry*) args_alloc( args_static, sizeof(CoreInputDeviceSetKeymapEntry) );
CoreInputDeviceSetKeymapEntryReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreInputDeviceSetKeymapEntryReturn*) args_alloc( return_args_static, sizeof(CoreInputDeviceSetKeymapEntryReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreInputDevice, "IInputDevice_Requestor::%s()\n", __FUNCTION__ );
D_ASSERT( entry != NULL );
args->key_code = key_code;
args->entry = *entry;
ret = (DFBResult) CoreInputDevice_Call( obj, FCEF_NONE, CoreInputDevice_SetKeymapEntry, args, sizeof(CoreInputDeviceSetKeymapEntry), return_args, sizeof(CoreInputDeviceSetKeymapEntryReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreInputDevice_Call( CoreInputDevice_SetKeymapEntry ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreInputDevice_SetKeymapEntry failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
ICore_Requestor::CreateImageProvider(
u32 buffer_call,
u32 *ret_call
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreDFBCreateImageProvider *args = (CoreDFBCreateImageProvider*) args_alloc( args_static, sizeof(CoreDFBCreateImageProvider) );
CoreDFBCreateImageProviderReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreDFBCreateImageProviderReturn*) args_alloc( return_args_static, sizeof(CoreDFBCreateImageProviderReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
args->buffer_call = buffer_call;
ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, CoreDFB_CreateImageProvider, args, sizeof(CoreDFBCreateImageProvider), return_args, sizeof(CoreDFBCreateImageProviderReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_CreateImageProvider ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreDFB_CreateImageProvider failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
*ret_call = return_args->call;
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
IImageProvider_Requestor::GetImageDescription(
DFBImageDescription *ret_description
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
ImageProviderGetImageDescription *args = (ImageProviderGetImageDescription*) args_alloc( args_static, sizeof(ImageProviderGetImageDescription) );
ImageProviderGetImageDescriptionReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (ImageProviderGetImageDescriptionReturn*) args_alloc( return_args_static, sizeof(ImageProviderGetImageDescriptionReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_ImageProvider, "IImageProvider_Requestor::%s()\n", __FUNCTION__ );
D_ASSERT( ret_description != NULL );
ret = (DFBResult) ImageProvider_Call( obj, FCEF_NONE, ImageProvider_GetImageDescription, args, sizeof(ImageProviderGetImageDescription), return_args, sizeof(ImageProviderGetImageDescriptionReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: ImageProvider_Call( ImageProvider_GetImageDescription ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: ImageProvider_GetImageDescription failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
*ret_description = return_args->description;
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
IInputDevice_Requestor::SetConfiguration(
const DFBInputDeviceConfig *config
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreInputDeviceSetConfiguration *args = (CoreInputDeviceSetConfiguration*) args_alloc( args_static, sizeof(CoreInputDeviceSetConfiguration) );
CoreInputDeviceSetConfigurationReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreInputDeviceSetConfigurationReturn*) args_alloc( return_args_static, sizeof(CoreInputDeviceSetConfigurationReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreInputDevice, "IInputDevice_Requestor::%s()\n", __FUNCTION__ );
D_ASSERT( config != NULL );
args->config = *config;
ret = (DFBResult) CoreInputDevice_Call( obj, FCEF_NONE, CoreInputDevice_SetConfiguration, args, sizeof(CoreInputDeviceSetConfiguration), return_args, sizeof(CoreInputDeviceSetConfigurationReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreInputDevice_Call( CoreInputDevice_SetConfiguration ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreInputDevice_SetConfiguration failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
ILayer_Requestor::ActivateContext(
CoreLayerContext *context
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreLayerActivateContext *args = (CoreLayerActivateContext*) args_alloc( args_static, sizeof(CoreLayerActivateContext) );
CoreLayerActivateContextReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreLayerActivateContextReturn*) args_alloc( return_args_static, sizeof(CoreLayerActivateContextReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreLayer, "ILayer_Requestor::%s()\n", __FUNCTION__ );
D_ASSERT( context != NULL );
args->context_id = CoreLayerContext_GetID( context );
ret = (DFBResult) CoreLayer_Call( obj, FCEF_NONE, CoreLayer_ActivateContext, args, sizeof(CoreLayerActivateContext), return_args, sizeof(CoreLayerActivateContextReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreLayer_Call( CoreLayer_ActivateContext ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreLayer_ActivateContext failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
ICore_Requestor::ClipboardGetTimestamp(
u64 *ret_timestamp_us
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreDFBClipboardGetTimestamp *args = (CoreDFBClipboardGetTimestamp*) args_alloc( args_static, sizeof(CoreDFBClipboardGetTimestamp) );
CoreDFBClipboardGetTimestampReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreDFBClipboardGetTimestampReturn*) args_alloc( return_args_static, sizeof(CoreDFBClipboardGetTimestampReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, CoreDFB_ClipboardGetTimestamp, args, sizeof(CoreDFBClipboardGetTimestamp), return_args, sizeof(CoreDFBClipboardGetTimestampReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_ClipboardGetTimestamp ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreDFB_ClipboardGetTimestamp failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
*ret_timestamp_us = return_args->timestamp_us;
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
ILayer_Requestor::SetLevel(
s32 level
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreLayerSetLevel *args = (CoreLayerSetLevel*) args_alloc( args_static, sizeof(CoreLayerSetLevel) );
CoreLayerSetLevelReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreLayerSetLevelReturn*) args_alloc( return_args_static, sizeof(CoreLayerSetLevelReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreLayer, "ILayer_Requestor::%s()\n", __FUNCTION__ );
args->level = level;
ret = (DFBResult) CoreLayer_Call( obj, FCEF_NONE, CoreLayer_SetLevel, args, sizeof(CoreLayerSetLevel), return_args, sizeof(CoreLayerSetLevelReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreLayer_Call( CoreLayer_SetLevel ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreLayer_SetLevel failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
ILayer_Requestor::GetCurrentOutputField(
s32 *ret_field
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreLayerGetCurrentOutputField *args = (CoreLayerGetCurrentOutputField*) args_alloc( args_static, sizeof(CoreLayerGetCurrentOutputField) );
CoreLayerGetCurrentOutputFieldReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreLayerGetCurrentOutputFieldReturn*) args_alloc( return_args_static, sizeof(CoreLayerGetCurrentOutputFieldReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreLayer, "ILayer_Requestor::%s()\n", __FUNCTION__ );
ret = (DFBResult) CoreLayer_Call( obj, FCEF_NONE, CoreLayer_GetCurrentOutputField, args, sizeof(CoreLayerGetCurrentOutputField), return_args, sizeof(CoreLayerGetCurrentOutputFieldReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreLayer_Call( CoreLayer_GetCurrentOutputField ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreLayer_GetCurrentOutputField failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
*ret_field = return_args->field;
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
static void delete_native_rule( void * xrule, void * data )
{
native_rule_t * rule = (native_rule_t *)xrule;
if ( rule->arguments )
args_free( rule->arguments );
object_free( rule->name );
if ( rule->procedure )
function_free( rule->procedure );
}
DFBResult
IImageProvider_Requestor::Dispose(
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
ImageProviderDispose *args = (ImageProviderDispose*) args_alloc( args_static, sizeof(ImageProviderDispose) );
ImageProviderDisposeReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (ImageProviderDisposeReturn*) args_alloc( return_args_static, sizeof(ImageProviderDisposeReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_ImageProvider, "IImageProvider_Requestor::%s()\n", __FUNCTION__ );
ret = (DFBResult) ImageProvider_Call( obj, FCEF_NONE, ImageProvider_Dispose, args, sizeof(ImageProviderDispose), return_args, sizeof(ImageProviderDisposeReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: ImageProvider_Call( ImageProvider_Dispose ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: ImageProvider_Dispose failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
ICore_Requestor::WaitIdle(
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreDFBWaitIdle *args = (CoreDFBWaitIdle*) args_alloc( args_static, sizeof(CoreDFBWaitIdle) );
CoreDFBWaitIdleReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreDFBWaitIdleReturn*) args_alloc( return_args_static, sizeof(CoreDFBWaitIdleReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, CoreDFB_WaitIdle, args, sizeof(CoreDFBWaitIdle), return_args, sizeof(CoreDFBWaitIdleReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_WaitIdle ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreDFB_WaitIdle failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
DFBResult
IInputDevice_Requestor::ReloadKeymap(
)
{
DFBResult ret = DFB_OK;
char args_static[FLUXED_ARGS_BYTES];
char return_args_static[FLUXED_ARGS_BYTES];
CoreInputDeviceReloadKeymap *args = (CoreInputDeviceReloadKeymap*) args_alloc( args_static, sizeof(CoreInputDeviceReloadKeymap) );
CoreInputDeviceReloadKeymapReturn *return_args;
if (!args)
return (DFBResult) D_OOM();
return_args = (CoreInputDeviceReloadKeymapReturn*) args_alloc( return_args_static, sizeof(CoreInputDeviceReloadKeymapReturn) );
if (!return_args) {
args_free( args_static, args );
return (DFBResult) D_OOM();
}
D_DEBUG_AT( DirectFB_CoreInputDevice, "IInputDevice_Requestor::%s()\n", __FUNCTION__ );
ret = (DFBResult) CoreInputDevice_Call( obj, FCEF_NONE, CoreInputDevice_ReloadKeymap, args, sizeof(CoreInputDeviceReloadKeymap), return_args, sizeof(CoreInputDeviceReloadKeymapReturn), NULL );
if (ret) {
D_DERROR( ret, "%s: CoreInputDevice_Call( CoreInputDevice_ReloadKeymap ) failed!\n", __FUNCTION__ );
goto out;
}
if (return_args->result) {
/*D_DERROR( return_args->result, "%s: CoreInputDevice_ReloadKeymap failed!\n", __FUNCTION__ );*/
ret = return_args->result;
goto out;
}
out:
args_free( return_args_static, return_args );
args_free( args_static, args );
return ret;
}
int main(int argc, char **argv)
{
t_application app;
t_args args;
(void)argc;
if (!args_init(&args, argv + 1))
{
if (!application_init(&app, &args))
{
args_free(&args);
application_run(&app);
}
else
args_free(&args);
application_free(&app);
}
return (0);
}
static void in_pop(void)
{
struct inbuf *old = buf;
buf = buf->prev;
if (old->args)
args_free(old->args);
if (old->fin && old->fin != stdin)
fclose(old->fin);
free(old->buf);
free(old);
}
static enum cmd_retval
cmd_find_window_exec(struct cmd *self, struct cmdq_item *item)
{
struct args *args = self->args, *new_args;
struct window_pane *wp = item->target.wp;
const char *s = args->argv[0];
char *filter, *argv = { NULL };
int C, N, T;
C = args_has(args, 'C');
N = args_has(args, 'N');
T = args_has(args, 'T');
if (!C && !N && !T)
C = N = T = 1;
if (C && N && T) {
xasprintf(&filter,
"#{||:"
"#{C:%s},#{||:#{m:*%s*,#{window_name}},"
"#{m:*%s*,#{pane_title}}}}",
s, s, s);
} else if (C && N) {
xasprintf(&filter,
"#{||:#{C:%s},#{m:*%s*,#{window_name}}}",
s, s);
} else if (C && T) {
xasprintf(&filter,
"#{||:#{C:%s},#{m:*%s*,#{pane_title}}}",
s, s);
} else if (N && T) {
xasprintf(&filter,
"#{||:#{m:*%s*,#{window_name}},#{m:*%s*,#{pane_title}}}",
s, s);
} else if (C)
xasprintf(&filter, "#{C:%s}", s);
else if (N)
xasprintf(&filter, "#{m:*%s*,#{window_name}}", s);
else
xasprintf(&filter, "#{m:*%s*,#{pane_title}}", s);
new_args = args_parse("", 1, &argv);
args_set(new_args, 'f', filter);
window_pane_set_mode(wp, &window_tree_mode, &item->target, new_args);
args_free(new_args);
free(filter);
return (CMD_RETURN_NORMAL);
}
/*
* set_rule_body() - set the argument list and procedure of the given rule
*/
static void set_rule_body( RULE* rule, argument_list* args, PARSE* procedure )
{
if ( args )
args_refer( args );
if ( rule->arguments )
args_free( rule->arguments );
rule->arguments = args;
if ( procedure )
parse_refer( procedure );
if ( rule->procedure )
parse_free( rule->procedure );
rule->procedure = procedure;
}
void
rule_free( RULE* r )
{
freestr( r->name );
r->name = "";
parse_free( r->procedure );
r->procedure = 0;
if ( r->arguments )
args_free( r->arguments );
r->arguments = 0;
if ( r->actions )
actions_free( r->actions );
r->actions = 0;
}
static void set_rule_body( RULE * rule, argument_list * args, FUNCTION * procedure )
{
if ( args )
args_refer( args );
if ( rule->arguments )
args_free( rule->arguments );
rule->arguments = args;
if ( procedure )
function_refer( procedure );
if ( rule->procedure )
function_free( rule->procedure );
rule->procedure = procedure;
}
/* Handles arguments received from remote instance. */
static void
parse_received_arguments(char *argv[])
{
int argc = 0;
args_t args = {};
while(argv[argc] != NULL)
{
argc++;
}
(void)vifm_chdir(argv[0]);
opterr = 0;
args_parse(&args, argc, argv, argv[0]);
args_process(&args, 0);
exec_startup_commands(&args);
args_free(&args);
if(NONE(vle_mode_is, NORMAL_MODE, VIEW_MODE))
{
return;
}
#ifdef _WIN32
SwitchToThisWindow(GetConsoleWindow(), TRUE);
BringWindowToTop(GetConsoleWindow());
SetForegroundWindow(GetConsoleWindow());
#endif
if(view_needs_cd(&lwin, args.lwin_path))
{
remote_cd(&lwin, args.lwin_path, args.lwin_handle);
}
if(view_needs_cd(&rwin, args.rwin_path))
{
remote_cd(&rwin, args.rwin_path, args.rwin_handle);
}
if(need_to_switch_active_pane(args.lwin_path, args.rwin_path))
{
change_window();
}
ui_sb_clear();
curr_stats.save_msg = 0;
}
int
main(int argc, char *argv[])
{
char *program_name, *compiler_name, *other_wrappers, *sysroot;
struct args *compiler_args, *cmd;
compiler_args = args_init(argc, argv);
/* check if we were called directly. */
program_name = basename(compiler_args->argv[0]);
args_remove_first(compiler_args);
if (str_eq(program_name, MYNAME)) {
/* the first argument should be a compiler */
if (compiler_args->argc < 1 || compiler_args->argv[0][0] == '-') {
fprintf(stderr, "%s", USAGE_TEXT);
exit(1);
}
compiler_name = x_strdup(compiler_args->argv[0]);
args_remove_first(compiler_args);
} else {
compiler_name = x_strdup(program_name);
}
free(program_name);
other_wrappers = getenv(MYNAME "_OTHER_WRAPPERS");
if (!other_wrappers) {
other_wrappers = "ccache distcc";
}
cmd = find_all_executables(compiler_name, MYNAME, other_wrappers);
if (!cmd) {
fatal("No valid executables named %s found!", compiler_name);
}
free(compiler_name);
sysroot = getenv("SYSROOT");
if (sysroot) {
args_add(cmd, "--sysroot");
args_add(cmd, sysroot);
}
args_extend(cmd, compiler_args);
args_free(compiler_args);
execute(cmd->argv);
return 1;
}
