C++ QPainter::setClipping方法代码示例

void nsRenderingContextQt::UpdateGC()
{
  QPainter *pGC;
  QColor color(NS_GET_R(mCurrentColor),
               NS_GET_G(mCurrentColor),
               NS_GET_B(mCurrentColor));
  QPen   pen(color,0,mQLineStyle);
  QBrush brush(color);

  pGC = mSurface->GetGC();
  pGC->setPen(pen);
  pGC->setBrush(brush);
  pGC->setRasterOp(mFunction);
  if (mCurrentFont)
    pGC->setFont(mCurrentFont->font);
  if (mClipRegion) {
     QRegion *rgn = nsnull;

     pGC->setClipping(TRUE);
     mClipRegion->GetNativeRegion((void*&)rgn);
     pGC->setClipRegion(*rgn);
  }
  else {
    pGC->setClipping(FALSE);
  }
}

void MapWidget::drawMarker(const MapMarker &marker, QPainter &painter, const QPointF &markerPosition, const QPointF &rectPosition)
{
    QRectF markerRect = getMarkerRect(marker, rectPosition);

    QColor bgColor = getMarkerTextBackgroundColor();
    painter.setBrush(QBrush(bgColor));

    // drawing the line connector
    painter.setPen(bgColor);
    painter.setClipping(true);
    painter.setClipRegion(QRegion(rect()).subtracted(markerRect.toRect()));
    painter.drawLine(markerRect.center(), markerPosition);

    // drawing the transparent background
    painter.setClipping(false);
    painter.setPen(Qt::NoPen);
    painter.drawRect(markerRect);

    // drawing the player marker
    const static qreal markerSize = 1.6;
    painter.setBrush(getMarkerColor());
    painter.drawEllipse(markerPosition, markerSize, markerSize);

    qreal hOffset = rectPosition.x() + TEXT_MARGIM; // left margin

    // draw the player name text
    QString playerName = marker.getPlayerName();
    painter.setFont(userFont);

    QFontMetrics metrics = painter.fontMetrics();
    qreal playerNameWidth = metrics.width(playerName);
    painter.setPen(getMarkerTextColor());
    qreal textY = rectPosition.y() + TEXT_MARGIM + metrics.descent()/2.0;
    painter.drawText(hOffset, textY, playerName);
    hOffset += playerNameWidth + TEXT_MARGIM * 3;

    // draw the player country name
    painter.setFont(countryFont);
    metrics = painter.fontMetrics();

    QColor countryNameColor(getMarkerTextColor());
    countryNameColor.setAlpha(180); // country name is drawed using some alpha
    painter.setPen(countryNameColor);
    QString countryName = marker.getCountryName();
    painter.drawText(hOffset, textY, countryName);

    hOffset += metrics.width(countryName);

    painter.setFont(userFont); //restore the normal font
    metrics = painter.fontMetrics();

    // draw the player country flag
    const QImage &image = marker.getFlag();
    qreal imageX = hOffset + TEXT_MARGIM;
    qreal imageY = rectPosition.y() - image.height()/2.0;
    painter.drawImage(QPointF(imageX, imageY), image);
}

QPixmap ImageProcessor::drawPiece(int i, int j, const QPainterPath &shape, const Puzzle::Creation::Correction &corr)
{
    QPainter p;
    QPixmap px(_p->descriptor.unitSize.width() + corr.widthCorrection + 1,
               _p->descriptor.unitSize.height() + corr.heightCorrection + 1);
    px.fill(Qt::transparent);

    p.begin(&px);
    p.setRenderHint(QPainter::SmoothPixmapTransform);
    p.setRenderHint(QPainter::Antialiasing);
    p.setRenderHint(QPainter::HighQualityAntialiasing);
    p.setClipping(true);
    p.setClipPath(shape);

    p.drawPixmap(_p->descriptor.tabFull + corr.xCorrection + corr.sxCorrection,
                 _p->descriptor.tabFull + corr.yCorrection + corr.syCorrection,
                 _p->pixmap,
                 i * _p->descriptor.unitSize.width() + corr.sxCorrection,
                 j * _p->descriptor.unitSize.height() + corr.syCorrection,
                 _p->descriptor.unitSize.width() * 2,
                 _p->descriptor.unitSize.height() * 2);

    p.end();
    return px;
}

