void
dfb_init(int argc, char *argv[])
{
DFBCHECK(DirectFBInit( &argc, &argv ));
/* quiet option is no longer supported in DFB 1.2 */
/* DFBCHECK(DirectFBSetOption ("quiet", "")); */
/* create the super interface */
DFBCHECK(DirectFBCreate( &dfb ));
dfb->SetCooperativeLevel(dfb, DFSCL_FULLSCREEN);
DFBCHECK(dfb->GetDisplayLayer( dfb, DLID_PRIMARY, &layer ));
layer->GetConfiguration (layer, &layer_config);
/* get the primary surface, i.e. the surface of the primary layer we have
exclusive access to */
memset( &dsc, 0, sizeof(DFBSurfaceDescription) );
dsc.flags =
DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT;
dsc.width = layer_config.width;
dsc.height = layer_config.height;
dsc.caps = DSCAPS_PRIMARY | DSCAPS_SYSTEMONLY /*| DSCAPS_FLIPPING */;
/* FIXME */
dsc.pixelformat = DSPF_RGB16;
DFBCHECK(dfb->CreateSurface(dfb, &dsc, &primary ));
primary->GetSize (primary, &opt.client.width, &opt.client.height);
DFBCHECK(dfb->GetInputDevice( dfb, DIDID_KEYBOARD, &keyboard ));
DFBCHECK(dfb->GetInputDevice( dfb, DIDID_MOUSE, &mouse ));
DFBCHECK (dfb->CreateInputEventBuffer (dfb, DICAPS_ALL, DFB_TRUE, &input_buffer));
}
int dfb_init(int argc, char** argv, unsigned short width, unsigned short height) {
DFBCHECK(DirectFBInit (&argc, &argv));
DFBCHECK(DirectFBCreate (&DFBC_INTERFACE_));
DFBCHECK(DFBC_INTERFACE_->SetCooperativeLevel (DFBC_INTERFACE_, DFSCL_FULLSCREEN));
DFBC_ESCAPECTRL_ = DIKS_UP;
DFBC_SURFACE_DESC_.flags = DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT;
DFBC_SURFACE_DESC_.height = height;
DFBC_SURFACE_DESC_.width = width;
DFBC_SURFACE_DESC_.caps = DSCAPS_PRIMARY | DSCAPS_FLIPPING;
DFBCHECK(DFBC_INTERFACE_->CreateSurface(DFBC_INTERFACE_, &DFBC_SURFACE_DESC_, &DFBC_SURFACE_));
DFBCHECK(DFBC_SURFACE_->GetSize (DFBC_SURFACE_, &DFB_SCREENW, &DFB_SCREENH));
//Hide the cursor
DFBC_INTERFACE_->GetDisplayLayer(DFBC_INTERFACE_, 0x00, &DFBC_LAYER_);
DFBC_LAYER_->SetCooperativeLevel(DFBC_LAYER_, DLSCL_ADMINISTRATIVE);
DFBC_LAYER_->SetCursorOpacity(DFBC_LAYER_, 0);
/*
* TO-DO
* Return code
*/
return 0;
}
int
main( int argc, char** argv )
{
IDirectFB *dfb = NULL;
ISaWMan *saw = NULL;
ISaWManManager *manager = NULL;
D_INFO( "SaWMan/Sample1: Initializing...\n" );
CHECK( DirectFBInit( &argc, &argv ) );
CHECK( DirectFBCreate( &dfb ) );
CHECK( SaWManCreate( &saw ) );
CHECK( saw->CreateManager( saw, &callbacks, NULL, &manager ) );
pause();
out:
D_INFO( "SaWMan/Sample1: Shutting down...\n" );
if (manager)
manager->Release( manager );
if (saw)
saw->Release( saw );
if (dfb)
dfb->Release( dfb );
return 0;
}
int directfb_init(int argc, char *argv[])
{
DFBSurfaceDescription dsc;
DFBFontDescription font_dsc;
DFBCHECK (DirectFBInit (&argc, &argv));
DFBCHECK (DirectFBCreate (&dfb));
DFBCHECK (dfb->SetCooperativeLevel (dfb, DFSCL_NORMAL));
dsc.flags = DSDESC_CAPS | DSDESC_PIXELFORMAT;
dsc.caps = DSCAPS_PRIMARY | DSCAPS_INTERLACED | DSCAPS_FLIPPING;
dsc.pixelformat = DSPF_YUY2;
DFBCHECK (dfb->CreateSurface( dfb, &dsc, &primary ));
DFBCHECK (primary->GetSize (primary, &screen_width, &screen_height));
font_dsc.flags = DFDESC_HEIGHT;
font_dsc.height = 48;
DFBCHECK (dfb->CreateFont (dfb, "Vera.ttf", &font_dsc, &font));
DFBCHECK (primary->SetFont(primary, font));
/* Blank screen */
DFBCHECK (primary->SetColor (primary, 0x0, 0x0, 0x0, 0xFF));
DFBCHECK (primary->FillRectangle (primary, 0, 0, screen_width, screen_height));
/* Print text */
DFBCHECK (primary->SetColor (primary, 0x80, 0x0, 0x20, 0xFF));
DFBCHECK (primary->DrawString (primary, title, -1, 10, screen_height-100, DSTF_LEFT));
/* Flip the front and back buffer, but wait for the vertical retrace to avoid tearing. */
DFBCHECK (primary->Flip (primary, NULL, DSFLIP_WAITFORSYNC));
font->Release (font);
return 23;
}
// Prepare things before the very first graphic rendering
Boolean v4pDisplayInit(int quality, Boolean fullscreen) {
int rc = success;
/* Get screen size from display structure macro */
int wantedWidth = defaultScreenWidth * 2 / (3 - quality);
int wantedHeight = defaultScreenHeight * 2 / (3 - quality);
int argc = 0;
char *argv[] = {"directFB"};
DirectFBInit(&argc, &argv);
DirectFBCreate(&dfb);
if (fullscreen) {
dfb->SetCooperativeLevel (dfb, DFSCL_FULLSCREEN);
}
DFBSurfaceDescription dsc;
/* dsc.flags = DSDESC_CAPS|DSDESC_WIDTH|DSDESC_HEIGHT; */
dsc.flags = DSDESC_CAPS;
dsc.caps = DSCAPS_PRIMARY /* | DSCAPS_FLIPPING */;
dsc.width = wantedWidth;
dsc.height = wantedHeight;
dfb->CreateSurface( dfb, &dsc, &v4pDisplayDefaultContextS.surface);
v4pDisplayDefaultContextS.surface->GetSize (
v4pDisplayDefaultContextS.surface,
&v4pDisplayDefaultContextS.width,
&v4pDisplayDefaultContextS.height);
v4pDisplaySetContext(v4pDisplayDefaultContext);
return rc;
}
DirectFBFrame *createWindowFrame(const char *inTitle, int inWidth, int inHeight, unsigned int inFlags)
{
putenv ((char*)"DFBARGS=system=x11");
DirectFBInit(0, NULL);
DirectFBCreate(&dfb);
bool fullscreen = (inFlags & wfFullScreen) != 0;
if (fullscreen)
{
dfb->SetCooperativeLevel(dfb, DFSCL_FULLSCREEN);
}
else
{
//dfb->SetCooperativeLevel(dfb, DFSCL_NORMAL);
dfb->SetCooperativeLevel(dfb, DFSCL_FULLSCREEN);
}
dfb->SetVideoMode(dfb, inWidth, inHeight, 32);
dfb->CreateInputEventBuffer(dfb, (DFBInputDeviceCapabilities)(DICAPS_KEYS | DICAPS_BUTTONS), DFB_FALSE, &sgEventBuffer);
DFBSurfaceDescription dsc;
dsc.flags = DSDESC_CAPS;
dsc.caps = (DFBSurfaceCapabilities)(DSCAPS_PRIMARY | DSCAPS_FLIPPING);
dsc.width = inWidth;
dsc.height = inHeight;
IDirectFBSurface *surface = NULL;
dfb->CreateSurface(dfb, &dsc, &surface);
return new DirectFBFrame(surface, inWidth, inHeight);
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
IDirectFB *dfb;
/* Initialize DirectFB. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "DFBTest/Init: DirectFBInit() failed!\n" );
return ret;
}
/* Create super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
D_DERROR( ret, "DFBTest/Init: DirectFBCreate() failed!\n" );
return ret;
}
/* Shutdown DirectFB. */
ret = dfb->Release( dfb );
if (ret) {
D_DERROR( ret, "DFBTest/Init: IDirectFB::Release() failed!\n" );
return ret;
}
return 0;
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
int i;
VoodooPlayInfo info;
VoodooPlayer *player = NULL;
/* Initialize DirectFB including command line parsing. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
DirectFBError( "DirectFBInit() failed", ret );
return -1;
}
/* Parse the command line. */
if (!parse_command_line( argc, argv ))
return -2;
if (m_name) {
direct_snputs( info.name, m_name, VOODOO_PLAYER_NAME_LENGTH );
}
ret = voodoo_player_create( m_name ? &info : NULL, &player );
if (ret) {
D_ERROR( "Voodoo/Play: Could not create the player (%s)!\n", DirectFBErrorString(ret) );
goto out;
}
do {
voodoo_player_broadcast( player );
direct_thread_sleep( 100000 );
voodoo_player_enumerate( player, player_callback, NULL );
if (m_lookup) {
for (i=1; i<argc; i++) {
char buf[100];
if (voodoo_player_lookup( player, (const u8 *)argv[i], NULL, buf, sizeof(buf) )) {
D_ERROR( "Voodoo/Play: No '%s' found!\n", argv[i] );
continue;
}
D_INFO( "Voodoo/Play: Found '%s' with address %s\n", argv[i], buf );
}
}
direct_thread_sleep( 2000000 );
} while (m_run);
out:
if (player)
voodoo_player_destroy( player );
return ret;
}
g_error directfb_init(void) {
DFBResult err;
DFBSurfaceDescription dsc;
err = DirectFBInit(NULL, NULL); /* no argc/argv */
dfb_errcheck_die;
err = DirectFBCreate (&directfb);
dfb_errcheck_die;
//directfb->SetCooperativeLevel (directfb, DFSCL_FULLSCREEN);
dsc.flags = DSDESC_CAPS;
dsc.caps = DSCAPS_PRIMARY | DSCAPS_FLIPPING;
err = directfb->CreateSurface(directfb, &dsc, &primary);
dfb_errcheck_die;
err = primary->GetSize (primary, &vid->xres, &vid->yres);
dfb_errcheck_die;
vid->display = NULL;
// FIXME
if (!vid->bpp) vid->bpp = 32;
#ifdef DRIVER_DIRECTFBINPUT
/* Load a main input driver */
return load_inlib(&directfbinput_regfunc,&inlib_main);
#else
return success;
#endif
}
int testing_multicore() {
IDirectFB *dfb = NULL;
IDirectFBSurface *surface = NULL;
DFBSurfaceDescription dsc;
pid_t n_pid = fork();
if (n_pid) {
sleep(1);
}
DFBCHECK(DirectFBInit(NULL, NULL));
DFBCHECK(DirectFBCreate(&dfb));
push_release(dfb, dfb->Release);
DFBCHECK(dfb->SetCooperativeLevel (dfb, DFSCL_FULLSCREEN));
dsc.flags = DSDESC_CAPS;
dsc.caps = DSCAPS_PRIMARY | DSCAPS_FLIPPING;
DFBCHECK (dfb->CreateSurface( dfb, &dsc, &surface ));
push_release(surface, surface->Release);
if (!n_pid) {
sleep(1);
}
sleep(2);
//DFBCHECK(surface->Release(surface));
//DFBCHECK(dfb->Release(dfb));
release_all();
if (n_pid) {
wait(NULL);
}
return 0;
}
int main(int, char **)
{
DFBResult result = DFB_OK;
result = DirectFBInit(0, 0);
return (result == DFB_OK);
}
int get_display_layer_window() {
IDirectFB *dfb = NULL;
IDirectFBDisplayLayer *layer = NULL;
IDirectFBWindow *window = NULL;
DFBWindowDescription desc;
DFBCHECK(DirectFBInit(NULL, NULL));
DFBCHECK(DirectFBCreate(&dfb));
push_release(dfb,dfb->Release);
DFBCHECK(dfb->GetDisplayLayer(dfb, DLID_PRIMARY, &layer));
push_release(layer, layer->Release);
desc.flags = DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_POSX | DWDESC_POSY;
desc.posx = desc.posy = desc.width = desc.height = 20;
DFBCHECK(layer->CreateWindow(layer, &desc, &window));
push_release(window, window->Release);
/* check window */
release_all();
return 0;
}
QDirectFbIntegration::QDirectFbIntegration()
: mFontDb(new QGenericUnixFontDatabase())
{
const QStringList args = QCoreApplication::arguments();
int argc = args.size();
char **argv = new char*[argc];
for (int i = 0; i < argc; ++i)
argv[i] = qstrdup(args.at(i).toLocal8Bit().constData());
DFBResult result = DirectFBInit(&argc, &argv);
if (result != DFB_OK) {
DirectFBError("QDirectFBScreen: error initializing DirectFB",
result);
}
delete[] argv;
QDirectFbScreen *primaryScreen = new QDirectFbScreen(0);
mScreens.append(primaryScreen);
mInputRunner = new QThread;
mInput = new QDirectFbInput(0);
mInput->moveToThread(mInputRunner);
QObject::connect(mInputRunner,SIGNAL(started()),mInput,SLOT(runInputEventLoop()));
mInputRunner->start();
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
IDirectFB *dfb;
/* Initialize DirectFB. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "DFBTest/Resize: DirectFBInit() failed!\n" );
return ret;
}
/* Create super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
D_DERROR( ret, "DFBTest/Resize: DirectFBCreate() failed!\n" );
return ret;
}
/* Required for keyboard access */
dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN );
TestResize( dfb );
/* Shutdown DirectFB. */
dfb->Release( dfb );
return ret;
}
/** Opens application window and return pointer to offscreen buffer for */
char *directfbapp_open_window() {
DFBWindowDescription wdesc;
DFBDisplayLayerConfig lconfig;
static char *argv_array[] = {
"CVM",
"--dfb:system=FBDev"
",force-windowed" /* use windows instead of surfaces */
",no-vt-switch" /* do not switch between Linux' VT */
",no-cursor" /* do not use pointer */
// ",no-deinit-check" /* do not check for deinit */
,NULL
};
int argc = sizeof argv_array / sizeof argv_array[0] - 1;
char **argv = argv_array;
IDirectFBDisplayLayer *dlayer;
char *dst;
int pitch;
unsigned int win_id;
int win_x, win_y;
DFBCHECK(DirectFBInit(&argc, &argv));
DFBCHECK(DirectFBCreate(&dfb));
DFBCHECK(dfb->SetCooperativeLevel(dfb, DFSCL_NORMAL));
DFBCHECK(dfb->GetDisplayLayer(dfb, DLID_PRIMARY, &dlayer));
DFBCHECK(dlayer->GetConfiguration(dlayer, &lconfig));
wdesc.caps = DWCAPS_DOUBLEBUFFER;
wdesc.surface_caps = DSCAPS_DOUBLE;
wdesc.pixelformat = DSPF_RGB16;
wdesc.width = CHAM_WIDTH;
wdesc.height = CHAM_HEIGHT;
wdesc.flags = DWDESC_CAPS | DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_PIXELFORMAT |
DWDESC_SURFACE_CAPS;
DFBCHECK(dlayer->CreateWindow(dlayer, &wdesc, &window));
releaseInterface(dlayer);
if ((lconfig.flags & (DLCONF_WIDTH | DLCONF_HEIGHT)) == (DLCONF_WIDTH | DLCONF_HEIGHT)) {
DFBCHECK(window->GetID(window, &win_id));
set_win_position(win_id, lconfig.width, lconfig.height, win_x, win_y);
DFBCHECK(window->MoveTo(window, win_x, win_y));
}
DFBCHECK(window->RaiseToTop(window));
DFBCHECK(window->SetOpacity(window, 0xff));
DFBCHECK(window->RequestFocus(window));
DFBCHECK(window->GetSurface(window, &screen));
DFBCHECK(screen->GetSize(screen, &screen_width, &screen_height));
DFBCHECK(screen->Lock(screen, DSLF_WRITE, (void**)(void*)&dst, &pitch));
if (pitch != (int)sizeof(gxj_pixel_type) * screen_width) {
REPORT_ERROR(LC_LOWUI,
"Invalid pixel format: Supports only 16-bit, 5:6:5 display");
goto dfb_err;
}
return dst;
dfb_err:;
directfbapp_finalize();
exit(1); /* TODO: exit from Java */
/* return NULL; */
}
int main(int argc, char* argv[])
{
int status;
pthread_t thread;
freerdp* instance;
dfContext* context;
rdpChannels* channels;
struct thread_data* data;
setlocale(LC_ALL, "");
freerdp_channels_global_init();
g_sem = CreateSemaphore(NULL, 0, 1, NULL);
instance = freerdp_new();
instance->PreConnect = df_pre_connect;
instance->PostConnect = df_post_connect;
instance->VerifyCertificate = df_verify_certificate;
instance->ReceiveChannelData = df_receive_channel_data;
instance->ContextSize = sizeof(dfContext);
instance->ContextNew = df_context_new;
instance->ContextFree = df_context_free;
freerdp_context_new(instance);
context = (dfContext*) instance->context;
channels = instance->context->channels;
DirectFBInit(&argc, &argv);
instance->context->argc = argc;
instance->context->argv = argv;
status = freerdp_client_parse_command_line_arguments(argc, argv, instance->settings);
if (status < 0)
exit(0);
freerdp_client_load_addins(instance->context->channels, instance->settings);
data = (struct thread_data*) malloc(sizeof(struct thread_data));
ZeroMemory(data, sizeof(sizeof(struct thread_data)));
data->instance = instance;
g_thread_count++;
pthread_create(&thread, 0, thread_func, data);
while (g_thread_count > 0)
{
WaitForSingleObject(g_sem, INFINITE);
}
freerdp_channels_global_uninit();
return 0;
}
int init_n_close() {
IDirectFB *dfb = NULL;
DFBCHECK(DirectFBInit(NULL, NULL));
DFBCHECK(DirectFBCreate(&dfb));
push_release(dfb, dfb->Release);
release_all();
return 0;
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
int i;
IDirectFB *dfb;
DFBInputDeviceID device_id = 0;
/* Initialize DirectFB. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "DFBTest/Input: DirectFBInit() failed!\n" );
return ret;
}
/* Parse arguments. */
for (i=1; i<argc; i++) {
const char *arg = argv[i];
if (strcmp( arg, "-h" ) == 0 || strcmp (arg, "--help") == 0)
return print_usage( argv[0] );
else if (strcmp (arg, "-v") == 0 || strcmp (arg, "--version") == 0) {
fprintf (stderr, "dfbtest_input version %s\n", DIRECTFB_VERSION);
return false;
}
else if (strcmp (arg, "-d") == 0 || strcmp (arg, "--device") == 0) {
if (++i == argc) {
print_usage (argv[0]);
return false;
}
if (!parse_id( argv[i], &device_id ))
return false;
}
else
return print_usage( argv[0] );
}
/* Create super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
D_DERROR( ret, "DFBTest/Input: DirectFBCreate() failed!\n" );
return ret;
}
Test_Sensitivity( dfb, device_id );
/* Shutdown DirectFB. */
ret = dfb->Release( dfb );
if (ret) {
D_DERROR( ret, "DFBTest/Input: IDirectFB::Release() failed!\n" );
return ret;
}
return 0;
}
int
main( int argc, char *argv[] )
{
int i;
DFBResult ret;
IDirectFB *dfb;
IDirectFBDisplayLayer *layer = NULL;
App apps[1];
DFBDisplayLayerConfig config;
/* Parse arguments. */
for (i=1; i<argc; i++) {
if (!strcmp( argv[i], "-h" ))
return show_usage( argv[0] );
}
/* Initialize DirectFB. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "DFBTest/WindowFlip: DirectFBInit() failed!\n" );
return ret;
}
/* Create super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
D_DERROR( ret, "DFBTest/WindowFlip: DirectFBCreate() failed!\n" );
return ret;
}
/* Get primary layer. */
ret = dfb->GetDisplayLayer( dfb, DLID_PRIMARY, &layer );
if (ret) {
D_DERROR( ret, "DFBTest/WindowFlip: IDirectFB::GetDisplayLayer( PRIMARY ) failed!\n" );
goto out;
}
layer->GetConfiguration( layer, &config );
app_init( &apps[0], layer, 100, 50, config.width-300, config.height-150, 0 );
while (true) {
direct_thread_sleep( 1000000 );
app_update( &apps[0] );
}
out:
/* Shutdown DirectFB. */
dfb->Release( dfb );
return ret;
}
void Renderer::initialize(int argc, char **argv, NMTSettings * nmtSettings)
{
if (DirectFBInit(&argc, &argv) != DFB_OK) {
fprintf(stderr, "Error in DirectFBInit!\n");
}
else {
BOOST_ASSERT(nmtSettings != NULL);
m_videoMode = nmtSettings->getVideoMode();
init();
}
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
Reaction reaction;
/* Initialize DirectFB including command line parsing. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
DirectFBError( "DirectFBInit() failed", ret );
return -1;
}
/* Parse the command line. */
if (!parse_command_line( argc, argv ))
return -2;
/* Create the super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
DirectFBError( "DirectFBCreate() failed", ret );
return -3;
}
if (!unique_wm_running()) {
D_ERROR( "UniQuE/Test: This session doesn't run UniQuE!\n" );
dfb->Release( dfb );
return EXIT_FAILURE;
}
unique_wm_enum_contexts( context_callback, NULL );
if (!context) {
D_ERROR( "UniQuE/Test: No context available!\n" );
dfb->Release( dfb );
return EXIT_FAILURE;
}
unique_input_channel_attach( context->foo_channel, foo_channel_listener, context, &reaction );
pause();
unique_input_channel_detach( context->foo_channel, &reaction );
unique_context_unref( context );
/* Release the super interface. */
dfb->Release( dfb );
return EXIT_SUCCESS;
}
bool wxApp::Initialize(int& argc, wxChar **argv)
{
if ( !wxAppBase::Initialize(argc, argv) )
return false;
if ( !wxDfbCheckReturn(DirectFBInit(&argc, &argv)) )
return false;
if ( !wxIDirectFB::Get() )
return false;
return true;
}
int
main( int argc, char *argv[] )
{
DirectResult ret;
/* Initialize DirectFB. */
ret = DirectFBInit( &argc, &argv );
if (ret)
return DirectFBError( "DirectFBInit()", ret );
dfb_system_lookup();
ret = fusion_enter( -1, 0, FER_MASTER, &world );
if (ret)
return DirectFBError( "fusion_enter()", ret );
printf( "\n" );
#if FUSION_BUILD_MULTI
printf( "Fusion Benchmark (Multi Application Core)\n" );
#else
printf( "Fusion Benchmark (Single Application Core)\n" );
#endif
printf( "\n" );
bench_flock();
bench_mutex();
bench_mutex_threaded();
bench_skirmish();
bench_skirmish_threaded();
//bench_spinlock_threaded();
bench_property();
bench_ref();
bench_reactor();
bench_shmpool( false );
bench_shmpool( true );
printf( "\n" );
fusion_exit( world, false );
return 0;
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
/* Initialize DirectFB including command line parsing. */
ret = DirectFBInit( &argc, &argv );
if (ret) {
DirectFBError( "DirectFBInit() failed", ret );
return -1;
}
/* Parse the command line. */
if (!parse_command_line( argc, argv ))
return -2;
/* Create the super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
DirectFBError( "DirectFBCreate() failed", ret );
return -3;
}
if (!prophecy_wm_running()) {
D_ERROR( "Prophecy/Test: This session doesn't run Prophecy!\n" );
dfb->Release( dfb );
return EXIT_FAILURE;
}
prophecy_wm_enum_contexts( context_callback, NULL );
if (!context) {
D_ERROR( "Prophecy/Test: No context available!\n" );
dfb->Release( dfb );
return EXIT_FAILURE;
}
/* Set the background according to the users wishes. */
if (color)
set_color();
prophecy_context_unref( context );
/* Release the super interface. */
dfb->Release( dfb );
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
pthread_t thread;
freerdp* instance;
dfContext* context;
rdpChannels* channels;
struct thread_data* data;
setlocale(LC_ALL, "");
freerdp_channels_global_init();
g_sem = freerdp_sem_new(1);
instance = freerdp_new();
instance->PreConnect = df_pre_connect;
instance->PostConnect = df_post_connect;
instance->VerifyCertificate = df_verify_certificate;
instance->ReceiveChannelData = df_receive_channel_data;
instance->context_size = sizeof(dfContext);
instance->ContextNew = df_context_new;
instance->ContextFree = df_context_free;
freerdp_context_new(instance);
context = (dfContext*) instance->context;
channels = instance->context->channels;
DirectFBInit(&argc, &argv);
freerdp_parse_args(instance->settings, argc, argv, df_process_plugin_args, channels, NULL, NULL);
data = (struct thread_data*) xzalloc(sizeof(struct thread_data));
data->instance = instance;
g_thread_count++;
pthread_create(&thread, 0, thread_func, data);
while (g_thread_count > 0)
{
freerdp_sem_wait(g_sem);
}
freerdp_channels_global_uninit();
return 0;
}
int get_display_layer() {
IDirectFB *dfb = NULL;
IDirectFBDisplayLayer *layer = NULL;
DFBCHECK(DirectFBInit(NULL, NULL));
DFBCHECK(DirectFBCreate(&dfb));
push_release(dfb, dfb->Release);
DFBCHECK(dfb->GetDisplayLayer(dfb, DLID_PRIMARY, &layer));
push_release(layer, layer->Release);
release_all();
return 0;
}
int open_display(int w, int h)
{
DirectFBInit(NULL, NULL);
DirectFBCreate( &dfb );
width = w;
height = h;
dfb->SetCooperativeLevel(dfb, DFSCL_EXCLUSIVE);
dfb->GetDisplayLayer(dfb, DLID_PRIMARY, &layer);
layer->GetSurface(layer, &surface);
return 0;
}
Eina_Bool
engine_directfb_args(const char *engine, int width, int height)
{
Evas_Engine_Info_DirectFB *einfo;
DFBWindowDescription desc;
int i;
evas_output_method_set(evas, evas_render_method_lookup("directfb"));
einfo = (Evas_Engine_Info_DirectFB *)evas_engine_info_get(evas);
if (!einfo)
{
printf("Evas does not support the DirectFB Engine\n");
return EINA_FALSE;
}
DFBCHECK(DirectFBInit(NULL, NULL));
DFBCHECK(DirectFBCreate(&_dfb));
DFBCHECK(_dfb->GetDisplayLayer(_dfb, DLID_PRIMARY, &_layer));
DFBCHECK(_dfb->CreateEventBuffer(_dfb, &_window_event));
DFBCHECK(_dfb->CreateInputEventBuffer(_dfb, DICAPS_ALL, DFB_FALSE, &_input_event));
memset(&desc, 0, sizeof(DFBWindowDescription));
desc.flags = (DWDESC_POSX | DWDESC_POSY | DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_PIXELFORMAT);
desc.posx = 0;
desc.posy = 0;
desc.width = width;
desc.height = height;
desc.pixelformat = DSPF_ARGB;
DFBCHECK(_layer->CreateWindow(_layer, &desc, &_dfb_window));
DFBCHECK(_dfb_window->AttachEventBuffer(_dfb_window, _window_event));
DFBCHECK(_dfb_window->SetOptions(_dfb_window, DWOP_NONE));
DFBCHECK(_dfb_window->SetOpacity(_dfb_window, 0xFF));
DFBCHECK(_dfb_window->GetSurface(_dfb_window, &_dfb_surface));
DFBCHECK(_dfb_surface->SetPorterDuff(_dfb_surface, DSPD_SRC_OVER));
einfo->info.dfb = _dfb;
einfo->info.surface = _dfb_surface;
if (!evas_engine_info_set(evas, (Evas_Engine_Info *) einfo))
{
printf("Evas can not setup the informations of the DirectFB Engine\n");
return EINA_FALSE;
}
return EINA_TRUE;
}
static void
init_application( int *argc, char **argv[] )
{
DFBResult ret;
DFBSurfaceDescription desc;
/* Initialize DirectFB including command line parsing. */
ret = DirectFBInit( argc, argv );
if (ret) {
DirectFBError( "DirectFBInit() failed", ret );
exit_application( 1 );
}
/* Create the super interface. */
ret = DirectFBCreate( &dfb );
if (ret) {
DirectFBError( "DirectFBCreate() failed", ret );
exit_application( 2 );
}
/* Request fullscreen mode. */
dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN );
/* Fill the surface description. */
desc.flags = DSDESC_CAPS | DSDESC_PIXELFORMAT;
desc.caps = DSCAPS_PRIMARY | DSCAPS_DOUBLE;
desc.pixelformat = DSPF_ARGB;
/* Create an 8 bit palette surface. */
ret = dfb->CreateSurface( dfb, &desc, &primary );
if (ret) {
DirectFBError( "IDirectFB::CreateSurface() failed", ret );
exit_application( 3 );
}
/* Create an event buffer with key capable devices attached. */
ret = dfb->CreateInputEventBuffer( dfb, DICAPS_KEYS, DFB_FALSE, &events );
if (ret) {
DirectFBError( "IDirectFB::CreateEventBuffer() failed", ret );
exit_application( 4 );
}
/* Clear with black. */
primary->Clear( primary, 0x00, 0x00, 0x00, 0xff );
primary->Flip( primary, NULL, 0 );
}
int
main( int argc, char *argv[] )
{
DFBResult ret;
Inspector inspector;
ret = DirectFBInit( &argc, &argv );
if (ret) {
D_DERROR( ret, "Inspector/Init: DirectFBInit() failed!\n" );
return ret;
}
ret = Inspector_Init( &inspector, argc, argv );
if (ret)
return ret;
return Inspector_Run( &inspector );
}
