int main(int argc, char** argv) { IDirectFB *dfb = NULL; IDirectFBDisplayLayer *layer = NULL; IDirectFBSurface *surface = NULL; IDirectFBVideoProvider *vp = NULL; CHECK(DirectFBInit (&argc, &argv)); if (argc != 2) { return 1; } CHECK(DirectFBCreate(&dfb)); /* Signals */ signal(SIGINT, signal_handler); signal(SIGTERM, signal_handler); signal(SIGUSR1, signal_handler); signal(SIGUSR2, signal_handler); CHECK(dfb->GetDisplayLayer(dfb, 0, &layer)); CHECK(dfb->CreateVideoProvider(dfb, argv[1], &vp)); CHECK(layer->GetSurface(layer, &surface)); CHECK(vp->PlayTo(vp, surface, NULL, flip, surface)); while(to_exit == 0) { sleep(1); } CHECK(vp->Stop(vp)); CHECK(vp->Release(vp)); CHECK(surface->Release(surface)); CHECK(layer->Release(layer)); CHECK(dfb->Release(dfb)); return 0; }
static int DirectFB_RenderDrawPoints(SDL_Renderer * renderer, const SDL_FPoint * points, int count) { DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata; IDirectFBSurface *destsurf = data->target; DFBRegion clip_region; int i; DirectFB_ActivateRenderer(renderer); PrepareDraw(renderer); destsurf->GetClip(destsurf, &clip_region); for (i=0; i < count; i++) { int x = points[i].x + clip_region.x1; int y = points[i].y + clip_region.y1; SDL_DFB_CHECKERR(destsurf->DrawLine(destsurf, x, y, x, y)); } return 0; error: return -1; }
static void _image_autoset_alpha(DirectFB_Engine_Image_Entry *image) { DFBResult r; DFBSurfacePixelFormat fmt; IDirectFBSurface *surface; RGBA_Image *im; int has_alpha; surface = image->surface; r = surface->GetPixelFormat(surface, &fmt); if (r != DFB_OK) { ERR("Could not get pixel format: %s", DirectFBErrorString(r)); return; } /* XXX: check this in more depth in future, if other PF are supported */ image->cache_entry.src->flags.alpha = (fmt == DSPF_ARGB); }
static int DirectFB_UpdateClipRect(SDL_Renderer * renderer) { const SDL_Rect *rect = &renderer->clip_rect; DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata; IDirectFBSurface *destsurf = get_dfb_surface(data->window); DFBRegion region; if (!SDL_RectEmpty(rect)) { region.x1 = rect->x; region.x2 = rect->x + rect->w; region.y1 = rect->y; region.y2 = rect->y + rect->h; SDL_DFB_CHECKERR(destsurf->SetClip(destsurf, ®ion)); } else { SDL_DFB_CHECKERR(destsurf->SetClip(destsurf, NULL)); } return 0; error: return -1; }
static int directfb_get_empty_bitmap (struct bitmap *bmp) { IDirectFBSurface *surface; DFBSurfaceDescription desc; bmp->data = bmp->flags = NULL; desc.flags = DSDESC_WIDTH | DSDESC_HEIGHT; desc.width = bmp->x; desc.height = bmp->y; if (dfb->CreateSurface (dfb, &desc, &surface) != DFB_OK) return 0; surface->Lock (surface, DSLF_READ | DSLF_WRITE, &bmp->data, &bmp->skip); bmp->flags = surface; return 0; }
static void update( Context *context ) { unsigned long t; IDirectFBSurface *surface = context->surface; static __u8 r = 0, g = 0, b = 0; context->gl->Lock( context->gl ); glClearColor( r++/255.0, g++/255.0, b++/255.0, 1.0 ); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); context->gl->Unlock( context->gl ); if (context->fps) { char buf[16]; snprintf(buf, sizeof(buf), "%.1f FPS\n", context->fps); surface->SetColor( surface, 0xff, 0x00, 0x00, 0xff ); surface->DrawString( surface, buf, -1, context->width - 5, 5, DSTF_TOPRIGHT ); } surface->Flip( surface, NULL, 0 ); context->frames++; t = get_millis(); if (t - context->last_time >= 2000) { float seconds = (t - context->last_time) / 1000.0f; context->fps = context->frames / seconds; context->last_time = t; context->frames = 0; } }
static int DirectFB_RenderDrawLines(SDL_Renderer * renderer, const SDL_Point * points, int count) { DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata; IDirectFBSurface *destsurf = get_dfb_surface(data->window); int i; DirectFB_ActivateRenderer(renderer); PrepareDraw(renderer); /* Use antialiasing when available */ #if (DFB_VERSION_ATLEAST(1,2,0)) SDL_DFB_CHECKERR(destsurf->SetRenderOptions(destsurf, DSRO_ANTIALIAS)); #endif for (i=0; i < count - 1; i++) SDL_DFB_CHECKERR(destsurf->DrawLine(destsurf, points[i].x, points[i].y, points[i+1].x, points[i+1].y)); return 0; error: return -1; }
QPixmap QDirectFBPixmapData::transformed(const QTransform &transform, Qt::TransformationMode mode) const { if (!surface || transform.type() != QTransform::TxScale || mode != Qt::FastTransformation) { QDirectFBPixmapData *that = const_cast<QDirectFBPixmapData*>(this); const QImage *image = that->buffer(); if (image) { // avoid deep copy const QImage transformed = image->transformed(transform, mode); that->unlockDirectFB(); QDirectFBPixmapData *data = new QDirectFBPixmapData(pixelType()); data->fromImage(transformed, Qt::AutoColor); return QPixmap(data); } return QPixmapData::transformed(transform, mode); } int w, h; surface->GetSize(surface, &w, &h); const QSize size = transform.mapRect(QRect(0, 0, w, h)).size(); if (size.isEmpty()) return QPixmap(); QDirectFBPixmapData *data = new QDirectFBPixmapData(pixelType()); data->resize(size.width(), size.height()); IDirectFBSurface *dest = data->surface; dest->SetBlittingFlags(dest, DSBLIT_NOFX); const DFBRectangle srcRect = { 0, 0, w, h }; const DFBRectangle destRect = { 0, 0, size.width(), size.height() }; dest->StretchBlit(dest, surface, &srcRect, &destRect); return QPixmap(data); }
void CFbAccel::blit2FB(void *fbbuff, uint32_t width, uint32_t height, uint32_t xoff, uint32_t yoff, uint32_t xp, uint32_t yp, bool transp) { DFBRectangle src; DFBResult err; IDirectFBSurface *surf; DFBSurfaceDescription dsc; src.x = xp; src.y = yp; src.w = width - xp; src.h = height - yp; dsc.flags = (DFBSurfaceDescriptionFlags)(DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PREALLOCATED); dsc.caps = DSCAPS_NONE; dsc.width = width; dsc.height = height; dsc.preallocated[0].data = fbbuff; dsc.preallocated[0].pitch = width * sizeof(fb_pixel_t); err = dfb->CreateSurface(dfb, &dsc, &surf); /* TODO: maybe we should not die if this fails? */ if (err != DFB_OK) { fprintf(stderr, "CFbAccel::blit2FB: "); DirectFBErrorFatal("dfb->CreateSurface(dfb, &dsc, &surf)", err); } if (transp) { surf->SetSrcColorKey(surf, 0, 0, 0); dfbdest->SetBlittingFlags(dfbdest, DSBLIT_SRC_COLORKEY); } else dfbdest->SetBlittingFlags(dfbdest, DSBLIT_BLEND_ALPHACHANNEL); dfbdest->Blit(dfbdest, surf, &src, xoff, yoff); surf->Release(surf); return; }
static int evas_cache_image_dfb_update_data(Engine_Image_Entry *dst, void *engine_data) { DirectFB_Engine_Image_Entry *deie = (DirectFB_Engine_Image_Entry *)dst; IDirectFBSurface *s = engine_data; Image_Entry *ie; RGBA_Image *im; ie = dst->src; im = (RGBA_Image *)ie; if (s) { deie->surface = s; /* XXX why size is required here? */ s->GetSize(s, &dst->w, &dst->h); if (im) { im->image.data = NULL; /* IDirectFBSurface requires lock */ im->image.no_free = 1; ie->w = dst->w; ie->h = dst->h; _image_autoset_alpha(deie); } } else { _dfb_surface_free(deie->surface); s = _dfb_surface_from_data(dfb, dst->w, dst->h, im->image.data); deie->surface = s; } return 0; }
/* render callback */ virtual void Render( IDirectFBSurface &surface ) { surface.Clear( 0, 0, 255, 255 ); surface.SetFont( font ); surface.SetColor( 0, 0, 0, 255 ); surface.SetSrcBlendFunction( DSBF_INVSRCALPHA ); surface.SetDstBlendFunction( DSBF_INVSRCALPHA ); surface.DrawString( "Test Text", -1, 10, 10, (DFBSurfaceTextFlags)(DSTF_TOPLEFT | DSTF_BLEND_FUNCS) ); }
static void* render_loop (void *arg) { IDirectFBSurface *view = (IDirectFBSurface*)arg; view->SetBlittingFlags( view, DSBLIT_SRC_COLORKEY | DSBLIT_COLORIZE ); while (started_rendering()) { int i; pthread_testcancel(); view->SetColor( view, 0, 0, 0, 0 ); view->FillRectangle( view, 0, 0, xres, yres ); for (i=0; i<STARFIELD_SIZE; i++) { int map = (int)(t_starfield[i].pos.v[Z]) >> 8; int light = 0xFF - ((int)(t_starfield[i].pos.v[Z] * t_starfield[i].pos.v[Z]) >> 12); if (map >= 0 && light > 0) { if (map >= NUM_STARS) map = NUM_STARS - 1; view->SetColor( view, light, light, light, 0xff ); view->Blit( view, stars[map], NULL, (int)(t_starfield[i].pos.v[X]), (int)(t_starfield[i].pos.v[Y]) ); } } view->Flip( view, NULL, DSFLIP_WAITFORSYNC ); finished_rendering(); } pthread_testcancel(); return NULL; }
static IDirectFBSurface * load_image (const char *filename) { IDirectFBImageProvider *provider; IDirectFBSurface *tmp = NULL; IDirectFBSurface *surface = NULL; DFBSurfaceDescription dsc; DFBResult err; err = dfb->CreateImageProvider( dfb, filename, &provider ); if (err != DFB_OK) { fprintf( stderr, "Couldn't load image from file '%s': %s\n", filename, DirectFBErrorString( err )); return NULL; } provider->GetSurfaceDescription( provider, &dsc ); dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT; dsc.pixelformat = DSPF_ARGB; if (dfb->CreateSurface( dfb, &dsc, &tmp ) == DFB_OK) provider->RenderTo( provider, tmp, NULL ); provider->Release( provider ); if (tmp) { primary->GetPixelFormat( primary, &dsc.pixelformat ); if (dfb->CreateSurface( dfb, &dsc, &surface ) == DFB_OK) { surface->Clear( surface, 0, 0, 0, 0xFF ); surface->SetBlittingFlags( surface, DSBLIT_BLEND_ALPHACHANNEL ); surface->Blit( surface, tmp, NULL, 0, 0 ); } tmp->Release( tmp ); } return surface; }
SDL_Renderer * DirectFB_CreateRenderer(SDL_Window * window, Uint32 flags) { IDirectFBSurface *winsurf = get_dfb_surface(window); SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window); SDL_Renderer *renderer = NULL; DirectFB_RenderData *data = NULL; DFBSurfaceCapabilities scaps; SDL_DFB_ALLOC_CLEAR(renderer, sizeof(*renderer)); SDL_DFB_ALLOC_CLEAR(data, sizeof(*data)); renderer->WindowEvent = DirectFB_WindowEvent; renderer->CreateTexture = DirectFB_CreateTexture; renderer->SetTextureAlphaMod = DirectFB_SetTextureAlphaMod; renderer->SetTextureColorMod = DirectFB_SetTextureColorMod; renderer->SetTextureBlendMode = DirectFB_SetTextureBlendMode; renderer->UpdateTexture = DirectFB_UpdateTexture; renderer->LockTexture = DirectFB_LockTexture; renderer->RenderClear = DirectFB_RenderClear; renderer->UnlockTexture = DirectFB_UnlockTexture; renderer->RenderDrawPoints = DirectFB_RenderDrawPoints; renderer->RenderDrawLines = DirectFB_RenderDrawLines; /* SetDrawColor - no needed */ renderer->RenderFillRects = DirectFB_RenderFillRects; renderer->RenderCopy = DirectFB_RenderCopy; renderer->RenderPresent = DirectFB_RenderPresent; /* FIXME: Yet to be tested */ renderer->RenderReadPixels = DirectFB_RenderReadPixels; /* renderer->RenderWritePixels = DirectFB_RenderWritePixels; */ renderer->DestroyTexture = DirectFB_DestroyTexture; renderer->DestroyRenderer = DirectFB_DestroyRenderer; renderer->UpdateViewport = DirectFB_UpdateViewport; renderer->UpdateClipRect = DirectFB_UpdateClipRect; renderer->SetRenderTarget = DirectFB_SetRenderTarget; #if 0 renderer->QueryTexturePixels = DirectFB_QueryTexturePixels; renderer->SetTexturePalette = DirectFB_SetTexturePalette; renderer->GetTexturePalette = DirectFB_GetTexturePalette; renderer->SetTextureScaleMode = DirectFB_SetTextureScaleMode; renderer->DirtyTexture = DirectFB_DirtyTexture; renderer->SetDrawBlendMode = DirectFB_SetDrawBlendMode; renderer->RenderDrawRects = DirectFB_RenderDrawRects; #endif renderer->info = DirectFB_RenderDriver.info; renderer->window = window; /* SDL window */ renderer->driverdata = data; renderer->info.flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE; data->window = window; data->target = winsurf; data->flipflags = DSFLIP_PIPELINE | DSFLIP_BLIT; if (flags & SDL_RENDERER_PRESENTVSYNC) { data->flipflags |= DSFLIP_WAITFORSYNC | DSFLIP_ONSYNC; renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC; } else data->flipflags |= DSFLIP_ONSYNC; SDL_DFB_CHECKERR(winsurf->GetCapabilities(winsurf, &scaps)); #if 0 if (scaps & DSCAPS_DOUBLE) renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2; else if (scaps & DSCAPS_TRIPLE) renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3; else renderer->info.flags |= SDL_RENDERER_SINGLEBUFFER; #endif DirectFB_SetSupportedPixelFormats(&renderer->info); #if 0 /* Set up a palette watch on the display palette */ if (display-> palette) { SDL_AddPaletteWatch(display->palette, DisplayPaletteChanged, data); } #endif return renderer; error: SDL_DFB_FREE(renderer); SDL_DFB_FREE(data); return NULL; }
void DirectFB_WM_RedrawLayout(_THIS, SDL_Window * window) { SDL_DFB_WINDOWDATA(window); IDirectFBSurface *s = windata->window_surface; DFB_Theme *t = &windata->theme; int i; int d = (t->caption_size - t->font_size) / 2; int x, y, w; if (!windata->is_managed || (window->flags & SDL_WINDOW_FULLSCREEN)) return; SDL_DFB_CHECK(s->SetSrcBlendFunction(s, DSBF_ONE)); SDL_DFB_CHECK(s->SetDstBlendFunction(s, DSBF_ZERO)); SDL_DFB_CHECK(s->SetDrawingFlags(s, DSDRAW_NOFX)); SDL_DFB_CHECK(s->SetBlittingFlags(s, DSBLIT_NOFX)); LoadFont(_this, window); /* s->SetDrawingFlags(s, DSDRAW_BLEND); */ s->SetColor(s, COLOR_EXPAND(t->frame_color)); /* top */ for (i = 0; i < t->top_size; i++) s->DrawLine(s, 0, i, windata->size.w, i); /* bottom */ for (i = windata->size.h - t->bottom_size; i < windata->size.h; i++) s->DrawLine(s, 0, i, windata->size.w, i); /* left */ for (i = 0; i < t->left_size; i++) s->DrawLine(s, i, 0, i, windata->size.h); /* right */ for (i = windata->size.w - t->right_size; i < windata->size.w; i++) s->DrawLine(s, i, 0, i, windata->size.h); /* Caption */ s->SetColor(s, COLOR_EXPAND(t->caption_color)); s->FillRectangle(s, t->left_size, t->top_size, windata->client.w, t->caption_size); /* Close Button */ w = t->caption_size; x = windata->size.w - t->right_size - w + d; y = t->top_size + d; s->SetColor(s, COLOR_EXPAND(t->close_color)); DrawTriangle(s, 1, x, y, w - 2 * d); /* Max Button */ s->SetColor(s, COLOR_EXPAND(t->max_color)); DrawTriangle(s, window->flags & SDL_WINDOW_MAXIMIZED ? 1 : 0, x - w, y, w - 2 * d); /* Caption */ if (*window->title) { s->SetColor(s, COLOR_EXPAND(t->font_color)); DrawCraption(_this, s, (x - w) / 2, t->top_size + d, window->title); } /* Icon */ if (windata->icon) { DFBRectangle dr; dr.x = t->left_size + d; dr.y = t->top_size + d; dr.w = w - 2 * d; dr.h = w - 2 * d; s->SetBlittingFlags(s, DSBLIT_BLEND_ALPHACHANNEL); s->StretchBlit(s, windata->icon, NULL, &dr); } windata->wm_needs_redraw = 0; }
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 SetBlendMode(DirectFB_RenderData * data, int blendMode, DirectFB_TextureData * source) { IDirectFBSurface *destsurf = data->target; /* FIXME: check for format change */ if (1 || data->lastBlendMode != blendMode) { switch (blendMode) { case SDL_BLENDMODE_NONE: /**< No blending */ data->blitFlags = DSBLIT_NOFX; data->drawFlags = DSDRAW_NOFX; SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ONE)); SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_ZERO)); break; #if 0 case SDL_BLENDMODE_MASK: data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL; data->drawFlags = DSDRAW_BLEND; SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA)); SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_INVSRCALPHA)); break; #endif case SDL_BLENDMODE_BLEND: data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL; data->drawFlags = DSDRAW_BLEND; SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA)); SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_INVSRCALPHA)); break; case SDL_BLENDMODE_ADD: data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL; data->drawFlags = DSDRAW_BLEND; /* FIXME: SRCALPHA kills performance on radeon ... * It will be cheaper to copy the surface to a temporary surface and premultiply */ if (source && TextureHasAlpha(source)) SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA)); else SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ONE)); SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_ONE)); break; case SDL_BLENDMODE_MOD: data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL; data->drawFlags = DSDRAW_BLEND; SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ZERO)); SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_SRCCOLOR)); break; } data->lastBlendMode = blendMode; } }
int main( int argc, char *argv[] ) { DFBResult ret; IDirectFB *dfb; IDirectFBDisplayLayer *layer; /* Initialize DirectFB. */ ret = DirectFBInit( &argc, &argv ); if (ret) { D_DERROR( ret, "DFBTest/Window_Surface: DirectFBInit() failed!\n" ); return ret; } /* Create super interface. */ ret = DirectFBCreate( &dfb ); if (ret) { D_DERROR( ret, "DFBTest/Window_Surface: DirectFBCreate() failed!\n" ); return ret; } dfb->GetDisplayLayer( dfb, DLID_PRIMARY, &layer ); while (true) { DFBWindowDescription desc; IDirectFBWindow *window; IDirectFBSurface *surface; desc.flags = DWDESC_POSX | DWDESC_POSY | DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_CAPS; desc.posx = 150; desc.posy = 150; desc.width = 300; desc.height = 300; desc.caps = DWCAPS_ALPHACHANNEL; ret = layer->CreateWindow( layer, &desc, &window ); if (ret) { D_DERROR( ret, "DFBTest/Window_Surface: CreateWindow() failed!\n" ); return ret; } window->GetSurface( window, &surface ); D_INFO( "Created window and surface, going to release window... (in 2 seconds)\n" ); usleep( 2000000 ); D_INFO("Releasing window...\n"); window->Release( window ); D_INFO("Window released, going to release surface... (in 2 seconds)\n"); usleep( 2000000 ); D_INFO("Releasing surface...\n"); surface->Release( surface ); D_INFO("Surface released, done.\n"); usleep( 5000000 ); } /* Shutdown DirectFB. */ dfb->Release( dfb ); return ret; }
static int DirectFB_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, const SDL_Rect * srcrect, const SDL_FRect * dstrect) { DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata; IDirectFBSurface *destsurf = data->target; DirectFB_TextureData *texturedata = (DirectFB_TextureData *) texture->driverdata; Uint8 alpha, r, g, b; DFBRegion clip_region; DFBRectangle sr, dr; DirectFB_ActivateRenderer(renderer); SDLtoDFBRect(srcrect, &sr); SDLtoDFBRect_Float(dstrect, &dr); destsurf->GetClip(destsurf, &clip_region); dr.x += clip_region.x1; dr.y += clip_region.y1; if (texturedata->display) { int px, py; SDL_Window *window = renderer->window; IDirectFBWindow *dfbwin = get_dfb_window(window); SDL_DFB_WINDOWDATA(window); SDL_VideoDisplay *display = texturedata->display; DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata; SDL_DFB_CHECKERR(dispdata-> vidlayer->SetSourceRectangle(dispdata->vidlayer, sr.x, sr.y, sr.w, sr.h)); dfbwin->GetPosition(dfbwin, &px, &py); px += windata->client.x; py += windata->client.y; SDL_DFB_CHECKERR(dispdata-> vidlayer->SetScreenRectangle(dispdata->vidlayer, px + dr.x, py + dr.y, dr.w, dr.h)); } else { DFBSurfaceBlittingFlags flags = 0; #if 0 if (texturedata->dirty.list) { SDL_DirtyRect *dirty; void *pixels; int bpp = DFB_BYTES_PER_PIXEL(DirectFB_SDLToDFBPixelFormat(texture->format)); int pitch = texturedata->pitch; for (dirty = texturedata->dirty.list; dirty; dirty = dirty->next) { SDL_Rect *rect = &dirty->rect; pixels = (void *) ((Uint8 *) texturedata->pixels + rect->y * pitch + rect->x * bpp); DirectFB_UpdateTexture(renderer, texture, rect, pixels, texturedata->pitch); } SDL_ClearDirtyRects(&texturedata->dirty); } #endif if (texturedata->isDirty) { SDL_Rect rect; rect.x = 0; rect.y = 0; rect.w = texture->w; rect.h = texture->h; DirectFB_UpdateTexture(renderer, texture, &rect, texturedata->pixels, texturedata->pitch); } alpha = r = g = b = 0xff; if (texture->modMode & SDL_TEXTUREMODULATE_ALPHA){ alpha = texture->a; flags |= DSBLIT_BLEND_COLORALPHA; } if (texture->modMode & SDL_TEXTUREMODULATE_COLOR) { r = texture->r; g = texture->g; b = texture->b; flags |= DSBLIT_COLORIZE; } SDL_DFB_CHECKERR(destsurf-> SetColor(destsurf, r, g, b, alpha)); /* ???? flags |= DSBLIT_SRC_PREMULTCOLOR; */ SetBlendMode(data, texture->blendMode, texturedata); SDL_DFB_CHECKERR(destsurf->SetBlittingFlags(destsurf, data->blitFlags | flags)); #if (DFB_VERSION_ATLEAST(1,2,0)) SDL_DFB_CHECKERR(destsurf->SetRenderOptions(destsurf, texturedata-> render_options)); #endif if (srcrect->w == dstrect->w && srcrect->h == dstrect->h) { SDL_DFB_CHECKERR(destsurf->Blit(destsurf, texturedata->surface, &sr, dr.x, dr.y)); } else { SDL_DFB_CHECKERR(destsurf->StretchBlit(destsurf, texturedata->surface, &sr, &dr)); } } return 0; error: return -1; }
void QDirectFBWindowSurface::setGeometry(const QRect &rect) { const QRect oldRect = geometry(); if (oldRect == rect) return; IDirectFBSurface *oldSurface = dfbSurface; const bool sizeChanged = oldRect.size() != rect.size(); if (sizeChanged) { delete engine; engine = 0; releaseSurface(); Q_ASSERT(!dfbSurface); } if (rect.isNull()) { #ifndef QT_NO_DIRECTFB_WM if (dfbWindow) { if (window()) window()->setProperty("_q_DirectFBWindowID", QVariant()); dfbWindow->Release(dfbWindow); dfbWindow = 0; } #endif Q_ASSERT(!dfbSurface); #ifdef QT_DIRECTFB_SUBSURFACE Q_ASSERT(!subSurface); #endif } else { #ifdef QT_DIRECTFB_WM if (!dfbWindow) { createWindow(rect); } else { setWindowGeometry(dfbWindow, oldRect, rect); Q_ASSERT(!sizeChanged || !dfbSurface); if (sizeChanged) dfbWindow->GetSurface(dfbWindow, &dfbSurface); } #else IDirectFBSurface *primarySurface = screen->primarySurface(); DFBResult result = DFB_OK; if (mode == Primary) { Q_ASSERT(primarySurface); if (rect == screen->region().boundingRect()) { dfbSurface = primarySurface; } else { const DFBRectangle r = { rect.x(), rect.y(), rect.width(), rect.height() }; result = primarySurface->GetSubSurface(primarySurface, &r, &dfbSurface); } } else { // mode == Offscreen if (!dfbSurface) { dfbSurface = screen->createDFBSurface(rect.size(), surfaceFlags() & Opaque ? screen->pixelFormat() : screen->alphaPixmapFormat(), QDirectFBScreen::DontTrackSurface); } } if (result != DFB_OK) DirectFBErrorFatal("QDirectFBWindowSurface::setGeometry()", result); #endif } if (oldSurface != dfbSurface) { imageFormat = dfbSurface ? QDirectFBScreen::getImageFormat(dfbSurface) : QImage::Format_Invalid; } if (oldRect.size() != rect.size()) { QWSWindowSurface::setGeometry(rect); } else { QWindowSurface::setGeometry(rect); } }
GdkCursor * gdk_cursor_new_for_display (GdkDisplay *display, GdkCursorType cursor_type) { GdkCursor *cursor; GdkDisplayDFB *dfb_display = GDK_DISPLAY_DFB (display); if (cursor_type >= sizeof (stock_cursors) / sizeof (stock_cursors[0])) return NULL; cursor = stock_cursors[cursor_type].cursor; if (!cursor) { GdkCursorDirectFB *private; DFBResult ret; IDirectFBSurface *temp; IDirectFBSurface *temp2; IDirectFBSurface *shape; int width = stock_cursors[cursor_type+1].width; int height = stock_cursors[cursor_type+1].height; temp = gdk_display_dfb_create_surface (dfb_display, DSPF_ARGB, width, height); if (!temp) { return NULL; } else { u32 *dst; int pitch; ret = temp->Lock (temp, DSLF_WRITE, (void**)&dst, &pitch); if (ret) { DirectFBError ("gdkcursor-directfb.c (gdk_cursor_new): " "temp->Lock", ret); temp->Release (temp); return NULL; } else { gint x, y; gint mx, my; gint p = ((stock_cursors[cursor_type].width + 7) / 8) * 8; gint mp = ((stock_cursors[cursor_type + 1].width + 7) / 8) * 8; const guchar *src; const guchar *mask; pitch >>= 2; src = stock_cursors[cursor_type].bits; mask = stock_cursors[cursor_type+1].bits; mx = stock_cursors[cursor_type+1].hotx - stock_cursors[cursor_type].hotx; my = stock_cursors[cursor_type+1].hoty - stock_cursors[cursor_type].hoty; for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { gint bit = x-mx + (y-my) * p; gint mbit = x + y * mp; u32 color = ((x - mx) < 0 || (y - my) < 0 || (x - mx) >= stock_cursors[cursor_type].width || (y - my) >= stock_cursors[cursor_type].height) ? 0x00FFFFFF : (src[bit/8] & (1 << bit%8) ? 0 : 0x00FFFFFF); u8 a = color ? 0xE0 : 0xFF; u32 alpha = mask[mbit/8] & (1 << mbit%8) ? (a << 24) : 0; dst[x + y*pitch] = alpha | color; } } temp->Unlock (temp); } } width += 2; height += 2; temp2 = gdk_display_dfb_create_surface (dfb_display, DSPF_ARGB, width, height); if (!temp2) { temp->Release (temp); return NULL; } temp2->Clear (temp2, 0x80, 0x80, 0x80, 0); temp2->SetBlittingFlags (temp2, (DSBLIT_BLEND_COLORALPHA | DSBLIT_BLEND_ALPHACHANNEL)); temp2->SetColor (temp2, 0, 0, 0, 0x30); temp2->Blit (temp2, temp, NULL, 0, 0); temp2->Blit (temp2, temp, NULL, 0, 2); temp2->Blit (temp2, temp, NULL, 2, 0); temp2->Blit (temp2, temp, NULL, 2, 2); temp2->SetColor (temp2, 0, 0, 0, 0xA0); temp2->Blit (temp2, temp, NULL, 1, 0); temp2->Blit (temp2, temp, NULL, 0, 1); temp2->Blit (temp2, temp, NULL, 2, 1); temp2->Blit (temp2, temp, NULL, 1, 2); temp2->SetColor (temp2, 0, 0, 0, 0xE0); temp2->Blit (temp2, temp, NULL, 1, 1); temp->Release (temp); // creating stretch width = width * 2; height = height * 2; shape = gdk_display_dfb_create_surface (dfb_display, DSPF_ARGB, width, height); if (!shape) { temp2->Release (temp2); return NULL; } shape->StretchBlit(shape, temp2, NULL, NULL); temp2->Release (temp2); private = g_new0 (GdkCursorDirectFB, 1);
int main( int argc, char *argv[] ) { DFBResult ret; DFBSurfaceDescription desc; IDirectFB *dfb; IDirectFBSurface *surface; IWater *water; D_INFO( "Tests/Water: Starting up...\n" ); /* 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; } /* Fill surface description, flipping primary. */ desc.flags = DSDESC_CAPS; desc.caps = DSCAPS_PRIMARY | DSCAPS_FLIPPING; /* Set width or height? */ if (m_width > 0) { desc.flags |= DSDESC_WIDTH; desc.width = m_width; } if (m_height > 0) { desc.flags |= DSDESC_HEIGHT; desc.height = m_height; } /* Set pixel format? */ if (m_format != DSPF_UNKNOWN) { desc.flags |= DSDESC_PIXELFORMAT; desc.pixelformat = m_format; } dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN ); /* Create a primary surface. */ ret = dfb->CreateSurface( dfb, &desc, &surface ); if (ret) { D_DERROR( ret, "IDirectFB::CreateSurface() failed!\n" ); dfb->Release( dfb ); return -4; } /* Get the extended rendering interface. */ ret = dfb->GetInterface( dfb, "IWater", NULL, dfb, (void**) &water ); if (ret) { DirectFBError( "IDirectFB::GetInterface( 'IWater' ) failed", ret ); surface->Release( surface ); dfb->Release( dfb ); return -5; } D_INFO( "Tests/Water: Got render interface, running tests...\n" ); RunTest( Test_Simple, water, surface ); RunTest( Test_RenderElement, water, surface ); RunTest( Test_RenderElements, water, surface ); RunTest( Test_RenderShape, water, surface ); RunTest( Test_RenderShapes, water, surface ); D_INFO( "Tests/Water: Dumping surface...\n" ); unlink( "dfbrender.pgm" ); unlink( "dfbrender.ppm" ); surface->Dump( surface, "dfbrender", NULL ); D_INFO( "Tests/Water: Shutting down...\n" ); /* Release the render interface. */ water->Release( water ); /* Release the surface. */ surface->Release( surface ); /* Release the super interface. */ dfb->Release( dfb ); return EXIT_SUCCESS; }
int main( int argc, char *argv[] ) { int i; DFBResult ret; DFBSurfaceDescription desc; IDirectFB *dfb; IDirectFBImageProvider *provider = NULL; IDirectFBSurface *source = NULL; IDirectFBSurface *dest = NULL; const char *url = NULL; /* Parse arguments. */ for (i=1; i<argc; i++) { if (!strcmp( argv[i], "-h" )) return show_usage( argv[0] ); else if (!url) url = argv[i]; else return show_usage( argv[0] ); } /* Check if we got an URL. */ if (!url) return show_usage( argv[0] ); /* Initialize DirectFB. */ ret = DirectFBInit( &argc, &argv ); if (ret) { D_DERROR( ret, "DFBTest/Scale: DirectFBInit() failed!\n" ); return ret; } /* Create super interface. */ ret = DirectFBCreate( &dfb ); if (ret) { D_DERROR( ret, "DFBTest/Scale: DirectFBCreate() failed!\n" ); return ret; } /* Create an image provider for the image to be loaded. */ ret = dfb->CreateImageProvider( dfb, url, &provider ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateImageProvider( '%s' ) failed!\n", url ); goto out; } /* Get the surface description. */ ret = provider->GetSurfaceDescription( provider, &desc ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFBImageProvider::GetSurfaceDescription() failed!\n" ); goto out; } desc.pixelformat = DSPF_LUT8; D_INFO( "DFBTest/Scale: Source is %dx%d using %s\n", desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) ); /* Create a surface for the image. */ ret = dfb->CreateSurface( dfb, &desc, &source ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateSurface() failed!\n" ); goto out; } ret = provider->RenderTo( provider, source, NULL ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFBImageProvider::RenderTo() failed!\n" ); goto out; } desc.width = desc.width * 3 / 4; desc.height = desc.height * 3 / 4; if (DFB_PIXELFORMAT_IS_INDEXED( desc.pixelformat )) desc.pixelformat = DSPF_ARGB; D_INFO( "DFBTest/Scale: Destination is %dx%d using %s\n", desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) ); /* Create a surface for the image. */ ret = dfb->CreateSurface( dfb, &desc, &dest ); if (ret) { D_DERROR( ret, "DFBTest/Scale: IDirectFB::CreateSurface() failed!\n" ); goto out; } dest->SetBlittingFlags( dest, DSBLIT_SRC_PREMULTIPLY ); dest->StretchBlit( dest, source, NULL, NULL ); dest->Dump( dest, "dfbtest_scale", NULL ); out: if (dest) dest->Release( dest ); if (source) source->Release( source ); if (provider) provider->Release( provider ); /* Shutdown DirectFB. */ dfb->Release( dfb ); return ret; }
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; } /* Get the primary display layer. */ ret = dfb->GetDisplayLayer( dfb, id, &layer ); if (ret) { if (ret == DFB_IDNOTFOUND) fprintf (stderr, "\nUnknown layer id, check 'dfbinfo' for valid values.\n\n"); else DirectFBError( "IDirectFB::GetDisplayLayer() failed", ret ); dfb->Release( dfb ); return -4; } /* Get a description of the layer. */ ret = layer->GetDescription( layer, &desc ); if (ret) { DirectFBError( "IDirectFBDisplayLayer::GetDescription() failed", ret ); layer->Release( layer ); dfb->Release( dfb ); return -5; } /* Acquire administrative cooperative level. */ ret = layer->SetCooperativeLevel( layer, DLSCL_ADMINISTRATIVE ); if (ret) { DirectFBError( "IDirectFBDisplayLayer::SetCooperativeLevel() failed", ret ); layer->Release( layer ); dfb->Release( dfb ); return -6; } /* Show/change the configuration. */ set_configuration(); /* Test Lock() on layer surface? */ if (test_lock) { IDirectFBSurface *surface; fprintf( stderr, "\nGetting layer surface...\n" ); ret = layer->GetSurface( layer, &surface ); if (ret) DirectFBError( "IDirectFBDisplayLayer::GetSurface() failed", ret ); else { void *data; int pitch; fprintf( stderr, "\nTesting Lock( %s ) on layer surface...\n", test_lock == DSLF_READ ? "read only" : test_lock == DSLF_WRITE ? "write only" : "read/write" ); ret = surface->Lock( surface, test_lock, &data, &pitch ); if (ret) DirectFBError( "IDirectFBSurface::Lock() failed", ret ); else fprintf( stderr, " => OK\n\n" ); surface->Release( surface ); } } /* Release the display layer. */ layer->Release( layer ); /* Release the super interface. */ dfb->Release( dfb ); return EXIT_SUCCESS; }
static DFBResult Test_CreateSubWindow( IDirectFBDisplayLayer *layer, void *arg ) { IDirectFBWindow *window; DFBWindowID window_id; DFBDimension size = { m_desc_sub.width, m_desc_sub.height }; D_ASSERT( m_toplevel_id != 0 ); /* Write window ID of top level into description */ m_desc_sub.toplevel_id = m_toplevel_id; /* * Create a new sub window with 75% width/height and positioned at 20,20 within top level window */ SHOW_TEST( "CreateWindow( %d,%d - %dx%d %s + toplevel ID %u, options 0x%08x )...", m_desc_sub.posx, m_desc_sub.posy, m_desc_sub.width, m_desc_sub.height, dfb_pixelformat_name( m_desc_sub.pixelformat ), m_desc_sub.toplevel_id, m_desc_top.options ); _T( layer->CreateWindow( layer, &m_desc_sub, &window ) ); if (m_subcolor.valid) { DFBColor c = m_subcolor.color; SHOW_INFO( " - SetColor( 0x%02x, 0x%02x, 0x%02x, 0x%02x )...", c.r, c.g, c.b, c.a ); _T( window->SetColor( window, c.r, c.g, c.b, c.a ) ); } /* * Query its surface and clear it with light gray (if not input or color only) */ if (!(m_desc_sub.caps & (DWCAPS_INPUTONLY | DWCAPS_COLOR) )) { IDirectFBSurface *surface; SHOW_INFO( " - GetSurface()..." ); _T( window->GetSurface( window, &surface ) ); SHOW_INFO( " - Clear( 0xC0, 0xC0, 0xC0, 0xFF )..." ); _T( surface->Clear( surface, 0xC0, 0xC0, 0xC0, 0xFF ) ); _T( surface->DrawRectangle( surface, 0, 0, size.w, size.h ) ); _T( surface->FillRectangle( surface, size.w / 2, 1, 1, size.h - 2 ) ); _T( surface->FillRectangle( surface, 1, size.h / 2, size.w - 2, 1 ) ); surface->Release( surface ); } /* * Show the window */ SHOW_INFO( " - SetOpacity( 255 )..." ); _T( window->SetOpacity( window, 0xff ) ); /* * Query and print ID of new window */ SHOW_INFO( " - GetID()..." ); _T( window->GetID( window, &window_id ) ); /* * Set association of new window */ if (m_desc_sub.parent_id) { SHOW_INFO( " - SetAssociation( %u )...", m_desc_sub.parent_id ); _T( window->SetAssociation( window, m_desc_sub.parent_id ) ); } /* * Set top level window ID (user hasn't specified one) */ m_subwindow_id = window_id; m_subwindow = window; SHOW_RESULT( "...CreateWindow( %d,%d - %dx%d %s + toplevel ID %u ) done. => Sub Window ID %u", m_desc_sub.posx, m_desc_sub.posy, m_desc_sub.width, m_desc_sub.height, dfb_pixelformat_name( m_desc_sub.pixelformat ), m_desc_sub.toplevel_id, window_id ); return DFB_OK; }
int main( int argc, char *argv[] ) { int i; DFBResult ret; DFBSurfaceDescription desc; IDirectFB *dfb; IDirectFBSurface *dest = NULL; const char *url = NULL; DFBFontAttributes attributes = DFFA_NONE; DFBSurfaceTextFlags text_flags = DSTF_TOPLEFT; int outline_width = 0x10000; int outline_opacity = 255; const DFBColorID color_ids[2] = { DCID_PRIMARY, DCID_OUTLINE }; const DFBColor colors[2] = { { 0xff, 0xff, 0xff, 0xff }, { 0xff, 0x00, 0x80, 0xff } }; /* Initialize DirectFB. */ ret = DirectFBInit( &argc, &argv ); if (ret) { D_DERROR( ret, "DFBTest/Font: 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, "-o") == 0 || strcmp (arg, "--outline") == 0) { attributes |= DFFA_OUTLINED; text_flags |= DSTF_OUTLINE; } else if (strcmp (arg, "-ow") == 0 || strcmp (arg, "--outline-width") == 0) { if (++i == argc) return print_usage( argv[0] ); if (sscanf( argv[i], "%d", &outline_width ) != 1) return print_usage( argv[0] ); outline_width <<= 16; } else if (strcmp (arg, "-oo") == 0 || strcmp (arg, "--outline-opacity") == 0) { if (++i == argc) return print_usage( argv[0] ); if (sscanf( argv[i], "%d", &outline_opacity ) != 1) return print_usage( argv[0] ); } else if (!url) url = arg; else return print_usage( argv[0] ); } /* Check if we got an URL. */ if (!url) return print_usage( argv[0] ); /* Create super interface. */ ret = DirectFBCreate( &dfb ); if (ret) { D_DERROR( ret, "DFBTest/Font: DirectFBCreate() failed!\n" ); return ret; } /* Fill description for a primary surface. */ desc.flags = DSDESC_CAPS; desc.caps = DSCAPS_PRIMARY | DSCAPS_FLIPPING; dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN ); /* Create a primary surface. */ ret = dfb->CreateSurface( dfb, &desc, &dest ); if (ret) { D_DERROR( ret, "DFBTest/Font: IDirectFB::CreateSurface() failed!\n" ); goto out; } dest->GetSize( dest, &desc.width, &desc.height ); dest->GetPixelFormat( dest, &desc.pixelformat ); D_INFO( "DFBTest/Font: Destination is %dx%d using %s\n", desc.width, desc.height, dfb_pixelformat_name(desc.pixelformat) ); for (i=10; i<50; i++) { IDirectFBFont *font; font = CreateFont( dfb, url, i, attributes, outline_width, outline_opacity ); RenderChecker( dest, 64, 64 ); dest->SetColors( dest, color_ids, colors, 2 ); dest->SetFont( dest, font ); dest->DrawString( dest, "Test String AVAWA", -1, 100, 100, text_flags ); dest->Flip( dest, NULL, DSFLIP_NONE ); font->Release( font ); usleep( 500000 ); } out: if (dest) dest->Release( dest ); /* Shutdown DirectFB. */ dfb->Release( dfb ); return ret; }
int main( int argc, char *argv[] ) { IDirectFB *dfb; IDirectFBDisplayLayer *layer; IDirectFBSurface *bgsurface; IDirectFBImageProvider *provider; IDirectFBWindow *window1; IDirectFBWindow *window2; IDirectFBSurface *window_surface1; IDirectFBSurface *window_surface2; IDirectFBEventBuffer *buffer; DFBDisplayLayerConfig layer_config; #if ((DIRECTFB_MAJOR_VERSION == 0) && (DIRECTFB_MINOR_VERSION == 9) && (DIRECTFB_MICRO_VERSION < 23)) DFBCardCapabilities caps; #else DFBGraphicsDeviceDescription caps; #endif IDirectFBWindow* upper; DFBWindowID id1; IDirectFBFont *font; int fontheight; int err; int quit = 0; DFBCHECK(DirectFBInit( &argc, &argv )); DFBCHECK(DirectFBCreate( &dfb )); #if ((DIRECTFB_MAJOR_VERSION == 0) && (DIRECTFB_MINOR_VERSION == 9) && (DIRECTFB_MICRO_VERSION < 23)) dfb->GetCardCapabilities( dfb, &caps ); #else dfb->GetDeviceDescription( dfb, &caps ); #endif dfb->GetDisplayLayer( dfb, DLID_PRIMARY, &layer ); if (!((caps.blitting_flags & DSBLIT_BLEND_ALPHACHANNEL) && (caps.blitting_flags & DSBLIT_BLEND_COLORALPHA ))) { layer_config.flags = DLCONF_BUFFERMODE; layer_config.buffermode = DLBM_BACKSYSTEM; layer->SetConfiguration( layer, &layer_config ); } layer->GetConfiguration( layer, &layer_config ); layer->EnableCursor ( layer, 1 ); { DFBFontDescription desc; desc.flags = DFDESC_HEIGHT; desc.height = layer_config.width/50; DFBCHECK(dfb->CreateFont( dfb, PACKAGE_DATA_DIR"/grunge.ttf", &desc, &font )); font->GetHeight( font, &fontheight ); } { DFBSurfaceDescription desc; DFBCHECK(dfb->CreateImageProvider( dfb, PACKAGE_DATA_DIR"/bg.png", &provider )); desc.flags = DSDESC_WIDTH | DSDESC_HEIGHT; desc.width = layer_config.width; desc.height = layer_config.height; DFBCHECK(dfb->CreateSurface( dfb, &desc, &bgsurface ) ); provider->RenderTo( provider, bgsurface, NULL ); provider->Release( provider ); DFBCHECK(bgsurface->SetFont( bgsurface, font )); bgsurface->SetColor( bgsurface, 0xCF, 0xCF, 0xFF, 0xFF ); bgsurface->DrawString( bgsurface, "Move the mouse over a window to activate it.", -1, 10, 0, DSTF_LEFT | DSTF_TOP ); bgsurface->SetColor( bgsurface, 0xFF, 0xCF, 0xFF, 0xFF ); bgsurface->DrawString( bgsurface, "You can drag them around, too, if you want.", -1, 10 , 40, DSTF_LEFT | DSTF_TOP ); bgsurface->SetColor( bgsurface, 0xCF, 0xCF, 0xFF, 0xFF ); bgsurface->DrawString( bgsurface, "The one with funky stuff happening and things flying around is an evas.", -1, 10, 80, DSTF_LEFT | DSTF_TOP ); layer->SetBackgroundImage( layer, bgsurface ); layer->SetBackgroundMode( layer, DLBM_IMAGE ); } { DFBWindowDescription desc; desc.flags = ( DWDESC_POSX | DWDESC_POSY | DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_CAPS ); desc.posx = 20; desc.posy = 120; desc.width = 200; desc.height = 200; desc.caps = DWCAPS_ALPHACHANNEL; DFBCHECK( layer->CreateWindow( layer, &desc, &window2 ) ); window2->GetSurface( window2, &window_surface2 ); window2->SetOpacity( window2, 0xFF ); window2->CreateEventBuffer( window2, &buffer ); { window_surface2->SetColor( window_surface2, 0x00, 0x30, 0x10, 0xc0 ); window_surface2->DrawRectangle( window_surface2, 0, 0, desc.width, desc.height ); window_surface2->SetColor( window_surface2, 0x80, 0xa0, 0x00, 0x90 ); window_surface2->FillRectangle( window_surface2, 1, 1, desc.width-2, desc.height-2 ); DFBCHECK(window_surface2->SetFont(window_surface2, font )); window_surface2->SetColor( window_surface2, 0xCF, 0xFF, 0xCF, 0xFF ); window_surface2->DrawString( window_surface2, "Pants!", -1,10, fontheight + 5, DSTF_LEFT | DSTF_TOP ); } window_surface2->Flip( window_surface2, NULL, 0 ); } { DFBWindowDescription desc; desc.flags = ( DWDESC_POSX | DWDESC_POSY | DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_CAPS ); desc.posx = 200; desc.posy = 200; desc.width = 240; desc.height = 320; desc.caps = DWCAPS_ALPHACHANNEL; DFBCHECK(layer->CreateWindow( layer, &desc, &window1 ) ); window1->GetSurface( window1, &window_surface1 ); window_surface1->SetColor( window_surface1, 0xFF, 0x20, 0x20, 0x90 ); window_surface1->DrawRectangle( window_surface1, 0, 0, desc.width, desc.height ); window_surface1->Flip( window_surface1, NULL, 0 ); window1->SetOpacity( window1, 0xFF ); window1->GetID( window1, &id1 ); window1->AttachEventBuffer( window1, buffer ); } window1->RequestFocus( window1 ); window1->RaiseToTop( window1 ); upper = window1; { evas_init(); evas = evas_new(); evas_output_method_set(evas, evas_render_method_lookup("directfb")); evas_output_size_set(evas, 240, 320); evas_output_viewport_set(evas, 0, 0, 240, 320); { Evas_Engine_Info_DirectFB *einfo; einfo = (Evas_Engine_Info_DirectFB *) evas_engine_info_get(evas); einfo->info.dfb = dfb; einfo->info.surface = window_surface1; einfo->info.flags = DSDRAW_BLEND; evas_engine_info_set(evas, (Evas_Engine_Info *) einfo); } setup(); evas_render(evas); start_time = get_time(); } while (!quit) { static IDirectFBWindow* active = NULL; static int grabbed = 0; static int startx = 0; static int starty = 0; static int endx = 0; static int endy = 0; DFBWindowEvent evt; buffer->WaitForEventWithTimeout( buffer, 0, 10 ); while (buffer->GetEvent( buffer, DFB_EVENT(&evt) ) == DFB_OK) { IDirectFBWindow* window; if (evt.window_id == id1) window = window1; else window = window2; if (active) { switch (evt.type) { case DWET_BUTTONDOWN: if (!grabbed && evt.button == DIBI_LEFT) { grabbed = 1; layer->GetCursorPosition( layer, &startx, &starty ); window->GrabPointer( window ); } break; case DWET_BUTTONUP: switch (evt.button) { case DIBI_LEFT: if (grabbed) { window->UngrabPointer( window ); grabbed = 0; } break; case DIBI_MIDDLE: upper->LowerToBottom( upper ); upper = (upper == window1) ? window2 : window1; break; case DIBI_RIGHT: quit = DIKS_DOWN; break; default: break; } break; case DWET_KEYDOWN: if (grabbed) break; switch (evt.key_id) { case DIKI_RIGHT: active->Move (active, 1, 0); break; case DIKI_LEFT: active->Move (active, -1, 0); break; case DIKI_UP: active->Move (active, 0, -1); break; case DIKI_DOWN: active->Move (active, 0, 1); break; default: break; } break; case DWET_LOSTFOCUS: if (!grabbed) active = NULL; break; default: break; } } else if (evt.type == DWET_GOTFOCUS) active = window; switch (evt.type) { case DWET_MOTION: endx = evt.cx; endy = evt.cy; break; case DWET_KEYDOWN: switch (evt.key_symbol) { case DIKS_ESCAPE: case DIKS_SMALL_Q: case DIKS_CAPITAL_Q: case DIKS_BACK: case DIKS_STOP: quit = 1; break; default: break; } break; default: break; } } if (active) { if (grabbed) { active->Move( active, endx - startx, endy - starty); startx = endx; starty = endy; } active->SetOpacity( active, (sin( myclock()/300.0 ) * 85) + 170 ); } loop(); { Eina_List *updates; updates = evas_render_updates(evas); /* efficient update.. only flip the rectangle regions that changed! */ if (updates) { DFBRegion region; Eina_List *l; for (l = updates; l; l = l->next) { Evas_Rectangle *rect; rect = l->data; region.x1 = rect->x; region.y1 = rect->y; region.x2 = rect->x + rect->w - 1; region.y2 = rect->y + rect->h - 1; window_surface1->Flip(window_surface1, ®ion, DSFLIP_BLIT); } evas_render_updates_free(updates); } } } buffer->Release( buffer ); window_surface2->Release( window_surface2 ); window_surface1->Release( window_surface1 ); window2->Release( window2 ); window1->Release( window1 ); layer->Release( layer ); bgsurface->Release( bgsurface ); dfb->Release( dfb ); evas_shutdown(); return 0; }
int main( int argc, char *argv[] ) { int quit = 0; pthread_t render_loop_thread = -1; IDirectFBSurface *primary; IDirectFBEventBuffer *buffer; DFBSurfaceDescription dsc; srand((long)time(0)); DFBCHECK(DirectFBInit( &argc, &argv )); /* create the super interface */ DFBCHECK(DirectFBCreate( &dfb )); /* get an interface to the primary keyboard and create an input buffer for it */ DFBCHECK(dfb->CreateInputEventBuffer( dfb, DICAPS_ALL, DFB_FALSE, &buffer )); /* set our cooperative level to DFSCL_FULLSCREEN for exclusive access to the primary layer */ dfb->SetCooperativeLevel( dfb, DFSCL_FULLSCREEN ); /* get the primary surface, i.e. the surface of the primary layer we have exclusive access to */ dsc.flags = DSDESC_CAPS; dsc.caps = DSCAPS_PRIMARY | DSCAPS_DOUBLE; DFBCHECK(dfb->CreateSurface( dfb, &dsc, &primary )); DFBCHECK(primary->GetSize( primary, &xres, &yres )); /* load font */ { DFBFontDescription desc; desc.flags = DFDESC_HEIGHT; desc.height = yres/10; DFBCHECK(dfb->CreateFont( dfb, FONT, &desc, &font )); DFBCHECK(primary->SetFont( primary, font )); } projection = matrix_new_perspective( 400 ); camera = matrix_new_identity(); load_stars(); generate_starfield(); pthread_mutex_lock( &render_start ); pthread_mutex_lock( &render_finish ); pthread_create( &render_loop_thread, NULL, render_loop, (void*)primary ); /* main loop */ while (!quit) { static float translation[3] = { 0, 0, 0 }; DFBInputEvent evt; /* transform world to screen coordinates */ transform_starfield(); /* start rendering before waiting for events */ start_rendering(); buffer->WaitForEvent( buffer ); /* process event buffer */ while (buffer->GetEvent( buffer, DFB_EVENT(&evt)) == DFB_OK) { if (evt.type == DIET_KEYPRESS) { switch (evt.key_id) { case DIKI_ESCAPE: /* quit main loop */ quit = 1; break; case DIKI_LEFT: translation[0] = 10; break; case DIKI_RIGHT: translation[0] = -10; break; case DIKI_UP: translation[2] = -10; break; case DIKI_DOWN: translation[2] = 10; break; default: break; } } else if (evt.type == DIET_KEYRELEASE) { switch (evt.key_id) { case DIKI_LEFT: case DIKI_RIGHT: translation[0] = 0; break; case DIKI_UP: case DIKI_DOWN: translation[2] = 0; break; default: break; } } else if (evt.type == DIET_AXISMOTION && (evt.flags & DIEF_AXISREL)) { switch (evt.axis) { case DIAI_X: matrix_rotate( camera, Y, -evt.axisrel/80.0f ); break; case DIAI_Y: matrix_rotate( camera, X, evt.axisrel/80.0f ); break; default: break; } } } matrix_translate( camera, translation[0], translation[1], translation[2] ); /* finish rendering before retransforming the world */ finish_rendering(); } pthread_cancel( render_loop_thread ); pthread_mutex_unlock( &render_start ); pthread_join( render_loop_thread, NULL ); render_loop_thread = -1; unload_stars(); free( camera ); free( projection ); buffer->Release( buffer ); primary->Release( primary ); dfb->Release( dfb ); return 0; }
DFBResult lite_theme_frame_load( LiteThemeFrame *frame, const char **filenames ) { int i, y; int width = 0; int height = 0; DFBResult ret; D_ASSERT( frame != NULL ); D_ASSERT( filenames != NULL ); for (i=0; i<_LITE_THEME_FRAME_PART_NUM; i++) { D_ASSERT( filenames[i] != NULL ); ret = lite_util_load_image( filenames[i], DSPF_UNKNOWN, &frame->parts[i].source, &frame->parts[i].rect.w, &frame->parts[i].rect.h, NULL ); if (ret) { D_DERROR( ret, "Lite/ThemeFrame: Loading '%s' failed!\n", filenames[i] ); while (i--) frame->parts[i].source->Release( frame->parts[i].source ); return ret; } if (width < frame->parts[i].rect.w) width = frame->parts[i].rect.w; height += frame->parts[i].rect.h; } IDirectFB *dfb; IDirectFBSurface *compact; DFBSurfaceDescription desc; desc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT; desc.width = width; desc.height = height; desc.pixelformat = DSPF_ARGB; //FIXME DirectFBCreate( &dfb ); dfb->CreateSurface( dfb, &desc, &compact ); compact->Clear( compact, 0, 0, 0, 0 ); for (i=0, y=0; i<_LITE_THEME_FRAME_PART_NUM; i++) { compact->Blit( compact, frame->parts[i].source, &frame->parts[i].rect, 0, y ); compact->AddRef( compact ); frame->parts[i].source->Release( frame->parts[i].source ); frame->parts[i].source = compact; frame->parts[i].rect.x = 0; frame->parts[i].rect.y = y; y += frame->parts[i].rect.h; } compact->ReleaseSource( compact ); compact->Release( compact ); dfb->Release( dfb ); D_MAGIC_SET( frame, LiteThemeFrame ); return DFB_OK; }
void DFBDeviceScreen::setBackgroundImage(string uri) { DFBResult ret; DFBSurfaceDescription desc; IDirectFBSurface *surface; IDirectFBImageProvider *provider; ret = dfb->CreateImageProvider(dfb, uri.c_str(), &provider); if (ret) { DirectFBError("IDirectFB::CreateImageProvider() failed", ret); return; } ret = provider->GetSurfaceDescription(provider, &desc); if (ret) { DirectFBError( "DFBDeviceScreen::setBackgroundImage surdsc failed", ret); provider->Release(provider); return; } desc.width = this->wRes; desc.height = this->hRes; ret = dfb->CreateSurface(dfb, &desc, &surface); if (ret) { DirectFBError( "DFBDeviceScreen::setBackgroundImage sur failed", ret); provider->Release(provider); return; } ret = provider->RenderTo(provider, surface, NULL); if (ret) { DirectFBError( "DFBDeviceScreen::setBackgroundImage renderto failed", ret); surface->Release(surface); provider->Release(provider); return; } ret = gfxLayer->SetBackgroundImage(gfxLayer, surface); if (ret) { DirectFBError( "DFBDeviceScreen::setBackgroundImage bg failed", ret); surface->Release(surface); provider->Release(provider); return; } ret = gfxLayer->SetBackgroundMode(gfxLayer, DLBM_IMAGE); if (ret) { DirectFBError( "DFBDeviceScreen::setBackgroundImage bgm failed", ret); } surface->Release(surface); provider->Release(provider); cout << endl << endl; cout << "DFBScreen::setBackgroundImage '" << uri << "'" << endl; cout << endl << endl; }