void AFCWidget::drawAmplitude(QPainter & painter, QRectF rect)
{
	if(m_dB_points.size()<2) return;

	painter.setClipping(true);
	painter.setClipRect(rect);
	painter.setRenderHint(QPainter::Antialiasing, true);
	

	//amplitude
	painter.setPen( QPen(QColor(0, 0, 0, 255)) );

	float prev_x=m_dB_points.first().x();
	float prev_y=m_dB_points.first().y();

	float dB_range = m_dB2-m_dB1;

	foreach(QPointF p, m_dB_points){
//		QPointF p1( rect.left()+log_coef*log10(prev_x-m_freq1)/freq_range*rect.width(), rect.bottom()-(prev_y-m_dB1)/dB_range*rect.height() );
//		QPointF p2( rect.left()+log_coef*log10(p.rx()-m_freq1)/freq_range*rect.width(), rect.bottom()-(p.ry()-m_dB1)/dB_range*rect.height() );

		//linear scale
//		QPointF p1( rect.left()+(prev_x-m_freq1)/(m_freq2-m_freq1)*rect.width(), rect.bottom()-(prev_y-m_dB1)/dB_range*rect.height() );
//		QPointF p2( rect.left()+(p.rx()-m_freq1)/(m_freq2-m_freq1)*rect.width(), rect.bottom()-(p.ry()-m_dB1)/dB_range*rect.height() );

		//log scale
		QPointF p1( rect.left()+logFreq(prev_x)*rect.width(), rect.bottom()-(prev_y-m_dB1)/dB_range*rect.height() );
		QPointF p2( rect.left()+logFreq(p.rx())*rect.width(), rect.bottom()-(p.ry()-m_dB1)/dB_range*rect.height() );


		if(p.x() <= m_freq2) painter.drawLine(p1, p2);
		prev_x = p.rx();
		prev_y = p.ry();
	}

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();
}

void UIPopupPane::paintFrame(QPainter &painter)
{
    /* Paint frame: */
    QColor currentColor(palette().color(QPalette::Window).darker(150));
    QPainterPath path = painter.clipPath();
    painter.setClipping(false);
    painter.strokePath(path, currentColor);
}

void
PlayField::paintPainterClip(QPainter &paint, int x, int y, int w, int h) {
  QRect rect(x, y, w, h);

  paint.setClipRect(rect);
  paint.setClipping(true);
  paintPainter(paint, rect);
}

void SurfaceImpl::DrawTextClipped(PRectangle rc, Font &font_, XYPOSITION ybase,
        const char *s, int len, ColourDesired fore, ColourDesired back)
{
    Q_ASSERT(painter);

    SetClip(rc);
    DrawTextNoClip(rc, font_, ybase, s, len, fore, back);
    painter->setClipping(false);
}

