void FormatMapTest::indexMapQBrushTest()
{
IndexFormatMap map;
QBrush brush;
brush.setColor(QColor(10, 20, 30));
map.setFormatForIndex(1, 2, brush);
QVERIFY(map.formatForIndex(1, 1).isNull());
QCOMPARE(map.formatForIndex(1, 2).value<QBrush>().color().red(), 10);
QCOMPARE(map.formatForIndex(1, 2).value<QBrush>().color().green(), 20);
QCOMPARE(map.formatForIndex(1, 2).value<QBrush>().color().blue(), 30);
}
void UmlCanvas::resize(CanvasFormat f)
{
setSceneRect(0, 0,(int)(formatSize[f].w * zoom_value),
(int)(formatSize[f].h * zoom_value));
width100percent = formatSize[f].w;
height100percent = formatSize[f].h;
update_limits();
// force redisplay else phantoms may appears
QBrush bBrush = backgroundBrush();
bBrush.setColor(::Qt::lightGray);
setBackgroundBrush(bBrush);
//setBackgroundColor(::Qt::lightGray);
update();
bBrush.setColor(::Qt::white);
//setBackgroundColor(::Qt::white);
setBackgroundBrush(bBrush);
update();
}
void AbstractItem::setPenBrushDriftRect(QPainter* painter)
{
QPen pen(QColor("whitesmoke"));
pen.setStyle(Qt::SolidLine);
pen.setWidth(0);
QBrush brush;
brush.setStyle(Qt::NoBrush);
brush.setColor(Qt::white);
painter->setPen(pen);
painter->setBrush(brush);
}
void FormatMapTest::rowColumnMapBaseQBrushTest()
{
RowColumnFormatMapBase map;
QBrush brush;
brush.setColor(QColor(10, 20, 30));
map.setFormatVariantForIndex(1, brush);
QVERIFY(map.formatForIndex(0).isNull());
QCOMPARE(map.formatForIndex(1).value<QBrush>().color().red(), 10);
QCOMPARE(map.formatForIndex(1).value<QBrush>().color().green(), 20);
QCOMPARE(map.formatForIndex(1).value<QBrush>().color().blue(), 30);
}
void CanvasRect::paint(QPainter *painter, const QTransform &tran, const QRectF &limits)
{
QRectF plotRect = bounds();
// Let's not waste time here...
if (!limits.intersects(plotRect)) return;
// TODO: This boilerplate style stuff to a CanvasShape::applyStyle(QPainter*) func?
QPen pen;
LineSpec *ln = lineSpec();
pen.setColor(ln->color());
pen.setWidthF(ln->width());
QString style = ln->style();
if (style == ".") {
pen.setStyle(Qt::SolidLine);
} else {
pen.setStyle( LineSpec::styleMap[style] );
}
QBrush brush;
brush.setStyle(Qt::SolidPattern);
brush.setColor(fillSpec()->color());
painter->setRenderHint(QPainter::Antialiasing);
// Only draw the part of the rect in the view
QRectF rect = limits.intersected(plotRect);
// Figure out which sides still need lines...
QVector<QLineF> lines;
if (rect.left() == plotRect.left())
lines << QLineF(rect.bottomLeft(), rect.topLeft());
if (rect.right() == plotRect.right())
lines << QLineF(rect.bottomRight(), rect.topRight());
if (rect.top() == plotRect.top())
lines << QLineF(rect.topLeft(), rect.topRight());
if (rect.bottom() == plotRect.bottom())
lines << QLineF(rect.bottomLeft(), rect.bottomRight());
// Map the fill and lines
QRectF mappedRect = tran.mapRect(rect);
for (int i=0; i<lines.length(); ++i) {
lines[i] = tran.map(lines[i]);
}
// Draw the rect
painter->setPen(Qt::NoPen);
painter->setBrush(brush);
painter->drawRect(mappedRect);
// Draw the outline
painter->setBrush(Qt::NoBrush);
painter->setPen(pen);
painter->drawLines(lines);
}
void CustomSlice::showHighlight(bool show)
{
if (show) {
QBrush brush = this->brush();
m_originalBrush = brush;
brush.setColor(brush.color().lighter());
setBrush(brush);
} else {
setBrush(m_originalBrush);
}
}
static QBrush awesomeHeaderBrush()
{
static QBrush brush;
if (brush.style() == Qt::NoBrush) {
QColor alphaBlue(Qt::darkBlue);
alphaBlue.setAlpha(155);
brush.setStyle(Qt::SolidPattern);
brush.setColor(alphaBlue);
}
return brush;
}
void ArrowSprite::setActive(bool value)
{
int alpha = (value?128:64);
// kDebug() << value << alpha;
QBrush b = brush();
QColor color = b.color();
color.setAlpha(alpha);
// kDebug() << color.alpha();
b.setColor(color);
setBrush(b);
}
void
TextField::DoPaint( const GUI::DrawContext& inDC,
RGBColor inTextColor,
RGBColor inBackgroundColor )
{
#if USE_QT
QPainter* p = inDC.handle.painter;
QRect rect(
static_cast<int>( inDC.rect.left ),
static_cast<int>( inDC.rect.top ),
static_cast<int>( inDC.rect.right - inDC.rect.left ),
static_cast<int>( inDC.rect.bottom - inDC.rect.top )
);
QBrush brush;
brush.setStyle( Qt::SolidPattern );
if( mColor != RGBColor( RGBColor::NullColor ) )
{
QColor backColor( mColor.R(), mColor.G(), mColor.B() );
brush.setColor( backColor );
p->fillRect( rect, brush );
}
QFont font;
font.fromString( QString( "Arial" ) );
font.setPixelSize( static_cast<int>( mTextHeight * ( inDC.rect.bottom - inDC.rect.top ) ) );
font.setBold( true );
QColor textColor( inTextColor.R(), inTextColor.G(), inTextColor.B() );
QPen pen;
brush.setColor( textColor );
pen.setColor( textColor );
p->setPen( pen );
p->setBrush( brush );
p->setFont( font );
QString text = QString::fromLocal8Bit( mText.c_str() );
text.append( " " ).prepend( " " );
p->drawText( rect, Qt::AlignCenter, text );
#endif // USE_QT
}
void Draw_Line::drawEdges()
{
QBrush rectbrush;
rectbrush.setColor(QColor(0,175,225));
rectbrush.setStyle(Qt::SolidPattern);
for(int i=0;i<poly_pnts.size();i++)
{
QGraphicsRectItem *rect = new QGraphicsRectItem(QRectF(QPointF(poly_pnts[i].x()-5.0,poly_pnts[i].y()-5.0),QPointF(poly_pnts[i].x()+5.0,poly_pnts[i].y()+5.0)));
rect->setBrush(rectbrush);
edge_items.push_back(rect);
}
}
void instDialog::setInProcessState(QTreeWidgetItem *item)
{
QBrush b = item->foreground(1);
b.setColor(Qt::black);
item->setForeground(1,b);
item->setForeground(0,b);
QFont f = item->font(1);
f.setBold(true);
item->setFont(1,f);
item->setFont(0,f);
}
void instDialog::setWarningState(QTreeWidgetItem *item)
{
QBrush b = item->foreground(1);
b.setColor(QColor("orange"));
item->setForeground(1,b);
item->setForeground(0,b);
QFont f = item->font(1);
f.setBold(true);
item->setFont(1,f);
item->setFont(0,f);
}
void instDialog::setErrorState(QTreeWidgetItem *item)
{
QBrush b = item->foreground(1);
b.setColor(Qt::darkRed);
item->setForeground(1,b);
item->setForeground(0,b);
QFont f = item->font(1);
f.setBold(true);
item->setFont(1,f);
item->setFont(0,f);
}
/// Fills the specified cell.
///
/// Marks it filled in the pathingMap_ and draws a gray square to visually
/// represent it.
void Game::fill( int x, int y){
pathingMap_.fillCell(x,y);
// draw rectangle
QGraphicsRectItem* rect = new QGraphicsRectItem(0,0,cellSize_,cellSize_);
rect->setPos(x*cellSize_,y*cellSize_);
QBrush brush;
brush.setColor(Qt::gray);
brush.setStyle(Qt::SolidPattern);
rect->setBrush(brush);
scene_->addItem(rect);
}
void OptionsMenu::paintEvent(QPaintEvent * event )
{
QPainter painter(this);
QPen* pen = new QPen();
pen->setWidth(4);
painter.setPen(*pen);
QBrush* brush = new QBrush(Qt::Dense5Pattern);
brush->setColor(QColor(48,213,208));
painter.setBrush(*brush);
painter.setRenderHint(QPainter::Antialiasing);
painter.drawRoundedRect(1,1,this->width()-2,this->height()-2,20,10);
}
// функция отрисовки корабля
void Ship::draw(QPainter *painter)
{
QPen pen; // карандаш(определяет контур фигур)
QBrush brush; // кисть(определяет заливку фигур)
if(conflicted) // корабль конфликтный
{
drawShadow(painter); // рисуем "тень"
brush.setColor(Qt::red); // выбираем цвет заливки
}
else if(active) // корабль не конфликтный, но активный
{
drawShadow(painter); // рисуем "тень"
brush.setColor(Qt::green); // выбираем цвет заливки
}
else
{
brush.setColor(Qt::blue); // выбираем цвет заливки
}
brush.setStyle(Qt::SolidPattern); // определяем стиль закраски фигур (SolidPattern - сплошная закраска)
pen.setWidth(2); // устанавливаем толщину карандаша
if(active)
pen.setColor(Qt::darkGreen); // выбираем цвет заливки
else
pen.setColor(Qt::gray); // выбираем цвет заливки
painter->setPen(pen); // передаем карандаш рисовальщику
painter->setBrush(brush); // передаем кисть рисовальщику
// отрисовываем все "квадраты" корабля в зависимости от его ориентации
for(int i = 0 ; i < size ; i++)
{
switch(dir)
{
case HORIZONTAL:
painter->drawRect(i * CELL + drawPoint.x(), drawPoint.y(), CELL, CELL);
break;
case VERTICAL:
painter->drawRect(drawPoint.x(), i * CELL + drawPoint.y(), CELL, CELL);
break;
}
}
}
/*!
Draw a compass needle
\param painter Painter
\param brush Brush
\param colorOffset Color offset
\param center Center, where the needle starts
\param length Length of the needle
\param width Width of the needle
\param direction Direction
*/
void QwtCompassMagnetNeedle::drawPointer(
QPainter *painter, const QBrush &brush,
int colorOffset, const QPoint ¢er, int length,
int width, double direction )
{
painter->save();
const int peak = qMax( qRound( length / 10.0 ), 5 );
const int knobWidth = width + 8;
QRect knobRect( 0, 0, knobWidth, knobWidth );
knobRect.moveCenter( center );
QPolygon pa( 5 );
pa.setPoint( 0, qwtDegree2Pos( center, width / 2, direction + 90.0 ) );
pa.setPoint( 1, center );
pa.setPoint( 2, qwtDegree2Pos( pa.point( 1 ), length - peak, direction ) );
pa.setPoint( 3, qwtDegree2Pos( center, length, direction ) );
pa.setPoint( 4, qwtDegree2Pos( pa.point( 0 ), length - peak, direction ) );
painter->setPen( Qt::NoPen );
QBrush darkBrush = brush;
darkBrush.setColor( darkBrush.color().dark( 100 + colorOffset ) );
painter->setBrush( darkBrush );
painter->drawPolygon( pa );
painter->drawPie( knobRect, qRound( direction * 16 ), 90 * 16 );
pa.setPoint( 0, qwtDegree2Pos( center, width / 2, direction - 90.0 ) );
pa.setPoint( 4, qwtDegree2Pos( pa.point( 0 ), length - peak, direction ) );
QBrush lightBrush = brush;
lightBrush.setColor( lightBrush.color().dark( 100 - colorOffset ) );
painter->setBrush( lightBrush );
painter->drawPolygon( pa );
painter->drawPie( knobRect, qRound( direction * 16 ), -90 * 16 );
painter->restore();
}
void DKMemmoryView::paintEvent(QPaintEvent *ev)
{
QPainter painter(this);
//
QHashIterator<uint32_t, uint32_t> i(mem);
while (i.hasNext())
{
i.next();
//
for (uint32_t p = i.key(); p < i.key()+i.value(); p++)
{
int row = p/p_viewSize.width();
int column = p%p_viewSize.width();
QBrush brush;
if (selectedRegion == i.key())
brush.setColor(QColor("red"));
else
brush.setColor(QColor("green"));
if (highlightedRegion == i.key())
{
QColor col = brush.color();
col.setBlue(240);
brush.setColor(col);
}
brush.setStyle(Qt::SolidPattern);
painter.setBrush(brush);
painter.drawRect(
column*p_rectSize.height(),
row*p_rectSize.width(),
p_rectSize.width(),
p_rectSize.height()
);
}
}
//
painter.end();
QFrame::paintEvent(ev);
}
void CollReport::registerHeader(QPainter *p)
{
QRect rect;
QString tmpSt;
QBrush bbrush;
char headFont[1024];
strcpy(headFont, "b&h lucida");
p->setFont(QFont(headFont, 8, QFont::Normal));
// p->drawRect(40, 150, 525, 15);
bbrush.setStyle(Qt::SolidPattern);
bbrush.setColor(Qt::black);
//p->setBackgroundMode(Qt::OpaqueMode);
p->setPen(Qt::white);
rect.setCoords(transDateX1, 150, transDateX2, 165);
p->fillRect(rect, bbrush);
p->drawText(rect, Qt::AlignCenter, "Trans Date");
rect.setCoords(dueDateX1, 150, dueDateX2, 165);
p->fillRect(rect, bbrush);
p->drawText(rect, Qt::AlignCenter, "Due Date");
p->drawLine(dueDateX1, 150, dueDateX1, 165);
/*
rect.setCoords(140, 150, 200, 165);
p->fillRect(rect, bbrush);
p->drawText(rect, Qt::AlignCenter, "Login ID");
p->drawLine(140, 150, 140, 165);
*/
rect.setCoords(descriptionX1, 150, descriptionX2, 165);
p->fillRect(rect, bbrush);
p->drawText(rect, Qt::AlignCenter, "Description");
p->drawLine(descriptionX1, 150, descriptionX1, 165);
rect.setCoords(amountX1, 150, amountX2, 165);
p->fillRect(rect, bbrush);
p->drawText(rect, Qt::AlignCenter, "Amount");
p->drawLine(amountX1, 150, amountX1, 165);
rect.setCoords(balanceX1, 150, balanceX2, 165);
p->fillRect(rect, bbrush);
p->drawText(rect, Qt::AlignCenter, "Balance");
p->drawLine(balanceX1, 150, balanceX1, 165);
// Reset our pen back to a transparent background and black letters.
p->setBackgroundMode(Qt::TransparentMode);
p->setPen(Qt::black);
}
void ArrowItem::paint(QPainter *painter) {
painter->drawLine(line());
QBrush b = brush();
b.setStyle(Qt::SolidPattern);
b.setColor(pen().color());
setBrush(b);
start.clear();
end.clear();
if (_startArrowHead) {
qreal deltax = view()->scaledFontSize(_startArrowScale, *painter->device())*0.5; // in points
deltax *= painter->device()->logicalDpiX()/72.0; // convert to 'pixels'.
qreal theta = atan2(qreal(line().y2() - line().y1()), qreal(line().x2() - line().x1())) - M_PI / 2.0;
qreal sina = sin(theta);
qreal cosa = cos(theta);
qreal yin = sqrt(3.0) * deltax;
qreal x1, y1, x2, y2;
QMatrix m(cosa, sina, -sina, cosa, 0.0, 0.0);
m.map( deltax, yin, &x1, &y1);
m.map(-deltax, yin, &x2, &y2);
QPolygonF pts;
pts.append(line().p1());
pts.append(line().p1() + QPointF(x1, y1));
pts.append(line().p1() + QPointF(x2, y2));
painter->drawPolygon(pts);
start = pts;
}
if (_endArrowHead) {
qreal deltax = view()->scaledFontSize(_endArrowScale, *painter->device())*0.5;
deltax *= painter->device()->logicalDpiX()/72.0; // convert points to 'pixels'.
qreal theta = atan2(qreal(line().y1() - line().y2()), qreal(line().x1() - line().x2())) - M_PI / 2.0;
qreal sina = sin(theta);
qreal cosa = cos(theta);
qreal yin = sqrt(3.0) * deltax;
qreal x1, y1, x2, y2;
QMatrix m(cosa, sina, -sina, cosa, 0.0, 0.0);
m.map( deltax, yin, &x1, &y1);
m.map(-deltax, yin, &x2, &y2);
QPolygonF pts;
pts.append(line().p2());
pts.append(line().p2() + QPointF(x1, y1));
pts.append(line().p2() + QPointF(x2, y2));
painter->drawPolygon(pts);
end = pts;
}
}
void H2CanvasDelegate::highlightStraightH2Triangle(const H2Triangle &triangle, const QColor &color)
{
H2Point A, B, C;
(mobius*triangle).getVertices(A, B, C);
QBrush brush;
brush.setColor(color);
brush.setStyle(Qt::SolidPattern);
painterTop->setBrush(brush);
penTop->setWidth(1);
penTop->setColor(color);
painterTop->setPen(*penTop);
drawFilledTriangle(A.getDiskCoordinate(), B.getDiskCoordinate(), C.getDiskCoordinate(), false);
}
void pigalePaint::DrawText(QPainter *p,double x,double y,double nx,double ny,tvertex v,int col)
// draw centered text in rectangle left at x,y of size: nx,ny
{QPen pn = p->pen();pn.setColor(color[Black]);
nx *= xscale; ny *= yscale;
QRect rect = QRect(to_x(x),to_y(y),(int)(nx+.5),(int)(ny+.5));
QBrush pb = p->brush();pb.setStyle(Qt::SolidPattern);
pb.setColor(color[bound(col,1,16)]);p->setBrush(pb);
pn.setWidth(1);p->setPen(pn);
p->drawRect(rect);
pn.setWidth(1);p->setPen(pn);
QString t = getVertexLabel(GCP,v);
p->drawText(rect,Qt::AlignCenter,t);
}
/*********************************************************************************
* Function: refresh trackers' position
* Parameters: bonding rect
* Return: none
********************************************************************************/
void SamDrawItemBase::refreshTrackers(const QRectF &qrcCurBndRect, QGraphicsScene *pScene)
{
QRectF qrcRect = qrcCurBndRect;
if (false == this->getResizable()) return;
if (m_pvecTrackers.size() <= 0)
{
this->drawTracker(TRK_SELECTED, pScene, qrcRect);
return;
}
int iHandleCnt = this->getHandleCount();
for (int i = 1; i <= iHandleCnt; i++)
{
QPointF qrcPoint = getHandle(i, qrcRect);
if (m_pvecTrackers[i-1] != NULL)
{
QRectF rect(qrcPoint.x()-3, qrcPoint.y()-3, SAMDRAW_TRACKER_SIZE, SAMDRAW_TRACKER_SIZE);
m_pvecTrackers[i-1]->setRect(rect);
QBrush br = m_pvecTrackers[i-1]->brush();
QPen pen = m_pvecTrackers[i-1]->pen();
if(bFlag && br.color() != Qt::black)
{
br.setColor(Qt::black);
pen.setColor(Qt::white);
m_pvecTrackers[i-1]->setPen(pen);
m_pvecTrackers[i-1]->setBrush(br);
}
else if(!bFlag && br.color() != Qt::green)
{
pen.setColor(Qt::black);
m_pvecTrackers[i-1]->setPen(pen);
br.setColor(Qt::green);
m_pvecTrackers[i-1]->setBrush(br);
}
}
}
}
void AssetDecodePopup::drawItem(const QString& displayFilename, const QString& status, const QRect& target, float progress)
{
QPainter p(this);
// item background
QBrush brush;
brush.setColor(QColor(60, 60, 60));
brush.setStyle(Qt::BrushStyle::SolidPattern);
p.fillRect(target.left(), target.top(), target.width(), target.height(), brush);
// item borders
QPen pen;
pen.setColor(QColor(41, 41, 41));
p.setPen(pen);
p.drawRect(target.left(), target.top(), target.width(), target.height());
// absoluteFilename and status text
pen.setColor(QColor(220, 220, 220));
p.setPen(pen);
p.drawText(QRect(target.left() + 1, target.top(), target.width() - 2, 15), displayFilename);
p.drawText(QRect(target.left() + 1, target.top() + 15, target.width() - 2, 15), status);
// progress background
brush.setColor(QColor(60, 60, 60));
p.fillRect(target.left() + 2, target.top() + 30, target.width() - 4, 10, brush);
// progress borders
pen.setColor(QColor(41, 41, 41));
p.setPen(pen);
p.drawRect(target.left() + 2, target.top() + 30, target.width() - 4, 10);
// progress bar
QLinearGradient gradient(QPoint(target.left() + 4, target.top() + 32), QPoint(target.width() - 8, target.top() + 32));
gradient.setColorAt(0, QColor(43, 155, 207));
gradient.setColorAt(1, QColor(195, 236, 255));
float progWidth = (target.width() - 7) * progress;
float progHeight = 6;
p.fillRect(QRect(target.left() + 4, target.top() + 32, progWidth, 6), gradient);
}
//------------------------------------------------------------------------------
//
void QEAnalogIndicator::drawBar (QPainter & painter, QRect &area,
const double fraction)
{
int temp;
QPen pen;
QBrush brush;
QRect barRect (area);
switch (this->mOrientation) {
case Left_To_Right:
// Convert fractions back to pixels.
//
temp = int (fraction * (area.right () - area.left ()));
barRect.setRight (area.left () + temp);
break;
case Top_To_Bottom:
temp = int (fraction * (area.bottom () - area.top ()));
barRect.setBottom (area.top () + temp);
break;
case Right_To_Left:
temp = int (fraction * (area.right () - area.left ()));
barRect.setLeft (area.right () - temp);
break;
case Bottom_To_Top:
temp = int (fraction * (area.bottom () - area.top ()));
barRect.setTop (area.bottom () - temp);
break;
default:
// report an error??
//
return;
}
// barRect and paint it.
//
pen.setColor (this->getForegroundPaintColour ());
pen.setWidth (1);
painter.setPen (pen);
brush.setStyle (Qt::SolidPattern);
brush.setColor (this->getForegroundPaintColour() );
painter.setBrush (brush);
painter.drawRect (barRect);
}
QIcon RColor::getIcon(const RColor& color, const QSize& size) {
init();
if (iconMap.contains(QPair<RColor, QPair<int, int> >(color, QPair<int, int>(size.width(), size.height())))) {
return iconMap[QPair<RColor, QPair<int, int> >(color, QPair<int, int>(size.width(), size.height()))];
}
RColor col = color;
if (color.isByLayer() || color.isByBlock() || /*color == RColor(Qt::black,
RColor::BlackWhite) ||*/ !color.isValid()) {
col = Qt::white;
}
QImage img(size, QImage::Format_ARGB32_Premultiplied);
img.fill(0);
QPainter painter(&img);
int w = img.width();
int h = img.height();
// painter.setCompositionMode(QPainter::CompositionMode_Source);
painter.fillRect(0, 0, w, h, col);
if (!color.isValid()) {
// icon for "Other colors..."
QLinearGradient grad(0, 0, w, 0);
grad.setColorAt(0, Qt::red);
grad.setColorAt(0.33, Qt::yellow);
grad.setColorAt(0.66, Qt::blue);
grad.setColorAt(1, Qt::green);
painter.fillRect(QRect(0, 0, w, h), grad);
} /*else if (color == RColor(Qt::black, RColor::BlackWhite) || color
== RColor(Qt::white, RColor::BlackWhite)) {
// icon for black / white
painter.setRenderHint(QPainter::Antialiasing);
QPainterPath path;
path.moveTo(0, 0);
path.lineTo(w, 0);
path.lineTo(w, h);
painter.fillPath(path, Qt::black);
painter.setRenderHint(QPainter::Antialiasing, false);
}*/ else if (col.alpha() != 255) {
// indicate alpha by an inset
QBrush opaqueBrush = col;
col.setAlpha(255);
opaqueBrush.setColor(col);
painter.fillRect(w / 4, h / 4, w / 2, h / 2, opaqueBrush);
}
painter.setPen(Qt::black);
painter.drawRect(0, 0, w - 1, h - 1);
painter.end();
QIcon ret(QPixmap::fromImage(img));
iconMap.insert(QPair<RColor, QPair<int, int> >(color, QPair<int, int>(size.width(), size.height())), ret);
return ret;
}
void ScrollBar::paintEvent(QPaintEvent *event)
{
Q_UNUSED(event)
Q_D(ScrollBar);
QPainter painter(this);
painter.fillRect(rect(), palette().color(QPalette::Window));
int x, y, w, h;
rect().getRect(&x, &y, &w, &h);
QMargins margins(2, 2, 2, 2);
QBrush brush;
brush.setStyle(Qt::SolidPattern);
brush.setColor(backgroundColor());
painter.setBrush(brush);
painter.setPen(Qt::NoPen);
if (d->hideOnMouseOut) {
painter.setOpacity(d->machine->opacity());
}
painter.drawRect(rect().marginsRemoved(margins));
const qreal q = h / static_cast<qreal>(maximum() - minimum() + pageStep());
QRect handle = Qt::Horizontal == orientation()
? QRect(sliderPosition()*q, y, pageStep()*q, h)
: QRect(x, sliderPosition()*q, w, pageStep()*q);
brush.setColor(sliderColor());
painter.setBrush(brush);
painter.drawRect(handle.marginsRemoved(margins));
}
void CanvasStyle::applyFillColor(GraphicsContext* context)
{
if (!context)
return;
switch (m_type) {
case ColorString: {
RGBA32 rgba = 0; // default is transparant black
if (CSSParser::parseColor(rgba, m_color))
context->setFillColor(rgba);
break;
}
case ColorStringWithAlpha: {
RGBA32 color = 0; // default is transparant black
if (CSSParser::parseColor(color, m_color))
context->setFillColor(colorWithOverrideAlpha(color, m_alpha));
break;
}
case GrayLevel:
// We're only supporting 255 levels of gray here. Since this isn't
// even part of HTML5, I don't expect anyone will care. If they do
// we'll make a fancier Color abstraction.
context->setFillColor(Color(m_grayLevel, m_grayLevel, m_grayLevel, m_alpha));
break;
case RGBA:
context->setFillColor(Color(m_red, m_green, m_blue, m_alpha));
break;
case CMYKA: {
// FIXME: Do this through platform-independent GraphicsContext API.
// We'll need a fancier Color abstraction to support CYMKA correctly
#if PLATFORM(CG)
CGContextSetCMYKFillColor(context->platformContext(), m_cyan, m_magenta, m_yellow, m_black, m_alpha);
#elif PLATFORM(QT)
QBrush currentBrush = context->platformContext()->brush();
QColor clr;
clr.setCmykF(m_cyan, m_magenta, m_yellow, m_black, m_alpha);
currentBrush.setColor(clr);
context->platformContext()->setBrush(currentBrush);
#elif PLATFORM(SGL)
context->setCMYKAFillColor(m_cyan, m_magenta, m_yellow, m_black, m_alpha);
#endif
break;
}
case Gradient:
context->setFillGradient(canvasGradient()->gradient());
break;
case ImagePattern:
context->setFillPattern(canvasPattern()->pattern());
break;
}
}
void HoppHen::paintEvent(QPaintEvent * e)
{
QPainter p(this);
QBrush br;
br.setColor(Qt::blue);
p.setBrush(br);
QFont font;
font.setPointSize(24);
QPen pen(QColor("#FFF"));
p.setPen(pen);
p.setFont(font);
switch (gameState)
{
case Intro:
//Intro
p.drawPixmap(0, 0, *introTexture);
break;
case Game:
//Bakgrund
p.drawPixmap(0, _bgYPos, *_background);
_worldManager->paint(p);
p.drawPixmap(0, 0, *scoreTab);
p.drawText(220, 45, "Height:");
p.drawText(340, 45, QString::number(_scoreManager->GetScore()));
break;
case Pause:
//Bakgrund
p.drawPixmap(0, _bgYPos, *_background);
_worldManager->paint(p);
p.drawPixmap(0, 0, *scoreTab);
p.drawText(220, 45, "Height:");
p.drawText(340, 45, QString::number(_scoreManager->GetScore()));
break;
case Lose:
_worldManager->paint(p);
_scoreManager->paint(p);
break;
}
}
void QgsLayoutItemPolyline::drawArrow( QPainter *painter, QPointF center, double angle )
{
// translate angle from ccw from axis to cw from north
angle = 90 - angle;
QPen p;
p.setColor( mArrowHeadStrokeColor );
p.setWidthF( mArrowHeadStrokeWidth );
painter->setPen( p );
QBrush b;
b.setColor( mArrowHeadFillColor );
painter->setBrush( b );
drawArrowHead( painter, center.x(), center.y(), angle, mArrowHeadWidth );
}
