void Item::render()
{
// if the item is mounted, renderItem will be called from the
// ship it is mounted to
if(mIsMounted)
return;
renderItem(mMoveState[RenderState].pos);
}
void CustomMenu::Accept(CallbackProcessor * processor)
{
GString playSound("PlaySound");
processor->Process(playSound, PlaySoundCallback);
#ifdef _CUSTOMMENU_ITEMDISPLAY
GString renderItem("UpdateItem3D");
processor->Process(renderItem, UpdateItem3D);
#endif
}
/*!
Render the legend into a given rectangle.
\param painter Painter
\param rect Bounding rectangle
\param fillBackground When true, fill rect with the widget background
\sa renderLegend() is used by QwtPlotRenderer - not by QwtLegend itself
*/
void QwtLegend::renderLegend( QPainter *painter,
const QRectF &rect, bool fillBackground ) const
{
if ( d_data->itemMap.isEmpty() )
return;
if ( fillBackground )
{
if ( autoFillBackground() ||
testAttribute( Qt::WA_StyledBackground ) )
{
QwtPainter::drawBackgound( painter, rect, this );
}
}
const QwtDynGridLayout *legendLayout =
qobject_cast<QwtDynGridLayout *>( contentsWidget()->layout() );
if ( legendLayout == NULL )
return;
int left, right, top, bottom;
getContentsMargins( &left, &top, &right, &bottom );
QRect layoutRect;
layoutRect.setLeft( qCeil( rect.left() ) + left );
layoutRect.setTop( qCeil( rect.top() ) + top );
layoutRect.setRight( qFloor( rect.right() ) - right );
layoutRect.setBottom( qFloor( rect.bottom() ) - bottom );
uint numCols = legendLayout->columnsForWidth( layoutRect.width() );
QList<QRect> itemRects =
legendLayout->layoutItems( layoutRect, numCols );
int index = 0;
for ( int i = 0; i < legendLayout->count(); i++ )
{
QLayoutItem *item = legendLayout->itemAt( i );
QWidget *w = item->widget();
if ( w )
{
painter->save();
painter->setClipRect( itemRects[index], Qt::IntersectClip );
renderItem( painter, w, itemRects[index], fillBackground );
index++;
painter->restore();
}
}
}
void FileManager::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
BarBase::paint( painter, option, widget );
painter->save();
//*********************************************************
drawDropArea( painter );
drawFileArea( painter );
drawVisArea( painter );
renderItem( painter );
drawControl( painter );
drawViews( painter );
drawColorBar( painter );
//*********************************************************
painter->restore();
//*********************************************************
return;
}
//! Event filter
bool QwtPlotDirectPainter::eventFilter( QObject *, QEvent *event )
{
if ( event->type() == QEvent::Paint )
{
reset();
if ( d_data->seriesItem )
{
const QPaintEvent *pe = static_cast< QPaintEvent *>( event );
QwtPlotCanvas *canvas = d_data->seriesItem->plot()->canvas();
QPainter painter( canvas );
painter.setClipRegion( pe->region() );
bool copyCache = testAttribute( CopyBackingStore )
&& canvas->testPaintAttribute( QwtPlotCanvas::BackingStore );
if ( copyCache )
{
// is something valid in the cache ?
copyCache = ( canvas->backingStore() != NULL )
&& !canvas->backingStore()->isNull();
}
if ( copyCache )
{
painter.drawPixmap(
canvas->contentsRect().topLeft(),
*canvas->backingStore() );
}
else
{
renderItem( &painter, canvas->contentsRect(),
d_data->seriesItem, d_data->from, d_data->to );
}
return true; // don't call QwtPlotCanvas::paintEvent()
}
}
return false;
}
void renderAll(Game& game) {
SDL_RenderClear(game.renderer);
if (game.bonusItem.alive)
renderItem(game.renderer, game.bonusItem);
for (unsigned int i = 0; i < game.daMissiles.size(); i++)
renderMissile(game.renderer, game.daMissiles[i]);
for (unsigned int i = 0; i < game.daEnemies.size(); i++)
renderEnemy(game.renderer, game.daEnemies[i]);
for (unsigned int i = 0; i < game.daBlasts.size(); i++)
renderBlast(game.renderer, game.daBlasts[i]);
if (game.daBox.alive)
renderBox(game.renderer, game.daBox);
for (unsigned int i = 0; i < game.lives.size(); i++)
renderBlast(game.renderer, game.lives[i]);
renderScore(game);
SDL_UpdateWindowSurface(game.window);
}
//! Event filter
bool QwtPlotDirectPainter::eventFilter( QObject *, QEvent *event )
{
if ( event->type() == QEvent::Paint )
{
reset();
if ( d_data->seriesItem )
{
QwtPlotCanvas *canvas = d_data->seriesItem->plot()->canvas();
QPainter painter( canvas );
painter.setClipping( true );
painter.setClipRect( canvas->contentsRect() );
renderItem( &painter, d_data->seriesItem,
d_data->from, d_data->to );
return true;
}
}
return false;
}
void Item::renderEditor(F32 currentScale, bool snappingToWallCornersEnabled, bool renderVertices) const
{
renderItem(getPos());
}
void Item::render() const
{
renderItem(getPos());
}
/*!
\brief Draw a set of points of a seriesItem.
When observing an measurement while it is running, new points have to be
added to an existing seriesItem. drawSeries can be used to display them avoiding
a complete redraw of the canvas.
Setting plot()->canvas()->setAttribute(Qt::WA_PaintOutsidePaintEvent, true);
will result in faster painting, if the paint engine of the canvas widget
supports this feature.
\param seriesItem Item to be painted
\param from Index of the first point to be painted
\param to Index of the last point to be painted. If to < 0 the
series will be painted to its last point.
*/
void QwtPlotDirectPainter::drawSeries(
QwtPlotAbstractSeriesItem *seriesItem, int from, int to )
{
if ( seriesItem == NULL || seriesItem->plot() == NULL )
return;
QwtPlotCanvas *canvas = seriesItem->plot()->canvas();
const QRect canvasRect = canvas->contentsRect();
const bool hasBackingStore =
canvas->testPaintAttribute( QwtPlotCanvas::BackingStore )
&& canvas->backingStore() && !canvas->backingStore()->isNull();
if ( hasBackingStore )
{
QPainter painter( const_cast<QPixmap *>( canvas->backingStore() ) );
if ( d_data->hasClipping )
painter.setClipRegion( d_data->clipRegion );
renderItem( &painter, canvasRect, seriesItem, from, to );
if ( testAttribute( QwtPlotDirectPainter::FullRepaint ) )
{
canvas->repaint();
return;
}
}
bool immediatePaint = true;
if ( !canvas->testAttribute( Qt::WA_WState_InPaintEvent ) )
{
immediatePaint = false;
}
if ( immediatePaint )
{
if ( !d_data->painter.isActive() )
{
reset();
d_data->painter.begin( canvas );
canvas->installEventFilter( this );
}
if ( d_data->hasClipping )
{
d_data->painter.setClipRegion(
QRegion( canvasRect ) & d_data->clipRegion );
}
else
{
if ( !d_data->painter.hasClipping() )
d_data->painter.setClipRect( canvasRect );
}
renderItem( &d_data->painter, canvasRect, seriesItem, from, to );
if ( d_data->attributes & QwtPlotDirectPainter::AtomicPainter )
{
reset();
}
else
{
if ( d_data->hasClipping )
d_data->painter.setClipping( false );
}
}
else
{
reset();
d_data->seriesItem = seriesItem;
d_data->from = from;
d_data->to = to;
QRegion clipRegion = canvasRect;
if ( d_data->hasClipping )
clipRegion &= d_data->clipRegion;
canvas->installEventFilter( this );
canvas->repaint(clipRegion);
canvas->removeEventFilter( this );
d_data->seriesItem = NULL;
}
}
void StonePhiras::render()
{
renderItem();
}
void StoneThystame::render()
{
renderItem();
}
/*!
\brief Draw a set of points of a seriesItem.
When observing an measurement while it is running, new points have to be
added to an existing seriesItem. drawSeries can be used to display them avoiding
a complete redraw of the canvas.
Setting plot()->canvas()->setAttribute(Qt::WA_PaintOutsidePaintEvent, true);
will result in faster painting, if the paint engine of the canvas widget
supports this feature.
\param seriesItem Item to be painted
\param from Index of the first point to be painted
\param to Index of the last point to be painted. If to < 0 the
series will be painted to its last point.
*/
void QwtPlotDirectPainter::drawSeries(
QwtPlotAbstractSeriesItem *seriesItem, int from, int to )
{
if ( seriesItem == NULL || seriesItem->plot() == NULL )
return;
QwtPlotCanvas *canvas = seriesItem->plot()->canvas();
if ( canvas->testPaintAttribute( QwtPlotCanvas::PaintCached ) &&
canvas->paintCache() && !canvas->paintCache()->isNull() )
{
QPainter painter( ( QPixmap * )canvas->paintCache() );
painter.translate( -canvas->contentsRect().x(),
-canvas->contentsRect().y() );
renderItem( &painter, seriesItem, from, to );
if ( d_data->attributes & FullRepaint )
{
canvas->repaint();
return;
}
}
bool immediatePaint = true;
if ( !canvas->testAttribute( Qt::WA_WState_InPaintEvent ) &&
!canvas->testAttribute( Qt::WA_PaintOutsidePaintEvent ) )
{
immediatePaint = false;
}
if ( immediatePaint )
{
QwtPlotCanvas *canvas = seriesItem->plot()->canvas();
if ( !( d_data->painter.isActive() &&
d_data->painter.device() == canvas ) )
{
reset();
d_data->painter.begin( canvas );
d_data->painter.setClipping( true );
d_data->painter.setClipRect( canvas->contentsRect() );
canvas->installEventFilter( this );
}
renderItem( &d_data->painter, seriesItem, from, to );
if ( d_data->attributes & AtomicPainter )
reset();
}
else
{
reset();
d_data->seriesItem = seriesItem;
d_data->from = from;
d_data->to = to;
canvas->installEventFilter( this );
canvas->repaint();
canvas->removeEventFilter( this );
d_data->seriesItem = NULL;
}
}