void ItemDocument::print() {
	static KPrinter *printer = new KPrinter;

	if (! printer->setup(KTechlab::self()))
		return;

	// setup the printer.  with Qt, you always "print" to a
	// QPainter.. whether the output medium is a pixmap, a screen,
	// or paper
	QPainter p;
	p.begin(printer);

	// we let our view do the actual printing
	QPaintDeviceMetrics metrics(printer);

	// Round to 16 so that we cut in the middle of squares
	int w = metrics.width();
	w = (w & 0xFFFFFFF0) + ((w << 1) & 0x10);

	int h = metrics.height();
	h = (h & 0xFFFFFFF0) + ((h << 1) & 0x10);

	p.setClipping(true);
	p.setClipRect(0, 0, w, h, QPainter::CoordPainter);

	// Send off the painter for drawing
	m_canvas->setBackgroundPixmap(0);
	QRect bounding = canvasBoundingRect();

	unsigned int rows = (unsigned) std::ceil(double(bounding.height()) / double(h));
	unsigned int cols = (unsigned) std::ceil(double(bounding.width()) / double(w));

	int offset_x = bounding.x();
	int offset_y = bounding.y();

	for (unsigned row = 0; row < rows; ++row) {
		for (unsigned col = 0; col < cols; ++col) {
			if (row != 0 || col != 0)
				printer->newPage();

			QRect drawArea(offset_x + (col * w), offset_y + (row * h), w, h);

			m_canvas->drawArea(drawArea, & p);

			p.translate(-w, 0);
		}

		p.translate(w * cols, -h);
	}

	updateBackground();

	// and send the result to the printer
	p.end();
}

