void QDirectFBPixmapData::resize(int width, int height)
{
if (width <= 0 || height <= 0) {
setSerialNumber(0);
return;
}
IDirectFB *dfb = QDirectFBScreen::instance()->dfb();
if (!dfb)
qFatal("QDirectFBPixmapData::resize(): "
"Unable to get DirectFB handle!");
DFBSurfaceDescription description;
description.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH |
DSDESC_HEIGHT);
description.width = width;
description.height = height;
DFBResult result = dfb->CreateSurface(dfb, &description, &surface);
if (result != DFB_OK) {
DirectFBErrorFatal("QDirectFBPixmapData::resize(): "
"Unable to allocate surface", result);
}
setSerialNumber(++global_ser_no);
}
void QDirectFBWindowSurface::createWindow(const QRect &rect)
{
IDirectFBDisplayLayer *layer = screen->dfbDisplayLayer();
if (!layer)
qFatal("QDirectFBWindowSurface: Unable to get primary display layer!");
updateIsOpaque();
DFBWindowDescription description;
memset(&description, 0, sizeof(DFBWindowDescription));
description.flags = DWDESC_CAPS|DWDESC_HEIGHT|DWDESC_WIDTH|DWDESC_POSX|DWDESC_POSY|DWDESC_SURFACE_CAPS|DWDESC_PIXELFORMAT;
description.caps = DWCAPS_NODECORATION;
description.surface_caps = DSCAPS_NONE;
imageFormat = screen->pixelFormat();
if (!(surfaceFlags() & Opaque)) {
imageFormat = screen->alphaPixmapFormat();
description.caps |= DWCAPS_ALPHACHANNEL;
#if (Q_DIRECTFB_VERSION >= 0x010200)
description.flags |= DWDESC_OPTIONS;
description.options |= DWOP_ALPHACHANNEL;
#endif
}
description.pixelformat = QDirectFBScreen::getSurfacePixelFormat(imageFormat);
description.posx = rect.x();
description.posy = rect.y();
description.width = rect.width();
description.height = rect.height();
if (QDirectFBScreen::isPremultiplied(imageFormat))
description.surface_caps = DSCAPS_PREMULTIPLIED;
if (screen->directFBFlags() & QDirectFBScreen::VideoOnly)
description.surface_caps |= DSCAPS_VIDEOONLY;
DFBResult result = layer->CreateWindow(layer, &description, &dfbWindow);
if (result != DFB_OK)
DirectFBErrorFatal("QDirectFBWindowSurface::createWindow", result);
if (window()) {
if (window()->windowFlags() & Qt::WindowStaysOnTopHint) {
dfbWindow->SetStackingClass(dfbWindow, DWSC_UPPER);
}
DFBWindowID winid;
result = dfbWindow->GetID(dfbWindow, &winid);
if (result != DFB_OK) {
DirectFBError("QDirectFBWindowSurface::createWindow. Can't get ID", result);
} else {
window()->setProperty("_q_DirectFBWindowID", winid);
}
}
Q_ASSERT(!dfbSurface);
dfbWindow->GetSurface(dfbWindow, &dfbSurface);
}
IDirectFBDisplayLayer *QDirectFbConvenience::dfbDisplayLayer(int display)
{
IDirectFBDisplayLayer *layer;
DFBResult result = QDirectFbConvenience::dfbInterface()->GetDisplayLayer(QDirectFbConvenience::dfbInterface(),display,&layer);
if (result != DFB_OK)
DirectFBErrorFatal("QDirectFbConvenience: "
"Unable to get primary display layer!", result);
return layer;
}
static DFBEnumerationResult
screen_callback( DFBScreenID id,
DFBScreenDescription desc,
void *arg )
{
int i;
DFBResult ret;
IDirectFBScreen *screen;
ret = dfb->GetScreen( dfb, id, &screen );
if (ret)
DirectFBErrorFatal( "IDirectFB::GetScreen", ret );
/* Name */
printf( "Screen (%02x) %-30s", id, desc.name );
switch (id) {
case DSCID_PRIMARY:
printf( " (primary screen)" );
break;
default:
break;
}
printf( "\n" );
/* Caps */
printf( " Caps: " );
for (i=0; screen_caps[i].capability; i++) {
if (desc.caps & screen_caps[i].capability)
printf( "%s ", screen_caps[i].name );
}
printf( "\n\n" );
/* Mixers */
if (desc.mixers)
dump_mixers( screen, desc.mixers );
/* Encoders */
if (desc.encoders)
dump_encoders( screen, desc.encoders );
/* Outputs */
if (desc.outputs)
dump_outputs( screen, desc.outputs );
/* Display layers */
enum_display_layers( screen );
screen->Release( screen );
return DFB_OK;
}
QT_BEGIN_NAMESPACE
IDirectFB *QDirectFbConvenience::dfbInterface()
{
static IDirectFB *dfb = 0;
if (!dfb) {
DFBResult result = DirectFBCreate(&dfb);
if (result != DFB_OK) {
DirectFBErrorFatal("QDirectFBConvenience: error creating DirectFB interface", result);
return 0;
}
}
return dfb;
}
void df_Pointer_New(rdpContext* context, rdpPointer* pointer)
{
dfInfo* dfi;
DFBResult result;
dfPointer* df_pointer;
DFBSurfaceDescription dsc;
dfi = ((dfContext*) context)->dfi;
df_pointer = (dfPointer*) pointer;
dsc.flags = DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT;
dsc.caps = DSCAPS_SYSTEMONLY;
dsc.width = pointer->width;
dsc.height = pointer->height;
dsc.pixelformat = DSPF_ARGB;
result = dfi->dfb->CreateSurface(dfi->dfb, &dsc, &(df_pointer->surface));
if (result == DFB_OK)
{
int pitch;
uint8* point = NULL;
df_pointer->xhot = pointer->xPos;
df_pointer->yhot = pointer->yPos;
result = df_pointer->surface->Lock(df_pointer->surface,
DSLF_WRITE, (void**) &point, &pitch);
if (result != DFB_OK)
{
DirectFBErrorFatal("Error while creating pointer surface", result);
return;
}
if ((pointer->andMaskData != 0) && (pointer->xorMaskData != 0))
{
freerdp_alpha_cursor_convert(point, pointer->xorMaskData, pointer->andMaskData,
pointer->width, pointer->height, pointer->xorBpp, dfi->clrconv);
}
if (pointer->xorBpp > 24)
{
freerdp_image_swap_color_order(point, pointer->width, pointer->height);
}
df_pointer->surface->Unlock(df_pointer->surface);
}
}
void df_Pointer_Set(rdpContext* context, rdpPointer* pointer)
{
dfInfo* dfi;
DFBResult result;
dfPointer* df_pointer;
dfi = ((dfContext*) context)->dfi;
df_pointer = (dfPointer*) pointer;
dfi->layer->SetCooperativeLevel(dfi->layer, DLSCL_ADMINISTRATIVE);
result = dfi->layer->SetCursorShape(dfi->layer,
df_pointer->surface, df_pointer->xhot, df_pointer->yhot);
if (result != DFB_OK)
{
DirectFBErrorFatal("SetCursorShape Error", result);
return;
}
dfi->layer->SetCooperativeLevel(dfi->layer, DLSCL_SHARED);
}
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;
}
int main (int argc, char **argv)
{
DFBResult dfberr;
if( (dfberr = DirectFBInit( &argc, &argv )) != DFB_OK )
{ DirectFBErrorFatal("DirectFBInit( &argc, &argv )", dfberr); }
IDirectFB * main_interface = NULL;
IDirectFB * main_interface_2 = NULL;
/* 1) */
if( (dfberr = DirectFBCreate( &main_interface )) != DFB_OK )
{ DirectFBErrorFatal( "DirectFBCreate( &main_interface )", dfberr); }
#if 0
/* 2) */
if( (dfberr = DirectFBCreate( &main_interface )) != DFB_OK )
{ DirectFBErrorFatal( "DirectFBCreate( &main_interface )", dfberr); }
#endif
/*if( (dfberr
= main_dfb_interface->SetVideoMode( main_interface, 100, 100, 0 )) !=
DFB_OK ) { fprintf(stderr, "File: %s, Line: %d:\n", __FILE__, __LINE__);
DirectFBErrorFatal( "SetVideoMode( main_interface, 100, 100, 100 )",
dfberr); }*/
if( (dfberr = DirectFBCreate( &main_interface_2 )) != DFB_OK )
{ DirectFBErrorFatal( "DirectFBCreate( &main_interface_2 )", dfberr); }
if (main_interface == main_interface_2)
{
printf("Returns same\n");
printf("Returns same\n");
printf("Returns same\n");
sleep(10);
}
if( (dfberr = main_interface->SetCooperativeLevel( main_interface, DFSCL_FULLSCREEN )) != DFB_OK )
{ DirectFBErrorFatal( "SetCooperativeLevel( main_interface, DFSCL_FULLSCREEN )", dfberr); }
if( (dfberr = main_interface_2->SetCooperativeLevel( main_interface_2, DFSCL_FULLSCREEN )) != DFB_OK ) /* 3) */
{ DirectFBErrorFatal( "SetCooperativeLevel( main_interface_2, DFSCL_FULLSCREEN )", dfberr); }
}
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);
}
}