void MouseHoverable::DrawMouseHoverRect(QPainter &painter) const
{
    qreal old = painter.opacity();
    painter.setOpacity(m_alpha);
    painter.fillRect(m_composite->rect(), m_mouseOverColor);
    painter.setOpacity(old);
}
示例#2
0
//-----------------------------------------------------------------------------
//! 
//-----------------------------------------------------------------------------
void tBoatWidget::DrawBoat( QPainter& painter )
{
    painter.save();

    // Draw boat
    QColor color;
    if( tSystemSettings::Instance()->NightMode() )
    {
        color = Qt::white;
        painter.setOpacity(0.2);
    }
    else
    {
        color = Qt::black;
        painter.setOpacity(0.5);
    }

    painter.setPen(QPen(color, 6, Qt::SolidLine, Qt::SquareCap, Qt::MiterJoin));
    painter.translate(QPointF((width()/2.0)+0.5, 15.0));
    QPainterPath p;

    p.moveTo( 28, 146 );
    p.cubicTo(  34, 90,  44, 70, 0, 0 );
    p.cubicTo( -44, 70, -34, 90, -28, 146 );
    p.lineTo( 28, 146 );

    painter.drawPath(p);

    painter.restore();
}
示例#3
0
void TextureMapperQt::drawTexture(const BitmapTexture& texture, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity, const BitmapTexture* maskTexture)
{
    const BitmapTextureQt& textureQt = static_cast<const BitmapTextureQt&>(texture);
    QPainter* painter = m_painter;
    QPixmap pixmap = textureQt.m_pixmap;
    if (m_currentSurface)
        painter = &m_currentSurface->m_painter;

    if (maskTexture && maskTexture->isValid()) {
        const BitmapTextureQt* mask = static_cast<const BitmapTextureQt*>(maskTexture);
        QPixmap intermediatePixmap(pixmap.size());
        intermediatePixmap.fill(Qt::transparent);
        QPainter maskPainter(&intermediatePixmap);
        maskPainter.setCompositionMode(QPainter::CompositionMode_Source);
        maskPainter.drawPixmap(0, 0, pixmap);
        maskPainter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
        maskPainter.drawPixmap(QRect(0, 0, pixmap.width(), pixmap.height()), mask->m_pixmap, mask->sourceRect());
        maskPainter.end();
        pixmap = intermediatePixmap;
    }

    const qreal prevOpacity = painter->opacity();
    const QTransform prevTransform = painter->transform();
    painter->setOpacity(opacity);
    painter->setTransform(matrix, true);
    painter->drawPixmap(targetRect, pixmap, FloatRect(textureQt.sourceRect()));
    painter->setTransform(prevTransform);
    painter->setOpacity(prevOpacity);
}
void CanvasRenderer::paintCurrentFrame( QPainter& painter )
{

    for ( int i = 0; i < mObject->getLayerCount(); ++i )
    {
        Layer* layer = mObject->getLayer( i );

        if ( i == mLayerIndex || mOptions.nShowAllLayers != 1 )
        {
            painter.setOpacity( 1.0 );
        }
        else {
            painter.setOpacity( 0.8 );
        }


        if ( i == mLayerIndex || mOptions.nShowAllLayers > 0 ) {
            switch ( layer->type() )
            {
                case Layer::BITMAP: { paintBitmapFrame( painter, i, mFrameNumber ); break; }
                case Layer::VECTOR: { paintVectorFrame( painter, i, mFrameNumber ); break; }
                case Layer::CAMERA: break;
                case Layer::SOUND: break;
                default: Q_ASSERT( false ); break;
            }
        }
    }
}
示例#5
0
void
PictureZoneEditor::onPaint(QPainter& painter, InteractionState const& interaction)
{
	painter.setWorldTransform(QTransform());
	painter.setRenderHint(QPainter::Antialiasing);

	if (!validateScreenPictureMask()) {
		schedulePictureMaskRebuild();
	} else {
		double const sn = sin(constants::DEG2RAD * m_pictureMaskAnimationPhase);
		double const scale = 0.5 * (sn + 1.0); // 0 .. 1
		double const opacity = 0.35 * scale + 0.15;

		QPixmap mask(m_screenPictureMask);

		{
			QPainter mask_painter(&mask);
			mask_painter.translate(-m_screenPictureMaskOrigin);
			paintOverPictureMask(mask_painter);
		}

		painter.setOpacity(opacity);
		painter.drawPixmap(m_screenPictureMaskOrigin, mask);
		painter.setOpacity(1.0);

		if (!m_pictureMaskAnimateTimer.isActive()) {
			m_pictureMaskAnimateTimer.start();
		}
	}
}
void SelectLocation::paintEvent(QPaintEvent *paintevent)
{
	QPainter painter;
	QPainterPath roundedrect;
	roundedrect.addRoundRect(this->rect(),20);
	
	painter.setOpacity(0.8);
	painter.fillPath(roundedrect,QColor(Qt::black));
	painter.setOpacity(1);
	
}
示例#7
0
void Timeline::Render(QPainter& painter)
{
    std::vector<QImage*> onions;

    for (size_t i = 0; i < mLayers.size(); ++i)
    {
        Layer* layer = mLayers[i];
        if (!layer->IsEnabled())
        {
            continue;
        }
        if (layer->GetType() == LayerTypeRaster)
        {
            QImage* img = mLayers[i]->GetImage(mFrameIndex);
            if (img)
            {
                if (mEditor->IsOnionEnabled() && mLayerIndex == (int)i)
                {
                    if (layer->GetType() == LayerTypeRaster && layer->IsOnionEnabled())
                    {
                        RasterLayer* l = (RasterLayer*)mLayers[i];
                        QImage* prev = l->GetImage(l->GetPrevImageIndex(mFrameIndex));
                        if(prev && prev != img)
                        {
                            onions.push_back(prev);
                        }
                        QImage* next = l->GetImage(l->GetNextImageIndex(mFrameIndex));
                        if(next && next != img)
                        {
                            onions.push_back(next);
                        }
                    }
                }

                painter.setOpacity(layer->GetOpacity() / 255.0f);
                painter.drawImage(0, 0, *img);
            }
        }
        else if (layer->GetType() == LayerTypeTrace)
        {
            TraceLayer* tl = (TraceLayer*)layer;
            tl->Render(painter);
        }
    }

    painter.setOpacity(0.25f);
    for (size_t i = 0; i < onions.size(); ++i)
    {
        painter.drawImage(0, 0, *onions[i]);
    }
}
示例#8
0
void ChessBoardWidget::drawChess(QPainter& painter)
{
    if(!showBoard)
        return;

    int i,j,step;
    bool flag;
    ChessBoard::ChessType type;

    painter.setFont(QFont("arial", cellHeight*0.35));
    painter.translate(gridLeft-cellWidth*0.5, gridTop-cellHeight*0.5);

    for(i=0;i<B_HEIGHT;++i)
    {
        for(j=0;j<B_WIDTH;++j)
        {
            type=showBoard->getGrid(i, j);
            if(type==ChessBoard::invalid)
                continue;
            painter.save();
            painter.translate(cellWidth*i, cellHeight*j);
            if(type==ChessBoard::empty)
            {
                if(historyStep==0&&!showBoard->isFinished()&&i==mouseX&&j==mouseY
                        &&showHint&&showBoard->checkMove(i, j, isNextBlack))
                {
                    painter.setOpacity(0.3);
                    painter.drawImage(QRectF(0, 0, cellWidth, cellHeight),
                                      isNextBlack?imgChessBlack[0]:imgChessWhite[0]);
                }
            }
            else
            {
                step=showBoard->getStep(i, j);
                flag=(i==currentX&&j==currentY);
                if(historyStep>0&&historyStep<step)
                    painter.setOpacity(0.2);
                painter.drawImage(QRectF(0, 0, cellWidth, cellHeight),
                                  type==ChessBoard::black?imgChessBlack[flag]:imgChessWhite[flag]);
                if(showGuide||historyStep>=step)
                {
                    painter.setPen(type==ChessBoard::black?"white":"black");
                    painter.drawText(QRectF(0, 0, cellWidth, cellHeight), Qt::AlignCenter,
                                     QString("%0").arg(step));
                }
            }
            painter.restore();
        }
    }

}
void ProfileWidget::paintTopBar(QPainter &p, float64 over, int32 decreaseWidth) {
	if (animating() && _showing) {
		p.setOpacity(a_bgAlpha.current());
		p.drawPixmap(a_bgCoord.current(), 0, _bgAnimTopBarCache);
		p.setOpacity(a_alpha.current());
		p.drawPixmap(a_coord.current(), 0, _animTopBarCache);
	} else {
		p.setOpacity(st::topBarBackAlpha + (1 - st::topBarBackAlpha) * over);
		p.drawPixmap(QPoint(st::topBarBackPadding.left(), (st::topBarHeight - st::topBarBackImg.height()) / 2), App::sprite(), st::topBarBackImg);
		p.setFont(st::topBarBackFont->f);
		p.setPen(st::topBarBackColor->p);
		p.drawText(st::topBarBackPadding.left() + st::topBarBackImg.width() + st::topBarBackPadding.right(), (st::topBarHeight - st::titleFont->height) / 2 + st::titleFont->ascent, lang(peer()->chat ? lng_profile_group_info : lng_profile_info));
	}
}
示例#10
0
void Bubble::draw_bubble(QPainter &painter) {
    QPen pen;
    pen.setWidth(stroke);
    pen.setBrush(colour);
    painter.setRenderHint(QPainter::HighQualityAntialiasing);
    painter.setPen(Qt::NoPen);
    painter.setBrush(colour);
    painter.setOpacity(opacity);
    painter.drawEllipse(QPointF(position()[0],position()[1]), r, r);
    painter.setPen(pen);
    painter.setBrush(Qt::NoBrush);
    painter.setOpacity(1.0);
    painter.drawEllipse(QPointF(position()[0],position()[1]), r, r);
}
示例#11
0
void PerspectivePixmap::drawUsingPainter(QPainter &painter)
{
    if (!mPixMap.isNull()) {
        qreal opOld = painter.opacity();
        QTransform transOld = painter.transform();
        QTransform trans = painter.transform();
        trans.scale(1, -1);
        painter.setTransform(trans);
        painter.setOpacity(0.8);
        painter.drawPixmap(-mXOffset / mScale, -mYOffset / mScale,
                           mPixMap.width() / mScale, mPixMap.height() / mScale, mPixMap);
        painter.setOpacity(opOld);
        painter.setTransform(transOld);
    }
}
void QQuickShapeSoftwareRenderNode::render(const RenderState *state)
{
    if (m_sp.isEmpty())
        return;

    QSGRendererInterface *rif = m_item->window()->rendererInterface();
    QPainter *p = static_cast<QPainter *>(rif->getResource(m_item->window(), QSGRendererInterface::PainterResource));
    Q_ASSERT(p);

    const QRegion *clipRegion = state->clipRegion();
    if (clipRegion && !clipRegion->isEmpty())
        p->setClipRegion(*clipRegion, Qt::ReplaceClip); // must be done before setTransform

    p->setTransform(matrix()->toTransform());
    p->setOpacity(inheritedOpacity());

    for (const ShapePathRenderData &d : qAsConst(m_sp)) {
        if (d.hidden) {
            continue;
        }

//        QTransform oldTransform = p->transform();
//        p->setTransform(d.transform, true);

//        p->setOpacity(inheritedOpacity() * d.opacity);
        p->setPen(d.strokeWidth >= 0.0f && d.pen.color() != Qt::transparent ? d.pen : Qt::NoPen);
        p->setBrush(d.brush.color() != Qt::transparent ? d.brush : Qt::NoBrush);
        p->drawPath(d.path);

//        p->setTransform(oldTransform);
    }
}
示例#13
0
void LevelWinDialog::paintContent(QPainter &p)
{
  GamePanel::paintContent(p);

  p.setOpacity(1);
  p.setFont(gameStock->Font40);
  p.setPen(QPen(QColor(0x030055)));

  drawHCentered(p, 50, tr("Level %1 completed!").arg(level));

  p.setFont(gameStock->Font20);

  const int y30 = DY(40);

  const int x1 = DX(300), x2 = DX(380), x3 = DX(600);
  const int y1 = DY(250), y2 = DY(350);

  p.drawPixmap(x1,y1, gameStock->Clock);
  p.drawText(x3,y1+y30, QString("%1:%2").arg(time/60, 2, 10, QChar('0')).arg(time%60, 2, 10, QChar('0')));

  p.drawPixmap(x1,y2, gameStock->Score);
  p.drawText(x3,y2+y30, QString::number(score));

  p.setPen(QPen(Qt::black));
  p.drawText(x2,y1+y30, tr("Time left:"));
  p.drawText(x2,y2+y30, tr("Score:"));
}
示例#14
0
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
void Circle::draw(QPainter& painter, const QPointF& startTile,
                  const QRect& viewport, const int& zoom) {

	if ( !isVisible() )
		return;

	QPointF coords;

	coord2screen(geoPosition(), coords, startTile, zoom);

	if ( !viewport.contains(coords.toPoint()) )
		coord2screen(geoPosition(), coords, startTile, zoom, true);

	setScreenPosition(coords);

	qreal yu = size().height() / WGS84CELLSIZE / pow(2, 18 - zoom) * 1000;
	qreal xu = size().width() / WGS84CELLSIZE / pow(2, 18 - zoom) * 1000;

	painter.save();
	painter.setPen(pen());
	painter.setBrush(brush());
	painter.setOpacity(opacity());
	painter.setRenderHint(QPainter::Antialiasing, isAntialiased());

	if ( isSizeInKm() )
		painter.drawEllipse(coords, xu, yu);
	else
		painter.drawEllipse(coords, size().width(), size().height());

	painter.restore();
}
示例#15
0
void AudioGraphWidget::drawDbLabels(QPainter& p, const QRect &rect)
{
    int dbLabelCount = m_dbLabels.size();
    int textHeight = fontMetrics().ascent();
    int x = 0;
    int y = 0;
    int yline = 0;

    if (dbLabelCount == 0) return;

    int maxWidth = fontMetrics().width(QStringLiteral("-50"));
    // dB scale is vertical along the left side
    int prevY = height();
    QColor textCol = palette().text().color();
    QColor lineCol = textCol;
    p.setOpacity(0.8);
    lineCol.setAlpha(100);
    for (int i = 0; i < dbLabelCount; i++) {
        int value = m_dbLabels[i];
        QString label = QString::number(value);
        x = rect.left() + maxWidth - fontMetrics().width(label);
        yline = rect.bottom() - IEC_ScaleMax(value, m_maxDb) * rect.height();
        y = yline + textHeight / 2;
        if (y - textHeight < 0) {
            y = textHeight;
        }
        if (prevY - y >= 2) {
            p.setPen(textCol);
            p.drawText(x, y, label);
            p.setPen(lineCol);
            p.drawLine(rect.left() + maxWidth + 2, yline, rect.width(), yline);
            prevY = y - textHeight;
        }
    }
}
示例#16
0
void GameWinDialog::paintContent(QPainter &p)
{
  GamePanel::paintContent(p);

  p.setOpacity(1);
  p.setFont(gameStock->Font60);
  p.setPen(QPen(QColor(0x030055)));

  drawHCentered(p, 50, tr("You're the Winner!"));

  p.setFont(gameStock->Font40);

  drawHCentered(p, 200, tr("You finished all the levels!"));

  p.setFont(gameStock->Font20);

  const int y30 = DY(40);

  const int x1 = DX(300), x2 = DX(420), x3 = DX(600);
  const int /*y1 = DY(250), */y2 = DY(350)/*, y3 = DY(350)*/;

  p.drawPixmap(x1,y2, gameStock->Score);
  p.drawText(x3,y2+y30, QString::number(score));

  p.setPen(QPen(Qt::black));
  p.drawText(x2,y2+y30, tr("Score:"));
}
示例#17
0
void Bubble::do_draw(QPainter& painter) {
    draw_bubble(painter);
    painter.setPen(Qt::red);
    painter.setBrush(Qt::NoBrush);
    painter.setOpacity(1.0);
    painter.drawRect(get_bounding_box());
}
void GraphicsContext::setAlpha(float opacity)
{
    if (paintingDisabled())
        return;
    QPainter *p = m_data->p();
    p->setOpacity(opacity);
}
示例#19
0
文件: baseitem.cpp 项目: neoclust/jag
void TextItem::paint(QPainter &painter)
{
  painter.setOpacity(myOpacity);
  painter.setFont(myFont);
  painter.setPen(QPen(myColor));
  painter.drawText(myRect, myFlags, myText);
}
示例#20
0
void ImageBufferDataPrivateAccelerated::platformTransformColorSpace(const Vector<int>& lookUpTable)
{
    QPainter* painter = paintDevice()->paintEngine()->painter();

    QImage image = toQImage().convertToFormat(QImage::Format_ARGB32);
    ASSERT(!image.isNull());

    uchar* bits = image.bits();
    const int bytesPerLine = image.bytesPerLine();

    for (int y = 0; y < image.height(); ++y) {
        quint32* scanLine = reinterpret_cast_ptr<quint32*>(bits + y * bytesPerLine);
        for (int x = 0; x < image.width(); ++x) {
            QRgb& pixel = scanLine[x];
            pixel = qRgba(lookUpTable[qRed(pixel)],
                          lookUpTable[qGreen(pixel)],
                          lookUpTable[qBlue(pixel)],
                          qAlpha(pixel));
        }
    }

    painter->save();
    painter->resetTransform();
    painter->setOpacity(1.0);
    painter->setClipping(false);
    painter->setCompositionMode(QPainter::CompositionMode_Source);
    // Should coordinates be flipped?
    painter->drawImage(QPoint(0,0), image);
    painter->restore();
}
    bool eventFilter(QObject *pO, QEvent *event)
    {
        if ( event->type() == QEvent::Paint) {
            QWidget* pW = qobject_cast<QWidget*>(pO);
            QColor backColor = NotificationServerSettings::instance()->value("notification_backgroundColor").value<QColor>();
            float fOpacity = NotificationServerSettings::instance()->value("notification_opacity").value<float>();
            QPainter painter ( pW );
            painter.setRenderHint(QPainter::Antialiasing);
            painter.setRenderHint(QPainter::HighQualityAntialiasing);

            // corners
            const int kShadowCornerSize = scShadowSize + scRadiusSize;
            painter.drawPixmap(0, 0, shadowsCorners.at(0));
            painter.drawPixmap(pW->width() - kShadowCornerSize, 0, shadowsCorners.at(1));
            painter.drawPixmap(pW->width() - kShadowCornerSize, pW->height() - kShadowCornerSize, shadowsCorners.at(2));
            painter.drawPixmap(0, pW->height() - kShadowCornerSize, shadowsCorners.at(3));

            //edges
            painter.drawTiledPixmap(kShadowCornerSize, 0,pW->width() - kShadowCornerSize*2, scShadowSize,shadowsEdges.at(0));
            painter.drawTiledPixmap(pW->width() - scShadowSize, kShadowCornerSize,scShadowSize, pW->height() - kShadowCornerSize*2,shadowsEdges.at(1));
            painter.drawTiledPixmap(kShadowCornerSize, pW->height() - scShadowSize,pW->width() - kShadowCornerSize*2, scShadowSize,shadowsEdges.at(2));
            painter.drawTiledPixmap(0, kShadowCornerSize,scShadowSize, pW->height() - kShadowCornerSize*2,shadowsEdges.at(3));


            // rounded pixmap
            painter.setBrush(backColor);
            painter.setPen(backColor);
            painter.setOpacity(fOpacity);
            painter.drawRoundedRect(scShadowSize,scShadowSize,pW->width()-2*scShadowSize, pW->height()-2*scShadowSize,scRadiusSize,scRadiusSize);
        }
    }
