void StackFolder::paintInterface(QPainter *p, const QStyleOptionGraphicsItem *option, const QRect &contentsRect)
{
Q_UNUSED(p);
Q_UNUSED(option);
Q_UNUSED(contentsRect);
if (m_placesModel && m_iconAnimationGroup->state() != QAbstractAnimation::Stopped) {
if (m_hoverState) {
stopAnimation();
}
else {
setPopupIcon(m_icon.pixmap(m_popupIconSize.width(), m_popupIconSize.height()));
return;
}
}
if (m_hoverShow) {
if (m_hoverState) {
QPixmap pixmap = m_icon.pixmap(geometry().width(), geometry().height());
QPixmap alphaMask(pixmap.width(), pixmap.height());
const QColor color(127, 127, 127);
alphaMask.fill(color);
pixmap.setAlphaChannel(alphaMask);
setPopupIcon(pixmap);
}
else {
setPopupIcon(m_icon);
}
}
}
void TreeItem::setImage(const QIcon &icon, int column)
{
if (column<13&&column>-1)
{
if (column==1)
{
int size=24;
QSize ava_size(size,size);
QPixmap pixmap = icon.pixmap(icon.actualSize(QSize(65535,65535)),QIcon::Normal,QIcon::On);
if (!pixmap.isNull())
{
QPixmap alpha (ava_size);
alpha.fill(QColor(0,0,0));
QPainter painter(&alpha);
QPen pen(QColor(127,127,127));
painter.setRenderHint(QPainter::Antialiasing);
pen.setWidth(0);
painter.setPen(pen);
painter.setBrush(QBrush(QColor(255,255,255)));
painter.drawRoundRect(QRectF(QPointF(0,0),QSize(size-1,size-1)),5,5);
painter.end();
pixmap = pixmap.scaled(ava_size,Qt::IgnoreAspectRatio,Qt::SmoothTransformation);
pixmap.setAlphaChannel(alpha);
m_item_icons[column] = QIcon(pixmap);
}
return;
}
if (column==0)
m_current_status_icon=icon;
m_item_icons[column] = icon;
}
}
QPixmap SIconPool::loadIcon(
const QString &fileName,
const QSize &size,
Qt::AspectRatioMode mode,
const QColor &color)
{
QPixmap pm;
// SVG? Use QSvgRenderer
if (fileName.endsWith(".svg")) {
QSvgRenderer *renderer = getSvgRenderer(fileName);
if (renderer->isValid()) {
QSize renderSize = renderer->defaultSize();
// If given size is valid, scale default size to it using the given aspect ratio mode
if (size.isValid()) {
renderSize.scale(size, mode);
// If only one dimension is valid, scale other dimension keeping the aspect ratio
} else if (size.height() > 0) {
Qt::AspectRatioMode scaleMode = size.height() > renderSize.height()
? Qt::KeepAspectRatioByExpanding
: Qt::KeepAspectRatio;
renderSize.scale(renderSize.width(), size.height(), scaleMode);
} else if (size.width() > 0) {
Qt::AspectRatioMode scaleMode = size.width() > renderSize.width()
? Qt::KeepAspectRatioByExpanding
: Qt::KeepAspectRatio;
renderSize.scale(size.width(), renderSize.height(), scaleMode);
}
// Otherwise (-1,-1) was given as size, leave renderSize as icon's default size
pm = QPixmap(renderSize);
pm.fill(QColor(0, 0, 0, 0));
QPainter painter(&pm);
renderer->render(&painter, QRectF(QPointF(), renderSize));
}
} else {
// Otherwise load with QPixmap
pm.load(fileName);
if (!pm.isNull()) {
pm = pm.scaled(size, mode, Qt::SmoothTransformation);
}
}
if (!pm.isNull() && color.isValid()) {
// Colorize the icon
QPixmap mask = pm.alphaChannel();
pm.fill(color);
pm.setAlphaChannel(mask);
}
#ifdef Q_DEBUG_ICON
if (pm.isNull()) {
qDebug() << "Fail to load icon: " << filename;
}
#endif
return pm;
}
//-----------------------------------------------------------------------------
//! Set the alpha channel of a given pixmap to enable a faded / grayed out effect
//-----------------------------------------------------------------------------
void tThrusterPopup::SetAlpha(QPixmap& px, int val)
{
QPixmap alpha = px;
QPainter painter(&alpha);
painter.fillRect(alpha.rect(), QColor(val, val, val));
painter.end();
px.setAlphaChannel(alpha);
}
void MachineSplash::setPreview(const QString previewLocation)
{
if(!previewLocation.isEmpty())
previewLoc = previewLocation;
QPixmap preview = QPixmap(previewLoc);
preview.setAlphaChannel(alpha.scaled(preview.width(),preview.height()));
previewImage->setPixmap(preview);
doResize();
}
void RatingWidget::applyFading(QPixmap& pix)
{
if (hasFading() && d->fadingValue < 255)
{
QPixmap alphaMask(pix.width(), pix.height());
const QColor color(d->fadingValue, d->fadingValue, d->fadingValue);
alphaMask.fill(color);
pix.setAlphaChannel(alphaMask);
}
}
void DraggableLabel::dragPixmap()
{
const QPixmap *currentPixmap = pixmap();
if (currentPixmap == NULL)
return;
// Make temp file
QTemporaryFile *tempFile = new QTemporaryFile(AppTools::addPathSeparator(QDir::tempPath()) + DRAG_LABEL_FILENAME_TEMPLATE);
tempFile->setAutoRemove(false);
if (!tempFile->open())
{
delete tempFile;
return;
}
// Arrange data
QMimeData *data = new QMimeData;
data->setImageData(currentPixmap->toImage());
// Save pixmap
QString tempFileName = tempFile->fileName();
currentPixmap->save(tempFileName);
delete tempFile;
QDEBUG("Dragged file saved to " << tempFileName);
// Keep its name
QList <QUrl> urls;
urls.append(QUrl::fromLocalFile(tempFileName));
data->setUrls(urls);
QPixmap preview = currentPixmap->scaled(DRAG_LABEL_PREVIEW_WIDTH, DRAG_LABEL_PREVIEW_HEIGHT, Qt::KeepAspectRatio);
QPixmap preview2(preview.width(), preview.height());
preview2.fill(QColor(180, 180, 180));
preview.setAlphaChannel(preview2);
// Go drag
QDrag *drag = new QDrag(this);
drag->setPixmap(preview);
drag->setMimeData(data);
drag->setHotSpot(QPoint(preview.width() / 2, preview.height() / 2));
// Let's go!
drag->exec(Qt::MoveAction);
}
void CaMifIconEngine::getPixmapFromBitmap(const QSize &size, QPixmap& pixmap)
{
if (!mBitmapCached || !mMaskBitmapCached) {
TRAP_IGNORE(cacheBitmapL());
}
if (mBitmapCached && mMaskBitmapCached) {
CFbsBitmap *bitmap = mBitmapCached;
CFbsBitmap *maskBitmap = mMaskBitmapCached;
AknIconUtils::SetSize(bitmap, TSize(size.width(), size.height()),
EAspectRatioPreservedAndUnusedSpaceRemoved);
pixmap = pixmap.fromSymbianCFbsBitmap(bitmap);
QPixmap mask;
mask = mask.fromSymbianCFbsBitmap(maskBitmap);
pixmap.setAlphaChannel(mask);
}
}
void QTlenRosterManager::showRoster()
{
for(int i = 0; i < addedItems.count(); i++)
{
//all the items should be painted, not emulated by widgets
if (rosterBox->itemWidget(addedItems[i].item, 0))
rosterBox->itemWidget(addedItems[i].item, 0)->deleteLater();
}
rosterBox->clear();
qSort( rosterItems.begin(), rosterItems.end() );
addedItems.clear();
addedGroups.clear();
AddedItem i;
QTreeWidgetItem *node;
for ( int n = 0; n < (int)rosterItems.count(); n++ )
{
appendGroup(rosterItems[n].group);
if (!dontShowOfflines || rosterItems[n].presence != Offline)
{
int group_index = getIndexOfGroup(rosterItems[n].group);
if(group_index != -1)
node = addedGroups[group_index].item;
else
{
node = rosterBox->addRosterNode(rosterItems[n].group);
AddedGroup g;
g.item = node;
g.group = rosterItems[n].group;
addedGroups.append(g);
}
QPixmap tmpAvatar = QPixmap(rosterItems[n].avatar);
if(!tmpAvatar.isNull())
tmpAvatar.setAlphaChannel(avMask);
i.item = rosterBox->addRosterItem(rosterItems[n].name,
rosterItems[n].presence,
rosterItems[n].desc,
rosterItems[n].jid,
tmpAvatar,
node);
i.jid = rosterItems[n].jid;
addedItems.append(i);
}
}
}
void UBTabDockPalette::paintEvent(QPaintEvent *)
{
int nTabs = dock->mTabWidgets.size();
if (nTabs <= 0) {
qDebug() << "not enough tabs";
return;
}
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(Qt::NoPen);
painter.setBrush(dock->mBackgroundBrush);
int yFrom = 0;
for (int i = 0; i < nTabs; i++) {
UBDockPaletteWidget* pCrntWidget = dock->mTabWidgets.at(i);
QPainterPath path;
path.setFillRule(Qt::WindingFill);
QPixmap iconPixmap;
switch (dock->mOrientation) {
case eUBDockOrientation_Left:
path.addRect(0, yFrom, width() / 2, TABSIZE);
path.addRoundedRect(0, yFrom, width(), TABSIZE, dock->radius(), dock->radius());
if (pCrntWidget) {
if(dock->mCollapseWidth >= dock->width()) {
// Get the collapsed icon
iconPixmap = pCrntWidget->iconToRight();
} else {
// Get the expanded icon
iconPixmap = pCrntWidget->iconToLeft();
}
}
break;
case eUBDockOrientation_Right:
path.addRect(width() /2, yFrom, width() / 2, TABSIZE);
path.addRoundedRect(0, yFrom, width(), TABSIZE, dock->radius(), dock->radius());
if (pCrntWidget) {
if(dock->mCollapseWidth >= dock->width()) {
// Get the collapsed icon
iconPixmap = pCrntWidget->iconToLeft();
} else {
// Get the expanded icon
iconPixmap = pCrntWidget->iconToRight();
}
}
break;
case eUBDockOrientation_Top: ;
case eUBDockOrientation_Bottom: ;
default:
break;
}
painter.save();
QPixmap transparencyPix(":/images/tab_mask.png");
if (dock->mCurrentTab != i) {
iconPixmap.setAlphaChannel(transparencyPix);
QColor color(0x7F, 0x7F, 0x7F, 0x3F);
painter.setBrush(QBrush(color));
}
painter.drawPath(path);
painter.drawPixmap(2, yFrom + 2, width() - 4, TABSIZE - 4, iconPixmap);
yFrom += (TABSIZE + dock->tabSpacing());
painter.restore();
}
}
