void MainWindow::loadCursors()
{
cursorList << Qt::ArrowCursor;
QPixmap cursorCrossPic;
cursorCrossPic.load((cursorDir+QString("cursorCross.bmp")), "BMP", Qt::MonoOnly);
cursorCrossPic.setMask(QBitmap(cursorCrossPic));
QCursor cursorCross(cursorCrossPic, 15,15);
cursorList << cursorCross;
QPixmap cursorDownPic;
cursorDownPic.load((cursorDir+QString("cursorDown.bmp")), "BMP", Qt::MonoOnly);
cursorDownPic.setMask(QBitmap(cursorDownPic));
QCursor cursorDown(cursorDownPic, 15,31);
cursorList << cursorDown;
QPixmap cursorLeftPic;
cursorLeftPic.load((cursorDir+QString("cursorLeft.bmp")), "BMP", Qt::MonoOnly);
cursorLeftPic.setMask(QBitmap(cursorLeftPic));
QCursor cursorLeft(cursorLeftPic, 0,15);
cursorList << cursorLeft;
QPixmap cursorRightPic;
cursorRightPic.load((cursorDir+QString("cursorRight.bmp")), "BMP", Qt::MonoOnly);
cursorRightPic.setMask(QBitmap(cursorRightPic));
QCursor cursorRight(cursorRightPic, 31,15);
cursorList << cursorRight;
cursorList+=cursorList;
roundNum = 1;
}
CursorWindow::CursorWindow(const QImage &img, QPoint hot, QWidget* sk)
:QWidget(0),
m_view(0), skin(sk),
hotspot(hot)
{
setWindowFlags( Qt::FramelessWindowHint );
mouseRecipient = 0;
setMouseTracking(true);
#ifndef QT_NO_CURSOR
setCursor(Qt::BlankCursor);
#endif
QPixmap p;
p = QPixmap::fromImage(img);
if (!p.mask()) {
if ( img.hasAlphaChannel() ) {
QBitmap bm;
bm = QPixmap::fromImage(img.createAlphaMask());
p.setMask( bm );
} else {
QBitmap bm;
bm = QPixmap::fromImage(img.createHeuristicMask());
p.setMask( bm );
}
}
QPalette palette;
palette.setBrush(backgroundRole(), QBrush(p));
setPalette(palette);
setFixedSize( p.size() );
if ( !p.mask().isNull() )
setMask( p.mask() );
}
/*!
\brief Paint event
Repaint the grabbed pixmap on its current position and
fill the empty spaces by the background of the parent widget.
\param event Paint event
*/
void QwtPanner::paintEvent( QPaintEvent *event )
{
int dx = d_data->pos.x() - d_data->initialPos.x();
int dy = d_data->pos.y() - d_data->initialPos.y();
QRectF r;
r.setSize( d_data->pixmap.size() / QwtPainter::devicePixelRatio( &d_data->pixmap ) );
r.moveCenter( QPointF( r.center().x() + dx, r.center().y() + dy ) );
QPixmap pm = QwtPainter::backingStore( this, size() );
QwtPainter::fillPixmap( parentWidget(), pm );
QPainter painter( &pm );
if ( !d_data->contentsMask.isNull() )
{
QPixmap masked = d_data->pixmap;
masked.setMask( d_data->contentsMask );
painter.drawPixmap( r.toRect(), masked );
}
else
{
painter.drawPixmap( r.toRect(), d_data->pixmap );
}
painter.end();
if ( !d_data->contentsMask.isNull() )
pm.setMask( d_data->contentsMask );
painter.begin( this );
painter.setClipRegion( event->region() );
painter.drawPixmap( 0, 0, pm );
}
QPixmap BitmapFactoryInst::resize(int w, int h, const QPixmap& p, Qt::BGMode bgmode) const
{
if (bgmode == Qt::TransparentMode) {
if (p.width() == 0 || p.height() == 0)
w = 1;
QPixmap pix = p;
int x = pix.width () > w ? 0 : (w - pix.width ())/2;
int y = pix.height() > h ? 0 : (h - pix.height())/2;
if (x == 0 && y == 0)
return pix;
QPixmap pm (w,h);
QBitmap mask (w,h);
mask.fill(Qt::color0);
QBitmap bm = pix.mask();
if (!bm.isNull())
{
QPainter painter(&mask);
painter.drawPixmap(QPoint(x, y), bm, QRect(0, 0, pix.width(), pix.height()));
pm.setMask(mask);
}
else
{
pm.setMask(mask);
pm = fillRect(x, y, pix.width(), pix.height(), pm, Qt::OpaqueMode);
}
QPainter pt;
pt.begin( &pm );
pt.drawPixmap(x, y, pix);
pt.end();
return pm;
} else { // Qt::OpaqueMode
QPixmap pix = p;
if (pix.width() == 0 || pix.height() == 0)
return pix; // do not resize a null pixmap
QPalette pal = qApp->palette();
QColor dl = pal.color(QPalette::Disabled, QPalette::Light);
QColor dt = pal.color(QPalette::Disabled, QPalette::Text);
QPixmap pm = pix;
pm = QPixmap(w,h);
pm.fill(dl);
QPainter pt;
pt.begin( &pm );
pt.setPen( dl );
pt.drawPixmap(1, 1, pix);
pt.setPen( dt );
pt.drawPixmap(0, 0, pix);
pt.end();
return pm;
}
}
void mainWindow::addWidgetToViewer( QPixmap p, bool isNewPic)
{
if( isNewPic)
for( int i = viewer->count()-1; i >= 0; i--)
viewer->removeTab( i);
if( viewer->count() > 0)
{
QPixmap output( p.width(), p.height());
output.fill(Qt::transparent);
QPainter painter( &output);
//Setting the mask for the output Image
QBitmap mask = p.createMaskFromColor(Qt::MaskInColor);
QPixmap tempImage = monitorWidget->image->copy( monitorWidget->image->rect());
tempImage.setMask(mask);
painter.drawPixmap(0, 0, tempImage);
painter.drawPixmap(p.width(), 0 , p);
QPixmap *image = new QPixmap(output);
QWidget *w = new QWidget(0);
QLabel *l = new QLabel( w);
l->setPixmap( *image);
viewer->addTab( w, QString("ForeGround %1").arg(viewer->count()));
}
else
{
monitorWidget->setFixedSize( p.size());
viewer->addTab( monitorWidget, "Original");
}
}
void QGraphicsImportItem::updateKeyColor(QPointF pos)
{
QColor keycolor = QColor(pixmap().toImage().pixel(pos.toPoint()));
QPixmap pix = QPixmap(m_original_pix);
pix.setMask(m_original_pix.createMaskFromColor(keycolor));
this->setPixmap(pix);
}
bool CWizAttachmentListView::itemExtraImage(const QModelIndex& index, const QRect& itemBound, QRect& rcImage, QPixmap& extraPix) const
{
if (const CWizAttachmentListViewItem* item = attachmentItemFromIndex(index))
{
QString strIcoPath;
CWizDatabase& db = m_dbMgr.db(item->attachment().strKbGUID);
MainWindow* mainWindow = qobject_cast<MainWindow *>(Core::ICore::mainWindow());
if (!db.IsAttachmentDownloaded(item->attachment().strGUID))
{
strIcoPath = ::WizGetSkinResourcePath(mainWindow->userSettings().skin()) + "downloading.bmp";
}
else if (db.IsAttachmentModified(item->attachment().strGUID))
{
strIcoPath = ::WizGetSkinResourcePath(mainWindow->userSettings().skin()) + "uploading.bmp";
}
else
return false;
QPixmap fullPix(strIcoPath);
extraPix = fullPix.copy(0, 0, fullPix.height(), fullPix.height());
extraPix.setMask(extraPix.createMaskFromColor(Qt::black, Qt::MaskInColor));
int nMargin = -1;
rcImage.setLeft(itemBound.right() - extraPix.width() - nMargin);
rcImage.setTop(itemBound.bottom() - extraPix.height() - nMargin);
rcImage.setSize(extraPix.size());
return true;
}
return false;
}
QList<QIcon> CUnitSync::getModSideIcons(const QString& name) const
{
int index = Mods.indexOf(name);
if(index < 0)
return QList<QIcon>();
QList<QIcon> list;
m_AddAllArchives(m_GetPrimaryModArchive(index));
int sideCount = m_GetSideCount();
for(int j = 0; j < sideCount; j++)
{
int F = m_OpenFileVFS(QString("SidePics/%1.bmp").arg(QString(m_GetSideName(j))).toAscii().data());
if(F)
{
qint64 size = m_FileSizeVFS(F);
char *data = new char[size];
m_ReadFileVFS(F, data, size);
QPixmap pixmap;
pixmap.loadFromData((uchar *)data, size, "BMP");
pixmap.setMask(pixmap.createHeuristicMask());
delete data;
list.append(QIcon(pixmap));
m_CloseFileVFS(F);
}
else
list.append(QIcon(":/icons/unknown.png"));
}
return list;
}
/*!
\brief Paint event
Repaint the grabbed pixmap on its current position and
fill the empty spaces by the background of the parent widget.
\param pe Paint event
*/
void QwtPanner::paintEvent( QPaintEvent *pe )
{
int dx = d_data->pos.x() - d_data->initialPos.x();
int dy = d_data->pos.y() - d_data->initialPos.y();
QRect r( 0, 0, d_data->pixmap.width(), d_data->pixmap.height() );
r.moveCenter( QPoint( r.center().x() + dx, r.center().y() + dy ) );
QPixmap pm( size() );
QwtPainter::fillPixmap( parentWidget(), pm );
QPainter painter( &pm );
if ( !d_data->contentsMask.isNull() )
{
QPixmap masked = d_data->pixmap;
masked.setMask( d_data->contentsMask );
painter.drawPixmap( r, masked );
}
else
{
painter.drawPixmap( r, d_data->pixmap );
}
painter.end();
if ( !d_data->contentsMask.isNull() )
pm.setMask( d_data->contentsMask );
painter.begin( this );
painter.setClipRegion( pe->region() );
painter.drawPixmap( 0, 0, pm );
}
void wxQtDCImpl::DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
bool useMask )
{
QPixmap pix = *bmp.GetHandle();
if (pix.depth() == 1) {
//Monochrome bitmap, draw using text fore/background
//Save pen/brush
QBrush savedBrush = m_qtPainter->background();
QPen savedPen = m_qtPainter->pen();
//Use text colors
m_qtPainter->setBackground(QBrush(m_textBackgroundColour.GetQColor()));
m_qtPainter->setPen(QPen(m_textForegroundColour.GetQColor()));
//Draw
m_qtPainter->drawPixmap(x, y, pix);
//Restore saved settings
m_qtPainter->setBackground(savedBrush);
m_qtPainter->setPen(savedPen);
}
else
{
if ( useMask && bmp.GetMask() && bmp.GetMask()->GetHandle() )
pix.setMask(*bmp.GetMask()->GetHandle());
m_qtPainter->drawPixmap(x, y, pix);
}
}
void wxQtDCImpl::SetBrush(const wxBrush& brush)
{
m_brush = brush;
if (brush.GetStyle() == wxBRUSHSTYLE_STIPPLE_MASK_OPAQUE)
{
// Use a monochrome mask: use foreground color for the mask
QBrush b(brush.GetHandle());
b.setColor(m_textForegroundColour.GetHandle());
b.setTexture(b.texture().mask());
m_qtPainter->setBrush(b);
}
else if (brush.GetStyle() == wxBRUSHSTYLE_STIPPLE)
{
//Don't use the mask
QBrush b(brush.GetHandle());
QPixmap p = b.texture();
p.setMask(QBitmap());
b.setTexture(p);
m_qtPainter->setBrush(b);
}
else
{
m_qtPainter->setBrush(brush.GetHandle());
}
ApplyRasterColourOp();
}
/**
* Load this tileset from the given tileset \a image. This will replace
* existing tile images in this tileset with new ones. If the new image
* contains more tiles than exist in the tileset new tiles will be
* appended, if there are fewer tiles the excess images will be blanked.
*
* The tile width and height of this tileset must be higher than 0.
*
* @param image the image to load the tiles from
* @param fileName the file name of the image, which will be remembered
* as the image source of this tileset.
* @return <code>true</code> if loading was successful, otherwise
* returns <code>false</code>
*/
bool Tileset::loadFromImage(const QImage &image,
const QString &fileName)
{
mImageReference.source = fileName;
if (image.isNull()) {
mImageReference.loaded = false;
return false;
}
const QSize tileSize = this->tileSize();
const int margin = this->margin();
const int spacing = this->tileSpacing();
Q_ASSERT(tileSize.width() > 0 && tileSize.height() > 0);
const int stopWidth = image.width() - tileSize.width();
const int stopHeight = image.height() - tileSize.height();
int tileNum = 0;
for (int y = margin; y <= stopHeight; y += tileSize.height() + spacing) {
for (int x = margin; x <= stopWidth; x += tileSize.width() + spacing) {
const QImage tileImage = image.copy(x, y, tileSize.width(), tileSize.height());
QPixmap tilePixmap = QPixmap::fromImage(tileImage);
const QColor &transparent = mImageReference.transparentColor;
if (transparent.isValid()) {
const QImage mask = tileImage.createMaskFromColor(transparent.rgb());
tilePixmap.setMask(QBitmap::fromImage(mask));
}
auto it = mTiles.find(tileNum);
if (it != mTiles.end())
it.value()->setImage(tilePixmap);
else
mTiles.insert(tileNum, new Tile(tilePixmap, tileNum, this));
++tileNum;
}
}
// Blank out any remaining tiles to avoid confusion (todo: could be more clear)
for (Tile *tile : mTiles) {
if (tile->id() >= tileNum) {
QPixmap tilePixmap = QPixmap(tileSize);
tilePixmap.fill();
tile->setImage(tilePixmap);
}
}
mNextTileId = std::max(mNextTileId, tileNum);
mImageReference.size = image.size();
mColumnCount = columnCountForWidth(mImageReference.size.width());
mImageReference.loaded = true;
return true;
}
void KJSeeker::paint(QPainter *p, const QRect &)
{
closest();
QPixmap *pixmap = toPixmap(g);
pixmap->setMask(barModeMask);
bitBlt(p->device(), rect().topLeft().x(), rect().topLeft().y(),
pixmap, 0, 0, rect().width(), rect().height(), Qt::CopyROP);
}
QPixmap UGrabCursorMouse::compileIcon(QPixmap p1Top, QPixmap p2Top, QPixmap p2Bottom)
{
QPixmap result = p1Top;
const QBitmap bitmap = p2Top;
result.setMask(bitmap);
drawTop(result, p2Bottom);
return result;
}
void BackgroundWidget::paintEvent( QPaintEvent *e )
{
if ( !b_withart )
{
/* we just want background autofill */
QWidget::paintEvent( e );
return;
}
int i_maxwidth, i_maxheight;
QPixmap pixmap = QPixmap( pixmapUrl );
QPainter painter(this);
QBitmap pMask;
float f_alpha = 1.0;
i_maxwidth = __MIN( maximumWidth(), width() ) - MARGIN * 2;
i_maxheight = __MIN( maximumHeight(), height() ) - MARGIN * 2;
painter.setOpacity( property( "opacity" ).toFloat() );
if ( height() > MARGIN * 2 )
{
/* Scale down the pixmap if the widget is too small */
if( pixmap.width() > i_maxwidth || pixmap.height() > i_maxheight )
{
pixmap = pixmap.scaled( i_maxwidth, i_maxheight,
Qt::KeepAspectRatio, Qt::SmoothTransformation );
}
else
if ( b_expandPixmap &&
pixmap.width() < width() && pixmap.height() < height() )
{
/* Scale up the pixmap to fill widget's size */
f_alpha = ( (float) pixmap.height() / (float) height() );
pixmap = pixmap.scaled(
width() - MARGIN * 2,
height() - MARGIN * 2,
Qt::KeepAspectRatio,
( f_alpha < .2 )? /* Don't waste cpu when not visible */
Qt::SmoothTransformation:
Qt::FastTransformation
);
/* Non agressive alpha compositing when sizing up */
pMask = QBitmap( pixmap.width(), pixmap.height() );
pMask.fill( QColor::fromRgbF( 1.0, 1.0, 1.0, f_alpha ) );
pixmap.setMask( pMask );
}
painter.drawPixmap(
MARGIN + ( i_maxwidth - pixmap.width() ) /2,
MARGIN + ( i_maxheight - pixmap.height() ) /2,
pixmap);
}
QWidget::paintEvent( e );
}
TransparentSprite(
const int width, const int height,
const int r = 255,
const int g = 255,
const int b = 255)
: angle(GetRandomUniform() * 2.0 * boost::math::constants::pi<double>()), //Random direction
speed(2.0),
maxx(0),
maxy(0)
{
QImage i(width,height,QImage::Format_ARGB32);
const QColor transparency_color = QColor(0,0,0,255);
const double r_real = static_cast<double>(r);
const double g_real = static_cast<double>(g);
const double b_real = static_cast<double>(b);
const double midx = static_cast<double>(width ) / 2.0;
const double midy = static_cast<double>(height) / 2.0;
const double ray = std::min(midx,midy);
for (int y=0;y!=height;++y)
{
const double y_real = static_cast<double>(y);
const double dy = midy - y_real;
const double dy2 = dy * dy;
for (int x=0;x!=width;++x)
{
const double x_real = static_cast<double>(x);
const double dx = midx - x_real;
const double dx2 = dx * dx;
const double dist = std::sqrt(dx2 + dy2);
if (dist < ray)
{
const QColor c(
(1.0 - (dist / ray)) * r_real,
(1.0 - (dist / ray)) * g_real,
(1.0 - (dist / ray)) * b_real
);
i.setPixel(x,y,c.rgb());
}
else
{
i.setPixel(x,y,transparency_color.rgb());
}
}
}
this->setPixmap(this->pixmap().fromImage(i));
//Add transparancy
QPixmap pixmap = this->pixmap();
const QBitmap mask = pixmap.createMaskFromColor(transparency_color);
pixmap.setMask(mask);
this->setPixmap(pixmap);
}
QPixmap MusicUtils::UWidget::pixmapToRound(const QPixmap &src, const QRect &rect, int ratioX, int ratioY)
{
if(src.isNull())
{
return QPixmap();
}
QPixmap image = src.scaled(rect.size());
image.setMask( getBitmapMask(rect, ratioX, ratioY) );
return image;
}
/**
* Load this tileset from the given tileset \a image. This will replace
* existing tile images in this tileset with new ones. If the new image
* contains more tiles than exist in the tileset new tiles will be
* appended, if there are fewer tiles the excess images will be blanked.
*
* The tile width and height of this tileset must be higher than 0.
*
* @param image the image to load the tiles from
* @param fileName the file name of the image, which will be remembered
* as the image source of this tileset.
* @return <code>true</code> if loading was successful, otherwise
* returns <code>false</code>
*/
bool Tileset::loadFromImage(const QImage &image,
const QString &fileName)
{
const QSize tileSize = this->tileSize();
const int margin = this->margin();
const int spacing = this->tileSpacing();
Q_ASSERT(tileSize.width() > 0 && tileSize.height() > 0);
if (image.isNull())
return false;
const int stopWidth = image.width() - tileSize.width();
const int stopHeight = image.height() - tileSize.height();
int oldTilesetSize = tileCount();
int tileNum = 0;
for (int y = margin; y <= stopHeight; y += tileSize.height() + spacing) {
for (int x = margin; x <= stopWidth; x += tileSize.width() + spacing) {
const QImage tileImage = image.copy(x, y, tileSize.width(), tileSize.height());
QPixmap tilePixmap = QPixmap::fromImage(tileImage);
if (mTransparentColor.isValid()) {
const QImage mask =
tileImage.createMaskFromColor(mTransparentColor.rgb());
tilePixmap.setMask(QBitmap::fromImage(mask));
}
if (tileNum < oldTilesetSize) {
mTiles.at(tileNum)->setImage(tilePixmap);
} else {
mTiles.append(new Tile(tilePixmap, tileNum, this));
}
++tileNum;
}
}
// Blank out any remaining tiles to avoid confusion
while (tileNum < oldTilesetSize) {
QPixmap tilePixmap = QPixmap(tileSize);
tilePixmap.fill();
mTiles.at(tileNum)->setImage(tilePixmap);
++tileNum;
}
mImageWidth = image.width();
mImageHeight = image.height();
mColumnCount = columnCountForWidth(mImageWidth);
mImageSource = fileName;
return true;
}
void DefaultDockIcon::updateConfig()
{
myFortyEight = Config::General::instance()->defaultIconFortyEight();
QPixmap* pic = new QPixmap(myFortyEight ? back48_xpm : back64_xpm);
QBitmap bmp = QBitmap(QPixmap(myFortyEight ? mask48_xpm : mask64_xpm));
pic->setMask(bmp);
myIcon->setFace(pic);
delete pic;
updateStatusIcon();
updateIconMessages(myNewMsg, mySysMsg);
}
kpToolWidgetSpraycanSize::kpToolWidgetSpraycanSize (QWidget *parent, const char *name)
: kpToolWidgetBase (parent, name)
{
#if DEBUG_KP_TOOL_WIDGET_SPRAYCAN_SIZE
kdDebug () << "kpToolWidgetSpraycanSize::kpToolWidgetSpraycanSize() CALLED!" << endl;
#endif
for (int i = 0; i < int (sizeof (spraycanSizes) / sizeof (spraycanSizes [0])); i++)
{
int s = spraycanSizes [i];
QString iconName = QString ("tool_spraycan_%1x%1").arg (s).arg(s);
#if DEBUG_KP_TOOL_WIDGET_SPRAYCAN_SIZE
kdDebug () << "\ticonName=" << iconName << endl;
#endif
QPixmap pixmap (s, s);
pixmap.fill (Qt::white);
QPainter painter (&pixmap);
painter.drawPixmap (0, 0, UserIcon (iconName));
painter.end ();
QImage image = kpPixmapFX::convertToImage (pixmap);
QBitmap mask (pixmap.width (), pixmap.height ());
mask.fill (Qt::color0);
painter.begin (&mask);
painter.setPen (Qt::color1);
for (int y = 0; y < image.height (); y++)
{
for (int x = 0; x < image.width (); x++)
{
if ((image.pixel (x, y) & RGB_MASK) == 0/*black*/)
painter.drawPoint (x, y); // mark as opaque
}
}
painter.end ();
pixmap.setMask (mask);
addOption (pixmap, i18n ("%1x%2").arg (s).arg (s)/*tooltip*/);
if (i == 1)
startNewOptionRow ();
}
finishConstruction (0, 0);
}
/*------------------------------------------------------------------*
* MODIFICATIONS *
* Date Description Author *
* =========== ================================== =============== *
* *
*------------------------------------------------------------------*/
void ZUtils::MaskWidget(QWidget* pWidget, const QString& pImage)
{
QPixmap vPix;
QBitmap vBitmap;
QImage vImg(QImage::fromMimeSource(pImage));
vPix.convertFromImage(vImg);
if (!vPix.mask())
{
if (vImg.hasAlphaBuffer())
{
vBitmap = vImg.createAlphaMask();
vPix.setMask(vBitmap);
}
else
{
vBitmap = vImg.createHeuristicMask();
vPix.setMask(vBitmap);
}
}
if (vPix.mask())
pWidget->setMask(*vPix.mask());
}
/*------------------------------------------------------------------*
* MODIFICATIONS *
* Date Description Author *
* =========== ================================== =============== *
* *
*------------------------------------------------------------------*/
void ZPushButton::MaskButton(const QPixmap *pPix)
{
QPixmap vPix;
QBitmap vBitMask;
QImage vImg(pPix->convertToImage());
vPix = *pPix;
if (!vPix.mask())
{
if (vImg.hasAlphaBuffer())
{
vBitMask = vImg.createAlphaMask();
vPix.setMask(vBitMask);
}
else
{
vBitMask = vImg.createHeuristicMask();
vPix.setMask(vBitMask);
}
}
if (vPix.mask())
setMask(*vPix.mask());
}
bool Tileset::loadFromImage(const QString &fileName)
{
Q_ASSERT(mTileWidth > 0 && mTileHeight > 0);
const QImage image(fileName);
if (image.isNull())
return false;
mTileSetHeight = image.height();
mTileSetWidth = image.width();
const int stopWidth = image.width() - mTileWidth;
const int stopHeight = image.height() - mTileHeight;
int oldTilesetSize = mTiles.size();
int tileNum = 0;
for (int y = mMargin; y <= stopHeight; y += mTileHeight + mTileSpacing) {
for (int x = mMargin; x <= stopWidth; x += mTileWidth + mTileSpacing) {
const QImage tileImage = image.copy(x, y, mTileWidth, mTileHeight);
QPixmap tilePixmap = QPixmap::fromImage(tileImage);
if (mTransparentColor.isValid()) {
const QImage mask =
tileImage.createMaskFromColor(mTransparentColor.rgb());
tilePixmap.setMask(QBitmap::fromImage(mask));
}
if (tileNum < oldTilesetSize) {
mTiles.at(tileNum)->setImage(tilePixmap);
} else {
mTiles.append(new Tile(tilePixmap, tileNum, this));
}
++tileNum;
}
}
// Blank out any remaining tiles to avoid confusion
while (tileNum < oldTilesetSize) {
QPixmap tilePixmap = QPixmap(mTileWidth, mTileHeight);
tilePixmap.fill();
mTiles.at(tileNum)->setImage(tilePixmap);
++tileNum;
}
mColumnCount = (image.width() - mMargin * 2 + mTileSpacing)
/ (mTileWidth + mTileSpacing);
mImageSource = fileName;
return true;
}
void Database_Terrain::on_bSetFG_clicked()
{
ImageBrowser *imageBrowser = new ImageBrowser();
imageBrowser->setupBrowser("/backgrounds", ImageBrowser::BlockGIF|ImageBrowser::BlockJPEG|ImageBrowser::BlockPBM|ImageBrowser::BlockPCX|ImageBrowser::BlockPGM|ImageBrowser::BlockPNM|ImageBrowser::BlockTGA|ImageBrowser::BlockTIFF, QList<QSize>() << QSize(640, 480));
if (imageBrowser->exec())
{
QString fileLocation = imageBrowser->getFileLocation();
QPixmap pixmap = QPixmap(fileLocation).scaled(400, 300);
pixmap.setMask(pixmap.createMaskFromColor(QColor(255, 0, 255), Qt::MaskInColor));
bgPreview_FGImageItem->setPixmap(pixmap);
gvBGPreview->setEnabled(true);
(*terrainRef)->setFGImageLocation(fileLocation);
}
delete imageBrowser;
}
QPixmap * QTHelpers::createPixmap(const QString &filename)
{
QString id = QString("T") + filename;
if( m_Pixmaps.find( id ) != m_Pixmaps.end() )
return m_Pixmaps[id];
QPixmap * pixmap = new QPixmap( filename );
QImage image = pixmap->toImage();
QColor transpColor = image.pixel(0,0);
pixmap->setMask( pixmap->createMaskFromColor( transpColor ) );
m_Pixmaps[id]=pixmap;
return pixmap;
}
QPixmap * RazorDeskIconBase::initialPainting(QIcon::Mode mode)
{
qDebug() << "RazorDeskIconBase::initialPainting";
if (icon().isNull())
{
qDebug() << "RazorDeskIconBase::setPos - icon() is null. Skipping for now.";
return 0;
}
QPixmap * pm = new QPixmap(70, 70);
pm->fill(QColor(0,0,0,0));
QPainter painter(pm);
painter.setRenderHint(QPainter::Antialiasing);
painter.setRenderHint(QPainter::HighQualityAntialiasing);
painter.setRenderHint(QPainter::NonCosmeticDefaultPen);
// now the icon
QPixmap appIcon = icon().pixmap(iconSize(), mode);
// HACK: in some cases we can get larger icon than expected so rescale
// it with brute force if it's required...
if (appIcon.size().width() > iconSize().width())
appIcon = appIcon.scaled(iconSize(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
QRect source(0, 0, 32, 32);
int w = pm->width() / 2;
int h = pm->height() / 2;
int iw = iconSize().width() / 2;
int ih = iconSize().height() / 2;
QRect target(w - iw, h - ih - 10,
iconSize().width(), iconSize().height());
painter.drawPixmap(target, appIcon, source);
// text now - it has to follow potential QSS
QColor txt = palette().color(QPalette::WindowText);
painter.setPen(txt);
painter.setBrush(palette().color(QPalette::Window));
painter.drawText(QRectF(2, h+ih-10, pm->width()-4, pm->height()-h-ih+10),
Qt::AlignCenter | Qt::TextWordWrap | Qt::TextIncludeTrailingSpaces | Qt::TextDontClip,
text());
painter.end();
pm->setMask(pm->createHeuristicMask());
setMask(pm->mask());
return pm;
}
QPixmap NetworkSetup::devicePixmap( void ) {
QPixmap pm = NSResources->getPixmap(
getToplevel()->nextNode()->pixmapName()+"-large");
QPixmap Mini = NSResources->getPixmap(
device()->netNode()->pixmapName() );
if( pm.isNull() || Mini.isNull() )
return Resource::loadPixmap("Unknown");
QPainter painter( &pm );
painter.drawPixmap( pm.width()-Mini.width(),
pm.height()-Mini.height(),
Mini );
pm.setMask( pm.createHeuristicMask( TRUE ) );
return pm;
}
QPixmap IqAmeSymbolGraphicsItem::symbolPixmap(int number, bool selected)
{
if (!selected) {
if (m_symbolPixmaps.contains(number))
return m_symbolPixmaps[number];
m_symbolPixmaps[number] = QPixmap(QString("://symbols/%0.png").arg(number));
return m_symbolPixmaps[number];
}
if (m_selectedSymbolPixmaps.contains(number))
return m_selectedSymbolPixmaps[number];
QPixmap oldPixmap = symbolPixmap(number);
QPixmap newPixmap (oldPixmap.size());
newPixmap.fill(Qt::blue);
newPixmap.setMask(oldPixmap.createMaskFromColor(Qt::transparent));
m_selectedSymbolPixmaps[number] = newPixmap;
return m_selectedSymbolPixmaps[number];
}
// ===== WindowPixmap() =====
QPixmap LX11::WindowPixmap(WId win){
//Use the _NET_WM_ICON value instead of the WMHints pixmaps
// - the pixmaps are very unstable and erratic
QPixmap pix;
Display *disp = QX11Info::display();
Atom type;
Atom SA = XInternAtom(disp, "_NET_WM_ICON", false);
int format;
unsigned long num, bytes;
unsigned char *data = 0;
int status = XGetWindowProperty( disp, win, SA, XA_CARDINAL, ~(0L), false, AnyPropertyType,
&type, &format, &num, &bytes, &data);
if(status != 0 && data != 0){
//Now convert it into a Qt image
// - first 2 elements are width and height
// - data in rows from left to right and top to bottom
QImage image(data[0], data[1], QImage::Format_ARGB32); //initial setup
for(int i=0; i<image.byteCount()/4; ++i){
((uint*)image.bits())[i] = data[i+2]; //remember the first 2 element offset
}
pix = QPixmap::fromImage(image); //Now convert it into the pixmap
XFree(data);
}
if(pix.isNull()){
//Fall back on the old method
XWMHints *hints = XGetWMHints(QX11Info::display(), win);
if(hints != 0){
if( hints->flags & IconWindowHint ){
pix = QPixmap::grabWindow( hints->icon_window );
}
else if( hints->flags & IconPixmapHint ){
pix = QPixmap::fromX11Pixmap( hints->icon_pixmap ) ;
}
if( hints->flags & IconMaskHint ){
pix.setMask( QPixmap::fromX11Pixmap(hints->icon_mask).createHeuristicMask() );
}
XFree(hints);
}
}
return pix;
}
QPixmap BitmapFactoryInst::fillRect(int x, int y, int w, int h, const QPixmap& p, Qt::BGMode bgmode) const
{
QBitmap b = p.mask();
if (b.isNull())
return p; // sorry, but cannot do anything
QPixmap pix = p;
// modify the mask
QPainter pt;
pt.begin(&b);
if (bgmode == Qt::OpaqueMode)
pt.fillRect(x, y, w, h, Qt::color1); // make opaque
else // Qt::TransparentMode
pt.fillRect(x, y, w, h, Qt::color0); // make transparent
pt.end();
pix.setMask(b);
return pix;
}
