void GraphScene::drawForeground ( QPainter * painter, const QRectF & rect ) {
//draw all graphs
for (int i=0;i < lines.size();i++) {
TimeLine * l=lines.at(i);
int minidx=l->findIdx(control->getVisibleRange()->getMin());
if (minidx > 0) minidx--;
int maxidx=l->findIdx(control->getVisibleRange()->getMax());
if (maxidx < (l->size()-1)) maxidx++;
if (minidx >= 0 && maxidx >= 0) {
QPainterPath path;
painter->save();
painter->setRenderHints(QPainter::Antialiasing);
QColor c(0,192,255);
if (shade_area) {
path = makePath(l,minidx,maxidx, true);
c.setAlpha(128);
painter->setBrush( QBrush(c) );
painter->setPen ( Qt::NoPen );
painter->drawPath(path);
}
c.setAlpha(255);
path = makePath(l,minidx,maxidx, false);
QPen graphpen(c, 2, Qt::SolidLine);
graphpen.setCosmetic(true);
painter->setBrush( Qt::NoBrush );
painter->setPen (graphpen);
painter->drawPath(path);
painter->restore();
}
}
//draw pointer
painter->save();
//painter->setCompositionMode(QPainter::CompositionMode_Overlay);
QPen ppen (QColor(255,255,0,128),2,Qt::SolidLine);
ppen.setCosmetic(true);
painter->setPen (ppen);
painter->drawLine(QPointF(control->getTimePointer()->get(),rect.y()),QPointF(control->getTimePointer()->get(),rect.height()));
painter->restore();
painter->save();
painter->resetTransform();
QPen tpen (QColor(255,255,255),1,Qt::SolidLine);
tpen.setCosmetic(true);
painter->setPen (tpen);
painter->drawText(QPointF(0,10),"test");
painter->restore();
//draw pointer if needed
}
void DualColorButton::paintEvent(QPaintEvent *event)
{
Q_UNUSED(event);
QPainter painter(this);
QPen normal = palette().color(QPalette::Mid);
QPen hilite = palette().color(QPalette::Light);
normal.setCosmetic(true);
hilite.setCosmetic(true);
painter.setRenderHint(QPainter::Antialiasing);
// Draw background box
const QRectF bgbox = backgroundRect();
painter.setPen(hilite_==2 ? hilite : normal);
painter.setBrush(background_);
painter.drawRoundedRect(bgbox, 3, 3);
// Draw foreground box
const QRectF fgbox = foregroundRect();
painter.setPen(hilite_==1 ? hilite : normal);
painter.setBrush(foreground_);
painter.drawRoundedRect(fgbox, 3, 3);
// Draw reset boxes
painter.setPen(hilite_==4 ? hilite : normal);
painter.setBrush(Qt::white);
painter.drawRect(resetWhiteRect());
painter.setBrush(Qt::black);
painter.drawRect(resetBlackRect());
// Draw swap arrow
static const QPointF arrows[] = {
QPointF(0, 2),
QPointF(2, 4),
QPointF(2, 3),
QPointF(4, 3),
QPointF(4, 5),
QPointF(3, 5),
QPointF(5, 7),
QPointF(7, 5),
QPointF(6, 5),
QPointF(6, 1),
QPointF(2, 1),
QPointF(2, 0)
};
const qreal scale = (1.0 / 8.0) * width() / 3.0;
painter.translate(ceil(fgbox.width()) + 0.0, 0);
painter.scale(scale, scale);
painter.setPen(hilite_==3 ? hilite : normal);
painter.setBrush(palette().dark());
painter.drawPolygon(arrows, 12);
}
void Ellipse::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
QWidget *widget)
{
// draws/paints the path of ellipse
QPen paintpen;
paintpen.setCosmetic(true);
paintpen.setWidth(1);
painter->setRenderHint(QPainter::Antialiasing);
if (option->state & QStyle::State_Selected)
{
// sets brush for center point
painter->setBrush(Qt::SolidPattern);
paintpen.setColor(Qt::red);
painter->setPen(paintpen);
painter->drawEllipse(p1, 2, 2);
// sets pen for circumference
paintpen.setStyle(Qt::DashLine);
paintpen.setColor(Qt::black);
painter->setBrush(Qt::NoBrush);
painter->setPen(paintpen);
painter->drawEllipse(p1, majRadius, minRadius);
}
else
{
painter->setBrush(Qt::SolidPattern);
painter->drawEllipse(p1, 2, 2);
painter->setBrush(Qt::NoBrush);
painter->setPen(paintpen);
painter->drawEllipse(p1, majRadius, minRadius);
}
}
void widgetLandmark::NewRegion()
{
ui->add_button->setChecked(false);
// show ellipse and text in graphics view
QPen pen = QPen(Qt::darkGreen,2);
pen.setCosmetic(true);
QRectF rect = _gview->GetCurrentSelectRect()->rect();
QGraphicsEllipseItem* ellipse = _gview->GetScene()->addEllipse(rect,pen);
ellipse->setTransform(QTransform::fromTranslate(_gview->GetTranslationX(),_gview->GetTranslationY()), true);
// create region
jpsRegion* region = new jpsRegion(_dmanager->GetRegionCounter(),"Region"+QString::number(_dmanager->GetRegionCounter()),
rect.center(),std::fabs(rect.width()/2.0),std::fabs(rect.height()/2.0));
QGraphicsTextItem* text = _gview->GetScene()->addText(region->GetCaption());
text->setPos(rect.center().x()+_gview->GetTranslationX(),rect.center().y()+_gview->GetTranslationY());
//text->setScale(gl_scale_f);
text->setData(0,_gview->GetScaleF());
text->setTransform(QTransform::fromScale(_gview->GetScaleF(),-_gview->GetScaleF()),true);
region->SetTextItem(text);
region->SetEllipse(ellipse);
_dmanager->NewRegion(region);
//show Region in listwidget
ShowRegions();
}
void widgetLandmark::SetPosInCMap()
{
jpsLandmark* landmark = GetCurrentLandmark();
if (landmark!=nullptr)
{
landmark->SetRect(_gview->GetCurrentSelectRect()->rect());
QString string = "Ellipse: x: "+QString::number(landmark->GetRect().center().x())
+ " y: "+QString::number(landmark->GetRect().center().y())+" rA: "+QString::number(landmark->GetA())
+ " rB: "+QString::number(landmark->GetB());
ui->ellipse_label->setText(string);
ui->add_button->setChecked(false);
// show ellipse and text in graphics view
QPen pen = QPen(Qt::blue,2);
pen.setCosmetic(true);
QGraphicsEllipseItem* ellipse = _gview->GetScene()->addEllipse(landmark->GetRect(),pen);
ellipse->setTransform(QTransform::fromTranslate(_gview->GetTranslationX(),_gview->GetTranslationY()), true);
QGraphicsTextItem* text = _gview->GetScene()->addText(landmark->GetCaption());
text->setPos(landmark->GetPos().x()+_gview->GetTranslationX(),landmark->GetPos().y()+_gview->GetTranslationY());
//text->setScale(gl_scale_f);
text->setData(0,_gview->GetScaleF());
text->setTransform(QTransform::fromScale(_gview->GetScaleF(),-_gview->GetScaleF()),true);
landmark->SetEllipseItem(ellipse);
landmark->SetTextItem(text);
}
}
WaveGraphicsScene::WaveGraphicsScene( const qreal x, const qreal y, const qreal width, const qreal height, QObject* parent ) :
QGraphicsScene( x, y, width, height, parent ),
m_interactionMode( AUDITION_ITEMS ),
m_isSceneAtSampleDetailLevel( false )
{
createBpmRuler();
// Set up playhead
m_playhead = new QGraphicsLineItem( 0.0, 0.0, 0.0, height - BpmRuler::HEIGHT );
QPen pen = QPen( Qt::red );
pen.setCosmetic( true );
m_playhead->setPen( pen );
m_playhead->setZValue( ZValues::PLAYHEAD );
m_timer = new QTimeLine();
m_timer->setFrameRange( 0, 100 );
m_timer->setCurveShape( QTimeLine::LinearCurve );
m_timer->setUpdateInterval( 17 ); // 17ms - roughly 60 fps
m_animation = new QGraphicsItemAnimation;
m_animation->setItem( m_playhead );
m_animation->setTimeLine( m_timer );
QObject::connect( m_timer, SIGNAL( finished() ),
this, SLOT( removePlayhead() ) );
QObject::connect( m_timer, SIGNAL( finished() ),
this, SIGNAL( playheadFinishedScrolling() ) );
}
void TransferFunctionEditorView::drawForeground(QPainter* painter, const QRectF& rect) {
QPen pen;
pen.setCosmetic(true);
pen.setWidthF(1.5);
pen.setColor(Qt::lightGray);
painter->setPen(pen);
QRectF sRect = sceneRect();
if (maskHorizontal_.x > 0.0f) {
double leftMaskBorder = maskHorizontal_.x * sRect.width();
QRectF r(0.0, rect.top(), leftMaskBorder, rect.height());
QLineF line(leftMaskBorder, rect.top(), leftMaskBorder, rect.bottom());
painter->fillRect(r, QColor(25, 25, 25, 100));
painter->drawLine(line);
}
if (maskHorizontal_.y < 1.0f) {
double rightMaskBorder = maskHorizontal_.y * sRect.width();
QRectF r(rightMaskBorder, rect.top(), sRect.right() - rightMaskBorder, rect.height());
QLineF line(rightMaskBorder, rect.top(), rightMaskBorder, rect.bottom());
painter->fillRect(r, QColor(25, 25, 25, 100));
painter->drawLine(line);
}
QGraphicsView::drawForeground(painter, rect);
}
void SelectionItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
{
if(!m_selection->pasteImage().isNull()) {
if(m_shape.size() == 4) {
QPolygonF src({
QPointF(0, 0),
QPointF(m_selection->pasteImage().width(), 0),
QPointF(m_selection->pasteImage().width(), m_selection->pasteImage().height()),
QPointF(0, m_selection->pasteImage().height())
});
QTransform t;
if(QTransform::quadToQuad(src, m_shape, t)) {
painter->save();
painter->setTransform(t, true);
painter->drawImage(0, 0, m_selection->pasteImage());
painter->restore();
} else
qWarning("Couldn't transform pasted image!");
} else {
qWarning("Pasted selection item with non-rectangular polygon!");
}
}
painter->setClipRect(boundingRect().adjusted(-1, -1, 1, 1));
QPen pen;
pen.setWidth(qApp->devicePixelRatio());
pen.setColor(Qt::white);
pen.setStyle(Qt::DashLine);
pen.setDashOffset(m_marchingants);
pen.setCosmetic(true);
painter->setPen(pen);
painter->setCompositionMode(QPainter::RasterOp_SourceXorDestination);
if(m_selection->isClosed())
painter->drawPolygon(m_shape);
else
painter->drawPolyline(m_shape);
// Draw resizing handles
if(m_selection->isClosed()) {
QRect rect = m_selection->boundingRect();
pen.setWidth(m_selection->handleSize());
pen.setStyle(Qt::SolidLine);
painter->setPen(pen);
painter->drawPoint(rect.topLeft());
painter->drawPoint(rect.topLeft() + QPointF(rect.width()/2, 0));
painter->drawPoint(rect.topRight());
painter->drawPoint(rect.topLeft() + QPointF(0, rect.height()/2));
painter->drawPoint(rect.topRight() + QPointF(0, rect.height()/2));
painter->drawPoint(rect.bottomLeft());
painter->drawPoint(rect.bottomLeft() + QPointF(rect.width()/2, 0));
painter->drawPoint(rect.bottomRight());
}
}
/*! \brief Sets the color according to the road superelevation.
*/
void
SuperelevationSectionPolynomialItem::updateColor()
{
QPen pen;
pen.setWidth(2);
pen.setCosmetic(true); // constant size independent of scaling
if (superelevationSection_->getDegree() == 3)
{
pen.setColor(ODD::instance()->colors()->darkRed());
}
else if (superelevationSection_->getDegree() == 2)
{
pen.setColor(ODD::instance()->colors()->darkOrange());
}
else if (superelevationSection_->getDegree() == 1)
{
pen.setColor(ODD::instance()->colors()->darkGreen());
}
else if (superelevationSection_->getDegree() == 0)
{
pen.setColor(ODD::instance()->colors()->darkCyan());
}
else
{
pen.setColor(ODD::instance()->colors()->darkBlue());
}
setPen(pen);
}
void Line::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
QWidget *widget)
{
// draws/paints the path of line
QPen paintpen;
painter->setRenderHint(QPainter::Antialiasing);
paintpen.setCosmetic(true);
paintpen.setWidth(1);
if (option->state & QStyle::State_Selected)
{
// sets brush for end points
painter->setBrush(Qt::SolidPattern);
paintpen.setColor(Qt::red);
painter->setPen(paintpen);
painter->drawEllipse(startP, 2, 2);
painter->drawEllipse(endP, 2, 2);
// sets pen for line path
paintpen.setStyle(Qt::DashLine);
paintpen.setColor(Qt::black);
painter->setPen(paintpen);
painter->drawPath(path);
}
else
{
painter->setBrush(Qt::SolidPattern);
paintpen.setColor(Qt::black);
painter->setPen(paintpen);
painter->drawEllipse(startP, 2, 2);
painter->drawEllipse(endP, 2, 2);
painter->drawPath(path);
}
}
/**
Dessine la borne
@param p QPainter a utiliser pour rendre le dessin
@param options Options pour affiner le rendu
@param widget Widget sur lequel le rendu est effectue
*/
void PartTerminal::paint(QPainter *p, const QStyleOptionGraphicsItem *options, QWidget *widget) {
Q_UNUSED(widget);
p -> save();
// annulation des renderhints
p -> setRenderHint(QPainter::Antialiasing, false);
p -> setRenderHint(QPainter::TextAntialiasing, false);
p -> setRenderHint(QPainter::SmoothPixmapTransform, false);
QPen t;
t.setWidthF(1.0);
t.setCosmetic(options && options -> levelOfDetail < 1.0);
// dessin de la borne en rouge
t.setColor(isSelected() ? Terminal::neutralColor : Qt::red);
p -> setPen(t);
p -> drawLine(QPointF(0.0, 0.0), second_point);
// dessin du point d'amarrage au conducteur en bleu
t.setColor(isSelected() ? Qt::red : Terminal::neutralColor);
p -> setPen(t);
p -> setBrush(Terminal::neutralColor);
p -> drawPoint(QPointF(0.0, 0.0));
p -> restore();
if (m_hovered)
drawShadowShape(p);
}
void DiveProfileItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
Q_UNUSED(widget);
if (polygon().isEmpty())
return;
// This paints the Polygon + Background. I'm setting the pen to QPen() so we don't get a black line here,
// after all we need to plot the correct velocities colors later.
setPen(Qt::NoPen);
QGraphicsPolygonItem::paint(painter, option, widget);
// Here we actually paint the boundaries of the Polygon using the colors that the model provides.
// Those are the speed colors of the dives.
QPen pen;
pen.setCosmetic(true);
pen.setWidth(2);
QPolygonF poly = polygon();
// This paints the colors of the velocities.
for (int i = 1, count = dataModel->rowCount(); i < count; i++) {
QModelIndex colorIndex = dataModel->index(i, DivePlotDataModel::COLOR);
pen.setBrush(QBrush(colorIndex.data(Qt::BackgroundRole).value<QColor>()));
painter->setPen(pen);
painter->drawLine(poly[i - 1], poly[i]);
}
}
DiveHeartrateItem::DiveHeartrateItem()
{
QPen pen;
pen.setBrush(QBrush(getColor(::HR_PLOT)));
pen.setCosmetic(true);
pen.setWidth(1);
setPen(pen);
}
DiveTemperatureItem::DiveTemperatureItem()
{
QPen pen;
pen.setBrush(QBrush(getColor(::TEMP_PLOT)));
pen.setCosmetic(true);
pen.setWidth(2);
setPen(pen);
}
static QPen gridPen()
{
QPen pen;
pen.setColor(getColor(TIME_GRID));
pen.setWidth(2);
pen.setCosmetic(true);
return pen;
}
DiveHeartrateItem::DiveHeartrateItem()
{
QPen pen;
pen.setBrush(QBrush(getColor(::HR_PLOT)));
pen.setCosmetic(true);
pen.setWidth(1);
setPen(pen);
connect(qPrefTechnicalDetails::instance(), &qPrefTechnicalDetails::hrgraphChanged, this, &DiveHeartrateItem::setVisible);
}
void EditorMagnifierItem::paint(QPainter * painter,
const QStyleOptionGraphicsItem *option,
QWidget * widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
if ( !scene() )
return;
QRectF rect = getRect();
EditorScene *scn = qobject_cast<EditorScene *>( scene() );
if (rect.isValid() && m_valid && scn)
{
updateMask();
painter->save(); // because clipping is active !!
QPainterPath clipPath;
clipPath.addEllipse(getRect().center(), getRect().width() / 2,getRect().width() / 2);
painter->setClipPath(clipPath);
painter->setClipping(true);
// TODO add extracted image to a cache !!!
QRectF extractRect( rect.translated( pos() - scn->getUnderlayOffset() ) );
int extractWidth = extractRect.width() / m_magnifyingFactor;
extractRect.adjust(extractWidth,extractWidth,-extractWidth,-extractWidth);
QRectF bgRect = scn->getUnderlayImage().rect();
QRectF croppedRect = extractRect.intersected(bgRect);
if ( !croppedRect.isNull() )
{
QImage background = scn->getUnderlayImage().copy( croppedRect.toRect() );
QImage mag = background.scaled(rect.size().toSize(),Qt::KeepAspectRatio,Qt::SmoothTransformation);
painter->drawImage(rect,mag);
}
painter->drawPixmap(rect.topLeft(), m_imgMask);
painter->restore();
}
// draw a box if selected
if( isSelected() )
{
painter->save();
QPen pen;
pen.setCosmetic(true);
pen.setColor(Qt::black);
pen.setWidth(1);
pen.setStyle(Qt::DotLine);
painter->setPen(pen);
painter->drawRect(rect);
painter->restore();
}
}
DiveGFLineItem::DiveGFLineItem()
{
QPen pen;
pen.setBrush(QBrush(getColor(::GF_LINE)));
pen.setCosmetic(true);
pen.setWidth(2);
setPen(pen);
settingsChanged();
}
DiveMeanDepthItem::DiveMeanDepthItem()
{
QPen pen;
pen.setBrush(QBrush(getColor(::HR_AXIS)));
pen.setCosmetic(true);
pen.setWidth(2);
setPen(pen);
settingsChanged();
}
DiveHeartrateItem::DiveHeartrateItem()
{
QPen pen;
pen.setBrush(QBrush(getColor(::HR_PLOT)));
pen.setCosmetic(true);
pen.setWidth(1);
setPen(pen);
connect(SettingsObjectWrapper::instance()->techDetails, &TechnicalDetailsSettings::hrgraphChanged, this, &DiveHeartrateItem::setVisible);
}
DiveAmbPressureItem::DiveAmbPressureItem()
{
QPen pen;
pen.setBrush(QBrush(getColor(::AMB_PRESSURE_LINE)));
pen.setCosmetic(true);
pen.setWidth(2);
setPen(pen);
settingsChanged();
}
void widgetLandmark::SetLineItemAsConnection()
{
QLineF line = QLineF(_currentConnection->GetLandmarks().first->GetPos(),_currentConnection->GetLandmarks().second->GetPos());
QPen pen = QPen(Qt::blue,2);
pen.setCosmetic(true);
QGraphicsLineItem* lineItem = _gview->GetScene()->addLine(line,pen);
lineItem->setTransform(QTransform::fromTranslate(_gview->GetTranslationX(),_gview->GetTranslationY()), true);
_currentConnection->SetLineItem(lineItem);
_currentConnection=nullptr;
}
void View::keyPressEvent(QKeyEvent *event) {
if (event->key() == Qt::Key_Right) {
// Zoom in.
int steps = 1;
if (event->modifiers() == Qt::ControlModifier)
steps = 10;
if (event->modifiers() == Qt::ShiftModifier)
steps = 100;
moveForward(steps);
} else if (event->key() == Qt::Key_Left) {
// Zoom out.
int steps = 1;
if (event->modifiers() == Qt::ControlModifier)
steps = 10;
if (event->modifiers() == Qt::ShiftModifier)
steps = 100;
moveBackward(steps);
} else if (event->key() == Qt::Key_S) {
if (event->modifiers() == Qt::ControlModifier) {
/*
* Render SVG.
*/
QString fileName = QFileDialog::getSaveFileName(this,
"Save SVG", QString(), "SVG Files (*.svg)");
QSvgGenerator generator;
generator.setFileName(fileName);
generator.setSize(viewport()->rect().size());
generator.setViewBox(viewport()->rect());
// Temporarily give legs and edges non-cosmetic pens while rendering.
foreach (QGraphicsLineItem *leg, m_legs) {
QPen pen = leg->pen();
pen.setCosmetic(false);
pen.setWidthF(1.0/transform().m11());
leg->setPen(pen);
}
foreach (QGraphicsLineItem *edge, m_edges) {
QPen pen = edge->pen();
pen.setCosmetic(false);
pen.setWidthF(1.0/transform().m11());
edge->setPen(pen);
}
cwAbstract2PointItem::cwAbstract2PointItem(QQuickItem *parent) :
QQuickItem(parent)
{
TransformUpdater = NULL;
connect(this, SIGNAL(visibleChanged()), SLOT(updateTransformUpdater()));
QPen pen;
pen.setWidthF(2.0);
pen.setCosmetic(true);
LinePen = pen;
}
/*!
\property QGeoMapPolylineObject::pen
\brief This property holds the pen that will be used to draw this object.
The pen is used to draw the polyline.
The pen will be treated as a cosmetic pen, which means that the width
of the pen will be independent of the zoom level of the map.
*/
void QGeoMapPolylineObject::setPen(const QPen &pen)
{
QPen newPen = pen;
newPen.setCosmetic(true);
if (d_ptr->pen == newPen)
return;
d_ptr->pen = newPen;
emit penChanged(d_ptr->pen);
}
DivePercentageItem::DivePercentageItem(int i)
{
QPen pen;
QColor color;
color.setHsl(100 + 10 * i, 200, 100);
pen.setBrush(QBrush(color));
pen.setCosmetic(true);
pen.setWidth(1);
setPen(pen);
settingsChanged();
}
QPen Contour::getPen() const {
QPen pen;
pen.setCosmetic( true );
pen.setWidthF( m_state.getValue<double>( Util::WIDTH) );
int redAmount = m_state.getValue<int>( Util::RED );
int greenAmount = m_state.getValue<int>( Util::GREEN );
int blueAmount = m_state.getValue<int>( Util::BLUE );
int alphaAmount = m_state.getValue<int>( Util::ALPHA );
pen.setColor( QColor(redAmount, greenAmount, blueAmount, alphaAmount) );
return pen;
}
void QGeoMapRouteObject::setPen(const QPen &pen)
{
QPen newPen = pen;
newPen.setCosmetic(false);
if (d_ptr->pen == newPen)
return;
d_ptr->pen = newPen;
emit penChanged(newPen);
}
QPen DiveCartesianAxis::gridPen()
{
QPen pen;
pen.setColor(getColor(TIME_GRID));
/* cosmetic width() == 0 for lines in printMode
* having setCosmetic(true) and width() > 0 does not work when
* printing on OSX and Linux */
pen.setWidth(DiveCartesianAxis::printMode ? 0 : 2);
pen.setCosmetic(true);
return pen;
}
/*!
\property QGeoMapCircleObject::pen
\brief This property holds the pen that will be used to draw this object.
The pen is used to draw an outline around the circle. The circle is
filled using the QGeoMapCircleObject::brush property.
The pen will be treated as a cosmetic pen, which means that the width
of the pen will be independent of the zoom level of the map.
\since 1.1
*/
void QGeoMapCircleObject::setPen(const QPen &pen)
{
QPen newPen = pen;
newPen.setCosmetic(true);
const QPen oldPen = d_ptr->pen;
if (oldPen == newPen)
return;
d_ptr->pen = newPen;
emit penChanged(newPen);
}
