QPixmap MainWindow::distortImg(QPixmap pixmap)
{
QImage pixmapImg = pixmap.toImage();
QPixmap pixmap2(pixmap.width(),pixmap.height());
QPainter painter2(&pixmap2);
// Distort text
for(int x = 0; x < pixmap.width(); x++){
for(int y = 0; y < pixmap.height(); y++){
qsrand(x);
float rand1 = qrand()%5;
qsrand(y);
float rand2 = qrand()%5;
float sinx = sin(x/10+1)*5;
float siny = qSin(y/10)*5;
int newx = x+rand1+sinx;
int newy = y+rand2+siny;
if(newx < pixmap.width() && newy < pixmap.height()){
if(rand1+rand2 > 1) {
painter2.setPen(pixmapImg.pixel(newx,newy));
} else {
painter2.setPen(Qt::green);
painter2.drawRect(x,y,10,10);
}
painter2.drawRect(x,y,1,1);
}
}
}
ui->label->setPixmap(pixmap2);
return pixmap2;
}
void PainterWidget::paintEvent(QPaintEvent * /* event */)
{
//QPainter painter(&image);
// setupPainter(painter);
// painter.drawPoint(QPoint(20,20));
QPainter painter2(this);
painter2.drawImage(QPoint(0, 0), image);
//painter2.drawPoint(QPoint(100,100));
float* datap = cutoffData;
for(int i = 0; i < 256; i++)
{
for(int j = 0; j < 256; j++)
{
QColor c = QColor(image.pixel(j,255-i));
datap[0] = float(c.red())/255.0f;
datap[1] = float(c.green())/255.f;
datap[2] = float(c.blue())/255.f;
datap[3] = 1.0f;
datap+=4;
}
}
emit imageChanged(cutoffData, 256, 256);
}
void PlaylistItemDelegate::createPlayIcon() {
playIcon = QPixmap(THUMB_WIDTH, THUMB_HEIGHT);
playIcon.fill(Qt::transparent);
QPixmap tempPixmap(THUMB_WIDTH, THUMB_HEIGHT);
tempPixmap.fill(Qt::transparent);
QPainter painter(&tempPixmap);
painter.setRenderHints(QPainter::Antialiasing, true);
const int hPadding = PADDING*6;
const int vPadding = PADDING*2;
QPolygon polygon;
polygon << QPoint(hPadding, vPadding)
<< QPoint(THUMB_WIDTH-hPadding, THUMB_HEIGHT/2)
<< QPoint(hPadding, THUMB_HEIGHT-vPadding);
painter.setBrush(Qt::white);
QPen pen;
pen.setColor(Qt::white);
pen.setWidth(PADDING);
pen.setJoinStyle(Qt::RoundJoin);
pen.setCapStyle(Qt::RoundCap);
painter.setPen(pen);
painter.drawPolygon(polygon);
painter.end();
QPainter painter2(&playIcon);
painter2.setOpacity(.75);
painter2.drawPixmap(0, 0, tempPixmap);
}
void OscilloscopeScreen::paintEvent(QPaintEvent *event)
{
QImage image = QImage ( this->width(), this->height(), QImage::Format_ARGB32 );
if ( core() )
{
image.fill(core()->bGColor()); // 填充背景色
QPainter painter (&image);
// 画刻度线
drawScaleLines(painter) ;
//qDebug()<<"刻度线画完";
// 画所有波的波形
for (int i=0;i<core()->channelsCount();i++)
{
if ( core()->channel(i)->show() )
{
drawWaveByTimeStamp(painter,i) ;
}
}
}
else
{
image.fill(qRgb(0,0,0)); // 填充黑色
}
QPainter painter2(this);
QRect rect(0,0,this->width(),this->height()); //创建绘图区域
painter2.drawImage(rect,image); //绘图，drawImage有很多重载函数，可根据自己的需要调用相应函数
}
void TextPreview::paintEvent(QPaintEvent */* event */)
{
QPixmap pix(320, 224);
QPainter painter(&pix);
/* Screen background */
painter.setBrush(Qt::black);
painter.drawRect(0, 0, 320, 224);
drawTextArea(&painter);
painter.end();
QPainter painter2(this);
if(!isEnabled()) {
QStyleOption opt;
opt.initFrom(this);
painter2.drawPixmap(0, 0, QWidget::style()->generatedIconPixmap(QIcon::Disabled, pix, &opt));
}
else {
painter2.drawPixmap(0, 0, pix);
}
painter2.end();
}
void PlaylistItemDelegate::createPlayIcon() {
qreal maxRatio = 2.0;
playIcon = QPixmap(thumbWidth * maxRatio, thumbHeight * maxRatio);
playIcon.setDevicePixelRatio(maxRatio);
playIcon.fill(Qt::transparent);
QPixmap tempPixmap(thumbWidth * maxRatio, thumbHeight * maxRatio);
tempPixmap.setDevicePixelRatio(maxRatio);
tempPixmap.fill(Qt::transparent);
QPainter painter(&tempPixmap);
painter.setRenderHints(QPainter::Antialiasing, true);
const int hPadding = padding * 6;
const int vPadding = padding * 2;
QPolygon polygon;
polygon << QPoint(hPadding, vPadding) << QPoint(thumbWidth - hPadding, thumbHeight / 2)
<< QPoint(hPadding, thumbHeight - vPadding);
painter.setBrush(Qt::white);
QPen pen;
pen.setColor(Qt::white);
pen.setWidth(padding);
pen.setJoinStyle(Qt::RoundJoin);
pen.setCapStyle(Qt::RoundCap);
painter.setPen(pen);
painter.drawPolygon(polygon);
painter.end();
QPainter painter2(&playIcon);
painter2.setOpacity(.75);
painter2.drawPixmap(0, 0, tempPixmap);
}
void SkinsWidget::paintEvent(QPaintEvent *) {
if(!is_change) {
//初始化皮肤对画框的皮肤
pSettings->beginGroup("skin");
skinName = pSettings->value("background").toString();
skinName = QString(":/skin/image/") + skinName;
pSettings->endGroup();
pSettings->sync();
}
QPainter painter(this);
painter.drawPixmap(rect(), QPixmap(skinName));
QPainter painter2(this);
QLinearGradient linear2(rect().topLeft(), rect().bottomLeft());
linear2.setColorAt(0, Qt::white);
linear2.setColorAt(0.5, Qt::white);
linear2.setColorAt(1, Qt::white);
painter2.setPen(Qt::white);
painter2.setBrush(linear2);
painter2.drawRect(QRect(0, 30, this->width(), this->height()-30));
QPainter painter3(this);
painter3.setPen(Qt::gray);
static const QPointF points[4] = {QPointF(0, 30), QPointF(0, this->height()-1), QPointF(this->width()-1, this->height()-1), QPointF(this->width()-1, 30)};
painter3.drawPolyline(points, 4);
}
void SettingDialog::paintEvent(QPaintEvent *)
{
QString skin_name;
bool is_read = Util::readInit(QString("./user.ini"), QString("skin"), skin_name);
if(is_read)
{
if(skin_name.isEmpty())
{
skin_name = QString(":/skin/17_big");
}
}
else
{
skin_name = QString(":/skin/17_big");
}
QPainter painter(this);
painter.drawPixmap(rect(), QPixmap(skin_name));
QPainter painter2(this);
QLinearGradient linear2(rect().topLeft(), rect().bottomLeft());
linear2.setColorAt(0, Qt::white);
linear2.setColorAt(0.5, Qt::white);
linear2.setColorAt(1, Qt::white);
painter2.setPen(Qt::white); //设定画笔颜色，到时侯就是边框颜色
painter2.setBrush(linear2);
painter2.drawRect(QRect(0, 60, this->width(), this->height()-60));
QPainter painter3(this);
painter3.setPen(Qt::gray);
static const QPointF points[4] = {QPointF(0, 60), QPointF(0, this->height()-1), QPointF(this->width()-1, this->height()-1), QPointF(this->width()-1, 60)};
painter3.drawPolyline(points, 4);
}
void PaintBoard::paintEvent( QPaintEvent * event ){
pix->fill(Qt::white);
QPainter painter2(pix);
if(lista!=0){ // Si el apuntador de lista es diferente de nulo
// Recorrer la lista y dibujar
lista->ir_a_inicio();
for (int i=0; i < lista->getCuantos(); i++){
Figura *temp = lista->recuperar();
temp->Dibujar(&painter2);
lista->siguiente();
}
/*qDebug()<<"CurrentFigura " << this->currentFigura << "cuantos :"
<< this->lista->getCuantos();
if (this->currentFigura > 0
&& this->currentFigura <= this->lista->getCuantos()){
// Dibujar el indicadord
//qDebug()<<"Entro";
QPen pen(Qt::gray, 3, Qt::DotLine, Qt::RoundCap, Qt::RoundJoin);
painter.setPen( pen);
painter.setBrush(Qt::green);
Figura *temp = lista->recuperar(this->currentFigura);
painter.drawEllipse(0,0,5,5);
painter.drawLine(0,0,temp->getX(),temp->getY());
}*/
}
QPainter painter(this);
painter.drawPixmap(0,0, *pix);
}
/**
* Handles paint events by redrawing the graphic in this view.
* usually that's very fast since we only paint the buffer we
* have from the last call..
*/
void QG_GraphicView::paintEvent(QPaintEvent *) {
RS_DEBUG->print("QG_GraphicView::paintEvent begin");
RS_SETTINGS->beginGroup("/Appearance");
bool draftMode = (bool)RS_SETTINGS->readNumEntry("/DraftMode", 0);
RS_SETTINGS->endGroup();
// Re-Create or get the layering pixmaps
PixmapLayer1=getPixmapForView(PixmapLayer1);
PixmapLayer2=getPixmapForView(PixmapLayer2);
PixmapLayer3=getPixmapForView(PixmapLayer3);
// Draw Layer 1
if (redrawMethod & RS2::RedrawGrid) {
PixmapLayer1->fill(background);
RS_PainterQt painter1(PixmapLayer1);
//painter1->setBackgroundMode(Qt::OpaqueMode);
//painter1->setBackgroundColor(background);
//painter1->eraseRect(0,0,getWidth(), getHeight());
drawLayer1((RS_Painter*)&painter1);
painter1.end();
}
if (redrawMethod & RS2::RedrawDrawing) {
// DRaw layer 2
PixmapLayer2->fill(Qt::transparent);
RS_PainterQt painter2(PixmapLayer2);
painter2.setDrawingMode(drawingMode);
setDraftMode(draftMode);
painter2.setDrawSelectedOnly(false);
drawLayer2((RS_Painter*)&painter2);
painter2.setDrawSelectedOnly(true);
drawLayer2((RS_Painter*)&painter2);
//removed to solve bug #3470573
// setDraftMode(false);
painter2.end();
}
if (redrawMethod & RS2::RedrawOverlay) {
PixmapLayer3->fill(Qt::transparent);
RS_PainterQt painter3(PixmapLayer3);
drawLayer3((RS_Painter*)&painter3);
painter3.end();
}
// Finally paint the layers back on the screen, bitblk to the rescue!
RS_PainterQt wPainter(this);
//wPainter.setCompositionMode(QPainter::CompositionMode_Screen);
wPainter.drawPixmap(0,0,*PixmapLayer1);
wPainter.drawPixmap(0,0,*PixmapLayer2);
wPainter.drawPixmap(0,0,*PixmapLayer3);
wPainter.end();
redrawMethod=RS2::RedrawNone;
RS_DEBUG->print("QG_GraphicView::paintEvent end");
}
/**
* Handles paint events by redrawing the graphic in this view.
* usually that's very fast since we only paint the buffer we
* have from the last call..
*/
void QG_GraphicView::paintEvent(QPaintEvent *)
{
// Re-Create or get the layering pixmaps
getPixmapForView(PixmapLayer1);
getPixmapForView(PixmapLayer2);
getPixmapForView(PixmapLayer3);
// Draw Layer 1
if (redrawMethod & RS2::RedrawGrid)
{
PixmapLayer1->fill(background);
RS_PainterQt painter1(PixmapLayer1.get());
drawLayer1((RS_Painter*)&painter1);
painter1.end();
}
if (redrawMethod & RS2::RedrawDrawing)
{
view_rect = LC_Rect(toGraph(0, 0),
toGraph(getWidth(), getHeight()));
// DRaw layer 2
PixmapLayer2->fill(Qt::transparent);
RS_PainterQt painter2(PixmapLayer2.get());
if (antialiasing)
{
painter2.setRenderHint(QPainter::Antialiasing);
}
painter2.setDrawingMode(drawingMode);
painter2.setDrawSelectedOnly(false);
drawLayer2((RS_Painter*)&painter2);
painter2.setDrawSelectedOnly(true);
drawLayer2((RS_Painter*)&painter2);
painter2.end();
}
if (redrawMethod & RS2::RedrawOverlay)
{
PixmapLayer3->fill(Qt::transparent);
RS_PainterQt painter3(PixmapLayer3.get());
if (antialiasing)
{
painter3.setRenderHint(QPainter::Antialiasing);
}
drawLayer3((RS_Painter*)&painter3);
painter3.end();
}
// Finally paint the layers back on the screen, bitblk to the rescue!
RS_PainterQt wPainter(this);
wPainter.drawPixmap(0,0,*PixmapLayer1);
wPainter.drawPixmap(0,0,*PixmapLayer2);
wPainter.drawPixmap(0,0,*PixmapLayer3);
wPainter.end();
redrawMethod=RS2::RedrawNone;
}
void CardContainer::_repaint() {
int card_width = G_COMMON_LAYOUT.m_cardNormalWidth;
int card_height = G_COMMON_LAYOUT.m_cardNormalHeight;
bool one_row = true;
const int blank = 3;
int width = (card_width + blank) * items.length() - blank + 50;
if (width * 1.5 > RoomSceneInstance->sceneRect().width()) {
width = (card_width + blank) * ((items.length() + 1) / 2) - blank + 50;
one_row = false;
}
int height = (one_row ? 1 : 2) * card_height + 70 + (one_row ? 0 : blank);
int middle_height = qMax(height - _m_background_top.height() - _m_background_bottom.height(), 0);
_m_boundingRect = QRectF(0, 0, width, _m_background_top.height() + middle_height + _m_background_bottom.height());
QPixmap pix(width, _m_background_top.height() + middle_height + _m_background_bottom.height());
pix.fill(QColor(0, 0, 0, 0));
QPainter painter(&pix);
painter.drawPixmap(0, 0, width, _m_background_top.height(), _m_background_top);
painter.drawPixmap(0, _m_background_top.height(), width, middle_height, _m_background_middle);
painter.drawPixmap(0, _m_background_top.height() + middle_height, width, _m_background_bottom.height(), _m_background_bottom);
_m_background = new QGraphicsPixmapItem(this);
_m_background->setTransformationMode(Qt::SmoothTransformation);
_m_background->setPixmap(pix);
_m_background->setParentItem(this);
int first_row = one_row ? items.length() : (items.length() + 1) / 2;
_m_background_seat = new QGraphicsPixmapItem(this);
_m_background_seat->setTransformationMode(Qt::SmoothTransformation);
QPixmap pixmap(width, _m_background_top.height() + middle_height + _m_background_bottom.height());
pixmap.fill(QColor(0, 0, 0, 0));
QPainter painter2(&pixmap);
for (int i = 0; i < items.length(); ++ i) {
int x, y = 0;
if (i < first_row) {
x = 25 + (card_width + blank) * i;
y = 45;
} else {
if (items.length() % 2 == 1)
x = 25 + card_width / 2 + blank / 2
+ (card_width + blank) * (i - first_row);
else
x = 25 + (card_width + blank) * (i - first_row);
y = 45 + card_height + blank;
}
painter2.drawPixmap(x, y, card_width, card_height, G_ROOM_SKIN.getPixmap(QSanRoomSkin::S_SKIN_KEY_CARD_CONTAINER_FRAME));
}
_m_background_seat->setPixmap(pixmap);
_m_background_seat->setParentItem(this);
_m_background_seat->setZValue(-999);
_m_background->setZValue(-1000);
close_button->setPos(width - 30, 0);
update();
}
//////////////////////////////////////////////////////////////////////
// Called to update spectrum data for displaying on the screen
//////////////////////////////////////////////////////////////////////
void CPlotter::draw()
{
int i;
int w;
int h;
QPoint LineBuf[MAX_SCREENSIZE];
if (!m_Running)
return;
//get/draw the waterfall
w = m_WaterfallPixmap.width();
h = m_WaterfallPixmap.height();
//move current data down one line(must do before attaching a QPainter object)
m_WaterfallPixmap.scroll(0,1,0,0, w, h);
QPainter painter1(&m_WaterfallPixmap);
//get scaled FFT data
GetScreenIntegerFFTData(255, w, m_MaxdB, m_MindB, -m_Span/2, m_Span/2, m_fftbuf);
//draw new line of fft data at top of waterfall bitmap
for(i=0; i<w; i++)
{
painter1.setPen(m_ColorTbl[ 255-m_fftbuf[i] ]);
painter1.drawPoint(i,0);
}
//get/draw the 2D spectrum
w = m_2DPixmap.width();
h = m_2DPixmap.height();
//first copy into 2Dbitmap the overlay bitmap.
m_2DPixmap = m_OverlayPixmap.copy(0,0,w,h);
QPainter painter2(&m_2DPixmap);
//get new scaled fft data
GetScreenIntegerFFTData(h, w, m_MaxdB, m_MindB, -m_Span/2, m_Span/2, m_fftbuf);
//draw the 2D spectrum
painter2.setPen(QColor(0x97,0xD0,0x97,0xFF));
for(i=0; i<w; i++)
{
LineBuf[i].setX(i);
LineBuf[i].setY(m_fftbuf[i]);
}
painter2.drawPolyline(LineBuf,w);
//trigger a new paintEvent
update();
}
QIcon patternDockWidget::createIcon(QRgb color,
const QPixmap& symbol) const {
QPixmap listImage(listIconSize());
listImage.fill(color);
QPainter painter(&listImage);
painter.drawPixmap(0, 0, symbol);
QPixmap iconPixmap(listIconSize() + QSize(0, 4));
iconPixmap.fill(Qt::white);
QPainter painter2(&iconPixmap);
painter2.drawPixmap(0, 2, listImage);
return QIcon(iconPixmap);
}
void LoginDialog::paintEvent(QPaintEvent*){
QBitmap objBitmap(size());
QPainter painter(&objBitmap);
painter.setBrush(QColor(0, 0, 0));
painter.drawRoundedRect(this->rect(), 10, 10);
setMask(objBitmap);
QPainter painter2(this);
QPen pen(Qt::green, 3, Qt::DashDotLine, Qt::RoundCap, Qt::RoundJoin);
painter2.setPen(pen);
QBrush brush(Qt::blue);
brush.setStyle(Qt::HorPattern);
painter2.setBrush(brush);
painter2.drawRect(0, 0, size().width() - 1, size().height() - 1);
}
void NewBlockWindow::paintEvent(QPaintEvent * event){
(void)event;
QPainter painter(this);
QColor c1;
int size_x = ui->widthSlider->value();
int size_y = ui->heightSlider->value();
if(size_x > ui->lblBlock->maximumWidth())
size_x = ui->lblBlock->maximumWidth();
if(size_y > ui->lblBlock->maximumHeight())
size_y = ui->lblBlock->maximumHeight();
if(size_x < ui->lblBlock->minimumWidth())
size_x = ui->lblBlock->minimumWidth();
if(size_y < ui->lblBlock->minimumHeight())
size_y = ui->lblBlock->minimumHeight();
QPixmap pixmap(size_x+3, size_y+3);
pixmap.fill(QColor("transparent"));
QPainter painter2(&pixmap);
if(ui->colourLineEdit->text().length() == 7)
c1.setNamedColor(ui->colourLineEdit->text());
else
c1.setNamedColor("#ffffff");
painter2.setBrush(QBrush(c1));
painter2.drawRect(0, 0,size_x, size_y);
painter2.drawText(3, 30, "("+QString::number(pos.x()) +", "
+ QString::number(pos.y()) + ")");
painter2.drawText(3, 15, "("+QString::number(ui->widthSlider->value())+", "+
QString::number(ui->heightSlider->value()) + ")");
ui->lblBlock->resize( size_x + 3, size_y + 3);
ui->lblBlock->setPixmap(pixmap);
if(ui->spatiallyEmbeddedCheckBox->isChecked()){
int i,j;
for(i=0; i<ui->spinBoxNeuronsX->value(); i++){
for(j=0; j<ui->spinBoxNeuronsY->value(); j++){
painter.drawEllipse(QPoint(SIZEX+10+i*10,550-j*10),3,3);
}
}
}
}
//////////////////////////////////////////////////////////////////////
// Called to update time domain data for displaying on the screen
//////////////////////////////////////////////////////////////////////
void CTestBench::DrawTimePlot()
{
int i;
int w;
int h;
QPoint LineBuf[TB_MAX_SCREENSIZE];
if(m_2DPixmap.isNull())
return;
if(m_NewDataIsCpx != m_CurrentDataIsCpx)
{
m_CurrentDataIsCpx = m_NewDataIsCpx;
}
//get/draw the 2D spectrum
w = m_2DPixmap.width();
h = m_2DPixmap.height();
//first copy into 2Dbitmap the overlay bitmap.
m_2DPixmap = m_OverlayPixmap.copy(0,0,w,h);
QPainter painter2(&m_2DPixmap);
//draw the time points
int c = h/2;
for(i=0; i<w; i++)
{
LineBuf[i].setX(i);
LineBuf[i].setY(c - (2*c*m_TimeScrnBuf1[i])/m_VertRange );
}
painter2.setPen( Qt::green );
painter2.drawPolyline(LineBuf,w);
if(m_CurrentDataIsCpx)
{
for(i=0; i<w; i++)
{
LineBuf[i].setX(i);
LineBuf[i].setY(c - (2*c*m_TimeScrnBuf2[i])/m_VertRange );
}
painter2.setPen( Qt::red );
painter2.drawPolyline(LineBuf,w);
}
//trigger a new paintEvent
update();
if( (TRIG_PSINGLE != m_TrigIndex) &&
(TRIG_NSINGLE != m_TrigIndex) )
{
m_TrigState = TRIGSTATE_WAIT;
}
}
void MultiGradientSelector::paintEvent(QPaintEvent * /* e */)
{
static QPixmap pixmap = QPixmap(size());
pixmap.fill(palette().window().color());
//calculate gradient area width
if (gradient_area_width_ == 0)
{
gradient_area_width_ = width() - 2 * margin_ - 2;
}
QPainter painter(&pixmap);
//gradient field outline
painter.setPen(QColor(0, 0, 0));
painter.drawRect(margin_, margin_, width() - 2 * margin_, height() - 2 * margin_ - lever_area_height_);
//draw gradient
for (Int i = 0; i <= gradient_area_width_; ++i)
{
painter.setPen(gradient_.interpolatedColorAt(i, 0, gradient_area_width_));
painter.drawLine(margin_ + 1 + i, margin_ + 1, margin_ + 1 + i, height() - margin_ - lever_area_height_ - 1);
}
//levers
painter.setPen(QColor(0, 0, 0));
for (UInt i = 0; i < (UInt)gradient_.size(); ++i)
{
Int pos = Int(float(gradient_.position(i)) / 100.0 * gradient_area_width_ + margin_ + 1);
painter.drawRect(pos - 4, height() - margin_ - lever_area_height_ + 5, 9, 9);
painter.drawLine(pos - 4, height() - margin_ - lever_area_height_ + 5, pos, height() - margin_ - lever_area_height_);
painter.drawLine(pos, height() - margin_ - lever_area_height_, pos + 4, height() - margin_ - lever_area_height_ + 5);
painter.fillRect(pos - 3, height() - margin_ - lever_area_height_ + 6, 8, 8, gradient_.color(i));
//selected lever
if (Int(gradient_.position(i)) == selected_)
{
painter.fillRect(pos - 2, height() - margin_ - lever_area_height_ + 3, 6, 3, QColor(0, 0, 0));
painter.fillRect(pos - 1, height() - margin_ - lever_area_height_ + 1, 4, 3, QColor(0, 0, 0));
}
}
QPainter painter2(this);
painter2.drawPixmap(0, 0, pixmap);
}
void SSTimeSeriesPlot::paintPlot(QPainter *painter) {
updateSize();
if ((width()!=d->m_image.width())||(height()!=d->m_image.height())) {
d->m_image_needs_update=true;
}
if (d->m_image_needs_update) {
d->m_image=QPixmap(width(),height());
d->m_image.fill(QColor(0,0,0,0));
QPainter painter2(&d->m_image);
d->m_plot_area.refresh(&painter2);
d->m_image_needs_update=false;
}
painter->drawPixmap(0,0,d->m_image);
}
void PainterWidget::updateBrush()
{
QRadialGradient g;
g.setCenter(brush_size/2, brush_size/2);
g.setFocalPoint(brush_size/2, brush_size/2);
g.setRadius(brush_size/2);
g.setColorAt(1.0, Qt::black);
g.setColorAt(0, QColor(100,100,100));
QImage mask(brush_size, brush_size,QImage::Format_RGB32);
mask.fill(qRgb(0,0,0));
QPainter painter2(&mask);
painter2.fillRect(mask.rect(), g);
painter2.end();
soft_brush = QImage(brush_size, brush_size,QImage::Format_RGB32);
soft_brush.fill(brush_color.rgb());
soft_brush.setAlphaChannel(mask);
}
void MyCardsPixmapLabel::paintEvent(QPaintEvent * event)
{
if (!(flipCardsAction1 || flipCardsAction2 || fadeOutAction)) {
QLabel::paintEvent(event);
}
if (fadeOutAction && !fastFlipCardsFront) {
QPainter painter(this);
painter.setOpacity(frameOpacity);
if(isFlipside)
painter.drawPixmap(0,0, flipside);
else
painter.drawPixmap(0,0, front);
}
if (flipCardsAction1) {
QPainter painter2(this);
QPointF center(flipside.width()/2.0, flipside.height()/2.0);
painter2.translate(center);
painter2.scale(frameFlipCardsAction1Size ,1);
painter2.translate(-center);
painter2.drawPixmap(0,0, flipside);
}
if (flipCardsAction2) {
QPainter painter3(this);
QPointF center(front.width()/2.0, front.height()/2.0);
painter3.translate(center);
painter3.scale(frameFlipCardsAction2Size ,1);
painter3.translate(-center);
painter3.drawPixmap(0,0, front);
}
if (fastFlipCardsFront && !flipCardsAction1 && !flipCardsAction2) {
if(objectName().contains("pixmapLabel_card0")) {
QPainter painter4(this);
if(fadeOutAction) {
painter4.setOpacity(0.25);
}
painter4.drawPixmap(0,0, myHiddenFront);
}
}
}
void MainGraphicsView::createLightingMap(unsigned char lighting_min) {
LOG("MainGraphicsView::createLightingMap(): lighting_min = %d\n", lighting_min);
this->darkness_alpha = (unsigned char)(255 - (int)lighting_min);
if( game_g->isLightingEnabled() )
{
const int res_c = 128;
QPixmap pixmap(res_c, res_c);
pixmap.fill(Qt::transparent);
QRadialGradient radialGrad((res_c-1)/2, (res_c-1)/2, (res_c-1)/2);
radialGrad.setColorAt(0.0, QColor(0, 0, 0, 0));
radialGrad.setColorAt(1.0, QColor(0, 0, 0, darkness_alpha));
QPainter painter2(&pixmap);
painter2.setPen(Qt::NoPen);
painter2.fillRect(0, 0, res_c, res_c, radialGrad);
painter2.end();
this->calculated_lighting_pixmap = true;
this->lighting_pixmap = pixmap;
}
}
bool ContentWidget::eventFilter(QObject *obj, QEvent *event)
{
if(obj == line_label_1 || obj == line_label_2)
{
if(event->type() == QEvent::Paint)
{
int label_height_1 = line_label_1->height();
int label_width_1 = line_label_1->width();
QPainter painter(line_label_1);
painter.setPen(QPen(QColor(220, 220, 220), 1, Qt::DashLine));
painter.drawLine(label_width_1/2, 0, label_width_1/2, label_height_1);
int label_height_2 = line_label_2->height();
int label_width_2 = line_label_2->width();
QPainter painter2(line_label_2);
painter2.setPen(QPen(QColor(220, 220, 220), 1, Qt::DashLine));
painter2.drawLine(label_width_2/2, 0, label_width_2/2, label_height_2);
}
}
return QWidget::eventFilter(obj, event);
}
//////////////////////////////////////////////////////////////////////
// Called to update spectrum data for displaying on the screen
//////////////////////////////////////////////////////////////////////
void CPlotter::draw()
{
int i;
int w;
int h;
int xmin, xmax;
if (m_DrawOverlay)
{
DrawOverlay();
m_DrawOverlay = false;
}
QPoint LineBuf[MAX_SCREENSIZE];
if (!m_Running)
return;
// get/draw the waterfall
w = m_WaterfallPixmap.width();
h = m_WaterfallPixmap.height();
// no need to draw if pixmap is invisible
if ((w != 0) || (h != 0))
{
// move current data down one line(must do before attaching a QPainter object)
m_WaterfallPixmap.scroll(0,1,0,0, w, h);
QPainter painter1(&m_WaterfallPixmap);
// get scaled FFT data
GetScreenIntegerFFTData(255, w, m_MaxdB, m_MindB,
m_FftCenter-m_Span/2, m_FftCenter+m_Span/2,
m_fftbuf, &xmin, &xmax);
// draw new line of fft data at top of waterfall bitmap
painter1.setPen(QColor(0, 0, 0));
for (i = 0; i < xmin; i++)
painter1.drawPoint(i,0);
for (i = xmax; i < w; i++)
painter1.drawPoint(i,0);
for (i = xmin; i < xmax; i++)
{
painter1.setPen(m_ColorTbl[ 255-m_fftbuf[i] ]);
painter1.drawPoint(i,0);
}
}
// get/draw the 2D spectrum
w = m_2DPixmap.width();
h = m_2DPixmap.height();
if ((w != 0) || (h != 0))
{
// first copy into 2Dbitmap the overlay bitmap.
m_2DPixmap = m_OverlayPixmap.copy(0,0,w,h);
QPainter painter2(&m_2DPixmap);
// get new scaled fft data
GetScreenIntegerFFTData(h, w, m_MaxdB, m_MindB,
m_FftCenter-m_Span/2, m_FftCenter+m_Span/2,
m_fftbuf, &xmin, &xmax);
// draw the 2D spectrum
painter2.setPen(QColor(0x97,0xD0,0x97,0xFF));
for (i = 0; i < xmax - xmin; i++)
{
LineBuf[i].setX(i + xmin);
LineBuf[i].setY(m_fftbuf[i + xmin]);
}
painter2.drawPolyline(LineBuf, xmax - xmin);
}
// trigger a new paintEvent
update();
}
void tst_QPixmapFilter::convolutionDrawSubRect()
{
QPixmapConvolutionFilter filter;
qreal kernel[] = {
0, 0, 0,
0, 0, 0,
0, 0, 1
};
filter.setConvolutionKernel(kernel, 3, 3);
QPixmap pixmap("noise.png");
QImage result(pixmap.size(), QImage::Format_ARGB32_Premultiplied);
QPainter painter(&result);
painter.setCompositionMode(QPainter::CompositionMode_Source);
painter.fillRect(result.rect(), QColor(128, 0, 0, 255));
painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
filter.draw(&painter, QPointF(16, 16), pixmap, QRectF(16, 16, 16, 16));
painter.end();
QImage resultImg = result;
QImage sourceImg = pixmap.toImage();
for(int y = 0; y < resultImg.height()-1; y++)
{
for(int x = 0; x < resultImg.width()-1; x++)
{
QRgb pixel = resultImg.pixel(x,y);
QRgb srcPixel = sourceImg.pixel(x+1,y+1);
if(x>=15 && x<33 && y>=15 && y<33) {
QCOMPARE(pixel, srcPixel);
} else {
QCOMPARE(qRed(pixel), 128);
QCOMPARE(qGreen(pixel), 0);
QCOMPARE(qBlue(pixel), 0);
QCOMPARE(qAlpha(pixel), 255);
}
}
}
kernel[2] = 1;
kernel[8] = 0;
filter.setConvolutionKernel(kernel, 3, 3);
QPainter painter2(&result);
painter2.setCompositionMode(QPainter::CompositionMode_Source);
painter2.fillRect(result.rect(), QColor(128, 0, 0, 255));
painter2.setCompositionMode(QPainter::CompositionMode_SourceOver);
filter.draw(&painter2, QPointF(16, 16), pixmap, QRectF(16, 16, 16, 16));
painter2.end();
resultImg = result;
sourceImg = pixmap.toImage();
for(int y = 1; y < resultImg.height(); y++)
{
for(int x = 0; x < resultImg.width()-1; x++)
{
QRgb pixel = resultImg.pixel(x,y);
QRgb srcPixel = sourceImg.pixel(x+1,y-1);
if(x>=15 && x<33 && y>=15 && y<33) {
QCOMPARE(pixel, srcPixel);
} else {
QCOMPARE(qRed(pixel), 128);
QCOMPARE(qGreen(pixel), 0);
QCOMPARE(qBlue(pixel), 0);
QCOMPARE(qAlpha(pixel), 255);
}
}
}
}
void MaskWidget::paintEvent(QPaintEvent* e)
{
if (!m_desktopPixmap.isNull())
{
m_curPos = QCursor::pos();
QPainter painter(this);
painter.drawPixmap(0, 0, m_desktopPixmap);
if (!m_bScreenShotDone)
{
if (!m_bDragging)
{
m_curRc.setRect(-9999, -9999, 19999, 19999);
for (std::vector<RECT>::iterator it = g_winRects.begin(); it != g_winRects.end(); ++it)
{
QRect rect;
rect.setRect(it->left, it->top, it->right - it->left, it->bottom - it->top);
if (rect.contains(QCursor::pos()) && m_curRc.contains(rect)/* && rect.height() > 5 && rect.width() > 5*/)
{
m_curRc = rect;
//break;
}
}
}
else
{
m_curRc = QRect(m_startPoint, QCursor::pos());
}
}
painter.save();
painter.setPen(Qt::NoPen);
painter.setBrush(QColor(0, 0, 0, 120));
QPolygon p1(QRect(0, 0, width(), height()));
QPolygon p2(m_curRc, true);
p1 = p1.subtracted(p2);
painter.drawPolygon(p1);
painter.restore();
painter.save();
QPen pen = painter.pen();
if (m_bScreenShotDone || m_bMousePressing)
{
pen.setWidth(2);
pen.setColor(QColor(6, 157, 213));
pen.setStyle(Qt::DashDotDotLine);
}
else
{
pen.setWidth(4);
pen.setColor(QColor(0, 255, 0));
pen.setStyle(Qt::SolidLine);
}
painter.setPen(pen);
painter.drawRect(m_curRc);
painter.restore();
painter.save();
QRect ori(m_curPos.x() - 15, m_curPos.y() - 11, 30, 22);
QPixmap magnifier(126, 122);
QPainter painter2(&magnifier);
painter2.save();
painter2.fillRect(0, 0, 126, 122, QBrush(QColor(51, 51, 51, 200)));
painter2.restore();
QPen p = painter2.pen();
p.setWidth(1);
p.setColor(QColor(51, 51, 51));
painter2.setPen(p);
painter2.drawRect(0, 0, 125, 93);
p.setWidth(2);
p.setColor(QColor(255, 255, 255));
painter2.setPen(p);
painter2.drawRect(2, 2, 122, 90);
painter2.drawPixmap(3, 3, m_desktopPixmap.copy(ori).scaled(120, 88));
p.setWidth(4);
p.setColor(QColor(0, 122, 179, 128));
painter2.setPen(p);
painter2.drawLine(5, 45, 121, 45);
painter2.drawLine(61, 5, 61, 89);
p.setWidth(1);
p.setColor(QColor(255, 255, 255));
painter2.setPen(p);
painter2.drawText(6, 105, QString("%1 x %2").arg(m_curRc.width()).arg(m_curRc.height()));
QImage image = m_desktopPixmap.toImage();
QRgb rgb = image.pixel(m_curPos.x()-1, m_curPos.y()-1);
painter2.drawText(6, 118, QString("rgb(%1,%2,%3").arg(qRed(rgb)).arg(qGreen(rgb)).arg(qBlue(rgb)));
QPoint showPoint(m_curPos.x() + 10, m_curPos.y() + 10);
if (m_curPos.y() + 130 > this->height())
showPoint.setY(m_curPos.y() - 130);
if (m_curPos.x() + 130 > this->width())
showPoint.setX(m_curPos.x() - 130);
painter.drawPixmap(showPoint, magnifier);
}
}
//////////////////////////////////////////////////////////////////////
// Called to update spectrum data for displaying on the screen
//////////////////////////////////////////////////////////////////////
void CPlotter::draw()
{
int i,n;
int w;
int h;
int xmin, xmax;
if (m_DrawOverlay)
{
drawOverlay();
m_DrawOverlay = false;
}
QPoint LineBuf[MAX_SCREENSIZE];
if (!m_Running)
return;
// get/draw the waterfall
w = m_WaterfallPixmap.width();
h = m_WaterfallPixmap.height();
// no need to draw if pixmap is invisible
if ((w != 0) || (h != 0))
{
// move current data down one line(must do before attaching a QPainter object)
m_WaterfallPixmap.scroll(0,1,0,0, w, h);
QPainter painter1(&m_WaterfallPixmap);
// get scaled FFT data
getScreenIntegerFFTData(255, qMin(w, MAX_SCREENSIZE),
m_MaxdB, m_MindB,
m_FftCenter - (qint64)m_Span/2,
m_FftCenter + (qint64)m_Span/2,
m_wfData, m_fftbuf,
&xmin, &xmax);
// draw new line of fft data at top of waterfall bitmap
painter1.setPen(QColor(0, 0, 0));
for (i = 0; i < xmin; i++)
painter1.drawPoint(i,0);
for (i = xmax; i < w; i++)
painter1.drawPoint(i,0);
for (i = xmin; i < xmax; i++)
{
painter1.setPen(m_ColorTbl[ 255-m_fftbuf[i] ]);
painter1.drawPoint(i,0);
}
}
// get/draw the 2D spectrum
w = m_2DPixmap.width();
h = m_2DPixmap.height();
if ((w != 0) || (h != 0))
{
// first copy into 2Dbitmap the overlay bitmap.
m_2DPixmap = m_OverlayPixmap.copy(0,0,w,h);
QPainter painter2(&m_2DPixmap);
// workaround for "fixed" line drawing since Qt 5
// see http://stackoverflow.com/questions/16990326
#if QT_VERSION >= 0x050000
painter2.translate(0.5, 0.5);
#endif
// get new scaled fft data
getScreenIntegerFFTData(h, qMin(w, MAX_SCREENSIZE),
m_MaxdB, m_MindB,
m_FftCenter - (qint64)m_Span/2,
m_FftCenter + (qint64)m_Span/2,
m_fftData, m_fftbuf,
&xmin, &xmax);
// draw the pandapter
painter2.setPen(m_FftColor);
n = xmax - xmin;
for (i = 0; i < n; i++)
{
LineBuf[i].setX(i + xmin);
LineBuf[i].setY(m_fftbuf[i + xmin]);
}
if (m_FftFill)
{
QLinearGradient linGrad(QPointF(xmin, h), QPointF(xmin, 0));
linGrad.setColorAt(0.0, m_FftCol0);
linGrad.setColorAt(1.0, m_FftCol1);
painter2.setBrush(QBrush(QGradient(linGrad)));
if (n < MAX_SCREENSIZE-2)
{
LineBuf[n].setX(xmax-1);
LineBuf[n].setY(h);
LineBuf[n+1].setX(xmin);
LineBuf[n+1].setY(h);
painter2.drawPolygon(LineBuf, n+2);
}
else
{
LineBuf[MAX_SCREENSIZE-2].setX(xmax-1);
LineBuf[MAX_SCREENSIZE-2].setY(h);
LineBuf[MAX_SCREENSIZE-1].setX(xmin);
LineBuf[MAX_SCREENSIZE-1].setY(h);
painter2.drawPolygon(LineBuf, n);
}
}
else
{
painter2.drawPolyline(LineBuf, n);
}
}
// trigger a new paintEvent
update();
}
//////////////////////////////////////////////////////////////////////
// Called to update spectrum data for displaying on the screen
//////////////////////////////////////////////////////////////////////
void CTestBench::DrawFftPlot()
{
int i;
int w;
int h;
qint32 fftbuf[TB_MAX_SCREENSIZE];
QPoint LineBuf[TB_MAX_SCREENSIZE];
if(m_2DPixmap.isNull())
return;
if(m_NewDataIsCpx != m_CurrentDataIsCpx)
{
m_CurrentDataIsCpx = m_NewDataIsCpx;
DrawFreqOverlay();
}
//get/draw the 2D spectrum
w = m_2DPixmap.width();
h = m_2DPixmap.height();
//first copy into 2Dbitmap the overlay bitmap.
m_2DPixmap = m_OverlayPixmap.copy(0,0,w,h);
QPainter painter2(&m_2DPixmap);
//get new scaled fft data
if(m_CurrentDataIsCpx)
{
m_Fft.GetScreenIntegerFFTData( h, w,
m_MaxdB,
m_MindB,
-m_Span/2,
m_Span/2,
fftbuf );
}
else
{
m_Fft.GetScreenIntegerFFTData( h, w,
m_MaxdB,
m_MindB,
0.0,
m_Span/2,
fftbuf );
}
//draw the 2D spectrum
for(i=0; i<w; i++)
{
LineBuf[i].setX(i);
LineBuf[i].setY(fftbuf[i]);
if(fftbuf[i] < m_FftPkBuf[i])
m_FftPkBuf[i] = fftbuf[i];
}
painter2.setPen( Qt::green );
painter2.drawPolyline(LineBuf,w);
if(m_PeakOn)
{
for(i=0; i<w; i++)
{
LineBuf[i].setX(i);
LineBuf[i].setY(m_FftPkBuf[i]);
}
painter2.setPen( Qt::red );
painter2.drawPolyline(LineBuf,w);
}
//trigger a new paintEvent
update();
}
void dController::printWithTemplate (int RowId)
{
qDebug()<<Q_FUNC_INFO;
//TODO это должно быть в отдельном классе !!!
QGraphicsScene * scene = new QGraphicsScene();
bool page_orient= false;
int margin_top = MM_TO_POINT(15);
int margin_bottom=MM_TO_POINT(15);
int margin_left=MM_TO_POINT(35);
int margin_right=MM_TO_POINT(15);
int page_width=210;
int page_height=297;
scene->clear();
scene->setSceneRect(0, 0, MM_TO_POINT(page_width),MM_TO_POINT(page_height));
QGraphicsRectItem *border_rect = new QGraphicsRectItem (QRectF(margin_left, margin_top, MM_TO_POINT(page_width)-margin_left-margin_right,MM_TO_POINT(page_height)-margin_top-margin_bottom));
qDebug() <<"margin_rect"<< margin_left << margin_top << margin_left<<margin_right;
border_rect->setPen(QPen(Qt::black,2,Qt::DotLine));
border_rect->setBrush(QBrush(Qt::white));
border_rect->setOpacity(0.5);
border_rect->setZValue(0);
//border_rect->setData(ObjectName, "Border");
scene->addItem(border_rect);
SimpleItem* Gritem = new SimpleItem;
Gritem->setPos(MM_TO_POINT(180), MM_TO_POINT(0));
Gritem->setPrintFrame(false);
Gritem->setText(QStringList()<<QString("Секретно")<<QString("Пункт 12"));
Gritem->setFlag(QGraphicsItem::ItemIsMovable);
Gritem->setParentItem(border_rect);
SimpleItem* MBitem = new SimpleItem;
MBitem->setPos(MM_TO_POINT(5), MM_TO_POINT(280));
MBitem->setPrintFrame(false);
MBitem->setText(QStringList()<<QString("МБ №-%1"));//.arg(templ));
MBitem->setFlag(QGraphicsItem::ItemIsMovable);
scene->addItem(MBitem);//->setParentItem(border_rect);
scene->update();
QPrinter printer;
QString with_t;
with_t.append(spoolDIR).append("compl_teml2.pdf");
printer.setOutputFormat(QPrinter::PdfFormat);
printer.setOutputFileName(with_t);
printer.setPageSize(QPrinter::A4);
QPainter painter(&printer);
scene->render(&painter);
//QString in_file =mainPDF;
//in_file.arg(QString(SID));
qDebug() <<Q_FUNC_INFO<< mainPDF << outPDF;
this->mergeTwoPDF(mainPDF,with_t,outPDF);
// Рисуем последнюю страничку
scene->clear();
border_rect = new QGraphicsRectItem (QRectF(margin_left, margin_top, MM_TO_POINT(page_width)-margin_left-margin_right,MM_TO_POINT(page_height)-margin_top-margin_bottom));
qDebug() <<"margin_rect"<< margin_left << margin_top << margin_left<<margin_right;
border_rect->setPen(QPen(Qt::black,2,Qt::DotLine));
border_rect->setBrush(QBrush(Qt::white));
border_rect->setOpacity(0.5);
border_rect->setZValue(0);
//border_rect->setData(ObjectName, "Border");
scene->addItem(border_rect);
SimpleItem* Lastitem = new SimpleItem;
Lastitem->setPos(MM_TO_POINT(40), MM_TO_POINT(200));
Lastitem->setPrintFrame(true);
Lastitem->setText(QStringList()<<QString("Секретно")
<<QString("Пункт 12")
<<QString("Исполнитель:ФИО исполнителя")
<<QString("Отпечатал:ФИО кто печатал")
<<QString("Телефон:2-63-15")
<<QString("Инв.№ 12/13")
<<QString("Дата: 09.09.09'")
<<QString("МБ №-%1"));//.arg(templ)
//);
Lastitem->setFlag(QGraphicsItem::ItemIsMovable);
scene->addItem(Lastitem);//->setParentItem(border_rect);
QPrinter printer2;
printer2.setOutputFormat(QPrinter::PdfFormat);
QString last_p;
last_p.append(spoolDIR).append("last_page.pdf");
printer2.setOutputFileName(last_p);
printer2.setPageSize(QPrinter::A4);
QPainter painter2(&printer2);
scene->render(&painter2);
// emit sayMeGood();
}
void QBalloonTip::balloon(const QPoint& pos, int msecs, bool showArrow)
{
QRect scr = QApplication::desktop()->screenGeometry(pos);
QSize sh = sizeHint();
const int border = 1;
const int ah = 18, ao = 18, aw = 18, rc = 7;
bool arrowAtTop = (pos.y() + sh.height() + ah < scr.height());
bool arrowAtLeft = (pos.x() + sh.width() - ao < scr.width());
setContentsMargins(border + 3, border + (arrowAtTop ? ah : 0) + 2, border + 3, border + (arrowAtTop ? 0 : ah) + 2);
updateGeometry();
sh = sizeHint();
int ml, mr, mt, mb;
QSize sz = sizeHint();
if (!arrowAtTop) {
ml = mt = 0;
mr = sz.width() - 1;
mb = sz.height() - ah - 1;
} else {
ml = 0;
mt = ah;
mr = sz.width() - 1;
mb = sz.height() - 1;
}
QPainterPath path;
#if defined(QT_NO_XSHAPE) && defined(Q_WS_X11)
// XShape is required for setting the mask, so we just
// draw an ugly square when its not available
path.moveTo(0, 0);
path.lineTo(sz.width() - 1, 0);
path.lineTo(sz.width() - 1, sz.height() - 1);
path.lineTo(0, sz.height() - 1);
path.lineTo(0, 0);
move(qMax(pos.x() - sz.width(), scr.left()), pos.y());
#else
path.moveTo(ml + rc, mt);
if (arrowAtTop && arrowAtLeft) {
if (showArrow) {
path.lineTo(ml + ao, mt);
path.lineTo(ml + ao, mt - ah);
path.lineTo(ml + ao + aw, mt);
}
move(qMax(pos.x() - ao, scr.left() + 2), pos.y());
} else if (arrowAtTop && !arrowAtLeft) {
if (showArrow) {
path.lineTo(mr - ao - aw, mt);
path.lineTo(mr - ao, mt - ah);
path.lineTo(mr - ao, mt);
}
move(qMin(pos.x() - sh.width() + ao, scr.right() - sh.width() - 2), pos.y());
}
path.lineTo(mr - rc, mt);
path.arcTo(QRect(mr - rc*2, mt, rc*2, rc*2), 90, -90);
path.lineTo(mr, mb - rc);
path.arcTo(QRect(mr - rc*2, mb - rc*2, rc*2, rc*2), 0, -90);
if (!arrowAtTop && !arrowAtLeft) {
if (showArrow) {
path.lineTo(mr - ao, mb);
path.lineTo(mr - ao, mb + ah);
path.lineTo(mr - ao - aw, mb);
}
move(qMin(pos.x() - sh.width() + ao, scr.right() - sh.width() - 2),
pos.y() - sh.height());
} else if (!arrowAtTop && arrowAtLeft) {
if (showArrow) {
path.lineTo(ao + aw, mb);
path.lineTo(ao, mb + ah);
path.lineTo(ao, mb);
}
move(qMax(pos.x() - ao, scr.x() + 2), pos.y() - sh.height());
}
path.lineTo(ml + rc, mb);
path.arcTo(QRect(ml, mb - rc*2, rc*2, rc*2), -90, -90);
path.lineTo(ml, mt + rc);
path.arcTo(QRect(ml, mt, rc*2, rc*2), 180, -90);
// Set the mask
QBitmap bitmap = QBitmap(sizeHint());
bitmap.fill(Qt::color0);
QPainter painter1(&bitmap);
painter1.setPen(QPen(Qt::color1, border));
painter1.setBrush(QBrush(Qt::color1));
painter1.drawPath(path);
setMask(bitmap);
#endif
// Draw the border
pixmap = QPixmap(sz);
QPainter painter2(&pixmap);
painter2.setPen(QPen(palette().color(QPalette::Window).darker(160), border));
painter2.setBrush(palette().color(QPalette::Window));
painter2.drawPath(path);
if (msecs > 0)
timerId = startTimer(msecs);
show();
}
