QCursor KarbonCursor::crossHair()
{
static unsigned char cross_bits[] = {
0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00,
0x80, 0x00, 0xff, 0x7f, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00,
0x80, 0x00, 0x80, 0x00, 0x80, 0x00
};
QBitmap b = QBitmap::fromData(QSize(15, 15), cross_bits);
QBitmap m = b.createHeuristicMask(false);
return QCursor(b, m, 7, 7);
}
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);
}
QBitmap Slider::drawValue()
{
QFontMetrics fm(this->font());
QString st;
st.setNum(value,'f',precision);
QPainter painter;
int _x,_y;
QBitmap res;
if (orientation == 0) {
res.resize(width(),(height()-20)/2);
res.fill(Qt::color0);
painter.begin(&res);
painter.setPen(Qt::color1);
painter.setBrush(Qt::color1);
painter.setFont(this->font());
_x = (int)((res.width()-fm.width(st))/2);
_y = (int)(res.height());
painter.drawText(_x,_y,st);
}
else if (orientation == 1) {
res.resize((width()-20)/2,height());
res.fill(Qt::color0);
painter.begin(&res);
painter.setPen(Qt::color1);
painter.setBrush(Qt::color1);
painter.setFont(this->font());
_x = 0;
_y = (int)((res.height()+fm.height())/2);
painter.drawText(_x,_y,st);
}
painter.end();
return res;
}
void VlcPrimitiveBackgroundWidget::paintEvent(QPaintEvent *e)
{
int i_maxwidth, i_maxheight;
QPixmap pixmap = QPixmap(_path);
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 );
}
void tst_QPixmap::mask()
{
QFETCH(QSize, size);
QPixmap src = rasterPixmap(size);
src.fill(Qt::transparent);
{
QPainter p(&src);
p.drawLine(QPoint(0, 0), QPoint(src.width(), src.height()));
}
QBENCHMARK {
QBitmap bitmap = src.mask();
QVERIFY(bitmap.size() == src.size());
}
}
void OSDWidget::renderOSDText( const QString &text) {
static QBitmap mask;
// Set a sensible maximum size, don't cover the whole desktop or cross the screen
//Actually unused but it definitly should
//QSize max = QApplication::desktop() ->screen( m_screen ) ->size() - QSize( MARGIN*2 + 20, 100 );
if(this->m_srt!=0){
delete m_srt;
}
this->m_srt=new QSimpleRichText(text,this->font(),this->m_context);
// The title cannnot be taller than one line
// AlignAuto = align Arabic to the right, etc.
int w=this->m_srt->widthUsed();
int h=this->m_srt->height();
osdBuffer.resize(w,h);
mask.resize(w,h);
// Start painting!
QPainter bufferPainter( &osdBuffer );
QPainter maskPainter( &mask );
// Draw backing rectangle
//bufferPainter.save();
bufferPainter.setPen( Qt::black );
bufferPainter.setBrush( backgroundColor() );
bufferPainter.drawRoundRect( 0,0,w,h, 1500 /w, 1500/h);
//bufferPainter.restore();
this->m_srt->draw(&bufferPainter,0,0,QRect(),this->colorGroup());
// Masking for transparency
mask.fill( Qt::black );
maskPainter.setBrush( Qt::white );
maskPainter.drawRoundRect(0,0,w,h, 1500/w,1500/h);
setMask( mask );
//do last to reduce noticeable change when showing multiple OSDs in succession
reposition(QSize(w,h));
m_currentText = text;
m_dirty = false;
if(this->m_linking&&this==this->mouseGrabber()){
this->releaseMouse();
this->m_linking=false;
}
update();
}
/*!
\internal
A static function for reading the sprite files containing
pixmaps for displaying animated elements seen in the game.
*/
void KSprite::loadSprites()
{
QString sprites_prefix = IMG_BACKGROUND;
int sep = sprites_prefix.lastIndexOf("/");
sprites_prefix.truncate(sep);
int i = 0;
QString file_name;
QString base = sprites_prefix + '/';
while (animations_[i].id_) {
QList<QPixmap> p;
if (animations_[i].frames_) {
for (int j=0; j<animations_[i].frames_; ++j) {
QString s(animations_[i].path_);
file_name = base + s.arg(j,4,10,QLatin1Char('0'));
QPixmap pixmap(file_name);
p.insert(j,pixmap);
}
}
else {
file_name = base + QString(animations_[i].path_);
QPixmap pixmap(file_name);
p.insert(0,pixmap);
}
QList<Frame> frameshape;
for (int f = 0; f < p.size(); ++f) {
QPixmap pixmap = p.at(f);
Frame frame;
frame.pixmap = pixmap;
QPainterPath path;
QBitmap m = pixmap.mask();
if (m.width())
path.addRegion(QRegion(m));
else
path.addRegion(QRect(pixmap.rect()));
frame.shape = path;
frame.boundingRect = path.controlPointRect();
frameshape << frame;
}
shapemap_.insert(animations_[i].id_,frameshape);
i++;
}
spritesLoaded_ = true;
}
void PixmapEditor::setValue(const QBitmap &aValue)
{
mValue=QPixmap::fromImage(aValue.toImage());
ui->valueEdit->setText(bitmapToString(aValue));
setIcon(iconForPixmap(mValue));
mDataType=BITMAP;
}
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);
}
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 QPixmap::resize( int w, int h )
{
if ( w < 1 || h < 1 ) { // becomes null
QPixmap pm( 0, 0, 0, data->bitmap, data->optim );
*this = pm;
return;
}
int d;
if ( depth() > 0 )
d = depth();
else
d = isQBitmap() ? 1 : -1;
// Create new pixmap
QPixmap pm( w, h, d, data->bitmap, data->optim );
#ifdef Q_WS_X11
pm.x11SetScreen( x11Screen() );
#endif // Q_WS_X11
if ( !data->uninit && !isNull() ) // has existing pixmap
bitBlt( &pm, 0, 0, this, 0, 0, // copy old pixmap
QMIN(width(), w),
QMIN(height(),h), CopyROP, TRUE );
#if defined(Q_WS_MAC)
if(data->alphapm) {
data->alphapm->resize(w, h);
} else
#elif defined(Q_WS_X11) && !defined(QT_NO_XFTFREETYPE)
if (data->alphapm)
qWarning("QPixmap::resize: TODO: resize alpha data");
else
#endif // Q_WS_X11
if ( data->mask ) { // resize mask as well
if ( data->selfmask ) { // preserve self-mask
pm.setMask( *((QBitmap*)&pm) );
} else { // independent mask
QBitmap m = *data->mask;
m.resize( w, h );
pm.setMask( m );
}
}
*this = pm;
}
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;
}
static PyObject *meth_QBitmap_clear(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
QBitmap *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QBitmap, &sipCpp))
{
sipCpp->clear();
Py_INCREF(Py_None);
return Py_None;
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QBitmap, sipName_clear, doc_QBitmap_clear);
return NULL;
}
void QCursor::setBitmap( const QBitmap &bitmap, const QBitmap &mask,
int hotX, int hotY )
{
if ( !initialized )
initialize();
if ( bitmap.depth() != 1 || mask.depth() != 1 ||
bitmap.size() != mask.size() ) {
#if defined(QT_CHECK_NULL)
qWarning( "QCursor: Cannot create bitmap cursor; invalid bitmap(s)" );
#endif
QCursor *c = &cursorTable[arrowCursorIdx];
c->data->ref();
data = c->data;
return;
}
data = new QCursorData;
Q_CHECK_PTR( data );
data->bm = new QBitmap( bitmap );
data->bmm = new QBitmap( mask );
data->cshape = BitmapCursor;
data->id = nextCursorId++;
data->hx = hotX >= 0 ? hotX : bitmap.width()/2;
data->hy = hotY >= 0 ? hotY : bitmap.height()/2;
QPaintDevice::qwsDisplay()->defineCursor(data->id, *data->bm,
*data->bmm, data->hx, data->hy);
}
void QCursor::setBitmap( const QBitmap &bitmap, const QBitmap &mask,
int hotX, int hotY )
{
if ( !initialized )
initialize();
if ( bitmap.depth() != 1 || mask.depth() != 1 ||
bitmap.size() != mask.size() ) {
#if defined(QT_CHECK_NULL)
qWarning( "QCursor: Cannot create bitmap cursor; invalid bitmap(s)" );
#endif
QCursor *c = &cursorTable[arrowCursorIdx];
c->data->ref();
data = c->data;
return;
}
data = new QCursorData;
Q_CHECK_PTR( data );
data->bm = new QBitmap( bitmap );
data->bmm = new QBitmap( mask );
data->hcurs = 0;
data->cshape = BitmapCursor;
data->hx = hotX >= 0 ? hotX : bitmap.width()/2;
data->hy = hotY >= 0 ? hotY : bitmap.height()/2;
data->fg.red = 0 << 8;
data->fg.green = 0 << 8;
data->fg.blue = 0 << 8;
data->bg.red = 255 << 8;
data->bg.green = 255 << 8;
data->bg.blue = 255 << 8;
update(); // Xcursor's backward compatibility hack needs the cursor to be created
// right after the bitmaps are created and filled with data
}
kpToolWidgetLineWidth::kpToolWidgetLineWidth (QWidget *parent, const char *name)
: kpToolWidgetBase (parent, name)
{
setInvertSelectedPixmap ();
int numLineWidths = sizeof (lineWidths) / sizeof (lineWidths [0]);
int w = (width () - 2/*margin*/) * 3 / 4;
int h = (height () - 2/*margin*/ - (numLineWidths - 1)/*spacing*/) * 3 / (numLineWidths * 4);
for (int i = 0; i < numLineWidths; i++)
{
QPixmap pixmap ((w <= 0 ? width () : w),
(h <= 0 ? height () : h));
pixmap.fill (Qt::white);
QBitmap maskBitmap (pixmap.width (), pixmap.height ());
maskBitmap.fill (Qt::color0/*transparent*/);
QPainter painter (&pixmap), maskPainter (&maskBitmap);
painter.setPen (Qt::black), maskPainter.setPen (Qt::color1/*opaque*/);
painter.setBrush (Qt::black), maskPainter.setBrush (Qt::color1/*opaque*/);
QRect rect = QRect (0, (pixmap.height () - lineWidths [i]) / 2,
pixmap.width (), lineWidths [i]);
painter.drawRect (rect), maskPainter.drawRect (rect);
painter.end (), maskPainter.end ();
pixmap.setMask (maskBitmap);
addOption (pixmap, QString::number (lineWidths [i]));
startNewOptionRow ();
}
finishConstruction (0, 0);
}
//-------------------------------------------------------
void Terrain::createCrossCursor ()
{
//---------------------------------------------------
// Define new cross cursor, more visible
//---------------------------------------------------
/* * B=1 and M=1 gives black.
* B=0 and M=1 gives white.
* B=0 and M=0 gives transparent.
* B=1 and M=0 gives an XOR'd result.*/
QBitmap *crossBits = new QBitmap(32,32);
QBitmap *crossMask = new QBitmap(32,32);
crossBits->clear();
crossMask->clear();
QPainter pb (crossBits);
QPainter pm (crossMask);
QPen pen1(Qt::color1);
pen1.setWidth(1);
pb.setPen(pen1);
pb.drawLine(6,16, 26,16);
pb.drawLine(16,6, 16,26);
pm.setPen(pen1);
// black
pm.drawLine(6,16, 26,16);
pm.drawLine(16,6, 16,26);
// white
pm.drawLine(6,15, 26,15);
pm.drawLine(6,17, 26,17);
pm.drawLine(15,6, 15,26);
pm.drawLine(17,6, 17,26);
pb.end();
pm.end();
myCrossCursor = QCursor(*crossBits, *crossMask);
int v = 180;
selectColor = QColor(v,v,v);
setCursor(myCrossCursor);
}
QCursor KarbonCursor::horzMove()
{
/*
#define horzMove_width 15
#define horzMove_height 15
static unsigned char horzMove_bits[] = {
0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x90, 0x04,
0x98, 0x0c, 0xfc, 0x1f, 0x98, 0x0c, 0x90, 0x04, 0x80, 0x00, 0x80, 0x00,
0x80, 0x00, 0x80, 0x00, 0x00, 0x00};
*/
#define horzMove_width 15
#define horzMove_height 15
static unsigned char horzMove_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08,
0x0c, 0x18, 0xfe, 0x3f, 0x0c, 0x18, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
QBitmap b = QBitmap::fromData( QSize(15, 15), horzMove_bits );
QBitmap m = b.createHeuristicMask( false );
return QCursor( b, m, 7, 7 );
}
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;
}
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;
}
HBITMAP qt_createIconMask(const QBitmap &bitmap)
{
QImage bm = bitmap.toImage().convertToFormat(QImage::Format_Mono);
int w = bm.width();
int h = bm.height();
int bpl = ((w+15)/16)*2; // bpl, 16 bit alignment
uchar *bits = new uchar[bpl*h];
bm.invertPixels();
for (int y=0; y<h; y++)
memcpy(bits+y*bpl, bm.scanLine(y), bpl);
HBITMAP hbm = CreateBitmap(w, h, 1, 1, bits);
delete [] bits;
return hbm;
}
KDEFX_EXPORT void kColorBitmaps(QPainter *p, const QColorGroup &g, int x, int y, int w,
int h, bool isXBitmaps, const uchar *lightColor,
const uchar *midColor, const uchar *midlightColor,
const uchar *darkColor, const uchar *blackColor,
const uchar *whiteColor)
{
const uchar *data[]={lightColor, midColor, midlightColor, darkColor,
blackColor, whiteColor};
QColor colors[]={g.light(), g.mid(), g.midlight(), g.dark(),
Qt::black, Qt::white};
int i;
QBitmap b;
for(i=0; i < 6; ++i){
if(data[i]){
b = QBitmap(w, h, data[i], isXBitmaps);
b.setMask(b);
p->setPen(colors[i]);
p->drawPixmap(x, y, b);
}
}
}
//!
//! Constructor of the ParameterTypeIcon class.
//!
//! \param color The color for the parameter type icon.
//!
ParameterTypeIcon::ParameterTypeIcon ( const QColor &color )
{
m_color = color;
const QRect pinRect (0, 4, 15, 8);
const QColor penColor (109, 109, 109);
QPixmap normalPixmap (16, 16);
QPainter painter;
if (painter.begin(&normalPixmap)) {
// get the background color from the application style's standard palette
QColor backgroundColor = QApplication::style()->standardPalette().color(QPalette::Base);
// fill the pixmap with the background color
painter.fillRect(normalPixmap.rect(), QBrush(backgroundColor));
// draw the pin rect into the pixmap
painter.setPen(QPen(penColor));
painter.setBrush(QBrush(m_color));
painter.drawRoundRect(pinRect);
// end painting the pixmap
if (painter.end()) {
// create a bitmap for masking the pixmap
QBitmap maskBitmap (normalPixmap.size());
if (painter.begin(&maskBitmap)) {
// fill the bitmap with white (meaning transparent)
painter.fillRect(maskBitmap.rect(), QBrush(QColor(Qt::white)));
// draw the pin rect as black (meaning opaque)
painter.setPen(QPen(QColor(Qt::black)));
painter.setBrush(QBrush(QColor(Qt::black)));
painter.drawRoundRect(pinRect);
// end painting the bitmap and set it as mask for the pixmap
if (painter.end())
normalPixmap.setMask(maskBitmap);
}
}
}
// add the pixmap to the icon
addPixmap(normalPixmap);
}
//-----------------------------------------------------------------------------
bool KBusyPtr :: loadBitmap (QBitmap& bm, const QString& filename)
{
QString f;
bool rc;
if (filename[0]=='/' || filename[0]=='.')
{
f = filename;
}
else
{
f = app->kde_datadir().copy();
f += "/kmail/pics/";
f += filename;
}
rc = bm.load(f);
if (!rc) printf ("ERROR: cannot load bitmap %s\n", f.data());
return rc;
}
QBitmap basicSegmentation::xand(QBitmap am, QBitmap bm) {
int x, y, ap, bp;
QImage a = am.toImage();
QImage b = bm.toImage();
QImage r = QImage(am.width(), am.height(), QImage::Format_Mono);
for(x=0; x < am.width(); x++) {
for(y=0;y < am.height(); y++) {
ap=qRed(a.pixel(x,y));
bp=qRed(b.pixel(x,y));
if(ap == 0 && bp == 0){
r.setPixel(x, y, Qt::color0);
} else {
r.setPixel(x, y, Qt::color1);
}
}
}
return(QBitmap::fromImage(r));
}
QBitmap basicSegmentation::erode(QBitmap mm, int count) {
int x, y, p, p1, p2, p3, p4, n;
QImage m = mm.toImage();
p=qRed(m.pixel(1,1));
for(n=0; n < count; n++) {
QImage gm = QImage(m.width(), m.height(), QImage::Format_Mono);
for(x=0; x < m.width(); x++) {
gm.setPixel(x, 0, Qt::color1);
gm.setPixel(x, m.width()-1, Qt::color1);
}
for(y=1;y < (m.height()-1); y++) {
gm.setPixel(0, y, Qt::color1);
gm.setPixel(m.height()-1, y, Qt::color1);
}
for(x=1; x < (m.width()-1); x++) {
for(y=1;y < (m.height()-1); y++) {
p=qRed(m.pixel(x,y));
if(p == 0){
p1 = qRed(m.pixel(x-1, y));
p2 = qRed(m.pixel(x+1, y));
p3 = qRed(m.pixel(x, y-1));
p4 = qRed(m.pixel(x, y+1));
if(p1 == 255 || p2 == 255 || p3 == 255 || p4 == 255) {
gm.setPixel(x,y, Qt::color1);
} else {
gm.setPixel(x,y, Qt::color0);
}
} else {
gm.setPixel(x,y, Qt::color1);
}
}
}
m = gm;
}
return(QBitmap::fromImage(m));
}
QBitmap QPixmap::createHeuristicMask( bool clipTight ) const
{
QBitmap m;
m.convertFromImage( convertToImage().createHeuristicMask(clipTight) );
return m;
}
void OSDWidget::renderOSDText( const QString &txt )
{
// Escaped text
QString text = Konversation::removeIrcMarkup(txt);
static QBitmap mask;
//This is various spacings and margins, based on the font to look "just right"
const uint METRIC = fontMetrics().width( 'x' );
// Set a sensible maximum size, don't cover the whole desktop or cross the screen
QSize max = QApplication::desktop()->screen( m_screen )->size() - QSize( MARGIN*2 + METRIC*2, 100 );
QFont titleFont( "Arial", 12, QFont::Bold );
QFontMetrics titleFm( titleFont );
// The title cannnot be taller than one line
// AlignAuto = align Arabic to the right, etc.
QRect titleRect = titleFm.boundingRect( 0, 0, max.width() - METRIC, titleFm.height(), AlignAuto, m_appName );
// The osd cannot be larger than the screen
QRect textRect = fontMetrics().boundingRect( 0, 0, max.width(), max.height(), AlignAuto | WordBreak, text );
if ( textRect.width() < titleRect.width() )
textRect.setWidth( titleRect.width() );
//this should still be within the screen bounds
textRect.addCoords( 0, 0, METRIC*2, titleRect.height() + METRIC );
osdBuffer.resize( textRect.size() );
mask.resize( textRect.size() );
// Start painting!
QPainter bufferPainter( &osdBuffer );
QPainter maskPainter( &mask );
// Draw backing rectangle
const uint xround = (METRIC * 200) / textRect.width();
const uint yround = (METRIC * 200) / textRect.height();
bufferPainter.setPen( Qt::black );
bufferPainter.setBrush( backgroundColor() );
bufferPainter.drawRoundRect( textRect, xround, yround );
bufferPainter.setFont( font() );
const uint w = textRect.width() - 1;
const uint h = textRect.height() - 1;
// Draw the text shadow
if ( m_shadow )
{
bufferPainter.setPen( backgroundColor().dark( 175 ) );
bufferPainter.drawText( METRIC + 3, (METRIC/2) + titleFm.height() + 1, w, h, AlignLeft | WordBreak, text );
}
// Draw the text
bufferPainter.setPen( foregroundColor() );
bufferPainter.drawText( METRIC, (METRIC/2) + titleFm.height() - 1, w, h, AlignLeft | WordBreak, text );
// Draw the title text
bufferPainter.setFont( titleFont );
bufferPainter.drawText( METRIC * 2, (METRIC/2), w, h, AlignLeft, m_appName );
// Masking for transparency
mask.fill( Qt::black );
maskPainter.setBrush( Qt::white );
maskPainter.drawRoundRect( textRect, xround, yround );
setMask( mask );
//do last to reduce noticeable change when showing multiple OSDs in succession
reposition( textRect.size() );
m_currentText = text;
m_dirty = false;
update();
}
QIntMatrix basicSegmentation::find(QBitmap mask, int minsize)
{
int y, x, a, l, t, eqI, eqTI, eqV, w, h, eqMaxI=1, newID = 2;
bool done;
QIntMatrix r(mask.width(), mask.height());
QImage im = mask.toImage();
QVector<int> u, eq, counts;
w = mask.width();
h = mask.height();
for(y = 0; y < h; y++) {
for(x = 0; x < w; x++) {
a = qRed(im.pixel(x, y));
if(a == 0) {
r.set(x, y, 1);
} else {
r.set(x, y, 0);
}
}
}
eq = QVector<int>(2);
counts = QVector<int>(2);
for(y = 1; y < (h - 1); y++) {
for(x = 1; x < (w - 1); x++) {
a = r.at(x, y-1);
l = r.at(x-1, y);
t = r.at(x, y);
if (t == 1) {
if (a == l && a > 1) {
r.set(x, y, a);
if(a > (counts.size()-1)) {
counts.resize(a+1);
}
counts[a]++;
} else if (a != l && a > 1 && l > 1) {
r.set(x, y, mathmin(a, l));
if(mathmin(a, l) > (counts.size()-1)) {
counts.resize(mathmin(a, l)+1);
}
counts[mathmin(a, l)]++;
eqI = mathmax(a,l);
eqV = mathmin(a,l);
done = false;
while (!done) {
if (eqI > eqMaxI) {
eq.resize(eqI+1);
eqMaxI = eqI;
}
if ((eq.at(eqI) > 1)) {
if (eqV != eq.at(eqI)) {
eqTI = eqI;
eqI = mathmax(eqV, eq.at(eqTI));
eqV = mathmin(eqV, eq.at(eqTI));
eq[eqTI] = eqV;
} else {
eq[eqI] = eqV;
done = true;
}
} else {
eq[eqI] = eqV;
done = true;
}
}
} else if (mathmax(a,l) > 1) {
r.set(x, y, mathmax(a, l));
if(mathmax(a, l) > (counts.size()-1)) {
counts.resize(mathmax(a, l)+1);
}
counts[mathmax(a, l)]++;
} else {
r.set(x, y, newID++);
counts.resize(newID+1);
counts[newID]=1;
}
} else {
r.set(x, y, 0);
}
}
}
//clean up edges
r.replace(1, 0);
//resolve equivalent ids
if(eqMaxI > 1)
{
resolveEq(&r, eq, counts, minsize);
}
return(r);
}
QCursor KarbonCursor::needleArrow()
{
static const unsigned char needle_bits[] = {
0x00, 0x00, 0x10, 0x00, 0x20, 0x00, 0x60, 0x00, 0xc0, 0x00, 0xc0, 0x01,
0x80, 0x03, 0x80, 0x07, 0x00, 0x0f, 0x00, 0x1f, 0x00, 0x3e, 0x00, 0x7e,
0x00, 0x7c, 0x00, 0x1c, 0x00, 0x18, 0x00, 0x00
};
QBitmap b = QBitmap::fromData(QSize(16, 16), needle_bits);
QBitmap m = b.createHeuristicMask(false);
return QCursor(b, m, 2, 0);
}
