//not used anywhere
int Calligra::Sheets::Util::penCompare(QPen const & pen1, QPen const & pen2)
{
if (pen1.style() == Qt::NoPen && pen2.style() == Qt::NoPen)
return 0;
if (pen1.style() == Qt::NoPen)
return -1;
if (pen2.style() == Qt::NoPen)
return 1;
if (pen1.width() < pen2.width())
return -1;
if (pen1.width() > pen2.width())
return 1;
if (pen1.style() < pen2.style())
return -1;
if (pen1.style() > pen2.style())
return 1;
if (pen1.color().name() < pen2.color().name())
return -1;
if (pen1.color().name() > pen2.color().name())
return 1;
return 0;
}
void MythD3D9Painter::DrawRect(const QRect &area, const QBrush &fillBrush,
const QPen &linePen, int alpha)
{
int style = fillBrush.style();
if (style == Qt::SolidPattern || style == Qt::NoBrush)
{
if (!m_render)
return;
if (style != Qt::NoBrush)
m_render->DrawRect(area, fillBrush.color(), alpha);
if (linePen.style() != Qt::NoPen)
{
int lineWidth = linePen.width();
QRect top(QPoint(area.x(), area.y()),
QSize(area.width(), lineWidth));
QRect bot(QPoint(area.x(), area.y() + area.height() - lineWidth),
QSize(area.width(), lineWidth));
QRect left(QPoint(area.x(), area.y()),
QSize(lineWidth, area.height()));
QRect right(QPoint(area.x() + area.width() - lineWidth, area.y()),
QSize(lineWidth, area.height()));
m_render->DrawRect(top, linePen.color(), alpha);
m_render->DrawRect(bot, linePen.color(), alpha);
m_render->DrawRect(left, linePen.color(), alpha);
m_render->DrawRect(right, linePen.color(), alpha);
}
return;
}
MythPainter::DrawRect(area, fillBrush, linePen, alpha);
}
QString Calligra::Sheets::Odf::encodePen(const QPen & pen)
{
// kDebug()<<"encodePen( const QPen & pen ) :"<<pen;
// NOTE Stefan: QPen api docs:
// A line width of zero indicates a cosmetic pen. This means
// that the pen width is always drawn one pixel wide,
// independent of the transformation set on the painter.
QString s = QString("%1pt ").arg((pen.width() == 0) ? 1 : pen.width());
switch (pen.style()) {
case Qt::NoPen:
return "none";
case Qt::SolidLine:
s += "solid";
break;
case Qt::DashLine:
s += "dashed";
break;
case Qt::DotLine:
s += "dotted";
break;
case Qt::DashDotLine:
s += "dot-dash";
break;
case Qt::DashDotDotLine:
s += "dot-dot-dash";
break;
default: break;
}
//kDebug() << " encodePen :" << s;
if (pen.color().isValid()) {
s += ' ' + Style::colorName(pen.color());
}
return s;
}
void ContentWindowGraphicsItem::drawMovieControls_( QPainter* painter )
{
ContentWindowManagerPtr contentWindowManager = getContentWindowManager();
float buttonWidth, buttonHeight;
getButtonDimensions(buttonWidth, buttonHeight);
QPen pen;
if( contentWindowManager->getContent()->getType() == CONTENT_TYPE_MOVIE &&
g_configuration->getOptions()->getShowMovieControls( ))
{
// play/pause
QRectF playPauseRect(coordinates_.x() + coordinates_.width()/2 - buttonWidth, coordinates_.y() + coordinates_.height() - buttonHeight,
buttonWidth, buttonHeight);
pen.setColor(QColor(contentWindowManager->getControlState() & STATE_PAUSED ? 128 :200,0,0));
painter->setPen(pen);
painter->fillRect(playPauseRect, pen.color());
// loop
QRectF loopRect(coordinates_.x() + coordinates_.width()/2, coordinates_.y() + coordinates_.height() - buttonHeight,
buttonWidth, buttonHeight);
pen.setColor(QColor(0,contentWindowManager->getControlState() & STATE_LOOP ? 200 :128,0));
painter->setPen(pen);
painter->fillRect(loopRect, pen.color());
}
}
QPair<QPixmap, QPoint> makeStandardMarker(MapShapeType shapeType, const QString & text, const QPen & pen, const QPen & textPen, const QBrush & brush)
{
QString svgTemplate;
QPoint offset;
switch (shapeType) {
case SHAPE_BALLOON:
svgTemplate = "<svg>"
"<path "
"style=\"fill:#000000;fill-opacity:.4\" "
"d=\"m 18.948,33.432051 c 0,1.41694 -2.238,2.567949 -5,2.567949 -2.762,0 -5,-1.151009 -5,-2.567949 0,-1.416939 2.238,-2.567948 5,-2.567948 2.762,-0.002 5,1.149994 5,2.567948\" "
"/>"
"<path "
"style=\"fill:#666\" "
"d=\"M 14 0 C 6.28 0 0 6.3348796 0 14.125 C 0 16.209809 0.4425 18.209911 1.3125 20.09375 L 1.84375 21.125 C 2.96275 23.084964 12.2565 32.190555 13.3125 33.21875 L 14 33.875 L 14.6875 33.21875 C 15.7435 32.188525 25.026 23.109909 26.125 21.1875 L 26.65625 20.15625 C 27.54825 18.225721 28 16.204734 28 14.125 C 28.001 6.3348796 21.72 0 14 0 z M 14 0.90625 C 21.175 0.90625 27 6.7640687 27 14 C 27 15.982294 26.55825 17.873541 25.78125 19.5625 L 25.28125 20.53125 C 24.22125 22.386669 14 32.375 14 32.375 C 14 32.375 3.77875 22.387684 2.71875 20.53125 L 2.21875 19.5625 C 1.43975 17.875571 1 15.982294 1 14 C 1 6.7640687 6.823 0.90625 14 0.90625 z \" "
"/>"
"<path "
"style=\"fill:#fff\" "
"d=\"M 14 0.90625 C 6.823 0.90625 1 6.7640687 1 14 C 1 15.982294 1.43975 17.875571 2.21875 19.5625 L 2.71875 20.53125 C 3.77875 22.387684 14 32.375 14 32.375 C 14 32.375 24.22125 22.386669 25.28125 20.53125 L 25.78125 19.5625 C 26.55825 17.873541 27 15.982294 27 14 C 27 6.7640687 21.175 0.90625 14 0.90625 z M 14 1.90625 C 20.616 1.90625 26 7.3294234 26 14 C 25.910217 16.115917 25.491329 18.196844 24.40625 20.03125 C 23.776565 21.248455 17.937 27.075427 14 30.9375 C 10.063 27.075427 4.206579 21.245609 3.59375 20.0625 C 2.614452 18.171896 1.90079 16.186259 2 14 C 2 7.3294234 7.383 1.90625 14 1.90625 z \" "
"/>"
"<path "
"style=\"fill:%brush%;fill-opacity:%brushOpacity%\" "
"d=\"m 13.996268,1.9105251 c -6.617,0 -12.001,5.4261873 -12.001,12.0967639 -0.09921,2.186259 0.631702,4.174018 1.611,6.064622 0.612829,1.183109 6.453,7.017707 10.39,10.87978 3.937,-3.862073 9.777315,-9.70013 10.407,-10.917335 1.085079,-1.834406 1.503217,-3.91115 1.593,-6.027067 0,-6.6705766 -5.384,-12.0967639 -12,-12.0967639 l 0,0 z\" "
"/>"
"<path style=\"fill:#ffffff;fill-opacity:0.7\" "
"d=\"M 20.968528,6.089997 C 17.785074,3.5240085 13.725682,2.5379787 11.919627,3.8924751 11.436514,4.2548035 11.151528,4.750748 11.073071,5.3665525 c 4.1092,0.6284223 7.111478,2.6511761 8.521564,4.4853881 2.388133,3.1064364 1.967904,3.9515754 1.967904,3.9515754 0.774274,-0.0387 1.422004,-0.242256 1.904023,-0.603757 1.806055,-1.354497 0.684944,-4.5441591 -2.498034,-7.109762 l 0,0 z\" "
"/>"
"<text "
"x=\"14\" y=\"19\" "
"font-size=\"10pt\" font-family=\"arial\" font-weight=\"bold\" text-anchor=\"middle\" "
"fill=\"%textPen%\" "
"textContent = \"%textContent%\""
">"
"%text%"
"</text>"
"</svg>";
offset = QPoint(-14, -34);
break;
case SHAPE_STAR:
svgTemplate = "<svg><path style=\"fill:%brush%;fill-opacity:%brushOpacity%\" d=\"M 16.00663,.0000019037492 C 7.1692812,.0000019037492 0,7.1692841 0,16.006632 0,24.843981 7.1692812,32 16.00663,32 24.84398,32 32,24.843981 32,16.006632 32,7.1692841 24.84398,.0000019037492 16.00663,.0000019037492 z M 15.847492,0.39784686 L 19.136344,11.484461 30.766679,10.993786 21.178615,17.544966 25.236635,28.379612 16.00663,21.324494 6.8959804,28.512225 10.794861,17.624536 1.1007042,11.232493 12.73104,11.537507 15.847492,0.39784686 z\" /><path style=\"fill:%pen%;fill-opacity:%penOpacity%\" d=\"M 15.847492,0.39784686 L 19.136344,11.484461 30.766679,10.993786 21.178615,17.544966 25.236635,28.379612 16.00663,21.324494 6.8959804,28.512225 10.794861,17.624536 1.1007042,11.232493 12.73104,11.537507 15.847492,0.39784686 z\" /><text x=\"16\" y=\"20\" font-size=\"10pt\" font-family=\"arial\" font-weight=\"bold\" text-anchor=\"middle\" fill=\"%textPen%\" textContent = \"%textContent%\">%text%</text></svg>";
offset = QPoint(-16, -16);
break;
}
svgTemplate.replace("%text%", text, Qt::CaseSensitive);
svgTemplate.replace("%pen%", pen.color().name(), Qt::CaseSensitive);
svgTemplate.replace("%penOpacity%", QString::number(pen.color().alpha() / 255.0), Qt::CaseSensitive);
svgTemplate.replace("%textPen%", textPen.color().name(), Qt::CaseSensitive);
svgTemplate.replace("%brush%", brush.color().name(), Qt::CaseSensitive);
svgTemplate.replace("%brushOpacity%", QString::number(brush.color().alpha() / 255.0), Qt::CaseSensitive);
svgTemplate.replace("%textContent%", "", Qt::CaseSensitive);
QSvgRenderer renderer(svgTemplate.toAscii());
QPixmap pixmap(renderer.defaultSize());
pixmap.fill(QColor(0, 0, 0, 0));
QPainter painter(&pixmap);
renderer.render(&painter);
return qMakePair(pixmap, offset);
}
void MythRenderOpenGL1::DrawRectPriv(const QRect &area, const QBrush &fillBrush,
const QPen &linePen, int alpha)
{
SetBlend(true);
DisableTextures();
glEnableClientState(GL_VERTEX_ARRAY);
if (fillBrush.style() != Qt::NoBrush)
{
SetColor(fillBrush.color().red(), fillBrush.color().green(),
fillBrush.color().blue(), fillBrush.color().alpha());
GLfloat *vertices = GetCachedVertices(GL_TRIANGLE_STRIP, area);
glVertexPointer(2, GL_FLOAT, 0, vertices);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
if (linePen.style() != Qt::NoPen)
{
SetColor(linePen.color().red(), linePen.color().green(),
linePen.color().blue(), linePen.color().alpha());
glLineWidth(linePen.width());
GLfloat *vertices = GetCachedVertices(GL_LINE_LOOP, area);
glVertexPointer(2, GL_FLOAT, 0, vertices);
glDrawArrays(GL_LINE_LOOP, 0, 4);
}
glDisableClientState(GL_VERTEX_ARRAY);
}
void RawDelegate::plotEvents(const QModelIndex &index, const QStyleOptionViewItem &option, QPainter* painter) const
{
const RawModel* rawModel = static_cast<const RawModel*>(index.model());
qint32 sampleRangeLow = rawModel->relFiffCursor();
qint32 sampleRangeHigh = sampleRangeLow + rawModel->sizeOfPreloadedData();
QPen pen;
pen.setWidth(EVENT_MARKER_WIDTH);
QColor colorTemp;
QMap<int, QColor> eventTypeColor = m_pEventModel->getEventTypeColors();
if(!m_bShowSelectedEventsOnly) { //Plot all events
for(int i = 0; i<m_pEventModel->rowCount(); i++) {
int sampleValue = m_pEventModel->data(m_pEventModel->index(i,0)).toInt();
int type = m_pEventModel->data(m_pEventModel->index(i,2)).toInt();
if(sampleValue>=sampleRangeLow && sampleValue<=sampleRangeHigh) {
//Set color for pen depending on current event type
pen.setColor(eventTypeColor.value(type, Qt::black));
colorTemp = pen.color();
colorTemp.setAlpha(EVENT_MARKER_OPACITY);
pen.setColor(colorTemp);
painter->setPen(pen);
//Draw line from sample position (x) and highest to lowest y position of the column widget - Add -m_qSettings.value("EventDesignParameters/event_marker_width").toInt() to avoid painting ovre the edge of the column widget
painter->drawLine(option.rect.x() + sampleValue, option.rect.y(), option.rect.x() + sampleValue, option.rect.y() + option.rect.height() - EVENT_MARKER_WIDTH);
} // END for statement
} // END if statement event in data range
} // END if statement plot all
else { //Only plot selected events
QModelIndexList indexes = m_pEventView->selectionModel()->selectedIndexes();
for(int i = 0; i<indexes.size(); i++) {
qDebug()<<indexes.at(i).row();
int currentRow = indexes.at(i).row();
int sampleValue = m_pEventModel->data(m_pEventModel->index(currentRow,0)).toInt();
int type = m_pEventModel->data(m_pEventModel->index(currentRow,2)).toInt();
if(sampleValue>=sampleRangeLow && sampleValue<=sampleRangeHigh) {
//qDebug()<<"currentRow"<<currentRow<<"sampleValue"<<sampleValue<<"sampleRangeLow"<<sampleRangeLow<<"sampleRangeHigh"<<sampleRangeHigh;
//Set color for pen depending on current event type
pen.setColor(eventTypeColor.value(type, Qt::black));
colorTemp = pen.color();
colorTemp.setAlpha(EVENT_MARKER_OPACITY);
pen.setColor(colorTemp);
painter->setPen(pen);
//Draw line from sample position (x) and highest to lowest y position of the column widget - Add +m_qSettings.value("EventDesignParameters/event_marker_width").toInt() to avoid painting ovre the edge of the column widget
painter->drawLine(option.rect.x() + sampleValue, option.rect.y(), option.rect.x() + sampleValue, option.rect.y() - option.rect.height() + EVENT_MARKER_WIDTH);
} // END for statement
} // END if statement
} // END else statement
}
void graphInspector::changeColor()
{
QPen* pen = &(graphs->at(graphBox->currentIndex())->pen);
pen->setColor(QColorDialog::getColor(pen->color(),parentWidget()));
colorEdit->setPalette(pen->color());
emit needToRedraw();
}
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 SAPenSetWidget::setPen(const QPen &pen)
{
m_curPen = pen;
m_enableEmit = false;
ui->pushButtonColor->setCurrentColor(pen.color());
ui->comboBoxPenStyle->setStyle(pen.style());
ui->spinBoxPenWidth->setValue(pen.width());
ui->horizontalSliderColorAlpha->setValue(pen.color().alpha());
m_enableEmit = true;
}
void PinNode::drawShape( QPainter & p )
{
initPainter( p );
double v = pin() ? pin()->voltage() : 0.0;
QColor voltageColor = Component::voltageColor( v );
QPen pen = p.pen();
if ( isSelected() )
pen = m_selectedColor;
else if ( m_bShowVoltageColor )
pen = voltageColor;
if (m_pinPoint) {
bool drawDivPoint;
QPoint divPoint = findConnectorDivergePoint(&drawDivPoint);
m_pinPoint->setVisible(drawDivPoint);
m_pinPoint->move( divPoint.x()-1, divPoint.y()-1 );
m_pinPoint->setBrush( pen.color() );
m_pinPoint->setPen( pen.color() );
}
// Now to draw on our current/voltage bar indicators
int length = calcLength( v );
if ( (numPins() == 1) && m_bShowVoltageBars && length != 0 ) {
// we can assume that v != 0 as length != 0
double i = pin()->current();
double iProp = calcIProp(i);
int thickness = calcThickness(iProp);
p.setPen( QPen( voltageColor, thickness ) );
// The node line (drawn at the end of this function) will overdraw
// some of the voltage bar, so we need to adapt the length
if ( (v > 0) && (((225 < m_dir) && (m_dir < 315)) || ((45 < m_dir) && (m_dir < 135))) )
length--;
else if ( (v < 0) && (((135 < m_dir) && (m_dir < 225)) || ((315 < m_dir) || (m_dir < 45))) )
length++;
if ( (m_dir > 270) || (m_dir <= 90) )
p.drawLine( 3, 0, 3, length );
else p.drawLine( 3, 0, 3, -length );
}
pen.setWidth( (numPins() > 1) ? 2 : 1 );
p.setPen( pen );
p.drawLine( 0, 0, m_length, 0 );
deinitPainter( p );
}
void KoOdfGraphicStyles::saveOdfStrokeStyle(KoGenStyle &styleStroke, KoGenStyles &mainStyles, const QPen &pen)
{
// TODO implement all possibilities
switch (pen.style()) {
case Qt::NoPen:
styleStroke.addProperty("draw:stroke", "none");
return;
case Qt::SolidLine:
styleStroke.addProperty("draw:stroke", "solid");
break;
default: { // must be a dashed line
styleStroke.addProperty("draw:stroke", "dash");
// save stroke dash (14.14.7) which is severly limited, but still
KoGenStyle dashStyle(KoGenStyle::StrokeDashStyle);
dashStyle.addAttribute("draw:style", "rect");
QVector<qreal> dashes = pen.dashPattern();
dashStyle.addAttribute("draw:dots1", static_cast<int>(1));
dashStyle.addAttributePt("draw:dots1-length", dashes[0]*pen.widthF());
dashStyle.addAttributePt("draw:distance", dashes[1]*pen.widthF());
if (dashes.size() > 2) {
dashStyle.addAttribute("draw:dots2", static_cast<int>(1));
dashStyle.addAttributePt("draw:dots2-length", dashes[2]*pen.widthF());
}
QString dashStyleName = mainStyles.insert(dashStyle, "dash");
styleStroke.addProperty("draw:stroke-dash", dashStyleName);
break;
}
}
if (pen.brush().gradient()) {
styleStroke.addProperty("koffice:stroke-gradient", saveOdfGradientStyle(mainStyles, pen.brush()));
}
else {
styleStroke.addProperty("svg:stroke-color", pen.color().name());
styleStroke.addProperty("svg:stroke-opacity", QString("%1").arg(pen.color().alphaF()));
}
styleStroke.addPropertyPt("svg:stroke-width", pen.widthF());
switch (pen.joinStyle()) {
case Qt::MiterJoin:
styleStroke.addProperty("draw:stroke-linejoin", "miter");
break;
case Qt::BevelJoin:
styleStroke.addProperty("draw:stroke-linejoin", "bevel");
break;
case Qt::RoundJoin:
styleStroke.addProperty("draw:stroke-linejoin", "round");
break;
default:
styleStroke.addProperty("draw:stroke-linejoin", "miter");
styleStroke.addProperty("koffice:stroke-miterlimit", QString("%1").arg(pen.miterLimit()));
break;
}
}
void QDeclarativeTextLayout::draw(QPainter *painter, const QPointF &p)
{
QPainterPrivate *priv = QPainterPrivate::get(painter);
bool paintEngineSupportsTransformations = priv->extended &&
(priv->extended->type() == QPaintEngine::OpenGL2 ||
priv->extended->type() == QPaintEngine::OpenVG ||
priv->extended->type() == QPaintEngine::OpenGL);
if (!paintEngineSupportsTransformations || !priv->state->matrix.isAffine()) {
QTextLayout::draw(painter, p);
return;
}
prepare();
int itemCount = d->items.count();
if (p != d->position) {
QFixed fx = QFixed::fromReal(p.x());
QFixed fy = QFixed::fromReal(p.y());
QFixed oldX = QFixed::fromReal(d->position.x());
QFixed oldY = QFixed::fromReal(d->position.y());
for (int item = 0; item < itemCount; ++item) {
QStaticTextItem &textItem = d->items[item];
for (int ii = 0; ii < textItem.numGlyphs; ++ii) {
textItem.glyphPositions[ii].x += fx - oldX;
textItem.glyphPositions[ii].y += fy - oldY;
}
textItem.userDataNeedsUpdate = true;
}
d->position = p;
}
QPen oldPen = priv->state->pen;
QColor currentColor = oldPen.color();
for (int ii = 0; ii < itemCount; ++ii) {
QStaticTextItem &item = d->items[ii];
if (item.color.isValid() && currentColor != item.color) {
painter->setPen(item.color);
currentColor = item.color;
}
priv->extended->drawStaticTextItem(&item);
qt_draw_decoration_for_glyphs(painter, item.glyphs, item.glyphPositions,
item.numGlyphs, item.fontEngine(), painter->font(),
QTextCharFormat());
}
if (currentColor != oldPen.color())
painter->setPen(oldPen);
}
void ClipPainter::drawPolyline(const QPolygonF & polygon, QVector<QPointF>& labelNodes,
LabelPositionFlags positionFlags)
{
if ( d->m_doClip ) {
d->initClipRect();
QVector<QPolygonF> clippedPolyObjects;
d->clipPolyObject( polygon, clippedPolyObjects, false );
for( const QPolygonF & clippedPolyObject: clippedPolyObjects ) {
if (d->m_debugPolygonsLevel) {
QPen pen = QPainter::pen();
QPen originalPen = pen;
QColor color = pen.color();
color.setAlpha(color.alpha()*0.75);
pen.setColor(color);
QPainter::setPen(pen);
QPainter::drawPolyline ( clippedPolyObject );
QPainter::setPen(originalPen);
d->debugDrawNodes( clippedPolyObject );
}
else {
QPainter::drawPolyline ( clippedPolyObject );
}
}
}
else {
if (d->m_debugPolygonsLevel) {
QPen pen = QPainter::pen();
QPen originalPen = pen;
QColor color = pen.color();
color.setAlpha(color.alpha()*0.75);
pen.setColor(color);
QPainter::setPen(pen);
QPainter::drawPolyline ( polygon );
QPainter::setPen(originalPen);
d->debugDrawNodes( polygon );
}
else {
QPainter::drawPolyline ( polygon );
}
d->labelPosition( polygon, labelNodes, positionFlags );
}
}
void CMindMapDtLineTool::onLineColor()
{
QPoint p;
QColor c;
QPen pen;
QList<CDiagramItem*> items;
if (!m_d || !m_p)
return;
items = m_d->getItemsHasFocus();
if (items.length() == 0)
return;
foreach (CDiagramItem *item, items)
{
if (dynamic_cast<CMindMapNode*>(item))
{
pen = item->pen();
break;
}
}
c = pen.color();
m_lineColors->setMode( CUiColorPanel::SolidFill );
m_lineColors->setSelectedColor(c);
p = Utils::getPopupPoint(m_d, m_p, ui->m_btnLineColor, m_lineColors);
if (!p.isNull())
{
m_lineColors->raise();
m_lineColors->show();
m_lineColors->move( p );
}
}
/**
* Draws an ordinary line in 3D by expanding it in the z-axis by the given depth.
*
* @param line The line to draw
* @param brush The brush to fill the resulting polygon with
* @param pen The pen to paint the borders of the resulting polygon with
* @param props The 3D properties to draw the line with
* @return The 3D shape drawn
*/
QPolygonF StockDiagram::Private::ThreeDPainter::drawThreeDLine( const QLineF &line, const QBrush &brush,
const QPen &pen, const ThreeDProperties &props )
{
// Restores the painting properties when destroyed
PainterSaver painterSaver( painter );
const QPointF p1 = line.p1();
const QPointF p2 = line.p2();
// Project the 2D points of the line in 3D
const QPointF deepP1 = projectPoint( p1, props.depth, props.angle );
const QPointF deepP2 = projectPoint( p2, props.depth, props.angle );
// The result is a 3D representation of the 2D line
QPolygonF threeDArea;
threeDArea << p1 << p2 << deepP2 << deepP1 << p1;
// Use shadow colors if ThreeDProperties::useShadowColors is set
// Note: Setting a new color on a brush or pen does not effect gradients or textures
if ( props.useShadowColors ) {
QBrush shadowBrush( brush );
QPen shadowPen( pen );
shadowBrush.setColor( calcShadowColor( brush.color(), props.angle ) );
shadowPen.setColor( calcShadowColor( pen.color(), props.angle ) );
painter->setBrush( shadowBrush );
painter->setPen( shadowPen );
} else {
painter->setBrush( brush );
painter->setPen( pen );
}
painter->drawPolygon( threeDArea );
return threeDArea;
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
QPen Application::configGetPen(const std::string& query, const QPen& base) const {
QPen p(base);
// Color
try {
const std::string& colQuery = query + ".color";
p.setColor(readColor(colQuery, configGetString(colQuery), base.color()));
}
catch ( ... ) {}
// Style
try {
static const std::map<std::string, Qt::PenStyle> styleNameMap =
boost::assign::map_list_of<std::string, Qt::PenStyle>
("customdashline", Qt::CustomDashLine)
("dashdotdotline", Qt::DashDotDotLine)
("dashdotline", Qt::DashDotLine)
("dashline", Qt::DashLine)
("dotline", Qt::DotLine)
("nopen", Qt::NoPen)
("solidline", Qt::SolidLine);
std::string value = configGetString(query + ".style");
std::transform(value.begin(), value.end(), value.begin(), ::tolower);
p.setStyle(styleNameMap.at(value));
}
catch ( ... ) {}
// Width
try {
p.setWidth(configGetDouble(query + ".width"));
}
catch ( ... ) {}
return p;
}
void QgsComposerLegend::drawPolygonSymbol( QPainter* p, QgsSymbol* s, double currentYCoord, double& currentXPosition, int opacity ) const
{
if ( !s )
{
return;
}
if ( p )
{
//scale brush and set transparencies
QBrush symbolBrush = s->brush();
QColor brushColor = symbolBrush.color();
brushColor.setAlpha( opacity );
symbolBrush.setColor( brushColor );
QPaintDevice* paintDevice = p->device();
if ( paintDevice )
{
double rasterScaleFactor = ( paintDevice->logicalDpiX() + paintDevice->logicalDpiY() ) / 2.0 / 25.4;
QgsRenderer::scaleBrush( symbolBrush, rasterScaleFactor );
}
p->setBrush( symbolBrush );
QPen symbolPen = s->pen();
QColor penColor = symbolPen.color();
penColor.setAlpha( opacity );
symbolPen.setColor( penColor );
p->setPen( symbolPen );
p->drawRect( QRectF( currentXPosition, currentYCoord, mSymbolWidth, mSymbolHeight ) );
}
currentXPosition += mSymbolWidth;
}
void KeypointItem::showDescription()
{
if(!placeHolder_ || !placeHolder_->isVisible())
{
if(!placeHolder_)
{
QString info = QString( "Keypoint = %1\n"
"Word = %2\n"
"Response = %3\n"
"Angle = %4\n"
"X = %5\n"
"Y = %6\n"
"Size = %7").arg(id_).arg(wordID_).arg(kpt_.response).arg(kpt_.angle).arg(kpt_.pt.x).arg(kpt_.pt.y).arg(kpt_.size);
placeHolder_ = new QGraphicsRectItem();
placeHolder_->setVisible(false);
this->scene()->addItem(placeHolder_);
placeHolder_->setBrush(QBrush(QColor ( 0, 0, 0, 170 ))); // Black transparent background
QGraphicsTextItem * text = new QGraphicsTextItem(placeHolder_);
text->setDefaultTextColor(this->pen().color().rgb());
text->setPlainText(info);
placeHolder_->setRect(text->boundingRect());
}
QPen pen = this->pen();
this->setPen(QPen(pen.color(), pen.width()+2));
placeHolder_->setZValue(this->zValue()+1);
placeHolder_->setPos(this->mapToScene(0,0));
placeHolder_->setVisible(true);
}
}
void ObjWidget::setAlpha(int alpha)
{
if(alpha>=0 && alpha<=255)
{
alpha_ = alpha;
if(graphicsViewInitialized_)
{
for(int i=0; i<keypointItems_.size() && i<kptColors_.size(); ++i)
{
QColor color = kptColors_.at(i);
color.setAlpha(alpha_);
keypointItems_.at(i)->setColor(color);
}
}
for(int i=0; i<rectItems_.size(); ++i)
{
QPen pen = rectItems_.at(i)->pen();
QColor color = pen.color();
color.setAlpha(alpha_);
pen.setColor(color);
rectItems_.at(i)->setPen(pen);
}
if(!graphicsViewMode_->isChecked())
{
this->update();
}
}
}
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;
}
int Pen::color(lua_State * L) // () const : QColor
{
QPen* obj = QtValue<QPen>::check( L, 1 );
QColor* res = QtValue<QColor>::create( L );
*res = obj->color();
return 1;
}
void KigPainter::setPen( const QPen& p )
{
color = p.color();
width = p.width();
style = p.style();
mP.setPen(p);
}
//-------------------------------------------------------------
void GDeviceQt::PushPen( const VGColor & inColor, float inWidth )
{
QPen qPen = mQPainter->pen();
PenState state = {qPen.color(), static_cast<float>(qPen.widthF())};
mPenStack.push( state );
SelectPen( inColor, inWidth );
}
void ItemDelegate::paintStartFinishConstraint( QPainter* painter, const QStyleOptionGraphicsItem& opt, const QPointF& start, const QPointF& end, const Constraint &constraint )
{
Q_UNUSED( opt );
QPen pen;
QVariant dataPen;
// default pens
if ( start.x() <= end.x() ) {
pen = QPen( Qt::black );
dataPen = constraint.data( Constraint::ValidConstraintPen );
} else {
pen = QPen( Qt::red );
dataPen = constraint.data( Constraint::InvalidConstraintPen );
}
// data() pen
if( qVariantCanConvert< QPen >( dataPen ) )
pen = qVariantValue< QPen >( dataPen );
painter->setPen( pen );
painter->setBrush( pen.color() );
QPointF e = end;
if ( constraint.endIndex().data( KDGantt::ItemTypeRole ).toInt() == KDGantt::TypeEvent ) {
e.setX( e.x() + TURN );
}
painter->drawPolyline( startFinishLine( start, e ) );
painter->drawPolygon( startFinishArrow( start, e ) );
}
void ValueTrackerAttributes::setPen( const QPen& pen )
{
d->linePen = pen;
d->markerPen = pen;
d->markerBrush = QBrush();
d->arrowBrush = pen.color();
}
void QAbstractDiagramGraphicsItem::setPen(const QPen & pen)
{
QStringList mAttrs;
mAttrs << QString("color:#%1").arg(pen.color().rgb(),3, 16)
<< QString("width:%1").arg(pen.width());
switch(pen.style()){
case Qt::SolidLine:
mAttrs << "style::solid";
break;
case Qt::DashLine:
mAttrs << "style::dash";
break;
case Qt::DotLine:
mAttrs << "style::dor";
break;
case Qt::DashDotLine:
mAttrs << "style::dashdot";
break;
case Qt::DashDotDotLine:
mAttrs << "style::dashdotdot";
break;
default:
mAttrs << "style::solid";
break;
}
setProperty("pen", mAttrs.join(";"));
}
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);
}
}
ColorItemPopup::ColorItemPopup(const QPen &pen, graphicsUtils::AbstractScene &scene, QWidget *parent)
: ItemPopup(scene, parent)
, mLastColor(pen.color())
, mLastThickness(pen.width())
{
initWidget();
}
QgsGrassOptions::QgsGrassOptions( QWidget *parent )
: QgsOptionsDialogBase( "GrassOptions", parent )
, QgsGrassOptionsBase()
, mImportSettingsPath( "/GRASS/browser/import" )
, mModulesSettingsPath( "/GRASS/modules/config" )
{
setupUi( this );
initOptionsBase( false );
connect( this, SIGNAL( accepted() ), SLOT( saveOptions() ) );
connect( buttonBox->button( QDialogButtonBox::Apply ), SIGNAL( clicked() ), SLOT( saveOptions() ) );
QSettings settings;
// General
QString version = QString( GRASS_VERSION_STRING ).remove( "@(#)" ).trimmed();
QString revision = QString( GIS_H_VERSION ).remove( "$" ).trimmed();
mGrassVersionLabel->setText( tr( "GRASS version" ) + " : " + version + " " + revision );
bool customGisbase = settings.value( "/GRASS/gidbase/custom", false ).toBool();
QString customGisbaseDir = settings.value( "/GRASS/gidbase/customDir" ).toString();
mGisbaseDefaultRadioButton->setText( tr( "Default" ) + " (" + QgsGrass::defaultGisbase() + ")" );
mGisbaseDefaultRadioButton->setChecked( !customGisbase );
mGisbaseCustomRadioButton->setChecked( customGisbase );
mGisbaseLineEdit->setText( customGisbaseDir );
gisbaseChanged();
connect( mGisbaseDefaultRadioButton, SIGNAL( toggled( bool ) ), SLOT( gisbaseChanged() ) );
connect( mGisbaseLineEdit, SIGNAL( textChanged( const QString & ) ), SLOT( gisbaseChanged() ) );
connect( mGisbaseLineEdit, SIGNAL( textEdited( const QString & ) ), SLOT( gisbaseChanged() ) );
connect( mGisbaseGroupBox, SIGNAL( collapsedStateChanged( bool ) ), SLOT( gisbaseChanged() ) );
// Modules
bool customModules = settings.value( mModulesSettingsPath + "/custom", false ).toBool();
QString customModulesDir = settings.value( mModulesSettingsPath + "/customDir" ).toString();
mModulesConfigDefaultRadioButton->setText( tr( "Default" ) + " (" + QgsGrass::modulesConfigDefaultDirPath() + ")" );
mModulesConfigDefaultRadioButton->setChecked( !customModules );
mModulesConfigCustomRadioButton->setChecked( customModules );
mModulesConfigDirLineEdit->setText( customModulesDir );
mModulesDebugCheckBox->setChecked( QgsGrass::modulesDebug() );
// Browser
QgsRasterProjector::Precision crsTransform = ( QgsRasterProjector::Precision ) settings.value( mImportSettingsPath + "/crsTransform", QgsRasterProjector::Approximate ).toInt();
mCrsTransformationComboBox->addItem( QgsRasterProjector::precisionLabel( QgsRasterProjector::Approximate ), QgsRasterProjector::Approximate );
mCrsTransformationComboBox->addItem( QgsRasterProjector::precisionLabel( QgsRasterProjector::Exact ), QgsRasterProjector::Exact );
mCrsTransformationComboBox->setCurrentIndex( mCrsTransformationComboBox->findData( crsTransform ) );
mImportExternalCheckBox->setChecked( settings.value( mImportSettingsPath + "/external", true ).toBool() );
mTopoLayersCheckBox->setChecked( settings.value( "/GRASS/showTopoLayers", false ).toBool() );
// Region
QPen regionPen = QgsGrass::regionPen();
mRegionColorButton->setContext( "gui" );
mRegionColorButton->setColorDialogTitle( tr( "Select color" ) );
mRegionColorButton->setColor( regionPen.color() );
mRegionWidthSpinBox->setValue( regionPen.width() );
restoreOptionsBaseUi();
}
