int main( int argc, char *argv[] ) { DFBResult ret; bool quit = false; int i; IDirectFB dfb; IDirectFBDisplayLayer layer; IDirectFBSurface surface; DFBDisplayLayerConfig config; DFBDimension sizes[2] = { {400, 400}, {600, 600} }; size_t num_sizes = D_ARRAY_SIZE(sizes); DFBInputEvent evt; IDirectFBEventBuffer keybuffer; /* Initialize DirectFB. */ DirectFB::Init( &argc, &argv ); /* Create super interface. */ dfb = DirectFB::Create(); layer = dfb.GetDisplayLayer( DLID_PRIMARY ); /* Create an input buffer for key events */ keybuffer = dfb.CreateInputEventBuffer( DICAPS_KEYS, DFB_TRUE ); layer.SetCooperativeLevel( DLSCL_EXCLUSIVE ); layer.GetConfiguration( &config ); config.width = sizes[0].w; config.height = sizes[0].h; layer.SetConfiguration( config ); surface = layer.GetSurface(); while (true) { surface.Clear( 0, 0, 0, 0xff ); surface.SetColor( 0x00, 0xff, 0x00, 0xff ); surface.DrawRectangle( 0, 0, config.width, config.height ); surface.Flip( NULL, DSFLIP_NONE ); keybuffer.WaitForEventWithTimeout( 3, 0 ); /* Process keybuffer */ while (keybuffer.GetEvent( DFB_EVENT(&evt) )) { if (evt.type == DIET_KEYPRESS) { switch (DFB_LOWER_CASE(evt.key_symbol)) { case DIKS_ESCAPE: case DIKS_SMALL_Q: case DIKS_BACK: case DIKS_STOP: case DIKS_EXIT: /* Quit main loop & test thread */ quit = 1; break; case DIKS_SPACE: case DIKS_OK: i++; config.width = sizes[i % num_sizes].w; config.height = sizes[i % num_sizes].h; layer.SetConfiguration( config ); break; default: break; } } } } return 0; }
static void TestResize( IDirectFB *dfb ) { DFBResult ret; DirectThread *thread; DFBWindowDescription desc; IDirectFBDisplayLayer *layer; IDirectFBWindow *window; IDirectFBSurface *surface; DFBInputEvent evt; IDirectFBEventBuffer *keybuffer; quit = 0; /* Create an input buffer for key events */ ret = dfb->CreateInputEventBuffer( dfb, DICAPS_KEYS, DFB_FALSE, &keybuffer); if (ret) { D_DERROR( ret, "DFBTest/Resize: CreateInputBuffer() failed!\n" ); return; } ret = dfb->GetDisplayLayer( dfb, DLID_PRIMARY, &layer ); if (ret) { D_DERROR( ret, "DFBTest/Resize: Failed to get display layer!\n" ); keybuffer->Release( keybuffer ); return; } desc.flags = DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_PIXELFORMAT; desc.width = 500; desc.height = 500; desc.pixelformat = DSPF_ARGB; ret = layer->CreateWindow( layer, &desc, &window ); if (ret) { D_DERROR( ret, "DFBTest/Resize: CreateWindow() failed!\n" ); keybuffer->Release( keybuffer ); layer->Release( layer ); return; } ret = window->GetSurface( window, &surface ); if (ret) { D_DERROR( ret, "DFBTest/Resize: GetSurface() failed!\n" ); keybuffer->Release( keybuffer ); window->Release( window ); layer->Release( layer ); return; } thread = direct_thread_create( DTT_DEFAULT, TestThread, surface, "Test" ); while (!quit) { ret = window->Resize( window, 500, 400 ); if (ret) D_DERROR( ret, "DFBTest/Resize: Resize() failed!\n" ); ret = window->Resize( window, 500, 500 ); if (ret) D_DERROR( ret, "DFBTest/Resize: Resize() failed!\n" ); /* Process keybuffer */ while (keybuffer->GetEvent( keybuffer, DFB_EVENT(&evt)) == DFB_OK) { if (evt.type == DIET_KEYPRESS) { switch (DFB_LOWER_CASE(evt.key_symbol)) { case DIKS_ESCAPE: case DIKS_SMALL_Q: case DIKS_BACK: case DIKS_STOP: case DIKS_EXIT: /* Quit main loop & test thread */ quit = 1; direct_thread_join(thread); break; default: break; } } } } keybuffer->Release( keybuffer ); surface->Release( surface ); window->Release( window ); layer->Release( layer ); }
static ReactionResult stack_inputdevice_react( const void *msg_data, void *ctx ) { const DFBInputEvent *evt = (DFBInputEvent*)msg_data; DFBWindowEvent we; CoreWindow *window = NULL; CoreWindowStack *stack = (CoreWindowStack*)ctx; DisplayLayer *layer = dfb_layer_at( stack->layer_id ); /* FIXME: this is a bad check for exclusive access */ if (dfb_layer_lease( layer ) ) return RS_OK; dfb_layer_release( layer, false ); if (stack->wm_hack) { switch (evt->type) { case DIET_KEYRELEASE: switch (evt->key_symbol) { case DIKS_CAPS_LOCK: stack->wm_hack = 0; stack_lock( stack ); handle_enter_leave_focus( stack ); stack_unlock( stack ); break; case DIKS_CONTROL: stack->wm_hack = 1; return RS_OK; default: ; } break; case DIET_KEYPRESS: switch (DFB_LOWER_CASE(evt->key_symbol)) { case DIKS_CONTROL: stack->wm_hack = 2; return RS_OK; case DIKS_SMALL_C: if (stack->entered_window) { DFBWindowEvent evt; evt.type = DWET_CLOSE; dfb_window_dispatch( stack->entered_window, &evt ); } return RS_OK; case DIKS_SMALL_D: { CoreWindow *window = stack->entered_window; if (window && !(window->options & DWOP_INDESTRUCTIBLE)) { dfb_window_deinit( window ); dfb_window_destroy( window, true ); } return RS_OK; } default: ; } break; case DIET_BUTTONRELEASE: return RS_OK; case DIET_BUTTONPRESS: if (stack->entered_window && !(stack->entered_window->options & DWOP_KEEP_STACKING)) dfb_window_raisetotop( stack->entered_window ); return RS_OK; default: ; } } switch (evt->type) { case DIET_KEYPRESS: if (evt->key_id == DIKI_CAPS_LOCK) stack->wm_hack = 1; /* fall through */ case DIET_KEYRELEASE: stack_lock( stack ); window = (stack->keyboard_window ? stack->keyboard_window : stack->focused_window); if (window) { we.type = (evt->type == DIET_KEYPRESS) ? DWET_KEYDOWN : DWET_KEYUP; we.key_code = evt->key_code; we.key_id = evt->key_id; we.key_symbol = evt->key_symbol; we.modifiers = evt->modifiers; /* FIXME: handle mult. devices */ we.locks = evt->locks; /* FIXME: handle mult. devices */ dfb_window_dispatch( window, &we ); } stack_unlock( stack ); break; case DIET_BUTTONPRESS: case DIET_BUTTONRELEASE: if (!stack->cursor.enabled) break; stack_lock( stack ); window = (stack->pointer_window ? stack->pointer_window : stack->entered_window); if (window) { we.type = (evt->type == DIET_BUTTONPRESS) ? DWET_BUTTONDOWN : DWET_BUTTONUP; we.button = evt->button; we.buttons = evt->buttons; /* FIXME: handle mult. devices */ we.cx = stack->cursor.x; we.cy = stack->cursor.y; we.x = we.cx - window->x; we.y = we.cy - window->y; dfb_window_dispatch( window, &we ); } stack_unlock( stack ); break; case DIET_AXISMOTION: if (evt->flags & DIEF_AXISREL) { int rel = evt->axisrel; /* handle cursor acceleration */ if (rel > stack->cursor.threshold) rel += (rel - stack->cursor.threshold) * stack->cursor.numerator / stack->cursor.denominator; else if (rel < -stack->cursor.threshold) rel += (rel + stack->cursor.threshold) * stack->cursor.numerator / stack->cursor.denominator; switch (evt->axis) { case DIAI_X: dfb_windowstack_handle_motion( stack, rel, 0 ); break; case DIAI_Y: dfb_windowstack_handle_motion( stack, 0, rel ); break; case DIAI_Z: handle_wheel( stack, - evt->axisrel ); break; default: return RS_OK; } } else if (evt->flags & DIEF_AXISABS) { switch (evt->axis) { case DIAI_X: dfb_windowstack_handle_motion( stack, evt->axisabs - stack->cursor.x, 0 ); break; case DIAI_Y: dfb_windowstack_handle_motion( stack, 0, evt->axisabs - stack->cursor.y); break; default: return RS_OK; } } break; default: break; } return RS_OK; }
int main( int argc, char *argv[] ) { DFBResult ret; int i; DFBSurfaceDescription desc; IDirectFB *dfb; IDirectFBSurface *dest = NULL; DFBSurfacePixelFormat dest_format = DSPF_UNKNOWN; char pixel_buffer[100*100*4]; IDirectFBSurface *source = NULL; IDirectFBEventBuffer *keybuffer; DFBInputEvent evt; bool quit = false; /* Initialize DirectFB. */ ret = DirectFBInit( &argc, &argv ); if (ret) { D_DERROR( ret, "DFBTest/PreAlloc: 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_blit version %s\n", DIRECTFB_VERSION); return false; } else if (strcmp (arg, "-d") == 0 || strcmp (arg, "--dest") == 0) { if (++i == argc) { print_usage (argv[0]); return false; } if (!parse_format( argv[i], &dest_format )) return false; } else if (strcmp (arg, "-s") == 0 || strcmp (arg, "--static") == 0) { static_caps = DSCAPS_STATIC_ALLOC; } else return print_usage( argv[0] ); } /* Create super interface. */ ret = DirectFBCreate( &dfb ); if (ret) { D_DERROR( ret, "DFBTest/PreAlloc: DirectFBCreate() failed!\n" ); return ret; } /* Fill description for a primary surface. */ desc.flags = DSDESC_CAPS; desc.caps = DSCAPS_PRIMARY | DSCAPS_FLIPPING; if (dest_format != DSPF_UNKNOWN) { desc.flags |= DSDESC_PIXELFORMAT; desc.pixelformat = dest_format; } dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN ); /* Create an input buffer for key events */ dfb->CreateInputEventBuffer( dfb, DICAPS_KEYS, DFB_TRUE, &keybuffer); /* Create a primary surface. */ ret = dfb->CreateSurface( dfb, &desc, &dest ); if (ret) { D_DERROR( ret, "DFBTest/PreAlloc: IDirectFB::CreateSurface() for the destination failed!\n" ); goto out; } dest->GetSize( dest, &desc.width, &desc.height ); dest->GetPixelFormat( dest, &desc.pixelformat ); D_INFO( "DFBTest/PreAlloc: Destination is %dx%d using %s\n", desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) ); /* Create a preallocated surface. */ desc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS | DSDESC_PREALLOCATED; desc.width = 100; desc.height = 100; desc.pixelformat = DSPF_ARGB; desc.caps = static_caps; desc.preallocated[0].data = pixel_buffer; desc.preallocated[0].pitch = 100 * 4; ret = dfb->CreateSurface( dfb, &desc, &source ); if (ret) { D_DERROR( ret, "DFBTest/PreAlloc: IDirectFB::CreateSurface() for the preallocated source failed!\n" ); goto out; } /* Before any other operation the pixel data can be written to without locking */ gen_pixels( pixel_buffer, 100 * 4, 100 ); while (!quit) { void *ptr; int pitch; /* Lock source surface for writing before making updates to the pixel buffer */ source->Lock( source, DSLF_WRITE, &ptr, &pitch ); if (ptr == pixel_buffer) D_INFO( "DFBTest/PreAlloc: Locking preallocated source gave original preallocated pixel buffer :-)\n" ); else { if (static_caps) D_INFO( "DFBTest/PreAlloc: Locking preallocated source gave different pixel buffer, ERROR with static alloc!\n" ); else D_INFO( "DFBTest/PreAlloc: Locking preallocated source gave different pixel buffer, but OK (no static alloc)\n" ); } update_pixels( ptr, pitch, 100 ); /* Unlock source surface after writing, before making further Blits, to have the buffer be transfered to master again */ source->Unlock( source ); dest->Clear( dest, 0, 0, 0, 0xff ); /* First Blit from preallocated source, data will be transfered to master */ dest->Blit( dest, source, NULL, 50, 50 ); /* Second Blit from preallocated source, data is already master */ dest->Blit( dest, source, NULL, 150, 150 ); dest->Flip( dest, NULL, DSFLIP_NONE ); /* This will upload again the preallocated buffer to the master, where it is modified and outdates the preallocated buffer. Now it depends on the static alloc flag whether the next Lock will directly go into the shared memory allocation or the preallocated buffer again (with a transfer back from master to us). */ source->FillRectangle( source, 0, 0, 10, 10 ); /* Process keybuffer */ while (keybuffer->GetEvent( keybuffer, DFB_EVENT(&evt)) == DFB_OK) { if (evt.type == DIET_KEYPRESS) { switch (DFB_LOWER_CASE(evt.key_symbol)) { case DIKS_ESCAPE: case DIKS_SMALL_Q: case DIKS_BACK: case DIKS_STOP: case DIKS_EXIT: /* Quit main loop & test thread */ quit = true; break; default: break; } } } if (!quit) sleep( 5 ); } out: if (source) source->Release( source ); if (dest) dest->Release( dest ); keybuffer->Release( keybuffer ); /* Shutdown DirectFB. */ dfb->Release( dfb ); return ret; }
int main( int argc, char *argv[] ) { DFBResult ret; int i; int x, y; int dx, dy; int sw3, sh3; int opacity = 255; int opacity_delta = -1; IDirectFB *dfb; IDirectFBDisplayLayer *layer; IDirectFBSurface *surface; DFBDisplayLayerConfig config; DFBDimension size; DFBInputEvent evt; /* Initialize DirectFB. */ ret = DirectFBInit( &argc, &argv ); if (ret) { D_DERROR( ret, "DFBTest/Layer: DirectFBInit() failed!\n" ); return ret; } /* Create super interface. */ ret = DirectFBCreate( &dfb ); if (ret) { D_DERROR( ret, "DFBTest/Layer: DirectFBCreate() failed!\n" ); return ret; } dfb->GetDisplayLayer( dfb, DLID_PRIMARY, &layer ); /* Create an input buffer for key events */ dfb->CreateInputEventBuffer( dfb, DICAPS_KEYS, DFB_TRUE, &keybuffer); layer->SetCooperativeLevel( layer, DFSCL_EXCLUSIVE ); layer->GetConfiguration( layer, &config ); config.options = DLOP_OPACITY | DLOP_SRC_COLORKEY; config.buffermode = DLBM_FRONTONLY; layer->SetConfiguration( layer, &config ); layer->SetSrcColorKey( layer, 0x00, 0xff, 0x00 ); ret = layer->GetSurface( layer, &surface ); if (ret) { D_DERROR( ret, "DFBTest/Layer: GetSurface() failed!\n" ); dfb->Release( dfb ); return ret; } surface->GetSize( surface, &size.w, &size.h ); sw3 = ((size.w / 3) + 1) & ~1; sh3 = ((size.h / 3) + 1) & ~1; surface->Clear( surface, 0, 0, 0, 0xff ); for (i=0; i<10; i++) { surface->SetColor( surface, 0xff - i*16, 0xff - i*16, 0xff - i*16, 0xff ); surface->DrawRectangle( surface, i, i, size.w - i*2, size.h - i*2 ); } surface->FillRectangle( surface, 10, size.h/2, size.w - 20, 1 ); surface->FillRectangle( surface, size.w/2, 10, 1, size.h - 20 ); surface->SetColor( surface, 0xff, 0x00, 0x00, 0xff ); surface->FillRectangle( surface, size.w/3, size.h/3, size.w/3, size.h/3 ); surface->SetColor( surface, 0x00, 0xff, 0x00, 0xff ); surface->FillRectangle( surface, size.w/3 + size.w/9, size.h/3 + size.h/9, size.w/9, size.h/9 ); surface->Flip( surface, NULL, DSFLIP_NONE ); #ifdef BUILD_AUTOMATION sleep( 2 ); #else sleep( 12 ); #endif layer->SetSourceRectangle( layer, 0, 0, size.w - sw3, size.h - sh3 ); layer->SetScreenPosition( layer, 100, 100 ); layer->SetScreenRectangle( layer, 100, 100, size.w - sw3, size.h - sh3 ); sleep( 2 ); #ifdef BUILD_AUTOMATION sleep( 20 ); quit = 1; #endif for (x=0, y=0, dx=1, dy=1; !quit ; x+=dx, y+=dy) { layer->SetOpacity( layer, opacity ); if (opacity == 255) opacity_delta = -1; else if (opacity == 0) opacity_delta = 1; opacity += opacity_delta; layer->SetSourceRectangle( layer, x, y, size.w - sw3, size.h - sh3 ); surface->Flip( surface, NULL, DSFLIP_UPDATE ); if (dx > 0) { if (x == size.w/3) { dx = -1; usleep( 500000 ); } } else if (x == 0) { dx = 1; usleep( 500000 ); } if (dy > 0) { if (y == size.h/3) { dy = -1; usleep( 500000 ); } } else if (y == 0) { dy = 1; usleep( 500000 ); } usleep( 10000 ); /* Process keybuffer */ while (keybuffer->GetEvent( keybuffer, DFB_EVENT(&evt)) == DFB_OK) { if (evt.type == DIET_KEYPRESS) { switch (DFB_LOWER_CASE(evt.key_symbol)) { case DIKS_ESCAPE: case DIKS_SMALL_Q: case DIKS_BACK: case DIKS_STOP: case DIKS_EXIT: /* Quit main loop & test thread */ quit = 1; break; default: break; } } } } surface->Release( surface ); layer->Release( layer ); /* Shutdown DirectFB. */ dfb->Release( dfb ); return ret; }