void QLed::paintEvent(QPaintEvent *)
{
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.setWindow( -50,-50,100,100);
painter.setPen(Qt::white);
painter.drawArc(-25,-25,50,50,0,5670);
painter.drawArc(-32,-33,66,66,0,5670);
painter.setPen(Qt::darkGray);
painter.drawArc(-34,-33,66,66,3400,3000);
if(m_value)
{
QRadialGradient radialGrad(QPointF(-8, -8), 20);
radialGrad.setColorAt(0, Qt::white);
radialGrad.setColorAt(1, m_color);
QBrush brush(radialGrad);
painter.setBrush(brush);
painter.setPen(Qt::black);
painter.drawEllipse(-25,-25,50,50);
}
else
{
QRadialGradient radialGrad(QPointF(-8, -8), 20);
radialGrad.setColorAt(0, Qt::white);
radialGrad.setColorAt(1, Qt::lightGray);
QBrush brush(radialGrad);
painter.setBrush(brush);
painter.drawEllipse(-25,-25,50,50);
}
}
void LensItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
Q_UNUSED(widget);
painter->setPen(QPen(Qt::black, 1.0 / option->levelOfDetail));
QRadialGradient radialGrad(QPointF(0.5, 0.5), 1.0);
radialGrad.setColorAt(0.0, QColor(255, 0, 0, 127));
radialGrad.setColorAt(0.1, QColor(255, 0, 0, 127));
radialGrad.setColorAt(1.0, QColor(255, 255, 255, 0));
#if QT_VERSION >= 0x040301
radialGrad.setCoordinateMode(QGradient::ObjectBoundingMode);
#endif
painter->setBrush(radialGrad);
painter->drawEllipse(rect().toRect());
if (option->state & QStyle::State_Selected)
{
scaling = option->levelOfDetail;
double siz = 6.0 / option->levelOfDetail;
QRectF br = boundingRect();
painter->setBrush(Qt::NoBrush);
painter->setPen(QPen(Qt::red, 1.0 / option->levelOfDetail, Qt::DotLine));
painter->drawRect(br);
painter->setBrush(Qt::red);
painter->setPen(Qt::NoPen);
painter->drawRect(QRectF(br.x() + br.width(), br.y() + br.height(), -siz, -siz));
painter->drawRect(QRectF(br.x() + br.width(), br.y(), -siz, siz));
painter->drawRect(QRectF(br.x(), br.y() + br.height(), siz, -siz));
painter->drawRect(QRectF(br.x(), br.y(), siz, siz));
}
}
ZLightingCoursor::ZLightingCoursor(QGraphicsScene* pScene, const QSize& size)
:QGraphicsPixmapItem(), m_Size(size)
{
QRadialGradient radialGrad(size.width()/2, size.height()/2, size.width());
QColor col = Qt::darkBlue;
col.setAlpha(127);
radialGrad.setColorAt(0,col/* Qt::darkBlue*/);
radialGrad.setColorAt(0.5,col/* Qt::darkBlue*/);
radialGrad.setColorAt(1, Qt::transparent);
QPixmap pixmap(size);
pixmap.fill(Qt::transparent);
QPainter painter(&pixmap);
painter.setPen(Qt::NoPen);
painter.setBrush(radialGrad);
painter.drawEllipse(-2, -2, size.width()+4, size.height()+4);
painter.end();
setPixmap(pixmap);
setZValue(2);
pScene->addItem(this);
hide();
m_TimeLine.setDuration(150);
m_TimeLine.setFrameRange(1, 150);
m_TimeLine.setDirection(QTimeLine::Backward);
connect(&m_TimeLine, SIGNAL(frameChanged(int)), this, SLOT(OnSetFrame(int)));
// connect(&m_TimeLine, SIGNAL(finished()), this, SLOT(updateItemPosition()));
}
HandgripItem::HandgripItem(QObject *parentObject, QGraphicsItem *parentItem, int id, int type)
: QObject(parentObject),
QGraphicsPathItem(parentItem),
m_opacityAnimation( new QPropertyAnimation(this, "opacity", this) ),
m_moving(false),
m_id(id),
m_type(type)
{
setAcceptHoverEvents(true);
setFlag(QGraphicsItem::ItemIgnoresTransformations,true);
QRadialGradient radialGrad(0,0,sizeMark,0,0);
radialGrad.setColorAt( 0.0, QColor(200, 255, 255) );
if (m_type == ROTATOR)
{
radialGrad.setColorAt( 0.0, QColor(255, 50, 0) );
radialGrad.setColorAt( 1.0, QColor(255, 190, 0) );
}
else
{
radialGrad.setColorAt( 0.0, QColor(200, 255, 255) );
radialGrad.setColorAt( 1.0, QColor(31, 197, 193) );
}
QBrush b(radialGrad);
b.setStyle(Qt::RadialGradientPattern);
QRectF r(0, 0, sizeMark, sizeMark);
r.moveCenter( QPoint(0, 0) );
QPainterPath p;
p.addRoundedRect(r, cornerSize, cornerSize);
setPath(p);
setBrush(b);
setPen( QPen(Qt::black) );
QPen p2(Qt::red, 1);
p2.setCosmetic(true);
m_outerRing.setParentItem(this);
m_outerRing.setRect( r.adjusted(-sizeMark / 2, -sizeMark / 2, sizeMark / 2, sizeMark / 2) );
m_outerRing.setPen(p2 );
m_outerRing.hide();
// in order to
connect( m_opacityAnimation,SIGNAL( finished () ),this,SLOT( checkVisibility() ) );
// select a correct cursor from type
if (m_type == TRANSLATOR_XY)
QGraphicsItem::setCursor( QCursor(Qt::SizeAllCursor ) );
else if (m_type == TRANSLATOR_Y)
QGraphicsItem::setCursor( QCursor(Qt::SizeVerCursor ) );
else if (m_type == TRANSLATOR_X)
QGraphicsItem::setCursor( QCursor(Qt::SizeHorCursor ) );
else
QGraphicsItem::setCursor( QCursor( QPixmap(":/editor/editor/cursor_rotate.png") ) );
}
// Draw background pixmap separately, only updated after resize event and when
// m_LimitReached state is changed
void AnalogPad::paintBackground()
{
m_BackgroundPixmap = QPixmap(this->size());
m_BackgroundPixmap.fill(Qt::transparent);
QPainter painter(&m_BackgroundPixmap);
painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::HighQualityAntialiasing);
painter.setPen(m_BackgroundColor2);
// Draw widget borders
//painter.drawRect(this->rect().adjusted(0, 0, -1, -1));
// Draw pad
// Outer circle..
QRadialGradient radialGrad(QPointF(m_Position.x(), m_Position.y()), this->height()*0.7, QPointF(this->width()*0.1,this->height()*0.1));
const int BRIGHTNESS = 95;
radialGrad.setColorAt(0, m_BackgroundColor1.lighter(BRIGHTNESS));
radialGrad.setColorAt(1, m_BackgroundColor2.lighter(BRIGHTNESS));
painter.setBrush(QBrush(radialGrad));
painter.drawEllipse(m_Position, this->width()*0.45, this->height()*0.45);
// ..and inner circle
radialGrad.setColorAt(0, m_BackgroundColor1);
radialGrad.setColorAt(1, m_BackgroundColor2);
painter.setBrush(QBrush(radialGrad));
painter.drawEllipse(m_Position, this->width()*0.41, this->height()*0.41);
// Draw pad arrows
const qreal ARROW_SCALE = 0.2;
const qreal ARROW_WIDTH = this->width()*ARROW_SCALE;
const qreal ARROW_HEIGHT = this->height()*ARROW_SCALE;
const qreal ARROW_DISTANCE = 0.38;
const qreal ARROW_ANGLE = 60;
QRectF rectangle(m_Position.x()-ARROW_WIDTH/2, m_Position.y()-ARROW_HEIGHT/2, ARROW_WIDTH, ARROW_HEIGHT);
painter.setBrush(m_BackgroundColor1);
painter.setOpacity(0.5);
painter.drawPie(rectangle.adjusted(0, this->height()*ARROW_DISTANCE, 0, this->height()*ARROW_DISTANCE), (90-ARROW_ANGLE/2) * 16, ARROW_ANGLE * 16);
painter.drawPie(rectangle.adjusted(this->width()*ARROW_DISTANCE, 0, this->width()*ARROW_DISTANCE, 0), (180-ARROW_ANGLE/2) * 16, ARROW_ANGLE * 16);
painter.drawPie(rectangle.adjusted(0, this->height()*-ARROW_DISTANCE, 0, this->height()*-ARROW_DISTANCE), (270-ARROW_ANGLE/2) * 16, ARROW_ANGLE * 16);
painter.drawPie(rectangle.adjusted(this->width()*-ARROW_DISTANCE, 0, this->width()*-ARROW_DISTANCE, 0), (360-ARROW_ANGLE/2) * 16, ARROW_ANGLE * 16);
// Draw the cross in the middle
painter.setOpacity(1);
painter.drawLine(this->width()*0.48, this->height()/2, this->width()*0.52+1, this->height()/2);
painter.drawLine(this->width()/2, this->height()*0.48, this->width()/2, this->height()*0.52+1);
}
void Lighting::setupScene()
{
m_scene.setSceneRect(-300, -200, 600, 460);
QLinearGradient linearGrad(QPointF(-100, -100), QPointF(100, 100));
linearGrad.setColorAt(0, QColor(255, 255, 255));
linearGrad.setColorAt(1, QColor(192, 192, 255));
setBackgroundBrush(linearGrad);
QRadialGradient radialGrad(30, 30, 30);
radialGrad.setColorAt(0, Qt::yellow);
radialGrad.setColorAt(0.2, Qt::yellow);
radialGrad.setColorAt(1, Qt::transparent);
QPixmap pixmap(60, 60);
pixmap.fill(Qt::transparent);
QPainter painter(&pixmap);
painter.setPen(Qt::NoPen);
painter.setBrush(radialGrad);
painter.drawEllipse(0, 0, 60, 60);
painter.end();
m_lightSource = m_scene.addPixmap(pixmap);
m_lightSource->setZValue(2);
for (int i = -2; i < 3; ++i)
for (int j = -2; j < 3; ++j) {
QAbstractGraphicsShapeItem *item;
if ((i + j) & 1)
item = new QGraphicsEllipseItem(0, 0, 50, 50);
else
item = new QGraphicsRectItem(0, 0, 50, 50);
item->setPen(QPen(Qt::black, 1));
item->setBrush(QBrush(Qt::white));
QGraphicsDropShadowEffect *effect = new QGraphicsDropShadowEffect;
effect->setBlurRadius(8);
item->setGraphicsEffect(effect);
item->setZValue(1);
item->setPos(i * 80, j * 80);
m_scene.addItem(item);
m_items << item;
}
}
LensItem::LensItem(QRectF geom, LensDialog *parent) : QGraphicsRectItem(geom)
{
dialog = parent;
strength = -100.0;
scaling = 1.0,
handle = -1;
setPen(QPen(Qt::black));
QRadialGradient radialGrad(QPointF(0.5, 0.5), 1.0);
radialGrad.setColorAt(0.0, QColor(255, 0, 0, 127));
radialGrad.setColorAt(0.1, QColor(255, 0, 0, 127));
radialGrad.setColorAt(1.0, QColor(255, 255, 255, 0));
#if QT_VERSION >= 0x040301
radialGrad.setCoordinateMode(QGradient::ObjectBoundingMode);
#endif
setBrush(radialGrad);
setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
setAcceptsHoverEvents(true);
}
int main()
{
QWidget anyPaintDevice;
{
// PEN SNIPPET
QPainter painter;
QPen pen(Qt::red, 2); // red solid line, 2 pixels wide
painter.begin(&anyPaintDevice); // paint something
painter.setPen(pen); // set the red, wide pen
painter.drawRect(40,30, 200,100); // draw a rectangle
painter.setPen(Qt::blue); // set blue pen, 0 pixel width
painter.drawLine(40,30, 240,130); // draw a diagonal in rectangle
painter.end(); // painting done
}
{
// BRUSH SNIPPET
QPainter painter;
QBrush brush(Qt::yellow); // yellow solid pattern
painter.begin(&anyPaintDevice); // paint something
painter.setBrush(brush); // set the yellow brush
painter.setPen(Qt::NoPen); // do not draw outline
painter.drawRect(40,30, 200,100); // draw filled rectangle
painter.setBrush(Qt::NoBrush); // do not fill
painter.setPen(Qt::black); // set black pen, 0 pixel width
painter.drawRect(10,10, 30,20); // draw rectangle outline
painter.end(); // painting done
}
// LINEAR
//! [0]
QLinearGradient linearGrad(QPointF(100, 100), QPointF(200, 200));
linearGrad.setColorAt(0, Qt::black);
linearGrad.setColorAt(1, Qt::white);
//! [0]
// RADIAL
//! [1]
QRadialGradient radialGrad(QPointF(100, 100), 100);
radialGrad.setColorAt(0, Qt::red);
radialGrad.setColorAt(0.5, Qt::blue);
radialGrad.setColorAt(1, Qt::green);
//! [1]
}
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;
}
}
void MousePadWidgetInternal::paintEvent(QPaintEvent *)
{
QPainter p(this);
Vector3D center(this->width() / 2, this->height() / 2, 0);
double radius = center.length();
QPoint qcenter(this->width() / 2, this->height() / 2);
QRadialGradient radialGrad(qcenter, radius, mLastPos);
radialGrad.setColorAt(0.0, QColor("khaki"));
radialGrad.setColorAt(0.4, QColor("lightgrey"));
radialGrad.setColorAt(1, QColor("dimgrey"));
QColor color(146, 0, 146);
QBrush brush(radialGrad);
p.setPen(QColor(146, 0, 146));
p.setBrush(QColor(146, 0, 146));
p.fillRect(0, 0, width() - 1, height() - 1, brush);
}
void StatusLight::paintEvent( QPaintEvent* )
{
QPainter p( this );
p.setRenderHint( QPainter::Antialiasing, true );
p.setWindow( -50,-50, 100, 100 );
p.setPen( Qt::white );
p.drawArc( -25, -25, 50, 50, 0, 5670 );
p.drawArc( -32, -33, 66, 66, 0, 5670 );
p.setPen( QColor(Qt::darkGray).lighter( 125 ) );
p.drawArc( -34, -33, 66, 66, 0, 180*16 );
QRadialGradient radialGrad(QPointF(0, -14), 20);
radialGrad.setColorAt( 0, QColor( 0xff, 0xff, 0xff, 0.8 ) );
radialGrad.setColorAt( 1, m_color );
QBrush brush(radialGrad);
p.setBrush(brush);
p.setPen( m_color.darker() );
p.drawEllipse(-25,-25,50,50);
}
void GameWidget::resizeEvent(QResizeEvent* /*event*/)
{
const int old_bubblesize = bubblesize;
const int max_size = qMin(width(), height());
margin = max_size / 70; //separates bubbles from each other and the widget border
bubblesize = (max_size - margin*(grid_size+1)) / grid_size;
//center grid
xoff = (width() - margin*(grid_size+1) - bubblesize*grid_size)/2;
yoff = (height() -margin*(grid_size+1) - bubblesize*grid_size)/2;
if(bubblesize != old_bubblesize) { //generate new pixmaps
for(int i = 1; i <= num_colors; i++) {
for(int j = 0; j < num_scale_steps; j++) {
bubblePixmap[i][j] = QPixmap(bubblesize, bubblesize); //pixmaps have same size, graphic may be tinier
bubblePixmap[i][j].fill(Qt::transparent);
const qreal scaled_size = (1 - double(j)/num_scale_steps)*(1 - double(j)/num_scale_steps) * bubblesize;
QPainter painter(&bubblePixmap[i][j]);
painter.setPen(Qt::transparent);
painter.setRenderHint(QPainter::Antialiasing, true);
QRadialGradient radialGrad(QPointF(0.3*bubblesize, 0.3*bubblesize), 0.8*scaled_size);
radialGrad.setColorAt(0, Qt::white);
radialGrad.setColorAt(0.4, bubbleColor[i]);
radialGrad.setColorAt(1, bubbleColor[i].darker(700));
painter.setBrush(QBrush(radialGrad));
painter.drawEllipse((bubblesize-scaled_size)/2, (bubblesize-scaled_size)/2,
scaled_size, scaled_size);
}
}
}
update();
}
void tst_QPixmap::fromImageReader_data()
{
const QString tempDir = QDir::tempPath();
QTest::addColumn<QString>("filename");
QImage image(2000, 2000, QImage::Format_ARGB32);
image.fill(0);
{
// Generate an image with opaque and transparent pixels
// with an interesting distribution.
QPainter painter(&image);
QRadialGradient radialGrad(QPointF(1000, 1000), 1000);
radialGrad.setColorAt(0, QColor(255, 0, 0, 255));
radialGrad.setColorAt(0.5, QColor(0, 255, 0, 255));
radialGrad.setColorAt(0.9, QColor(0, 0, 255, 100));
radialGrad.setColorAt(1, QColor(0, 0, 0, 0));
painter.fillRect(image.rect(), radialGrad);
}
image.save("test.png");
// RGB32
const QString rgb32Path = tempDir + QString::fromLatin1("/rgb32.jpg");
image.save(rgb32Path);
QTest::newRow("gradient RGB32") << rgb32Path;
// ARGB32
const QString argb32Path = tempDir + QString::fromLatin1("/argb32.png");
image.save(argb32Path);
QTest::newRow("gradient ARGB32") << argb32Path;
// Indexed 8
const QString indexed8Path = tempDir + QString::fromLatin1("/indexed8.gif");
image.save(indexed8Path);
QTest::newRow("gradient indexed8") << indexed8Path;
}
void paintEvent (QPaintEvent *event)
{
QPainter p(this);
QRadialGradient radialGrad(QPointF(event->rect().width() / 2,
event->rect().height() / 2),
qMin(event->rect().width() / 2,
event->rect().height() / 2));
if (underMouse())
radialGrad.setColorAt(0, Qt::green);
else
radialGrad.setColorAt(0, Qt::red);
radialGrad.setColorAt(1, Qt::transparent);
p.fillRect(event->rect(), radialGrad);
p.setPen(Qt::black);
p.drawLine(0, 15, 30, 15);
p.drawLine(15, 0, 15, 30);
p.end();
}
void CSwitcher::paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget)
{
QPen t_pen;
painter->setPen(t_pen);
QBrush t_brush(Qt::white); //笔刷填充颜色：白色
painter->setBrush(t_brush);
painter->save(); //保存当前painter状态
painter->setRenderHint(QPainter::Antialiasing, true);
QRectF rectangle(2, 7, m_boundingRect.width() - 4,m_boundingRect.height() - 4);
if(m_switcherInfo.type == SWITCH)
{
painter->drawRoundedRect(rectangle,20,15);
}
else {
painter->drawRoundedRect(rectangle,10,5);
}
painter->restore();
painter->save();
painter->setRenderHint(QPainter::Antialiasing, true);
QRadialGradient radialGrad(QPointF(m_boundingRect.width()/2, m_boundingRect.height()/2), m_boundingRect.height());
radialGrad.setColorAt(0.2, QColor(150,214,241));
radialGrad.setColorAt(0.5, QColor(83,190,249));
radialGrad.setColorAt(1, QColor(98,176,255));
painter->setBrush(QBrush(radialGrad));
QRectF rectangle1(7, 12, m_boundingRect.width() - 14, m_boundingRect.height() - 14);
if(m_switcherInfo.type == SWITCH)
{
painter->drawRoundedRect(rectangle1,20,15);
}
else {
painter->drawRoundedRect(rectangle1,10,5);
}
painter->restore();
if(m_switcherInfo.portNum == 32 )
{
painter->save();
painter->setRenderHint(QPainter::Antialiasing, true);
t_brush.setColor(m_color);
painter->setBrush(t_brush);
//painter->drawEllipse(QRectF(m_boundingRect.width()/2 - 5,m_boundingRect.height() - 2 - 8,10,8)); //M duankou
painter->restore();
}
if(m_switcherInfo.portNum == 48 )
{
painter->save();
painter->setRenderHint(QPainter::Antialiasing, true);
t_brush.setColor(m_color);
painter->setBrush(t_brush);
painter->drawEllipse(QRectF(m_boundingRect.width()/2 - 18,m_boundingRect.height() - 2 - 8,10,8)); //M duankou
painter->drawEllipse(QRectF(m_boundingRect.width()/2 + 15,m_boundingRect.height()- 2 - 8,10,8));
painter->restore();
}
int t_fontSize = 10;
QFont t_font("Times New Roman");
t_font.setPointSize(t_fontSize);
t_font.setBold(true);
QFontMetrics t_textFontM(t_font);
qreal t_textHeight = t_textFontM.height();
QString s_id = QString("%1").arg(m_switcherInfo.ID);
QString t_str2 = s_id +"-" + m_switcherInfo.name;
qreal t_textWidth2 = t_textFontM.width(t_str2);
if(t_textWidth2 > m_boundingRect.width())
{
t_textWidth2 = m_boundingRect.width();
}
if(t_textHeight > m_boundingRect.height()/2)
{
t_textHeight = m_boundingRect.height()/4;
}
//限定字体大小
if (t_textWidth2 < m_boundingRect.width())
{
t_fontSize = 10;
}
else if (t_textWidth2 > m_boundingRect.width())
{
t_textWidth2 = m_boundingRect.width();
t_fontSize = m_boundingRect.width()/10;
}
else if(t_textHeight > m_boundingRect.height()/3)
{
t_textHeight = m_boundingRect.height()/4;
t_fontSize = m_boundingRect.width()/20;
}
//文字
painter->setRenderHint(QPainter::Antialiasing, true);
painter->setFont(t_font);
//QPointF t_text1Pos(m_boundingRect.width()/2 - t_textWidth1/2,m_boundingRect.height()/4 /*- t_textHeight*/);
//painter->drawText(t_text1Pos.x(),t_text1Pos.y(),t_str1);
// QPointF t_text2Pos(m_boundingRect.width()/2 - t_textWidth2/2,m_boundingRect.height()*3/4 + t_textHeight/1.5);
// painter->drawText(t_text2Pos.x(),t_text2Pos.y(),t_str2);
painter->drawText(0, 5, t_str2);
//交叉线
painter->setRenderHint(QPainter::Antialiasing, true);
t_pen.setWidth(2);
if(m_switcherInfo.type == SWITCH)
{
t_pen.setColor(Qt::white);
painter->setPen(t_pen);
QPointF t_pnt1(m_boundingRect.width()/8+8,m_boundingRect.height()*3/8+5);
QPointF t_pnt2(m_boundingRect.width()*3/8+2,m_boundingRect.height()*3/8+5);
QPointF t_pnt3(m_boundingRect.width()*5/8-2,m_boundingRect.height()*3/8+5);
QPointF t_pnt4(m_boundingRect.width()*7/8-8,m_boundingRect.height()*3/8+5);
QPointF t_pnt5(m_boundingRect.width()/8+8,m_boundingRect.height()*5/8+5);
QPointF t_pnt6(m_boundingRect.width()*3/8+2,m_boundingRect.height()*5/8+5);
QPointF t_pnt7(m_boundingRect.width()*5/8-2,m_boundingRect.height()*5/8+5);
QPointF t_pnt8(m_boundingRect.width()*7/8-8,m_boundingRect.height()*5/8+5);
//箭头点坐标
QPointF t_pnt11(m_boundingRect.width()/8+8+5,m_boundingRect.height()*3/8-3+5);
QPointF t_pnt12(m_boundingRect.width()/8+8+5,m_boundingRect.height()*3/8+3+5);
QPointF t_pnt41(m_boundingRect.width()*7/8-8-5,m_boundingRect.height()*3/8-3+5);
QPointF t_pnt42(m_boundingRect.width()*7/8-8-5,m_boundingRect.height()*3/8+3+5);
QPointF t_pnt51(m_boundingRect.width()/8+8+5,m_boundingRect.height()*5/8-3+5);
QPointF t_pnt52(m_boundingRect.width()/8+8+5,m_boundingRect.height()*5/8+3+5);
QPointF t_pnt81(m_boundingRect.width()*7/8-8-5,m_boundingRect.height()*5/8-3+5);
QPointF t_pnt82(m_boundingRect.width()*7/8-8-5,m_boundingRect.height()*5/8+3+5);
painter->setRenderHint(QPainter::Antialiasing, true);
painter->drawLine(t_pnt1,t_pnt2);
painter->drawLine(t_pnt3,t_pnt4);
painter->drawLine(t_pnt5,t_pnt6);
painter->drawLine(t_pnt7,t_pnt8);
painter->drawLine(t_pnt2,t_pnt7);
painter->drawLine(t_pnt3,t_pnt6);
painter->drawLine(t_pnt1,t_pnt11);
painter->drawLine(t_pnt1,t_pnt12);
painter->drawLine(t_pnt4,t_pnt41);
painter->drawLine(t_pnt4,t_pnt42);
painter->drawLine(t_pnt5,t_pnt51);
painter->drawLine(t_pnt5,t_pnt52);
painter->drawLine(t_pnt8,t_pnt81);
painter->drawLine(t_pnt8,t_pnt82);
}
else{
t_pen.setColor(Qt::black);
}
}
void BrushTool::drawStroke()
{
StrokeTool::drawStroke();
QList<QPointF> p = m_pStrokeManager->interpolateStroke();
Layer* layer = mEditor->layers()->currentLayer();
if ( layer->type() == Layer::BITMAP )
{
for ( int i = 0; i < p.size(); i++ )
{
p[ i ] = mEditor->view()->mapScreenToCanvas( p[ i ] );
}
qreal opacity = 1.0;
qreal brushWidth = mCurrentWidth + 0.5 * properties.feather;
qreal offset = qMax( 0.0, mCurrentWidth - 0.5 * properties.feather ) / brushWidth;
opacity = mCurrentPressure;
brushWidth = brushWidth * mCurrentPressure;
qreal brushStep = 0.5 * mCurrentWidth + 0.5 * properties.feather;
brushStep = brushStep * mCurrentPressure;
// if (usePressure) { brushStep = brushStep * tabletPressure; }
brushStep = qMax( 1.0, brushStep );
mCurrentWidth = properties.width;
BlitRect rect;
QRadialGradient radialGrad( QPointF( 0, 0 ), 0.5 * brushWidth );
mScribbleArea->setGaussianGradient( radialGrad,
mEditor->color()->frontColor(),
opacity,
offset );
QPointF a = lastBrushPoint;
QPointF b = getCurrentPoint();
// foreach (QSegment segment, calculateStroke(brushWidth))
// {
// QPointF a = lastBrushPoint;
// QPointF b = m_pScribbleArea->pixelToPoint(segment.second);
qreal distance = 4 * QLineF( b, a ).length();
int steps = qRound( distance ) / brushStep;
for ( int i = 0; i < steps; i++ )
{
QPointF point = lastBrushPoint + ( i + 1 ) * ( brushStep )* ( b - lastBrushPoint ) / distance;
rect.extend( point.toPoint() );
mScribbleArea->drawBrush( point,
brushWidth,
offset,
mEditor->color()->frontColor(),
opacity );
if ( i == ( steps - 1 ) )
{
lastBrushPoint = point;
}
}
int rad = qRound( brushWidth ) / 2 + 2;
mScribbleArea->refreshBitmap( rect, rad );
}
else if ( layer->type() == Layer::VECTOR )
{
qreal brushWidth = properties.width * mCurrentPressure;
int rad = qRound( ( brushWidth / 2 + 2 ) * mEditor->view()->scaling() );
QPen pen( mEditor->color()->frontColor(),
brushWidth * mEditor->view()->scaling(),
Qt::SolidLine,
Qt::RoundCap,
Qt::RoundJoin );
if ( p.size() == 4 )
{
QPainterPath path( p[ 0 ] );
path.cubicTo( p[ 1 ],
p[ 2 ],
p[ 3 ] );
mScribbleArea->drawPath( path, pen, Qt::NoBrush, QPainter::CompositionMode_Source );
mScribbleArea->refreshVector( path.boundingRect().toRect(), rad );
}
}
}
void BrushTool::drawStroke()
{
StrokeTool::drawStroke();
QList<QPointF> p = m_pStrokeManager->interpolateStroke(currentWidth);
Layer *layer = m_pEditor->getCurrentLayer();
if (layer->type == Layer::BITMAP)
{
for (int i = 0; i < p.size(); i++) {
p[i] = m_pScribbleArea->pixelToPoint(p[i]);
}
qreal opacity = 1.0;
qreal brushWidth = currentWidth + 0.5 * properties.feather;
qreal offset = qMax(0.0, currentWidth - 0.5 * properties.feather) / brushWidth;
opacity = currentPressure;
brushWidth = brushWidth * currentPressure;
// if (tabletInUse) { opacity = tabletPressure; }
// if (usePressure) { brushWidth = brushWidth * tabletPressure; }
qreal brushStep = 0.5 * currentWidth + 0.5 * properties.feather;
brushStep = brushStep * currentPressure;
// if (usePressure) { brushStep = brushStep * tabletPressure; }
brushStep = qMax(1.0, brushStep);
currentWidth = properties.width;
BlitRect rect;
QRadialGradient radialGrad(QPointF(0,0), 0.5 * brushWidth);
m_pScribbleArea->setGaussianGradient(radialGrad,
m_pEditor->colorManager()->frontColor(),
opacity,
offset);
QPointF a = lastBrushPoint;
QPointF b = getCurrentPoint();
// foreach (QSegment segment, calculateStroke(brushWidth))
// {
// QPointF a = lastBrushPoint;
// QPointF b = m_pScribbleArea->pixelToPoint(segment.second);
qreal distance = 4 * QLineF(b, a).length();
int steps = qRound(distance) / brushStep;
for (int i = 0; i < steps; i++)
{
QPointF point = lastBrushPoint + (i + 1) * (brushStep) * (b - lastBrushPoint) / distance;
rect.extend(point.toPoint());
m_pScribbleArea->drawBrush( point,
brushWidth,
offset,
m_pEditor->colorManager()->frontColor(),
opacity);
if (i == (steps - 1))
{
lastBrushPoint = point;
}
}
// }
int rad = qRound(brushWidth) / 2 + 2;
m_pScribbleArea->refreshBitmap(rect, rad);
}
else if (layer->type == Layer::VECTOR)
{
QPen pen(Qt::gray, 1, Qt::DashLine, Qt::RoundCap, Qt::RoundJoin);
int rad = qRound((currentWidth / 2 + 2) * qAbs(m_pScribbleArea->getTempViewScaleX()));
// foreach (QSegment segment, calculateStroke(currentWidth))
// {
// QPointF a = segment.first;
// QPointF b = segment.second;
// m_pScribbleArea->drawLine(a, b, pen, QPainter::CompositionMode_SourceOver);
// m_pScribbleArea->refreshVector(QRect(a.toPoint(), b.toPoint()), rad);
// }
if (p.size() == 4) {
QSizeF size(2,2);
QPainterPath path(p[0]);
path.cubicTo(p[1],
p[2],
p[3]);
m_pScribbleArea->drawPath(path, pen, Qt::NoBrush, QPainter::CompositionMode_Source);
m_pScribbleArea->refreshVector(path.boundingRect().toRect(), rad);
}
}
}
/*!
Reimplementation of QGraphicsItem::paint(). This function does the actual painting of the legend.
\sa QGraphicsItem::paint().
*/
void CartesianPlotLegendPrivate::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) {
Q_UNUSED(option);
Q_UNUSED(widget);
if (!isVisible())
return;
painter->save();
//draw the area
painter->setOpacity(backgroundOpacity);
painter->setPen(Qt::NoPen);
if (backgroundType == PlotArea::Color){
switch (backgroundColorStyle){
case PlotArea::SingleColor:{
painter->setBrush(QBrush(backgroundFirstColor));
break;
}
case PlotArea::HorizontalLinearGradient:{
QLinearGradient linearGrad(rect.topLeft(), rect.topRight());
linearGrad.setColorAt(0, backgroundFirstColor);
linearGrad.setColorAt(1, backgroundSecondColor);
painter->setBrush(QBrush(linearGrad));
break;
}
case PlotArea::VerticalLinearGradient:{
QLinearGradient linearGrad(rect.topLeft(), rect.bottomLeft());
linearGrad.setColorAt(0, backgroundFirstColor);
linearGrad.setColorAt(1, backgroundSecondColor);
painter->setBrush(QBrush(linearGrad));
break;
}
case PlotArea::TopLeftDiagonalLinearGradient:{
QLinearGradient linearGrad(rect.topLeft(), rect.bottomRight());
linearGrad.setColorAt(0, backgroundFirstColor);
linearGrad.setColorAt(1, backgroundSecondColor);
painter->setBrush(QBrush(linearGrad));
break;
}
case PlotArea::BottomLeftDiagonalLinearGradient:{
QLinearGradient linearGrad(rect.bottomLeft(), rect.topRight());
linearGrad.setColorAt(0, backgroundFirstColor);
linearGrad.setColorAt(1, backgroundSecondColor);
painter->setBrush(QBrush(linearGrad));
break;
}
case PlotArea::RadialGradient:{
QRadialGradient radialGrad(rect.center(), rect.width()/2);
radialGrad.setColorAt(0, backgroundFirstColor);
radialGrad.setColorAt(1, backgroundSecondColor);
painter->setBrush(QBrush(radialGrad));
break;
}
}
}else if (backgroundType == PlotArea::Image){
if ( !backgroundFileName.trimmed().isEmpty() ) {
QPixmap pix(backgroundFileName);
switch (backgroundImageStyle){
case PlotArea::ScaledCropped:
pix = pix.scaled(rect.size().toSize(),Qt::KeepAspectRatioByExpanding,Qt::SmoothTransformation);
painter->drawPixmap(rect.topLeft(),pix);
break;
case PlotArea::Scaled:
pix = pix.scaled(rect.size().toSize(),Qt::IgnoreAspectRatio,Qt::SmoothTransformation);
painter->drawPixmap(rect.topLeft(),pix);
break;
case PlotArea::ScaledAspectRatio:
pix = pix.scaled(rect.size().toSize(),Qt::KeepAspectRatio,Qt::SmoothTransformation);
painter->drawPixmap(rect.topLeft(),pix);
break;
case PlotArea::Centered:
painter->drawPixmap(QPointF(rect.center().x()-pix.size().width()/2,rect.center().y()-pix.size().height()/2),pix);
break;
case PlotArea::Tiled:
painter->drawTiledPixmap(rect,pix);
break;
case PlotArea::CenterTiled:
painter->drawTiledPixmap(rect,pix,QPoint(rect.size().width()/2,rect.size().height()/2));
}
}
} else if (backgroundType == PlotArea::Pattern){
painter->setBrush(QBrush(backgroundFirstColor,backgroundBrushStyle));
}
if ( qFuzzyIsNull(borderCornerRadius) )
painter->drawRect(rect);
else
painter->drawRoundedRect(rect, borderCornerRadius, borderCornerRadius);
//draw the border
if (borderPen.style() != Qt::NoPen){
painter->setPen(borderPen);
painter->setBrush(Qt::NoBrush);
painter->setOpacity(borderOpacity);
if ( qFuzzyIsNull(borderCornerRadius) )
painter->drawRect(rect);
else
painter->drawRoundedRect(rect, borderCornerRadius, borderCornerRadius);
}
//draw curve's line+symbol and the names
int curveCount = curvesList.size();
QFontMetrics fm(labelFont);
float h=fm.ascent();
XYCurve* curve;
painter->setFont(labelFont);
//translate to left upper conner of the bounding rect plus the layout offset and the height of the title
painter->translate(-rect.width()/2+layoutLeftMargin, -rect.height()/2+layoutTopMargin);
if (title->isVisible() && !title->text().text.isEmpty())
painter->translate(0, title->graphicsItem()->boundingRect().height());
painter->save();
int index;
for (int c=0; c<columnCount; ++c) {
for (int r=0; r<rowCount; ++r) {
if (labelColumnMajor)
index = c*rowCount + r;
else
index = r*columnCount + c;
if ( index >= curveCount )
break;
curve = curvesList.at(index);
//curve's line (painted at the half of the ascent size)
if (curve->lineType() != XYCurve::NoLine){
painter->setPen(curve->linePen());
painter->setOpacity(curve->lineOpacity());
painter->drawLine(0, h/2, lineSymbolWidth, h/2);
}
//error bars
if ( (curve->xErrorType() != XYCurve::NoError) || (curve->yErrorType() != XYCurve::NoError) ) {
painter->setOpacity(curve->errorBarsOpacity());
painter->setPen(curve->errorBarsPen());
//curve's error bars for x
float errorBarsSize = Worksheet::convertToSceneUnits(10, Worksheet::Point);
if (curve->symbolsStyle()!=Symbol::NoSymbols && errorBarsSize<curve->symbolsSize()*1.4)
errorBarsSize = curve->symbolsSize()*1.4;
switch(curve->errorBarsType()) {
case XYCurve::ErrorBarsSimple:
//horiz. line
painter->drawLine(lineSymbolWidth/2-errorBarsSize/2, h/2,
lineSymbolWidth/2+errorBarsSize/2, h/2);
//vert. line
painter->drawLine(lineSymbolWidth/2, h/2-errorBarsSize/2,
lineSymbolWidth/2, h/2+errorBarsSize/2);
break;
case XYCurve::ErrorBarsWithEnds: {
//horiz. line
painter->drawLine(lineSymbolWidth/2-errorBarsSize/2, h/2,
lineSymbolWidth/2+errorBarsSize/2, h/2);
//vert. line
painter->drawLine(lineSymbolWidth/2, h/2-errorBarsSize/2,
lineSymbolWidth/2, h/2+errorBarsSize/2);
//caps for the horiz. line
painter->drawLine(lineSymbolWidth/2-errorBarsSize/2, h/2-errorBarsSize/4,
lineSymbolWidth/2-errorBarsSize/2, h/2+errorBarsSize/4);
painter->drawLine(lineSymbolWidth/2+errorBarsSize/2, h/2-errorBarsSize/4,
lineSymbolWidth/2+errorBarsSize/2, h/2+errorBarsSize/4);
//caps for the vert. line
painter->drawLine(lineSymbolWidth/2-errorBarsSize/4, h/2-errorBarsSize/2,
lineSymbolWidth/2+errorBarsSize/4, h/2-errorBarsSize/2);
painter->drawLine(lineSymbolWidth/2-errorBarsSize/4, h/2+errorBarsSize/2,
lineSymbolWidth/2+errorBarsSize/4, h/2+errorBarsSize/2);
break;
}
}
}
//curve's symbol
if (curve->symbolsStyle()!=Symbol::NoSymbols){
painter->setOpacity(curve->symbolsOpacity());
painter->setBrush(curve->symbolsBrush());
painter->setPen(curve->symbolsPen());
QPainterPath path = Symbol::pathFromStyle(curve->symbolsStyle());
QTransform trafo;
trafo.scale(curve->symbolsSize(), curve->symbolsSize());
path = trafo.map(path);
if (curve->symbolsRotationAngle() != 0) {
trafo.reset();
trafo.rotate(curve->symbolsRotationAngle());
path = trafo.map(path);
}
painter->translate(QPointF(lineSymbolWidth/2, h/2));
painter->drawPath(path);
painter->translate(-QPointF(lineSymbolWidth/2, h/2));
}
//curve's name
painter->setPen(QPen(labelColor));
painter->setOpacity(1.0);
painter->drawText(QPoint(lineSymbolWidth+layoutHorizontalSpacing, h), curve->name());
painter->translate(0,layoutVerticalSpacing+h);
}
//translate to the beginning of the next column
painter->restore();
int deltaX = lineSymbolWidth+layoutHorizontalSpacing+maxColumnTextWidths.at(c); //the width of the current columns
deltaX += 2*layoutHorizontalSpacing; //spacing between two columns
painter->translate(deltaX,0);
painter->save();
}
painter->restore();
painter->restore();
if (m_hovered && !isSelected() && !m_printing){
painter->setPen(q->hoveredPen);
painter->setOpacity(q->hoveredOpacity);
painter->drawPath(shape());
}
if (isSelected() && !m_printing){
painter->setPen(q->selectedPen);
painter->setOpacity(q->selectedOpacity);
painter->drawPath(shape());
}
}
void TimelineWidget::paintEvent(QPaintEvent* event)
{
if (similar(mStart,mStop))
return;
QWidget::paintEvent(event);
QPainter painter(this);
// QPen pointPen, pointLinePen;
painter.setRenderHint(QPainter::Antialiasing);
painter.setPen(Qt::NoPen);
QColor gray0(240, 240, 240);
QColor gray01(220, 220, 220);
QColor gray1(200, 200, 200);
QColor gray2(170, 170, 170); // darker
QColor gray3(150, 150, 150); // even darker
QColor gray4(100, 100, 100); // even darker
QColor highlight(110, 214, 255); // color around highlighted circle in qslider on KDE.
// Fill with white background color and grey plot area background color
QBrush brush(Qt::SolidPattern); // = painter.brush();
brush.setColor(gray2);
painter.setBrush(brush);
painter.drawRoundedRect(this->mFullArea, 4, 4);
// brush.setColor(gray01);
brush.setColor(gray1);
painter.setBrush(brush);
painter.drawRoundedRect(this->mPlotArea, 4, 4);
int margin = 1;
// draw noncompacted interval
for (unsigned i = 0; i < mNoncompactedIntervals.size(); ++i)
{
int start_p = this->mapTime2PlotX(mNoncompactedIntervals[i].mStartTime);
int stop_p = this->mapTime2PlotX(mNoncompactedIntervals[i].mEndTime);
QColor color = gray01;
painter.fillRect(QRect(start_p, mPlotArea.top(), stop_p - start_p, mPlotArea.height()), color);
}
// draw all continous events
for (unsigned i = 0; i < mEvents.size(); ++i)
{
if (!mContinousEvents.contains(mEvents[i].mGroup))
continue;
int start_p = this->mapTime2PlotX(mEvents[i].mStartTime);
int stop_p = this->mapTime2PlotX(mEvents[i].mEndTime);
int level = std::distance(mContinousEvents.begin(),
std::find(mContinousEvents.begin(), mContinousEvents.end(), mEvents[i].mGroup));
int level_max = mContinousEvents.size();
int thisHeight = (mPlotArea.height()) / level_max - margin * (level_max - 1) / level_max;
int thisTop = mPlotArea.top() + level * thisHeight + level * margin;
// QColor color = mEventColors[level % mEventColors.size()];
QColor color = mEvents[i].mColor;
painter.fillRect(QRect(start_p, thisTop, stop_p - start_p, thisHeight), color);
}
// draw all singular events
for (unsigned i = 0; i < mEvents.size(); ++i)
{
if (mContinousEvents.contains(mEvents[i].mGroup))
continue;
int start_p = this->mapTime2PlotX(mEvents[i].mStartTime);
// int stop_p = this->mapTime2PlotX(mEvents[i].mEndTime);
int glyphWidth = 3;
QRect rect(start_p - glyphWidth / 2, mPlotArea.top(), glyphWidth, mPlotArea.height());
brush.setColor(QColor(50, 50, 50));
painter.setBrush(brush);
painter.drawRoundedRect(rect, 2, 2);
// painter.fillRect(rect, gray4);
if (rect.width() > 2 && rect.height() > 2)
{
rect.adjust(1, 1, -1, -1);
painter.fillRect(rect, gray2);
}
}
int offset_p = this->mapTime2PlotX(mPos);
QPolygonF glyph;
int z = 5;
int h = mPlotArea.height();
glyph.push_back(QPointF(-z, 0));
glyph.push_back(QPointF(z, 0));
glyph.push_back(QPointF(z, 0.7 * h));
glyph.push_back(QPointF(0, h));
glyph.push_back(QPointF(-z, 0.7 * h));
glyph.translate(offset_p, 0);
if (this->hasFocus() || mCloseToGlyph)
painter.setPen(highlight);
else
painter.setPen(gray4);
// QBrush brush(Qt::SolidPattern);// = painter.brush();
QRadialGradient radialGrad(QPointF(offset_p, h / 3), 2 * h / 3);
radialGrad.setColorAt(0, gray0);
// radialGrad.setColorAt(0.5, Qt::blue);
radialGrad.setColorAt(1, gray2);
brush = QBrush(radialGrad);
// brush.setColor(gray0);
painter.setBrush(brush);
painter.drawPolygon(glyph);
}