示例#22
0
void QUProfileController::drawLoadingMessage(QPainter & p)
{
    if( avail() < m_total || m_total == 0)
    {
        p.save();
        p.setFont ( m_captionFont);
        p.setOpacity(1);
        QString txt = QString( "Loading %1/%2").arg( avail()).arg(m_total);
        QRectF anchor( m_buffer.width()/2.0, m_buffer.height()/2.0, 1, 1);
        QRectF brect = p.boundingRect(
                    anchor,  Qt::AlignCenter | Qt::TextDontClip,
                    txt);
        brect.adjust( -3, -3, 3, 3);
        QColor bg( 255, 255, 255, 225);
        QColor border( 128, 0, 0, 225);
        p.setPen( border);
        p.setBrush( bg);
        p.drawRoundedRect( brect, 5, 5);
        p.setPen( QColor(0, 0, 0));
        p.drawText(anchor,  Qt::AlignCenter | Qt::TextDontClip,
                   txt);
        p.setPen( QPen(QColor( 0, 0, 0, 128), 1, Qt::DashLine));
        p.restore();
    }
}
示例#23
0
void GraphicsContext3DPrivate::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity)
{
    m_context->markLayerComposited();
    blitMultisampleFramebufferAndRestoreContext();

    if (textureMapper->accelerationMode() == TextureMapper::OpenGLMode) {
        TextureMapperGL* texmapGL = static_cast<TextureMapperGL*>(textureMapper);
        TextureMapperGL::Flags flags = TextureMapperGL::ShouldFlipTexture | (m_context->m_attrs.alpha ? TextureMapperGL::ShouldBlend : 0);
        IntSize textureSize(m_context->m_currentWidth, m_context->m_currentHeight);
        texmapGL->drawTexture(m_context->m_texture, flags, textureSize, targetRect, matrix, opacity);
        return;
    }

    // Alternatively read pixels to a memory buffer.
    GraphicsContext* context = textureMapper->graphicsContext();
    QPainter* painter = context->platformContext();
    painter->save();
    painter->setTransform(matrix);
    painter->setOpacity(opacity);

    const int height = m_context->m_currentHeight;
    const int width = m_context->m_currentWidth;

    painter->beginNativePainting();
    makeCurrentIfNeeded();
    glBindFramebuffer(GL_FRAMEBUFFER, m_context->m_fbo);
    QImage offscreenImage = qt_gl_read_framebuffer(QSize(width, height), true, true);
    glBindFramebuffer(GL_FRAMEBUFFER, m_context->m_state.boundFBO);

    painter->endNativePainting();

    painter->drawImage(targetRect, offscreenImage);
    painter->restore();
}
示例#24
0
文件: Scene.cpp 项目: dujodujo/chimp
void Scene::drawTextHint(QPainter& painter) {
	painter.setOpacity(1);
	painter.setPen(QPen(Qt::white));
	painter.setFont(gameStock->font12);
	QString hintText = "Hint";
	painter.drawText(0, DY(690), DX(860), DY(30), Qt::AlignRight, hintText);
}
示例#25
0
void painterUtils::drawRectangleBar(QPainter &qp ,int const &startPos,int const &width,
                                    int const &height
                                 ,const float value, bool drawText ,
                                    QColor &color1 , QColor &color2)

