/*
QPair<int, int> ClassItem::ganttIndex() const
{
int class_ix = startSlotItem()->classItemIndex(this);
int slot_ix = ganttItem()->startSlotItemIndex(startSlotItem());
return QPair<int, int>(slot_ix, class_ix);
}
*/
void ClassItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
QColor c_runner = color();
QColor c_free = c_runner;
c_free.setAlpha(64);
auto r = rect();
QRectF r1 = r;
r1.setWidth(minToPx(1));
r1.setHeight(r.height() / 8);
painter->save();
painter->fillRect(r, c_free);
auto dt = data();
int interval = dt.startIntervalMin();
for (int i = 0; i < runsAndVacantCount(); ++i) {
r1.moveLeft(minToPx(i * interval));
//QColor c = (i == 0)? c_first: c_runner;
painter->fillRect(r1, c_runner);
painter->drawRect(r1);
}
if(isSelected()) {
painter->save();
qreal w = r.height() / 15;
QPen p;
p.setColor(QColor(Qt::blue).lighter());
p.setWidthF(w);
painter->setPen(p);
w /= 2;
QRectF r2 = r.adjusted(w, w, -w, -w);
painter->drawRect(r2);
painter->restore();
}
if(clashingClasses().count()) {
painter->save();
qreal w = r.height() / 15;
QPen p;
p.setColor(Qt::red);
p.setWidthF(w);
painter->setPen(p);
w /= 2;
QRectF r2 = r.adjusted(w, w, -w, -w);
painter->drawRect(r2);
painter->restore();
}
if(m_dropInsertsBefore.isValid()) {
QColor c_insert = c_runner;
//c_insert.setAlpha(128);
QRectF r2 = r;
r2.setWidth(minToPx(2));
if(!m_dropInsertsBefore.toBool()) {
r2.moveLeft(r.width() - r2.width());
}
painter->fillRect(r2, c_insert);
QPen p;
p.setColor(color());
painter->setPen(p);
painter->drawRect(r2);
}
painter->restore();
Super::paint(painter, option, widget);
}
SpeedPlotView::SpeedPlotView(QWidget *parent)
: QGraphicsView(parent)
, m_viewablePointsCount(MIN5_SEC)
, m_maxCapacity(HOUR6_SEC)
{
QPen greenPen;
greenPen.setWidthF(1.5);
greenPen.setColor(QColor(134, 196, 63));
QPen bluePen;
bluePen.setWidthF(1.5);
bluePen.setColor(QColor(50, 153, 255));
m_properties[UP] = GraphProperties(tr("Total Upload"), bluePen);
m_properties[DOWN] = GraphProperties(tr("Total Download"), greenPen);
bluePen.setStyle(Qt::DashLine);
greenPen.setStyle(Qt::DashLine);
m_properties[PAYLOAD_UP] = GraphProperties(tr("Payload Upload"), bluePen);
m_properties[PAYLOAD_DOWN] = GraphProperties(tr("Payload Download"), greenPen);
bluePen.setStyle(Qt::DashDotLine);
greenPen.setStyle(Qt::DashDotLine);
m_properties[OVERHEAD_UP] = GraphProperties(tr("Overhead Upload"), bluePen);
m_properties[OVERHEAD_DOWN] = GraphProperties(tr("Overhead Download"), greenPen);
bluePen.setStyle(Qt::DashDotDotLine);
greenPen.setStyle(Qt::DashDotDotLine);
m_properties[DHT_UP] = GraphProperties(tr("DHT Upload"), bluePen);
m_properties[DHT_DOWN] = GraphProperties(tr("DHT Download"), greenPen);
bluePen.setStyle(Qt::DotLine);
greenPen.setStyle(Qt::DotLine);
m_properties[TRACKER_UP] = GraphProperties(tr("Tracker Upload"), bluePen);
m_properties[TRACKER_DOWN] = GraphProperties(tr("Tracker Download"), greenPen);
}
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();
}
void QgsSimpleLineSymbolLayerV2::applyDataDefinedSymbology( QgsSymbolV2RenderContext& context, QPen& pen, QPen& selPen, double& offset )
{
//data defined properties
double scaledWidth = 0;
if ( mStrokeWidthExpression )
{
scaledWidth = mStrokeWidthExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toDouble()
* QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mWidthUnit );
pen.setWidthF( scaledWidth );
selPen.setWidthF( scaledWidth );
}
else if ( context.renderHints() & QgsSymbolV2::DataDefinedSizeScale )
{
scaledWidth = mWidth * QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mWidthUnit );
pen.setWidthF( scaledWidth );
selPen.setWidthF( scaledWidth );
}
//color
if ( mStrokeColorExpression )
{
pen.setColor( QgsSymbolLayerV2Utils::decodeColor( mStrokeColorExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString() ) );
}
//offset
offset = mOffset;
if ( mLineOffsetExpression )
{
offset = mLineOffsetExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toDouble();
}
//dash dot vector
if ( mDashPatternExpression )
{
QVector<qreal> dashVector;
QStringList dashList = mDashPatternExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString().split( ";" );
QStringList::const_iterator dashIt = dashList.constBegin();
for ( ; dashIt != dashList.constEnd(); ++dashIt )
{
dashVector.push_back( dashIt->toDouble() * QgsSymbolLayerV2Utils::lineWidthScaleFactor( context.renderContext(), mCustomDashPatternUnit ) / mPen.widthF() );
}
pen.setDashPattern( dashVector );
}
//join style
if ( mJoinStyleExpression )
{
QString joinStyleString = mJoinStyleExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString();
pen.setJoinStyle( QgsSymbolLayerV2Utils::decodePenJoinStyle( joinStyleString ) );
}
//cap style
if ( mCapStyleExpression )
{
QString capStyleString = mCapStyleExpression->evaluate( const_cast<QgsFeature*>( context.feature() ) ).toString();
pen.setCapStyle( QgsSymbolLayerV2Utils::decodePenCapStyle( capStyleString ) );
}
}
/*!
save preferences settings from the dialog to the outside world...
*/
void Preferences::savePrefs()
{
QPen pen;
map->setBackgroundBrush(ui.backgroundColour->currentColor());
map->setGridTextBrush(ui.gridTextPenColour->currentColor());
// careful to retain any other properties of these pens... just change colour
pen = map->getGridPen(); pen.setColor(ui.gridPenColour->currentColor()); map->setGridPen(pen);
pen = map->getOriginPen(); pen.setColor(ui.originPenColour->currentColor()); map->setOriginPen(pen);
// change colour and line width (but not other properties) of these...
pen = map->getTrackPen(); pen.setColor(ui.trackPenColour->currentColor()); pen.setWidthF(ui.trackLineWidth->value()); map->setTrackPen(pen);
pen = map->getRoadPen(); pen.setColor(ui.roadPenColour->currentColor()); pen.setWidthF(ui.roadLineWidth->value()); map->setRoadPen(pen);
map->setTrackScaling(ui.trackExaggerateSmall->isChecked() ? MapWidget::Scale_Exaggerated : MapWidget::Scale_WithView);
map->setRoadScaling(ui.roadExaggerateSmall->isChecked() ? MapWidget::Scale_Exaggerated : MapWidget::Scale_WithView);
map->setGridTextFont(gridFont);
map->setTextFont(textFont);
//TODO: CHeck the path is OK before committing
if (ui.pathSerzAutolocate->isChecked())
{
import->setSerzAuto(true);
}
else
{
import->setSerzAuto(false);
import->setSerzPath(ui.pathSerz->text());
}
import->setTempPath(ui.pathTempFolder->text());
// these two bools should always be opposite, so if the same a change needs to be made.
if (ui.pathRailworksRoutesAutolocate->isChecked() && locater->isRoutefolderSpecified())
{
// the change is to use the default folders...
locater->defaultRWLocations();
locater->defaultRoutes();
}
else if (!ui.pathRailworksRoutesAutolocate->isChecked() && !locater->isRoutefolderSpecified())
{
// the change is to set a folder...
locater->setSpecifiedRouteFolder(ui.pathRailworksRoutes->text());
}
//
map->showLoftEnds(ui.markLoftSegments->isChecked());
map->setFastRender(ui.fastRendering->isChecked());
//ui.reportRouteInconsistencies->isChecked()
map->setWheelZoom(ui.reverseMousewheelZoom->isChecked() ? MapWidget::Zoom_InOut : MapWidget::Zoom_OutIn);
QSettings settings;
settings.setValue("logFile", ui.logFilename->text());
}
void QgsDiagram::setPenWidth( QPen& pen, const QgsDiagramSettings& s, const QgsRenderContext& c )
{
if ( s.sizeType == QgsDiagramSettings::MM )
{
pen.setWidthF( s.penWidth * c.scaleFactor() );
}
else
{
pen.setWidthF( s.penWidth / c.mapToPixel().mapUnitsPerPixel() );
}
}
/*!
\brief Draw the grid
The grid is drawn into the bounding rectangle such that
gridlines begin and end at the rectangle's borders. The X and Y
maps are used to map the scale divisions into the drawing region
screen.
\param painter Painter
\param mx X axis map
\param my Y axis
\param r Contents rect of the plot canvas
*/
void Grid::draw(QPainter *painter,
const QwtScaleMap &mx, const QwtScaleMap &my,
const QRect &r) const
{
double x_factor = (double)painter->device()->logicalDpiX()/(double)plot()->logicalDpiX();
double y_factor = (double)painter->device()->logicalDpiY()/(double)plot()->logicalDpiY();
// draw minor X gridlines
QPen pen = minPen();
pen.setWidthF(pen.widthF() * x_factor);
painter->setPen(pen);
if (xMinEnabled()){
drawLines(painter, r, Qt::Vertical, mx,
xScaleDiv().ticks(QwtScaleDiv::MinorTick));
drawLines(painter, r, Qt::Vertical, mx,
xScaleDiv().ticks(QwtScaleDiv::MediumTick));
}
// draw minor Y gridlines
pen = d_min_pen_y;
pen.setWidthF(pen.widthF() * y_factor);
painter->setPen(pen);
if (yMinEnabled()){
drawLines(painter, r, Qt::Horizontal, my,
yScaleDiv().ticks(QwtScaleDiv::MinorTick));
drawLines(painter, r, Qt::Horizontal, my,
yScaleDiv().ticks(QwtScaleDiv::MediumTick));
}
// draw major X gridlines
pen = majPen();
pen.setWidthF(pen.widthF() * x_factor);
painter->setPen(pen);
if (xEnabled()){
drawLines(painter, r, Qt::Vertical, mx,
xScaleDiv().ticks (QwtScaleDiv::MajorTick));
}
// draw major Y gridlines
pen = d_maj_pen_y;
pen.setWidthF(pen.widthF() * y_factor);
painter->setPen(pen);
if (yEnabled()){
drawLines(painter, r, Qt::Horizontal, my,
yScaleDiv().ticks (QwtScaleDiv::MajorTick));
}
}
bool OLSAdaptiveNodeExpandStatusVisualizer::tryPerformAdaptableVisualization(OLSOntologyGraphNodeItem *nodeToVisualize,
OLSOntologyGraphNodeItem *nodeWithVisualizeInfo, QPainter *painter)
{
if (nodeToVisualize == nullptr || painter == nullptr)
return false;
int plusSize = getParameterValueOrDefaultInt(m_plusSizeStr, nodeWithVisualizeInfo, m_plusSize);
OLSAdaptiveNodeVisualizerMaster::stepOfAdaptableVisualization(m_textAreaVisualizers, nodeToVisualize, painter);
if (nodeToVisualize->expandState() != ExpandState::NotExpandable) {
QPainterPath path;
QRectF rect = nodeToVisualize->rect();
QPointF mid(rect.x() - rect.height() / 2, rect.y() + rect.height() / 2);
if (nodeToVisualize->expandState() == ExpandState::NotExpanded) {
path.moveTo(mid - QPointF(0, -plusSize));
path.lineTo(mid - QPointF(0, plusSize));
}
path.moveTo(mid - QPointF(-plusSize, 0));
path.lineTo(mid - QPointF(plusSize, 0));
QPen pen;
pen.setWidthF(2.0);
QPen oldPen = painter->pen();
painter->setPen(pen);
painter->drawPath(path);
painter->setPen(oldPen);
}
qDebug() << OLS_AVIS_NODE_EXPAND_STATUS__VISUALIZER_CLASS;
return true;
}
void REPainter::StrokeRect(const RERect& rc, float lineWidth)
{
if(!_painter) return;
QPen pen = _painter->pen();
QBrush brush = _painter->brush();
float oldLineWidth = pen.widthF();
pen.setWidthF(lineWidth);
_painter->setPen(pen);
_painter->setBrush(Qt::NoBrush);
_painter->drawRect(rc.ToQRectF());
pen.setWidthF(oldLineWidth);
_painter->setPen(pen);
_painter->setBrush(brush);
}
void KoOdtFrameReportTextBox::createStyle(KoGenStyles *coll)
{
QFont font = textBox()->textStyle().font;
KoGenStyle ps(KoGenStyle::ParagraphStyle, "paragraph");
m_paragraphStyleName = coll->insert(ps, "P");
// text style
KoGenStyle ts(KoGenStyle::TextStyle, "text");
ts.addProperty("fo:font-family", font.family());
ts.addPropertyPt("fo:font-size", font.pointSizeF());
ts.addProperty("fo:font-weight", font.weight() * 10);
ts.addProperty("fo:color", textBox()->textStyle().foregroundColor.name());
QString fs;
switch (font.style()) {
case QFont::StyleNormal: fs = "normal"; break;
case QFont::StyleItalic: fs = "italic"; break;
case QFont::StyleOblique: fs = "oblique"; break;
}
ts.addProperty("fo:font-style", fs);
m_textStyleName = coll->insert(ts, "T");
KoGenStyle gs(KoGenStyle::GraphicStyle, "graphic");
QPen pen;
pen.setColor(textBox()->lineStyle().lineColor);
pen.setWidthF(textBox()->lineStyle().weight);
pen.setStyle(textBox()->lineStyle().style);
KoOdfGraphicStyles::saveOdfStrokeStyle(gs, coll, pen);
gs.addProperty("style:horizontal-pos", "from-left");
gs.addProperty("style:horizontal-rel", "page");
gs.addProperty("style:vertical-pos", "from-top");
gs.addProperty("style:vertical-rel", "page");
gs.addProperty("fo:background-color", textBox()->textStyle().backgroundColor.name());
m_frameStyleName = coll->insert(gs, "F");
}
void Radar::PrintPlanes(QPainter &painter)
{
int row = 1;
int col = 0;
for (AConstIterator iter = Acs.begin(), end = Acs.end(); iter != end; iter ++)
{
qDebug("print");
row = 1;
col = (int)(iter.value().Heading / 11.25);
if (iter.key() == selectedIcao)
{
QPen pen;
pen.setColor(QColor(180, 200, 0));
pen.setWidthF(2);
painter.setBrush(QColor(0, 0, 0, 50));
painter.setPen(pen);
painter.setRenderHint(QPainter::Antialiasing, true);
painter.drawEllipse(QPointF(iter.value().r_x, iter.value().r_y), 19, 19);
painter.setRenderHint(QPainter::Antialiasing, false);
row = 0;
}
painter.drawPixmap(iter.value().r_x - 17, iter.value().r_y - 17, icon_width, icon_height,
sprite,
col * icon_width, row * icon_height, icon_width, icon_height);
}
}
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)
}
}
void MainWindow::plot3(QCustomPlot *customPlot)
{
QVector<double> x0(pts), y0(pts);
update_w(w,1.0);
double y_inc = 1.0;
for (int i=0; i<pts; ++i) {
x0[i] = (double)0.5*i/pts;
y0[i] = y_inc*(w[i]);
}
customPlot->graph()->setData(x0, y0);
customPlot->graph()->setLineStyle(QCPGraph::lsLine);
customPlot->graph()->setScatterStyle(QCPScatterStyle::ssNone); // (QCP::ScatterStyle)(rand()%9+1));
QPen graphPen;
graphPen.setColor(QColor(Qt::GlobalColor(5+graph_counter)));
graphPen.setWidthF(2);
customPlot->graph()->setPen(graphPen);
customPlot->xAxis->setRange(0,0.5);
customPlot->yAxis->setRange(-90,10);
customPlot->legend->setVisible(true);
// customPlot->setInteraction(QCustomPlot::iSelectPlottables);
customPlot->graph()->setName(QString(shape.c_str()));
customPlot->replot();
}
void GLEDrawingObject::setSimplePenProperties(QPen& pen) {
QColor col;
GLEDrawObject* obj = getGLEObject();
GLEColor* color = obj->getProperties()->getColorProperty(GLEDOPropertyColor);
col.setRgbF(color->getRed(), color->getGreen(), color->getBlue());
pen.setColor(col);
double lwidth = obj->getProperties()->getRealProperty(GLEDOPropertyLineWidth);
pen.setWidthF(QGLE::relGLEToQt(lwidth, dpi));
GLEString* lstyle = obj->getProperties()->getStringProperty(GLEDOPropertyLineStyle);
if (lstyle->length() == 1 && lstyle->get(0) > (unsigned int)'1') {
QVector<qreal> dashes;
const char *defline[] = {"","","12","41","14","92","1282","9229","4114","54","73","7337","6261","2514"};
const char *myline = defline[lstyle->get(0)-'0'];
int len = strlen(myline);
for (int i = 0; i < len; i++) {
double value = (myline[i]-'0');
dashes.append((qreal)QGLE::relGLEToQt(value*0.04, dpi));
}
pen.setDashPattern(dashes);
} else if (lstyle->length() > 1) {
QVector<qreal> dashes;
for (unsigned int i = 0; i < lstyle->length(); i++) {
double value = (lstyle->get(i)-'0');
dashes.append((qreal)QGLE::relGLEToQt(value*0.04, dpi));
}
pen.setDashPattern(dashes);
}
}
void QPaintEnginePrivate::drawBoxTextItem(const QPointF &p, const QTextItemInt &ti)
{
if (!ti.glyphs.numGlyphs)
return;
// any fixes here should probably also be done in QFontEngineBox::draw
const int size = qRound(ti.fontEngine->ascent());
QVarLengthArray<QFixedPoint> positions;
QVarLengthArray<glyph_t> glyphs;
QTransform matrix = QTransform::fromTranslate(p.x(), p.y() - size);
ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
if (glyphs.size() == 0)
return;
QSize s(size - 3, size - 3);
QPainter *painter = q_func()->state->painter();
painter->save();
painter->setBrush(Qt::NoBrush);
QPen pen = painter->pen();
pen.setWidthF(ti.fontEngine->lineThickness().toReal());
painter->setPen(pen);
for (int k = 0; k < positions.size(); k++)
painter->drawRect(QRectF(positions[k].toPointF(), s));
painter->restore();
}
/**
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 PlotCurve::setCurveWidth(qreal width)
{
mWidth = width;
QPen customPen = pen();
customPen.setWidthF(mWidth);
setPen(customPen);
}
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();
}
QSizeF QgsRasterSymbolLegendNode::drawSymbol( const QgsLegendSettings &settings, ItemContext *ctx, double itemHeight ) const
{
if ( ctx && ctx->painter )
{
QColor itemColor = mColor;
if ( QgsRasterLayer *rasterLayer = qobject_cast<QgsRasterLayer *>( layerNode()->layer() ) )
{
if ( QgsRasterRenderer *rasterRenderer = rasterLayer->renderer() )
itemColor.setAlpha( rasterRenderer->opacity() * 255.0 );
}
ctx->painter->setBrush( itemColor );
if ( settings.drawRasterStroke() )
{
QPen pen;
pen.setColor( settings.rasterStrokeColor() );
pen.setWidthF( settings.rasterStrokeWidth() );
pen.setJoinStyle( Qt::MiterJoin );
ctx->painter->setPen( pen );
}
else
{
ctx->painter->setPen( Qt::NoPen );
}
ctx->painter->drawRect( QRectF( ctx->point.x(), ctx->point.y() + ( itemHeight - settings.symbolSize().height() ) / 2,
settings.symbolSize().width(), settings.symbolSize().height() ) );
}
return settings.symbolSize();
}
void AverageSceneItem::paintStimLine(QPainter *painter)
{
if(m_lAverageData.size() == 0)
return;
//Plot averaged data
QRectF boundingRect = this->boundingRect();
QPainterPath path = QPainterPath(QPointF(boundingRect.x(), boundingRect.y() + boundingRect.height()/2));
int dsFactor = 1;
int totalCols = m_lAverageData.first().second;
totalCols / boundingRect.width()<1 ? dsFactor = 1 : dsFactor = totalCols / boundingRect.width();
if(dsFactor == 0)
dsFactor = 1;
QPen pen;
pen.setStyle(Qt::SolidLine);
pen.setColor(Qt::red);
pen.setWidthF(3);
painter->setPen(pen);
path.moveTo(boundingRect.x()+abs(m_firstLastSample.first)/dsFactor, boundingRect.y());
path.lineTo(boundingRect.x()+abs(m_firstLastSample.first)/dsFactor, boundingRect.y()+boundingRect.height());
path.moveTo(boundingRect.x(),boundingRect.y()+boundingRect.height()/2);
path.lineTo(boundingRect.x()+m_lAverageData.first().second/dsFactor, boundingRect.y()+boundingRect.height()/2);
painter->drawPath(path);
}
void ChanWidgetLED::paintEvent(QPaintEvent * /* event*/ )
{
QPainter painter(this);
initCoordinateSystem(painter);
int h,s,v,a;
QColor c,back = color();
c=back;
if (!m_checked || !isEnabled())
{
back.getHsv(&h,&s,&v,&a);
s*=0.20;
back.setHsv(h,s,v,a);
}
painter.setBrush(back);
QPen pen;
c.getHsv(&h,&s,&v,&a);
s*=0.5;
c.setHsv(h,s,v,a);
pen.setColor(c);
pen.setWidthF(3.0);
painter.drawEllipse(-(size-size/10)/2,-(size-size/10)/2,(size-size/10),(size-size/10));
painter.end();
drawBackground(); // to maluje na tym co dotychczas to co jest w bitmapce
}
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 AverageSceneItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
//set posistion
this->setPos(75*m_qpChannelPosition.x(), -75*m_qpChannelPosition.y());
painter->setRenderHint(QPainter::Antialiasing, true);
// //Plot bounding rect / drawing region of this item
// painter->drawRect(this->boundingRect());
//Plot stim time
painter->save();
paintStimLine(painter);
painter->restore();
//Plot average data
painter->save();
paintAveragePath(painter);
painter->restore();
// Plot channel name
QStaticText staticElectrodeName = QStaticText(m_sChannelName);
QSizeF sizeText = staticElectrodeName.size();
painter->save();
QPen pen;
pen.setColor(Qt::yellow);
pen.setWidthF(5);
painter->setPen(pen);
painter->drawStaticText(boundingRect().x(), boundingRect().y(), staticElectrodeName);
painter->restore();
}
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);
}
/**
* @brief Diagram::Diagram
* Constructor
* @param project : The project of this diagram and also parent QObject
*/
Diagram::Diagram(QETProject *project) :
QGraphicsScene (project),
project_ (NULL),
diagram_qet_version_ (-1),
draw_grid_ (true),
use_border_ (true),
draw_terminals_ (true),
draw_colored_conductors_ (true)
{
setProject(project);
qgi_manager_ = new QGIManager(this);
setBackgroundBrush(Qt::white);
conductor_setter_ = new QGraphicsLineItem(0, 0);
conductor_setter_ -> setZValue(1000000);
QPen t;
t.setColor(Qt::black);
t.setWidthF(1.5);
t.setStyle(Qt::DashLine);
conductor_setter_ -> setPen(t);
conductor_setter_ -> setLine(QLineF(QPointF(0.0, 0.0), QPointF(0.0, 0.0)));
//Init object for manage movement
elements_mover_ = new ElementsMover();
element_texts_mover_ = new ElementTextsMover();
connect(&border_and_titleblock, SIGNAL(needTitleBlockTemplate(const QString &)), this, SLOT(setTitleBlockTemplate(const QString &)));
connect(&border_and_titleblock, SIGNAL(diagramTitleChanged(const QString &)), this, SLOT(titleChanged(const QString &)));
}
OperatorItem::OperatorItem(OperatorModel* model, QGraphicsItem * parent)
: QGraphicsObject(parent),
m_model(model)
{
QPainterPath path;
path.addRoundedRect(QRectF(-SIZE/2, -SIZE/2, SIZE, SIZE), RADIUS, RADIUS);
m_opRect = new QGraphicsPathItem(path, this);
QPen pen = m_opRect->pen();
pen.setWidthF(WIDTH);
m_opRect->setPen(pen);
m_opRect->setBrush(Qt::white);
setPos(m_model->pos());
m_label = new QGraphicsTextItem(this);
m_label->setPlainText(QString::fromStdString(m_model->op()->name()));
m_label->setPos(-m_label->boundingRect().width()/2, SIZE/2 + LABEL_OFFSET);
setFlag(ItemIsMovable, true);
setFlag(ItemIsSelectable, true);
setFlag(ItemIsFocusable, true);
setFlag(ItemSendsScenePositionChanges, true);
setInitialized(model->isInitialized());
connect(m_model, SIGNAL(nameChanged(QString)), this, SLOT(setName(QString)));
connect(m_model, SIGNAL(initializedChanged(bool)), this, SLOT(setInitialized(bool)));
connect(m_model, SIGNAL(posChanged(QPointF)), this, SLOT(setOperatorPos(QPointF)));
connect(m_model, SIGNAL(connectorOccupiedChanged(OperatorModel::ConnectorType,uint,bool)),
this, SLOT(setConnectorOccupied(OperatorModel::ConnectorType,uint,bool)));
connect(m_model, SIGNAL(activeChanged(bool)), this, SLOT(resetAllConnectors()));
}
/**
Constructeur
@param parent Le QObject parent du schema
*/
Diagram::Diagram(QObject *parent) :
QGraphicsScene(parent),
draw_grid_(true),
use_border_(true),
draw_terminals_(true),
draw_colored_conductors_(true),
project_(0),
read_only_(false),
diagram_qet_version_(-1)
{
undo_stack_ = new QUndoStack();
qgi_manager_ = new QGIManager(this);
setBackgroundBrush(Qt::white);
conductor_setter_ = new QGraphicsLineItem(0, 0);
conductor_setter_ -> setZValue(1000000);
QPen t;
t.setColor(Qt::black);
t.setWidthF(1.5);
t.setStyle(Qt::DashLine);
conductor_setter_ -> setPen(t);
conductor_setter_ -> setLine(QLineF(QPointF(0.0, 0.0), QPointF(0.0, 0.0)));
// initialise les objets gerant les deplacements
elements_mover_ = new ElementsMover(); // deplacements d'elements/conducteurs/textes
element_texts_mover_ = new ElementTextsMover(); // deplacements d'ElementTextItem
connect(
&border_and_titleblock, SIGNAL(needTitleBlockTemplate(const QString &)),
this, SLOT(setTitleBlockTemplate(const QString &))
);
connect(
&border_and_titleblock, SIGNAL(diagramTitleChanged(const QString &)),
this, SLOT(titleChanged(const QString &))
);
}
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);
}
}
/**
* @brief widgetBarChart::drawYear draw a given year on a bar chart
* @param sel the index of the selected year
*/
void widgetBarChart::drawYear(const int &sel) {
QCPBars *bar = new QCPBars(ui->widgetBarChart_2->xAxis,ui->widgetBarChart_2->yAxis);
bar->setName(_meas->yearRange().at(sel));
bar->setWidth(BAR_WIDTH);
QPen pen;
bar->setBrush(COLOUR_LIST[sel%5]);
pen.setWidthF(PEN_WIDTH);
QVector<double> valueData, keyData;
ui->widgetBarChart_2->addPlottable(bar);
double i = 0.25 + 0.2*ui->widgetBarChart_2->xAxis->plottables().size();
QList<QListWidgetItem*> tempList = ui->listBarChartMunicipality->selectedItems();
for(QList<QListWidgetItem*>::Iterator it = tempList.begin(); it != tempList.end(); ++it) {
QListWidgetItem *tempItem = *it;
keyData << i;
i+=1.5;
try {
valueData.append(_meas->findMuni(tempItem->text()).getYear(_meas->yearRange().at(sel)).value());
} catch (std::string s) {
valueData.append(0.0);
}
}
bar->setData(keyData,valueData);
bar->keyAxis()->setTickVector(keyData);
ui->widgetBarChart_2->legend->setVisible(true);
ui->widgetBarChart_2->replot();
}
void MainWindow::plot2(QCustomPlot *customPlot)
{
QVector<double> x0(pts), y0(pts);
update_w(w,1.0);
double y_inc = 1.0;
for (int i=0; i<pts; ++i) {
x0[i] = (double)0.5*i/pts;
y0[i] = y_inc*(w[i]);
}
order = get_order();
ui->order->setText(QApplication::translate("MainWindow", std::to_string(order).c_str(), 0));
ui->ripple->setText(QApplication::translate("MainWindow", std::to_string(ripple()).c_str(), 0));
ui->fc->setText(QApplication::translate("MainWindow", std::to_string(fc()).c_str(), 0));
customPlot->graph()->setData(x0, y0);
customPlot->graph()->setLineStyle(QCPGraph::lsLine); //(QCPGraph::LineStyle)(rand()%5+1));
customPlot->graph()->setScatterStyle(QCPScatterStyle::ssNone); // (QCP::ScatterStyle)(rand()%9+1));
QPen graphPen;
// graphPen.setColor(QColor(rand()%245+10, rand()%245+10, rand()%245+10));
//graphPen.setWidthF(rand()/(double)RAND_MAX*2+1);
graph_counter++;
graph_counter = graph_counter%9;
graphPen.setColor(QColor(Qt::GlobalColor(5+graph_counter)));
graphPen.setWidthF(2);
customPlot->graph()->setPen(graphPen);
customPlot->xAxis->setRange(0,0.5);
customPlot->yAxis->setRange(-90,10);
customPlot->legend->setVisible(true);
// customPlot->setInteraction(QCustomPlot::iSelectPlottables);
customPlot->graph()->setName(QString(shape.c_str()));
customPlot->replot();
}
