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 QGLPixmapData::fromNativeType(void* pixmap, NativeType type)
{
if (type == QPixmapData::SgImage && pixmap) {
#if defined(QT_SYMBIAN_SUPPORTS_SGIMAGE) && !defined(QT_NO_EGL)
RSgImage *sgImage = reinterpret_cast<RSgImage*>(pixmap);
m_sgImage = new RSgImage;
m_sgImage->Open(sgImage->Id());
TSgImageInfo info;
sgImage->GetInfo(info);
w = info.iSizeInPixels.iWidth;
h = info.iSizeInPixels.iHeight;
d = symbianPixeFormatBitsPerPixel((TUidPixelFormat)info.iPixelFormat);
m_source = QVolatileImage();
m_hasAlpha = true;
m_hasFillColor = false;
m_dirty = true;
is_null = (w <= 0 || h <= 0);
#endif
} else if (type == QPixmapData::FbsBitmap && pixmap) {
CFbsBitmap *bitmap = reinterpret_cast<CFbsBitmap *>(pixmap);
QSize size(bitmap->SizeInPixels().iWidth, bitmap->SizeInPixels().iHeight);
if (size.width() == w && size.height() == h)
setSerialNumber(++qt_gl_pixmap_serial);
resize(size.width(), size.height());
m_source = QVolatileImage(bitmap);
if (pixelType() == BitmapType) {
m_source.ensureFormat(QImage::Format_MonoLSB);
} else if (!knownGoodFormat(m_source.format())) {
m_source.beginDataAccess();
QImage::Format format = idealFormat(m_source.imageRef(), Qt::AutoColor);
m_source.endDataAccess(true);
m_source.ensureFormat(format);
}
m_hasAlpha = m_source.hasAlphaChannel();
m_hasFillColor = false;
m_dirty = true;
d = m_source.depth();
} else if (type == QPixmapData::VolatileImage && pixmap) {
// Support QS60Style in more efficient skin graphics retrieval.
QVolatileImage *img = static_cast<QVolatileImage *>(pixmap);
if (img->width() == w && img->height() == h)
setSerialNumber(++qt_gl_pixmap_serial);
resize(img->width(), img->height());
m_source = *img;
m_hasAlpha = m_source.hasAlphaChannel();
m_hasFillColor = false;
m_dirty = true;
d = m_source.depth();
} else if (type == QPixmapData::NativeImageHandleProvider && pixmap) {
destroyTexture();
nativeImageHandleProvider = static_cast<QNativeImageHandleProvider *>(pixmap);
// Cannot defer the retrieval, we need at least the size right away.
createFromNativeImageHandleProvider();
}
}
void QMacPixmapData::resize(int width, int height)
{
setSerialNumber(++qt_pixmap_serial);
w = width;
h = height;
is_null = (w <= 0 || h <= 0);
d = (pixelType() == BitmapType ? 1 : 32);
bool make_null = w <= 0 || h <= 0; // create null pixmap
if (make_null || d == 0) {
w = 0;
h = 0;
is_null = true;
d = 0;
if (!make_null)
qWarning("Qt: QPixmap: Invalid pixmap parameters");
return;
}
if (w < 1 || h < 1)
return;
//create the pixels
bytesPerRow = w * sizeof(quint32); // Minimum bytes per row.
// Quartz2D likes things as a multple of 16 (for now).
bytesPerRow = COMPTUE_BEST_BYTES_PER_ROW(bytesPerRow);
macCreatePixels();
}
int FRModel::setSerialNumber(const QString &number, QString password)
{
fillString(password, getPasswordLength(password));
int result = hw->hw()->ECR_SetMode(0);
if (result == 0 || result == 157)
{
result = hw->hw()->ECR_SetMode(5, codec->fromUnicode(password));
if (!result)
result = hw->hw()->ECR_SetSerialNumber(codec->fromUnicode(number));
}
result = err->analizeError(result);
switch (result)
{
case 0:
updateInformation();
break;
case 1:
waitForRelease();
result = setSerialNumber(number, password);
break;
default:
emit signalFail(generateErrorMessage(conv("Ошибка установки серийного номера."), result));
}
return result;
}
STDMETHODIMP HostUSBDeviceFilterWrap::COMSETTER(SerialNumber)(IN_BSTR aSerialNumber)
{
LogRelFlow(("{%p} %s: enter aSerialNumber=%ls\n", this, "HostUSBDeviceFilter::setSerialNumber", aSerialNumber));
VirtualBoxBase::clearError();
HRESULT hrc;
try
{
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc()))
throw autoCaller.rc();
hrc = setSerialNumber(BSTRInConverter(aSerialNumber).str());
}
catch (HRESULT hrc2)
{
hrc = hrc2;
}
catch (...)
{
hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
}
LogRelFlow(("{%p} %s: leave hrc=%Rhrc\n", this, "HostUSBDeviceFilter::setSerialNumber", hrc));
return hrc;
}
void QGLPixmapData::resize(int width, int height)
{
if (width == w && height == h)
return;
if (width <= 0 || height <= 0) {
width = 0;
height = 0;
}
w = width;
h = height;
is_null = (w <= 0 || h <= 0);
d = pixelType() == QPixmapData::PixmapType ? 32 : 1;
if (m_texture.id) {
QGLShareContextScope ctx(qt_gl_share_context());
glDeleteTextures(1, &m_texture.id);
m_texture.id = 0;
}
m_source = QImage();
m_dirty = isValid();
setSerialNumber(++qt_gl_pixmap_serial);
}
void QDirectFBPixmapData::fromImage(const QImage &i,
Qt::ImageConversionFlags flags)
{
#ifdef QT_NO_DIRECTFB_OPAQUE_DETECTION
Q_UNUSED(flags);
#endif
const QImage img = (i.depth() == 1 ? i.convertToFormat(screen->alphaPixmapFormat()) : i);
if (img.hasAlphaChannel()
#ifndef QT_NO_DIRECTFB_OPAQUE_DETECTION
&& (flags & Qt::NoOpaqueDetection || QDirectFBPixmapData::hasAlphaChannel(img))
#endif
) {
alpha = true;
format = screen->alphaPixmapFormat();
} else {
alpha = false;
format = screen->pixelFormat();
}
dfbSurface = screen->copyToDFBSurface(img, format,
QDirectFBScreen::TrackSurface);
if (!dfbSurface) {
qWarning("QDirectFBPixmapData::fromImage()");
invalidate();
return;
}
setSerialNumber(++global_ser_no);
}
bool QDirectFBPixmapData::fromDataBufferDescription(const DFBDataBufferDescription &dataBufferDescription)
{
IDirectFB *dfb = screen->dfb();
Q_ASSERT(dfb);
DFBResult result = DFB_OK;
IDirectFBDataBuffer *dataBufferPtr;
if ((result = dfb->CreateDataBuffer(dfb, &dataBufferDescription, &dataBufferPtr)) != DFB_OK) {
DirectFBError("QDirectFBPixmapData::fromDataBufferDescription()", result);
return false;
}
QDirectFBPointer<IDirectFBDataBuffer> dataBuffer(dataBufferPtr);
IDirectFBImageProvider *providerPtr;
if ((result = dataBuffer->CreateImageProvider(dataBuffer.data(), &providerPtr)) != DFB_OK)
return false;
QDirectFBPointer<IDirectFBImageProvider> provider(providerPtr);
DFBImageDescription imageDescription;
result = provider->GetImageDescription(provider.data(), &imageDescription);
if (result != DFB_OK) {
DirectFBError("QDirectFBPixmapData::fromSurfaceDescription(): Can't get image description", result);
return false;
}
if (imageDescription.caps & DICAPS_COLORKEY) {
return false;
}
DFBSurfaceDescription surfaceDescription;
if ((result = provider->GetSurfaceDescription(provider.data(), &surfaceDescription)) != DFB_OK) {
DirectFBError("QDirectFBPixmapData::fromDataBufferDescription(): Can't get surface description", result);
return false;
}
alpha = imageDescription.caps & DICAPS_ALPHACHANNEL;
imageFormat = alpha ? screen->alphaPixmapFormat() : screen->pixelFormat();
dfbSurface = screen->createDFBSurface(QSize(surfaceDescription.width, surfaceDescription.height),
imageFormat, QDirectFBScreen::TrackSurface);
result = provider->RenderTo(provider.data(), dfbSurface, 0);
if (result != DFB_OK) {
DirectFBError("QDirectFBPixmapData::fromSurfaceDescription(): Can't render to surface", result);
return false;
}
w = surfaceDescription.width;
h = surfaceDescription.height;
is_null = (w <= 0 || h <= 0);
d = QDirectFBScreen::depth(imageFormat);
setSerialNumber(++global_ser_no);
#if defined QT_DIRECTFB_IMAGEPROVIDER_KEEPALIVE
screen->setDirectFBImageProvider(providerPtr);
provider.take();
#endif
return true;
}
void QDirectFBPixmapData::fromImage(const QImage &img, Qt::ImageConversionFlags flags)
{
alpha = QDirectFBPixmapData::hasAlphaChannel(img, flags);
imageFormat = alpha ? screen->alphaPixmapFormat() : screen->pixelFormat();
QImage image;
if ((flags & ~Qt::NoOpaqueDetection) != Qt::AutoColor) {
image = img.convertToFormat(imageFormat, flags);
flags = Qt::AutoColor;
} else if (img.format() == QImage::Format_RGB32 || img.depth() == 1) {
image = img.convertToFormat(imageFormat, flags);
} else if (img.format() != imageFormat) {
image = img.convertToFormat(imageFormat, flags);
} else {
image = img;
}
dfbSurface = screen->createDFBSurface(image, image.format(), QDirectFBScreen::NoPreallocated | QDirectFBScreen::TrackSurface);
if (!dfbSurface) {
qWarning("QDirectFBPixmapData::fromImage()");
invalidate();
return;
}
w = image.width();
h = image.height();
is_null = (w <= 0 || h <= 0);
d = QDirectFBScreen::depth(imageFormat);
setSerialNumber(++global_ser_no);
#ifdef QT_NO_DIRECTFB_OPAQUE_DETECTION
Q_UNUSED(flags);
#endif
}
void QDirectFBPixmapData::fill(const QColor &color)
{
if (!serialNumber())
return;
Q_ASSERT(dfbSurface);
alpha |= (color.alpha() < 255);
if (alpha && isOpaqueFormat(imageFormat)) {
QSize size;
dfbSurface->GetSize(dfbSurface, &size.rwidth(), &size.rheight());
screen->releaseDFBSurface(dfbSurface);
imageFormat = screen->alphaPixmapFormat();
d = QDirectFBScreen::depth(imageFormat);
dfbSurface = screen->createDFBSurface(size, screen->alphaPixmapFormat(), QDirectFBScreen::TrackSurface);
setSerialNumber(++global_ser_no);
if (!dfbSurface) {
qWarning("QDirectFBPixmapData::fill()");
invalidate();
return;
}
}
dfbSurface->Clear(dfbSurface, color.red(), color.green(), color.blue(), color.alpha());
}
LinuxDevice::LinuxDevice(struct udev_device* dev)
{
log->debug("Creating a new LinuxDevice instance");
const char *name = udev_device_get_sysattr_value(dev, "product");
if (name) {
log->debug("DeviceName={}", name);
setDeviceName(name);
}
const char *id_vendor = udev_device_get_sysattr_value(dev, "idVendor");
if (id_vendor) {
log->debug("VendorID={}", id_vendor);
setVendorID(id_vendor);
}
const char *id_product = udev_device_get_sysattr_value(dev, "idProduct");
if (id_product) {
log->debug("ProductID={}", id_product);
setProductID(id_product);
}
const char *serial = udev_device_get_sysattr_value(dev, "serial");
if (serial) {
log->debug("Serial={}", serial);
setSerialNumber(serial);
}
const char *syspath = udev_device_get_syspath(dev);
if (syspath) {
log->debug("Syspath={}", syspath);
_syspath = syspath;
} else {
throw std::runtime_error("device wihtout syspath");
}
const char *sysname = udev_device_get_sysname(dev);
if (sysname) {
log->debug("Sysname={}", sysname);
setDevicePort(sysname);
} else {
throw std::runtime_error("device wihtout sysname");
}
log->debug("DeviceHash={}", getDeviceHash());
setTarget(Rule::Target::Unknown);
std::ifstream descriptor_stream(_syspath + "/descriptors", std::ifstream::binary);
if (!descriptor_stream.good()) {
throw std::runtime_error("cannot load USB descriptors");
}
else {
readDescriptors(descriptor_stream);
}
return;
}
QBlittablePixmapData::QBlittablePixmapData()
: QPixmapData(QPixmapData::PixmapType,BlitterClass)
, m_alpha(false)
#ifdef QT_BLITTER_RASTEROVERLAY
,m_rasterOverlay(0), m_unmergedCopy(0)
#endif //QT_BLITTER_RASTEROVERLAY
{
setSerialNumber(++global_ser_no);
}
Task::Task(time_t deadline, int priority, string description, int cronFreq, bool isFinished, int serialNumber, string group, time_t ft){
// cout<<"newing task"<<endl;
setDeadline(deadline);
setPriority(priority);
setDescription(description);
setIsFinished(isFinished);
setSerialNumber(serialNumber);
setGroup(group);
setFinishTime(ft);
}
void QBlittablePlatformPixmap::resize(int width, int height)
{
m_blittable.reset(0);
m_engine.reset(0);
d = QGuiApplication::primaryScreen()->depth();
w = width;
h = height;
is_null = (w <= 0 || h <= 0);
setSerialNumber(++global_ser_no);
}
void QVGPixmapData::fromImage
(const QImage &image, Qt::ImageConversionFlags flags)
{
if (image.size() == QSize(w, h))
setSerialNumber(++qt_vg_pixmap_serial);
else
resize(image.width(), image.height());
source = image.convertToFormat(sourceFormat(), flags);
recreate = true;
}
void QDirectFBPixmapData::copy(const QPixmapData *data, const QRect &rect)
{
if (data->classId() != DirectFBClass) {
QPixmapData::copy(data, rect);
return;
}
IDirectFBSurface *src = static_cast<const QDirectFBPixmapData*>(data)->surface;
DFBSurfaceDescription description;
description.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH |
DSDESC_HEIGHT |
DSDESC_PIXELFORMAT);
description.width = rect.width();
description.height = rect.height();
src->GetPixelFormat(src, &description.pixelformat);
IDirectFB *fb = QDirectFBScreen::instance()->dfb();
DFBResult result = fb->CreateSurface(fb, &description, &surface);
if (result != DFB_OK) {
DirectFBError("QDirectFBPixmapData::copy()", result);
setSerialNumber(0);
return;
}
#ifndef QT_NO_DIRECTFB_PALETTE
IDirectFBPalette *palette;
src->GetPalette(src, &palette);
surface->SetPalette(surface, palette);
#endif
surface->SetBlittingFlags(surface, DSBLIT_NOFX);
const DFBRectangle blitRect = { rect.x(), rect.y(),
rect.width(), rect.height() };
result = surface->Blit(surface, src, &blitRect, 0, 0);
if (result != DFB_OK)
DirectFBError("QDirectFBPixmapData::copy()", result);
setSerialNumber(++global_ser_no);
}
QGLPixmapData::QGLPixmapData(PixelType type)
: QPixmapData(type, OpenGLClass)
, m_renderFbo(0)
, m_engine(0)
, m_ctx(0)
, m_dirty(false)
, m_hasFillColor(false)
, m_hasAlpha(false)
{
setSerialNumber(++qt_gl_pixmap_serial);
m_glDevice.setPixmapData(this);
}
void QDirectFBPixmapData::invalidate()
{
if (dfbSurface) {
screen->releaseDFBSurface(dfbSurface);
dfbSurface = 0;
}
setSerialNumber(0);
alpha = false;
d = w = h = 0;
is_null = true;
imageFormat = QImage::Format_Invalid;
}
void QDirectFBPixmapData::copy(const QPixmapData *data, const QRect &rect)
{
if (data->classId() != DirectFBClass) {
QPixmapData::copy(data, rect);
return;
}
const QDirectFBPixmapData *otherData = static_cast<const QDirectFBPixmapData*>(data);
#ifdef QT_NO_DIRECTFB_SUBSURFACE
if (otherData->lockFlags()) {
const_cast<QDirectFBPixmapData*>(otherData)->unlockSurface();
}
#endif
IDirectFBSurface *src = otherData->directFBSurface();
alpha = data->hasAlphaChannel();
imageFormat = (alpha
? QDirectFBScreen::instance()->alphaPixmapFormat()
: QDirectFBScreen::instance()->pixelFormat());
dfbSurface = screen->createDFBSurface(rect.size(), imageFormat,
QDirectFBScreen::TrackSurface);
if (!dfbSurface) {
qWarning("QDirectFBPixmapData::copy()");
invalidate();
return;
}
if (alpha) {
dfbSurface->Clear(dfbSurface, 0, 0, 0, 0);
dfbSurface->SetBlittingFlags(dfbSurface, DSBLIT_BLEND_ALPHACHANNEL);
} else {
dfbSurface->SetBlittingFlags(dfbSurface, DSBLIT_NOFX);
}
const DFBRectangle blitRect = { rect.x(), rect.y(),
rect.width(), rect.height() };
w = rect.width();
h = rect.height();
d = otherData->d;
is_null = (w <= 0 || h <= 0);
unlockSurface();
DFBResult result = dfbSurface->Blit(dfbSurface, src, &blitRect, 0, 0);
#if (Q_DIRECTFB_VERSION >= 0x010000)
dfbSurface->ReleaseSource(dfbSurface);
#endif
if (result != DFB_OK) {
DirectFBError("QDirectFBPixmapData::copy()", result);
invalidate();
return;
}
setSerialNumber(++global_ser_no);
}
QWindowsDirect2DPlatformPixmap::QWindowsDirect2DPlatformPixmap(QPlatformPixmap::PixelType pixelType,
QWindowsDirect2DPaintEngine::Flags flags,
QWindowsDirect2DBitmap *bitmap)
: QPlatformPixmap(pixelType, Direct2DClass)
, d_ptr(new QWindowsDirect2DPlatformPixmapPrivate(bitmap, flags))
{
setSerialNumber(qt_d2dpixmap_serno++);
is_null = false;
w = bitmap->size().width();
h = bitmap->size().height();
this->d = 32;
}
void QBlittablePixmapData::resize(int width, int height)
{
m_blittable.reset(0);
m_engine.reset(0);
#ifdef Q_WS_QPA
d = QApplicationPrivate::platformIntegration()->screens().at(0)->depth();
#endif
w = width;
h = height;
is_null = (w <= 0 || h <= 0);
setSerialNumber(++global_ser_no);
}
void QDirectFBPixmapData::fill(const QColor &color)
{
if (!serialNumber())
return;
Q_ASSERT(surface);
if (color.alpha() < 255 && !hasAlphaChannel()) {
// convert to surface supporting alpha channel
DFBSurfacePixelFormat format;
surface->GetPixelFormat(surface, &format);
switch (format) {
case DSPF_YUY2:
case DSPF_UYVY:
format = DSPF_AYUV;
break;
#if (Q_DIRECTFB_VERSION >= 0x010100)
case DSPF_RGB444:
format = DSPF_ARGB4444;
break;
case DSPF_RGB555:
#endif
case DSPF_RGB18:
format = DSPF_ARGB6666;
break;
default:
format = DSPF_ARGB;
break;
}
DFBSurfaceDescription description;
description.flags = DFBSurfaceDescriptionFlags(DSDESC_WIDTH |
DSDESC_HEIGHT |
DSDESC_PIXELFORMAT);
surface->GetSize(surface, &description.width, &description.height);
description.pixelformat = format;
surface->Release(surface); // release old surface
IDirectFB *fb = QDirectFBScreen::instance()->dfb();
DFBResult result = fb->CreateSurface(fb, &description, &surface);
if (result != DFB_OK) {
DirectFBError("QDirectFBPixmapData::fill()", result);
setSerialNumber(0);
return;
}
}
surface->Clear(surface, color.red(), color.green(), color.blue(),
color.alpha());
}
void QVGPixmapData::resize(int wid, int ht)
{
if (w == wid && h == ht)
return;
w = wid;
h = ht;
d = 32; // We always use ARGB_Premultiplied for VG pixmaps.
is_null = (w <= 0 || h <= 0);
source = QImage();
recreate = true;
setSerialNumber(++qt_vg_pixmap_serial);
}
IOReturn AppleACPIBatteryDevice::setBatteryBIF(OSArray *acpibat_bif)
{
fPowerUnit = GetValueFromArray (acpibat_bif, BIF_POWER_UNIT);
fDesignCapacity = GetValueFromArray (acpibat_bif, BIF_DESIGN_CAPACITY);
fMaxCapacity = GetValueFromArray (acpibat_bif, BIF_LAST_FULL_CAPACITY);
fDesignVoltage = GetValueFromArray (acpibat_bif, BIF_DESIGN_VOLTAGE);
fDeviceName = GetSymbolFromArray(acpibat_bif, BIF_MODEL_NUMBER);
fSerial = GetSymbolFromArray(acpibat_bif, BIF_SERIAL_NUMBER);
fSerialNumber = GetValueFromArray (acpibat_bif, BIF_SERIAL_NUMBER);
fManufacturer = GetSymbolFromArray(acpibat_bif, BIF_OEM);
fCycleCount = 0;
if(acpibat_bif->getCount() > 13)
fCycleCount = GetValueFromArray(acpibat_bif, BIF_CYCLE_COUNT);
else if(fDesignCapacity > fMaxCapacity)
fCycleCount = (fDesignCapacity - fMaxCapacity) / 6;
if ((fDesignCapacity == 0) || (fMaxCapacity == 0)) {
logReadError(kErrorZeroCapacity, 0, NULL);
}
setDesignCapacity(fDesignCapacity);
setMaxCapacity(fMaxCapacity);
setDeviceName(fDeviceName);
setSerialNumber(fSerialNumber);
setManufacturer(fManufacturer);
setCycleCount(fCycleCount);
float realCapacity = fMaxCapacity;
int capacityStatus = kIOPMUndefinedValue;
realCapacity /= fDesignCapacity;
if(realCapacity >= 0.8)
capacityStatus = kIOPMGoodValue;
else if(realCapacity >= 0.6)
capacityStatus = kIOPMFairValue;
else if(realCapacity >= 0.3)
capacityStatus = kIOPMPoorValue;
else
capacityStatus = fDesignCapacity;
properties->setObject(kIOPMPSBatteryHealthKey, OSNumber::withNumber(capacityStatus, NUM_BITS));
properties->setObject(kIOPMPSHealthConfidenceKey, OSNumber::withNumber(capacityStatus, NUM_BITS));
return kIOReturnSuccess;
}
QGLPixmapData::QGLPixmapData(PixelType type)
: QPixmapData(type, OpenGLClass)
, m_renderFbo(0)
, m_engine(0)
, m_ctx(0)
, nativeImageHandleProvider(0)
, nativeImageHandle(0)
#ifdef QT_SYMBIAN_SUPPORTS_SGIMAGE
, m_sgImage(0)
#endif
, m_dirty(false)
, m_hasFillColor(false)
, m_hasAlpha(false)
{
setSerialNumber(++qt_gl_pixmap_serial);
}
QVGPixmapData::QVGPixmapData(PixelType type)
: QPixmapData(type, OpenVGClass)
{
Q_ASSERT(type == QPixmapData::PixmapType);
vgImage = VG_INVALID_HANDLE;
vgImageOpacity = VG_INVALID_HANDLE;
cachedOpacity = 1.0f;
recreate = true;
inImagePool = false;
inLRU = false;
#if !defined(QT_NO_EGL)
context = 0;
qt_vg_register_pixmap(this);
#endif
setSerialNumber(++qt_vg_pixmap_serial);
}
void QDirectFBPixmapData::fromImage(const QImage &img, Qt::ImageConversionFlags flags)
{
alpha = QDirectFBPixmapData::hasAlphaChannel(img, flags);
imageFormat = alpha ? screen->alphaPixmapFormat() : screen->pixelFormat();
QImage image;
if ((flags & ~Qt::NoOpaqueDetection) != Qt::AutoColor) {
image = img.convertToFormat(imageFormat, flags);
flags = Qt::AutoColor;
} else if (img.format() == QImage::Format_RGB32 || img.depth() == 1) {
image = img.convertToFormat(imageFormat, flags);
} else {
image = img;
}
IDirectFBSurface *imageSurface = screen->createDFBSurface(image, image.format(), QDirectFBScreen::DontTrackSurface);
if (!imageSurface) {
qWarning("QDirectFBPixmapData::fromImage()");
invalidate();
return;
}
dfbSurface = screen->createDFBSurface(image.size(), imageFormat, QDirectFBScreen::TrackSurface);
if (!dfbSurface) {
qWarning("QDirectFBPixmapData::fromImage()");
invalidate();
return;
}
if (image.hasAlphaChannel()) {
dfbSurface->Clear(dfbSurface, 0, 0, 0, 0);
dfbSurface->SetBlittingFlags(dfbSurface, DSBLIT_BLEND_ALPHACHANNEL);
} else {
dfbSurface->SetBlittingFlags(dfbSurface, DSBLIT_NOFX);
}
dfbSurface->Blit(dfbSurface, imageSurface, 0, 0, 0);
imageSurface->Release(imageSurface);
w = image.width();
h = image.height();
is_null = (w <= 0 || h <= 0);
d = QDirectFBScreen::depth(imageFormat);
setSerialNumber(++global_ser_no);
#ifdef QT_NO_DIRECTFB_OPAQUE_DETECTION
Q_UNUSED(flags);
#endif
}
/*!
out-of-place conversion (inPlace == false) will always detach()
*/
void QGLPixmapData::createPixmapForImage(QImage &image, Qt::ImageConversionFlags flags, bool inPlace)
{
if (image.size() == QSize(w, h))
setSerialNumber(++qt_gl_pixmap_serial);
resize(image.width(), image.height());
if (pixelType() == BitmapType) {
m_source = image.convertToFormat(QImage::Format_MonoLSB);
} else {
QImage::Format format = QImage::Format_RGB32;
if (qApp->desktop()->depth() == 16)
format = QImage::Format_RGB16;
if (image.hasAlphaChannel()
&& ((flags & Qt::NoOpaqueDetection)
|| const_cast<QImage &>(image).data_ptr()->checkForAlphaPixels()))
format = QImage::Format_ARGB32_Premultiplied;;
if (inPlace && image.data_ptr()->convertInPlace(format, flags)) {
m_source = image;
} else {
m_source = image.convertToFormat(format);
// convertToFormat won't detach the image if format stays the same.
if (image.format() == format)
m_source.detach();
}
}
m_dirty = true;
m_hasFillColor = false;
m_hasAlpha = m_source.hasAlphaChannel();
w = image.width();
h = image.height();
is_null = (w <= 0 || h <= 0);
d = m_source.depth();
if (m_texture.id) {
QGLShareContextScope ctx(qt_gl_share_context());
glDeleteTextures(1, &m_texture.id);
m_texture.id = 0;
}
}
void QDirectFBPixmapData::resize(int width, int height)
{
if (width <= 0 || height <= 0) {
invalidate();
return;
}
format = screen->pixelFormat();
dfbSurface = QDirectFBScreen::instance()->createDFBSurface(QSize(width, height),
format,
QDirectFBScreen::TrackSurface);
alpha = false;
if (!dfbSurface) {
invalidate();
qWarning("QDirectFBPixmapData::resize(): Unable to allocate surface");
return;
}
setSerialNumber(++global_ser_no);
}
QGLPixmapData::QGLPixmapData(PixelType type)
: QPixmapData(type, OpenGLClass)
, m_renderFbo(0)
, m_engine(0)
, m_ctx(0)
, nativeImageHandleProvider(0)
, nativeImageHandle(0)
, m_dirty(false)
, m_hasFillColor(false)
, m_hasAlpha(false)
, inLRU(false)
, failedToAlloc(false)
, inTexturePool(false)
{
setSerialNumber(++qt_gl_pixmap_serial);
m_glDevice.setPixmapData(this);
qt_gl_register_pixmap(this);
}
