void KDecoration::clearMask()
{
bridge_->setMask(QRegion(), 0);
}
void tst_QGuiVariant::canConvert_data()
{
TST_QVARIANT_CANCONVERT_DATATABLE_HEADERS
#ifdef Y
#undef Y
#endif
#ifdef N
#undef N
#endif
#define Y true
#define N false
QVariant var;
// bita bitm bool brsh byta col curs date dt dbl font img int inv kseq list ll map pal pen pix pnt rect reg size sp str strl time uint ull
var = QVariant::fromValue(QBitmap());
QTest::newRow("Bitmap")
<< var << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N;
var = QVariant::fromValue(QBrush());
QTest::newRow("Brush")
<< var << N << N << N << Y << N << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N;
var = QVariant::fromValue(QColor());
QTest::newRow("Color")
<< var << N << N << N << Y << Y << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N;
#ifndef QTEST_NO_CURSOR
var = QVariant::fromValue(QCursor());
QTest::newRow("Cursor")
<< var << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N;
#endif
var = QVariant::fromValue(QFont());
QTest::newRow("Font")
<< var << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N;
var = QVariant::fromValue(QIcon());
QTest::newRow("Icon")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N;
var = QVariant::fromValue(QImage());
QTest::newRow("Image")
<< var << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N;
var = QVariant::fromValue(QKeySequence());
QTest::newRow("KeySequence")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << Y << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N;
var = QVariant::fromValue(QPalette());
QTest::newRow("Palette")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N << N;
var = QVariant::fromValue(QPen());
QTest::newRow("Pen")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N;
var = QVariant::fromValue(QPixmap());
QTest::newRow("Pixmap")
<< var << N << Y << N << Y << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N;
var = QVariant::fromValue(QPolygon());
QTest::newRow("PointArray")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N;
var = QVariant::fromValue(QRegion());
QTest::newRow("Region")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N;
#undef N
#undef Y
}
/*!
Draw the grid and axes
\param painter Painter
\param azimuthMap Maps azimuth values to values related to 0.0, M_2PI
\param radialMap Maps radius values into painter coordinates.
\param pole Position of the pole in painter coordinates
\param radius Radius of the complete plot area in painter coordinates
\param canvasRect Contents rect of the canvas in painter coordinates
*/
void QwtPolarGrid::draw( QPainter *painter,
const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,
const QPointF &pole, double radius,
const QRectF &canvasRect ) const
{
updateScaleDraws( azimuthMap, radialMap, pole, radius );
painter->save();
if ( testDisplayFlag( ClipAxisBackground ) )
{
QRegion clipRegion( canvasRect.toRect() );
for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ )
{
const AxisData &axis = d_data->axisData[axisId];
if ( axisId != QwtPolar::AxisAzimuth && axis.isVisible )
{
QwtScaleDraw *scaleDraw = static_cast<QwtScaleDraw *>( axis.scaleDraw );
if ( scaleDraw->hasComponent( QwtScaleDraw::Labels ) )
{
const QList<double> &ticks =
scaleDraw->scaleDiv().ticks( QwtScaleDiv::MajorTick );
for ( int i = 0; i < int( ticks.size() ); i++ )
{
if ( !scaleDraw->scaleDiv().contains( ticks[i] ) )
continue;
QRect labelRect =
scaleDraw->boundingLabelRect( axis.font, ticks[i] );
const int margin = 2;
labelRect.adjust( -margin, -margin, margin, margin );
if ( labelRect.isValid() )
clipRegion -= QRegion( labelRect );
}
}
}
}
painter->setClipRegion( clipRegion );
}
// draw radial grid
const GridData &radialGrid = d_data->gridData[QwtPolar::Radius];
if ( radialGrid.isVisible && radialGrid.isMinorVisible )
{
painter->setPen( radialGrid.minorPen );
drawCircles( painter, canvasRect, pole, radialMap,
radialGrid.scaleDiv.ticks( QwtScaleDiv::MinorTick ) );
drawCircles( painter, canvasRect, pole, radialMap,
radialGrid.scaleDiv.ticks( QwtScaleDiv::MediumTick ) );
}
if ( radialGrid.isVisible )
{
painter->setPen( radialGrid.majorPen );
drawCircles( painter, canvasRect, pole, radialMap,
radialGrid.scaleDiv.ticks( QwtScaleDiv::MajorTick ) );
}
// draw azimuth grid
const GridData &azimuthGrid =
d_data->gridData[QwtPolar::Azimuth];
if ( azimuthGrid.isVisible && azimuthGrid.isMinorVisible )
{
painter->setPen( azimuthGrid.minorPen );
drawRays( painter, canvasRect, pole, radius, azimuthMap,
azimuthGrid.scaleDiv.ticks( QwtScaleDiv::MinorTick ) );
drawRays( painter, canvasRect, pole, radius, azimuthMap,
azimuthGrid.scaleDiv.ticks( QwtScaleDiv::MediumTick ) );
}
if ( azimuthGrid.isVisible )
{
painter->setPen( azimuthGrid.majorPen );
drawRays( painter, canvasRect, pole, radius, azimuthMap,
azimuthGrid.scaleDiv.ticks( QwtScaleDiv::MajorTick ) );
}
painter->restore();
for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ )
{
const AxisData &axis = d_data->axisData[axisId];
if ( axis.isVisible )
{
painter->save();
drawAxis( painter, axisId );
painter->restore();
}
}
}
QRegion PlastikClient::cornerShape(WindowCorner corner)
{
int w = widget()->width();
int h = widget()->height();
switch (corner) {
case WC_TopLeft:
if (layoutMetric(LM_TitleEdgeLeft) > 0)
return QRegion(0, 0, 1, 2) + QRegion(1, 0, 1, 1);
else
return QRegion();
case WC_TopRight:
if (layoutMetric(LM_TitleEdgeRight) > 0)
return QRegion(w-1, 0, 1, 2) + QRegion(w-2, 0, 1, 1);
else
return QRegion();
case WC_BottomLeft:
if (layoutMetric(LM_BorderBottom) > 0)
return QRegion(0, h-1, 1, 1);
else
return QRegion();
case WC_BottomRight:
if (layoutMetric(LM_BorderBottom) > 0)
return QRegion(w-1, h-1, 1, 1);
else
return QRegion();
default:
return QRegion();
}
}
QRegion Popup::arrow_region() const
{
return QRegion(arrow_polygon());
}
MiniSplitterHandle(Qt::Orientation orientation, QSplitter *parent)
: QSplitterHandle(orientation, parent)
{
setMask(QRegion(contentsRect()));
setAttribute(Qt::WA_MouseNoMask, true);
}
void RoutingToolTip::maybeTip(const QPoint &p)
{
RoutingDrawWidget *drawWidget = (RoutingDrawWidget *)parentWidget();
RoutingWidget *parent = (RoutingWidget *)drawWidget->parentWidget();
StrGlobal *structure = parent->getStructure();
if (!structure)
return;
int i, j;
// find object under cursor
int xp = p.x();
int yp = p.y();
drawWidget->viewportToContents(xp, yp, xp, yp);
xp = parent->deZoomVal(xp);
yp = parent->deZoomVal(yp);
RSItemBaseWithType *item;
for(item = structure->UsedItems.first(); item; item = structure->UsedItems.next())
{
if (item->containsPoint(xp, yp))
{
int ix;
int iy;
int iw;
int ih;
QString tipText = "";
StrInput *in = NULL;
StrOutput *out = NULL;
StrFX *fx = NULL;
StrPatch *patch = NULL;
ix = item->x();
iy = item->y();
iw = item->width();
ih = item->height();
RSItemIO *pio = NULL;
switch(item->type())
{
case RSItemBaseWithType::In:
in = (StrInput *)item;
tipText = QString("Input: %1\nName: %2").arg(in->num()).arg(in->name());
break;
case RSItemBaseWithType::Out:
out = (StrOutput *)item;
tipText = QString("Output: %1\nName: %2").arg(out->num()).arg(out->name());
break;
case RSItemBaseWithType::FX:
fx = (StrFX *)item;
tipText = QString("FX: %1\nName: %2").arg(fx->num()).arg(fx->name());
break;
case RSItemBaseWithType::Patch:
patch = (StrPatch *)item;
pio = patch->getIOAtPoint(xp, yp);
if (pio)
{
if (pio->isOutput())
tipText = QString("Patch output: %1\nOutput name: %2\n\n").arg(pio->getIdx()).arg(pio->getDesc());
else
tipText = QString("Patch input: %1\nInput name: %2\n\n").arg(pio->getIdx()).arg(pio->getDesc());
QRect r;
patch->getIORect(pio->isOutput(), pio->getIdx(), r);
ix = r.x();
iy = r.y();
iw = r.width();
ih = r.height();
}
else
{
// create region without ios
QRegion reg(ix, iy, iw, ih);
QRect ior;
for (j = 0; j < 2; j++)
{
for (i = 0; i < patch->getMaxIOIdx(j); i++)
{
patch->getIORect(j, i, ior);
reg = reg.subtract(QRegion(ior));
}
}
// find rect with point
QMemArray<QRect> rects = reg.rects();
for (i = 0; i < (int)rects.count(); i++)
{
if (rects[i].contains(xp, yp))
{
ix = rects[i].x();
iy = rects[i].y();
iw = rects[i].width();
ih = rects[i].height();
break;
}
}
}
tipText = tipText + QString("Patch: %1\nOrder: %2\nName: %3").arg(patch->num()).arg(patch->order()).arg(patch->name());
break;
default:
break;
}
if (tipText != "")
{
ix = parent->zoomVal(ix);
iy = parent->zoomVal(iy);
iw = parent->zoomVal(iw);
ih = parent->zoomVal(ih);
drawWidget->contentsToViewport(ix, iy, ix, iy);
tip(QRect(ix, iy, iw, ih), tipText);
}
}
}
}
void DiagramCanvas::paint_all( QRect& r )
{
int i;
QPainter p( &buffer );
QPen pen;
QBrush brush;
QPointArray a;
QColor color;
QRegion mask, crossing_disk;
set<double>::iterator dbl_it;
for ( i=0; i<crossingList.size(); ++i )
{
Crossing *c = crossingList[i];
c->under->underpasses.insert( c->under->underpasses.end(), c->position_on_understrand );
}
for ( i=0; i<edgeList.size(); ++i )
{
Edge *e = edgeList[i];
pen.setWidth( e->thickness );
pen.setColor( CANVAS );
p.setPen( pen );
QPoint v, v1, v2, p1, p2 ;
p1 = e->vertex[begin]->position;
p2 = e->vertex[end]->position;
p.drawLine( p1, p2 );
/*
if (e->edge_type==singular)
{
v = p1 - p2;
v1.setX( v.x() - v.y() );
v1.setY( v.x() + v.y() );
v2.setX( v.x() + v.y() );
v2.setY( -v.x() + v.y() );
v1 = 5 * v1 / sqrt( double (v1.x() * v1.x() + v1.y() * v1.y()) );
v2 = 5 * v2 / sqrt( double (v2.x() * v2.x() + v2.y() * v2.y()) );
v = v / 2;
pen.setWidth( ARROW );
p.setPen( pen );
p.drawLine( p2+v, p2+v1+v );
p.drawLine( p2+v, p2+v2+v );
}
*/
}
for ( i=0; i<edgeList.size(); ++i )
{
Edge *e = edgeList[i];
color = (e->edge_type == drilled) ? DRILLED : colorList[e->arc_id % 18 ];
pen.setWidth( e->thickness );
pen.setColor( color );
p.setPen( pen );
brush.setColor( color );
brush.setStyle( SolidPattern );
p.setBrush( brush );
if ( e->underpasses.size() > 0 )
{
p.setClipping( TRUE );
mask = QRegion( 0, 0, width(), height(), QRegion::Rectangle );
for ( dbl_it=e->underpasses.begin(); dbl_it!=e->underpasses.end(); ++dbl_it )
{
QPoint center = time_to_point( e, *dbl_it );
crossing_disk = QRegion( center.x()-7, center.y()-7, 14, 14 , QRegion::Ellipse );
mask -= crossing_disk;
}
p.setClipRegion( mask );
QPoint v, v1, v2, p1, p2 ;
p1 = e->vertex[begin]->position;
p2 = e->vertex[end]->position;
p.drawLine( p1, p2 );
/*
if (e->edge_type==singular)
{
v = p1 - p2;
v1.setX( v.x() - v.y() );
v1.setY( v.x() + v.y() );
v2.setX( v.x() + v.y() );
v2.setY( -v.x() + v.y() );
v1 = 5 * v1 / sqrt( double (v1.x() * v1.x() + v1.y() * v1.y()) );
v2 = 5 * v2 / sqrt( double (v2.x() * v2.x() + v2.y() * v2.y()) );
v = v / 2;
pen.setWidth( ARROW );
p.setPen( pen );
p.drawLine( p2+v, p2+v1+v );
p.drawLine( p2+v, p2+v2+v );
}
*/
p.setClipping( FALSE );
}
else
{
QPoint v, v1, v2, p1, p2 ;
p1 = e->vertex[begin]->position;
p2 = e->vertex[end]->position;
p.drawLine( p1, p2 );
/*
if (e->edge_type==singular)
{
v = p1 - p2;
v1.setX( v.x() - v.y() );
v1.setY( v.x() + v.y() );
v2.setX( v.x() + v.y() );
v2.setY( -v.x() + v.y() );
v1 = 5 * v1 / sqrt( double (v1.x() * v1.x() + v1.y() * v1.y()) );
v2 = 5 * v2 / sqrt( double (v2.x() * v2.x() + v2.y() * v2.y()) );
v = v / 2;
pen.setWidth( ARROW );
p.setPen( pen );
p.drawLine( p2+v, p2+v1+v );
p.drawLine( p2+v, p2+v2+v );
}
*/
}
e->underpasses.clear();
}
p.end();
bitBlt( this, r.x(), r.y(), &buffer, r.x(), r.y(), r.width(), r.height() );
}
void Deck::applyShapeMask( void )
{
QRegion mask(0, 0, width(), height());
int r(width());
int b(height());
// Remove top-left corner.
if (_shapeMask & TopLeft)
{
mask -= QRegion(0, 0, 5, 1);
mask -= QRegion(0, 1, 3, 1);
mask -= QRegion(0, 2, 2, 1);
mask -= QRegion(0, 3, 1, 2);
}
// Remove top-right corner.
if (_shapeMask & TopRight)
{
mask -= QRegion(r - 5, 0, 5, 1);
mask -= QRegion(r - 3, 1, 3, 1);
mask -= QRegion(r - 2, 2, 2, 1);
mask -= QRegion(r - 1, 3, 1, 2);
}
// Remove bottom-left corner.
if (_shapeMask & BottomLeft)
{
mask -= QRegion(0, b - 5, 1, 3);
mask -= QRegion(0, b - 3, 2, 1);
mask -= QRegion(0, b - 2, 3, 1);
mask -= QRegion(0, b - 1, 5, 1);
}
// Remove bottom-right corner.
if (_shapeMask & BottomRight)
{
mask -= QRegion(r - 5, b - 1, 5, 1);
mask -= QRegion(r - 3, b - 2, 3, 1);
mask -= QRegion(r - 2, b - 3, 2, 1);
mask -= QRegion(r - 1, b - 5, 1, 2);
}
setMask(mask);
/*
now that the edge state has changed, make all cards in this
deck repaint. They'll read the adjacentEdge() property to
figure this stuff out.
*/
if (mask != _currentMask)
{
int cCount = count();
for (int i = 0; i < cCount; i++)
{
Card *c = cardAt(i);
if (c) c->repaintElements();
}
}
_currentMask = mask;
}
void QAlphaPaintEngine::flushAndInit(bool init)
{
Q_D(QAlphaPaintEngine);
Q_ASSERT(d->m_pass == 0);
if (d->m_pic) {
d->m_picpainter->end();
// set clip region
d->m_alphargn = d->m_alphargn.intersected(QRect(0, 0, d->m_pdev->width(), d->m_pdev->height()));
// just use the bounding rect if it's a complex region..
QVector<QRect> rects = d->m_alphargn.rects();
if (rects.size() > 10) {
QRect br = d->m_alphargn.boundingRect();
d->m_alphargn = QRegion(br);
rects.clear();
rects.append(br);
}
d->m_cliprgn = d->m_alphargn;
// now replay the QPicture
++d->m_pass; // we are now doing pass #2
// reset states
gccaps = d->m_savedcaps;
painter()->save();
d->resetState(painter());
// make sure the output from QPicture is unscaled
QTransform mtx;
mtx.scale(1.0f / (qreal(d->m_pdev->logicalDpiX()) / qreal(qt_defaultDpiX())),
1.0f / (qreal(d->m_pdev->logicalDpiY()) / qreal(qt_defaultDpiY())));
painter()->setTransform(mtx);
painter()->drawPicture(0, 0, *d->m_pic);
d->m_cliprgn = QRegion();
d->resetState(painter());
// fill in the alpha images
for (int i=0; i<rects.size(); ++i)
d->drawAlphaImage(rects.at(i));
d->m_alphargn = QRegion();
painter()->restore();
--d->m_pass; // pass #2 finished
cleanUp();
}
if (init) {
gccaps = PaintEngineFeatures(AllFeatures & ~QPaintEngine::ObjectBoundingModeGradients);
d->m_pic = new QPicture();
d->m_pic->d_ptr->in_memory_only = true;
d->m_picpainter = new QPainter(d->m_pic);
d->m_picengine = d->m_picpainter->paintEngine();
// When newPage() is called and the m_picpainter is recreated
// we have to copy the current state of the original printer
// painter back to the m_picpainter
d->m_picpainter->setPen(painter()->pen());
d->m_picpainter->setBrush(painter()->brush());
d->m_picpainter->setBrushOrigin(painter()->brushOrigin());
d->m_picpainter->setFont(painter()->font());
d->m_picpainter->setOpacity(painter()->opacity());
d->m_picpainter->setTransform(painter()->combinedTransform());
d->m_picengine->syncState();
QPainterState &state = *d->m_picpainter->d_func()->state;
QPainter *oldPainter = state.painter;
state = *painter()->d_func()->state;
state.painter = oldPainter;
}
}
QRegion
PartitionBarsView::visualRegionForSelection( const QItemSelection& selection ) const
{
return QRegion();
}
void QSGSoftwareRenderLoop::renderWindow(QQuickWindow *window, bool isNewExpose)
{
QQuickWindowPrivate *cd = QQuickWindowPrivate::get(window);
if (!m_windows.contains(window))
return;
WindowData &data = const_cast<WindowData &>(m_windows[window]);
//If were not in grabOnly mode, dont render a non-renderable window
if (!data.grabOnly && !cd->isRenderable())
return;
//Resize the backing store if necessary
if (m_backingStores[window]->size() != window->size()) {
m_backingStores[window]->resize(window->size());
}
// ### create QPainter and set up pointer to current window/painter
QSGSoftwareRenderContext *ctx = static_cast<QSGSoftwareRenderContext*>(cd->context);
ctx->initializeIfNeeded();
bool alsoSwap = data.updatePending;
data.updatePending = false;
if (!data.grabOnly) {
cd->flushFrameSynchronousEvents();
// Event delivery/processing triggered the window to be deleted or stop rendering.
if (!m_windows.contains(window))
return;
}
QElapsedTimer renderTimer;
qint64 renderTime = 0, syncTime = 0, polishTime = 0;
bool profileFrames = QSG_RASTER_LOG_TIME_RENDERLOOP().isDebugEnabled();
if (profileFrames)
renderTimer.start();
Q_QUICK_SG_PROFILE_START(QQuickProfiler::SceneGraphPolishFrame);
cd->polishItems();
if (profileFrames)
polishTime = renderTimer.nsecsElapsed();
Q_QUICK_SG_PROFILE_SWITCH(QQuickProfiler::SceneGraphPolishFrame,
QQuickProfiler::SceneGraphRenderLoopFrame,
QQuickProfiler::SceneGraphPolishPolish);
emit window->afterAnimating();
cd->syncSceneGraph();
rc->endSync();
if (profileFrames)
syncTime = renderTimer.nsecsElapsed();
Q_QUICK_SG_PROFILE_RECORD(QQuickProfiler::SceneGraphRenderLoopFrame,
QQuickProfiler::SceneGraphRenderLoopSync);
//Tell the renderer about the windows backing store
auto softwareRenderer = static_cast<QSGSoftwareRenderer*>(cd->renderer);
if (softwareRenderer)
softwareRenderer->setBackingStore(m_backingStores[window]);
cd->renderSceneGraph(window->size());
if (profileFrames)
renderTime = renderTimer.nsecsElapsed();
Q_QUICK_SG_PROFILE_RECORD(QQuickProfiler::SceneGraphRenderLoopFrame,
QQuickProfiler::SceneGraphRenderLoopRender);
if (data.grabOnly) {
grabContent = m_backingStores[window]->handle()->toImage();
data.grabOnly = false;
}
if (alsoSwap && window->isVisible()) {
//Flush backingstore to window
if (!isNewExpose)
m_backingStores[window]->flush(softwareRenderer->flushRegion());
else
m_backingStores[window]->flush(QRegion(QRect(QPoint(0,0), window->size())));
cd->fireFrameSwapped();
}
qint64 swapTime = 0;
if (profileFrames)
swapTime = renderTimer.nsecsElapsed();
Q_QUICK_SG_PROFILE_END(QQuickProfiler::SceneGraphRenderLoopFrame,
QQuickProfiler::SceneGraphRenderLoopSwap);
if (QSG_RASTER_LOG_TIME_RENDERLOOP().isDebugEnabled()) {
static QTime lastFrameTime = QTime::currentTime();
qCDebug(QSG_RASTER_LOG_TIME_RENDERLOOP,
"Frame rendered with 'software' renderloop in %dms, polish=%d, sync=%d, render=%d, swap=%d, frameDelta=%d",
int(swapTime / 1000000),
int(polishTime / 1000000),
int((syncTime - polishTime) / 1000000),
int((renderTime - syncTime) / 1000000),
int((swapTime - renderTime) / 10000000),
int(lastFrameTime.msecsTo(QTime::currentTime())));
lastFrameTime = QTime::currentTime();
}
// Might have been set during syncSceneGraph()
if (data.updatePending)
maybeUpdate(window);
}
QRegion TilePainter::computeFillRegion(const QPoint &fillOrigin) const {
//create that region that will hold the fill
QRegion fillRegion;
//silently quit if parameters are unsatisfactory
if (!isDrawable(fillOrigin.x(), fillOrigin.y()))
return fillRegion;
//cache cell that we will match other cells against
const Cell matchCell = cellAt(fillOrigin.x(), fillOrigin.y());
//grab map dimensions for later use.
const int mapWidth = mMapEditor->map()->width();
const int mapHeight = mMapEditor->map()->height();
const int mapSize = mapWidth * mapHeight;
//create a queue to hold cells that need filling
QList<QPoint> fillPositions;
fillPositions.append(fillOrigin);
qDebug() << "fix " << fillPositions.at(0).x();
qDebug() << "fiy " << fillPositions.at(0).y();
//create an array that will store which cells have been processed
//this is faster than checking if a given cell is in the region/list
QVector<quint8> processedCellsVec(mapSize);
quint8 *processedCells = processedCellsVec.data();
//loop through queued positions and fill them, while at the same time
//checking adjacent positions to see if they should be added
while (!fillPositions.isEmpty()) {
for (int i = 0; i < fillPositions.size(); ++i) {
qDebug() << "fx " << fillPositions.at(i).x();
qDebug() << "fy " << fillPositions.at(i).y();
}
const QPoint currentPoint = fillPositions.takeFirst();
//qDebug() << "cpx" << currentPoint.x();
//qDebug() << "cpy" << currentPoint.y();
const int startOfLine = currentPoint.y() * mapWidth;
//seek as far left as we can
int left = currentPoint.x();
while (cellAt(left - 1, currentPoint.y()) == matchCell &&
isDrawable(left - 1, currentPoint.y()))
--left;
//seek as far right as we can
int right = currentPoint.x();
while (cellAt(right + 1, currentPoint.y()) == matchCell &&
isDrawable(right + 1, currentPoint.y()))
++right;
qDebug() << left;
//add cells between left and right to the region
fillRegion += QRegion(left, currentPoint.y(), right - left + 1, 1);
//add cell strip to processed cells
memset(&processedCells[startOfLine + left],
1,
right - left);
//these variables cache whether the last cell was added to the queue
//or not as an optimization, since adjacent cells on the x axis
//do not need to be added to the queue.
bool lastAboveCell = false;
bool lastBelowCell = false;
//loop between left and right and check if cells above or
//below need to be added to the queue
for (int x = left; x <= right; ++x) {
const QPoint fillPoint(x, currentPoint.y());
//check cell above
if (fillPoint.y() > 0) {
QPoint aboveCell(fillPoint.x(), fillPoint.y() - 1);
if (!processedCells[aboveCell.y() * mapWidth + aboveCell.x()] &&
cellAt(aboveCell.x(), aboveCell.y()) == matchCell &&
isDrawable(aboveCell.x(), aboveCell.y()))
{
//do not add the above cell to the queue if its
//x-adjacent cell was added.
if (!lastAboveCell)
fillPositions.append(aboveCell);
lastAboveCell = true;
} else lastAboveCell = false;
processedCells[aboveCell.y() * mapWidth + aboveCell.x()] = 1;
}
//check cell below
if (fillPoint.y() + 1 < mapHeight) {
QPoint belowCell(fillPoint.x(), fillPoint.y() + 1);
if (!processedCells[belowCell.y()*mapWidth + belowCell.x()] &&
cellAt(belowCell.x(), belowCell.y()) == matchCell &&
isDrawable(belowCell.x(), belowCell.y()))
{
//do not add the below cell to the queue if its
//x-adjacent cell was added.
if (!lastBelowCell)
fillPositions.append(belowCell);
lastBelowCell = true;
} else lastBelowCell = false;
processedCells[belowCell.y() * mapWidth + belowCell.x()] = 1;
}
}
}
return fillRegion;
}
/*!
\brief Adjust plot content to its current size.
\sa resizeEvent()
*/
void QwtPlot::updateLayout()
{
d_data->layout->activate( this, contentsRect() );
QRect titleRect = d_data->layout->titleRect().toRect();
QRect scaleRect[QwtPlot::axisCnt];
for ( int axisId = 0; axisId < axisCnt; axisId++ )
scaleRect[axisId] = d_data->layout->scaleRect( axisId ).toRect();
QRect legendRect = d_data->layout->legendRect().toRect();
QRect canvasRect = d_data->layout->canvasRect().toRect();
// resize and show the visible widgets
if ( !d_data->titleLabel->text().isEmpty() )
{
d_data->titleLabel->setGeometry( titleRect );
if ( !d_data->titleLabel->isVisibleTo( this ) )
d_data->titleLabel->show();
}
else
d_data->titleLabel->hide();
for ( int axisId = 0; axisId < axisCnt; axisId++ )
{
if ( axisEnabled( axisId ) )
{
axisWidget( axisId )->setGeometry( scaleRect[axisId] );
#if 1
if ( axisId == xBottom || axisId == xTop )
{
// do we need this code any longer ???
QRegion r( scaleRect[axisId] );
if ( axisEnabled( yLeft ) )
r = r.subtract( QRegion( scaleRect[yLeft] ) );
if ( axisEnabled( yRight ) )
r = r.subtract( QRegion( scaleRect[yRight] ) );
r.translate( -scaleRect[ axisId ].x(),
-scaleRect[axisId].y() );
axisWidget( axisId )->setMask( r );
}
#endif
if ( !axisWidget( axisId )->isVisibleTo( this ) )
axisWidget( axisId )->show();
}
else
axisWidget( axisId )->hide();
}
if ( d_data->legend &&
d_data->layout->legendPosition() != ExternalLegend )
{
if ( d_data->legend->itemCount() > 0 )
{
d_data->legend->setGeometry( legendRect );
d_data->legend->show();
}
else
d_data->legend->hide();
}
d_data->canvas->setGeometry( canvasRect );
}
QRegion KDecoration::region(KDecorationDefines::Region)
{
return QRegion();
}
/*!
\since 4.2
Returns the reserved region.
\sa reserveRegion(), frameBuffer()
\obsolete
Use allocatedRegion() instead.
*/
QRegion QDirectPainter::reservedRegion()
{
return QDirectPainterPrivate::staticPainter
? QDirectPainterPrivate::staticPainter->allocatedRegion() : QRegion();
}
/*!
\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(
QwtPlotSeriesItem *seriesItem, int from, int to )
{
if ( seriesItem == NULL || seriesItem->plot() == NULL )
return;
QWidget *canvas = seriesItem->plot()->canvas();
const QRect canvasRect = canvas->contentsRect();
QwtPlotCanvas *plotCanvas = qobject_cast<QwtPlotCanvas *>( canvas );
if ( plotCanvas && qwtHasBackingStore( plotCanvas ) )
{
QPainter painter( const_cast<QPixmap *>( plotCanvas->backingStore() ) );
if ( d_data->hasClipping )
painter.setClipRegion( d_data->clipRegion );
qwtRenderItem( &painter, canvasRect, seriesItem, from, to );
painter.end();
if ( testAttribute( QwtPlotDirectPainter::FullRepaint ) )
{
plotCanvas->repaint();
return;
}
}
bool immediatePaint = true;
if ( !canvas->testAttribute( Qt::WA_WState_InPaintEvent ) )
{
#if QT_VERSION < 0x050000
if ( !canvas->testAttribute( Qt::WA_PaintOutsidePaintEvent ) )
#endif
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 );
}
qwtRenderItem( &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;
}
}
/*!
Returns the region specified by \a decorationRegion for the
top-level \a widget. \a rect specifies the rectangle the decoration
wraps. The value of \a decorationRegion is a combination of the
bitmask values of enum DecorationRegion.
*/
QRegion QDecorationDefault::region(const QWidget *widget,
const QRect &rect,
int decorationRegion)
{
Qt::WindowFlags flags = widget->windowFlags();
bool hasBorder = !widget->isMaximized();
bool hasTitle = flags & Qt::WindowTitleHint;
bool hasSysMenu = flags & Qt::WindowSystemMenuHint;
bool hasContextHelp = flags & Qt::WindowContextHelpButtonHint;
bool hasMinimize = flags & Qt::WindowMinimizeButtonHint;
bool hasMaximize = flags & Qt::WindowMaximizeButtonHint;
int state = widget->windowState();
bool isMinimized = state & Qt::WindowMinimized;
bool isMaximized = state & Qt::WindowMaximized;
int titleHeight = hasTitle ? titleBarHeight(widget) : 0;
int bw = hasBorder ? BORDER_WIDTH : 0;
int bbw = hasBorder ? BOTTOM_BORDER_WIDTH : 0;
QRegion region;
switch (decorationRegion) {
case All: {
QRect r(rect.left() - bw,
rect.top() - titleHeight - bw,
rect.width() + 2 * bw,
rect.height() + titleHeight + bw + bbw);
region = r;
region -= rect;
}
break;
case Title: {
QRect r(rect.left()
+ (hasSysMenu ? menu_width : 0),
rect.top() - titleHeight,
rect.width()
- (hasSysMenu ? menu_width : 0)
- close_width
- (hasMaximize ? maximize_width : 0)
- (hasMinimize ? minimize_width : 0)
- (hasContextHelp ? help_width : 0),
titleHeight);
if (r.width() > 0)
region = r;
}
break;
case Top: {
QRect r(rect.left() + CORNER_GRAB,
rect.top() - titleHeight - bw,
rect.width() - 2 * CORNER_GRAB,
bw);
region = r;
}
break;
case Left: {
QRect r(rect.left() - bw,
rect.top() - titleHeight + CORNER_GRAB,
bw,
rect.height() + titleHeight - 2 * CORNER_GRAB);
region = r;
}
break;
case Right: {
QRect r(rect.right() + 1,
rect.top() - titleHeight + CORNER_GRAB,
bw,
rect.height() + titleHeight - 2 * CORNER_GRAB);
region = r;
}
break;
case Bottom: {
QRect r(rect.left() + CORNER_GRAB,
rect.bottom() + 1,
rect.width() - 2 * CORNER_GRAB,
bw);
region = r;
}
break;
case TopLeft: {
QRect r1(rect.left() - bw,
rect.top() - bw - titleHeight,
CORNER_GRAB + bw,
bw);
QRect r2(rect.left() - bw,
rect.top() - bw - titleHeight,
bw,
CORNER_GRAB + bw);
region = QRegion(r1) + r2;
}
break;
case TopRight: {
QRect r1(rect.right() - CORNER_GRAB,
rect.top() - bw - titleHeight,
CORNER_GRAB + bw,
bw);
QRect r2(rect.right() + 1,
rect.top() - bw - titleHeight,
bw,
CORNER_GRAB + bw);
region = QRegion(r1) + r2;
}
break;
case BottomLeft: {
QRect r1(rect.left() - bw,
rect.bottom() + 1,
CORNER_GRAB + bw,
bw);
QRect r2(rect.left() - bw,
rect.bottom() - CORNER_GRAB,
bw,
CORNER_GRAB + bw);
region = QRegion(r1) + r2;
}
break;
case BottomRight: {
QRect r1(rect.right() - CORNER_GRAB,
rect.bottom() + 1,
CORNER_GRAB + bw,
bw);
QRect r2(rect.right() + 1,
rect.bottom() - CORNER_GRAB,
bw,
CORNER_GRAB + bw);
region = QRegion(r1) + r2;
}
break;
case Menu: {
if (hasSysMenu) {
region = QRect(rect.left(), rect.top() - titleHeight,
menu_width, titleHeight);
}
}
break;
case Help: {
if (hasContextHelp) {
QRect r(rect.right()
- close_width
- (hasMaximize ? maximize_width : 0)
- (hasMinimize ? minimize_width : 0)
- help_width + 1, rect.top() - titleHeight,
help_width, titleHeight);
if (r.left() > rect.left() + titleHeight)
region = r;
}
}
break;
case Minimize: {
if (hasMinimize && !isMinimized) {
QRect r(rect.right() - close_width
- (hasMaximize ? maximize_width : 0)
- minimize_width + 1, rect.top() - titleHeight,
minimize_width, titleHeight);
if (r.left() > rect.left() + titleHeight)
region = r;
}
}
break;
case Maximize: {
if (hasMaximize && !isMaximized) {
QRect r(rect.right() - close_width - maximize_width + 1,
rect.top() - titleHeight, maximize_width, titleHeight);
if (r.left() > rect.left() + titleHeight)
region = r;
}
}
break;
case Normalize: {
if (hasMinimize && isMinimized) {
QRect r(rect.right() - close_width
- (hasMaximize ? maximize_width : 0)
- minimize_width + 1, rect.top() - titleHeight,
minimize_width, titleHeight);
if (r.left() > rect.left() + titleHeight)
region = r;
} else if (hasMaximize && isMaximized) {
QRect r(rect.right() - close_width - maximize_width + 1,
rect.top() - titleHeight, maximize_width, titleHeight);
if (r.left() > rect.left() + titleHeight)
region = r;
}
}
break;
case Close: {
QRect r(rect.right() - close_width + 1, rect.top() - titleHeight,
close_width, titleHeight);
if (r.left() > rect.left() + titleHeight)
region = r;
}
break;
default: {
int i = 1;
while (i) {
if (i & decorationRegion)
region += this->region(widget, rect, i);
i <<= 1;
}
}
break;
}
return region;
}
void QwtPicker::PickerWidget::updateMask()
{
QRegion mask;
if ( d_type == RubberBand )
{
QBitmap bm( width(), height() );
bm.fill( Qt::color0 );
QPainter painter( &bm );
QPen pen = d_picker->rubberBandPen();
pen.setColor( Qt::color1 );
painter.setPen( pen );
d_picker->drawRubberBand( &painter );
mask = QRegion( bm );
}
if ( d_type == Text )
{
d_hasTextMask = parentWidget()->testAttribute( Qt::WA_PaintOnScreen );
if ( d_hasTextMask )
{
const QwtText label = d_picker->trackerText(
d_picker->trackerPosition() );
if ( label.testPaintAttribute( QwtText::PaintBackground )
&& label.backgroundBrush().style() != Qt::NoBrush )
{
if ( label.backgroundBrush().color().alpha() > 0 )
{
// We don't need a text mask, when we have a background
d_hasTextMask = false;
}
}
}
if ( d_hasTextMask )
{
QBitmap bm( width(), height() );
bm.fill( Qt::color0 );
QPainter painter( &bm );
painter.setFont( font() );
QPen pen = d_picker->trackerPen();
pen.setColor( Qt::color1 );
painter.setPen( pen );
d_picker->drawTracker( &painter );
mask = QRegion( bm );
}
else
{
mask = d_picker->trackerRect( font() );
}
}
QWidget *w = parentWidget();
if ( w && !w->testAttribute( Qt::WA_PaintOnScreen ) )
{
// The parent widget gets an update for its complete rectangle
// when the mask is changed in visible state.
// With this hide/show we only get an update for the
// previous mask.
hide();
}
setMask( mask );
setVisible( !mask.isEmpty() );
}
void NotifyQt::runningTick()
{
//QMutexLocker lock(&runningToasterMutex);
int interval = runningToasterTimer->interval();
QPoint diff;
QList<ToasterItem*>::iterator it = runningToasterList.begin();
while (it != runningToasterList.end()) {
ToasterItem *toaster = *it;
bool visible = true;
if (toaster->elapsedTimeToShow) {
/* Toaster is started, check for visible */
visible = toaster->widget->isVisible();
}
QPoint newPos;
enum { NOTHING, SHOW, HIDE } operation = NOTHING;
if (visible && toaster->elapsedTimeToShow <= toaster->timeToShow) {
/* Toaster is showing */
if (toaster->elapsedTimeToShow == 0) {
/* Toaster is not visible, show it now */
operation = SHOW;
}
toaster->elapsedTimeToShow += interval;
newPos = QPoint(toaster->startPos.x() - (toaster->startPos.x() - toaster->endPos.x()) * toaster->elapsedTimeToShow / toaster->timeToShow,
toaster->startPos.y() - (toaster->startPos.y() - toaster->endPos.y()) * toaster->elapsedTimeToShow / toaster->timeToShow);
} else if (visible && toaster->elapsedTimeToLive <= toaster->timeToLive) {
/* Toaster is living */
toaster->elapsedTimeToLive += interval;
newPos = toaster->endPos;
} else if (visible && toaster->elapsedTimeToHide <= toaster->timeToHide) {
/* Toaster is hiding */
toaster->elapsedTimeToHide += interval;
if (toaster->elapsedTimeToHide == toaster->timeToHide) {
/* Toaster is back at the start position, hide it */
operation = HIDE;
}
newPos = QPoint(toaster->startPos.x() - (toaster->startPos.x() - toaster->endPos.x()) * (toaster->timeToHide - toaster->elapsedTimeToHide) / toaster->timeToHide,
toaster->startPos.y() - (toaster->startPos.y() - toaster->endPos.y()) * (toaster->timeToHide - toaster->elapsedTimeToHide) / toaster->timeToHide);
} else {
/* Toaster is hidden, delete it */
it = runningToasterList.erase(it);
//delete(toaster->widget);
delete(toaster);
continue;
}
toaster->widget->move(newPos + diff);
diff += newPos - toaster->startPos;
QRect mask = QRect(0, 0, toaster->widget->width(), qAbs(toaster->startPos.y() - newPos.y()));
if (newPos.y() > toaster->startPos.y()) {
/* Toaster is moving from top */
mask.moveTop(toaster->widget->height() - (newPos.y() - toaster->startPos.y()));
}
toaster->widget->setMask(QRegion(mask));
switch (operation) {
case NOTHING:
break;
case SHOW:
toaster->widget->show();
break;
case HIDE:
toaster->widget->hide();
break;
}
++it;
}
if (runningToasterList.size()) {
/* There are more running toasters, start the timer again */
runningToasterTimer->start();
}
}