void SeekGraph::paintEvent ( QPaintEvent* event )
{
    QFrame::paintEvent( event );
    QPainter p;

     p.begin( this );
     p.setRenderHint( QPainter::Antialiasing, antialiasing() );
     p.fillRect( rect(), backgroundColor() );
     p.translate( leftPadding() + 0.5, topPadding() + 0.5 );

     p.setClipping( false );
     drawAxes( &p );

     setPixRect();
     p.setClipRect( pixRect() );
     p.setClipping( true );

     resetPlotMask();

     foreach( KPlotObject *po, plotObjects() )
     {
       po->draw( &p, this );
     }

void ossimGui::ImageScrollWidget::drawCursor(QPainter& painter)
{
   if(!m_trackPoint.hasNans())
   {
      ossimIpt roundedPoint(m_trackPoint);
      bool hasClipping = painter.hasClipping();
      painter.setClipping(false);
      painter.setPen(QColor(255, 255, 255));
      
      ossimIrect rect(0,0,size().width()-1, size().height()-1);
      // ossimIpt ul = rect.ul();
      // ossimIpt lr = rect.lr();
      int left   = rect.ul().x;
      int right  = rect.lr().x;
      int top    = rect.ul().y;
      int bottom = rect.lr().y;
      if(rect.pointWithin(roundedPoint))
      {
         // draw horizontal
         //
         int x1 = left;
         int x2 = right;
         int y1  = roundedPoint.y;
         int y2  = y1;
         painter.drawLine(x1, y1, x2, y2);
         
         // draw vertical
         x1 = roundedPoint.x;
         x2 = x1;
         y1 = top;
         y2 = bottom;
         painter.drawLine(x1, y1, x2, y2);
      }
      painter.setClipping(hasClipping);
   }
   m_oldTrackPoint = m_trackPoint;
}

/*!
  draw an outline

  \warning Outlining functionality is obsolete: use QwtPlotPicker or
  QwtPlotZoomer.
*/
void QwtPlotCanvas::drawOutline(QPainter &p)
{
    const QRect &r = contentsRect();

    QColor bg = ((QwtPlot *)parent())->canvasBackground();

    QPen pn = d_pen;
    pn.setColor(QColor(bg.rgb() ^ d_pen.color().rgb()));

    p.setPen(pn);
    p.setRasterOp(XorROP);
    p.setClipRect(r);
    p.setClipping(TRUE);

    switch(d_outline)
    {
        case Qwt::VLine:
            QwtPainter::drawLine(&p, d_lastPoint.x(), 
                r.top(), d_lastPoint.x(), r.bottom());
            break;
        
        case Qwt::HLine:
            QwtPainter::drawLine(&p, r.left(), 
                d_lastPoint.y(), r.right(), d_lastPoint.y());
            break;
        
        case Qwt::Cross:
            QwtPainter::drawLine(&p, r.left(), 
                d_lastPoint.y(), r.right(), d_lastPoint.y());
            QwtPainter::drawLine(&p, d_lastPoint.x(), 
                r.top(), d_lastPoint.x(), r.bottom());
            break;

        case Qwt::Rect:
            QwtPainter::drawRect(&p, d_entryPoint.x(), d_entryPoint.y(),
               d_lastPoint.x() - d_entryPoint.x() + 1,
               d_lastPoint.y() - d_entryPoint.y() + 1);
            break;
        
        case Qwt::Ellipse:
            p.drawEllipse(d_entryPoint.x(), d_entryPoint.y(),
               d_lastPoint.x() - d_entryPoint.x() + 1,
               d_lastPoint.y() - d_entryPoint.y() + 1);
            break;

        default:
            break;
    }
}

 /**
  * Makes the corners of the image rounded
  */
 QImage polishImage(const QImage &img)
 {
     const int sz = 48 * 4;
     QImage roundedImage = QImage(QSize(sz, sz), QImage::Format_ARGB32_Premultiplied);
     roundedImage.fill(Qt::transparent);
     QPainter p;
     p.begin(&roundedImage);
     QPainterPath clippingPath;
     QRectF imgRect = QRectF(QPoint(0, 0), roundedImage.size());
     clippingPath.addRoundedRect(imgRect, 24, 24);
     p.setClipPath(clippingPath);
     p.setClipping(true);
     p.drawImage(QRectF(QPointF(0, 0), roundedImage.size()), img);
     return roundedImage;
 }

void NativeRenderDialog::render(QPainter& P, QRect theR, RendererOptions opt)
{
    P.setClipRect(theR);
    P.setClipping(true);
    P.setRenderHint(QPainter::Antialiasing);

    mapview->setGeometry(theR);
    mapview->setViewport(boundingBox(), theR);
    mapview->setRenderOptions(opt);
    mapview->invalidate(true, true, false);
    mapview->drawFeaturesSync(P);
    if (opt.options & RendererOptions::ScaleVisible)
        mapview->drawScale(P);
    if (opt.options & RendererOptions::LatLonGridVisible)
        mapview->drawLatLonGrid(P);
}

void ClusterView::print(QPainter& printPainter,QPaintDeviceMetrics& metrics,bool whiteBackground){
 //Draw the double buffer (pixmap) by copying it into the printer device throught the painter.
  QRect viewportOld = QRect(viewport.left(),viewport.top(),viewport.width(),viewport.height());

  viewport = QRect(printPainter.viewport().left(),printPainter.viewport().top(),printPainter.viewport().width(),printPainter.viewport().height());

  QRect r = ((QRect)window);

  //Set the window (part of the world I want to show)
  printPainter.setWindow(r.left(),r.top(),r.width()-1,r.height()-1);//hack because Qt QRect is used differently in this function

  //Fill the background with the background color
  QRect back = QRect(r.left(),r.top(),r.width(),r.height());

  QColor colorLegendTmp = colorLegend;
  QColor background= backgroundColor();
  if(whiteBackground){
   colorLegend = black;
   setPaletteBackgroundColor(white);
  }
  
  printPainter.fillRect(back,backgroundColor());
  printPainter.setClipRect(back,QPainter::CoordPainter);

  //Draw the axes
  drawAxes(printPainter);

  //Paint all the clusters in the shownClusters list (in the double buffer)
  drawClusters(printPainter,view.clusters(),true);

  //reset transformation due to setWindow and setViewport
  printPainter.resetXForm();

  //Draw the time axis information if the time is displayed
  drawTimeInformation(printPainter);

  printPainter.setClipping(false);

  //Restore the colors.
  if(whiteBackground){
   colorLegend = colorLegendTmp;
   setPaletteBackgroundColor(background);
  }
  
  //Restore the previous state
  viewport = QRect(viewportOld.left(),viewportOld.top(),viewportOld.width(),viewportOld.height());
}