Esempio n. 1
0
			void PiecesWidget::paintEvent (QPaintEvent *e)
			{
				int s = Pieces_.size ();
				QPainter painter (this);
				painter.setRenderHints (QPainter::Antialiasing |
						QPainter::SmoothPixmapTransform);
				if (!s)
				{
					painter.setBackgroundMode (Qt::OpaqueMode);
					painter.setBackground (Qt::white);
					painter.end ();
					return;
				}
			
				QPixmap tempPicture (s, 1);
				QPainter tempPainter (&tempPicture);
				tempPainter.setPen (Qt::red);
				tempPainter.drawLine (0, 0, s, 0);
				QList<QPair<int, int> > trues = FindTrues (Pieces_);
				for (int i = 0; i < trues.size (); ++i)
				{
					QPair<int, int> pair = trues.at (i);
			
					tempPainter.setPen (Qt::darkGreen);
					tempPainter.drawLine (pair.first, 0, pair.second, 0);
				}
				tempPainter.end ();
			
				painter.drawPixmap (QRect (0, 0, width (), height ()), tempPicture);
				painter.end ();
			
				e->accept ();
			}
Esempio n. 2
0
void ParameterSetCanvas::draw(QPainter & p) {
    if (! visible()) return;

    QBrush brsh = p.brush();
    QColor bckgrnd = p.backgroundColor();

    p.setBackgroundMode((used_color == UmlTransparent)
                        ? ::Qt::TransparentMode
                        : ::Qt::OpaqueMode);

    QColor co = color(used_color);
    QRect r = rect();
    FILE * fp = svg();

    p.setBackgroundColor(co);

    if (used_color != UmlTransparent)
        p.setBrush(co);

    if (fp != 0)
        fprintf(fp, "<g>\n"
                "\t<rect fill=\"%s\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\""
                " x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" />\n"
                "</g>\n",
                svg_color(used_color),
                r.x(), r.y(), r.width() - 1, r.height() - 1);

    p.drawRect(r);

    p.setBackgroundColor(bckgrnd);
    p.setBrush(brsh);

    if (selected())
        show_mark(p, r);
}
// creates an icon in the apple style of gray emboss
QIcon iconFromPNG(QString filename, bool emboss)
{
    QImage pngImage;
    pngImage.load(filename);

    // use muted dark gray color
    QImage gray8 = pngImage.convertToFormat(QImage::Format_Indexed8);
    gray8.setColor(0, QColor(80,80,80, 170).rgb());

    if (GCColor::isFlat()) return QIcon(QPixmap::fromImage(gray8));

    QImage white8 = pngImage.convertToFormat(QImage::Format_Indexed8);
    white8.setColor(0, QColor(255,255,255, 255).rgb());

    // now convert to a format we can paint with!
    QImage white = white8.convertToFormat(QImage::Format_ARGB32_Premultiplied);
    QImage gray = gray8.convertToFormat(QImage::Format_ARGB32_Premultiplied);

    QPainter painter;
    painter.begin(&white);
    painter.setBackgroundMode(Qt::TransparentMode);
    if (emboss) painter.drawImage(0,-1, gray);
    else painter.drawImage(0,0, gray);
    painter.end();

    return QIcon(QPixmap::fromImage(white));
}
Esempio n. 4
0
void Drawboard::setupBuffer()
{
    QPixmap* newBuffer = new QPixmap(width(), height());
    QPainter* newPainter = new QPainter(newBuffer);

    newPainter->setBackgroundMode(Qt::OpaqueMode);
    newPainter->setBackground(Qt::white);

    newPainter->setRenderHint(QPainter::Antialiasing);
    newPainter->setRenderHint(QPainter::SmoothPixmapTransform);

    newPainter->eraseRect(newBuffer->rect());
    if (buffer != NULL)
    {
        int w = std::min(buffer->width(), newBuffer->width());
        int h = std::min(buffer->height(), newBuffer->height());
        newPainter->drawPixmap(0, 0, *buffer, 0, 0, w, h);
    }

    newPainter->setBrush(QColor(255, 0, 0, 128));
    newPainter->setPen(QColor(255, 0, 0, 255));

    delete painter;
    delete buffer;
    buffer = newBuffer;
    painter = newPainter;

    update();
}
Esempio n. 5
0
void QHexEditPrivate::drawLine(QPainter &painter, QFontMetrics &fm, qint64 line, int y)
{
	int xhex = this->_xposhex, xascii = this->_xposascii;
	qint64 linestart = line * QHexEditPrivate::BYTES_PER_LINE;

	painter.setBackgroundMode(Qt::TransparentMode);
	this->drawLineBackground(painter, line, linestart, y);
	this->drawAddress(painter, fm, line, linestart, y);

	for(qint64 i = 0; i < QHexEditPrivate::BYTES_PER_LINE; i++)
	{
		qint64 pos = linestart + i;

		if(pos >= this->_hexeditdata->length())
			return; /* Reached EOF */

		uchar b = this->_reader->at(pos);

		if(this->_comments->isCommented(pos))
		{
			QFont f = this->font();
			f.setBold(true);
			painter.setFont(f);
		}
		else
			painter.setFont(this->font());

		QColor bchex, fchex, bcascii, fcascii;
		this->colorize(b, pos, bchex, fchex, bcascii, fcascii);

		this->drawHex(painter, fm, bchex, fchex, b, i, xhex, y);
		this->drawAscii(painter, fm, bcascii, fcascii, b, xascii, y);
	}
}
Esempio n. 6
0
void DrawSVG::Write(QString filename)
{
	if(!canvas) return;
	QSvgGenerator generator;
	generator.setFileName(filename);
	generator.setSize(QSize(canvas->width(), canvas->height()));
	generator.setTitle("MLDemos screenshot");
	generator.setDescription("Generated with MLDemos");
	QPainter painter;
	painter.begin(&generator);
	// we need to paint the different layers:
	// confidence map
	// samples + trajectories + reward
	canvas->PaintStandard(painter, true);
    if(canvas->bDisplayLearned)
	{
		// learned model
        painter.setBackgroundMode(Qt::TransparentMode);
        if(classifier) DrawClassificationSamples(canvas, painter, classifier, classifierMulti);
		if(regressor) drawRegr->DrawModel(canvas, painter, regressor);
		if(dynamical) drawDyn->DrawModel(canvas, painter, dynamical);
        if(clusterer) drawClust->DrawModel(canvas, painter, clusterer);
        if(projector) drawProj->DrawModel(canvas, painter, projector);
        if(dynamical)
		{
			int cnt = 10000; // not too many or it will make unreadable files
			int steps = 8;
			VectorsFast(cnt, steps, painter);
		}
		if(maximizer)
		{
			Maximization(painter);
		}
	}

	if(canvas->bDisplayInfo)
	{
		// model info
        painter.setBackgroundMode(Qt::TransparentMode);
        if(classifier) drawClass->DrawInfo(canvas, painter, classifier);
		if(regressor) drawRegr->DrawInfo(canvas, painter, regressor);
		if(dynamical) drawDyn->DrawInfo(canvas, painter, dynamical);
		if(clusterer) drawClust->DrawInfo(canvas, painter, clusterer);
        if(projector) drawProj->DrawInfo(canvas, painter, projector);
    }
	painter.end();
}
Esempio n. 7
0
void QHexEditPrivate::drawParts(QPainter &painter)
{
	int span = this->_charwidth / 2;
	painter.setBackgroundMode(Qt::TransparentMode);
	painter.setPen(this->palette().color(QPalette::WindowText));
	painter.drawLine(this->_xposhex - span, 0, this->_xposhex - span, this->height());
	painter.drawLine(this->_xposascii - span, 0, this->_xposascii - span, this->height());
	painter.drawLine(this->_xPosend + span, 0, this->_xPosend + span, this->height());
}
Esempio n. 8
0
void
drawCompositedPopup( QWidget* widget,
                     const QPainterPath& outline,
                     const QColor& lineColor,
                     const QBrush& backgroundBrush,
                     qreal opacity )
{
    bool compositingWorks = true;
#if defined(Q_WS_WIN)   //HACK: Windows refuses to perform compositing so we must fake it
    compositingWorks = false;
#elif defined(Q_WS_X11)
    if ( !QX11Info::isCompositingManagerRunning() )
        compositingWorks = false;
#endif

    QPainter p;
    QImage result;
    if ( compositingWorks )
    {
        p.begin( widget );
        p.setRenderHint( QPainter::Antialiasing );
        p.setBackgroundMode( Qt::TransparentMode );
    }
    else
    {
        result =  QImage( widget->rect().size(), QImage::Format_ARGB32_Premultiplied );
        p.begin( &result );
        p.setCompositionMode( QPainter::CompositionMode_Source );
        p.fillRect( result.rect(), Qt::transparent );
        p.setCompositionMode( QPainter::CompositionMode_SourceOver );
    }

    QPen pen( lineColor );
    pen.setWidth( 2 );
    p.setPen( pen );
    p.drawPath( outline );

    p.setOpacity( opacity );
    p.fillPath( outline, backgroundBrush );
    p.end();

    if ( !compositingWorks )
    {
        QPainter finalPainter( widget );
        finalPainter.setRenderHint( QPainter::Antialiasing );
        finalPainter.setBackgroundMode( Qt::TransparentMode );
        finalPainter.drawImage( 0, 0, result );
        widget->setMask( QPixmap::fromImage( result ).mask() );
    }

#ifdef QT_MAC_USE_COCOA
    // Work around bug in Qt/Mac Cocoa where opening subsequent popups
    // would incorrectly calculate the background due to it not being
    // invalidated.
    SourceTreePopupHelper::clearBackground( widget );
#endif
}
Esempio n. 9
0
void TextCanvas::draw(QPainter & p)
{
    if (! visible()) return;

    p.setRenderHint(QPainter::Antialiasing, true);
    QColor bgcolor = p.background().color();
    QPen fgcolor = p.pen();
    QBrush backgroundColor = p.background();

    if (bg_c == UmlTransparent)
        p.setBackgroundMode(::Qt::TransparentMode);
    else {
        p.setBackgroundMode(::Qt::OpaqueMode);
        //p.setBackgroundColor(color(bg_c));
        backgroundColor.setColor(bg_c);
        p.setBackground(backgroundColor);
    }

    if (fg_c != UmlTransparent)
        p.setPen(color(fg_c));

    QRect r = rect();

    p.setFont(the_canvas()->get_font(itsfont));
    p.drawText(r.left(), r.top(), r.width(), r.height(),
               ::Qt::AlignLeft + ::Qt::AlignTop + ::Qt::TextWordWrap, text);

    FILE * fp = svg();

    if (fp != 0)
        draw_text(r.left(), r.top(), r.width(), r.height(),
                  ::Qt::AlignLeft + ::Qt::AlignTop + ::Qt::TextWordWrap,
                  text, p.font(), fp, fg_c, bg_c);

    p.setFont(the_canvas()->get_font(UmlNormalFont));
    backgroundColor.setColor(bgcolor);
    //p.setBackgroundColor(bgcolor);
    p.setBackground(backgroundColor);
    p.setPen(fgcolor);

    if (selected())
        show_mark(p, r);
}
Esempio n. 10
0
void CommandPanel::drawPanel(QPainter& painter, const QRect& clipRect)
{
   QColor textColor = palette().color(QPalette::Text);
   QColor backgroundColor = palette().color(QPalette::Background);
   QColor disabledTextColor = blendColor(textColor, backgroundColor);
   //
   painter.setRenderHint(QPainter::TextAntialiasing);
   //
   painter.setPen(Qt::NoPen);
   painter.setBrush(backgroundColor);
   painter.drawRect(clipRect);
   //
   painter.setFont(font());
   painter.setPen(textColor);
   painter.setBackgroundMode(Qt::OpaqueMode);
   painter.setBackground(backgroundColor);
   //
   std::list<CommandOption>::const_iterator it = options_.items().begin(), itEnd = options_.items().end();
   for(int i=0;it!=itEnd;++it, ++i)
   {
      assert(i<(int)rects_.size());
      //
      QRect rect(rects_[i]);
      QRect textRect(rect);
      textRect.setBottom(textRect.bottom()-cUnderlineHeight);
      //
      if(!rect.intersects(clipRect)) continue;
      //
      if(i==pressedIndex_)
      {
         painter.setPen(backgroundColor);
         painter.setBackground(textColor);
         painter.drawText(textRect, Qt::AlignHCenter, it->text());
      }
      else if(enabled_[i])
      {
         painter.setPen(textColor);
         //
         QRect underlineRect(rect.left(), rect.bottom()-cUnderlineHeight,
                             rect.width()-1, cUnderlineHeight);
         if(i==highlightedIndex_ && showHighlight_)
         {
            painter.setBrush(textColor);
            painter.drawRect(underlineRect);
         }
         //
         painter.drawText(textRect, Qt::AlignCenter, it->text());
      }
      else
      {
         painter.setPen(disabledTextColor);
         painter.drawText(textRect, Qt::AlignCenter, it->text());
      }
   }
}
Esempio n. 11
0
void TEWidget::drawAttrStr(QPainter &paint, QRect rect,
                           QString& str, ca attr, BOOL pm, BOOL clear)
{
  //qDebug("begin TEWidget::drawAttrStr");
  if (pm && color_table[attr.b].transparent)
  {
    paint.setBackgroundMode( TransparentMode );
    if (clear) 
    {
      // erase(rect);
      qDebug("org code : erase(rect);");
    }
  }
  else
  {
    if (blinking)
    {
      paint.fillRect(rect, color_table[attr.b].color); // draw cursor
      qDebug("\tdarw cursor");
    }
    else
    {
      paint.setBackgroundMode(Qt::OpaqueMode);
      //paint.setBackgroundColor( color_table[attr.b].color );
      qDebug("org code : paint.setBackgroundColor( color_table[attr.b].color );");
    }
  }


  if (color_table[attr.f].bold)
    paint.setPen(QColor( 0x8F, 0x00, 0x00 ));
  else
    paint.setPen(color_table[attr.f].color);

  paint.drawText(rect.x(),rect.y()+font_a, str);

  static int count=0;
  if (attr.r & RE_UNDERLINE)
    paint.drawLine(rect.left(), rect.y()+font_a+1, rect.right(),rect.y()+font_a+1 );
  //qDebug("\t%d  str : %s", count++,str.toStdString().c_str() );
  //qDebug("end TEWidget::drawAttrStr");
}
Esempio n. 12
0
void SdLifeLineCanvas::drawShape(QPainter & p)
{
    if (end == 0)
        // masked by user
        return;

    p.setBackgroundMode(::Qt::OpaqueMode);
    p.setRenderHint(QPainter::Antialiasing, true);
    p.setPen(::Qt::DashLine);

    int m = (int)(x() + width() / 2);
    FILE * fp = svg();

    p.drawLine(m, (int) y(), m, end);

    p.setPen(::Qt::SolidLine);

    if (end != LIFE_LINE_HEIGHT) {
        int b = end + (int) width();

        p.drawLine((int) x(), end,
                   (int)(x() + width()) - 1, b);
        p.drawLine((int)(x() + width() - 1), end,
                   (int) x(), b);

        if (fp != 0) {
            fprintf(fp, "<g>\n"
                    "\t<line stroke=\"black\" stroke-dasharray=\"18,6\"  stroke-opacity=\"1\""
                    " x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n"
                    "</g>\n",
                    m, (int) y(), m, end);

            fprintf(fp, "<g>\n"
                    "\t<line stroke=\"black\" stroke-opacity=\"1\""
                    " x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
                    (int) x(), end, (int)(x() + width()) - 1, b);
            fprintf(fp, "\t<line stroke=\"black\" stroke-opacity=\"1\""
                    " x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n"
                    "</g>\n",
                    (int)(x() + width() - 1), end, (int) x(), b);
        }
    }
    else if (fp != 0)
        fprintf(fp, "<g>\n"
                "\t<line stroke=\"black\" stroke-dasharray=\"18,6\"  stroke-opacity=\"1\""
                " x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n"
                "</g>\n",
                m, (int) y(), m, svg_height());
}
Esempio n. 13
0
QPixmap WelcomeWidget::fromSvg(QRectF _rect, const QString &file) {
  PlexyDesk::ImageCache *cache = PlexyDesk::ImageCache::instance();
  QImage pixmap(_rect.width(), _rect.height(),
                QImage::Format_ARGB32_Premultiplied);
  QPainter painter;
  painter.begin(&pixmap);
  painter.setBackgroundMode(Qt::TransparentMode);
  painter.setCompositionMode(QPainter::CompositionMode_Source);
  painter.fillRect(_rect, Qt::transparent);
  painter.save();
  painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
  cache->drawSvg(&painter, _rect, file);
  painter.restore();
  painter.end();

  return QPixmap::fromImage(pixmap);
}
Esempio n. 14
0
void
DynamicWidget::paintRoundedFilledRect( QPainter& p, QPalette& pal, QRect& r, qreal opacity )
{   
    p.setBackgroundMode( Qt::TransparentMode );
    p.setRenderHint( QPainter::Antialiasing );
    p.setOpacity( opacity );
    
    QPen pen( pal.dark().color(), .5 );
    p.setPen( pen );
    p.setBrush( pal.highlight() );
    
    p.drawRoundedRect( r, 10, 10 );
    
    p.setOpacity( opacity + .2 );
    p.setBrush( QBrush() );
    p.setPen( pen );
    p.drawRoundedRect( r, 10, 10 );
}
Esempio n. 15
0
void QGraph::DrawGraph(QPainter &painter)
{
	static QColor color;
	painter.save();

//	Paint background
//	QBrush bg(m_BkColor);
//	painter.setBackground(bg);

//	Draw Border
	if(m_bBorder) color = m_BorderColor;
	else          color = m_BkColor;
	QPen BorderPen(color);
	BorderPen.setStyle(GetStyle(m_BorderStyle));
	BorderPen.setWidth(m_BorderWidth);

	painter.setPen(BorderPen);
	painter.fillRect(m_rCltRect, m_BkColor);
	painter.drawRect(m_rCltRect);
	Init();

	painter.setClipRect(m_rCltRect);

	painter.setBackgroundMode(Qt::TransparentMode);

	if(m_bXMinGrid) DrawXMinGrid(painter);
	if(m_bYMinGrid) DrawYMinGrid(painter);
	if(m_bXMajGrid) DrawXMajGrid(painter);
	if(m_bYMajGrid) DrawYMajGrid(painter);

	DrawAxes(painter);

	DrawXTicks(painter);

	DrawYTicks(painter);

	for (int nc=0; nc < m_oaCurves.size(); nc++)	DrawCurve(nc,painter);

	DrawTitles(painter);

	painter.setClipping(false);
	painter.restore();
}
Esempio n. 16
0
void
DynamicWidget::paintRoundedFilledRect( QPainter& p, QPalette& /* pal */, QRect& r, qreal opacity )
{
    p.setBackgroundMode( Qt::TransparentMode );
    p.setRenderHint( QPainter::Antialiasing );
    p.setOpacity( opacity );

    QColor c( 30, 30, 30 );

    QPen pen( c.darker(), .5 );
    p.setPen( pen );
    p.setBrush( c );

    p.drawRoundedRect( r, 10, 10 );

    p.setOpacity( opacity + .2 );
    p.setBrush( QBrush() );
    p.setPen( pen );
    p.drawRoundedRect( r, 10, 10 );
}
Esempio n. 17
0
void SubjectCanvas::draw(QPainter & p) {
  if (! visible()) return;
  p.setRenderHint(QPainter::Antialiasing, true);
  QRect r = rect();
  QColor bckgrnd = p.backgroundColor();

  p.setBackgroundMode((used_color == UmlTransparent) ? ::Qt::TransparentMode : ::Qt::OpaqueMode);

  QColor co = color(used_color);
  FILE * fp = svg();

  if (fp != 0)
    fputs("<g>\n", fp);  
  
  p.setBackgroundColor(co);
  p.setFont(the_canvas()->get_font(UmlNormalBoldFont));
  
  if (used_color != UmlTransparent)
    p.fillRect(r, co);
  
  if (fp != 0)
    fprintf(fp, "\t<rect fill=\"%s\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\""
	    " x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" />\n",
	    svg_color(used_color), 
	    r.x(), r.y(), r.width() - 1, r.height() - 1);

  p.drawRect(r);
  
  r.setTop(r.top() + (int) (2*the_canvas()->zoom()));
  p.drawText(r, ::Qt::AlignHCenter + ::Qt::AlignTop, name);
  if (fp != 0) {
    draw_text(r, ::Qt::AlignHCenter + ::Qt::AlignTop, name,
	      p.font(), fp);
    fputs("</g>\n", fp);
  }
    
  p.setBackgroundColor(bckgrnd);
  
  if (selected())
    show_mark(p, rect());
}
Esempio n. 18
0
void IconCanvas::draw(QPainter & p) {
  if (! visible()) return;
  p.setRenderHint(QPainter::Antialiasing, true);
  QRect r = rect();
  
  p.setBackgroundMode(::Qt::OpaqueMode);
  
  p.drawPixmap(r.topLeft(), *(browser_node->pixmap(0)));
    
  if (selected())
    show_mark(p, r);

  FILE * fp = svg();
  
  if (fp != 0) {
    fprintf(fp, "<g transform=\"translate(%d,%d)\">\n", 
	    r.left(), r.top());
    ((BrowserDiagram *) browser_node)->draw_svg();
    fputs("</g>\n", fp);
  }
}
Esempio n. 19
0
// --------------------------------------------------------------------------------------------------------------------------------------
void CCachedGraphicsItem::updateCache()
{
    if(isActive())
    {
        QPixmap *pixmap = new QPixmap(size().toSize());
        pixmap->fill(QColor(0,0,0,0));

        QPainter *painter = new QPainter(pixmap);
        painter->setBackgroundMode(Qt::TransparentMode);
        painter->setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::HighQualityAntialiasing, true);
        painter->setPen(m_stdPen);
        painter->setBrush(m_stdBrush);
        painter->setFont(m_stdFont);

        paintToCache(painter);

        delete painter;
        QPixmap *tmp = m_pixmap;
        m_pixmap = pixmap;
        delete tmp;
        //update(boundingRect());
    }
}
Esempio n. 20
0
void InterruptibleActivityRegionCanvas::draw(QPainter & p) {
  if (! visible()) return;
  
  QRect r = rect();
  QBrush brsh = p.brush();
  QColor bckgrnd = p.backgroundColor();
  
  p.setBackgroundMode((used_color == UmlTransparent)
		      ? ::Qt::TransparentMode
		      : ::Qt::OpaqueMode);

  QColor co = color(used_color);
  
  p.setBackgroundColor(co);
  
  if (used_color != UmlTransparent) 
    p.setBrush(co);
  
  p.setPen(::Qt::DotLine);
  p.drawRoundRect(r, 8, 8);

  FILE * fp = svg();

  if (fp != 0)
    fprintf(fp,
	    "\t<rect fill=\"%s\" stroke=\"black\" stroke-dasharray=\"4,4\" stroke-opacity=\"1\""
	    " x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" rx=\"10\" />\n",
	    svg_color(used_color),
	    r.left(), r.top(), r.width() - 1, r.height() - 1);
  
  p.setPen(::Qt::SolidLine);      
  p.setBackgroundColor(bckgrnd);
  p.setBrush(brsh);
  
  if (selected())
    show_mark(p, r);
}
Esempio n. 21
0
			void PiecesWidget::paintEvent (QPaintEvent *e)
			{
				int s = Pieces_.size ();
				QPainter painter (this);
				painter.setRenderHints (QPainter::Antialiasing |
						QPainter::SmoothPixmapTransform);
				if (!s)
				{
					painter.setBackgroundMode (Qt::OpaqueMode);
					painter.setBackground (Qt::white);
					painter.end ();
					return;
				}
			
				const QPalette& palette = QApplication::palette ();
				const QColor& backgroundColor = palette.color (QPalette::Base);
				const QColor& downloadedPieceColor = palette.color (QPalette::Highlight);

				QPixmap tempPicture (s, 1);
				QPainter tempPainter (&tempPicture);
				tempPainter.setPen (backgroundColor);
				tempPainter.drawLine (0, 0, s, 0);
				QList<QPair<int, int> > trues = FindTrues (Pieces_);
				for (int i = 0; i < trues.size (); ++i)
				{
					QPair<int, int> pair = trues.at (i);
			
					tempPainter.setPen (downloadedPieceColor);
					tempPainter.drawLine (pair.first, 0, pair.second, 0);
				}
				tempPainter.end ();
			
				painter.drawPixmap (QRect (0, 0, width (), height ()), tempPicture);
				painter.end ();
			
				e->accept ();
			}
