QwtBeginner::QwtBeginner(QWidget *parent)
: QWidget(parent)
{
funPlot = new QwtPlot;
funPlot->setTitle("Function");
QPen myPen = QPen(Qt::blue);
myPen.setWidth(2);
myPen.setCapStyle(Qt::RoundCap);
QPen dotPen = QPen(Qt::red);
dotPen.setWidth(5);
dotPen.setCapStyle(Qt::RoundCap);
myCurve = new QwtPlotCurve;
myCurve->setPen(myPen);
myCurve->attach(funPlot);
dot = new QwtPlotCurve;
dot->setPen(dotPen);
dot->attach(funPlot);
dot->setStyle(QwtPlotCurve::Dots);
QHBoxLayout *plotsLayout = new QHBoxLayout;
plotsLayout->setSpacing(10);
plotsLayout->addWidget(funPlot);
QVBoxLayout *widgetLayout = new QVBoxLayout;
widgetLayout->addLayout(plotsLayout);
setLayout(widgetLayout);
}
void SVGPaintServer::setPenProperties(const RenderObject* object, const RenderStyle* style, QPen& pen) const
{
pen.setWidthF(SVGRenderStyle::cssPrimitiveToLength(object, style->svgStyle()->strokeWidth(), 1.0));
if (style->svgStyle()->capStyle() == ButtCap)
pen.setCapStyle(Qt::FlatCap);
else if (style->svgStyle()->capStyle() == RoundCap)
pen.setCapStyle(Qt::RoundCap);
if (style->svgStyle()->joinStyle() == MiterJoin) {
pen.setJoinStyle(Qt::MiterJoin);
pen.setMiterLimit((qreal) style->svgStyle()->strokeMiterLimit());
} else if(style->svgStyle()->joinStyle() == RoundJoin)
pen.setJoinStyle(Qt::RoundJoin);
const DashArray& dashes = WebCore::dashArrayFromRenderingStyle(style);
double dashOffset = SVGRenderStyle::cssPrimitiveToLength(object, style->svgStyle()->strokeDashOffset(), 0.0);
unsigned int dashLength = !dashes.isEmpty() ? dashes.size() : 0;
if(dashLength) {
QVector<qreal> pattern;
unsigned int count = (dashLength % 2) == 0 ? dashLength : dashLength * 2;
for(unsigned int i = 0; i < count; i++)
pattern.append(dashes[i % dashLength] / (float)pen.widthF());
pen.setDashPattern(pattern);
Q_UNUSED(dashOffset);
// TODO: dash-offset, does/will qt4 API allow it? (Rob)
}
}
////////////////////////////////////////////////////////////////////////////////
/// CPuzzleNodeArtist::drawArrow
///
/// @description This function draws an arrow indicating a start
/// node.
/// @pre None
/// @post An arrow is drawn on the screen indicating the
/// start node.
///
/// @param painter: This is a pointer to the QPainter object which
/// draws the arrow to the screen.
/// @param boundingRect: This is the bounding rectangle of the node which
/// is the start node.
/// @param angleNorthOfEast: This is the angle in degrees from the East
/// direction going North to draw the arrow at.
///
/// @limitations None
///
////////////////////////////////////////////////////////////////////////////////
void CPuzzleNodeArtist::drawArrow( QPainter *painter, QRect &boundingRect,
qreal angleNorthOfEast )
{
QMatrix backupMatrix = painter->matrix();
QPen backupPen = painter->pen();
QPen editPen = m_style->getPen();
int w = painter->pen().width();
int d = m_style->getNodeRadius() * 2;
painter->translate( boundingRect.center() );
painter->rotate( -angleNorthOfEast );
painter->translate( (d/2)+(w*2), 0 );
editPen.setCapStyle( Qt::FlatCap );
painter->setPen( editPen );
painter->drawLine( 5, 4, (int)(d*.60), 4 );
painter->drawLine( 5, -4, (int)(d*.60), -4 );
editPen.setCapStyle( Qt::SquareCap );
painter->setPen( editPen );
painter->drawLine( 0, 0, (int)(d*.25), (int)(d*.25) );
painter->drawLine( 0, 0, (int)(d*.25), -(int)(d*.25) );
painter->setPen( backupPen );
painter->setMatrix( backupMatrix );
}
// Parse a <g> tag while opening a file
void svgParseGroup(const QDomElement &element, NoteEditor *editor, QPen pen)
{
if (element.tagName() != "g") return;
// Convert the <g> tag into a QPen
if (element.hasAttribute("stroke-width"))
pen.setWidthF(element.attribute("stroke-width").toDouble());
if (element.hasAttribute("stroke")) {
// Colors by hex value with '#' prefix
if (element.attribute("stroke").at(0) == '#') {
pen.setColor(QColor(element.attribute("stroke")
.right(6).toInt(0, 16)));
}
// TODO: handle colors by name
}
if (element.hasAttribute("stroke-linecap")) {
QString linecap = element.attribute("stroke-linecap");
if (linecap == "square") {
pen.setCapStyle(Qt::SquareCap);
} else if (linecap == "round") {
pen.setCapStyle(Qt::RoundCap);
} else if (linecap == "butt") {
pen.setCapStyle(Qt::FlatCap);
}
}
QDomElement child = element.firstChildElement();
while (!child.isNull()) {
if (child.tagName() == "g") {
svgParseGroup(child, editor, pen);
} else if (child.tagName() == "polyline") {
// Get curve from points, add to editor
Curve *curve = new Curve(pen);
QStringList pointStrs = child.attribute("points")
.split(' ', QString::SkipEmptyParts);
QStringList::iterator itr;
for (itr = pointStrs.begin(); itr != pointStrs.end(); ++itr) {
QStringList curPointStr =
itr->split(',', QString::SkipEmptyParts);
QPointF point(curPointStr[0].toDouble(),
curPointStr[1].toDouble());
editor->addPointToCurve(point, curve);
}
editor->addCurve(curve);
}
child = child.nextSiblingElement();
}
}
// ********************************************************
ImageBufferData::ImageBufferData(const IntSize& size, bool accelerated)
{
QPainter* painter = new QPainter;
m_painter = adoptPtr(painter);
#if ENABLE(ACCELERATED_2D_CANVAS)
if (accelerated) {
m_impl = adoptPtr(new ImageBufferDataPrivateAccelerated(size));
} else
#endif
m_impl = adoptPtr(new ImageBufferDataPrivateUnaccelerated(size));
if (!m_impl->paintDevice())
return;
if (!painter->begin(m_impl->paintDevice()))
return;
painter->setRenderHints(QPainter::Antialiasing | QPainter::HighQualityAntialiasing);
QPen pen = painter->pen();
pen.setColor(Qt::black);
pen.setWidth(1);
pen.setCapStyle(Qt::FlatCap);
pen.setJoinStyle(Qt::SvgMiterJoin);
pen.setMiterLimit(10);
painter->setPen(pen);
QBrush brush = painter->brush();
brush.setColor(Qt::black);
painter->setBrush(brush);
painter->setCompositionMode(QPainter::CompositionMode_SourceOver);
}
void GLEDrawingObject::setPenProperties(QPen& pen) {
setSimplePenProperties(pen);
GLEDrawObject* obj = getGLEObject();
int cap = obj->getIntProperty(GLEDOPropertyLineCap);
switch (cap) {
case GLELineCapButt:
pen.setCapStyle(Qt::FlatCap);
break;
case GLELineCapRound:
pen.setCapStyle(Qt::RoundCap);
break;
case GLELineCapSquare:
pen.setCapStyle(Qt::SquareCap);
break;
}
}
void DoubleSlider::paintEvent(QPaintEvent *)
{
QPainter painter(this);
QStyleOptionSlider option;
option.initFrom(this);
option.maximum = maximum();
option.minimum = minimum();
option.sliderPosition = v1;
style()->drawComplexControl(QStyle::CC_Slider, &option, &painter, this);
QRect handle1 = style()->subControlRect(QStyle::CC_Slider, &option, QStyle::SC_SliderHandle, this);
option.sliderPosition = v2;
option.subControls = QStyle::SC_SliderHandle;
style()->drawComplexControl(QStyle::CC_Slider, &option, &painter, this);
QRect handle2 = style()->subControlRect(QStyle::CC_Slider, &option, QStyle::SC_SliderHandle, this);
QPen p;
p.setColor(QColor(0, 0, 200, 150));
p.setWidth(handle1.height()-6);
p.setCapStyle(Qt::FlatCap);
painter.setPen(p);
QRect groove = style()->subControlRect(QStyle::CC_Slider, &option, QStyle::SC_SliderGroove, this);
int wi = handle1.width();
painter.drawLine(handle1.x()+wi, handle1.height()/2, handle2.x(), handle1.height()/2);
painter.end();
}
void QmitkScalarBarOverlay::GetProperties( mitk::PropertyList::Pointer pl )
{
if ( pl.IsNull() )
return;
QPen pen = QPen();
mitk::PropertyList::Pointer propertyList = pl;
QPalette palette = QPalette();
// get the desired color of the textOverlays
mitk::ColorProperty::Pointer colorProp =
dynamic_cast<mitk::ColorProperty*>( propertyList->GetProperty( "overlay.color" ) );
if ( colorProp.IsNull() )
{
MITK_DEBUG << "creating new colorProperty";
colorProp = mitk::ColorProperty::New( 127.0, 196.0, 232.0 );
}
mitk::Color color = colorProp->GetColor();
pen.setColor( QColor( color[0],color[1],color[2],255 ) );
pen.setStyle( Qt::SolidLine );
pen.setCapStyle( Qt::FlatCap );
pen.setJoinStyle( Qt::MiterJoin );
m_ScalarBar->SetPen( pen );
}
void Context2D::setupPainter()
{
m_painter.setRenderHint(QPainter::Antialiasing, true);
if ((m_state.flags & DirtyClippingRegion) && !m_state.clipPath.isEmpty())
m_painter.setClipPath(m_state.clipPath);
if (m_state.flags & DirtyFillStyle)
m_painter.setBrush(m_state.fillStyle);
if (m_state.flags & DirtyGlobalAlpha)
m_painter.setOpacity(m_state.globalAlpha);
if (m_state.flags & DirtyGlobalCompositeOperation)
m_painter.setCompositionMode(m_state.globalCompositeOperation);
if (m_state.flags & MDirtyPen) {
QPen pen = m_painter.pen();
if (m_state.flags & DirtyStrokeStyle)
pen.setBrush(m_state.strokeStyle);
if (m_state.flags & DirtyLineWidth)
pen.setWidthF(m_state.lineWidth);
if (m_state.flags & DirtyLineCap)
pen.setCapStyle(m_state.lineCap);
if (m_state.flags & DirtyLineJoin)
pen.setJoinStyle(m_state.lineJoin);
if (m_state.flags & DirtyMiterLimit)
pen.setMiterLimit(m_state.miterLimit);
m_painter.setPen(pen);
}
}
void
eyes::ShowPointer ()
{
QPoint mid (this->width()/2, this->height()/2);
double midx = double(mid.x());
double midy = double(mid.y());
QPoint cursPoint (QCursor::pos());
QPoint midGlobal = this->mapToGlobal(mid);
double dx = double(cursPoint.x()) - double (midGlobal.x());
double dy = double(cursPoint.y()) - double (midGlobal.y());
double dist = sqrt(dx*dx + dy*dy);
double theta = -atan2(dx,dy) * 180.0/M_PI;
double len = (midx > midy ? midy : midx);
if (len > dist) { len = dist; }
int shortlen = int(len /10.0);
QPainter paint(this);
paint.setRenderHint(QPainter::HighQualityAntialiasing);
paint.setBrush(Qt::NoBrush);
QPen linePen;
linePen.setColor(QColor(0,0,255,255));
linePen.setWidth(len*0.05);
linePen.setCapStyle(Qt::RoundCap);
paint.setPen(linePen);
paint.translate(mid);
paint.rotate(theta);
paint.save();
paint.drawLine(0,0,0,int(len));
paint.restore();
paint.translate(0,int(len));
paint.drawLine(0,0,-shortlen,-shortlen);
paint.drawLine(0,0,shortlen, -shortlen);
}
void KivioStencilFormatDlg::initLineEndStyles()
{
QBitmap mask;
QPixmap pix(m_lineEndStyleCBox->width(), 17);
QPainter p(&pix, m_lineEndStyleCBox);
QPen pen;
pen.setColor(QColor(0, 0, 0));
pen.setWidth(4);
pen.setStyle(SolidLine);
pen.setJoinStyle(RoundJoin);
p.setBrush(white);
for (int i = 0; i < 3; i++) {
pix.fill(white);
pen.setCapStyle(static_cast<PenCapStyle>(i * 0x10));
p.setPen(pen);
p.drawLine(6, 8, pix.width() - 12, 8);
mask = pix;
pix.setMask(mask);
m_lineEndStyleCBox->insertItem(pix, i);
}
p.end();
}
bool AbstractGeoPolygonGraphicsItem::configurePainter(GeoPainter *painter, const ViewportParams &viewport) const
{
QPen currentPen = painter->pen();
GeoDataStyle::ConstPtr style = this->style();
if (!style) {
painter->setPen( QPen() ); // "style-less" polygons: a 1px black solid line
}
else {
const GeoDataPolyStyle& polyStyle = style->polyStyle();
if (polyStyle.outline()) {
const GeoDataLineStyle& lineStyle = style->lineStyle();
// To save performance we avoid making changes to the painter's pen.
// So we first take a copy of the actual painter pen, make changes to it
// and only if the resulting pen is different from the actual pen
// we replace the painter's pen with our new pen.
// We want to avoid the mandatory detach in QPen::setColor(),
// so we carefully check whether applying the setter is needed
currentPen.setColor(lineStyle.paintedColor());
currentPen.setWidthF(lineStyle.width());
currentPen.setCapStyle(lineStyle.capStyle());
currentPen.setStyle(lineStyle.penStyle());
if (painter->pen().color() != currentPen.color()) {
painter->setPen(currentPen);
}
}
else {
// polygons without outline: Qt::NoPen (not drawn)
if (currentPen.style() != Qt::NoPen) {
painter->setPen(Qt::NoPen);
}
}
if (!polyStyle.fill()) {
painter->setBrush(Qt::transparent);
}
else {
const QColor paintedColor = polyStyle.paintedColor();
if (painter->brush().color() != paintedColor ||
painter->brush().style() != polyStyle.brushStyle()) {
if (!polyStyle.texturePath().isEmpty() || !polyStyle.textureImage().isNull()) {
GeoDataCoordinates coords = latLonAltBox().center();
qreal x, y;
viewport.screenCoordinates(coords, x, y);
QBrush brush(texture(polyStyle.texturePath(), paintedColor));
painter->setBrush(brush);
painter->setBrushOrigin(QPoint(x,y));
}
else {
painter->setBrush(QBrush(paintedColor, polyStyle.brushStyle()));
}
}
}
}
return true;
}
void OGraphicsEllipseItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
DBG_p("OGraphicsEllipseItem::mouseReleaseEvent\n");
OGraphicsScene *s = dynamic_cast<OGraphicsScene *>(scene());
OASSET(s != NULL);
QList<QGraphicsItem *> il = s->selectedItems();
// extractItemsByType(&il, ClassInfo::OConfNode);
extractItemsByTypes(&il, ClassInfo::OConfNode, ClassInfo::OLogpoolNode);
DBG_p("il.size()=%d\n", il.size());
if (il.size() == 2) {
OAbstractNode *no1 = dynamic_cast<OAbstractNode*>(il[0]);
OAbstractNode *no2 = dynamic_cast<OAbstractNode*>(il[1]);
if (no1 == NULL || no2 == NULL) return;
OGraphicsEllipseItem *el1 = no1->getSelectedPoint();
OGraphicsEllipseItem *el2 = no2->getSelectedPoint();
if (OAbstractNode::connect(no1, el1, no2, el2)) {
QPointF e_size = QPointF(ELLIPSE_SIZE / 2, ELLIPSE_SIZE / 2);
QLineF lf(el1->getAbsolutePos() + e_size, el2->getAbsolutePos() + e_size);
QGraphicsLineItem *gli = new QGraphicsLineItem(lf);
// gli->setFlag(QGraphicsItem::ItemIsSelectable);
el1->setLine(gli);
el2->setLine(gli);
QPen p;
p.setColor(ELLIPSE_DEFAULT_COLOR);
p.setCapStyle(Qt::RoundCap);
p.setWidth(5);
gli->setPen(p);
s->addItem(gli);
}
el1->unselect();
el2->unselect();
s->clearSelection();
}
}
QImage* createNumber(int i,int r,int g,int b,int a)
{
QImage* img = new QImage(32,32,QImage::Format_ARGB32);
QPainter *p = new QPainter();
QBrush br;
p->begin(img);
QColor black(0,0,0,0);
for (int i=0;i<img->width();i++)
for (int j=0;j<img->height();j++)
{
img->setPixel(i,j,black.rgba());
}
QColor txtcolor(r,g,b,a);
QPen pen;
pen.setStyle(Qt::SolidLine);
pen.setWidth(3);
pen.setBrush(txtcolor);
pen.setCapStyle(Qt::RoundCap);
pen.setJoinStyle(Qt::RoundJoin);
p->setPen(pen);
QFont f;
f.setBold(true);
f.setPointSize(26);
p->setFont(f);
p->drawText(img->width()/2-15,img->height()/2-15,30,30,Qt::AlignCenter,QString("%1").arg(i));
p->end();
delete p;
return img;
}
void UBSpinningWheel::paintEvent(QPaintEvent *event)
{
Q_UNUSED(event);
qreal side = qMin(width() / 2, height() / 2);
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing);
painter.translate(width() / 2, height() / 2);
QPen pen;
pen.setWidthF(side / 6.5);
pen.setCapStyle(Qt::RoundCap);
painter.setPen(pen);
painter.rotate(30 * (mPosition % 12));
for(int i = 0; i < 12; i++)
{
painter.drawLine(QPointF(side / 2, 0), QPointF(0.9 * side, 0));
painter.rotate(30);
QColor color = pen.color();
color.setAlphaF(0.25 + (i / 16.));
pen.setColor(color);
painter.setPen(pen);
}
}
void CurveLine::drawPort(QPainter *painter, int portNumber)
{
if ((portNumber == 0) || (portNumber == mEdge->line().count() - 1)) {
LineHandler::drawPort(painter, portNumber);
return;
}
QPen pen;
pen.setCapStyle(Qt::RoundCap);
QColor color;
QPointF p1(-0.25, 0);
QPointF p2(0.25, 0);
color.setNamedColor("#ffcc66");
pen.setWidth(12);
pen.setColor(color);
painter->setPen(pen);
painter->drawLine(p1, p2);
color.setNamedColor("#ff6666");
pen.setWidth(3);
pen.setColor(color);
painter->setPen(pen);
painter->drawLine(p1, p2);
}
ImageBufferData::ImageBufferData(const IntSize& size)
: m_pixmap(size)
{
if (m_pixmap.isNull())
return;
m_pixmap.fill(QColor(Qt::transparent));
QPainter* painter = new QPainter;
m_painter = adoptPtr(painter);
if (!painter->begin(&m_pixmap))
return;
// Since ImageBuffer is used mainly for Canvas, explicitly initialize
// its painter's pen and brush with the corresponding canvas defaults
// NOTE: keep in sync with CanvasRenderingContext2D::State
QPen pen = painter->pen();
pen.setColor(Qt::black);
pen.setWidth(1);
pen.setCapStyle(Qt::FlatCap);
pen.setJoinStyle(Qt::SvgMiterJoin);
pen.setMiterLimit(10);
painter->setPen(pen);
QBrush brush = painter->brush();
brush.setColor(Qt::black);
painter->setBrush(brush);
painter->setCompositionMode(QPainter::CompositionMode_SourceOver);
m_image = StillImage::createForRendering(&m_pixmap);
}
void QPaintEngineEx::drawPoints(const QPoint *points, int pointCount)
{
QPen pen = state()->pen;
if (pen.capStyle() == Qt::FlatCap)
pen.setCapStyle(Qt::SquareCap);
if (pen.brush().isOpaque()) {
while (pointCount > 0) {
int count = qMin(pointCount, 16);
qreal pts[64];
int oset = -1;
for (int i=0; i<count; ++i) {
pts[++oset] = points[i].x();
pts[++oset] = points[i].y();
pts[++oset] = points[i].x() + 1/63.;
pts[++oset] = points[i].y();
}
QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::LinesHint);
stroke(path, pen);
pointCount -= 16;
points += 16;
}
} else {
for (int i=0; i<pointCount; ++i) {
qreal pts[] = { qreal(points[i].x()), qreal(points[i].y()),
qreal(points[i].x() +1/63.), qreal(points[i].y()) };
QVectorPath path(pts, 2, 0);
stroke(path, pen);
}
}
}
void DrawStaticLoading(
QPainter &p,
QRectF rect,
int stroke,
QPen pen,
QBrush brush) {
PainterHighQualityEnabler hq(p);
p.setBrush(brush);
pen.setWidthF(stroke);
pen.setCapStyle(Qt::RoundCap);
pen.setJoinStyle(Qt::RoundJoin);
p.setPen(pen);
p.drawEllipse(rect);
const auto center = rect.center();
const auto first = QPointF(center.x(), rect.y() + 1.5 * stroke);
const auto delta = center.y() - first.y();
const auto second = QPointF(center.x() + delta * 2 / 3., center.y());
if (delta > 0) {
QPainterPath path;
path.moveTo(first);
path.lineTo(center);
path.lineTo(second);
p.drawPath(path);
}
}
void QgsMeshVectorRenderer::draw()
{
// Set up the render configuration options
QPainter *painter = mContext.painter();
painter->save();
if ( mContext.flags() & QgsRenderContext::Antialiasing )
painter->setRenderHint( QPainter::Antialiasing, true );
painter->setRenderHint( QPainter::Antialiasing );
QPen pen = painter->pen();
pen.setCapStyle( Qt::FlatCap );
pen.setJoinStyle( Qt::MiterJoin );
double penWidth = mContext.convertToPainterUnits( mCfg.lineWidth(),
QgsUnitTypes::RenderUnit::RenderMillimeters );
pen.setWidthF( penWidth );
pen.setColor( mCfg.color() );
painter->setPen( pen );
if ( mDataOnVertices )
drawVectorDataOnVertices();
else
drawVectorDataOnFaces();
painter->restore();
}
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 GaugeCompass::drawScale(QPainter *painter)
{
int radius = 85;
painter->save();
painter->setPen(foreground);
//总共8格,4格为NESW字母,4格为线条
int steps = 8;
double angleStep = 360.0 / steps;
QPen pen = painter->pen();
pen.setCapStyle(Qt::RoundCap);
pen.setWidth(4);
painter->setPen(pen);
//%2整数部分绘制NESW字母,其余绘制线条刻度
for (int i = 0; i <= steps; i++) {
if (i % 2 != 0) {
painter->drawLine(0, radius - 10, 0, radius);
}
painter->rotate(angleStep);
}
painter->restore();
}
////////////////////////////////////////////////////////////////////////////////
/// CPuzzleSpanArtist::paintStraightArrow
///
/// @description This function paints an arrow on the straight edge
/// between the two given nodes, pointing at the second
/// node.
/// @pre None
/// @post An arrow is painted on the straight edge pointing to
/// the second node.
///
/// @param nodeFromPos: This is the point the straight edge begins at.
/// @param nodeToPos: This is the point the straight edge terminates at.
/// @param painter: This is a pointer to the QPainter which will paint the
/// edge.
///
/// @limitations None
///
////////////////////////////////////////////////////////////////////////////////
void CPuzzleSpanArtist::paintStraightArrow( QPoint nodeFromPos,
QPoint nodeToPos,
QPainter *painter )
{
QMatrix backupMatrix = painter->matrix();
QPen pen = painter->pen();
int w = painter->pen().width();
int d = m_style->getNodeRadius() * 2;
painter->translate( nodeToPos );
painter->rotate( -angleNorthOfEast( nodeFromPos, nodeToPos )*180/PI );
painter->translate( (d/2)+(w/2), 0 );
//painter->drawLine( 0, 0, (int)(d*.25), (int)(d*.25) );
//painter->drawLine( 0, 0, (int)(d*.25), -(int)(d*.25) );
pen.setCapStyle( Qt::RoundCap );
pen.setJoinStyle( Qt::RoundJoin );
painter->setBrush(Qt::color1);
painter->setPen(pen);
painter->drawPolygon(QPolygonF() << QPointF(0,0)
<< QPointF(d/6,d/8)
<< QPointF(d/6,-d/8));
painter->setMatrix( backupMatrix );
}
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 LaserScanPlugin::DrawIcon()
{
if (icon_)
{
QPixmap icon(16, 16);
icon.fill(Qt::transparent);
QPainter painter(&icon);
painter.setRenderHint(QPainter::Antialiasing, true);
QPen pen;
pen.setWidth(4);
pen.setCapStyle(Qt::RoundCap);
pen.setColor(InterpolateColors(min_color_, max_color_, 0.2));
painter.setPen(pen);
painter.drawPoint(2, 13);
pen.setColor(InterpolateColors(min_color_, max_color_, 0.6));
painter.setPen(pen);
painter.drawPoint(4, 6);
pen.setColor(InterpolateColors(min_color_, max_color_, 0.4));
painter.setPen(pen);
painter.drawPoint(12, 9);
pen.setColor(InterpolateColors(min_color_, max_color_, 0.8));
painter.setPen(pen);
painter.drawPoint(13, 2);
icon_->SetPixmap(icon);
}
}
void PlotCurve::drawSideLines(QPainter *p, const QwtScaleMap &xMap,
const QwtScaleMap &yMap, int from, int to) const {
if (!p || dataSize() <= 0)
return;
if (to < 0)
to = dataSize() - 1;
p->save();
QPen pen = p->pen();
pen.setCapStyle(Qt::FlatCap);
pen.setJoinStyle(Qt::MiterJoin);
p->setPen(pen);
double lw = 0.5 * pen.widthF();
const double xl = xMap.xTransform(x(from)) - lw;
const double xr = xMap.xTransform(x(to)) + lw;
const double yl = yMap.xTransform(y(from)) - lw;
const double yr = yMap.xTransform(y(to)) - lw;
const double base = yMap.xTransform(baseline());
p->drawLine(QPointF(xl, yl), QPointF(xl, base));
p->drawLine(QPointF(xr, yr), QPointF(xr, base));
p->restore();
}
void radeon_profile::setupGraphsStyle()
{
QPen pen;
pen.setWidth(ui->spin_lineThick->value());
pen.setCapStyle(Qt::SquareCap);
pen.setColor(ui->graphColorsList->topLevelItem(TEMP_LINE)->backgroundColor(1));
ui->plotTemp->graph(0)->setPen(pen);
ui->plotFanProfile->graph(0)->setPen(pen);
pen.setColor(ui->graphColorsList->topLevelItem(GPU_CLOCK_LINE)->backgroundColor(1));
ui->plotClocks->graph(0)->setPen(pen);
pen.setColor(ui->graphColorsList->topLevelItem(MEM_CLOCK_LINE)->backgroundColor(1));
ui->plotClocks->graph(1)->setPen(pen);
pen.setColor(ui->graphColorsList->topLevelItem(UVD_VIDEO_LINE)->backgroundColor(1));
ui->plotClocks->graph(2)->setPen(pen);
pen.setColor(ui->graphColorsList->topLevelItem(UVD_DECODER_LINE)->backgroundColor(1));
ui->plotClocks->graph(3)->setPen(pen);
pen.setColor(ui->graphColorsList->topLevelItem(CORE_VOLTS_LINE)->backgroundColor(1));
ui->plotVolts->graph(0)->setPen(pen);
pen.setColor(ui->graphColorsList->topLevelItem(MEM_VOLTS_LINE)->backgroundColor(1));
ui->plotVolts->graph(1)->setPen(pen);
ui->plotTemp->setBackground(QBrush(ui->graphColorsList->topLevelItem(TEMP_BG)->backgroundColor(1)));
ui->plotClocks->setBackground(QBrush(ui->graphColorsList->topLevelItem(CLOCKS_BG)->backgroundColor(1)));
ui->plotVolts->setBackground(QBrush(ui->graphColorsList->topLevelItem(VOLTS_BG)->backgroundColor(1)));
ui->plotFanProfile->setBackground(QBrush(ui->graphColorsList->topLevelItem(TEMP_BG)->backgroundColor(1)));
}
static inline void qwtDrawXCrossSymbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
const QSize size = symbol.size();
int off = 0;
QPen pen = symbol.pen();
if ( pen.width() > 1 )
{
pen.setCapStyle( Qt::FlatCap );
off = 1;
}
painter->setPen( pen );
if ( QwtPainter::roundingAlignment( painter ) )
{
const int sw = size.width();
const int sh = size.height();
const int sw2 = size.width() / 2;
const int sh2 = size.height() / 2;
for ( int i = 0; i < numPoints; i++ )
{
const QPointF &pos = points[i];
const int x = qRound( pos.x() );
const int y = qRound( pos.y() );
const int x1 = x - sw2;
const int x2 = x1 + sw + off;
const int y1 = y - sh2;
const int y2 = y1 + sh + off;
QwtPainter::drawLine( painter, x1, y1, x2, y2 );
QwtPainter::drawLine( painter, x2, y1, x1, y2 );
}
}
else
{
const double sw = size.width();
const double sh = size.height();
const double sw2 = 0.5 * size.width();
const double sh2 = 0.5 * size.height();
for ( int i = 0; i < numPoints; i++ )
{
const QPointF &pos = points[i];
const double x1 = pos.x() - sw2;
const double x2 = x1 + sw;
const double y1 = pos.y() - sh2;
const double y2 = y1 + sh;
QwtPainter::drawLine( painter, x1, y1, x2, y2 );
QwtPainter::drawLine( painter, x1, y2, x2, y1 );
}
}
}
QPen* getPen(const CLGraphicalPrimitive1D *item, const CLGroup *group, const CLRenderResolver* resolver, const CLBoundingBox * /*pBB*/)
{
QColor color; double width;
if (item != NULL && item->isSetStroke())
{
color = getColor(item->getStroke(), resolver);
}
else if (group != NULL && group->isSetStroke())
{
color = getColor(group->getStroke(), resolver);
}
else return new QPen(Qt::transparent);
if (item != NULL && item->isSetStrokeWidth())
{
width = item->getStrokeWidth();
}
else if (group != NULL && group->isSetStrokeWidth())
{
width = group->getStrokeWidth();
}
else return new QPen(Qt::transparent);
QPen *result = new QPen(color, width);
result->setCapStyle(Qt::RoundCap);
result->setJoinStyle(Qt::RoundJoin);
if (item != NULL && item->isSetDashArray())
{
const std::vector<unsigned int>& raw = item->getDashArray();
std::vector<unsigned int>::const_iterator start = raw.begin();
QVector<qreal> pattern;
while (start != raw.end())
{
pattern << *start;
++start;
}
result->setDashPattern(pattern);
}
else if (group != NULL && group->isSetDashArray())
{
const std::vector<unsigned int>& raw = group->getDashArray();
std::vector<unsigned int>::const_iterator start = raw.begin();
QVector<qreal> pattern;
while (start != raw.end())
{
pattern << *start;
++start;
}
result->setDashPattern(pattern);
}
return result;
}
void GeoLineStringGraphicsItem::paint( GeoPainter* painter, const ViewportParams* viewport )
{
if ( !style() )
{
painter->save();
painter->setPen( QPen() );
painter->drawPolyline( *m_lineString );
painter->restore();
return;
}
if(style()->lineStyle().paintedColor() == Qt::transparent)
return;
painter->save();
QPen currentPen = painter->pen();
if ( currentPen.color() != style()->lineStyle().paintedColor() )
currentPen.setColor( style()->lineStyle().paintedColor() );
if ( currentPen.widthF() != style()->lineStyle().width() ||
style()->lineStyle().physicalWidth() != 0.0 )
{
if ( float( viewport->radius() ) / EARTH_RADIUS * style()->lineStyle().physicalWidth() < style()->lineStyle().width() )
currentPen.setWidthF( style()->lineStyle().width() );
else
currentPen.setWidthF( float( viewport->radius() ) / EARTH_RADIUS * style()->lineStyle().physicalWidth() );
}
if ( currentPen.capStyle() != style()->lineStyle().capStyle() )
currentPen.setCapStyle( style()->lineStyle().capStyle() );
if ( currentPen.style() != style()->lineStyle().penStyle() )
currentPen.setStyle( style()->lineStyle().penStyle() );
if ( style()->lineStyle().penStyle() == Qt::CustomDashLine )
currentPen.setDashPattern( style()->lineStyle().dashPattern() );
if ( painter->mapQuality() != Marble::HighQuality
&& painter->mapQuality() != Marble::PrintQuality )
{
QColor penColor = currentPen.color();
penColor.setAlpha( 255 );
currentPen.setColor( penColor );
}
if ( painter->pen() != currentPen ) painter->setPen( currentPen );
if ( style()->lineStyle().background() )
{
QBrush brush = painter->background();
brush.setColor( style()->polyStyle().paintedColor() );
painter->setBackground( brush );
painter->setBackgroundMode( Qt::OpaqueMode );
}
painter->drawPolyline( *m_lineString );
painter->restore();
}
