void QgsPalLabeling::drawLabeling( QgsRenderContext& context )
{
Q_ASSERT( mMapRenderer != NULL );
QPainter* painter = context.painter();
QgsRectangle extent = context.extent();
if ( mLabelSearchTree )
{
mLabelSearchTree->clear();
}
QTime t;
t.start();
// do the labeling itself
double scale = mMapRenderer->scale(); // scale denominator
QgsRectangle r = extent;
double bbox[] = { r.xMinimum(), r.yMinimum(), r.xMaximum(), r.yMaximum() };
std::list<LabelPosition*>* labels;
pal::Problem* problem;
try
{
problem = mPal->extractProblem( scale, bbox );
}
catch ( std::exception& e )
{
Q_UNUSED( e );
QgsDebugMsg( "PAL EXCEPTION :-( " + QString::fromLatin1( e.what() ) );
//mActiveLayers.clear(); // clean up
return;
}
const QgsMapToPixel* xform = mMapRenderer->coordinateTransform();
// draw rectangles with all candidates
// this is done before actual solution of the problem
// before number of candidates gets reduced
mCandidates.clear();
if ( mShowingCandidates && problem )
{
painter->setPen( QColor( 0, 0, 0, 64 ) );
painter->setBrush( Qt::NoBrush );
for ( int i = 0; i < problem->getNumFeatures(); i++ )
{
for ( int j = 0; j < problem->getFeatureCandidateCount( i ); j++ )
{
pal::LabelPosition* lp = problem->getFeatureCandidate( i, j );
drawLabelCandidateRect( lp, painter, xform );
}
}
}
// find the solution
labels = mPal->solveProblem( problem, mShowingAllLabels );
QgsDebugMsg( QString( "LABELING work: %1 ms ... labels# %2" ).arg( t.elapsed() ).arg( labels->size() ) );
t.restart();
painter->setRenderHint( QPainter::Antialiasing );
// draw the labels
std::list<LabelPosition*>::iterator it = labels->begin();
for ( ; it != labels->end(); ++it )
{
QgsPalGeometry* palGeometry = dynamic_cast< QgsPalGeometry* >(( *it )->getFeaturePart()->getUserGeometry() );
if ( !palGeometry )
{
continue;
}
//layer names
QString layerNameUtf8 = QString::fromUtf8(( *it )->getLayerName() );
if ( palGeometry->isDiagram() )
{
//render diagram
QHash<QgsVectorLayer*, QgsDiagramLayerSettings>::iterator dit = mActiveDiagramLayers.begin();
for ( dit = mActiveDiagramLayers.begin(); dit != mActiveDiagramLayers.end(); ++dit )
{
if ( dit.key() && dit.key()->id().append( "d" ) == layerNameUtf8 )
{
QgsPoint outPt = xform->transform(( *it )->getX(), ( *it )->getY() );
dit.value().renderer->renderDiagram( palGeometry->diagramAttributes(), context, QPointF( outPt.x(), outPt.y() ) );
}
}
//insert into label search tree to manipulate position interactively
if ( mLabelSearchTree )
{
//for diagrams, remove the additional 'd' at the end of the layer id
QString layerId = layerNameUtf8;
layerId.chop( 1 );
mLabelSearchTree->insertLabel( *it, QString( palGeometry->strId() ).toInt(), layerId, true );
}
continue;
}
const QgsPalLayerSettings& lyr = layer( layerNameUtf8 );
QFont fontForLabel = lyr.textFont;
QColor fontColor = lyr.textColor;
double bufferSize = lyr.bufferSize;
QColor bufferColor = lyr.bufferColor;
//apply data defined settings for the label
//font size
QVariant dataDefinedSize = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Size );
if ( dataDefinedSize.isValid() )
{
fontForLabel.setPixelSize( lyr.sizeToPixel( dataDefinedSize.toDouble(), context ) );
}
//font color
QVariant dataDefinedColor = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Color );
if ( dataDefinedColor.isValid() )
{
fontColor.setNamedColor( dataDefinedColor.toString() );
if ( !fontColor.isValid() )
{
fontColor = lyr.textColor;
}
}
//font bold
QVariant dataDefinedBold = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Bold );
if ( dataDefinedBold.isValid() )
{
fontForLabel.setBold(( bool )dataDefinedBold.toInt() );
}
//font italic
QVariant dataDefinedItalic = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Italic );
if ( dataDefinedItalic.isValid() )
{
fontForLabel.setItalic(( bool ) dataDefinedItalic.toInt() );
}
//font underline
QVariant dataDefinedUnderline = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Underline );
if ( dataDefinedUnderline.isValid() )
{
fontForLabel.setUnderline(( bool ) dataDefinedUnderline.toInt() );
}
//font strikeout
QVariant dataDefinedStrikeout = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Strikeout );
if ( dataDefinedStrikeout.isValid() )
{
fontForLabel.setStrikeOut(( bool ) dataDefinedStrikeout.toInt() );
}
//font family
QVariant dataDefinedFontFamily = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::Family );
if ( dataDefinedFontFamily.isValid() )
{
fontForLabel.setFamily( dataDefinedFontFamily.toString() );
}
//buffer size
QVariant dataDefinedBufferSize = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::BufferSize );
if ( dataDefinedBufferSize.isValid() )
{
bufferSize = dataDefinedBufferSize.toDouble();
}
//buffer color
QVariant dataDefinedBufferColor = palGeometry->dataDefinedValues().value( QgsPalLayerSettings::BufferColor );
if ( dataDefinedBufferColor.isValid() )
{
bufferColor.setNamedColor( dataDefinedBufferColor.toString() );
if ( !bufferColor.isValid() )
{
bufferColor = lyr.bufferColor;
}
}
if ( lyr.bufferSize != 0 )
drawLabel( *it, painter, fontForLabel, fontColor, xform, bufferSize, bufferColor, true );
drawLabel( *it, painter, fontForLabel, fontColor, xform );
if ( mLabelSearchTree )
{
mLabelSearchTree->insertLabel( *it, QString( palGeometry->strId() ).toInt(), ( *it )->getLayerName() );
}
}
QgsDebugMsg( QString( "LABELING draw: %1 ms" ).arg( t.elapsed() ) );
delete problem;
delete labels;
// delete all allocated geometries for features
QHash<QgsVectorLayer*, QgsPalLayerSettings>::iterator lit;
for ( lit = mActiveLayers.begin(); lit != mActiveLayers.end(); ++lit )
{
QgsPalLayerSettings& lyr = lit.value();
for ( QList<QgsPalGeometry*>::iterator git = lyr.geometries.begin(); git != lyr.geometries.end(); ++git )
delete *git;
lyr.geometries.clear();
}
//delete all allocated geometries for diagrams
QHash<QgsVectorLayer*, QgsDiagramLayerSettings>::iterator dIt = mActiveDiagramLayers.begin();
for ( ; dIt != mActiveDiagramLayers.end(); ++dIt )
{
QgsDiagramLayerSettings& dls = dIt.value();
for ( QList<QgsPalGeometry*>::iterator git = dls.geometries.begin(); git != dls.geometries.end(); ++git )
{
delete *git;
}
dls.geometries.clear();
}
}
void MyRenderWidget::paintEvent(QPaintEvent * /*event*/ )
{
QPainter painter;
painter.begin(this);
QColor color(0,0,0,255);
QMatrix m,n;
QString secstr = QString::number(sec);
QString minstr = QString::number(min);
QString hourstr = QString::number(hour);
QFont font("Arial",12);
painter.setFont(font);
painter.drawText(200,75,hourstr);
painter.drawText(250,75,minstr);
painter.drawText(300,75,secstr);
//Shadow
m.reset();
m.translate(90,420);
m.rotate(-35);
m.shear(1,0.2);
m.scale(0.5,0.5);
painter.setMatrix(m);
painter.setPen(Qt::gray);
painter.setBrush(QColor(138, 121, 93,255));
painter.drawEllipse(100,100,300,300);
//Background
m.reset();
painter.setMatrix(m);
painter.setPen(QColor(0,0,0,255));
painter.setBrush(QColor(16,23,33,255));
painter.drawEllipse(100,100,300,300);
m.scale(0.8,0.8);
painter.setMatrix(m);
painter.setBrush(QColor(188,237,241,255));
painter.drawEllipse(165,163,300,300);
//Number
QPoint rotatedPoint;
painter.setMatrix(m);
for(int deg = 1; deg < 13; deg++){
m.reset();
m.translate(146,155);
m.rotate(deg*30-135);
rotatedPoint = QPoint(97,97)* m;
n.reset();
n.translate(rotatedPoint.x(), rotatedPoint.y());
painter.setMatrix(n);
painter.setPen(QColor(245,146,55,255));
QString hour = QString::number(deg);
QFont font("Arial",12);
painter.setFont(font);
painter.drawText(100,100,hour);
}
//Second Hand
m.reset();
m.translate(250,250);
m.rotate(180+6*sec);
m.translate(-100,-100);
painter.setMatrix(m);
painter.setPen(QColor(245,146,55,255));
painter.drawLine(99,100,99,220);
//Minute Hand
m.reset();
m.translate(250,250);
m.rotate(-90+6*min);
m.translate(-100,-100);
painter.setMatrix(m);
painter.setPen(QColor(245,146,55,255));
painter.setBrush(QColor(245,146,55,255));
painter.drawRect(100,100,130,5);
//Hour Hand
m.reset();
m.translate(250,250);
m.rotate(-90+30*hour+0.5*min);
m.translate(-100,-100);
painter.setMatrix(m);
painter.setPen(QColor(245,146,55,255));
painter.setBrush(QColor(245,146,55,255));
painter.drawRect(100,100,100,10);
//Center dot
m.reset();
painter.setMatrix(m);
painter.setPen(QColor(0,0,0,255));
painter.setBrush(QColor(16,23,33,255));
painter.drawEllipse(245,245,20,20);
painter.end();
}
void PointSetStyles::drawShape(QPainter &p, int xScreen, int yScreen, PointSetStyle pointSetStyle)
{
p.setPen(pointSetPen(pointSetStyle.pointLineColor, pointSetStyle.pointLineSize));
p.setBrush(pointSetBrush(pointSetStyle.pointInColor));
Q3PointArray arr;
int hPS = pointSizeToHalfwidth(pointSetStyle.pointSize); // half point size, excluding point line size
switch (pointSetStyle.pointShape)
{
case Cross:
arr.resize(9);
arr.setPoint(0, QPoint(-hPS + xScreen, 0 + yScreen));
arr.setPoint(1, QPoint( 0 + xScreen, 0 + yScreen));
arr.setPoint(2, QPoint( 0 + xScreen, -hPS + yScreen));
arr.setPoint(3, QPoint( 0 + xScreen, 0 + yScreen));
arr.setPoint(4, QPoint( hPS + xScreen, 0 + yScreen));
arr.setPoint(5, QPoint( 0 + xScreen, 0 + yScreen));
arr.setPoint(6, QPoint( 0 + xScreen, hPS + yScreen));
arr.setPoint(7, QPoint( 0 + xScreen, 0 + yScreen));
arr.setPoint(8, QPoint(-hPS + xScreen, 0 + yScreen));
break;
case Diamond:
arr.resize(5);
arr.setPoint(0, QPoint(-hPS + xScreen, 0 + yScreen));
arr.setPoint(1, QPoint( 0 + xScreen, -hPS + yScreen));
arr.setPoint(2, QPoint( hPS + xScreen, 0 + yScreen));
arr.setPoint(3, QPoint( 0 + xScreen, hPS + yScreen));
arr.setPoint(4, QPoint(-hPS + xScreen, 0 + yScreen));
break;
case Square:
arr.resize(5);
arr.setPoint(0, QPoint(-hPS + xScreen, -hPS + yScreen));
arr.setPoint(1, QPoint( hPS + xScreen, -hPS + yScreen));
arr.setPoint(2, QPoint( hPS + xScreen, hPS + yScreen));
arr.setPoint(3, QPoint(-hPS + xScreen, hPS + yScreen));
arr.setPoint(4, QPoint(-hPS + xScreen, -hPS + yScreen));
break;
case Triangle:
arr.resize(4);
arr.setPoint(0, QPoint(-hPS + xScreen, hPS + yScreen));
arr.setPoint(1, QPoint( hPS + xScreen, hPS + yScreen));
arr.setPoint(2, QPoint( 0 + xScreen, -hPS + yScreen));
arr.setPoint(3, QPoint(-hPS + xScreen, hPS + yScreen));
break;
case X:
default:
arr.resize(9);
arr.setPoint(0, QPoint(-hPS + xScreen, -hPS + yScreen));
arr.setPoint(1, QPoint( 0 + xScreen, 0 + yScreen));
arr.setPoint(2, QPoint(-hPS + xScreen, hPS + yScreen));
arr.setPoint(3, QPoint( 0 + xScreen, 0 + yScreen));
arr.setPoint(4, QPoint( hPS + xScreen, hPS + yScreen));
arr.setPoint(5, QPoint( 0 + xScreen, 0 + yScreen));
arr.setPoint(6, QPoint( hPS + xScreen, -hPS + yScreen));
arr.setPoint(7, QPoint( 0 + xScreen, 0 + yScreen));
arr.setPoint(8, QPoint(-hPS + xScreen, -hPS + yScreen));
break;
}
p.drawPolygon(arr);
}
void QgsHistogramDiagram::renderDiagram( const QgsFeature& feature, QgsRenderContext& c, const QgsDiagramSettings& s, const QPointF& position )
{
QPainter* p = c.painter();
if ( !p )
{
return;
}
QList<double> values;
double maxValue = 0;
QgsExpressionContext expressionContext = c.expressionContext();
expressionContext.setFeature( feature );
if ( feature.fields() )
expressionContext.setFields( *feature.fields() );
Q_FOREACH ( const QString& cat, s.categoryAttributes )
{
QgsExpression* expression = getExpression( cat, expressionContext );
double currentVal = expression->evaluate( &expressionContext ).toDouble();
values.push_back( currentVal );
maxValue = qMax( currentVal, maxValue );
}
double scaledMaxVal = sizePainterUnits( maxValue * mScaleFactor, s, c );
double currentOffset = 0;
double scaledWidth = sizePainterUnits( s.barWidth, s, c );
double baseX = position.x();
double baseY = position.y();
mPen.setColor( s.penColor );
setPenWidth( mPen, s, c );
p->setPen( mPen );
QList<double>::const_iterator valIt = values.constBegin();
QList< QColor >::const_iterator colIt = s.categoryColors.constBegin();
for ( ; valIt != values.constEnd(); ++valIt, ++colIt )
{
double length = sizePainterUnits( *valIt * mScaleFactor, s, c );
mCategoryBrush.setColor( *colIt );
p->setBrush( mCategoryBrush );
switch ( s.diagramOrientation )
{
case QgsDiagramSettings::Up:
p->drawRect( baseX + currentOffset, baseY, scaledWidth, length * -1 );
break;
case QgsDiagramSettings::Down:
p->drawRect( baseX + currentOffset, baseY - scaledMaxVal, scaledWidth, length );
break;
case QgsDiagramSettings::Right:
p->drawRect( baseX, baseY - currentOffset, length, scaledWidth * -1 );
break;
case QgsDiagramSettings::Left:
p->drawRect( baseX + scaledMaxVal, baseY - currentOffset, 0 - length, scaledWidth * -1 );
break;
}
currentOffset += scaledWidth;
}
}
void ossimGui::ImageScrollWidget::paintMultiLayer(QPainter& painter)
{
if(m_multiLayerAlgorithm != ANIMATION_ALGORITHM)
{
ossimRefPtr<Layer> topLayer = m_layers->layer((ossim_uint32)0);
ossimRefPtr<Layer> bottomLayer = m_layers->layer((ossim_uint32)1);
if(topLayer.valid()&&bottomLayer.valid())
{
ossimRefPtr<StaticTileImageCache> topTileCache = topLayer->tileCache();
ossimRefPtr<StaticTileImageCache> bottomTileCache = bottomLayer->tileCache();
if(topTileCache.valid()&&bottomTileCache.valid())
{
ossimIrect rect = topTileCache->getRect();
QRectF rectF = m_scrollToLocal.mapRect(QRectF(rect.ul().x, rect.ul().y, rect.width(), rect.height()));
ossimIpt topOriginOffset = ossimDpt(rectF.x(), rectF.y());
// for scrolling we need to offset from the tile location to the actual rect indicated by the viewport.
//
ossim_uint32 w = rect.width();
ossim_uint32 h = rect.height();
switch(m_multiLayerAlgorithm)
{
case HORIZONTAL_SWIPE_ALGORITHM:
{
ossim_int64 topLayerx = topOriginOffset.x;
ossim_int64 bottomLayerx = m_activePointEnd.x();
ossim_int64 topLayerWidth = bottomLayerx - topLayerx;
painter.drawImage(topLayerx, topOriginOffset.y, topTileCache->getCache(), 0,0,topLayerWidth,h);
painter.drawImage(topLayerx+topLayerWidth, topOriginOffset.y, bottomTileCache->getCache(), topLayerWidth, 0);
break;
}
case VERTICAL_SWIPE_ALGORITHM:
{
ossim_int64 topLayery = topOriginOffset.y;
ossim_int64 bottomLayery = m_activePointEnd.y();
ossim_int64 topLayerHeight = bottomLayery - topLayery;
painter.drawImage(topOriginOffset.x, topLayery, topTileCache->getCache(), 0, 0, w, topLayerHeight);
painter.drawImage(topOriginOffset.x, topLayery+topLayerHeight, bottomTileCache->getCache(), 0, topLayerHeight);
break;
}
case BOX_SWIPE_ALGORITHM:
{
painter.drawImage(topOriginOffset.x, topOriginOffset.y, topTileCache->getCache());
ossim_int64 minx = ossim::min(m_activePointStart.x(), m_activePointEnd.x());
ossim_int64 maxx = ossim::max(m_activePointStart.x(), m_activePointEnd.x());
ossim_int64 miny = ossim::min(m_activePointStart.y(), m_activePointEnd.y());
ossim_int64 maxy = ossim::max(m_activePointStart.y(), m_activePointEnd.y());
ossim_int64 w = maxx-minx;
ossim_int64 h = maxy-miny;
ossim_int64 x = minx;
ossim_int64 y = miny;
QPointF scrollPoint = m_localToScroll.map(QPointF(x,y));
ossimDrect cacheRect = bottomTileCache->getRect();
ossimDpt delta = ossimDpt(scrollPoint.x(), scrollPoint.y()) - cacheRect.ul();
painter.drawImage(x, y, bottomTileCache->getCache(), delta.x, delta.y, w, h);
break;
}
case CIRCLE_SWIPE_ALGORITHM:
{
// QImage& cahceImage = topTileCache->getCache();
// draw top and then overlay the bottom
ossim_int64 minx = ossim::min(m_activePointStart.x(), m_activePointEnd.x());
ossim_int64 maxx = ossim::max(m_activePointStart.x(), m_activePointEnd.x());
ossim_int64 miny = ossim::min(m_activePointStart.y(), m_activePointEnd.y());
ossim_int64 maxy = ossim::max(m_activePointStart.y(), m_activePointEnd.y());
ossim_int64 w = maxx-minx;
ossim_int64 h = maxy-miny;
ossim_int64 x = minx;
ossim_int64 y = miny;
// QPointF scrollPoint = m_localToScroll.map(QPointF(x,y));
// ossimDpt cachePt = ossimDpt(scrollPoint.x(), scrollPoint.y()) - topTileCache->getRect().ul();
painter.save();
painter.drawImage(topOriginOffset.x, topOriginOffset.y, topTileCache->getCache());
painter.setBrush(QBrush(bottomTileCache->getCache()));
painter.setPen(Qt::NoPen);
// this part is a little tricky but for the texturing to be placed in the ellipse properly
// I had to add a translation for the painter because the cache might extend past the current scroll region because it
// is on tile boundaries
//
// Because we shift for texturing with the QBrush we must undo the shift when drawing the ellipse so it lines up with
// the mouse draws. The topOriginOffset holds the shift.
//
painter.translate(topOriginOffset.x, topOriginOffset.y);
painter.drawEllipse(x-topOriginOffset.x,y-topOriginOffset.y,w,h);
painter.restore();
break;
}
default:
{
break;
}
}
}
}
}
else
{
}
}
void KoColorBackground::paint(QPainter &painter, const QPainterPath &fillPath) const
{
painter.setBrush(QBrush(d->color, d->style));
painter.drawPath(fillPath);
}
void MapIcons::paintIcon(MapParameters& param,
QPainter& p,
const MapIcon& mapIcon,
const Point3D<int16_t>& item,
const QString& itemName,
const QPoint& point)
{
// Draw Line
if (mapIcon.showLine0())
{
p.setPen(mapIcon.line0Pen());
p.drawLine(param.playerXOffset(),
param.playerYOffset(),
point.x(), point.y());
}
// Calculate distance and draw distance related lines
uint32_t distance = UINT32_MAX;
if (mapIcon.line1Distance() || mapIcon.line2Distance())
{
if (!showeq_params->fast_machine)
distance = item.calcDist2DInt(param.player());
else
distance = (int)item.calcDist(param.player());
if (mapIcon.line1Distance() > distance)
{
p.setPen(mapIcon.line1Pen());
p.drawLine(param.playerXOffset(),
param.playerYOffset(),
point.x(), point.y());
}
if (mapIcon.line2Distance() > distance)
{
p.setPen(mapIcon.line2Pen());
p.drawLine(param.playerXOffset(),
param.playerYOffset(),
point.x(), point.y());
}
}
// Draw Item Name
if (mapIcon.showName())
{
QFontMetrics fm(param.font());
int width = fm.width(itemName);
p.setPen(gray);
p.drawText(point.x() - (width / 2),
point.y() + fm.height() + 1, itemName);
}
// Draw Icon Image
if (mapIcon.image() &&
(!mapIcon.imageFlash() || m_flash) &&
(mapIcon.imageStyle() != tIconStyleNone))
{
p.setPen(mapIcon.imagePen());
p.setBrush(mapIcon.imageBrush());
mapIcon.paintIconImage(mapIcon.imageStyle(), p, point,
*m_mapIconSizes[mapIcon.imageSize()],
*m_mapIconSizesWH[mapIcon.imageSize()]);
}
// Draw Highlight
if (mapIcon.highlight() &&
(!mapIcon.highlightFlash() || m_flash) &&
(mapIcon.highlightStyle() != tIconStyleNone))
{
p.setPen(mapIcon.highlightPen());
p.setBrush(mapIcon.highlightBrush());
mapIcon.paintIconImage(mapIcon.highlightStyle(), p, point,
*m_mapIconSizes[mapIcon.highlightSize()],
*m_mapIconSizesWH[mapIcon.highlightSize()]);
}
}
void FrameView::paintEvent(QPaintEvent *)
{
const int px_unit = font.pixelSize();
const int px_hspace = px_unit * horizontal_factor;
const int px_vspace = px_unit * vertical_factor;
const int y_offset = viewport()->height()/2 - px_vspace/2;
const DocInfo *dinfo = gui::activeDocInfo();
m_currentFrame = dinfo->currentFrame();
m_currentChannel = dinfo->currentChannel();
int currentFrame = m_currentFrame;
int currentChannel = m_currentChannel;
const int frame_y_offset = y_offset - currentFrame*px_vspace;
const QColor bg = stylecolor(styles::PATTERN_BG);
QPainter p;
p.begin(viewport());
p.setPen(Qt::NoPen);
p.setBrush(bg);
p.drawRect(rect());
{
QLinearGradient lg(0, 0, 0, 1);
lg.setColorAt(0, QColor(96, 96, 96));
lg.setColorAt(1, QColor(64, 64, 64));
lg.setCoordinateMode(QGradient::ObjectBoundingMode);
p.setBrush(lg);
p.drawRect(0, y_offset, viewport()->width(), px_vspace);
}
{
p.setBrush(QColor(255,255,255,64));
p.drawRect(px_hspace*(currentChannel+1), y_offset, px_hspace, px_vspace);
}
p.setFont(font);
QTextOption opt;
opt.setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
const QColor framenumcol = stylecolor(styles::PATTERN_HIGHLIGHT2_FG, true);
p.setPen(framenumcol);
p.setBrush(Qt::NoBrush);
FtmDocument *d = activeDocument();
int chans = 0;
if (d != NULL)
{
chans = d->GetAvailableChannels();
}
int num_frames = d->GetFrameCount();
int viewport_height = viewport()->height();
for (int i = 0; i < num_frames; i++)
{
int y = px_vspace*i+frame_y_offset;
if (y+px_vspace < 0)
continue;
if (y > viewport_height)
break;
char buf[6];
sprintf(buf, "%02X", i);
p.drawText(QRect(0,y,px_hspace,px_vspace), buf, opt);
}
unsigned int active_patterns[MAX_CHANNELS];
for (int i = 0; i < chans; i++)
{
active_patterns[i] = d->GetPatternAtFrame(currentFrame, i);
}
const QColor selectedpat = stylecolor(styles::PATTERN_FG, true);
const QColor unselectedpat = stylecolor(styles::PATTERN_FG, false);
for (int i = 0; i < num_frames; i++)
{
int y = px_vspace*i+frame_y_offset;
if (y+px_vspace < 0)
continue;
if (y > viewport_height)
break;
for (int x = 0; x < chans; x++)
{
char buf[6];
int pattern = d->GetPatternAtFrame(i, x);
if (pattern == active_patterns[x])
{
p.setPen(selectedpat);
}
else
{
p.setPen(unselectedpat);
}
sprintf(buf, "%02X", pattern);
p.drawText(QRect(px_hspace*(x+1),y,px_hspace,px_vspace), buf, opt);
}
}
p.setPen(Qt::gray);
p.drawLine(px_hspace,0,px_hspace,viewport()->height());
p.end();
}
void NWaveformSlider::checkForUpdate()
{
if (!m_waveBuilder)
return;
float builderPos;
int builderIndex;
m_waveBuilder->positionAndIndex(builderPos, builderIndex);
if (m_oldSize != size() || m_oldBuilderIndex != builderIndex)
m_needsUpdate = true;
if ((builderPos != 0.0 && builderPos != 1.0) && m_timer->interval() != FAST_INTERVAL)
m_timer->setInterval(FAST_INTERVAL);
else
if ((builderPos == 0.0 || builderPos == 1.0) && m_timer->interval() != IDLE_INTERVAL)
m_timer->setInterval(IDLE_INTERVAL);
if (m_needsUpdate) {
QPainter painter;
QImage waveImage;
QImage backgroundImage;
waveImage = backgroundImage = m_progressPlayingImage = m_progressPausedImage = m_remainingPlayingImage = m_remainingPausedImage = QImage(size(), QImage::Format_ARGB32_Premultiplied);
m_oldBuilderPos = builderPos;
m_oldBuilderIndex = builderIndex;
m_oldSize = size();
// waveform >>
waveImage.fill(0);
painter.begin(&waveImage);
painter.setBrush(m_waveBackground);
QPen wavePen;
wavePen.setWidth(0);
wavePen.setColor(m_waveBorderColor);
painter.setPen(wavePen);
painter.translate(1, 1);
painter.scale((qreal)(width() - 1) / m_oldBuilderIndex * m_oldBuilderPos, (height() - 2) / 2);
painter.translate(0, 1);
QPainterPath pathPos;
QPainterPath pathNeg;
NWaveformPeaks *peaks = m_waveBuilder->peaks();
for (int i = 0; i < m_oldBuilderIndex; ++i) {
pathPos.lineTo(i, peaks->positive(i));
pathNeg.lineTo(i, peaks->negative(i));
}
QPainterPath fullPath(pathNeg);
fullPath.connectPath(pathPos.toReversed());
fullPath.closeSubpath();
painter.setRenderHint(QPainter::Antialiasing);
painter.drawPath(fullPath);
painter.end();
// << waveform
// main background >>
painter.begin(&backgroundImage);
backgroundImage.fill(0);
painter.setPen(Qt::NoPen);
painter.setBrush(m_background);
painter.setRenderHint(QPainter::Antialiasing);
painter.drawRoundedRect(rect(), m_radius, m_radius);
painter.end();
// << main background
QList<QImage *> images; images << &m_progressPlayingImage << &m_progressPausedImage << &m_remainingPlayingImage << &m_remainingPausedImage;
QList<QPainter::CompositionMode> modes; modes << m_playingComposition << m_pausedComposition << m_playingComposition << m_pausedComposition;
QList<QBrush> brushes; brushes << m_progressPlayingBackground << m_progressPausedBackground << m_remainingPlayingBackground << m_remainingPausedBackground;
for (int i = 0; i < images.size(); ++i) {
painter.begin(images[i]);
// background
images[i]->fill(0);
// + overlay
painter.setPen(Qt::NoPen);
painter.setBrush(brushes[i]);
painter.setRenderHint(QPainter::Antialiasing);
painter.drawRoundedRect(rect(), m_radius, m_radius);
// + waveform
painter.setCompositionMode(modes[i]);
painter.drawImage(0, 0, waveImage);
painter.setCompositionMode(QPainter::CompositionMode_DestinationOver);
painter.drawImage(0, 0, backgroundImage);
painter.end();
}
update();
m_needsUpdate = false;
}
}
QPixmap QgsFontButton::createDragIcon( QSize size, const QgsTextFormat *tempFormat, const QFont *tempFont ) const
{
if ( !tempFormat )
tempFormat = &mFormat;
if ( !tempFont )
tempFont = &mFont;
//create an icon pixmap
QPixmap pixmap( size.width(), size.height() );
pixmap.fill( Qt::transparent );
QPainter p;
p.begin( &pixmap );
p.setRenderHint( QPainter::Antialiasing );
QRect rect( 0, 0, size.width(), size.height() );
if ( mMode == ModeQFont || tempFormat->color().lightnessF() < 0.7 )
{
p.setBrush( QBrush( QColor( 255, 255, 255 ) ) );
p.setPen( QPen( QColor( 150, 150, 150 ), 0 ) );
}
else
{
p.setBrush( QBrush( QColor( 0, 0, 0 ) ) );
p.setPen( QPen( QColor( 100, 100, 100 ), 0 ) );
}
p.drawRect( rect );
p.setBrush( Qt::NoBrush );
p.setPen( Qt::NoPen );
switch ( mMode )
{
case ModeTextRenderer:
{
QgsRenderContext context;
QgsMapToPixel newCoordXForm;
newCoordXForm.setParameters( 1, 0, 0, 0, 0, 0 );
context.setMapToPixel( newCoordXForm );
context.setScaleFactor( QgsApplication::desktop()->logicalDpiX() / 25.4 );
context.setUseAdvancedEffects( true );
context.setPainter( &p );
// slightly inset text to account for buffer/background
double xtrans = 0;
if ( tempFormat->buffer().enabled() )
xtrans = context.convertToPainterUnits( tempFormat->buffer().size(), tempFormat->buffer().sizeUnit(), tempFormat->buffer().sizeMapUnitScale() );
if ( tempFormat->background().enabled() && tempFormat->background().sizeType() != QgsTextBackgroundSettings::SizeFixed )
xtrans = std::max( xtrans, context.convertToPainterUnits( tempFormat->background().size().width(), tempFormat->background().sizeUnit(), tempFormat->background().sizeMapUnitScale() ) );
double ytrans = 0.0;
if ( tempFormat->buffer().enabled() )
ytrans = std::max( ytrans, context.convertToPainterUnits( tempFormat->buffer().size(), tempFormat->buffer().sizeUnit(), tempFormat->buffer().sizeMapUnitScale() ) );
if ( tempFormat->background().enabled() )
ytrans = std::max( ytrans, context.convertToPainterUnits( tempFormat->background().size().height(), tempFormat->background().sizeUnit(), tempFormat->background().sizeMapUnitScale() ) );
QRectF textRect = rect;
textRect.setLeft( xtrans );
textRect.setWidth( textRect.width() - xtrans );
textRect.setTop( ytrans );
if ( textRect.height() > 300 )
textRect.setHeight( 300 );
if ( textRect.width() > 2000 )
textRect.setWidth( 2000 );
QgsTextRenderer::drawText( textRect, 0, QgsTextRenderer::AlignCenter, QStringList() << tr( "Aa" ),
context, *tempFormat );
break;
}
case ModeQFont:
{
p.setBrush( Qt::NoBrush );
p.setPen( QColor( 0, 0, 0 ) );
p.setFont( *tempFont );
QRectF textRect = rect;
textRect.setLeft( 2 );
p.drawText( textRect, Qt::AlignVCenter, tr( "Aa" ) );
break;
}
}
p.end();
return pixmap;
}
//drawing:
void G_arcSector::draw(QPainter &p, const G_drawstyle &d, bool selected)
{ //FIXME!
double r = arc.getRadius();
QRect re = p.window();
if(!inRect(re)) return;
if(r > DRAW_MAX / 2) {
//draw big arc...
return;
}
p.setBrush(d.getBrush());
p.setPen(QPen(Qt::NoPen));
const double angle_scale = -16 * 180. / M_PI;
if(/*p.device()->isExtDev() ||*/ p.hasViewXForm()) { //draw at higher accuracy to a printer or image
p.scale(0.125, .125);
p.drawPie(ROUND((arc.getCenter().getX() - r) * 8),
ROUND((arc.getCenter().getY() - r) * 8),
ROUND(r * 16), ROUND(r * 16),
ROUND(((arc.getP2() - arc.getCenter()).angle() -
acos(arc.getCosangle())) * angle_scale),
ROUND(angle_scale * acos(arc.getCosangle()) * 2));
p.scale(8, 8);
return;
}
p.drawPie(ROUND(arc.getCenter().getX() - r),
ROUND(arc.getCenter().getY() - r),
ROUND(r * 2), ROUND(r * 2),
ROUND(((arc.getP2() - arc.getCenter()).angle() -
acos(arc.getCosangle())) * angle_scale),
ROUND(angle_scale * acos(arc.getCosangle()) * 2));
if(selected) {
if(KSegView::getSelectType() == KSegView::BORDER_SELECT) {
p.setBrush(QBrush(G_drawstyle::getBorderColor(d.getBrush().color()), Qt::BDiagPattern));
}
if(selected && KSegView::getSelectType() == KSegView::BLINKING_SELECT) {
QColor c(QTime::currentTime().msec() * 17, 255, 255, QColor::Hsv);
p.setBrush(QBrush(c, Qt::BDiagPattern));
}
p.drawPie(ROUND(arc.getCenter().getX() - r),
ROUND(arc.getCenter().getY() - r),
ROUND(r * 2), ROUND(r * 2),
ROUND(((arc.getP2() - arc.getCenter()).angle() -
acos(arc.getCosangle())) * angle_scale),
ROUND(angle_scale * acos(arc.getCosangle()) * 2));
}
p.setBrush(QBrush());
return;
}
void QLCDNumber::drawSegment( const QPoint &pos, char segmentNo, QPainter &p,
int segLen, bool erase )
{
QPoint pt = pos;
int width = segLen/5;
const QColorGroup & g = colorGroup();
QColor lightColor,darkColor,fgColor;
if ( erase ){
lightColor = backgroundColor();
darkColor = lightColor;
fgColor = lightColor;
} else {
lightColor = g.light();
darkColor = g.dark();
fgColor = g.foreground();
}
#define LINETO(X,Y) addPoint( a, QPoint(pt.x() + (X),pt.y() + (Y)))
#define LIGHT
#define DARK
if ( fill ) {
QPointArray a(0);
//The following is an exact copy of the switch below.
//don't make any changes here
switch ( segmentNo ) {
case 0 :
p.moveTo(pt);
LIGHT;
LINETO(segLen - 1,0);
DARK;
LINETO(segLen - width - 1,width);
LINETO(width,width);
LINETO(0,0);
break;
case 1 :
pt += QPoint(0 , 1);
p.moveTo(pt);
LIGHT;
LINETO(width,width);
DARK;
LINETO(width,segLen - width/2 - 2);
LINETO(0,segLen - 2);
LIGHT;
LINETO(0,0);
break;
case 2 :
pt += QPoint(segLen - 1 , 1);
p.moveTo(pt);
DARK;
LINETO(0,segLen - 2);
LINETO(-width,segLen - width/2 - 2);
LIGHT;
LINETO(-width,width);
LINETO(0,0);
break;
case 3 :
pt += QPoint(0 , segLen);
p.moveTo(pt);
LIGHT;
LINETO(width,-width/2);
LINETO(segLen - width - 1,-width/2);
LINETO(segLen - 1,0);
DARK;
if (width & 1) { // adjust for integer division error
LINETO(segLen - width - 3,width/2 + 1);
LINETO(width + 2,width/2 + 1);
} else {
LINETO(segLen - width - 1,width/2);
LINETO(width,width/2);
}
LINETO(0,0);
break;
case 4 :
pt += QPoint(0 , segLen + 1);
p.moveTo(pt);
LIGHT;
LINETO(width,width/2);
DARK;
LINETO(width,segLen - width - 2);
LINETO(0,segLen - 2);
LIGHT;
LINETO(0,0);
break;
case 5 :
pt += QPoint(segLen - 1 , segLen + 1);
p.moveTo(pt);
DARK;
LINETO(0,segLen - 2);
LINETO(-width,segLen - width - 2);
LIGHT;
LINETO(-width,width/2);
LINETO(0,0);
break;
case 6 :
pt += QPoint(0 , segLen*2);
p.moveTo(pt);
LIGHT;
LINETO(width,-width);
LINETO(segLen - width - 1,-width);
LINETO(segLen - 1,0);
DARK;
LINETO(0,0);
break;
case 7 :
if ( smallPoint ) // if smallpoint place'.' between other digits
pt += QPoint(segLen + width/2 , segLen*2);
else
pt += QPoint(segLen/2 , segLen*2);
p.moveTo(pt);
DARK;
LINETO(width,0);
LINETO(width,-width);
LIGHT;
LINETO(0,-width);
LINETO(0,0);
break;
case 8 :
pt += QPoint(segLen/2 - width/2 + 1 , segLen/2 + width);
p.moveTo(pt);
DARK;
LINETO(width,0);
LINETO(width,-width);
LIGHT;
LINETO(0,-width);
LINETO(0,0);
break;
case 9 :
pt += QPoint(segLen/2 - width/2 + 1 , 3*segLen/2 + width);
p.moveTo(pt);
DARK;
LINETO(width,0);
LINETO(width,-width);
LIGHT;
LINETO(0,-width);
LINETO(0,0);
break;
#if defined(CHECK_RANGE)
default :
qWarning( "QLCDNumber::drawSegment: (%s) Internal error."
" Illegal segment id: %d\n",
name( "unnamed" ), segmentNo );
#endif
}
// End exact copy
p.setPen( fgColor );
p.setBrush( fgColor );
p.drawPolygon( a );
p.setBrush( NoBrush );
pt = pos;
}
#undef LINETO
#undef LIGHT
#undef DARK
#define LINETO(X,Y) p.lineTo(QPoint(pt.x() + (X),pt.y() + (Y)))
#define LIGHT p.setPen(lightColor)
#define DARK p.setPen(darkColor)
if ( shadow )
switch ( segmentNo ) {
case 0 :
p.moveTo(pt);
LIGHT;
LINETO(segLen - 1,0);
DARK;
LINETO(segLen - width - 1,width);
LINETO(width,width);
LINETO(0,0);
break;
case 1 :
pt += QPoint(0,1);
p.moveTo(pt);
LIGHT;
LINETO(width,width);
DARK;
LINETO(width,segLen - width/2 - 2);
LINETO(0,segLen - 2);
LIGHT;
LINETO(0,0);
break;
case 2 :
pt += QPoint(segLen - 1 , 1);
p.moveTo(pt);
DARK;
LINETO(0,segLen - 2);
LINETO(-width,segLen - width/2 - 2);
LIGHT;
LINETO(-width,width);
LINETO(0,0);
break;
case 3 :
pt += QPoint(0 , segLen);
p.moveTo(pt);
LIGHT;
LINETO(width,-width/2);
LINETO(segLen - width - 1,-width/2);
LINETO(segLen - 1,0);
DARK;
if (width & 1) { // adjust for integer division error
LINETO(segLen - width - 3,width/2 + 1);
LINETO(width + 2,width/2 + 1);
} else {
LINETO(segLen - width - 1,width/2);
LINETO(width,width/2);
}
LINETO(0,0);
break;
case 4 :
pt += QPoint(0 , segLen + 1);
p.moveTo(pt);
LIGHT;
LINETO(width,width/2);
DARK;
LINETO(width,segLen - width - 2);
LINETO(0,segLen - 2);
LIGHT;
LINETO(0,0);
break;
case 5 :
pt += QPoint(segLen - 1 , segLen + 1);
p.moveTo(pt);
DARK;
LINETO(0,segLen - 2);
LINETO(-width,segLen - width - 2);
LIGHT;
LINETO(-width,width/2);
LINETO(0,0);
break;
case 6 :
pt += QPoint(0 , segLen*2);
p.moveTo(pt);
LIGHT;
LINETO(width,-width);
LINETO(segLen - width - 1,-width);
LINETO(segLen - 1,0);
DARK;
LINETO(0,0);
break;
case 7 :
if ( smallPoint ) // if smallpoint place'.' between other digits
pt += QPoint(segLen + width/2 , segLen*2);
else
pt += QPoint(segLen/2 , segLen*2);
p.moveTo(pt);
DARK;
LINETO(width,0);
LINETO(width,-width);
LIGHT;
LINETO(0,-width);
LINETO(0,0);
break;
case 8 :
pt += QPoint(segLen/2 - width/2 + 1 , segLen/2 + width);
p.moveTo(pt);
DARK;
LINETO(width,0);
LINETO(width,-width);
LIGHT;
LINETO(0,-width);
LINETO(0,0);
break;
case 9 :
pt += QPoint(segLen/2 - width/2 + 1 , 3*segLen/2 + width);
p.moveTo(pt);
DARK;
LINETO(width,0);
LINETO(width,-width);
LIGHT;
LINETO(0,-width);
LINETO(0,0);
break;
#if defined(CHECK_RANGE)
default :
qWarning( "QLCDNumber::drawSegment: (%s) Internal error."
" Illegal segment id: %d\n",
name( "unnamed" ), segmentNo );
#endif
}
#undef LINETO
#undef LIGHT
#undef DARK
}
void QRoundProgressBar::drawInnerBackground(QPainter &p, const QRectF &innerRect) {
if (m_barStyle == StyleDonut) {
p.setBrush(palette().alternateBase());
p.drawEllipse(innerRect);
}
}
bool m_node::eventFilter(QObject *object, QEvent *event){
//std::cout << "THE EVENT IS : "<< event->type() << "\n";
if(QLabel* label = static_cast<QLabel*>(object)){
if(event->type() == QEvent::MouseButtonDblClick){
std::cout << "declanche double clic \n";
this->edit_label->setReadOnly(false);
this->edit_label->setFocus();
return true;
}
if (event->type()==QEvent::KeyPress) {
std::cout <<"declanche key press \n";
QKeyEvent* key = static_cast<QKeyEvent*>(event);
if ( (key->key()==Qt::Key_Enter) || (key->key()==Qt::Key_Return) ) {
this->edit_label->setReadOnly(true);
this->setName(edit_label->text());
this->edit_label->clearFocus();
this->edit_label->setStyleSheet("border:nonde;background-color:#4c5053;");
}
return true;
}
if(event->type() == QEvent::MouseButtonPress){
if(QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event)){
if(mouseEvent->button() == Qt::RightButton){
std::cout <<"declanche right button \n";
QSize iconSize = QSize (30,30);
QPixmap iconPmap (iconSize);
iconPmap.fill (Qt::transparent);
QPainter painter (&iconPmap);
painter.setBrush (QBrush (*m_colors::colorNonParcouru));
painter.setPen(QPen(Qt::NoPen));
painter.drawRect (0,0,30,30);
painter.drawPixmap (0, 0, iconPmap);
QIcon retIconNonParoucru;
retIconNonParoucru.addPixmap(iconPmap, QIcon::Normal, QIcon::Off);
retIconNonParoucru.addPixmap(iconPmap, QIcon::Normal, QIcon::On);
painter.setBrush (QBrush (*m_colors::colorActif));
painter.drawRect (0,0,30,30);
painter.drawPixmap (0, 0, iconPmap);
QIcon retIconActif;
retIconActif.addPixmap(iconPmap, QIcon::Normal, QIcon::Off);
retIconActif.addPixmap(iconPmap, QIcon::Normal, QIcon::On);
painter.setBrush (QBrush (*m_colors::colorParcouru));
painter.drawRect (0,0,30,30);
painter.drawPixmap (0, 0, iconPmap);
QIcon retIconParcouru;
retIconParcouru.addPixmap(iconPmap, QIcon::Normal, QIcon::Off);
retIconParcouru.addPixmap(iconPmap, QIcon::Normal, QIcon::On);
painter.setBrush (QBrush (*m_colors::colorSolution));
painter.drawRect (0,0,30,30);
painter.drawPixmap (0, 0, iconPmap);
QIcon retIconSolution;
retIconSolution.addPixmap(iconPmap, QIcon::Normal, QIcon::Off);
retIconSolution.addPixmap(iconPmap, QIcon::Normal, QIcon::On);
menu = new QMenu(this);
menu->setStyleSheet("background-color:#8e8e8e;padding:0;");
action_non_parcouru = new QAction(retIconNonParoucru,"Non parcouru", this);
action_actif = new QAction(retIconActif,"Actif", this);
action_parcouru = new QAction(retIconParcouru, "Parcouru", this);
action_solution = new QAction(retIconSolution,"Solution",this);
if(this->isInitial && !this->isFinal){
action_setInitial = new QAction("☑ Noeud initial",this);
action_setFinal = new QAction("☐ Noeud final",this);
action_setSimpleNode = new QAction("☐ Noeud simple",this);
}
else if(!this->isInitial && this->isFinal){
action_setInitial = new QAction("☐ Noeud initial",this);
action_setFinal = new QAction("☑ Noeud final",this);
action_setSimpleNode = new QAction("☐ Noeud simple",this);
}
else{
action_setInitial = new QAction("☐ Noeud initial",this);
action_setFinal = new QAction("☐ Noeud final",this);
action_setSimpleNode = new QAction("☑ Noeud simple",this);
}
QObject::connect(action_solution,SIGNAL(triggered()),this, SLOT(setSolutionColor()));
QObject::connect(action_non_parcouru,SIGNAL(triggered()),this, SLOT(setNonParcouruColor()));
QObject::connect(action_parcouru,SIGNAL(triggered()),this, SLOT(setParcouruColor()));
QObject::connect(action_actif,SIGNAL(triggered()),this, SLOT(setActifColor()));
QObject::connect(action_setInitial,SIGNAL(triggered()),this, SLOT(setInitialStyle()));
QObject::connect(action_setFinal,SIGNAL(triggered()),this, SLOT(setFinalStyle()));
QObject::connect(action_setSimpleNode,SIGNAL(triggered()),this, SLOT(setSimpleStyle()));
menu->addAction(action_non_parcouru);
menu->addAction(action_actif);
menu->addAction(action_parcouru);
menu->addAction(action_solution);
menu->addAction(action_setInitial);
menu->addAction(action_setFinal);
menu->addAction(action_setSimpleNode);
//menu->installEventFilter(this);
//menu->grabMouse();
menu->exec(mouseEvent->globalPos());
}
}
return true;
}
//fonction hover node
if(event->type() == QEvent::Enter){
if(static_cast<QWidget*>(object) && object == this){
std::cout << "mouseEnter \n";
this->drawBorder = true;
this->repaint();
}
return true;
}
else if(event->type() == QEvent::Leave && !imSelected){
if(static_cast<QWidget*>(object) && object == this){
this->drawBorder = false;
this->repaint();
}
return true;
}
}
return false;
}
void MyImageWidget::painterDrawCar(QPainter &paint)
{
paint.setPen(QPen(Qt::black, 1));
paint.setBrush(Qt::black);
paint.drawEllipse(QPoint(nCarX,nCarY),7,7);
QPoint points[3];
double rdx,rdy,dx0,dy0,dx1,dy1,dx2,dy2;
double pi = 3.141592653;
dx0 = 21*sin((dCarSita/180)*pi);
dy0 = 21*cos((dCarSita/180)*pi);
dx2 = 14*sin((dCarSita/180)*pi);
dy2 = 14*cos((dCarSita/180)*pi);
rdx = 11*sin((dCarSita/180)*pi);
rdy = 11*cos((dCarSita/180)*pi);
dx1 = 7*cos((dCarSita/180)*pi);
dy1 = 7*sin((dCarSita/180)*pi);
points[0]=QPoint(nCarX+rdx-dx1,nCarY-rdy-dy1);
points[1]=QPoint(nCarX+dx0,nCarY-dy0);
points[2]=QPoint(nCarX+rdx+dx1,nCarY-rdy+dy1);
points[3]=QPoint(nCarX+dx2,nCarY-dy2);
paint.drawPolygon(points,4);
// //绘制小车图标
// QImage *myImage = new QImage;
// QString strPath = QApplication::applicationDirPath()+"/car.png";
// myImage->load(strPath);
// QPixmap myPixmap = QPixmap::fromImage(*myImage).scaled(myImage->width()/5,myImage->height()/5);
// QMatrix myMatrix;
// myMatrix.rotate(dCarSita);
// myPixmap=myPixmap.transformed(myMatrix);
// switch((int)dCarSita)
// {
// case 0:
// paint.drawPixmap(nCarX-myImage->width()/10,nCarY-myImage->height()/10,myPixmap);
// break;
// case 45:
// paint.drawPixmap(nCarX-myImage->width()/7,nCarY-myImage->height()/7,myPixmap);
// break;
// case 90:
// paint.drawPixmap(nCarX-myImage->height()/10,nCarY-myImage->width()/10,myPixmap);
// break;
// case 135:
// paint.drawPixmap(nCarX-myImage->width()/7,nCarY-myImage->width()/7,myPixmap);
// break;
// case 180:
// paint.drawPixmap(nCarX-myImage->width()/10,nCarY-myImage->height()/10,myPixmap);
// break;
// case 225:
// paint.drawPixmap(nCarX-myImage->width()/7,nCarY-myImage->height()/7,myPixmap);
// break;
// case 270:
// paint.drawPixmap(nCarX-myImage->height()/10,nCarY-myImage->width()/10,myPixmap);
// break;
// case 315:
// paint.drawPixmap(nCarX-myImage->height()/7,nCarY-myImage->height()/7,myPixmap);
// break;
// default:
// paint.drawPixmap(nCarX,nCarY,myPixmap);
// break;
// }
}
void GridDisplay::paintEvent(QPaintEvent* /* event */)
{
QPainter painter;
painter.begin(this);
_cellSize = grid_->getCellSize(_winSize);
//Find density
int maxDensity = 0;
int minDensity = 100;
for (int i=0; i < grid_->getFiles().size(); i++) {
if(grid_->getFilesAt(i).size() > maxDensity)
{
maxDensity = grid_->getFilesAt(i).size();
}
else if (grid_->getFilesAt(i).size() < minDensity)
{
minDensity = grid_->getFilesAt(i).size();
}
}
Colormap *map = Colormap::factory(Colormap::GreyScale);
for (int i=0; i < grid_->getHeight(); i++) {
for (int j=0; j < grid_->getWidth(); j++) {
int k = j * grid_->getHeight() + i;
QRect myr(i*_cellSize,j*_cellSize,_cellSize,_cellSize);
QLine myl1(i*_cellSize,j*_cellSize, i*_cellSize, j*_cellSize + _cellSize);
QLine myl2(i*_cellSize,j*_cellSize, i*_cellSize+_cellSize, j*_cellSize );
if ( grid_->getFilesAt(k).size() == 0 )
{
QColor color;
if(colourMapMode_)
{
color.setRgb(map->getRed(0), map->getGreen(0), map->getBlue(0));
}
else
{
color.setRgb(map->getRed(128), map->getGreen(0), map->getBlue(0));
}
painter.setBrush(color);
}
else
{
if(colourMapMode_)
{
/*
* index - genre - color
* 0 - blues - Qt::blue
* 1 - classical - Qt::darkRed
* 2 - country - Qt::green
* 3 - disco - PURPLE
* 4 - hiphop - Qt::yellow
* 5 - jazz - Qt::darkGreen
* 6 - metal - BROWN
* 7 - reggae - PINK
* 8 - rock - ORANGE
* 9 - pop - Qt::grey
*/
int * genreDensity = grid_->getDensity(k);
double *squarePaintSize = new double[10];
int startHeight = j*_cellSize;
for(int m = 0; m < 10; m++)
{
squarePaintSize[m] = genreDensity[m] / (1.0 * grid_->getFilesAt(k).size() );
}
// 10 is the number of genres
for(int l = 0; l < 10; l++)
{
QColor * color;
switch(l)
{
case 0:
color = new QColor(Qt::blue);
break;
case 1:
color = new QColor(Qt::darkRed);
break;
case 2:
color = new QColor(Qt::green);
break;
case 3:
color = new QColor(PURPLE);
break;
case 4:
color = new QColor(Qt::yellow);
break;
case 5:
color = new QColor(Qt::darkGreen);
break;
case 6:
color = new QColor(BROWN);
break;
case 7:
color = new QColor(PINK);
break;
case 8:
color = new QColor(ORANGE);
break;
case 9:
color = new QColor(Qt::gray);
break;
}
if(grid_->getFilesAt(k).size() > 0)
{
painter.setBrush(*color);
painter.setPen(Qt::NoPen);
QRect rect(i*_cellSize, startHeight, _cellSize, squarePaintSize[l] * _cellSize);
painter.drawRect(rect);
startHeight += squarePaintSize[l] * _cellSize;
}
}
}
else
{
int c = int(grid_->getFilesAt(k).size() / float(maxDensity) * (map->getDepth()-1));
QColor color(map->getRed(c), map->getGreen(c), map->getBlue(c));
painter.setBrush(color);
}
}
if(colourMapMode_)
{
painter.setPen(Qt::white);
if(grid_->getFilesAt(k).size() == 0)
painter.drawRect(myr);
}
else
{
painter.setPen(Qt::NoPen);
painter.drawRect(myr);
painter.setPen(Qt::black);
}
painter.drawLine(myl1);
painter.drawLine(myl2);
painter.setBrush(Qt::red);
QRect newr( grid_->getXPos() * _cellSize + _cellSize / 4,
grid_->getYPos() * _cellSize + _cellSize / 4,
_cellSize - _cellSize / 2,
_cellSize-_cellSize / 2);
painter.drawRect(newr);
painter.setBrush(Qt::white);
QRect newr1( grid_->getX1Pos() * _cellSize + _cellSize / 4,
grid_->getY1Pos() * _cellSize + _cellSize / 4,
_cellSize - _cellSize / 2,
_cellSize-_cellSize / 2);
painter.drawRect(newr1);
}
}
// Draw an 'i' in all initilized squares
for(int i = 0; i < squareHasInitialized.size(); i++)
{
if(squareHasInitialized[i])
{
int y = i / grid_->getHeight();
int x = i % grid_->getHeight();
painter.setBrush(Qt::green);
QFont *font = new QFont();
font->setPointSize(16);
font->setStyleHint(QFont::OldEnglish);
painter.setFont(*font);
painter.drawText(x * _cellSize, y * _cellSize, _cellSize, _cellSize, Qt::AlignCenter, "i");
}
}
delete map;
painter.end();
}
void MyImageWidget::painterDrawNaveRoute(QPainter &paint)
{
paint.setPen(QPen(Qt::green, 3));
paint.setBrush(Qt::green);
paint.drawPolyline(naviRoutePoints,nNaviRoutePointsNumber);
}
void DemoGLWidget::paintGL()
{
// Render scene to FBO
//render_fbo->bind();
//glBindFramebuffer(GL_FRAMEBUFFER, fbo->frame);
QPainter painter;
painter.begin(this);
Utils::setPainter(&painter);
painter.beginNativePainting();
float r = 0.05f;
float g = 0.05f;
float b = 0.2f;
// Flash screen on snare hit
float snareEnv = synth_get_current_envelope_for_instrument(4);
if (snareEnv > 0.001f)
{
r += snareEnv * 0.2f;
g += snareEnv * 0.2f;
b += snareEnv * 0.2f;
}
glClearColor(r, g, b, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glFrontFace(GL_CW);
glCullFace(GL_FRONT);
painter.endNativePainting();
// Create entities when an instrument is first played
if (synth_get_current_note_for_instrument(0) != 0 &&
critter == 0)
{
critter = new Critter(QPointF(500,200), 10, CRITTER_SPEED);
}
if (synth_get_current_note_for_instrument(1) != 0 &&
entity1 == 0)
{
entity1 = new Entity(QPointF(300,200), 6, 3, 1);
entities.append(entity1);
entities.append(new Entity(QPointF(200,300), 10, 3, 1));
}
if (synth_get_current_note_for_instrument(2) != 0 &&
entity2 == 0)
{
entity2 = new Entity(QPointF(300,200), 8, 3, 2);
entities.append(entity2);
entities.append(new Entity(QPointF(200,400), 10, 3, 2));
}
if (synth_get_current_note_for_instrument(3) != 0 &&
entity3 == 0)
{
entity3 = new Entity(QPointF(300,200), 8, 3, 3);
entities.append(entity3);
entities.append(new Entity(QPointF(400,300), 12, 3, 3));
entities.append(new Entity(QPointF(100,100), 7, 3, 3));
}
if (synth_get_current_note_for_instrument(4) != 0 &&
entity4 == 0)
{
entity4 = new Entity(QPointF(300,200), 8, 3, 4);
entities.append(entity4);
entities.append(new Entity(QPointF(200,400), 12, 3, 4));
}
// Draw Entities and Critter
painter.setBrush(QBrush());
// Move entities
qreal minDistToCritter = 8000;
static Entity* closestToCritter = 0;
static int critterEnemyDetectionDelayer = 0;
for(int i = 0; i < entities.size(); i++)
{
Entity *entity = entities[i];
qreal distToCritter = 10000;
// Use all entities as local flock for now
QMutableListIterator<Entity*> localFlock(entities);
entity->clearSteering();
if (critter != 0)
{
entity->steerToTarget(critter->pos(), STEER_TO_TARGET_STRENGTH);
distToCritter = entity->steerToAvoindWithinDistance(critter->pos(), STEER_AVOID_WITHIN_DISTANCE_STRENGTH);
}
entity->steerWithFlock(localFlock, STEER_SEPARATION_STRENGTH, STEER_COHESION_STRENGTH);
entity->move();
if(critterEnemyDetectionDelayer == 0 && distToCritter < minDistToCritter)
{
closestToCritter = entity;
minDistToCritter = distToCritter;
}
}
foreach (Entity *entity, entities)
{
entity->drawEntity(&painter);
}
void MapIcons::paintSpawnPointIcon(MapParameters& param,
QPainter& p,
const MapIcon& mapIcon,
const SpawnPoint* sp,
const QPoint& point)
{
// Draw Line
if (mapIcon.showLine0())
{
p.setPen(mapIcon.line0Pen());
p.drawLine(param.playerXOffset(),
param.playerYOffset(),
point.x(), point.y());
}
// calculate distance and draw distance related lines
uint32_t distance = UINT32_MAX;
if (mapIcon.line1Distance() || mapIcon.line2Distance())
{
if (!showeq_params->fast_machine)
distance = sp->calcDist2DInt(param.player());
else
distance = (int)sp->calcDist(param.player());
if (mapIcon.line1Distance() > distance)
{
p.setPen(mapIcon.line1Pen());
p.drawLine(param.playerXOffset(),
param.playerYOffset(),
point.x(), point.y());
}
if (mapIcon.line2Distance() > distance)
{
p.setPen(mapIcon.line2Pen());
p.drawLine(param.playerXOffset(),
param.playerYOffset(),
point.x(), point.y());
}
}
// Draw Spawn Names
if (mapIcon.showName())
{
QString spawnNameText;
spawnNameText.sprintf("sp:%s %s (%d)",
(const char*)sp->name(),
(const char*)sp->last(),
sp->count());
QFontMetrics fm(param.font());
int width = fm.width(spawnNameText);
p.setPen(gray);
p.drawText(point.x() - (width / 2),
point.y() + fm.height() + 1, spawnNameText);
}
// Draw the Icon
if (mapIcon.image() &&
(!mapIcon.imageFlash() || m_flash) &&
(mapIcon.imageStyle() != tIconStyleNone))
{
if (mapIcon.imageUseSpawnColorPen())
{
QPen pen = mapIcon.imagePen();
pen.setColor(pickSpawnPointColor(sp, pen.color()));
p.setPen(pen);
}
else
p.setPen(mapIcon.imagePen());
if (mapIcon.imageUseSpawnColorBrush())
{
QBrush brush = mapIcon.imageBrush();
brush.setColor(pickSpawnPointColor(sp, brush.color()));
p.setBrush(brush);
}
else
p.setBrush(mapIcon.imageBrush());
mapIcon.paintIconImage(mapIcon.imageStyle(), p, point,
*m_mapIconSizes[mapIcon.imageSize()],
*m_mapIconSizesWH[mapIcon.imageSize()]);
}
// Draw the highlight
if (mapIcon.highlight() &&
(!mapIcon.highlightFlash() || m_flash) &&
(mapIcon.highlightStyle() != tIconStyleNone))
{
if (mapIcon.highlightUseSpawnColorPen())
{
QPen pen = mapIcon.highlightPen();
pen.setColor(pickSpawnPointColor(sp, pen.color()));
p.setPen(pen);
}
else
p.setPen(mapIcon.highlightPen());
if (mapIcon.highlightUseSpawnColorBrush())
{
QBrush brush = mapIcon.highlightBrush();
brush.setColor(pickSpawnPointColor(sp, brush.color()));
p.setBrush(brush);
}
else
p.setBrush(mapIcon.highlightBrush());
mapIcon.paintIconImage(mapIcon.highlightStyle(), p, point,
*m_mapIconSizes[mapIcon.highlightSize()],
*m_mapIconSizesWH[mapIcon.highlightSize()]);
}
}
void TurnAndBank::createGlass(void){
QImage _glassImage = QImage(QSize(500,500), QImage::Format_ARGB32);
_glassImage.fill(0x00ffffff);
QPainter p;
p.setRenderHint(QPainter::Antialiasing, true);
p.begin(&_glassImage);
//p.scale(1./2.5, 1./2.5);
// Cosmetics on glass: yellow arrows:
p.setPen(QPen(QColor(79, 106, 25), 0, Qt::SolidLine,
Qt::FlatCap, Qt::MiterJoin));
p.setBrush(Qt::SolidPattern);
p.setBrush(Qt::yellow);
static const QPointF bigArrow[] = {
QPointF(250, 250),
QPointF(362.5, 287.5),
QPointF(137.5, 287.5)
};
int bigArrowNPts = sizeof(bigArrow)/sizeof(bigArrow[0]);
p.drawConvexPolygon(bigArrow, bigArrowNPts);
static const QPointF leftArrow[] = {
QPointF(125, 375-10),
QPointF(237.5, 320-10),
QPointF(240, 322.5-10),
QPointF(137.5, 387.5-10),
QPointF(125,387.5-10)
};
int leftArrowNPts = sizeof(leftArrow)/sizeof(leftArrow[0]);
p.drawConvexPolygon(leftArrow, leftArrowNPts);
static const QPointF rightArrow[] = {
QPointF(375, 375-10),
QPointF(262.5, 320-10),
QPointF(260, 322.5-10),
QPointF(362.5,387.5-10),
QPointF(375,387.5-10)
};
p.drawConvexPolygon(rightArrow, leftArrowNPts);
// Upwards facing orange arrow at vertical up:
static const QPointF orangeArrow[] = {
QPointF(250, 50),
QPointF(233, 88),
QPointF(267, 88)
};
p.setBrush(QColor(255,116,0));
p.drawConvexPolygon(orangeArrow, 3);
// Little black pyramid and chord at bottom:
p.setBrush(QColor(25,25,25));
static const QPointF pyramid[] = {
QPointF(250-19-60, 417+20),
QPointF(250+19+60, 417+20),
QPointF(250+25, 250+63+20),
QPointF(250-25, 250+63+20)
};
p.drawConvexPolygon(pyramid, 4);
p.setPen(QPen(Qt::black, 0, Qt::SolidLine,
Qt::FlatCap, Qt::MiterJoin));
p.setBrush(QColor(76,76,76));
p.drawChord(_glassImage.rect(), -40*16, -100*16);
p.setBrush(QColor(25,25,25));
p.drawChord(_glassImage.rect(), -42*16, -96*16);
// Little vacuum text line
p.setPen(QColor(200,200,200));
p.setFont(QFont(QString("Helvetica"), 24, QFont::Bold, false));
int width = p.fontMetrics().width(QString("VACUUM"));
int height =p.fontMetrics().height();
p.drawText(250-width/2,385,width, height, Qt::AlignCenter, "VACUUM");
p.end();
_glass = QPixmap::fromImage(_glassImage, Qt::AutoColor);
}
void MapIcons::paintSpawnIcon(MapParameters& param,
QPainter& p,
const MapIcon& mapIcon,
const Spawn* spawn,
const EQPoint& location,
const QPoint& point)
{
// ------------------------
// Draw Walk Path
if (mapIcon.showWalkPath() ||
(m_showNPCWalkPaths && spawn->isNPC()))
{
SpawnTrackListIterator trackIt(spawn->trackList());
const SpawnTrackPoint* trackPoint = trackIt.current();
if (trackPoint)
{
if (!mapIcon.useWalkPathPen())
p.setPen(blue);
else
p.setPen(mapIcon.walkPathPen());
p.moveTo (param.calcXOffsetI(trackPoint->x()),
param.calcYOffsetI(trackPoint->y()));
while ((trackPoint = ++trackIt) != NULL)
p.lineTo (param.calcXOffsetI (trackPoint->x()),
param.calcYOffsetI (trackPoint->y()));
p.lineTo (point.x(), point.y());
}
}
// Draw Line
if (mapIcon.showLine0())
{
p.setPen(mapIcon.line0Pen());
p.drawLine(param.playerXOffset(),
param.playerYOffset(),
point.x(), point.y());
}
// calculate distance and draw distance related lines
uint32_t distance = UINT32_MAX;
if (mapIcon.line1Distance() || mapIcon.line2Distance() ||
m_showSpawnNames)
{
if (!showeq_params->fast_machine)
distance = location.calcDist2DInt(param.player());
else
distance = (int)location.calcDist(param.player());
if (mapIcon.line1Distance() > distance)
{
p.setPen(mapIcon.line1Pen());
p.drawLine(param.playerXOffset(),
param.playerYOffset(),
point.x(), point.y());
}
if (mapIcon.line2Distance() > distance)
{
p.setPen(mapIcon.line2Pen());
p.drawLine(param.playerXOffset(),
param.playerYOffset(),
point.x(), point.y());
}
}
// Draw Spawn Names
if (mapIcon.showName() ||
(m_showSpawnNames && (distance < m_fovDistance)))
{
QString spawnNameText;
spawnNameText.sprintf("%2d: %s",
spawn->level(),
(const char*)spawn->name());
QFontMetrics fm(param.font());
int width = fm.width(spawnNameText);
p.setPen(gray);
p.drawText(point.x() - (width / 2),
point.y() + fm.height() + 1, spawnNameText);
}
// Draw the Icon
if (mapIcon.image() &&
(!mapIcon.imageFlash() || m_flash) &&
(mapIcon.imageStyle() != tIconStyleNone))
{
if (mapIcon.imageUseSpawnColorPen())
{
QPen pen = mapIcon.imagePen();
pen.setColor(pickSpawnColor(spawn));
p.setPen(pen);
}
else
p.setPen(mapIcon.imagePen());
if (mapIcon.imageUseSpawnColorBrush())
{
QBrush brush = mapIcon.imageBrush();
brush.setColor(pickSpawnColor(spawn));
p.setBrush(brush);
}
else
p.setBrush(mapIcon.imageBrush());
mapIcon.paintIconImage(mapIcon.imageStyle(), p, point,
*m_mapIconSizes[mapIcon.imageSize()],
*m_mapIconSizesWH[mapIcon.imageSize()]);
}
// Draw the highlight
if (mapIcon.highlight() &&
(!mapIcon.highlightFlash() || m_flash) &&
(mapIcon.highlightStyle() != tIconStyleNone))
{
if (mapIcon.highlightUseSpawnColorPen())
{
QPen pen = mapIcon.highlightPen();
pen.setColor(pickSpawnColor(spawn));
p.setPen(pen);
}
else
p.setPen(mapIcon.highlightPen());
if (mapIcon.highlightUseSpawnColorBrush())
{
QBrush brush = mapIcon.highlightBrush();
brush.setColor(pickSpawnColor(spawn));
p.setBrush(brush);
}
else
p.setBrush(mapIcon.highlightBrush());
mapIcon.paintIconImage(mapIcon.highlightStyle(), p, point,
*m_mapIconSizes[mapIcon.highlightSize()],
*m_mapIconSizesWH[mapIcon.highlightSize()]);
}
}
void TurnAndBank::createFrame(void){
QImage _frameImage = QImage(QSize(600,600), QImage::Format_ARGB32);
_frameImage.fill(0x00ff0000);
int outerR = _frameImage.width()/2;
const int innerR = _frameImage.width()/2-60;
QPainter p;
p.setRenderHint(QPainter::Antialiasing, true);
p.begin(&_frameImage);
p.translate(300, 300);
p.setPen(Qt::NoPen);
p.setBrush(Qt::SolidPattern);
p.setBrush(QColor(225,225,225));
QRadialGradient gradient(0, 0, outerR, 0, 0);
gradient.setSpread(QGradient::ReflectSpread);
gradient.setColorAt(0, Qt::white);
gradient.setColorAt(1, Qt::black);
QBrush gbrush(gradient);
p.setBrush(gbrush);
p.drawChord(-outerR, -outerR, 2*outerR, 2*outerR, 0, 360*16);
//Ring outside of intstrument with white line:
if (0){
p.setPen(QPen(QColor(225,225,225), 2, Qt::SolidLine,
Qt::FlatCap, Qt::MiterJoin));
p.setBrush(Qt::NoBrush);
p.drawChord(-outerR, -outerR, 2*outerR, 2*outerR, 0, 360*16);
}
// Create black inner core:
p.setBrush(Qt::black);
p.setPen(Qt::NoPen);
p.drawChord(-innerR, -innerR, 2*innerR, 2*innerR, 0, 360*16);
// Put horizontal and 2minute lines on outside:
p.setPen(QPen(Qt::white, 7, Qt::SolidLine,
Qt::FlatCap, Qt::MiterJoin));
const float angle = 15.;
outerR = outerR-20;
p.drawLine(innerR*cos(angle/180*3.1415926), innerR*sin(angle/180*3.1415926),
outerR*cos(angle/180*3.1415926), outerR*sin(angle/180*3.1415926));
p.drawLine(-innerR*cos(angle/180*3.1415926), innerR*sin(angle/180*3.1415926),
-outerR*cos(angle/180*3.1415926), outerR*sin(angle/180*3.1415926));
p.drawLine(innerR, 0, outerR, 0);
p.drawLine(-innerR, 0, -outerR, 0);
// Little vacuum text line
p.setPen(QColor(200,200,200));
QString legend = QString("NO PITCH");
p.setFont(QFont(QString("Helvetica"), 20, QFont::Bold, false));
int width = p.fontMetrics().width(legend);
int height =p.fontMetrics().height();
p.drawText(0-width/2,245,width, height, Qt::AlignCenter, legend);
legend = QString("INFORMATION");
width = p.fontMetrics().width(legend);
p.drawText(0-width/2,267,width, height, Qt::AlignCenter, legend);
p.setFont(QFont(QString("Helvetica"), 32, QFont::Bold, false));
legend = QString("D. C. ELEC.");
width = p.fontMetrics().width(legend);
height =p.fontMetrics().height();
p.drawText(0-width/2,-275,width, height, Qt::AlignCenter, legend);
legend = QString("2 MIN");
width = p.fontMetrics().width(legend);
height =p.fontMetrics().height();
p.drawText(0-width/2,205,width, height, Qt::AlignCenter, legend);
p.setFont(QFont(QString("Helvetica"), 24, QFont::Bold, false));
legend = QString("TURN COORDINATOR");
width = p.fontMetrics().width(legend);
height =p.fontMetrics().height();
p.drawText(0-width/2,-150,width, height, Qt::AlignCenter, legend);
p.setFont(QFont(QString("Helvetica"), 48, QFont::Bold, false));
legend = QString("L");
width = p.fontMetrics().width(legend);
height =p.fontMetrics().height();
p.drawText(-265*cos(18./180.*3.1415926)-width/2+5, 265*sin(18./180.*3.1415926),
width, height, Qt::AlignCenter, legend);
legend = QString("R");
width = p.fontMetrics().width(legend);
height =p.fontMetrics().height();
p.drawText(265*cos(18./180.*3.1415926)-width/2-5, 265*sin(18./180.*3.1415926),
width, height, Qt::AlignCenter, legend);
p.end();
_frame = QPixmap::fromImage(_frameImage, Qt::AutoColor);
}
void HeatmapDisplay::drawVarNames(){
//qDebug()<<"drawVarNames";
double height = floor(CANVAS_BORD/(2*CANVAS_BORD+1)*this->height());
double width = this->width();
RddtClust* currentClust = NULL;
if(this->m_dimClust==NULL)
return;
currentClust = this->m_dimClust->m_currentSelection;
if(currentClust == NULL)
return;
int r = 0;
r= currentClust->m_selected.size();
if(r!= currentClust->m_order.size())
return;
if(r<=0)
return;
int start_x = 10+(CANVAS_BORD/(1+2*CANVAS_BORD)*width)/sqrt(2.0); //CANVAS_BORD*width;//move right
int start_y = 10-(CANVAS_BORD/(1+2*CANVAS_BORD)*width)/sqrt(2.0); //CANVAS_BORD*width;//move up
double offset = (double)width*(((double)1)/(1+2*CANVAS_BORD))/((double)r*sqrt(2.0));
QImage img(width,height,QImage::Format_ARGB32);
QPainter p;
p.begin(&img);
p.setRenderHint(QPainter::Antialiasing);
p.fillRect(rect(),Qt::white);
//p.setBrush(Qt::red);
//p.drawRect(rect());
p.setBrush(Qt::black);
p.save();
p.translate(0,0);
p.rotate(45);
QFont f;
f.setFamily("Arial");
f.setPointSize(8);
//QFont font("Times",5,QFont::Normal);
//font.setPixelSize();
//p.setFont(font);
f.setStyleStrategy(QFont::PreferAntialias);
p.setFont(f);
for(int i = 0; i<r; i++){
int x = (int)(start_x+offset*(double)i);
int y = (int)(start_y-offset*(double)i);
int locIdx = currentClust->m_order[i];
int globIdx = currentClust->m_selected[locIdx];
bool selected = currentClust->m_colSelected[i];
std::string name = this->m_dimClust->m_dimName[globIdx];
QString qname = QString::fromAscii(name.c_str());
if(selected){
p.setPen(Qt::red);
p.drawText(x,y,qname);
}else{
p.setPen(Qt::black);
p.drawText(x,y,qname);
}
}
p.restore();
p.end();
QImage gldata = QGLWidget::convertToGLFormat(img);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslated(CANVAS_BORD,0,0);
glDepthMask(0); //before glDrawPixels().
glDrawPixels(img.width(), img.height(), GL_RGBA, GL_UNSIGNED_BYTE, gldata.bits());
glDepthMask(1); //Restore
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
void FormulaCursor::paint( QPainter& painter ) const
{
kDebug() << "Drawing cursor with selecting: "<< isSelecting() << " from "
<< mark()<<" to " << position() << " in "<<ElementFactory::elementName(m_currentElement->elementType());
if( !m_currentElement )
return;
painter.save();
QPointF origin=m_currentElement->absoluteBoundingRect().topLeft();
qreal baseline=m_currentElement->baseLine();
QPen pen;
pen.setWidthF( 0.5 );
pen.setColor(Qt::black);
painter.setPen( pen );
painter.drawLine(m_currentElement->cursorLine( m_position ));
pen.setWidth( 0.1);
pen.setColor(Qt::blue);
pen.setStyle(Qt::DashLine);
painter.setPen( pen );
painter.drawLine( origin+QPointF(0.0,baseline),origin+QPointF(m_currentElement->width(), baseline) );
pen.setStyle(Qt::DotLine);
//Only here for debug purpose for now
switch(m_currentElement->elementType()) {
case Number:
pen.setColor(Qt::red);
break;
case Identifier:
pen.setColor(Qt::darkRed);
break;
case Row:
pen.setColor(Qt::yellow);
break;
case Fraction:
pen.setColor(Qt::blue);
break;
case Table:
pen.setColor(Qt::darkGreen);
break;
case TableRow:
pen.setColor(Qt::green);
break;
default:
pen.setColor(Qt::darkGray);
break;
}
painter.setPen(pen);
painter.drawRect( m_currentElement->absoluteBoundingRect() );
//draw the selection rectangle
if ( m_selecting ) {
QBrush brush;
QColor color(Qt::blue);
color.setAlpha(128);
brush.setColor(color);
brush.setStyle(Qt::SolidPattern);
painter.setBrush(brush);
painter.setPen(Qt::NoPen);
int p1=position()<mark()? position() : mark();
int p2=position()<mark()? mark() : position() ;
painter.drawPath(m_currentElement->selectionRegion(p1,p2));
}
painter.restore();
}
void TernaryPointDiagram::paint (PaintContext *paintContext)
{
d->reverseMapper.clear();
d->paint( paintContext );
// sanity checks:
if ( model() == 0 ) return;
QPainter* p = paintContext->painter();
PainterSaver s( p );
TernaryCoordinatePlane* plane =
static_cast< TernaryCoordinatePlane* >( paintContext->coordinatePlane() );
Q_ASSERT( plane );
qreal x, y, z;
// for some reason(?) TernaryPointDiagram is using per-diagram DVAs only:
const DataValueAttributes attrs( dataValueAttributes() );
d->forgetAlreadyPaintedDataValues();
int columnCount = model()->columnCount( rootIndex() );
for (int column=0; column<columnCount; column+=datasetDimension() )
{
int numrows = model()->rowCount( rootIndex() );
for ( int row = 0; row < numrows; row++ )
{
QModelIndex base = model()->index( row, column, rootIndex() ); // checked
// see if there is data otherwise skip
if ( ! model()->data( base ).isNull() )
{
p->setPen( PrintingParameters::scalePen( pen( base ) ) );
p->setBrush( brush( base ) );
// retrieve data
x = qMax( model()->data( model()->index( row, column+0, rootIndex() ) ).toReal(), // checked
0.0 );
y = qMax( model()->data( model()->index( row, column+1, rootIndex() ) ).toReal(), // checked
0.0 );
z = qMax( model()->data( model()->index( row, column+2, rootIndex() ) ).toReal(), // checked
0.0 );
// fix messed up data values (paint as much as possible)
qreal total = x + y + z;
if ( fabs( total ) > 3 * std::numeric_limits<qreal>::epsilon() ) {
TernaryPoint tPunkt( x / total, y / total );
QPointF diagramLocation = translate( tPunkt );
QPointF widgetLocation = plane->translate( diagramLocation );
paintMarker( p, model()->index( row, column, rootIndex() ), widgetLocation ); // checked
QString text = tr( "(%1, %2, %3)" )
.arg( x * 100, 0, 'f', 0 )
.arg( y * 100, 0, 'f', 0 )
.arg( z * 100, 0, 'f', 0 );
d->paintDataValueText( p, attrs, widgetLocation, true, text, true );
} else {
// ignore and do not paint this point, garbage data
qDebug() << "TernaryPointDiagram::paint: data point x/y/z:"
<< x << "/" << y << "/" << z << "ignored, unusable.";
}
}
}
}
}
void ContactListEdit::addContactEntry(const QString& contactText, const bts::addressbook::contact& c)
{
QFont default_font;
default_font.setPointSize( default_font.pointSize() - 1 );
QFontMetrics font_metrics(default_font);
QRect bounding = font_metrics.boundingRect(contactText);
int completion_width = font_metrics.width(contactText);
int completion_height = bounding.height();
completion_width += 20;
QImage completion_image(completion_width, completion_height + 4, QImage::Format_ARGB32);
completion_image.fill(QColor(0, 0, 0, 0) );
QPainter painter;
painter.begin(&completion_image);
painter.setFont(default_font);
painter.setRenderHint(QPainter::Antialiasing);
QBrush brush(Qt::SolidPattern);
brush.setColor( QColor( 205, 220, 241 ) );
QPen pen;
bool isKeyhoteeFounder = Contact::isKeyhoteeFounder(c);
if (isKeyhoteeFounder)
{
QLinearGradient grad(QPointF(0, 0), QPointF(0, 1));
grad.setCoordinateMode(QGradient::ObjectBoundingMode);
grad.setColorAt(0, QColor(35, 40, 3));
grad.setColorAt(0.102273, QColor(136, 106, 22));
grad.setColorAt(0.225, QColor(166, 140, 41));
grad.setColorAt(0.285, QColor(204, 181, 74));
grad.setColorAt(0.345, QColor(235, 219, 102));
grad.setColorAt(0.415, QColor(245, 236, 112));
grad.setColorAt(0.52, QColor(209, 190, 76));
grad.setColorAt(0.57, QColor(187, 156, 51));
grad.setColorAt(0.635, QColor(168, 142, 42));
grad.setColorAt(0.695, QColor(202, 174, 68));
grad.setColorAt(0.75, QColor(218, 202, 86));
grad.setColorAt(0.815, QColor(208, 187, 73));
grad.setColorAt(0.88, QColor(187, 156, 51));
grad.setColorAt(0.935, QColor(137, 108, 26));
grad.setColorAt(1, QColor(35, 40, 3));
brush = QBrush(grad);
pen.setColor( QColor( 103, 51, 1 ) );
}
else
{
brush.setColor( QColor( 205, 220, 241 ) );
pen.setColor( QColor( 105,110,180 ) );
}
painter.setBrush(brush);
painter.setPen(pen);
painter.drawRoundedRect(0, 0, completion_width - 1, completion_image.height() - 1, 8, 8,
Qt::AbsoluteSize);
painter.setPen(QPen());
painter.drawText(QPoint(10, completion_height - 2), contactText);
QTextDocument* doc = document();
doc->addResource(QTextDocument::ImageResource, QUrl(contactText), completion_image);
QTextImageFormat format;
format.setName(contactText);
encodePublicKey(c.public_key, &format);
QTextCursor txtCursor = textCursor();
txtCursor.insertImage(format);
txtCursor.insertText(" ");
setTextCursor(txtCursor);
}
void Plot2D::drawFrame(QPainter &dc)
{
LocalPainter p(dc);
dc.setBrush(QColor(0xFFFFFF));
dc.drawRect(dm_offset.x(), dm_offset.y(), dm_area.width(), dm_area.height());
int x, y, i, ticknum;
int last_font;
double axis_min, axis_max, tick_spacing;
// draw x axis
last_font = -1;
ticknum = calcTickMarks(dm_view_xmin, dm_view_xmax, axis_min, axis_max, tick_spacing);
for (i=0; i<=ticknum; ++i) {
x = xToPixel(axis_min + i*tick_spacing);
if (x == -1)
continue;
y = dm_offset.y()+dm_area.height();
dc.drawLine(x, y, x, y+6);
QString label;
QTextStream s(&label);
s << handleXLabel(axis_min + i*tick_spacing);
QSize ext = QFontMetrics(dc.font()).size(Qt::TextSingleLine, label);
if (last_font == -1 || x-ext.width()/2 > last_font) {
dc.drawLine(x, y, x, y+12); // draw a longer line
dc.drawText(x-ext.width()/2, y+12+ext.height(), label);
last_font = x+ext.width()/2;
last_font += 10; // add some buffer space
}
}
// draw y axis
last_font = -1;
ticknum = calcTickMarks(dm_view_ymin, dm_view_ymax, axis_min, axis_max, tick_spacing);
for (i=0; i<=ticknum; ++i) {
y = yToPixel(axis_min + i*tick_spacing);
if (y == -1)
continue;
x = dm_offset.x();
dc.drawLine(x, y, x-4, y);
QString label;
QTextStream s(&label);
s << handleYLabel(axis_min + i*tick_spacing);
QSize ext = QFontMetrics(dc.font()).size(Qt::TextSingleLine, label);
if (last_font == -1 || y+ext.height()/2 < last_font) {
dc.drawLine(x, y, x-10, y); //draw a longer line
dc.drawText(x-10-4-ext.width(), y+ext.height()/2-4, label);
last_font = y+ext.height()/2;
last_font -= 20; // add some buffer space
}
}
if (!dm_title.isEmpty()) {
QSize ext = QFontMetrics(dc.font()).size(Qt::TextSingleLine, dm_title);
dc.drawText((dc.device()->width()-ext.width())/2, 10, dm_title);
}
if (!dm_xlabel.isEmpty()) {
QSize ext = QFontMetrics(dc.font()).size(Qt::TextSingleLine, dm_xlabel);
//dc.DrawRotatedText(dm_xlabel, (dm_area.width()-ext.width())/2+dm_offset.x(), dc.device()->height()-20, 0);
dc.drawText((dm_area.width()-ext.width())/2+dm_offset.x(), dc.device()->height(), dm_xlabel);
}
if (!dm_ylabel.isEmpty()) {
QSize ext = QFontMetrics(dc.font()).size(Qt::TextSingleLine, dm_ylabel);
LocalPainter rotatedcontext(dc); // cuz we'redoing a rotate
dc.translate(4+ext.height(), dm_offset.y()+dm_area.height()-(dm_area.height()-ext.width())/2);
dc.rotate(-90);
//dc.DrawRotatedText(dm_ylabel, 4, dm_offset.y()+dm_area.height()-(dm_area.height()-ext.width())/2, 90);
//dc.drawText(4, dm_offset.y()+dm_area.height()-(dm_area.height()-ext.width())/2, dm_ylabel);
dc.drawText(0, 0, dm_ylabel);
}
}
void ArthurFrame::paintEvent(QPaintEvent *e)
{
static QImage *static_image = 0;
QPainter painter;
if (preferImage()
#ifdef QT_OPENGL_SUPPORT
&& !m_use_opengl
#endif
) {
if (!static_image || static_image->size() != size()) {
delete static_image;
static_image = new QImage(size(), QImage::Format_RGB32);
}
painter.begin(static_image);
int o = 10;
QBrush bg = palette().brush(QPalette::Background);
painter.fillRect(0, 0, o, o, bg);
painter.fillRect(width() - o, 0, o, o, bg);
painter.fillRect(0, height() - o, o, o, bg);
painter.fillRect(width() - o, height() - o, o, o, bg);
} else {
#ifdef QT_OPENGL_SUPPORT
if (m_use_opengl) {
painter.begin(glw);
painter.fillRect(QRectF(0, 0, glw->width(), glw->height()), palette().color(backgroundRole()));
} else {
painter.begin(this);
}
#else
painter.begin(this);
#endif
}
painter.setClipRect(e->rect());
painter.setRenderHint(QPainter::Antialiasing);
QPainterPath clipPath;
QRect r = rect();
qreal left = r.x() + 1;
qreal top = r.y() + 1;
qreal right = r.right();
qreal bottom = r.bottom();
qreal radius2 = 8 * 2;
clipPath.moveTo(right - radius2, top);
clipPath.arcTo(right - radius2, top, radius2, radius2, 90, -90);
clipPath.arcTo(right - radius2, bottom - radius2, radius2, radius2, 0, -90);
clipPath.arcTo(left, bottom - radius2, radius2, radius2, 270, -90);
clipPath.arcTo(left, top, radius2, radius2, 180, -90);
clipPath.closeSubpath();
painter.save();
painter.setClipPath(clipPath, Qt::IntersectClip);
painter.drawTiledPixmap(rect(), m_tile);
// client painting
paint(&painter);
painter.restore();
painter.save();
if (m_show_doc)
paintDescription(&painter);
painter.restore();
int level = 180;
painter.setPen(QPen(QColor(level, level, level), 2));
painter.setBrush(Qt::NoBrush);
painter.drawPath(clipPath);
if (preferImage()
#ifdef QT_OPENGL_SUPPORT
&& !m_use_opengl
#endif
) {
painter.end();
painter.begin(this);
painter.drawImage(e->rect(), *static_image, e->rect());
}
#ifdef QT_OPENGL_SUPPORT
if (m_use_opengl && (inherits("PathDeformRenderer") || inherits("PathStrokeRenderer") || inherits("CompositionRenderer") || m_show_doc))
glw->swapBuffers();
#endif
}
void QgsColorButton::setButtonBackground( const QColor &color )
{
QColor backgroundColor = color;
bool isProjectColor = false;
if ( !backgroundColor.isValid() && !mLinkedColorName.isEmpty() )
{
backgroundColor = linkedProjectColor();
isProjectColor = backgroundColor.isValid();
if ( !isProjectColor )
{
mLinkedColorName.clear(); //color has been deleted, renamed, etc...
emit unlinked();
}
}
if ( !backgroundColor.isValid() )
{
backgroundColor = mColor;
}
QSize currentIconSize;
//icon size is button size with a small margin
if ( menu() )
{
if ( !mIconSize.isValid() )
{
//calculate size of push button part of widget (ie, without the menu drop-down button part)
QStyleOptionToolButton opt;
initStyleOption( &opt );
QRect buttonSize = QApplication::style()->subControlRect( QStyle::CC_ToolButton, &opt, QStyle::SC_ToolButton,
this );
//make sure height of icon looks good under different platforms
#ifdef Q_OS_WIN
mIconSize = QSize( buttonSize.width() - 10, height() - 6 );
#else
mIconSize = QSize( buttonSize.width() - 10, height() - 12 );
#endif
}
currentIconSize = mIconSize;
}
else
{
//no menu
#ifdef Q_OS_WIN
currentIconSize = QSize( width() - 10, height() - 6 );
#else
currentIconSize = QSize( width() - 10, height() - 12 );
#endif
}
if ( !currentIconSize.isValid() || currentIconSize.width() <= 0 || currentIconSize.height() <= 0 )
{
return;
}
//create an icon pixmap
QPixmap pixmap( currentIconSize );
pixmap.fill( Qt::transparent );
if ( backgroundColor.isValid() )
{
QRect rect( 0, 0, currentIconSize.width(), currentIconSize.height() );
QPainter p;
p.begin( &pixmap );
p.setRenderHint( QPainter::Antialiasing );
p.setPen( Qt::NoPen );
if ( mAllowOpacity && backgroundColor.alpha() < 255 )
{
//start with checkboard pattern
QBrush checkBrush = QBrush( transparentBackground() );
p.setBrush( checkBrush );
p.drawRoundedRect( rect, 3, 3 );
}
//draw semi-transparent color on top
p.setBrush( backgroundColor );
p.drawRoundedRect( rect, 3, 3 );
p.end();
}
setIconSize( currentIconSize );
setIcon( pixmap );
}
void PinItem::drawShape( QPainter& p )
{
if (!m_pinSettings)
return;
if ( m_pinSettings->state() == PinSettings::ps_on )
{
if ( m_pinSettings->type() == PinSettings::pt_output )
setBrush( QColor( 255, 127, 127 ) );
else
setBrush( QColor( 255, 191, 191 ) );
}
else
setBrush( Qt::white );
p.drawRect(rect());
p.setFont(m_font);
p.setBrush( Qt::NoBrush );
QRect r = m_textRect;
if ( onLeft )
p.drawText( r, Qt::AlignLeft, m_pinSettings->id() );
else
p.drawText( r, Qt::AlignRight, m_pinSettings->id() );
QRect br = p.boundingRect( r, Qt::AlignLeft, m_pinSettings->id() );
int left;
int right;
if ( onLeft )
{
right = (int)x();
left = right - 8;
}
else
{
left = (int)x() + PinLength;
right = left + 8;
}
int midY = (int)y() + PinWidth/2;
Q3PointArray pa(3);
int midLeft = left + (8-PinDirArrow)/2;
int midRight = left + (8+PinDirArrow)/2;
if ( onLeft )
{
midLeft--;
midRight--;
}
else
{
midLeft++;
midRight++;
}
p.setBrush( Qt::black );
// Right facing arrow
if ( (m_pinSettings->type() == PinSettings::pt_input && onLeft) ||
(m_pinSettings->type() == PinSettings::pt_output && !onLeft) )
{
pa[0] = QPoint( midRight, midY );
pa[1] = QPoint( midLeft, midY - PinDirArrow );
pa[2] = QPoint( midLeft, midY + PinDirArrow );
p.drawPolygon(pa);
p.drawLine ( left, midY, right, midY );
}
else // Left facing arrow
{
pa[0] = QPoint( midLeft, midY );
pa[1] = QPoint( midRight, midY - PinDirArrow );
pa[2] = QPoint( midRight, midY + PinDirArrow );
p.drawPolygon(pa);
p.drawLine ( left, midY, right, midY );
}
}