Esempio n. 22
0
void FragmentSeparatorCanvas::drawShape(QPainter & p) {
  p.setBackgroundMode(::Qt::TransparentMode);
  p.setRenderHint(QPainter::Antialiasing, true);
  p.setPen(::Qt::DashLine);
  
  int m = (int) (fragment->y() + fragment->height() * vpos);
  
  p.drawLine((int) fragment->x(), m,
	     (int) fragment->x() + fragment->width() - 1, m);
  
  p.setPen(::Qt::SolidLine);


  FILE * fp = svg();

  if (fp != 0)
    fprintf(fp, "<g>\n\t<line stroke=\"black\" stroke-dasharray=\"20,4\" stroke-opacity=\"1\""
	    " x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n</g>\n",
	    (int) fragment->x(), m,
	    (int) fragment->x() + fragment->width() - 1, m);
  
  if (selected())
    show_mark(p, rect());
}
QImage Utils::applyHomography(MatrixXd H, QImage inputImage, QList<Dot*> region)
{
    MatrixXd x(3,1);
    MatrixXd y(3,1);
    vector<double> x_values;
    vector<double> y_values;

    int height_output = 454;
    int width_output = 604;

    // Calculate output image corners
    x << region.at(0)->x(), region.at(0)->y(), 1;
    y = H*x;
    x_values.push_back(y(0,0)/y(2,0));
    y_values.push_back(y(1,0)/y(2,0));

    x << region.at(1)->x(), region.at(1)->y(), 1;
    y = H*x;
    x_values.push_back(y(0,0)/y(2,0));
    y_values.push_back(y(1,0)/y(2,0));

    x << region.at(2)->x(), region.at(2)->y(), 1;
    y = H*x;
    x_values.push_back(y(0,0)/y(2,0));
    y_values.push_back(y(1,0)/y(2,0));

    x << region.at(3)->x(), region.at(3)->y(), 1;
    y = H*x;
    x_values.push_back(y(0,0)/y(2,0));
    y_values.push_back(y(1,0)/y(2,0));

    double max_x = (*max_element(x_values.begin(), x_values.end()));
    double min_x = (*min_element(x_values.begin(), x_values.end()));
    double max_y = (*max_element(y_values.begin(), y_values.end()));
    double min_y = (*min_element(y_values.begin(), y_values.end()));
    height_output = width_output / ((max_x-min_x)/(max_y-min_y));

    QImage outputImage(width_output, height_output, QImage::Format_ARGB32);
    QPainter painter;
    painter.begin(&outputImage);
    painter.setRenderHint(QPainter::Antialiasing);
    painter.setBackgroundMode(Qt::TransparentMode);
    QPen pen;

    H = H.inverse().eval();

    double step = (max_x - min_x) / width_output;

    for (int i=0; i < height_output; i++)
    {
        for (int j=0; j<width_output; j++)
        {
            x << min_x+j*step, min_y+i*step, 1;
            y = H*x;

            y << y(0,0)/y(2,0), y(1,0)/y(2,0), 1;

            if (y(0,0) >= 0 && y(0,0) <= inputImage.width() - 1
                    && y(1,0) >= 0 && y(1,0) <= inputImage.height() - 1)
            {
                // Point lies inside the input Image

                // Do interpolation
                QColor c = interpolate(inputImage, y);
                //QRgb clrCurrent( inputImage.pixel( y(0,0), y(1,0) ) );
                pen.setColor(c);
                pen.setWidth(1);
                pen.setCapStyle(Qt::RoundCap);
                painter.setPen(pen);
                painter.drawPoint(j, i);

            }
            else
            {
                // Point lies outside the input Image
                QColor clrCurrent(0,0,0);
                pen.setColor(clrCurrent);
                pen.setWidth(1);
                pen.setCapStyle(Qt::RoundCap);
                painter.setPen(pen);
                painter.drawPoint(j, i);
            }
        }
    }
    painter.end();
    return outputImage;
}
Esempio n. 24
0
void UcUseCaseCanvas::draw(QPainter & p) {
  if (! visible()) return;
  
  QRect r = rect();
  UseCaseData * data = (UseCaseData *) browser_node->get_data();
  p.setRenderHint(QPainter::Antialiasing, true);
  used_color = (itscolor == UmlDefaultColor)
    ? the_canvas()->browser_diagram()->get_color(UmlUseCase)
    : itscolor;
  
  QColor col = color(used_color);
  QBrush brsh = p.brush();
  bool realizationp =
    !strcmp(data->get_short_stereotype(), "realization");
  FILE * fp = svg();
  int rx = width()/2 - 1;
  int ry = height()/2 - 1;

  if (fp != 0)
    fputs("<g>\n", fp);
  
  if (used_color != UmlTransparent) {
    const int shadow = the_canvas()->shadow() - 1;
    
    if (shadow != -1) {
      r.setRight(r.right() - shadow);
      r.setBottom(r.bottom() - shadow);
      p.setPen(::Qt::NoPen);
      p.setBrush(::Qt::darkGray);
      p.drawEllipse(r.left() + shadow, r.top() + shadow, r.width(), r.height());

      if (fp != 0) {
	rx = width()/2 - 1;
	ry = height()/2 - 1;

	fprintf(fp, "\t<ellipse fill=\"#%06x\" stroke=\"none\""
		" cx=\"%d\" cy=\"%d\" rx=\"%d\" ry=\"%d\" />\n",
		QColor(::Qt::darkGray).rgb()&0xffffff,
		r.left() + shadow + rx, r.top() + shadow + ry, rx, ry);
      }
    }

    if (fp != 0)
      fprintf(fp, "\t<ellipse fill=\"%s\" stroke=\"black\"%s stroke-width=\"1\" stroke-opacity=\"1\""
	      " cx=\"%d\" cy=\"%d\" rx=\"%d\" ry=\"%d\" />\n",
	      svg_color(used_color),
	      (realizationp) ? " stroke-dasharray=\"4,4\"" : "",
	      r.left() + rx, r.top() + ry, rx, ry);
  }
  else if (fp != 0)
    fprintf(fp, "\t<ellipse fill=\"none\" stroke=\"black\"%s stroke-width=\"1\" stroke-opacity=\"1\""
	    " cx=\"%d\" cy=\"%d\" rx=\"%d\" ry=\"%d\" />\n",
	    (realizationp) ? " stroke-dasharray=\"4,4\"" : "",
	    r.left() + rx, r.top() + ry, rx, ry);
  
  p.setBackgroundMode((used_color == UmlTransparent) ? ::Qt::TransparentMode : ::Qt::OpaqueMode);
  p.setBrush(col);

  if (realizationp)
    p.setPen(::Qt::DotLine);
  else
    p.setPen(::Qt::SolidLine);
  p.drawEllipse(r.left(), r.top(), r.width(), r.height());
  if (realizationp)
    p.setPen(::Qt::SolidLine);

  QString ep = data->get_extension_points();
  
  if (!ep.isEmpty()) {
    QFontMetrics fbm(the_canvas()->get_font(UmlNormalBoldFont));
    const int two = (int) (2 * the_canvas()->zoom());
    int he = fbm.height() + two;
    int py = (int) y() + height()/4;
    int dx = width() / 15;
    int px = (int) x() + dx;
    
    p.drawLine(px, py, r.right() - dx, py);
    if (fp != 0)
      fprintf(fp, "\t<line stroke=\"black\" stroke-opacity=\"1\""
	      " x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
	      px, py, r.right() - dx, py);
    
    int h = (height() * 3) / 4 - two;
    int w = width() - dx - dx;
    QColor bckgrnd = p.backgroundColor();
    
    py += two;
    p.setBackgroundColor(col);
    p.setFont(the_canvas()->get_font(UmlNormalBoldFont));

    p.drawText(px, py, w, h, ::Qt::AlignHCenter + ::Qt::AlignTop,
	       "Extension Points");
    if (fp != 0)
      draw_text(px, py, w, h, ::Qt::AlignHCenter + ::Qt::AlignTop, 
		"Extension Points", p.font(), fp);
    
    h -= he;
    
    if (h > he) {
      // at least one line may be written
      py += he;
      p.setFont(the_canvas()->get_font(UmlNormalFont));
      p.drawText(px, py, w, h, ::Qt::AlignCenter, ep);
      p.setBackgroundColor(bckgrnd);
      
      if (fp != 0)
	draw_text(px, py, w, h, ::Qt::AlignCenter, ep, p.font(), fp);
    }
  }
  
  if (fp != 0)
    fputs("</g>\n", fp);
  
  p.setBrush(brsh);
  
  if (selected())
    show_mark(p, rect());
}
Esempio n. 25
0
void FragmentCanvas::draw(QPainter & p) {
  if (! visible()) return;
  p.setRenderHint(QPainter::Antialiasing, true);
  QFontMetrics fm(the_canvas()->get_font(UmlNormalFont));
  int w = fm.width((name.isEmpty()) ? QString("X") : name);
  int h = fm.height() / 2;  
  QRect r = rect();
  QRect rname = r;
  
  rname.setWidth(w + h);
  rname.setHeight(fm.height() + h);
  
  int h1 = (fm.height() + h)/2;
  int x1 = rname.right() + h1;
  int y1 = rname.bottom() - h1;
  
  QColor bckgrnd = p.backgroundColor();

  p.setBackgroundMode((used_color == UmlTransparent) ? ::Qt::TransparentMode : ::Qt::OpaqueMode);

  QColor co = color(used_color);
  FILE * fp = svg();

  if (fp != 0)
    fputs("<g>\n", fp);
  
  p.setBackgroundColor(co);
  p.setFont(the_canvas()->get_font(UmlNormalFont));
  
  if (used_color != UmlTransparent)
    p.fillRect(r, co);
  else if (!name.isEmpty()) {
    Q3PointArray a(6);
    QBrush brsh = p.brush();
    
    a.setPoint(0, rname.left(), rname.top());
    a.setPoint(1, x1, rname.top());
    a.setPoint(2, x1, y1);
    a.setPoint(3, rname.right(), rname.bottom());
    a.setPoint(4, rname.left(), rname.bottom());
    a.setPoint(5, rname.left(), rname.top());

    p.setBrush(UmlWhiteColor);
    p.drawPolygon(a, TRUE, 0, 5);
    p.setBrush(brsh);
    
    if (fp != 0)
      draw_poly(fp, a, UmlWhite);
  }

  if (fp != 0)
    fprintf(fp, "\t<rect fill=\"%s\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\""
	    " x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" />\n",
	    svg_color(used_color), 
	    r.x(), r.y(), r.width() - 1, r.height() - 1);
  
  p.drawRect(r);
  
  if (refer != 0) {
    QString s = refer->get_name() + form;
    QRect r2(r.left(), r.top() + 2*fm.height(),
	     r.width(), fm.height());

    p.drawText(r2, ::Qt::AlignCenter, s);
    
    if (fp != 0)
      draw_text(r2, ::Qt::AlignCenter, s,
		p.font(), fp);
  }
  
  if (!name.isEmpty())
    p.drawText(rname, ::Qt::AlignCenter, name);
  if (fp != 0)
    draw_text(rname, ::Qt::AlignCenter, name,
	      p.font(), fp);
  
  p.drawLine(rname.left(), rname.bottom(), rname.right(), rname.bottom());
  p.drawLine(rname.right(), rname.bottom(), x1, y1);
  p.drawLine(x1, y1, x1, rname.top());

  if (fp != 0) {
    fprintf(fp, "\t<line stroke=\"black\" stroke-opacity=\"1\""
	    " x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
	    rname.left(), rname.bottom(), rname.right(), rname.bottom());
    fprintf(fp, "\t<line stroke=\"black\" stroke-opacity=\"1\""
	    " x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
	    rname.right(), rname.bottom(), x1, y1);
    fprintf(fp, "\t<line stroke=\"black\" stroke-opacity=\"1\""
	    " x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
	    x1, y1, x1, rname.top());
    fputs("</g>\n", fp);
  }
	       
  p.setBackgroundColor(bckgrnd);
  
  if (selected())
    show_mark(p, r);
}
Esempio n. 26
0
//////////////////////////////////////////////////////////////////////////////
// draw
//////////////////////////////////////////////////////////////////////////////
void CrossTab::Draw(QPainter & paint)
{
  paint.save();

  // Calculate the number of rows and columns that we can display
  int lastColumn(0);
  int lastRow(0);

  CalculateDisplayedRowsAndColumns(lastColumn, lastRow, m_rect);

  paint.drawRect(m_rect);

  QRect sampleRect(0,0,0,0); // Name itemRectangle
  QRect saveRect(0,0,0,0);

  int idRow=m_rowIndexStored;
  int idCol=m_columnIndexStored;

  // Start at the correct place
  CrossTabRowIndex::iterator    rowIt(m_rowIndex.begin());
  CrossTabColumnIndex::iterator columnIt(m_columnIndex.begin());
  for (idRow = 0, rowIt = m_rowIndex.begin() ; ((idRow <= lastRow) && (rowIt != m_rowIndex.end())); ++idRow, ++rowIt)
  {
    // Should this row cell be displayed
    //    Skip header column if not wanted
    if ( ((0 == idRow) && (0 != m_rowIndexStored) && !m_columnHeaderEachPage) ||
         //Skip already displayed rows          
         ((0 < idRow) && (idRow < m_rowIndexStored)) ||
         //Skip rows that are not part of the already drawn table part
         (m_tableWrapDisplayAllColumnsFirst && (0 < idRow) && (idRow > m_rowIndexStoredLast) && (0 != m_columnIndexStored)) )
    {
      continue;
    }

    for (idCol = 0, columnIt = m_columnIndex.begin() ; ((idCol <= lastColumn) && (columnIt != m_columnIndex.end())); ++idCol, ++columnIt)
    {
      // Should this column cell be displayed
           // Skip header row if not wanted
      if (((0 == idCol) && (0 != m_columnIndexStored) && !m_rowHeaderEachPage) ||
           // Skip already displayed columns
          ((0 < idCol) && (idCol < m_columnIndexStored)))
      {
        continue;
      }

      // Get width of this column
      QString dataTekst (columnIt.key());
      sampleRect.setWidth  (columnIt.value().m_columnMaxWidth + m_cellLeftMargin + m_cellRightMargin);
      sampleRect.setHeight (rowIt.value().m_rowMaxHeight + m_cellTopMargin + m_cellBottomMargin);

      // Save rectangle
      saveRect = sampleRect;

      paint.setBackgroundMode(Qt::OpaqueMode);
      // Draw headers row
      if  (idRow == 0)
      {
        paint.setBrush(QBrush(QColor(0, 0, 255, 127), Qt::SolidPattern));
      }
      // Header column
      else if  ((idRow != 0) && (idCol == 0))
      {
        // Odd rows
        if ((idRow%2) != 0 )
        {
          paint.setBrush(QBrush(QColor(0, 0, 255, 200), Qt::SolidPattern));
        }
        // Even rows
        else
        {
          paint.setBrush(QBrush(QColor(90, 210, 255, 150), Qt::SolidPattern));
        }
      }
      // Values
      else if  ((idRow != 0) && (idCol != 0))
      {
        // Odd rows
        if ((idRow%2) != 0 )
        {
          paint.setBrush(QBrush(QColor(0, 0, 0, 0), Qt::SolidPattern));
        }
        // Even rows
        else
        {
          paint.setBrush(QBrush(QColor(90, 210, 255, 127), Qt::SolidPattern));
        }
      }

      // Draw rectangle
      paint.drawRect(sampleRect);

      paint.setBackgroundMode(Qt::TransparentMode);
      paint.setPen(Qt::SolidLine);

      // Skip margins: Adjust rectangle for data insertion
      sampleRect.setX(sampleRect.x() + m_cellLeftMargin);
      sampleRect.setY(sampleRect.y() + m_cellTopMargin);
      sampleRect.setWidth  (columnIt.value().m_columnMaxWidth);
      sampleRect.setHeight (rowIt.value().m_rowMaxHeight);

      // get Font
      QFontMetrics fm(GetFont());
      QRect        dataRect;

      // Header
      if ((idRow == 0) && (idCol == 0))
      {
        // Do nothing
      }
      // Headerrow
      else if ((idRow == 0) && (idCol != 0))
      {
        dataRect = fm.boundingRect(sampleRect, m_hAlignMap["column"] | m_vAlignMap["column"], columnIt.key());
        paint.drawText(dataRect, m_hAlignMap["column"] | m_vAlignMap["column"], columnIt.key());
      }
      // Headercol
      else if ((idCol == 0) && (idRow != 0))
      {
        dataRect = fm.boundingRect(sampleRect, m_hAlignMap["row"] | m_vAlignMap["row"], rowIt.key());
        paint.drawText(dataRect, m_hAlignMap["row"] | m_vAlignMap["row"], rowIt.key());
      }
      // Value
      else
      {
        dataRect = fm.boundingRect(sampleRect, m_hAlignMap["value"] | m_vAlignMap["value"], GetValue(columnIt.key(), rowIt.key()));
        paint.drawText(dataRect, m_hAlignMap["value"] | m_vAlignMap["value"], GetValue(columnIt.key(), rowIt.key()));
      }
      // Restore rectangle
      sampleRect = saveRect;
      sampleRect.setX(sampleRect.x() + sampleRect.width());
    } // end for

    // Reset basic column id
    idCol = m_columnIndexStored;

    // Adjust item display rectangle
    sampleRect.setY(sampleRect.y()+sampleRect.height());
    sampleRect.setX(0);
  }

  // Store indexes for iterative purpose
  m_rowIndexStored    = lastRow + 1;
  m_columnIndexStored = lastColumn + 1;

  // Now that we are done return the paint device back to the state
  // it was when we started to mess with it
  paint.restore();
}
Esempio n. 27
0
void QDial::repaintScreen( const QRect *cr )
{
    QPainter p;
    p.begin( this );

    bool resetClipping = FALSE;

    // calculate clip-region for erasing background
    if ( cr ) {
	p.setClipRect( *cr );
    } else if ( !d->onlyOutside && d->eraseAreaValid ) {
	QRegion reg = d->eraseArea;
	double a;
	reg = reg.subtract( calcArrow( a ) );
	p.setClipRegion( reg );
	resetClipping = TRUE;
    }

    QRect br( calcDial() );
    p.setPen( NoPen );
    // if ( style() == MotifStyle )
    // p.setBrush( colorGroup().brush( QColorGroup::Mid ) );
    // else {
    QBrush b;
    if ( colorGroup().brush( QColorGroup::Light ).pixmap() )
	b = QBrush( colorGroup().brush( QColorGroup::Light ) );
    else
	b = QBrush( colorGroup().light(), Dense4Pattern );
    p.setBrush( b );
    p.setBackgroundMode( OpaqueMode );
    // }

    QRect te = br;
    te.setWidth(te.width()+2);
    te.setHeight(te.height()+2);
    // erase background of dial
    if ( !d->onlyOutside ) {
	p.drawEllipse( te );
    }

    // erase remaining space around the dial
    QRegion remaining( 0, 0, width(), height() );
    remaining = remaining.subtract( QRegion( te, QRegion::Ellipse ) );
    if ( p.hasClipping() )
	remaining = remaining.intersect( p.clipRegion() );
    erase(remaining);

    if ( resetClipping ) {
	if ( cr )
	    p.setClipRect( *cr );
	else
	    p.setClipRect( QRect( 0, 0, width(), height() ) );
    }

    // draw notches
    if ( d->showNotches ) {
	calcLines();
	p.setPen( colorGroup().foreground() );
	p.drawLineSegments( d->lines );
    }

    // calculate and paint arrow
    p.setPen( QPen( colorGroup().dark() ) );
    p.drawArc( te, 60 * 16, 180 * 16 );
    p.setPen( QPen( colorGroup().light() ) );
    p.drawArc( te, 240 * 16, 180 * 16 );

    double a;
    QPointArray arrow( calcArrow( a ) );
    QRect ea( arrow.boundingRect() );
    d->eraseArea = ea;
    d->eraseAreaValid = TRUE;

    p.setPen( NoPen );
    p.setBrush( colorGroup().brush( QColorGroup::Button ) );
    if ( !d->onlyOutside )
	p.drawPolygon( arrow );

    a = angle( QPoint( width() / 2, height() / 2 ), arrow[ 0 ] );
    p.setBrush( Qt::NoBrush );

    // that's still a hack...
    if ( a <= 0 || a > 200 ) {
	p.setPen( colorGroup().light() );
	p.drawLine( arrow[ 2 ], arrow[ 0 ] );
	p.drawLine( arrow[ 1 ], arrow[ 2 ] );
	p.setPen( colorGroup().dark() );
	p.drawLine( arrow[ 0 ], arrow[ 1 ] );
    } else if ( a > 0 && a < 45 ) {
	p.setPen( colorGroup().light() );
	p.drawLine( arrow[ 2 ], arrow[ 0 ] );
	p.setPen( colorGroup().dark() );
	p.drawLine( arrow[ 1 ], arrow[ 2 ] );
	p.drawLine( arrow[ 0 ], arrow[ 1 ] );
    } else if ( a >= 45 && a < 135 ) {
	p.setPen( colorGroup().dark() );
	p.drawLine( arrow[ 2 ], arrow[ 0 ] );
	p.drawLine( arrow[ 1 ], arrow[ 2 ] );
	p.setPen( colorGroup().light() );
	p.drawLine( arrow[ 0 ], arrow[ 1 ] );
    } else if ( a >= 135 && a < 200 ) {
	p.setPen( colorGroup().dark() );
	p.drawLine( arrow[ 2 ], arrow[ 0 ] );
	p.setPen( colorGroup().light() );
	p.drawLine( arrow[ 0 ], arrow[ 1 ] );
	p.drawLine( arrow[ 1 ], arrow[ 2 ] );
    }

    // draw focus rect around the dial
    if ( hasFocus() ) {
	p.setClipping( FALSE );
	br.setWidth( br.width() + 2 );
	br.setHeight( br.height() + 2 );
	if ( d->showNotches ) {
	    int r = QMIN( width(), height() ) / 2;
	    br.moveBy( -r / 6, - r / 6 );
	    br.setWidth( br.width() + r / 3 );
	    br.setHeight( br.height() + r / 3 );
	}
	// strange, but else we get redraw errors on Windows
	p.end();
	p.begin( this );
	p.save();
	p.setPen( QPen( colorGroup().background() ) );
	p.setBrush( NoBrush );
	p.drawRect( br );
	p.restore();
	style().drawPrimitive( QStyle::PE_FocusRect, &p, br, colorGroup());
    }
    p.end();
}
Esempio n. 28
0
/*!

 */
