1 /*
2 (c) Copyright 2001-2011 The world wide DirectFB Open Source Community (directfb.org)
3 (c) Copyright 2000-2004 Convergence (integrated media) GmbH
4
5 All rights reserved.
6
7 Written by Denis Oliver Kropp <dok@directfb.org>,
8 Andreas Hundt <andi@fischlustig.de>,
9 Sven Neumann <neo@directfb.org>,
10 Ville Syrjälä <syrjala@sci.fi> and
11 Claudio Ciccani <klan@users.sf.net>.
12
13 This library is free software; you can redistribute it and/or
14 modify it under the terms of the GNU Lesser General Public
15 License as published by the Free Software Foundation; either
16 version 2 of the License, or (at your option) any later version.
17
18 This library is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 Lesser General Public License for more details.
22
23 You should have received a copy of the GNU Lesser General Public
24 License along with this library; if not, write to the
25 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
26 Boston, MA 02111-1307, USA.
27 */
28
29 #include <config.h>
30
31 #include "CoreDFB.h"
32
33 #include <directfb_util.h>
34
35 #include <direct/debug.h>
36 #include <direct/mem.h>
37 #include <direct/memcpy.h>
38 #include <direct/messages.h>
39
40 #include <fusion/conf.h>
41
42 #include <core/core.h>
43
44 #include <core/CoreDFB_CallMode.h>
45
46 D_DEBUG_DOMAIN( DirectFB_CoreDFB, "DirectFB/CoreDFB", "DirectFB CoreDFB" );
47
48 /*********************************************************************************************************************/
49
50 DFBResult
CoreDFB_Register(CoreDFB * obj,u32 slave_call)51 CoreDFB_Register(
52 CoreDFB *obj,
53 u32 slave_call
54 )
55 {
56 DFBResult ret;
57
58 switch (CoreDFB_CallMode( core_dfb )) {
59 case COREDFB_CALL_DIRECT:{
60 Core_PushCalling();
61 ret = ICore_Real__Register( obj, slave_call );
62 Core_PopCalling();
63
64 return ret;
65 }
66
67 case COREDFB_CALL_INDIRECT: {
68 Core_PushCalling();
69 ret = ICore_Requestor__Register( obj, slave_call );
70 Core_PopCalling();
71
72 return ret;
73 }
74 case COREDFB_CALL_DENY:
75 return DFB_DEAD;
76 }
77
78 return DFB_UNIMPLEMENTED;
79 }
80
81 DFBResult
CoreDFB_CreateSurface(CoreDFB * obj,const CoreSurfaceConfig * config,CoreSurfaceTypeFlags type,u64 resource_id,CorePalette * palette,CoreSurface ** ret_surface)82 CoreDFB_CreateSurface(
83 CoreDFB *obj,
84 const CoreSurfaceConfig *config,
85 CoreSurfaceTypeFlags type,
86 u64 resource_id,
87 CorePalette *palette,
88 CoreSurface **ret_surface
89 )
90 {
91 DFBResult ret;
92
93 switch (CoreDFB_CallMode( core_dfb )) {
94 case COREDFB_CALL_DIRECT:{
95 Core_PushCalling();
96 ret = ICore_Real__CreateSurface( obj, config, type, resource_id, palette, ret_surface );
97 Core_PopCalling();
98
99 return ret;
100 }
101
102 case COREDFB_CALL_INDIRECT: {
103 Core_PushCalling();
104 ret = ICore_Requestor__CreateSurface( obj, config, type, resource_id, palette, ret_surface );
105 Core_PopCalling();
106
107 return ret;
108 }
109 case COREDFB_CALL_DENY:
110 return DFB_DEAD;
111 }
112
113 return DFB_UNIMPLEMENTED;
114 }
115
116 DFBResult
CoreDFB_CreatePalette(CoreDFB * obj,u32 size,CorePalette ** ret_palette)117 CoreDFB_CreatePalette(
118 CoreDFB *obj,
119 u32 size,
120 CorePalette **ret_palette
121 )
122 {
123 DFBResult ret;
124
125 switch (CoreDFB_CallMode( core_dfb )) {
126 case COREDFB_CALL_DIRECT:{
127 Core_PushCalling();
128 ret = ICore_Real__CreatePalette( obj, size, ret_palette );
129 Core_PopCalling();
130
131 return ret;
132 }
133
134 case COREDFB_CALL_INDIRECT: {
135 Core_PushCalling();
136 ret = ICore_Requestor__CreatePalette( obj, size, ret_palette );
137 Core_PopCalling();
138
139 return ret;
140 }
141 case COREDFB_CALL_DENY:
142 return DFB_DEAD;
143 }
144
145 return DFB_UNIMPLEMENTED;
146 }
147
148 DFBResult
CoreDFB_CreateState(CoreDFB * obj,CoreGraphicsState ** ret_state)149 CoreDFB_CreateState(
150 CoreDFB *obj,
151 CoreGraphicsState **ret_state
152 )
153 {
154 DFBResult ret;
155
156 switch (CoreDFB_CallMode( core_dfb )) {
157 case COREDFB_CALL_DIRECT:{
158 Core_PushCalling();
159 ret = ICore_Real__CreateState( obj, ret_state );
160 Core_PopCalling();
161
162 return ret;
163 }
164
165 case COREDFB_CALL_INDIRECT: {
166 Core_PushCalling();
167 ret = ICore_Requestor__CreateState( obj, ret_state );
168 Core_PopCalling();
169
170 return ret;
171 }
172 case COREDFB_CALL_DENY:
173 return DFB_DEAD;
174 }
175
176 return DFB_UNIMPLEMENTED;
177 }
178
179 DFBResult
CoreDFB_WaitIdle(CoreDFB * obj)180 CoreDFB_WaitIdle(
181 CoreDFB *obj
182
183 )
184 {
185 DFBResult ret;
186
187 switch (CoreDFB_CallMode( core_dfb )) {
188 case COREDFB_CALL_DIRECT:{
189 Core_PushCalling();
190 ret = ICore_Real__WaitIdle( obj );
191 Core_PopCalling();
192
193 return ret;
194 }
195
196 case COREDFB_CALL_INDIRECT: {
197 Core_PushCalling();
198 ret = ICore_Requestor__WaitIdle( obj );
199 Core_PopCalling();
200
201 return ret;
202 }
203 case COREDFB_CALL_DENY:
204 return DFB_DEAD;
205 }
206
207 return DFB_UNIMPLEMENTED;
208 }
209
210 DFBResult
CoreDFB_CreateImageProvider(CoreDFB * obj,u32 buffer_call,u32 * ret_call)211 CoreDFB_CreateImageProvider(
212 CoreDFB *obj,
213 u32 buffer_call,
214 u32 *ret_call
215 )
216 {
217 DFBResult ret;
218
219 switch (CoreDFB_CallMode( core_dfb )) {
220 case COREDFB_CALL_DIRECT:{
221 Core_PushCalling();
222 ret = ICore_Real__CreateImageProvider( obj, buffer_call, ret_call );
223 Core_PopCalling();
224
225 return ret;
226 }
227
228 case COREDFB_CALL_INDIRECT: {
229 Core_PushCalling();
230 ret = ICore_Requestor__CreateImageProvider( obj, buffer_call, ret_call );
231 Core_PopCalling();
232
233 return ret;
234 }
235 case COREDFB_CALL_DENY:
236 return DFB_DEAD;
237 }
238
239 return DFB_UNIMPLEMENTED;
240 }
241
242 /*********************************************************************************************************************/
243
244 static FusionCallHandlerResult
CoreDFB_Dispatch(int caller,int call_arg,void * ptr,unsigned int length,void * ctx,unsigned int serial,void * ret_ptr,unsigned int ret_size,unsigned int * ret_length)245 CoreDFB_Dispatch( int caller, /* fusion id of the caller */
246 int call_arg, /* optional call parameter */
247 void *ptr, /* optional call parameter */
248 unsigned int length,
249 void *ctx, /* optional handler context */
250 unsigned int serial,
251 void *ret_ptr,
252 unsigned int ret_size,
253 unsigned int *ret_length )
254 {
255 CoreDFB *obj = (CoreDFB*) ctx;
256 CoreDFBDispatch__Dispatch( obj, caller, call_arg, ptr, length, ret_ptr, ret_size, ret_length );
257
258 return FCHR_RETURN;
259 }
260
CoreDFB_Init_Dispatch(CoreDFB * core,CoreDFB * obj,FusionCall * call)261 void CoreDFB_Init_Dispatch(
262 CoreDFB *core,
263 CoreDFB *obj,
264 FusionCall *call
265 )
266 {
267 fusion_call_init3( call, CoreDFB_Dispatch, obj, core->world );
268 }
269
CoreDFB_Deinit_Dispatch(FusionCall * call)270 void CoreDFB_Deinit_Dispatch(
271 FusionCall *call
272 )
273 {
274 fusion_call_destroy( call );
275 }
276
277 /*********************************************************************************************************************/
278
279
280 DFBResult
ICore_Requestor__Register(CoreDFB * obj,u32 slave_call)281 ICore_Requestor__Register( CoreDFB *obj,
282 u32 slave_call
283 )
284 {
285 DFBResult ret;
286 CoreDFBRegister *args = (CoreDFBRegister*) alloca( sizeof(CoreDFBRegister) );
287 CoreDFBRegisterReturn *return_args = (CoreDFBRegisterReturn*) alloca( sizeof(CoreDFBRegisterReturn) );
288
289 D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
290
291
292 args->slave_call = slave_call;
293
294 ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, _CoreDFB_Register, args, sizeof(CoreDFBRegister), return_args, sizeof(CoreDFBRegisterReturn), NULL );
295 if (ret) {
296 D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_Register ) failed!\n", __FUNCTION__ );
297 return ret;
298 }
299
300 if (return_args->result) {
301 /*D_DERROR( return_args->result, "%s: CoreDFB_Register failed!\n", __FUNCTION__ );*/
302 return return_args->result;
303 }
304
305
306 return DFB_OK;
307 }
308
309
310 DFBResult
ICore_Requestor__CreateSurface(CoreDFB * obj,const CoreSurfaceConfig * config,CoreSurfaceTypeFlags type,u64 resource_id,CorePalette * palette,CoreSurface ** ret_surface)311 ICore_Requestor__CreateSurface( CoreDFB *obj,
312 const CoreSurfaceConfig *config,
313 CoreSurfaceTypeFlags type,
314 u64 resource_id,
315 CorePalette *palette,
316 CoreSurface **ret_surface
317 )
318 {
319 DFBResult ret;
320 CoreSurface *surface = NULL;
321 CoreDFBCreateSurface *args = (CoreDFBCreateSurface*) alloca( sizeof(CoreDFBCreateSurface) );
322 CoreDFBCreateSurfaceReturn *return_args = (CoreDFBCreateSurfaceReturn*) alloca( sizeof(CoreDFBCreateSurfaceReturn) );
323
324 D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
325
326 D_ASSERT( config != NULL );
327 D_ASSERT( ret_surface != NULL );
328
329 args->config = *config;
330 args->type = type;
331 args->resource_id = resource_id;
332 if (palette) {
333 args->palette_id = CorePalette_GetID( palette );
334 args->palette_set = true;
335 }
336 else
337 args->palette_set = false;
338
339 ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, _CoreDFB_CreateSurface, args, sizeof(CoreDFBCreateSurface), return_args, sizeof(CoreDFBCreateSurfaceReturn), NULL );
340 if (ret) {
341 D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_CreateSurface ) failed!\n", __FUNCTION__ );
342 return ret;
343 }
344
345 if (return_args->result) {
346 /*D_DERROR( return_args->result, "%s: CoreDFB_CreateSurface failed!\n", __FUNCTION__ );*/
347 return return_args->result;
348 }
349
350
351 ret = (DFBResult) CoreSurface_Catch( core_dfb, return_args->surface_id, &surface );
352 if (ret) {
353 D_DERROR( ret, "%s: Catching surface by ID %u failed!\n", __FUNCTION__, return_args->surface_id );
354 return ret;
355 }
356
357 *ret_surface = surface;
358
359 return DFB_OK;
360 }
361
362
363 DFBResult
ICore_Requestor__CreatePalette(CoreDFB * obj,u32 size,CorePalette ** ret_palette)364 ICore_Requestor__CreatePalette( CoreDFB *obj,
365 u32 size,
366 CorePalette **ret_palette
367 )
368 {
369 DFBResult ret;
370 CorePalette *palette = NULL;
371 CoreDFBCreatePalette *args = (CoreDFBCreatePalette*) alloca( sizeof(CoreDFBCreatePalette) );
372 CoreDFBCreatePaletteReturn *return_args = (CoreDFBCreatePaletteReturn*) alloca( sizeof(CoreDFBCreatePaletteReturn) );
373
374 D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
375
376 D_ASSERT( ret_palette != NULL );
377
378 args->size = size;
379
380 ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, _CoreDFB_CreatePalette, args, sizeof(CoreDFBCreatePalette), return_args, sizeof(CoreDFBCreatePaletteReturn), NULL );
381 if (ret) {
382 D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_CreatePalette ) failed!\n", __FUNCTION__ );
383 return ret;
384 }
385
386 if (return_args->result) {
387 /*D_DERROR( return_args->result, "%s: CoreDFB_CreatePalette failed!\n", __FUNCTION__ );*/
388 return return_args->result;
389 }
390
391
392 ret = (DFBResult) CorePalette_Catch( core_dfb, return_args->palette_id, &palette );
393 if (ret) {
394 D_DERROR( ret, "%s: Catching palette by ID %u failed!\n", __FUNCTION__, return_args->palette_id );
395 return ret;
396 }
397
398 *ret_palette = palette;
399
400 return DFB_OK;
401 }
402
403
404 DFBResult
ICore_Requestor__CreateState(CoreDFB * obj,CoreGraphicsState ** ret_state)405 ICore_Requestor__CreateState( CoreDFB *obj,
406 CoreGraphicsState **ret_state
407 )
408 {
409 DFBResult ret;
410 CoreGraphicsState *state = NULL;
411 CoreDFBCreateState *args = (CoreDFBCreateState*) alloca( sizeof(CoreDFBCreateState) );
412 CoreDFBCreateStateReturn *return_args = (CoreDFBCreateStateReturn*) alloca( sizeof(CoreDFBCreateStateReturn) );
413
414 D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
415
416 D_ASSERT( ret_state != NULL );
417
418
419 ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, _CoreDFB_CreateState, args, sizeof(CoreDFBCreateState), return_args, sizeof(CoreDFBCreateStateReturn), NULL );
420 if (ret) {
421 D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_CreateState ) failed!\n", __FUNCTION__ );
422 return ret;
423 }
424
425 if (return_args->result) {
426 /*D_DERROR( return_args->result, "%s: CoreDFB_CreateState failed!\n", __FUNCTION__ );*/
427 return return_args->result;
428 }
429
430
431 ret = (DFBResult) CoreGraphicsState_Catch( core_dfb, return_args->state_id, &state );
432 if (ret) {
433 D_DERROR( ret, "%s: Catching state by ID %u failed!\n", __FUNCTION__, return_args->state_id );
434 return ret;
435 }
436
437 *ret_state = state;
438
439 return DFB_OK;
440 }
441
442
443 DFBResult
ICore_Requestor__WaitIdle(CoreDFB * obj)444 ICore_Requestor__WaitIdle( CoreDFB *obj
445
446 )
447 {
448 DFBResult ret;
449 CoreDFBWaitIdle *args = (CoreDFBWaitIdle*) alloca( sizeof(CoreDFBWaitIdle) );
450 CoreDFBWaitIdleReturn *return_args = (CoreDFBWaitIdleReturn*) alloca( sizeof(CoreDFBWaitIdleReturn) );
451
452 D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
453
454
455
456 ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, _CoreDFB_WaitIdle, args, sizeof(CoreDFBWaitIdle), return_args, sizeof(CoreDFBWaitIdleReturn), NULL );
457 if (ret) {
458 D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_WaitIdle ) failed!\n", __FUNCTION__ );
459 return ret;
460 }
461
462 if (return_args->result) {
463 /*D_DERROR( return_args->result, "%s: CoreDFB_WaitIdle failed!\n", __FUNCTION__ );*/
464 return return_args->result;
465 }
466
467
468 return DFB_OK;
469 }
470
471
472 DFBResult
ICore_Requestor__CreateImageProvider(CoreDFB * obj,u32 buffer_call,u32 * ret_call)473 ICore_Requestor__CreateImageProvider( CoreDFB *obj,
474 u32 buffer_call,
475 u32 *ret_call
476 )
477 {
478 DFBResult ret;
479 CoreDFBCreateImageProvider *args = (CoreDFBCreateImageProvider*) alloca( sizeof(CoreDFBCreateImageProvider) );
480 CoreDFBCreateImageProviderReturn *return_args = (CoreDFBCreateImageProviderReturn*) alloca( sizeof(CoreDFBCreateImageProviderReturn) );
481
482 D_DEBUG_AT( DirectFB_CoreDFB, "ICore_Requestor::%s()\n", __FUNCTION__ );
483
484
485 args->buffer_call = buffer_call;
486
487 ret = (DFBResult) CoreDFB_Call( obj, FCEF_NONE, _CoreDFB_CreateImageProvider, args, sizeof(CoreDFBCreateImageProvider), return_args, sizeof(CoreDFBCreateImageProviderReturn), NULL );
488 if (ret) {
489 D_DERROR( ret, "%s: CoreDFB_Call( CoreDFB_CreateImageProvider ) failed!\n", __FUNCTION__ );
490 return ret;
491 }
492
493 if (return_args->result) {
494 /*D_DERROR( return_args->result, "%s: CoreDFB_CreateImageProvider failed!\n", __FUNCTION__ );*/
495 return return_args->result;
496 }
497
498 *ret_call = return_args->call;
499
500 return DFB_OK;
501 }
502
503 /*********************************************************************************************************************/
504
505 static DFBResult
__CoreDFBDispatch__Dispatch(CoreDFB * obj,FusionID caller,int method,void * ptr,unsigned int length,void * ret_ptr,unsigned int ret_size,unsigned int * ret_length)506 __CoreDFBDispatch__Dispatch( CoreDFB *obj,
507 FusionID caller,
508 int method,
509 void *ptr,
510 unsigned int length,
511 void *ret_ptr,
512 unsigned int ret_size,
513 unsigned int *ret_length )
514 {
515 D_UNUSED
516 DFBResult ret;
517
518
519 switch (method) {
520 case _CoreDFB_Register: {
521 D_UNUSED
522 CoreDFBRegister *args = (CoreDFBRegister *) ptr;
523 CoreDFBRegisterReturn *return_args = (CoreDFBRegisterReturn *) ret_ptr;
524
525 D_DEBUG_AT( DirectFB_CoreDFB, "=-> CoreDFB_Register\n" );
526
527 return_args->result = ICore_Real__Register( obj, args->slave_call );
528 if (return_args->result == DFB_OK) {
529 }
530
531 *ret_length = sizeof(CoreDFBRegisterReturn);
532
533 return DFB_OK;
534 }
535
536 case _CoreDFB_CreateSurface: {
537 CorePalette *palette = NULL;
538 CoreSurface *surface = NULL;
539 D_UNUSED
540 CoreDFBCreateSurface *args = (CoreDFBCreateSurface *) ptr;
541 CoreDFBCreateSurfaceReturn *return_args = (CoreDFBCreateSurfaceReturn *) ret_ptr;
542
543 D_DEBUG_AT( DirectFB_CoreDFB, "=-> CoreDFB_CreateSurface\n" );
544
545 if (args->palette_set) {
546 ret = (DFBResult) CorePalette_Lookup( core_dfb, args->palette_id, caller, &palette );
547 if (ret) {
548 D_DERROR( ret, "%s: Looking up palette by ID %u failed!\n", __FUNCTION__, args->palette_id );
549 return_args->result = ret;
550 return DFB_OK;
551 }
552 }
553
554 return_args->result = ICore_Real__CreateSurface( obj, &args->config, args->type, args->resource_id, args->palette_set ? palette : NULL, &surface );
555 if (return_args->result == DFB_OK) {
556 CoreSurface_Throw( surface, caller, &return_args->surface_id );
557 }
558
559 *ret_length = sizeof(CoreDFBCreateSurfaceReturn);
560
561 if (palette)
562 CorePalette_Unref( palette );
563
564 return DFB_OK;
565 }
566
567 case _CoreDFB_CreatePalette: {
568 CorePalette *palette = NULL;
569 D_UNUSED
570 CoreDFBCreatePalette *args = (CoreDFBCreatePalette *) ptr;
571 CoreDFBCreatePaletteReturn *return_args = (CoreDFBCreatePaletteReturn *) ret_ptr;
572
573 D_DEBUG_AT( DirectFB_CoreDFB, "=-> CoreDFB_CreatePalette\n" );
574
575 return_args->result = ICore_Real__CreatePalette( obj, args->size, &palette );
576 if (return_args->result == DFB_OK) {
577 CorePalette_Throw( palette, caller, &return_args->palette_id );
578 }
579
580 *ret_length = sizeof(CoreDFBCreatePaletteReturn);
581
582 return DFB_OK;
583 }
584
585 case _CoreDFB_CreateState: {
586 CoreGraphicsState *state = NULL;
587 D_UNUSED
588 CoreDFBCreateState *args = (CoreDFBCreateState *) ptr;
589 CoreDFBCreateStateReturn *return_args = (CoreDFBCreateStateReturn *) ret_ptr;
590
591 D_DEBUG_AT( DirectFB_CoreDFB, "=-> CoreDFB_CreateState\n" );
592
593 return_args->result = ICore_Real__CreateState( obj, &state );
594 if (return_args->result == DFB_OK) {
595 CoreGraphicsState_Throw( state, caller, &return_args->state_id );
596 }
597
598 *ret_length = sizeof(CoreDFBCreateStateReturn);
599
600 return DFB_OK;
601 }
602
603 case _CoreDFB_WaitIdle: {
604 D_UNUSED
605 CoreDFBWaitIdle *args = (CoreDFBWaitIdle *) ptr;
606 CoreDFBWaitIdleReturn *return_args = (CoreDFBWaitIdleReturn *) ret_ptr;
607
608 D_DEBUG_AT( DirectFB_CoreDFB, "=-> CoreDFB_WaitIdle\n" );
609
610 return_args->result = ICore_Real__WaitIdle( obj );
611 if (return_args->result == DFB_OK) {
612 }
613
614 *ret_length = sizeof(CoreDFBWaitIdleReturn);
615
616 return DFB_OK;
617 }
618
619 case _CoreDFB_CreateImageProvider: {
620 D_UNUSED
621 CoreDFBCreateImageProvider *args = (CoreDFBCreateImageProvider *) ptr;
622 CoreDFBCreateImageProviderReturn *return_args = (CoreDFBCreateImageProviderReturn *) ret_ptr;
623
624 D_DEBUG_AT( DirectFB_CoreDFB, "=-> CoreDFB_CreateImageProvider\n" );
625
626 return_args->result = ICore_Real__CreateImageProvider( obj, args->buffer_call, &return_args->call );
627 if (return_args->result == DFB_OK) {
628 }
629
630 *ret_length = sizeof(CoreDFBCreateImageProviderReturn);
631
632 return DFB_OK;
633 }
634
635 }
636
637 return DFB_NOSUCHMETHOD;
638 }
639 /*********************************************************************************************************************/
640
641 DFBResult
CoreDFBDispatch__Dispatch(CoreDFB * obj,FusionID caller,int method,void * ptr,unsigned int length,void * ret_ptr,unsigned int ret_size,unsigned int * ret_length)642 CoreDFBDispatch__Dispatch( CoreDFB *obj,
643 FusionID caller,
644 int method,
645 void *ptr,
646 unsigned int length,
647 void *ret_ptr,
648 unsigned int ret_size,
649 unsigned int *ret_length )
650 {
651 DFBResult ret;
652
653 D_DEBUG_AT( DirectFB_CoreDFB, "CoreDFBDispatch::%s( %p )\n", __FUNCTION__, obj );
654
655 Core_PushIdentity( caller );
656
657 ret = __CoreDFBDispatch__Dispatch( obj, caller, method, ptr, length, ret_ptr, ret_size, ret_length );
658
659 Core_PopIdentity();
660
661 return ret;
662 }
663