{
    //Calculate how many pixel our rectangle will cover in width, we base the computation on the current input value
    // which should be a percentage
    int pixToCover = width * value/100.0f ;
    //Lets check the result iis not too small
    if ( value < 1.0 || pixToCover < 0 )
    {
      pixToCover =4;
    }
    //or too big
    if (pixToCover >= width)
    {
      pixToCover = width - 4;
    }
    //Lets build the backaground rectangle
    QRect myQRect = QRect(QPoint(startPos,3) , QSize(pixToCover-1,height-6));
    //Lets build the gradient
    QLinearGradient gradient(myQRect.topLeft(), myQRect.topRight()); // diagonal gradient from top-left to bottom-right
    //Lets set the color for the start positon
    gradient.setColorAt(0, color1);
    float r =(255*value/100.0f);
    if (r<0)
        r=0;
    if (r>255)
        r=255;
    r /= 255;
    //Lets interpolate the second color based on the percentage value
    gradient.setColorAt(1, QColor(color1.red()* (1-r) + color2.red()*r,
                                  color1.green()* (1-r) + color2.green()*r,
                                  color1.blue()* (1-r) + color2.blue()*r,
                                  255));
    //Lets draw the gradient
    qp.fillRect(myQRect, gradient);
    //Lets draw the text in the center of the triangle if needed
    if (drawText == true)
    {
        qp.setOpacity(0.4);
        qp.setFont(QFont("Helvetica", 20, QFont::Bold));
        qp.drawText(startPos + (width/2),height/2,QString::number(int(value)) + " %");
        qp.setOpacity(1.0);
    }
}
示例#26
0
bool QtDNDTabBar::event(QEvent* event) {
	QMouseEvent* mouseEvent = dynamic_cast<QMouseEvent*>(event);
	if (mouseEvent) {
		QWidget* childAtPoint = window()->childAt(mapTo(window(), mouseEvent->pos()));
		QtDNDTabBar* underMouse = dynamic_cast<QtDNDTabBar*>(childAtPoint);
		if (!underMouse && childAtPoint) {
			underMouse = dynamic_cast<QtDNDTabBar*>(childAtPoint->parent());
		}
		if (!underMouse && currentIndex() >= 0) {
			// detach and drag

			// stop move event
			QMouseEvent* finishMoveEvent = new QMouseEvent (QEvent::MouseMove, mouseEvent->pos (), Qt::NoButton, Qt::NoButton, Qt::NoModifier);
			QTabBar::event(finishMoveEvent);
			delete finishMoveEvent;
			finishMoveEvent = NULL;

			// start drag
			QDrag* drag = new QDrag(this);
			QMimeData* mimeData = new QMimeData;

			// distinguish tab-reordering drops from other ones
			mimeData->setData("action", "application/tab-detach") ;
			drag->setMimeData(mimeData);

			// set drag image
			QRect rect = tabRect( currentIndex() );
#if QT_VERSION >= 0x050000
			QPixmap pixmap = grab(rect);
#else
			QPixmap pixmap = QPixmap::grabWidget(this, rect);
#endif
			QPixmap targetPixmap (pixmap.size ());
			QPainter painter (&targetPixmap);
			painter.setOpacity(0.9);
			painter.drawPixmap(0,0, pixmap);
			painter.end ();
			drag->setPixmap (targetPixmap);

			drag->setHotSpot(QPoint(drag->pixmap().width()/2, drag->pixmap().height()));

			dragIndex = currentIndex();
			dragText = tabText(dragIndex);
			dragWidget = dynamic_cast<QTabWidget*>(parent())->widget(dragIndex);
			assert(dragWidget);
			dynamic_cast<QTabWidget*>(parent())->removeTab(currentIndex());
			Qt::DropAction dropAction = drag->exec();
			if (dropAction == Qt::IgnoreAction) {
				// aborted drag, put tab back in place
				// disable event handling during the insert for the tab to prevent infinite recursion (stack overflow)
				dragWidget->blockSignals(true);
				dynamic_cast<QTabWidget*>(parent())->insertTab(dragIndex, dragWidget, dragText);
				dragWidget->blockSignals(false);
			}
			return true;
		}
	}
	return QTabBar::event(event);
}
示例#27
0
void IScene::drawTextHint(QPainter &p)
{
  p.setOpacity(1);
  p.setPen(QPen(Qt::yellow));
  p.setFont(gameStock->Font12);
  //p.drawText(0,DY(690),DX(860),DY(30), Qt::AlignRight, hintText);
  p.drawText(0,DY(675),WIDTH,DY(30), Qt::AlignCenter, hintText);
}
void AnimationViewerPanel::renderTargetSprite(const QPoint& centerPoint, QPainter& painter)
{
    painter.setOpacity(mpAnimationModel->getTargetSprite()->mSpriteDescriptor.mAlpha);

    painter.translate(centerPoint.x(), centerPoint.y());
    mpAnimationModel->getTargetSprite()->render(QPoint(0, 0), painter, NULL, false, mEmittedAnimationList);
    painter.translate(-centerPoint.x(), -centerPoint.y());
}
示例#29
0
void CanvasRenderer::paintCameraBorder(QPainter &painter)
{

    for ( int i = 0; i < mObject->getLayerCount(); ++i )
    {
        Layer* layer = mObject->getLayer( i );

        if ( layer->type() == Layer::CAMERA && (i == mLayerIndex || mOptions.nShowAllLayers > 0) && layer->visible() ) {

            if ( i == mLayerIndex || mOptions.nShowAllLayers != 1 )
            {
                painter.setOpacity( 1.0 );
            }
            else {
                painter.setOpacity( 0.8 );
            }

            QRectF viewRect = painter.viewport();
            QRect boundingRect = mViewTransform.inverted().mapRect( viewRect ).toRect();


            LayerCamera* cameraLayer = dynamic_cast< LayerCamera* >( layer );

            QRect cameraRect = cameraLayer->getViewRect();

            painter.setWorldMatrixEnabled( true );
            painter.setPen( Qt::NoPen );
            painter.setBrush( QColor( 0, 0, 0, 160 ) );

            QRegion rg1(boundingRect);
            QRegion rg2(cameraRect);
            QRegion rg3=rg1.subtracted(rg2);

            painter.setClipRegion(rg3);

            painter.drawRect( boundingRect );

            painter.setClipping(false);

            painter.setPen( Qt::black );
            painter.setBrush( Qt::NoBrush );
            painter.drawRect( cameraRect );
        }
    }
}
示例#30
0
void OraHandler::render_stack( xml_node node, QPainter &painter, int offset_x, int offset_y ) const{
	for( xml_node_iterator it = --node.end(); it != --node.begin(); it-- ){
		std::string name( (*it).name() );
		if( name == "stack" ){
			int x = (*it).attribute( "x" ).as_int( 0 );
			int y = (*it).attribute( "y" ).as_int( 0 );
			
			render_stack( *it, painter, offset_x+x, offset_y+y );
		}
		else if( name == "text" ){
			qWarning( "No support for text" );
		}
		else if( name == "layer" ){
			QString source( QString::fromUtf8( (*it).attribute( "src" ).value() ) );
			int x = (*it).attribute( "x" ).as_int( 0 ) + offset_x;
			int y = (*it).attribute( "y" ).as_int( 0 ) + offset_y;
			
			std::string visibility = (*it).attribute( "visibility" ).value();
			if( visibility == "" || visibility == "visible" ){
				//composite-op
				std::string composite = (*it).attribute( "composite-op" ).value();
				QPainter::CompositionMode mode = QPainter::CompositionMode_SourceOver;
				if( !ora_composite_mode( composite, mode ) )
					qWarning( "Unsupported composite-op: %s", composite.c_str() );
				painter.setCompositionMode( mode );
				
				double opacity = (*it).attribute( "opacity" ).as_double( 1.0 );
				painter.setOpacity( opacity );
				
				std::map<QString,QImage>::const_iterator img_it = images.find( source );
				if( img_it != images.end() )
					painter.drawImage( x, y, img_it->second );
				else
					qWarning( "Layer source not found: %s", source.toLocal8Bit().constData() );
				
				//Restore modified settings
				painter.setOpacity( 1.0 );
				painter.setCompositionMode( QPainter::CompositionMode_SourceOver );
			}
		}
		else{
			qWarning( "Unrecognized element: %s", name.c_str() );
		}
	}
}