HCURSOR QWindowsCursor::createPixmapCursor(const QPixmap &pixmap, int hotX, int hotY)
{
HCURSOR cur = 0;
QBitmap mask = pixmap.mask();
if (mask.isNull()) {
mask = QBitmap(pixmap.size());
mask.fill(Qt::color1);
}
HBITMAP ic = qt_pixmapToWinHBITMAP(pixmap, /* HBitmapAlpha */ 2);
const HBITMAP im = qt_createIconMask(mask);
ICONINFO ii;
ii.fIcon = 0;
ii.xHotspot = hotX;
ii.yHotspot = hotY;
ii.hbmMask = im;
ii.hbmColor = ic;
cur = CreateIconIndirect(&ii);
DeleteObject(ic);
DeleteObject(im);
return cur;
}
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;
}
}
QRegion::QRegion( const QBitmap & bm )
{
data = new QRegionData;
Q_CHECK_PTR( data );
data->hgt = 0;
data->is_null = FALSE;
if ( bm.isNull() )
data->rgn = 0;
else
data->rgn = qt_pm_bitmapToRegion( bm );
}
void GLWidget::createCursors()
{
QBitmap pic = QBitmap(":/zoomIn.png");
if(pic.isNull())
{
ui.print("Warning: Null pic");
}
QBitmap mask = QBitmap(":/zoomIn-mask.png");
if(mask.isNull())
{
ui.print("Warning: Null mask");
}
zoomInCursor = QCursor( pic, mask);
QBitmap pic2 = QBitmap(":/zoomOut.png");
if(pic2.isNull())
{
ui.print("Warning: Null pic2");
}
zoomOutCursor = QCursor( pic2, mask);
}
void QShapedPixmapWindow::setPixmap(const QPixmap &pixmap)
{
m_pixmap = pixmap;
if (!m_useCompositing) {
const QBitmap mask = m_pixmap.mask();
if (!mask.isNull()) {
if (!handle())
create();
setMask(mask);
}
}
}
void QPixmap::setMask( const QBitmap &newmask )
{
const QPixmap *tmp = &newmask; // dec cxx bug
if ( (data == tmp->data) ||
( newmask.handle() && newmask.handle() == handle() ) ) {
QPixmap m = tmp->copy( TRUE );
setMask( *((QBitmap*)&m) );
data->selfmask = TRUE; // mask == pixmap
return;
}
if ( newmask.isNull() ) { // reset the mask
if (data->mask) {
detach();
data->selfmask = FALSE;
delete data->mask;
data->mask = 0;
}
return;
}
detach();
data->selfmask = FALSE;
if ( newmask.width() != width() || newmask.height() != height() ) {
#if defined(QT_CHECK_RANGE)
qWarning( "QPixmap::setMask: The pixmap and the mask must have "
"the same size" );
#endif
return;
}
#if defined(Q_WS_MAC) || (defined(Q_WS_X11) && !defined(QT_NO_XFTFREETYPE))
// when setting the mask, we get rid of the alpha channel completely
delete data->alphapm;
data->alphapm = 0;
#endif // Q_WS_X11 && !QT_NO_XFTFREETYPE
delete data->mask;
QBitmap* newmaskcopy;
if ( newmask.mask() )
newmaskcopy = (QBitmap*)new QPixmap( tmp->copy( TRUE ) );
else
newmaskcopy = new QBitmap( newmask );
#ifdef Q_WS_X11
newmaskcopy->x11SetScreen( x11Screen() );
#endif
data->mask = newmaskcopy;
}
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;
}
HICON QPixmap::toWinHICON() const
{
QBitmap maskBitmap = mask();
if (maskBitmap.isNull()) {
maskBitmap= QBitmap(size());
maskBitmap.fill(Qt::color1);
}
ICONINFO ii;
ii.fIcon = true;
ii.hbmMask = qt_createIconMask(maskBitmap);
ii.hbmColor = toWinHBITMAP(QPixmap::Alpha);
ii.xHotspot = 0;
ii.yHotspot = 0;
HICON hIcon = CreateIconIndirect(&ii);
DeleteObject(ii.hbmColor);
DeleteObject(ii.hbmMask);
return hIcon;
}
// public virtual [base kpCommand]
void kpToolAutoCropCommand::unexecute ()
{
#if DEBUG_KP_TOOL_AUTO_CROP && 1
kdDebug () << "kpToolAutoCropCommand::unexecute()" << endl;
#endif
kpDocument *doc = document ();
if (!doc)
return;
QPixmap pixmap (m_oldWidth, m_oldHeight);
QBitmap maskBitmap;
// restore the position of the centre image
kpPixmapFX::setPixmapAt (&pixmap, m_contentsRect,
*doc->pixmap (m_actOnSelection));
// draw the borders
QPainter painter (&pixmap);
QPainter maskPainter;
const kpToolAutoCropBorder *borders [] =
{
&m_leftBorder, &m_rightBorder,
&m_topBorder, &m_botBorder,
0
};
const QPixmap *pixmaps [] =
{
m_leftPixmap, m_rightPixmap,
m_topPixmap, m_botPixmap,
0
};
const QPixmap **p = pixmaps;
for (const kpToolAutoCropBorder **b = borders; *b; b++, p++)
{
if (!(*b)->exists ())
continue;
if ((*b)->isSingleColor ())
{
kpColor col = (*b)->referenceColor ();
#if DEBUG_KP_TOOL_AUTO_CROP && 1
kdDebug () << "\tdrawing border " << (*b)->rect ()
<< " rgb=" << (int *) col.toQRgb () /* %X hack */ << endl;
#endif
if (col.isOpaque ())
{
painter.fillRect ((*b)->rect (), col.toQColor ());
}
else
{
if (maskBitmap.isNull ())
{
// TODO: dangerous when a painter is active on pixmap?
maskBitmap = kpPixmapFX::getNonNullMask (pixmap);
maskPainter.begin (&maskBitmap);
}
maskPainter.fillRect ((*b)->rect (), Qt::color0/*transparent*/);
}
}
else
{
#if DEBUG_KP_TOOL_AUTO_CROP && 1
kdDebug () << "\trestoring border pixmap " << (*b)->rect () << endl;
#endif
// **p cannot contain a single transparent pixel because
// if it did, all other pixels must be transparent (only
// transparent pixels are similar to transparent pixels)
// and the other branch would execute.
if (*p)
{
// TODO: We should really edit the mask here. Due to good
// luck (if "maskBitmap" is initialized above, this region
// will be marked as opaque in the mask; if it's not
// initialized, we will be opaque by default), we
// don't actually have to edit the mask but this is
// highly error-prone.
painter.drawPixmap ((*b)->rect (), **p);
}
}
}
if (maskPainter.isActive ())
maskPainter.end ();
painter.end ();
if (!maskBitmap.isNull ())
pixmap.setMask (maskBitmap);
if (!m_actOnSelection)
doc->setPixmap (pixmap);
else
{
kpSelection sel = m_oldSelection;
sel.setPixmap (pixmap);
doc->setSelection (sel);
if (m_mainWindow->tool ())
m_mainWindow->tool ()->somethingBelowTheCursorChanged ();
}
deleteUndoPixmaps ();
}
static HCURSOR create32BitCursor(const QPixmap &pixmap, int hx, int hy)
{
HCURSOR cur = 0;
#if !defined(Q_WS_WINCE)
QBitmap mask = pixmap.mask();
if (mask.isNull()) {
mask = QBitmap(pixmap.size());
mask.fill(Qt::color1);
}
HBITMAP ic = pixmap.toWinHBITMAP(QPixmap::Alpha);
HBITMAP im = qt_createIconMask(mask);
ICONINFO ii;
ii.fIcon = 0;
ii.xHotspot = hx;
ii.yHotspot = hy;
ii.hbmMask = im;
ii.hbmColor = ic;
cur = CreateIconIndirect(&ii);
DeleteObject(ic);
DeleteObject(im);
#elif defined(GWES_ICONCURS)
QImage bbits, mbits;
bool invb, invm;
bbits = pixmap.toImage().convertToFormat(QImage::Format_Mono);
mbits = pixmap.toImage().convertToFormat(QImage::Format_Mono);
invb = bbits.colorCount() > 1 && qGray(bbits.color(0)) < qGray(bbits.color(1));
invm = mbits.colorCount() > 1 && qGray(mbits.color(0)) < qGray(mbits.color(1));
int sysW = GetSystemMetrics(SM_CXCURSOR);
int sysH = GetSystemMetrics(SM_CYCURSOR);
int sysN = qMax(1, sysW / 8);
int n = qMax(1, bbits.width() / 8);
int h = bbits.height();
uchar* xBits = new uchar[sysH * sysN];
uchar* xMask = new uchar[sysH * sysN];
int x = 0;
for (int i = 0; i < sysH; ++i) {
if (i >= h) {
memset(&xBits[x] , 255, sysN);
memset(&xMask[x] , 0, sysN);
x += sysN;
} else {
int fillWidth = n > sysN ? sysN : n;
uchar *bits = bbits.scanLine(i);
uchar *mask = mbits.scanLine(i);
for (int j = 0; j < fillWidth; ++j) {
uchar b = bits[j];
uchar m = mask[j];
if (invb)
b ^= 0xFF;
if (invm)
m ^= 0xFF;
xBits[x] = ~m;
xMask[x] = b ^ m;
++x;
}
for (int j = fillWidth; j < sysN; ++j ) {
xBits[x] = 255;
xMask[x] = 0;
++x;
}
}
}
cur = CreateCursor(qWinAppInst(), hx, hy, sysW, sysH,
xBits, xMask);
#else
Q_UNUSED(pixmap);
Q_UNUSED(hx);
Q_UNUSED(hy);
#endif
return cur;
}
bool kpFloodFill::fill ()
{
if (m_initState < 2 && !prepare ())
{
kdError () << "kpFloodFill:fill() could not prepare()!" << endl;
return false;
}
// not trying to do a NOP fill
if (m_boundingRect.isValid ())
{
QApplication::setOverrideCursor (Qt::waitCursor);
QPainter painter, maskPainter;
QBitmap maskBitmap;
if (m_pixmapPtr->mask () || m_color.isTransparent ())
{
maskBitmap = kpPixmapFX::getNonNullMask (*m_pixmapPtr);
maskPainter.begin (&maskBitmap);
maskPainter.setPen (m_color.maskColor ());
}
if (m_color.isOpaque ())
{
painter.begin (m_pixmapPtr);
painter.setPen (m_color.toQColor ());
}
const QValueList <FillLine>::ConstIterator fillLinesEnd = m_fillLines.end ();
for (QValueList <FillLine>::ConstIterator it = m_fillLines.begin ();
it != fillLinesEnd;
it++)
{
QPoint p1 = QPoint ((*it).m_x1, (*it).m_y);
QPoint p2 = QPoint ((*it).m_x2, (*it).m_y);
if (painter.isActive ())
painter.drawLine (p1, p2);
if (maskPainter.isActive ())
maskPainter.drawLine (p1, p2);
}
if (painter.isActive ())
painter.end ();
if (maskPainter.isActive ())
maskPainter.end ();
if (!maskBitmap.isNull ())
m_pixmapPtr->setMask (maskBitmap);
QApplication::restoreOverrideCursor ();
}
else
{
#if DEBUG_KP_FLOOD_FILL && 1
kdDebug () << "kpFloodFill::fill() performing NOP fill" << endl;
#endif
}
return true;
}