void
PlayerPainter::drawText( QPainter & painter,
                         const PlayerPainter::Param & param ) const
{
    const Options & opt = Options::instance();

    char main_buf[64];
    std::memset( main_buf, 0, 64 );

    if ( opt.showPlayerNumber() )
    {
        char buf[8];
        snprintf( buf, 8, "%d", param.player_.unum_ );
        std::strcat( main_buf, buf );
    }

    if ( param.player_.hasStamina()
         && opt.showStamina() )
    {
        char buf[16];
        snprintf( buf, 16, "%4.0f", param.player_.stamina_ );
        if ( main_buf[0] != '\0' ) std::strcat( main_buf, "," );
        std::strcat( main_buf, buf );
    }

    if ( param.player_.hasStaminaCapacity()
         && opt.showStaminaCapacity() )
    {
        char buf[16];
        snprintf( buf, 16, "%.0f", param.player_.stamina_capacity_ );
        if ( main_buf[0] != '\0' )
        {
            if ( opt.showStamina() )
            {
                std::strcat( main_buf, "/" );
            }
            else
            {
                std::strcat( main_buf, "," );
            }
        }
        std::strcat( main_buf, buf );
    }

    if ( opt.showPlayerType() )
    {
        char buf[8];
        snprintf( buf, 8, "t%d", param.player_.type_ );
        if ( main_buf[0] != '\0' ) std::strcat( main_buf, "," );
        strcat( main_buf, buf );
    }

    painter.setFont( M_player_font );

    const int text_radius = std::min( 40, param.draw_radius_ );
    int card_offset = 0;

    if ( opt.showCard()
         && ( param.player_.hasRedCard()
              || param.player_.hasYellowCard() ) )
    {
        QFontMetrics fm = painter.fontMetrics();
        int x_size = std::max( 4, fm.ascent() - 2 );
        int y_size = std::max( 4, fm.ascent() );

        card_offset = x_size + 2;

        if ( opt.antiAliasing() )
        {
            painter.setRenderHint( QPainter::Antialiasing, false );
        }
        painter.setPen( Qt::black );
        painter.setBrush( param.player_.hasRedCard()
                          ? Qt::red
                          : Qt::yellow );
        painter.drawRect( param.x_ + text_radius,
                          param.y_ - y_size,
                          x_size, y_size );
        if ( opt.antiAliasing() )
        {
            painter.setRenderHint( QPainter::Antialiasing, true );
        }
    }

    if ( main_buf[0] != '\0' )
    {
        //painter.setPen( param.player_.side() == rcss::rcg::LEFT
        //                ? M_left_team_pen
        //                : M_right_team_pen );

        if ( text_radius < param.draw_radius_ )
        {
            painter.setPen( M_player_number_inner_pen );
        }
        else
        {
            painter.setPen( M_player_number_pen );
        }

        painter.setBrush( Qt::NoBrush );
        painter.drawText( param.x_ + text_radius + card_offset,
                          param.y_,
                          QString::fromAscii( main_buf ) );
        painter.setBackgroundMode( Qt::TransparentMode );
    }
}
Esempio n. 29
0
void ActivityPartitionCanvas::draw(QPainter & p) {
  if (! visible()) return;
  p.setRenderHint(QPainter::Antialiasing, true);
  
  QRect r = rect();
  FILE * fp = svg();
  QColor bckgrnd = p.backgroundColor();
  QColor co = color(used_color);
  
  p.setBackgroundMode((used_color == UmlTransparent)
		      ? ::Qt::TransparentMode
		      : ::Qt::OpaqueMode);

  
  p.setBackgroundColor(co);
  
  if (used_color != UmlTransparent)
    p.fillRect(r, co);
    
  p.setFont(the_canvas()->get_font(UmlNormalFont));
  
  QFontMetrics fm(p.font());
  int h = 3*fm.height();
    
  if (fp != 0) {
    fprintf(fp, "<g>\n\t<rect fill=\"%s\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\""
	    " x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" />\n",
	    svg_color(used_color), 
	    r.x(), r.y(), r.width() - 1, r.height() - 1);
  }
  
  p.drawRect(r);

  if (horiz) {
    if (! str.isEmpty()) { 
      p.save();
      p.rotate(-90);
      p.drawText(-r.y(), r.x(), -r.height(), h,
		 ::Qt::AlignCenter, str);
      p.restore();
      
      if (fp != 0) {
	int index = str.find('\n');
	
	if (index == -1)
	  draw_rotate_text(r.x() + h/2, r.y() + r.height()/2,
			   270, str, p.font(), fp);
	else {
	  int vc = r.y() + r.height()/2;
	  
	  draw_rotate_text(r.x() + h/4, vc,
			   270, str.left(index), p.font(), fp);
	  draw_rotate_text(r.x() + (h*3)/4, vc,
			   270, str.mid(index + 1), p.font(), fp);
	}
      }
    }
    
    r.setLeft(r.left() + h);
    p.drawLine(r.topLeft(), r.bottomLeft());
    
    if (fp) {
      fprintf(fp, "\t<line stroke=\"black\" stroke-opacity=\"1\""
	      " x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
	      r.left(), r.top(), r.left(), r.bottom());
      fputs("</g>\n", fp);
    }
  }
  else {
    if (! str.isEmpty()) { 
      p.drawText(r.x(), r.y(), r.width(), h,
		 ::Qt::AlignCenter, str);
      
      if (fp != 0)
	draw_text(r.x(), r.y(), r.width(), h,
		  ::Qt::AlignCenter, str, p.font(), fp);
    }
    
    r.setTop(r.top() + h);
    p.drawLine(r.topLeft(), r.topRight());
    
    if (fp) {
      fprintf(fp, "\t<line stroke=\"black\" stroke-opacity=\"1\""
	      " x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" />\n",
	      r.left(), r.top(), r.right(), r.top());
      fputs("</g>\n", fp);
    }
  }
  
  p.setBackgroundColor(bckgrnd);
  
  if (selected())
    show_mark(p, rect());
}
Esempio n. 30
0
void SdDurationCanvas::draw(QPainter & p) {
  const QRect r = rect();
  p.setRenderHint(QPainter::Antialiasing, true);
  UmlColor used_color = (itscolor != UmlDefaultColor)
    ? itscolor
    : browser_node->get_color(UmlActivityDuration);
  QColor co = color(used_color);
  
  int w = width() - 1;
  int x = r.left();
  int y = r.top();
  
  p.setBackgroundMode((used_color == UmlTransparent)
		      ? ::Qt::TransparentMode
		      : ::Qt::OpaqueMode);
  p.fillRect(r, co);
  if (coregion) {
    p.drawLine(x, y + w, x, y);



    //p.lineTo(x + w, y);
	p.drawLine(x, y, x + w, y);
   //p.lineTo(x + w, y + w);
   p.drawLine(x + w, y, x + w, y + w);
    
    int b = r.bottom();
    
    p.drawLine(x, b - w, x, b);



    //p.lineTo(x + w, b);
	p.drawLine(x, b, x + w, b);
    //p.lineTo(x + w, b - w);
	p.drawLine(x+w, b, x + w, b - w);
  }
  else
    p.drawRect(r);

  FILE * fp = svg();

  if (fp != 0) {
    if (coregion) {
      fprintf(fp, "<g>\n"
	      "\t<rect fill=\"%s\" stroke=\"none\" "
	      " x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" />\n"
	      "\t<path fill = \"none\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\" "
	      "d=\"M %d %d v %d h %d v %d M %d %d v %d h %d v %d\" />\n"
	      "</g>\n",
	      svg_color(used_color), 
	      x, y, w, r.height() - 1,
	      x, y + w, -w, w, w,
	      x, r.bottom() - w, w, w, -w);
    }
    else
      fprintf(fp, "<g>\n"
	      "\t<rect fill=\"%s\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\""
	      " x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" />\n"
	      "</g>\n",
	      svg_color(used_color), 
	      x, y, w, r.height() - 1);
  }
  
  if (selected())
    show_mark(p, r);
}