示例#1
0
void tGraph::draw(QPainter & paint) {
    //QPainter paint(this);
    paint.save();

    int gx1 = hPadding() + _rect.x();
    int gy1 = vPadding() + _rect.y();
    int gx2 = _rect.x() + width() - hPadding();
    int gy2 = _rect.y() + height() - vPadding();

    //paint.drawRect(gx1, gy1, gx2 - gx1, gy2 - gy1);

    QFontMetrics fm(font());
    //QRect brect;

    // get the dimensions of the title label and then draw it
    if(title().length() > 0) {
        fm = QFontMetrics(titleFont());
        //brect = fm.boundingRect(title());
        paint.setFont(titleFont());
        paint.drawText(gx1, gy1, gx2 - gx1, fm.height(), titleAlignment(), title());
        gy1 += fm.height();
    }

    // we need to do some drawing that depends on some other elements having
    // already been placed... since those require that these have already been
    // placed we will just save the old value of gy2 and then calculate the
    // value that we should have after the other code runs without actually
    // drawing anything right now
    int gy2_old = gy2;
    if(dataLabel().length() > 0) {
        fm = QFontMetrics(dataLabelFont());
        gy2 -= fm.height();
    }
    fm = QFontMetrics(dataFont());
    double tlh = 0.0;
    
    QMapIterator<int, GReference> dlit(_data);
    while(dlit.hasNext())
    {
        dlit.next();
        tlh = qMax(sin45deg * fm.width(dlit.value().first), tlh);
    }
    // don't change this variable as we use it later
    int th = (tlh == 0.0 ? 0 : (int)(tlh + (fm.height() * sin45deg)) + 2);
    gy2 -= th;


    // get the dimensions of the value label then draw it
    if(valueLabel().length() > 0) {
        fm = QFontMetrics(valueLabelFont());
        //brect = fm.boundingRect(valueLabel());
        paint.setFont(valueLabelFont());
        paint.save();
        paint.rotate(-90);
        paint.drawText(-gy2, gx1, gy2 - gy1, fm.height(), valueLabelAlignment(), valueLabel());
        paint.restore();
        gx1 += fm.height();
    }

    fm = QFontMetrics(valueFont());

    QString min_str = QString().sprintf("%-.0f",minValue());
    QString org_str = ( minValue() == 0.0 ? QString::null : QString("0") );
    QString max_str = QString().sprintf("%-.0f",maxValue());

    int width = qMax(fm.width(min_str), fm.width(max_str));
    if(org_str.length() > 0) width = qMax(width, fm.width(org_str));

    gx1 += width;

    int gy_max = gy1;
    int gy_min = gy2 - 1;
    int gy_org = gy_min;

    paint.setFont(valueFont());
    int tfa = Qt::AlignTop | Qt::AlignRight;
    paint.drawText(gx1 - fm.width(min_str), gy_min, fm.width(min_str), fm.height(), tfa, min_str);
    paint.drawLine(gx1 - 3, gy_min, gx1 + 2, gy_min);
    paint.drawText(gx1 - fm.width(max_str), gy_max, fm.width(max_str), fm.height(), tfa, max_str);
    paint.drawLine(gx1 - 3, gy_max, gx1 + 2, gy_max);
    int gheight = gy2 - gy1;
    double grng = maxValue() - minValue();
    if(org_str.length() > 0) {
        double perc = (0 - minValue()) / grng;
        gy_org = gy2 - (int)(perc * (double)gheight);
        paint.drawText(gx1 - fm.width(org_str), gy_org, fm.width(org_str), fm.height(), tfa, org_str);
        paint.drawLine(gx1 - 3, gy_org, gx1 + 2, gy_org);
    }

    gx1 += 3;

    // put the old value back so all the code to come draw correctly!
    gy2 = gy2_old;

    // get the dimensions of the data label then draw it
    if(dataLabel().length() > 0) {
        fm = QFontMetrics(dataLabelFont());
        //brect = fm.boundingRect(dataLabel());
        paint.setFont(dataLabelFont());
        gy2 -= fm.height();
        paint.drawText(gx1, gy2, gx2 - gx1, fm.height(), dataLabelAlignment(), dataLabel());
    }

    gy2 -= th;

    int ref_cnt = _data.count();
    int gwidth = gx2 - gx1;
    gheight = gy2 - gy1;

    if(ref_cnt > 0) {
        paint.save();
        fm = QFontMetrics(dataFont());
        paint.setFont(dataFont());
        int refwidth = qMax(1, gwidth / ref_cnt);
        int buf = (int)(refwidth / 5);
        int buf2 = buf * 2;
        int pos = gx1 + (int)((gwidth - (refwidth * ref_cnt)) / 2);
        int bar_height;
        int fmheight = fm.height();
        int fmheight_div_2 = fmheight / 2;
        int refwidth_div_2 = refwidth / 2;
        int label_offset = (int)(fmheight_div_2 * cos45deg);
        int last_label_at = -1000;
        QMap<int, double> last_map;
        QMap<int, double> this_map;
        QMapIterator<int, GReference> rit(_data);
        while(rit.hasNext())
        {
            rit.next();
            GReference ref = rit.value();
            QString label = ref.first;
            if(label.length() > 0 && ((pos + refwidth_div_2) - last_label_at) > ((label_offset * 2) + 1)) {
                last_label_at = pos + refwidth_div_2;
                int lx = (int)(((pos + refwidth_div_2) * cos45deg) - ((gy2 + label_offset) * sin45deg));
                int ly = (int)(((pos + refwidth_div_2) * sin45deg) + ((gy2 + label_offset) * cos45deg));
                int fmwidth = fm.width(label);
                paint.save();
                paint.rotate(-45);
                paint.drawText(lx - fmwidth, ly - fmheight_div_2, fmwidth, fmheight, Qt::AlignRight | Qt::AlignTop, label);
                paint.restore();
            }

            QMapIterator<int, double> sit(ref.second);
            paint.save();
            if(drawBars() == true) {
                TSetValue tval;
                QMap<double, TSetValue> sort_map;
                sit = ref.second;
                while(sit.hasNext())
                {
                    sit.next();
                    if(sit.value() != 0.0 && _setStyle[sit.key()].bar == true) {
                        tval.first = sit.key();
                        tval.second = sit.value();
                        sort_map[(tval.second < 0.0 ? minValue() : maxValue()) - (tval.second < 0.0 ? -tval.second : tval.second)] = tval;
                    }
                }
                QMapIterator<double, TSetValue> it(sort_map);
                while(it.hasNext())
                {
                    it.next();
                    tval = it.value();
                    if(tval.second != 0.0) {
                        if(tval.second < 0) {
                            bar_height = (int)((tval.second / minValue()) * (gy_org - gy_min));
                        } else {
                            bar_height = (int)((tval.second / maxValue()) * (gy_org - gy_max));
                        } 
                        paint.fillRect(pos + buf, gy_org - bar_height, refwidth - buf2, bar_height, getSetColor(tval.first));
                    }
                }
            }
            if(drawLines() == true) {
                this_map.clear();
                sit = ref.second;
                while(sit.hasNext())
                {
                    sit.next();
                    if(_setStyle[sit.key()].line == true) {
                        this_map[sit.key()] = sit.value();
                        if(last_map.contains(sit.key())) {
                            paint.setPen(getSetColor(sit.key()));
                            double old_val = last_map[sit.key()];
                            double new_val = sit.value();
                            int ly1;
                            if(old_val < 0.0) ly1 = (int)((old_val / minValue()) * (gy_org - gy_min));
                            else              ly1 = (int)((old_val / maxValue()) * (gy_org - gy_max));
                            ly1 = gy_org - ly1;
                            int lx1 = pos - refwidth_div_2;
                            int ly2;
                            if(new_val < 0.0) ly2 = (int)((new_val / minValue()) * (gy_org - gy_min));
                            else              ly2 = (int)((new_val / maxValue()) * (gy_org - gy_max));
                            ly2 = gy_org - ly2;
                            int lx2 = pos + refwidth_div_2;
                            paint.drawLine(lx1, ly1, lx2, ly2);
                        }
                    }
                }
                last_map = this_map;
            }
            if(drawPoints() == true) {
                sit = ref.second;
                while(sit.hasNext())
                {
                    sit.next();
                    if(_setStyle[sit.key()].point == true) {
                        paint.setBrush(getSetColor(sit.key()));
                        paint.setPen(QColor(0,0,0));
                        int ly1;
                        if(sit.value() < 0.0) ly1 = (int)((sit.value() / minValue()) * (gy_org - gy_min));
                        else                  ly1 = (int)((sit.value() / maxValue()) * (gy_org - gy_max));
                        ly1 = gy_org - ly1;
                        int lx1 = pos + refwidth_div_2;
                        paint.drawEllipse(lx1 - 2, ly1 - 2, 5, 5);
                    }
                }
            }
            paint.restore();
            pos += refwidth;
        }
        paint.restore();
    }

    paint.drawLine(gx1, gy_org, gx2 - 1, gy_org);
    paint.drawRect(gx1, gy1, gx2 - gx1, gy2 - gy1);


    // Now that we are done return the paint device back to the state
    // it was when we started to mess with it
    paint.restore();
}
示例#2
0
文件: qmaxbutton.cpp 项目: Qmax/PT6
void  QmaxButton::createButton(QPainter &painter)
{
    QRect scaledRect;
    scaledRect = matrix.mapRect(QRect(0,0,this->logicalSize.width(),this->logicalSize.height()));
    QImage bg(this->m_strImage);
    painter.setRenderHint(QPainter::SmoothPixmapTransform);
    painter.setRenderHint(QPainter::Antialiasing);
    painter.setPen(Qt::NoPen);
    QLinearGradient brush1(0,0,0,scaledRect.height());
    painter.drawImage(-2, -2, bg);


    if(Colors::useEightBitPalette)
    {
        painter.setPen(QColor(120,120,120));
        if(this->m_nPressed)
            painter.setBrush(QColor(60,60,60));
        else if(this->m_nHighlight)
            painter.setBrush(QColor(100,100,100));
        else
            painter.setBrush(QColor(80,80,80));
    }
    else
    {
        QLinearGradient outlinebrush(0,0,0,scaledRect.height());
        QLinearGradient brush(0,0,0,scaledRect.height());

        brush.setSpread(QLinearGradient::PadSpread);
        QColor highlight(255,255,255,128);
        QColor shadow(0,0,0,70);
        QColor sunken(220,220,220,30);
        QColor normal1(255,255,245,60);
        QColor normal2(255,255,235,10);
        QColor normal3(200,200,200,10);
        QColor normal4(255,255,250,255);

         if(m_nType && m_nType != 5  )
         {
            normal1 = QColor(200,170,160,50);
            normal2 = QColor(50,10,0,50);
         }
        if(m_nPressed)
        {
            outlinebrush.setColorAt(0.0f,shadow);
            outlinebrush.setColorAt(1.0f,highlight);
            brush.setColorAt(1.0f,sunken);
            painter.setPen(Qt::NoPen);

        }
        else
        {
            outlinebrush.setColorAt(1.0f,shadow);
            outlinebrush.setColorAt(0.0f,highlight);
            brush.setColorAt(0.0f,normal1);
            if(m_nHighlight)
                brush.setColorAt(1.0f,normal2);
            painter.setPen(QPen(outlinebrush,1));
        }
        if(this->isEnabled()==false )
        {
            outlinebrush.setColorAt(1.0f,shadow);
            outlinebrush.setColorAt(0.0f,highlight);
            brush.setColorAt(0.0f,normal3);
            painter.setPen(QPen(outlinebrush,1));

        }
        if(m_nStatus )
        {
            outlinebrush.setColorAt(1.0f,shadow);
            outlinebrush.setColorAt(0.0f,highlight);
            brush.setColorAt(0.0f,normal4);
            painter.setPen(QPen(outlinebrush,1));
        }
        painter.setBrush(brush);

    }


    if(m_nType == 1)
        painter.drawRect(0,0,scaledRect.width(),scaledRect.height());
    else if(m_nType == 0)
        painter.drawRoundedRect(0,0,scaledRect.width(),scaledRect.height(),40.0,40.0,Qt::RelativeSize);
    else if(m_nType == 5)
        painter.drawEllipse(0,0,scaledRect.width(),scaledRect.height());
    QFont font( "DejaVu Sans" );
    font.setPointSize( 12 );
    painter.setFont( font );
    brush1.setColorAt(1.0f,QColor(255,255,255,255));
    if(this->isEnabled()==false)
    {
        brush1.setColorAt(1.0f,QColor(200,200,200,100));
    }
    painter.setPen(QPen(brush1,1));
    painter.setBrush(brush1);
    QFontMetrics fMetrics = painter.fontMetrics();
    QSize sz = fMetrics.size( Qt::TextWordWrap, m_strText );
    QRectF txtRect( scaledRect.center(), sz );
    int xPoint = (scaledRect.width()/2)- ((m_strText.count()/2)*10);
    int yPoint = scaledRect.height()/2;
    painter.drawText(xPoint,yPoint,m_strText);
}
示例#3
0
void QgsLayoutTable::render( QgsLayoutItemRenderContext &context, const QRectF &, const int frameIndex )
{
  bool emptyTable = mTableContents.length() == 0;
  if ( emptyTable && mEmptyTableMode == QgsLayoutTable::HideTable )
  {
    //empty table set to hide table mode, so don't draw anything
    return;
  }

  if ( !mLayout->renderContext().isPreviewRender() )
  {
    //exporting composition, so force an attribute refresh
    //we do this in case vector layer has changed via an external source (e.g., another database user)
    refreshAttributes();
  }

  //calculate which rows to show in this frame
  QPair< int, int > rowsToShow = rowRange( frameIndex );

  double gridSizeX = mShowGrid && mVerticalGrid ? mGridStrokeWidth : 0;
  double gridSizeY = mShowGrid && mHorizontalGrid ? mGridStrokeWidth : 0;
  double cellHeaderHeight = QgsLayoutUtils::fontAscentMM( mHeaderFont ) + 2 * mCellMargin;
  double cellBodyHeight = QgsLayoutUtils::fontAscentMM( mContentFont ) + 2 * mCellMargin;
  QRectF cell;

  //calculate whether a header is required
  bool drawHeader = ( ( mHeaderMode == QgsLayoutTable::FirstFrame && frameIndex < 1 )
                      || ( mHeaderMode == QgsLayoutTable::AllFrames ) );
  //calculate whether drawing table contents is required
  bool drawContents = !( emptyTable && mEmptyTableMode == QgsLayoutTable::ShowMessage );

  int numberRowsToDraw = rowsToShow.second - rowsToShow.first;
  int numberEmptyRows = 0;
  if ( drawContents && mShowEmptyRows )
  {
    numberRowsToDraw = rowsVisible( frameIndex, rowsToShow.first, true );
    numberEmptyRows = numberRowsToDraw - rowsToShow.second + rowsToShow.first;
  }
  bool mergeCells = false;
  if ( emptyTable && mEmptyTableMode == QgsLayoutTable::ShowMessage )
  {
    //draw a merged row for the empty table message
    numberRowsToDraw++;
    rowsToShow.second++;
    mergeCells = true;
  }

  QPainter *p = context.renderContext().painter();
  p->save();
  // painter is scaled to dots, so scale back to layout units
  p->scale( context.renderContext().scaleFactor(), context.renderContext().scaleFactor() );

  //draw the text
  p->setPen( Qt::SolidLine );

  double currentX = gridSizeX;
  double currentY = gridSizeY;
  if ( drawHeader )
  {
    //draw the headers
    int col = 0;
    for ( const QgsLayoutTableColumn *column : qgis::as_const( mColumns ) )
    {
      //draw background
      p->save();
      p->setPen( Qt::NoPen );
      p->setBrush( backgroundColor( -1, col ) );
      p->drawRect( QRectF( currentX, currentY, mMaxColumnWidthMap[col] + 2 * mCellMargin, cellHeaderHeight ) );
      p->restore();

      currentX += mCellMargin;

      Qt::TextFlag textFlag = static_cast< Qt::TextFlag >( 0 );
      if ( column->width() <= 0 )
      {
        //automatic column width, so we use the Qt::TextDontClip flag when drawing contents, as this works nicer for italicised text
        //which may slightly exceed the calculated width
        //if column size was manually set then we do apply text clipping, to avoid painting text outside of columns width
        textFlag = Qt::TextDontClip;
      }

      cell = QRectF( currentX, currentY, mMaxColumnWidthMap[col], cellHeaderHeight );

      //calculate alignment of header
      Qt::AlignmentFlag headerAlign = Qt::AlignLeft;
      switch ( mHeaderHAlignment )
      {
        case FollowColumn:
          headerAlign = column->hAlignment();
          break;
        case HeaderLeft:
          headerAlign = Qt::AlignLeft;
          break;
        case HeaderCenter:
          headerAlign = Qt::AlignHCenter;
          break;
        case HeaderRight:
          headerAlign = Qt::AlignRight;
          break;
      }

      QgsLayoutUtils::drawText( p, cell, column->heading(), mHeaderFont, mHeaderFontColor, headerAlign, Qt::AlignVCenter, textFlag );

      currentX += mMaxColumnWidthMap[ col ];
      currentX += mCellMargin;
      currentX += gridSizeX;
      col++;
    }

    currentY += cellHeaderHeight;
    currentY += gridSizeY;
  }

  //now draw the body cells
  int rowsDrawn = 0;
  if ( drawContents )
  {
    //draw the attribute values
    for ( int row = rowsToShow.first; row < rowsToShow.second; ++row )
    {
      rowsDrawn++;
      currentX = gridSizeX;
      int col = 0;

      //calculate row height
      double rowHeight = mMaxRowHeightMap[row + 1] + 2 * mCellMargin;


      for ( const QgsLayoutTableColumn *column : qgis::as_const( mColumns ) )
      {
        //draw background
        p->save();
        p->setPen( Qt::NoPen );
        p->setBrush( backgroundColor( row, col ) );
        p->drawRect( QRectF( currentX, currentY, mMaxColumnWidthMap[col] + 2 * mCellMargin, rowHeight ) );
        p->restore();

        // currentY = gridSize;
        currentX += mCellMargin;

        QVariant cellContents = mTableContents.at( row ).at( col );
        QString str = cellContents.toString();

        Qt::TextFlag textFlag = static_cast< Qt::TextFlag >( 0 );
        if ( column->width() <= 0 && mWrapBehavior == TruncateText )
        {
          //automatic column width, so we use the Qt::TextDontClip flag when drawing contents, as this works nicer for italicised text
          //which may slightly exceed the calculated width
          //if column size was manually set then we do apply text clipping, to avoid painting text outside of columns width
          textFlag = Qt::TextDontClip;
        }
        else if ( textRequiresWrapping( str, column->width(), mContentFont ) )
        {
          str = wrappedText( str, column->width(), mContentFont );
        }

        cell = QRectF( currentX, currentY, mMaxColumnWidthMap[col], rowHeight );
        QgsLayoutUtils::drawText( p, cell, str, mContentFont, mContentFontColor, column->hAlignment(), column->vAlignment(), textFlag );

        currentX += mMaxColumnWidthMap[ col ];
        currentX += mCellMargin;
        currentX += gridSizeX;
        col++;
      }
      currentY += rowHeight;
      currentY += gridSizeY;
    }
  }

  if ( numberRowsToDraw > rowsDrawn )
  {
    p->save();
    p->setPen( Qt::NoPen );

    //draw background of empty rows
    for ( int row = rowsDrawn; row < numberRowsToDraw; ++row )
    {
      currentX = gridSizeX;
      int col = 0;

      if ( mergeCells )
      {
        p->setBrush( backgroundColor( row + 10000, 0 ) );
        p->drawRect( QRectF( gridSizeX, currentY, mTableSize.width() - 2 * gridSizeX, cellBodyHeight ) );
      }
      else
      {
        for ( QgsLayoutTableColumn *column : qgis::as_const( mColumns ) )
        {
          Q_UNUSED( column );

          //draw background

          //we use a bit of a hack here - since we don't want these extra blank rows to match the firstrow/lastrow rule, add 10000 to row number
          p->setBrush( backgroundColor( row + 10000, col ) );
          p->drawRect( QRectF( currentX, currentY, mMaxColumnWidthMap[col] + 2 * mCellMargin, cellBodyHeight ) );

          // currentY = gridSize;
          currentX += mMaxColumnWidthMap[ col ] + 2 * mCellMargin;
          currentX += gridSizeX;
          col++;
        }
      }
      currentY += cellBodyHeight + gridSizeY;
    }
    p->restore();
  }

  //and the borders
  if ( mShowGrid )
  {
    QPen gridPen;
    gridPen.setWidthF( mGridStrokeWidth );
    gridPen.setColor( mGridColor );
    gridPen.setJoinStyle( Qt::MiterJoin );
    p->setPen( gridPen );
    if ( mHorizontalGrid )
    {
      drawHorizontalGridLines( p, rowsToShow.first, rowsToShow.second + numberEmptyRows, drawHeader );
    }
    if ( mVerticalGrid )
    {
      drawVerticalGridLines( p, mMaxColumnWidthMap, rowsToShow.first, rowsToShow.second + numberEmptyRows, drawHeader, mergeCells );
    }
  }

  //special case - no records and table is set to ShowMessage mode
  if ( emptyTable && mEmptyTableMode == QgsLayoutTable::ShowMessage )
  {
    double messageX = gridSizeX + mCellMargin;
    double messageY = gridSizeY + ( drawHeader ? cellHeaderHeight + gridSizeY : 0 );
    cell = QRectF( messageX, messageY, mTableSize.width() - messageX, cellBodyHeight );
    QgsLayoutUtils::drawText( p, cell, mEmptyTableMessage, mContentFont, mContentFontColor, Qt::AlignHCenter, Qt::AlignVCenter, static_cast< Qt::TextFlag >( 0 ) );
  }

  p->restore();

}
示例#4
0
文件: brick.cpp 项目: azoyan/Arkanoid
void Brick::show(QPainter &painter) {
    painter.drawRect(x(), y(), width(), height());
}
void paint(QPaintDevice* pd) {
    QPainter p;
    if (!p.begin(pd)) return;
    QPen pe(QColor("black"));
    pe.setWidthF(6.0);
    pe.setStyle(Qt::DashLine);
    p.setPen(pe);
    p.drawLine(QPointF(0,0),QPointF(100.0,100.0));
    pe.setColor("red");
    pe.setStyle(Qt::DotLine);
    p.setPen(pe);
    p.drawLine(QPointF(0,0),QPointF(50.0,25.0));
    pe.setColor("green");
    pe.setStyle(Qt::SolidLine);
    p.setPen(pe);
    p.drawLine(QPointF(0,0),QPointF(25.0,50.0));
    pe.setColor("blue");
    p.setPen(pe);
    p.drawText(50,10, QString("Hello World!"));
    p.drawLine(50,10,55,15);
    QFont f;
    QImage img(QString("qfe_plotterexportercairo.png"));
    pe.setWidthF(0.5);
    p.setPen(pe);
    p.drawImage(QRectF(50,25,50,50), img);
    //p.drawRect(QRectF(50,25,50,50));
    p.drawImage(QRectF(25,50,15,10), img);
    //p.drawRect(QRectF(25,50,15,10));
    p.drawImage(QRectF(225,50,100,100), img, QRect(5,5,12,12));
    p.drawRect(QRectF(125,50,15,10));
    pe.setWidthF(2);
    pe.setColor("red");
    p.setPen(pe);
    f.setFamily("Times New Roman");
    f.setPointSizeF(10);
    p.setFont(f);
    p.drawText(50,30, QString("Hello World!"));
    p.drawLine(50,30,55,35);

    f.setFamily("Arial");
    f.setPointSizeF(16);
    p.setFont(f);
    p.drawText(250,30, QString("Unicode-test: ")+QChar(0x2190)+QChar(0x2591)+QChar(0x2665)+QChar(0x039B)+QChar(0x03B6));
    p.drawLine(250,30,255,35);

    pe.setWidthF(1);
    p.setPen(pe);
    QBrush b(QColor("salmon"));
    p.fillRect(QRectF(100,10,50,50), b);
    p.drawRect(QRectF(100,10,50,50));
    QColor c=b.color();
    c.setAlphaF(0.5);
    b.setColor(c);
    pe.setWidthF(5);
    p.setPen(pe);
    p.setBrush(b);
    p.drawEllipse(QRectF(130,40,50,30));
    //p.drawRect(QRectF(130,40,50,30));
    QPolygonF poly;
    for (int phi=0; phi<60; phi++) {
        double p=double(phi)/20.0*M_PI;
        poly<<QPointF(50.0+cos(p)*35.0*double(phi)/60.0, 50.0-sin(p)*35.0*double(phi)/60.0);
    }

    p.setClipRect(0,0,200,50);

    pe.setWidthF(1);
    p.setPen(pe);
    p.drawPolygon(poly);
    pe.setColor("red");
    pe.setStyle(Qt::DashDotDotLine);
    p.setPen(pe);
    p.setClipping(false);
    p.drawPolyline(poly);


    p.end();
}
示例#6
0
void MapIcon::paintSquare(QPainter&p, const QPoint& point, 
			  int size, int sizeWH)
{
  p.drawRect(point.x() - size, point.y() - size, sizeWH, sizeWH);
}
void CannonField::paintShot(QPainter &painter)
{
	painter.setPen(Qt::NoPen);
	painter.setBrush(Qt::black);
	painter.drawRect(shotRect());
}
示例#8
0
void SpaceElement::paint( QPainter& painter, AttributeManager* )
{
    painter.setBrush( QBrush( Qt::lightGray, Qt::DiagCrossPattern ) );
    painter.drawRect( QRectF( 0.0, 0.0, width(), height() ) );
}
示例#9
0
void QgsColorSwatchGrid::draw( QPainter &painter )
{
  QPalette pal = QPalette( qApp->palette() );
  QColor headerBgColor = pal.color( QPalette::Mid );
  QColor headerTextColor = pal.color( QPalette::BrightText );
  QColor highlight = pal.color( QPalette::Highlight );

  //draw header background
  painter.setBrush( headerBgColor );
  painter.setPen( Qt::NoPen );
  painter.drawRect( QRect( 0, 0, width(), LABEL_SIZE ) );

  //draw header text
  painter.setPen( headerTextColor );
  painter.drawText( QRect( LABEL_MARGIN, 0, width() - 2 * LABEL_MARGIN, LABEL_SIZE ),
                    Qt::AlignLeft | Qt::AlignVCenter, mScheme->schemeName() );

  //draw color swatches
  QgsNamedColorList::iterator colorIt = mColors.begin();
  int index = 0;
  for ( ; colorIt != mColors.end(); ++colorIt )
  {
    int row = index / NUMBER_COLORS_PER_ROW;
    int column = index % NUMBER_COLORS_PER_ROW;

    QRect swatchRect = QRect( column * ( SWATCH_SIZE + SWATCH_SPACING ) + LEFT_MARGIN,
                              row * ( SWATCH_SIZE + SWATCH_SPACING ) + TOP_MARGIN + LABEL_SIZE,
                              SWATCH_SIZE, SWATCH_SIZE );

    if ( mCurrentHoverBox == index )
    {
      //hovered boxes are slightly larger
      swatchRect.adjust( -1, -1, 1, 1 );
    }

    //start with checkboard pattern for semi-transparent colors
    if (( *colorIt ).first.alpha() != 255 )
    {
      QBrush checkBrush = QBrush( transparentBackground() );
      painter.setPen( Qt::NoPen );
      painter.setBrush( checkBrush );
      painter.drawRect( swatchRect );
    }

    if ( mCurrentHoverBox == index )
    {
      if ( mDrawBoxDepressed )
      {
        painter.setPen( QColor( 100, 100, 100 ) );
      }
      else
      {
        //hover color
        painter.setPen( QColor( 220, 220, 220 ) );
      }
    }
    else if ( mFocused && index == mCurrentFocusBox )
    {
      painter.setPen( highlight );
    }
    else if (( *colorIt ).first.name() == mBaseColor.name() )
    {
      //currently active color
      painter.setPen( QColor( 75, 75, 75 ) );
    }
    else
    {
      painter.setPen( QColor( 197, 197, 197 ) );
    }

    painter.setBrush(( *colorIt ).first );
    painter.drawRect( swatchRect );

    index++;
  }
}
示例#10
0
文件: LogoWidget.cpp 项目: KDE/kwave
//***************************************************************************
void Kwave::LogoWidget::paintEvent(QPaintEvent *)
{
    // if image has to be resized ...
    if ((rect().height() != m_height) || (rect().width() != m_width)) {
	m_height = rect().height();
	m_width  = rect().width();

	if (m_image) delete m_image;
	m_image = new QImage(size(), QImage::Format_ARGB32_Premultiplied);
	m_repaint = true;
    }

    if ((m_repaint) && (m_image)) {
	QPainter p;
	QPolygon si(20 + 3);

	p.begin(m_image);

	// erase everything to black
	p.setPen(Qt::black);
	p.setBrush(Qt::black);
	p.drawRect(0, 0, m_width, m_height);

	// blit logo bitmap
	int ampx = (m_logo.width()  - m_width ) / 2;
	int ampy = (m_logo.height() - m_height) / 2;
	p.setCompositionMode(QPainter::CompositionMode_Source);
	p.drawPixmap(
	    -ampx + Kwave::toInt(sin(m_deg[0]) * ampx),
	    -ampy + Kwave::toInt(sin(m_deg[1]) * ampy),
	    m_logo);

	// draw the sine waves with XOR
	p.setCompositionMode(QPainter::CompositionMode_Exclusion);
	p.setBrush(QColor::fromHsvF(m_color_h, 1.0, 1.0));
	m_color_h += COLOR_INCREMENT; // this gives the nice color change :-)
	if (m_color_h > 1.0) m_color_h -= 1.0;

	double amp = sin(m_deg[MAXSIN - 1] * 3);
	for (int j = 0; j < MAXSIN; j++) {
	    for (int i = 0; i < 21; i++) {
		si.setPoint(i, (j * m_width / MAXSIN) +
		    Kwave::toInt(amp * sin(M_PI * i / 10 + m_deg[j])
			* m_width / 2),
		    m_height * i / 20);
	    }
	    si.setPoint(21, m_width / 2, m_height);
	    si.setPoint(22, m_width / 2, 0);

	    p.drawPolygon(si);
	    amp = sin(m_deg[j] * 3);
	}

	p.end();
	m_repaint = false;
    }

    // blit the result to the display
    if (m_image) {
	QPainter p(this);
	p.drawImage(0, 0, *m_image);
	p.end();
    }

}
示例#11
0
void CharsetWidget::paintEvent(QPaintEvent *event)
{
    QPainter painter;

    painter.begin(this);
    painter.fillRect(event->rect(), QWidget::palette().color(QWidget::backgroundRole()));

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

    auto state = State::getInstance();

    int end_x = 8;
    int pixel_size_x = _pixelSize.width();
    int increment_x = 1;
    int bits_to_mask = 1;

    if (state->shouldBeDisplayedInMulticolor())
    {
        end_x = 4;
        pixel_size_x = _pixelSize.width() * 2;
        increment_x = 2;
        bits_to_mask = 3;
    }

    QPen pen;
    pen.setColor({149,195,244,255});
    if (hasFocus())
        pen.setWidth(3);
    else
        pen.setWidth(1);
    pen.setStyle(Qt::PenStyle::SolidLine);

    for (int w=0; w<COLUMNS; w++) {
        for (int h=0; h<ROWS; h++) {

            int index = w + h * COLUMNS;
            quint8* charPtr = state->getCharAtIndex(index);

            for (int y=0; y<8; y++) {

                char letter = charPtr[y];

                for (int x=0; x<end_x; x++) {

                    // Warning: Don't use 'char'. Instead use 'unsigned char'.
                    // 'char' doesn't work Ok with << and >>
                    // only mask the bits are needed
                    unsigned char mask = bits_to_mask << (((end_x-1)-x) * increment_x);

                    unsigned char color = letter & mask;
                    // now transform those bits into values from 0-3 since those are the
                    // possible colors

                    int bits_to_shift = (((end_x-1)-x) * increment_x);
                    int color_pen = color >> bits_to_shift;

                    if (!state->shouldBeDisplayedInMulticolor() && color_pen )
                        color_pen = State::PEN_FOREGROUND;
                    painter.setBrush(Palette::getColorForPen(color_pen));
                    painter.drawRect((w*end_x+x) * pixel_size_x + OFFSET,
                                     (h*8+y) * _pixelSize.height() + OFFSET,
                                     pixel_size_x,
                                     _pixelSize.height());
                }
            }

            painter.setPen(Qt::NoPen);
        }
    }

    if (_selecting) {
        pen.setColor({149,195,244,255});
        painter.setPen(pen);
        painter.setBrush(QColor(149,195,244,64));
        painter.drawRect(_cursorPos.x() * 8 * _pixelSize.width() + OFFSET,
                         _cursorPos.y() * 8 * _pixelSize.height() + OFFSET,
                         _selectingSize.width() * 8 * _pixelSize.width(),
                         _selectingSize.height() * 8 * _pixelSize.height());
    }
    else
    {
        pen.setColor({149,195,244,255});
        painter.setPen(pen);
        painter.setBrush(QColor(128,0,0,0));
        painter.drawRect(_cursorPos.x() * 8 * _pixelSize.width() + OFFSET,
                         _cursorPos.y() * 8 * _pixelSize.height() + OFFSET,
                         8 * _pixelSize.width(),
                         8 * _pixelSize.height());
    }

    paintFocus(painter);
    painter.end();
}
示例#12
0
//--------------------------------------------------------------------------------------------
void MGyrohorizon::paintEvent(QPaintEvent * event)
{
//--
  QImage imgagePaint(size(), QImage::Format_ARGB32_Premultiplied);
  QPainter painter;
  painter.begin(&imgagePaint);
//--

  painter.setRenderHint(QPainter::Antialiasing, true);

  QLinearGradient linearGrad;
  QPointF mpointsF[5];
  qreal yh;

//=============================

  bool isUpDawn = false;
  while(PitchAngle < -90.0)
  {
    PitchAngle += 180.0;
    isUpDawn = !isUpDawn; //true;
  }
  while(PitchAngle > 90.0)
  {
    PitchAngle -= 180.0;
    isUpDawn = !isUpDawn; //true;
  }


  if(isUpDawn)
  {
      RollAngle += 180.0;

  }
  while(RollAngle < -180.0)
  {
    RollAngle += 360.0;
  }
  while(RollAngle > 180.0)
  {
     RollAngle -= 360.0;
  }


  qreal hPitchAngle = HeightHalf/AngleHeightHalf*PitchAngle;//здвиг по пикселям в соответсвии с градусами
  if(isUpDawn) {
    hPitchAngle = -hPitchAngle;
  }


  painter.translate(WidthHalf,HeightHalf);//переместили цент с 0,0 на центр
  painter.rotate(-RollAngle);

//=====  Pitch:  =====
  painter.setPen(Qt::NoPen);


//-Sky:

// 0:
  yh = hPitchAngle;
  linearGrad.setStart(0.0,     yh);
  linearGrad.setFinalStop(0.0, yh-H1);
  linearGrad.setColorAt(0, ColorSky0);
  linearGrad.setColorAt(1, ColorSky1);
  QBrush brushSky1(linearGrad);   painter.setBrush(brushSky1);
  painter.drawRect(-MaxDimHalf,yh+0.5, MaxDim,-H1-2.0);//первый верхний четерехугольник

  yh -= H1;
  linearGrad.setStart(0.0,     yh);
  linearGrad.setFinalStop(0.0, yh-H2);
  linearGrad.setColorAt(0, ColorSky1);
  linearGrad.setColorAt(1, ColorSky2);
  QBrush brushSky2(linearGrad);   painter.setBrush(brushSky2);
  painter.drawRect(QRectF(-MaxDimHalf,yh, MaxDim,-H2-2.0));

//90
  yh -= H2;
  linearGrad.setStart(0.0,     yh);
  linearGrad.setFinalStop(0.0, yh-H2);
  linearGrad.setColorAt(0, ColorSky2);
  linearGrad.setColorAt(1, ColorSky1);
  QBrush brushSky3(linearGrad);   painter.setBrush(brushSky3);
  painter.drawRect(QRectF(-MaxDimHalf,yh, MaxDim,-H2-2.0));

  yh -= H2;
  linearGrad.setStart(0.0,     yh);
  linearGrad.setFinalStop(0.0, yh-H1);
  linearGrad.setColorAt(0, ColorSky1);
  linearGrad.setColorAt(1, ColorSky0);
  QBrush brushSky4(linearGrad);   painter.setBrush(brushSky4);
  painter.drawRect(QRectF(-MaxDimHalf,yh+0.5, MaxDim,-H1-2.0));

//180

//-Ground:

// 0:
  yh = hPitchAngle;
  linearGrad.setStart(0.0,     yh);
  linearGrad.setFinalStop(0.0, yh+H1);
  linearGrad.setColorAt(0, ColorGround0);
  linearGrad.setColorAt(1, ColorGround1);
  QBrush brushGround1(linearGrad);   painter.setBrush(brushGround1);
  painter.drawRect(QRectF(-MaxDimHalf,yh-0.5, MaxDim,H1+2.0));

  yh += H1;
  linearGrad.setStart(0.0,     yh);
  linearGrad.setFinalStop(0.0, yh+H2);
  linearGrad.setColorAt(0, ColorGround1);
  linearGrad.setColorAt(1, ColorGround2);
  QBrush brushGround2(linearGrad);   painter.setBrush(brushGround2);
  painter.drawRect(QRectF(-MaxDimHalf,yh, MaxDim,H2+2.0));

//90:
  yh += H2;
  linearGrad.setStart(0.0,     yh);
  linearGrad.setFinalStop(0.0, yh+H2);
  linearGrad.setColorAt(0, ColorGround2);
  linearGrad.setColorAt(1, ColorGround1);
  QBrush brushGround3(linearGrad);   painter.setBrush(brushGround3);
  painter.drawRect(QRectF(-MaxDimHalf,yh, MaxDim,H2+2.0));

  yh += H2;
  linearGrad.setStart(0.0,     yh);
  linearGrad.setFinalStop(0.0, yh+H1);
  linearGrad.setColorAt(0, ColorGround1);
  linearGrad.setColorAt(1, ColorGround0);
  QBrush brushGround4(linearGrad);   painter.setBrush(brushGround4);
  painter.drawRect(QRectF(-MaxDimHalf,yh, MaxDim,H1+2));
//180

//== Pitch Scale:

  QPen pen(ColorPitch);  pen.setWidthF(1.0);
  painter.setPen(pen);

  QVector<QLineF> lines;

//- (2)-degrees:
  qreal y;  bool isHas = false;
  for(int k = -1; k <= 1; k += 2)
  {
    y = hPitchAngle;
    while(y >=   2.0*(H1+H2)-2.0*HeightHalfVisible)  { y -= 2.0*(H1+H2); }
    while(y <= -(2.0*(H1+H2)-2.0*HeightHalfVisible)) { y += 2.0*(H1+H2); }
    for(int i = 1; i <= 4; i++)
    {
      y += -2.0*HOneDegreeAngle*k;
      if(qAbs(y) <= HeightHalfVisible)
      {
        isHas = true;
        lines << QLineF(-8.0,y, 8.0,y);
      }
    }
  }
  if(isHas)  painter.drawLines(lines);
  lines.clear();

  pen.setWidthF(1.5);   painter.setPen(pen);

  qreal xoff, yoff;
  qreal angle;

//- 10-degrees:
  mpointsF[0].setX(-24.0);
  mpointsF[1].setX(-24.0);
  mpointsF[2].setX(24.0);
  mpointsF[3].setX(24.0);
  for(int k = -1; k <= 1; k += 2)
  {
    for(int i = 0; i <= 9; i++)
    {
      angle = 10.0*i;
      y = hPitchAngle - angle*HOneDegreeAngle*k;
      while(y >=   2.0*(H1+H2)-2.0*HeightHalfVisible)  { y -= 2.0*(H1+H2); }
      while(y <= -(2.0*(H1+H2)-2.0*HeightHalfVisible)) { y += 2.0*(H1+H2); }
      if(qAbs(y) <= HeightHalfVisible)
      {
        if(i == 0)
        {
          painter.drawLine(QLineF(-48.0,y, 48.0,y));
        }
        else if(i < 9)
        {
          mpointsF[0].setY(y + 5.0*k);
          mpointsF[1].setY(y);
          mpointsF[2].setY(y);
          mpointsF[3].setY(y + 5.0*k);
          painter.drawPolyline(mpointsF, 4); //int pointCount)
          DrawText(painter, -24.0-12.0+0.5, y+5.0/2.0*k, angle);
          DrawText(painter,  24.0+12.0+1.0, y+5.0/2.0*k, angle);
        }
        else
        {
          lines << QLineF(-36.0,y-7.0, -36.0,y+7.0);
          lines << QLineF(-36.0,y,      36.0,y);
          lines << QLineF( 36.0,y-7.0,  36.0,y+7.0);
          painter.drawLines(lines);  lines.clear();
          DrawText(painter, -36.0-12.0+1.0, y, angle);
          DrawText(painter,  36.0+12.0+1.0, y, angle);
        }
      }
    }

  }
//- (15)-degrees:
  for(int k = -1; k <= 1; k += 2) {
    y = hPitchAngle - 10.0*HOneDegreeAngle*(1.0+0.5)*k;
    while(y >=   2.0*(H1+H2)-2.0*HeightHalfVisible)  { y -= 2.0*(H1+H2); }
    while(y <= -(2.0*(H1+H2)-2.0*HeightHalfVisible)) { y += 2.0*(H1+H2); }
    if(qAbs(y) <= HeightHalfVisible)
      painter.drawLine(QLineF(-16.0,y, 16.0,y));
  }

//=====  Roll:  =====
  painter.setBrush(QBrush(ColorRoll));

//- Triangle:
  painter.setPen(Qt::NoPen);
  mpointsF[0].setX(0.0);   mpointsF[0].setY(-rRoll);
  mpointsF[1].setX(-6.5);  mpointsF[1].setY(-rRoll - 11.258); //  11.258 = sqrt(3.0)/2.0 * 13.0
  mpointsF[2].setX(6.5);   mpointsF[2].setY(-rRoll - 11.258);
  painter.drawPolygon(mpointsF,3);

//- Arc:
  pen.setColor(ColorRoll);  pen.setWidthF(1.5);   painter.setPen(pen);
  painter.drawArc(QRectF(-rRoll, -rRoll, 2.0*rRoll, 2.0*rRoll), 30*16, 120*16);

//для крючочков
  qreal hs1 = 5.0;
  qreal hs2 = 12.0;  qreal ws2 = 5.0;
  qreal hs3 = 10.0;
  yoff = -rRoll - hs2 - 10.0; //  - 5.0
  angle = 0.0;

  qreal dopangle;  // QString text;

  for(int k = -1; k <= 1; k += 2)
  {
    xoff = ws2/2.0*k;
//- (5), (10):
    dopangle = 10.0*k;  painter.rotate(dopangle);
    for(int i = 1; i <= 2; i++)
    {
      painter.drawLine(QPointF(0.0,-rRoll), QPointF(0.0,-rRoll-hs1));
      painter.rotate(dopangle);
    }

//- 30, (45), 60, (75):
    dopangle = 15.0*k;  angle = 15.0;
    for(int i = 1; i <= 2; i++)
    {
// 30, 60:
      angle += dopangle*k;  //  text.sprintf(("%.0f"),angle);
      DrawText(painter, xoff, yoff, angle); //text);
      mpointsF[0].setX(0.0);  mpointsF[0].setY(-rRoll);
      mpointsF[1].setX(0.0);  mpointsF[1].setY(-rRoll-hs2);
      mpointsF[2].setX(ws2*k);  mpointsF[2].setY(-rRoll-hs2);
      painter.drawPolyline(mpointsF, 3);
// (45), (75):
      painter.rotate(dopangle);
      painter.drawLine(QPointF(0.0,-rRoll), QPointF(0.0,-rRoll-hs3));

      painter.rotate(dopangle);
      angle += dopangle*k;
    }

//- 90:
    xoff = 1.0;
    angle += dopangle*k;  //  text.sprintf(("%.0f"),angle);
    DrawText(painter, xoff, yoff, angle); //text);
    lines << QLineF(0.0,-rRoll, 0.0,-rRoll-hs2);
    lines << QLineF(-4.0,-rRoll-hs2, 4.0,-rRoll-hs2);
    painter.drawLines(lines);  lines.clear();

//- 120, 150:
    xoff = -ws2/2.0*k;
    dopangle = 30.0*k;    painter.rotate(dopangle);
    for(int i = 1; i <= 2; i++)
    {
      angle += dopangle*k;  //  text.sprintf(("%.0f"),angle);
      DrawText(painter, xoff, yoff, angle); //text);
      mpointsF[0].setX(0.0);  mpointsF[0].setY(-rRoll);
      mpointsF[1].setX(0.0);  mpointsF[1].setY(-rRoll-hs2);
      mpointsF[2].setX(-ws2*k);  mpointsF[2].setY(-rRoll-hs2);
      painter.drawPolyline(mpointsF, 3);

      painter.rotate(dopangle);
    }

    if(k == -1)  painter.rotate(180.0);
  }

//- 180:
  xoff = -1.0;
  angle += dopangle;  //  text.sprintf(("%.0f"),angle);
  DrawText(painter, xoff, yoff, angle); //text);
  lines << QLineF(0.0,-rRoll, 0.0,-rRoll-hs2);
  lines << QLineF(-3.0,-rRoll-hs2+4.0, 3.0,-rRoll-hs2+4.0);
  lines << QLineF(-6.0,-rRoll-hs2, 6.0,-rRoll-hs2);
  painter.drawLines(lines);  lines.clear();
  painter.rotate(-180.0);

//=====  Static:  =====

  painter.rotate(RollAngle);

//==Balance:

  pen.setColor(ColorStaticBalanceOutline);  pen.setWidthF(0.5);   painter.setPen(pen);

  linearGrad.setStart(0.0,    -3.5+1.5);
  linearGrad.setFinalStop(0.0, 3.5);
  linearGrad.setColorAt(0, ColorStaticBalance0);
  linearGrad.setColorAt(1, ColorStaticBalance1);
  QBrush brushBalance(linearGrad);   painter.setBrush(brushBalance);

//-Left:
  mpointsF[0].setX(-48.0-1.0);           mpointsF[0].setY(0.0);
  mpointsF[1].setX(-48.0-1.0-8.0);       mpointsF[1].setY(-3.5);
  mpointsF[2].setX(-48.0-1.0-8.0-24.0);  mpointsF[2].setY(-3.5);
  mpointsF[3].setX(-48.0-1.0-8.0-24.0);  mpointsF[3].setY(3.5);
  mpointsF[4].setX(-48.0-1.0-8.0);       mpointsF[4].setY(3.5);
  painter.drawPolygon(mpointsF,5);

//-Right:
  mpointsF[0].setX(48.0+1.0);
  mpointsF[1].setX(48.0+1.0+8.0);
  mpointsF[2].setX(48.0+1.0+8.0+24.0);
  mpointsF[3].setX(48.0+1.0+8.0+24.0);
  mpointsF[4].setX(48.0+1.0+8.0);
  painter.drawPolygon(mpointsF,5);

//-Center:
  linearGrad.setStart(0.0,    0.0);
  linearGrad.setFinalStop(0.0, 12.0+6.0);
  linearGrad.setColorAt(0, ColorStaticBalance0);
  linearGrad.setColorAt(1, ColorStaticBalance1);
  QBrush brushBalanceCenter(linearGrad);   painter.setBrush(brushBalanceCenter);
  mpointsF[0].setX(0.0);            mpointsF[0].setY(0.0);
  mpointsF[1].setX(-30.0);          mpointsF[1].setY(12.0);
  mpointsF[2].setX(0.0);            mpointsF[2].setY(6.0);
  mpointsF[3].setX(30.0);           mpointsF[3].setY(12.0);
  painter.drawPolygon(mpointsF,4);

//- Triangle:
  painter.setBrush(QBrush(ColorStaticTriangle));
  mpointsF[0].setX(0.0);   mpointsF[0].setY(-rRoll);
  mpointsF[1].setX(6.5);   mpointsF[1].setY(-rRoll + 11.258); //  11.258 = sqrt(3.0)/2.0 * 13.0
  mpointsF[2].setX(-6.5);  mpointsF[2].setY(-rRoll + 11.258);
  painter.drawPolygon(mpointsF,3);


//=============================
  painter.setOpacity(0.6);

  QPixmap pixmap = PEkranoplanGL->renderPixmap(); //80,80);//,false);
  pixmap.setMask(pixmap.createMaskFromColor(QColor(0,0,0, 255)));
  painter.drawPixmap(-WidthHalf+1,HeightHalf-pixmap.rect().height()-1, pixmap);
//--
  painter.end();
  QPainter paint(this);
  paint.drawImage(0,0, imgagePaint);
}
示例#13
0
void ScrollPanner::drawSlider(QPainter& p, QRect r)
{
    p.drawRect(r);
}
示例#14
0
void ScrollPanner::drawBackground(QPainter& p, QRect r)
{
    p.drawRect(r);
}
示例#15
0
bool c_graph_item::sceneEventFilter(QGraphicsItem *watched, QEvent *event){

    //ajout fleche rouge sur le hover
    if(event->type() == QEvent::GraphicsSceneHoverEnter && !model_graph->getTransClicked() && !model_graph->getNodeCLicked() && !model_graph->getFinalClicked()	){

        if( !model_graph->addedToScene){

           std::cout << "mouse enter QGraphics item\n";
           //creation de la ligne bleu
           m_transition * selectedTransition = getTransitionFromQGraphicsItem(watched,event);
           QLineF * transition_line = selectedTransition->getGraphicalComponentLine();
           QPointF p1(transition_line->p1().x(),transition_line->p1().y());
           QPointF p2(transition_line->p2().x(),transition_line->p2().y());

           //creation du polygon bleu
           QPointF destPoint = p2.toPoint();
           int arrowSize = 10;
           double angle = ::acos(transition_line->dx() / transition_line->length());
            if (transition_line->dy() >= 0)
               angle = TwoPi - angle;

            QPointF destArrowP1 = destPoint + QPointF(    sin(angle - Pi / 3)      * arrowSize, cos(angle - Pi / 3)      * arrowSize);
            QPointF destArrowP2 = destPoint + QPointF(    sin(angle - Pi + Pi / 3) * arrowSize, cos(angle - Pi + Pi / 3) * arrowSize);


            QPolygonF tmp_polygon;
            tmp_polygon << p2 << destArrowP1 << destArrowP2;


           model_graph->line = new QGraphicsLineItem(QLineF(p1,p2));
           model_graph->arrow = new QGraphicsPolygonItem(tmp_polygon);

           QPen * pen = new QPen();
           pen->setColor(Qt::red);
           pen->setBrush(Qt::red);
           pen->setWidth(3);
           model_graph->line->setPen(*pen);
           model_graph->arrow->setPen(*pen);
           model_graph->arrow->setBrush(Qt::red);

               model_graph->view_graph->scene()->addItem(dynamic_cast<QGraphicsItem *>(model_graph->line));
               model_graph->view_graph->scene()->addItem(dynamic_cast<QGraphicsItem *>(model_graph->arrow));
               //view_graph->scene()->update();
               model_graph->addedToScene = true;

           }

    }
    if(event->type() == QEvent::GraphicsSceneHoverLeave	 && !model_graph->getTransClicked() && !model_graph->getNodeCLicked() && !model_graph->getFinalClicked()){

        if(model_graph->addedToScene){
            model_graph->view_graph->scene()->removeItem(dynamic_cast<QGraphicsItem *>(model_graph->line));
            model_graph->view_graph->scene()->removeItem(dynamic_cast<QGraphicsItem *>(model_graph->arrow));
            delete model_graph->line;
            delete model_graph->arrow;
            model_graph->addedToScene = false;
        }

    }

   if(event->type() == QEvent::GraphicsSceneMousePress && !model_graph->getTransClicked() && !model_graph->getNodeCLicked() && !model_graph->getFinalClicked()){

       if(QGraphicsSceneMouseEvent* mouseEvent = static_cast<QGraphicsSceneMouseEvent*>(event)){

           if(mouseEvent->button() == Qt::RightButton){ //ajoute un menu pour le changement de couleur de la transition CLICK DROIT

               std::cout << "           the right button :D\n";

               std::cout <<"declanche right button \n";
               QSize iconSize = QSize (30,30);
               QPixmap iconPmap (iconSize);
               iconPmap.fill (Qt::transparent);

               QPainter painter (&iconPmap);
               painter.setBrush (QBrush (*m_colors::colorNonParcouru));
               painter.setPen(QPen(Qt::NoPen));
               painter.drawRect (0,0,30,30);
               painter.drawPixmap (0, 0, iconPmap);

               QIcon retIconNonParoucru;
               retIconNonParoucru.addPixmap(iconPmap, QIcon::Normal, QIcon::Off);
               retIconNonParoucru.addPixmap(iconPmap, QIcon::Normal, QIcon::On);

               painter.setBrush (QBrush (*m_colors::colorActif));
               painter.drawRect (0,0,30,30);
               painter.drawPixmap (0, 0, iconPmap);

               QIcon retIconActif;
               retIconActif.addPixmap(iconPmap, QIcon::Normal, QIcon::Off);
               retIconActif.addPixmap(iconPmap, QIcon::Normal, QIcon::On);

               painter.setBrush (QBrush (*m_colors::colorParcouru));
               painter.drawRect (0,0,30,30);
               painter.drawPixmap (0, 0, iconPmap);

               QIcon retIconParcouru;
               retIconParcouru.addPixmap(iconPmap, QIcon::Normal, QIcon::Off);
               retIconParcouru.addPixmap(iconPmap, QIcon::Normal, QIcon::On);

               painter.setBrush (QBrush (*m_colors::colorSolution));
               painter.drawRect (0,0,30,30);
               painter.drawPixmap (0, 0, iconPmap);

               QIcon retIconSolution;
               retIconSolution.addPixmap(iconPmap, QIcon::Normal, QIcon::Off);
               retIconSolution.addPixmap(iconPmap, QIcon::Normal, QIcon::On);

               menu = new QMenu(watched->scene()->views().at(0));
               menu->setStyleSheet("background-color:#8e8e8e;");


               action_non_parcouru = new QAction(retIconNonParoucru,"Non parcouru", watched->scene()->views().at(0));
               action_actif = new QAction(retIconActif,"Actif", watched->scene()->views().at(0));
               action_parcouru = new QAction(retIconParcouru, "Parcouru", watched->scene()->views().at(0));
               action_solution = new QAction(retIconSolution,"Solution",watched->scene()->views().at(0));

               model_graph->setRightClickedTransition(getTransitionFromQGraphicsItem(watched,event));

               QObject::connect(action_solution,SIGNAL(triggered()),this, SLOT(setSolutionTransColor()));
               QObject::connect(action_non_parcouru,SIGNAL(triggered()),this, SLOT(setNonParcouruTransColor()));
               QObject::connect(action_parcouru,SIGNAL(triggered()),this, SLOT(setParcouruTransColor()));
               QObject::connect(action_actif,SIGNAL(triggered()),this, SLOT(setActifTransColor()));


               menu->addAction(action_non_parcouru);
               menu->addAction(action_actif);
               menu->addAction(action_parcouru);
               menu->addAction(action_solution);


               menu->exec(mouseEvent->screenPos()); //euqivalent au global pos


           }
           else if(mouseEvent->button() == Qt::LeftButton){//ajoute fleche bleue sur le clic


                model_graph->removeAllSelectedTransitions();

                std::cout << "transClicked \n";
                model_graph->transition_clicked = true;
                //supprime les transition de hover (qui pourron donc etre reutiliser apres)
              // view_graph->scene()->removeItem(dynamic_cast<QGraphicsItem *>(line));
                //view_graph->scene()->removeItem(dynamic_cast<QGraphicsItem *>(arrow));
                model_graph->addedToScene = false;

                std::cout << "mouse enter QGraphics item\n";
                //creation de la ligne bleu
                m_transition * selectedTransition = getTransitionFromQGraphicsItem(watched,event);

                model_graph->clickedTransition = selectedTransition;
                QLineF * transition_line = selectedTransition->getGraphicalComponentLine();
                QPointF p1(transition_line->p1().x(),transition_line->p1().y());
                QPointF p2(transition_line->p2().x(),transition_line->p2().y());

                //creation du polygon bleu
                QPointF destPoint = p2.toPoint();
                int arrowSize = 10;
                double angle = ::acos(transition_line->dx() / transition_line->length());
                 if (transition_line->dy() >= 0)
                    angle = TwoPi - angle;

                 QPointF destArrowP1 = destPoint + QPointF(    sin(angle - Pi / 3)      * arrowSize, cos(angle - Pi / 3)      * arrowSize);
                 QPointF destArrowP2 = destPoint + QPointF(    sin(angle - Pi + Pi / 3) * arrowSize, cos(angle - Pi + Pi / 3) * arrowSize);


                 QPolygonF tmp_polygon;
                 tmp_polygon << p2 << destArrowP1 << destArrowP2;


                model_graph->line_click = new QGraphicsLineItem(QLineF(p1,p2));
                model_graph->arrow_click = new QGraphicsPolygonItem(tmp_polygon);

                QPen * pen = new QPen();
                pen->setColor(Qt::blue);
                pen->setBrush(Qt::blue);
                pen->setWidth(3);
                model_graph->line_click->setPen(*pen);
                model_graph->arrow_click->setPen(*pen);
                model_graph->arrow_click->setBrush(Qt::blue);

                model_graph->view_graph->scene()->addItem(dynamic_cast<QGraphicsItem *>(model_graph->line_click));
                model_graph->view_graph->scene()->addItem(dynamic_cast<QGraphicsItem *>(model_graph->arrow_click));
                //view_graph->scene()->update();
                model_graph->addedToScene = true;

                //supression des eventuelle selection de nodes (on ne peut pas selectionner a la fois une transition et un node)
                std::vector<m_node *> * nodes = model_graph->getNodes();
                for(int i =0;i<(int)nodes->size();i++){
                    m_node * tmp_node = nodes->at(i);
                    tmp_node->removePermanentSelection();
                }
           }
       }
    }


    return true;
}
示例#16
0
void SurfaceImpl::drawRect(const PRectangle &rc)
{
    painter->drawRect(
            QRectF(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top));
}
示例#17
0
/*
 * Let us pre-render the tiles. Either we've a Custom Image as
 * background or we use the drawRect  to fill the background and
 * last we put the number on it
 */
void PiecesTable::slotCustomImage( const QString& _str ) {
    QString str = _str;


    /* couldn't load image fall back to plain tiles*/
    QImage img = QImage(str);
    QPixmap pix;
    if(img.isNull())
        str = QString::null;
    else{
        img = img.smoothScale( width(),height() );
        pix.convertFromImage( img );
    }

    /* initialize base point */
    uint image=0;

    /* clear the old tiles */
    clear();

    /* used variables */
    int cols = numCols();
    int rows = numRows();
    int cellW   = cellWidth();
    int cellH   = cellHeight();
    int x2      = cellW-1;
    int y2      = cellH-1;
    bool empty  = str.isEmpty();
    double bw      = empty ? 0.9 : 0.98;
    int	x_offset = cellW - int(cellW * bw);	// 10% should be enough
    int	y_offset = cellH - int(cellH * bw);

    /* border polygon calculation*/
    initPolygon(cellW, cellH, x_offset, y_offset );

    /* avoid crashes with isNull() pixmap later */
    if ( cellW == 0 || cellH == 0 ) {
        _pixmap.resize( 0 );
        return;
    }

    /* make it bold and bigger */
    QFont f = font();
    f.setPixelSize(18);
    f.setBold( TRUE );

    /* for every tile */
    for(int row = 0; row < rows; ++row ) {
        for(int col= 0; col < cols; ++col) {
            QPixmap *pip = new QPixmap(cellW, cellH );
            QPainter *p = new QPainter(pip );
            p->setFont( f );

            /* draw the tradional tile  or a part of the pixmap*/
            if(empty) {
                p->setBrush(_colors[image]);
                p->setPen(NoPen);
                p->drawRect(0,0,cellW,cellH);
            }else
                p->drawPixmap(0, 0, pix,col*cellW, row*cellH, cellW, cellH );

            // draw borders
            if (height() > 40) {
                p->setBrush(_colors[image].light(130));
                p->drawPolygon(light_border);

                p->setBrush(_colors[image].dark(130));
                p->drawPolygon(dark_border);
            }

            // draw number
            p->setPen(black);
            p->drawText(0, 0, x2, y2, AlignHCenter | AlignVCenter, QString::number(image+1));

            delete p;
            _pixmap[image++] =  pip;
        }
    }
    _image = str;
}
//---------------------------------------------------------------------------
//  makePixmap
//
//! Create a pixmap representation of the rack.
//
//! @return the pixmap
//---------------------------------------------------------------------------
QPixmap
CrosswordGameRackWidget::makePixmap() const
{
    QPixmap pixmap (getRackSize());
    QPainter painter (&pixmap);

    // FIXME: most of this is duplicated between BoardWidget and here
    QColor backgroundColor = BACKGROUND_COLOR;
    QPalette backgroundPalette;
    backgroundPalette.setColor(QPalette::Light,
                               backgroundColor.light(SQUARE_SHADE_VALUE));
    backgroundPalette.setColor(QPalette::Mid, backgroundColor);
    backgroundPalette.setColor(QPalette::Dark,
                               backgroundColor.dark(SQUARE_SHADE_VALUE));

    for (int i = 0; i < NUM_TILES; ++i) {
        QRect rect (i * COLUMN_WIDTH, 0, COLUMN_WIDTH, ROW_HEIGHT);
        painter.setPen(backgroundColor);
        painter.setBrush(backgroundColor);
        painter.drawRect(rect);

        qDrawShadePanel(&painter, rect, backgroundPalette, false,
                        SQUARE_SHADE_PANEL_WIDTH);


        if (i >= letters.length())
            continue;

        QRect tileRect(i * COLUMN_WIDTH + TILE_MARGIN, TILE_MARGIN,
                       COLUMN_WIDTH - 2 * TILE_MARGIN -
                       SQUARE_SHADE_PANEL_WIDTH,
                       ROW_HEIGHT - 2 * TILE_MARGIN -
                       SQUARE_SHADE_PANEL_WIDTH);

        QColor color = TILE_COLOR;
        QPalette palette;
        palette.setColor(QPalette::Light,
                         color.light(TILE_SHADE_VALUE));
        palette.setColor(QPalette::Mid, color);
        palette.setColor(QPalette::Dark,
                         color.dark(TILE_SHADE_VALUE));

        painter.setPen(QColor("black"));
        painter.setBrush(color);
        painter.drawRect(tileRect);
        qDrawShadePanel(&painter, tileRect, palette, false,
                        TILE_SHADE_PANEL_WIDTH);

        QFont tileFont = font();
        tileFont.setPixelSize(LETTER_HEIGHT);
        tileFont.setWeight(QFont::Black);
        painter.setFont(tileFont);

        switch (playerNum) {
            case 1:  color = PLAYER1_LETTER_COLOR; break;
            case 2:  color = PLAYER2_LETTER_COLOR; break;
            default: color = DEFAULT_LETTER_COLOR; break;
        }
        painter.setPen(QPen(color));

        QChar letter = letters[i];
        if (letter == '?') {
            QPen pen (color);
            pen.setWidth(1);
            painter.setPen(pen);
            painter.setBrush(Qt::NoBrush);
            QRect blankRect(rect.x() + BLANK_SQUARE_MARGIN,
                            rect.y() + BLANK_SQUARE_MARGIN,
                            rect.width() - 2 * BLANK_SQUARE_MARGIN -
                            SQUARE_SHADE_PANEL_WIDTH - 1,
                            rect.height() - 2 * BLANK_SQUARE_MARGIN -
                            SQUARE_SHADE_PANEL_WIDTH - 1);
            painter.drawRect(blankRect);
        }

        else {
            painter.drawText(rect, Qt::AlignCenter, letter);
        }
    }

    return pixmap;
}
示例#19
0
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
    QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
    QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));


    QSqlDatabase db=QSqlDatabase::addDatabase("QMYSQL");

    //maBase=new QSqlDatabase(db);

    db.setHostName("172.16.63.111");
    db.setDatabaseName("dbtrouxNewWorld");
    db.setUserName("troux");
    db.setPassword("PscX57Q16");
    bool ok = db.open();
    if(!ok)
    {
        cout<<"Connection impossible"<<endl;
    }
    else
    {
        cout<<"Connection réussie"<<endl;
    }

    Connexion co;
    QVector<int> idUser = co.getTabIdUser();
    int nbUser = idUser.size();



    for(int comp=0; comp<nbUser; comp++)
    {
        QString userNom = co.getUserNom(idUser[comp]);
        QString userPrenom = co.getUserPrenom(idUser[comp]);
        QVector<int> numPDV = co.getUserTabPointDeVente(idUser[comp]);
        QVector<int> numProduit;
        for(int compPDV=0; compPDV<numPDV.size(); compPDV++)
        {
            QVector<int> tabInstNumProd = co.getProdByPDV(numPDV[compPDV]);
            for(int compProd=0; compProd < tabInstNumProd.size(); compProd++)
            {
                bool uniqueNumProd = true;
                for(int compVerifDoubleProd=0; compVerifDoubleProd < numProduit.size(); compVerifDoubleProd++)
                {
                    if(numProduit[compVerifDoubleProd] == tabInstNumProd[compProd])
                    {
                        uniqueNumProd = false;
                    }
                }
                if(uniqueNumProd){
                    numProduit.push_back(tabInstNumProd[compProd]);
                }
            }
        }
        QVector<int> numRayon = co.getTabRayon(numProduit);
        QVector<int> numCategorie = co.getTabCategorie(numRayon);

        QPrinter printer(QPrinter::HighResolution); //create your QPrinter (don't need to be high resolution, anyway)
        printer.setFullPage(QPrinter::A4);
        printer.setOutputFormat(QPrinter::NativeFormat);
        printer.setOutputFileName("pdfClient/"+ QString::number(idUser[comp]) +".pdf");


        QPen pen;
        int decalage = -100;
        int tailleImage = 1800;
        QPainter painter;
        painter.begin(&printer);
        QRectF rectangle(700, decalage,1000,900);
        QImage monImage;
        monImage.load("images/presentation/logoNw.jpg");
        painter.drawImage(rectangle, monImage);
        QRectF rectangle2(1200, decalage,8000,1000);
        QImage monImage2;
        monImage2.load("images/presentation/ecritureNw.png");
        painter.drawImage(rectangle2, monImage2);
        decalage += 2000;
        painter.setFont(QFont("Arial",15));
        painter.drawText(0, decalage, userNom +" "+ userPrenom +",");
        decalage += 250;
        painter.drawText(0, decalage,"Bienvenue sur votre catalogue personnalisé ");
        decalage += 400;
        painter.setFont(QFont("Arial",9));
        painter.drawText(0, decalage, "Liste des points de vente associés :");
        decalage += 200;
        pen.setWidth(10);
        painter.setPen(pen);
        for(int compNbPDV=0; compNbPDV<numPDV.size(); compNbPDV++)
        {
            painter.drawRect(0, decalage, 3000, 300);
            painter.drawText(100, decalage+200, QString::number(compNbPDV+1)+ " : " +co.getNomPDV(numPDV[compNbPDV]));
            painter.drawText(2000, decalage+200, QString::number(co.getProdByPDV(numPDV[compNbPDV]).size())+ " Produits");
            decalage += 300;
        }
        decalage += 1000;
        painter.setFont(QFont("Arial",12));
        painter.drawText(0, decalage,"Nous vous proposerons cette semaine "+QString::number(numProduit.size()) +" produits parmi les "+ QString::number(numPDV.size()) +" points de vente choisis.");
        decalage += 650;

        foreach(const int &idCategorie, numCategorie)
        {
            painter.drawText(0, decalage, co.getCategorieName(idCategorie));
            decalage += 200;
            foreach(const int &idRayon, numRayon)
            {
                if(co.getCategorieByRayon(idRayon) == idCategorie)
                {
                    painter.drawText(500,decalage, co.getRayonName(idRayon));
                    decalage += 500;
                    int decalageV = 1000;
                    foreach(const int &idProduit, numProduit)
                    {
                        if(co.getRayonByProd(idProduit) == idRayon)
                        {
                            painter.drawText(decalageV, decalage-300, co.getProdName(idProduit));
                            QRectF rectangle(decalageV, decalage-100, tailleImage, tailleImage);
                            QImage monImage;
                            monImage.load("images/produit/"+ QString::number(idProduit) +".png");
                            painter.drawImage(rectangle, monImage);
                            pen.setColor(Qt::magenta);
                            painter.setPen(pen);
                            painter.setFont(QFont("Arial",10));
                            painter.drawText(decalageV, decalage+tailleImage+100, QString::number(co.getPriceByIdProd(idProduit)) +" € par "+ co.getUniteByIdProd(idProduit));
                            QColor color;
                            color.setNamedColor("#04B404");
                            pen.setColor(color);
                            painter.setPen(pen);
                            painter.drawText(decalageV, decalage+tailleImage+300, "Restant : "+ QString::number(co.getQteRestanteByIdProd(idProduit)));
                            QVector<int> tabAssociatePDV = co.getTabPDVByIdProd(numPDV, idProduit);
                            QString letterPDV = "| ";
                            for(int compNoAPDV=0; compNoAPDV<tabAssociatePDV.size(); compNoAPDV++)
                            {
                                letterPDV += QString::number(compNoAPDV+1)+" | ";
                            }
                            pen.setColor(Qt::blue);
                            painter.setPen(pen);
                            painter.drawText(decalageV, decalage+tailleImage+500, "Disponible à : "+ letterPDV);
                            pen.setColor(Qt::black);
                            painter.setPen(pen);
                            painter.setFont(QFont("Arial",12));

                            decalageV += tailleImage+300;

                        }
                    }
                    decalage += tailleImage+900;
                    if(decalage > 10500){
                        printer.newPage();
                        decalage = 0;
                    }
                }
            }
        }
示例#20
0
//-----------------------------------------------------------
void CenaObjetos::definirGrade(unsigned tam)
{
 if(tam >= 20 || grade.style()==Qt::NoBrush)
 {
  QImage img_grade;
  float larg, alt, x, y;
  QSizeF tam_aux;
  QPrinter printer;
  QPainter painter;
  QPen pen;

  //Caso o tamanho do papel não seja personalizado
  if(tam_papel!=QPrinter::Custom)
  {
   //Configura um dispositivo QPrinter para obter os tamanhos de página
   printer.setPageSize(tam_papel);
   printer.setOrientation(orientacao_pag);
   printer.setPageMargins(margens_pag.left(), margens_pag.top(),
                          margens_pag.right(), margens_pag.bottom(), QPrinter::Millimeter);
   tam_aux=printer.pageRect(QPrinter::DevicePixel).size();
  }
  //Caso o tipo de papel seja personalizado, usa as margens como tamanho do papel
  else
   tam_aux=margens_pag.size();


  larg=fabs(roundf(tam_aux.width()/static_cast<float>(tam)) * tam);
  alt=fabs(roundf(tam_aux.height()/static_cast<float>(tam)) * tam);

  //Cria uma instância de QImage para ser a textura do brush
  tam_grade=tam;
  img_grade=QImage(larg, alt, QImage::Format_ARGB32);

  //Aloca um QPaointer para executar os desenhos sobre a imagem
  painter.begin(&img_grade);

  //Limpa a imagem
  painter.fillRect(QRect(0,0,larg,alt), QColor(255,255,255));

  if(exibir_grade)
  {
   //Cria a grade
   pen.setColor(QColor(225, 225, 225));
   painter.setPen(pen);

   for(x=0; x < larg; x+=tam)
    for(y=0; y < alt; y+=tam)
     painter.drawRect(QRectF(QPointF(x,y),QPointF(x + tam,y + tam)));
  }

  //Cria as linhas que definem o limite do papel
  if(exibir_lim_pagina)
  {
   pen.setColor(QColor(75,115,195));
   pen.setStyle(Qt::DashLine);
   pen.setWidthF(1.85f);
   painter.setPen(pen);
   painter.drawLine(larg-1, 0,larg-1,alt-1);
   painter.drawLine(0, alt-1,larg-1,alt-1);
  }

  painter.end();
  grade.setTextureImage(img_grade);
 }
}
void CannonField::paintTarget (QPainter &painter)
{
	painter.setPen (Qt::black);
	painter.setBrush (Qt::red);
	painter.drawRect (targetRect());
}
示例#22
0
void UcClassCanvas::draw(QPainter & p) {
  if (! visible()) return;
  p.setRenderHint(QPainter::Antialiasing, true);
  QRect r = rect();
  QFontMetrics fm(the_canvas()->get_font(UmlNormalFont));
  QFontMetrics fim(the_canvas()->get_font(UmlNormalItalicFont));
  QColor bckgrnd = p.backgroundColor();
  double zoom = the_canvas()->zoom();
  FILE * fp = svg();

  if (fp != 0)
    fputs("<g>\n", fp);

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

  QColor co = color(used_color);
  
  if (used_view_mode == asClass) {
    if (used_color != UmlTransparent) {
      const int shadow = the_canvas()->shadow();

      if (shadow != 0) {
	r.setRight(r.right() - shadow);
	r.setBottom(r.bottom() - shadow);
	
	p.fillRect (r.right(), r.top() + shadow,
		    shadow, r.height() - 1,
		    ::Qt::darkGray);
	p.fillRect (r.left() + shadow, r.bottom(),
		    r.width() - 1, shadow,
		    ::Qt::darkGray);

	if (fp != 0) {
	  fprintf(fp, "\t<rect fill=\"#%06x\" stroke=\"none\" stroke-opacity=\"1\""
		  " x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" />\n",
		  QColor(::Qt::darkGray).rgb()&0xffffff,
		  r.right(), r.top() + shadow, shadow - 1, r.height() - 1 - 1);

	  fprintf(fp, "\t<rect fill=\"#%06x\" stroke=\"none\" stroke-opacity=\"1\""
		  " x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" />\n",
		  QColor(::Qt::darkGray).rgb()&0xffffff,
		  r.left() + shadow, r.bottom(), r.width() - 1 - 1, shadow - 1);
	}
      }
    }
    
    p.setBackgroundColor(co);
  
    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);
    }
    else if (fp != 0)
      fprintf(fp, "\t<rect fill=\"none\" stroke=\"black\" stroke-width=\"1\" stroke-opacity=\"1\""
	      " x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" />\n",
	      r.x(), r.y(), r.width() - 1, r.height() - 1);

    p.drawRect(r);
  }
  
  const ClassData * data = ((ClassData *) browser_node->get_data());
  const int two = (int) (2 * zoom);
  int he = fm.height() + two;
  
  if (data->get_n_formalparams() != 0)
    r.setTop(r.top() + fm.height());
  
  switch (used_view_mode) {
  case asInterface:
    draw_interface_icon(p, r, used_color, zoom);
    r.setTop(r.top() + (int) (INTERFACE_SIZE * zoom) + two);
    break;
  case asControl:
    draw_control_icon(p, r, used_color, zoom);
    r.setTop(r.top() + (int) (CONTROL_HEIGHT * zoom) + two);
    break;
  case asBoundary:
    draw_boundary_icon(p, r, used_color, zoom);
    r.setTop(r.top() + (int) (BOUNDARY_HEIGHT * zoom) + two);
    break;
  case asEntity:
    draw_entity_icon(p, r, used_color, zoom);
    r.setTop(r.top() + (int) (ENTITY_SIZE * zoom) + two);
    break;
  case asActor:
    {
      QRect ra = r;
      
      ra.setHeight((int) (ACTOR_SIZE * zoom));
      ra.setLeft(ra.left() + 
		 (int) ((ra.width() - ACTOR_SIZE * zoom)/2));
      ra.setWidth(ra.height());
      draw_actor(&p, ra);
    }
    r.setTop(r.top() + (int) (ACTOR_SIZE * zoom) + two);
    break;
  case Natural:
    {
      const QPixmap * px = 
	ProfiledStereotypes::diagramPixmap(data->get_stereotype(), zoom);
      int lft = (px->width() < width()) ? r.x() + (width() - px->width())/2 : r.x();

      p.drawPixmap(lft, r.y(), *px);
      if (fp != 0)
	// pixmap not really exported in SVG
	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(UmlBlack), lft, r.y(), px->width() - 1, px->height() - 1);

      r.setTop(r.top() + px->height());
    }
    break;
  default:	// class
    r.setTop(r.top() + two);
    if (data->get_stereotype()[0]) {
      p.setFont(the_canvas()->get_font(UmlNormalFont));
      p.drawText(r, ::Qt::AlignHCenter + ::Qt::AlignTop, 
		 QString("<<") + toUnicode(data->get_short_stereotype()) + ">>");
      if (fp != 0)
	draw_text(r, ::Qt::AlignHCenter + ::Qt::AlignTop, 
		  QString("<<") + toUnicode(data->get_short_stereotype()) + ">>",
		  p.font(), fp);
      r.setTop(r.top() + he + two);
    }
  }
  
  p.setBackgroundMode(::Qt::TransparentMode);
  p.setFont((data->get_is_abstract())
	    ? the_canvas()->get_font(UmlNormalItalicFont)
	    : the_canvas()->get_font(UmlNormalFont));
  p.drawText(r, ::Qt::AlignHCenter + ::Qt::AlignTop, full_name);
  if (fp != 0)
    draw_text(r, ::Qt::AlignHCenter + ::Qt::AlignTop, full_name, p.font(), fp);

  p.setFont(the_canvas()->get_font(UmlNormalFont));
  
  if (used_view_mode == asClass) {
    r.setTop(r.top() + he);
    p.drawLine(r.topLeft(), r.topRight());
    
    if (fp != 0)
      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());
    
    r.setTop(r.top() + (int) (8 * zoom));
    p.drawLine(r.topLeft(), r.topRight());
    
    if (fp != 0)
      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());
  }
  
  if (fp != 0)
    fputs("</g>\n", fp);
    
  p.setBackgroundColor(bckgrnd);
  
  if (selected())
    show_mark(p, rect());
}
示例#23
0
void QgsColorSwatchGrid::draw( QPainter &painter )
{
  QPalette pal = QPalette( qApp->palette() );
  QColor headerBgColor = pal.color( QPalette::Mid );
  QColor headerTextColor = pal.color( QPalette::BrightText );
  QColor highlight = pal.color( QPalette::Highlight );

  //draw header background
  painter.setBrush( headerBgColor );
  painter.setPen( Qt::NoPen );
  painter.drawRect( QRect( 0, 0, width(), mLabelHeight + 0.5 * mLabelMargin ) );

  //draw header text
  painter.setPen( headerTextColor );
  painter.drawText( QRect( mLabelMargin, 0.25 * mLabelMargin, width() - 2 * mLabelMargin, mLabelHeight ),
                    Qt::AlignLeft | Qt::AlignVCenter, mScheme->schemeName() );

  //draw color swatches
  QgsNamedColorList::const_iterator colorIt = mColors.constBegin();
  int index = 0;
  for ( ; colorIt != mColors.constEnd(); ++colorIt )
  {
    int row = index / NUMBER_COLORS_PER_ROW;
    int column = index % NUMBER_COLORS_PER_ROW;

    QRect swatchRect = QRect( column * ( mSwatchSize + mSwatchSpacing ) + mSwatchMargin,
                              row * ( mSwatchSize + mSwatchSpacing ) + mSwatchMargin + mLabelHeight + 0.5 * mLabelMargin,
                              mSwatchSize, mSwatchSize );

    if ( mCurrentHoverBox == index )
    {
      //hovered boxes are slightly larger
      swatchRect.adjust( -1, -1, 1, 1 );
    }

    //start with checkboard pattern for semi-transparent colors
    if ( ( *colorIt ).first.alpha() != 255 )
    {
      QBrush checkBrush = QBrush( transparentBackground() );
      painter.setPen( Qt::NoPen );
      painter.setBrush( checkBrush );
      painter.drawRect( swatchRect );
    }

    if ( mCurrentHoverBox == index )
    {
      if ( mDrawBoxDepressed )
      {
        painter.setPen( QPen( QColor( 100, 100, 100 ), mSwatchOutlineSize ) );
      }
      else
      {
        //hover color
        painter.setPen( QPen( QColor( 220, 220, 220 ), mSwatchOutlineSize ) );
      }
    }
    else if ( mFocused && index == mCurrentFocusBox )
    {
      painter.setPen( highlight );
    }
    else if ( ( *colorIt ).first.name() == mBaseColor.name() )
    {
      //currently active color
      painter.setPen( QPen( QColor( 75, 75, 75 ), mSwatchOutlineSize ) );
    }
    else
    {
      painter.setPen( QPen( QColor( 197, 197, 197 ), mSwatchOutlineSize ) );
    }

    painter.setBrush( ( *colorIt ).first );
    painter.drawRect( swatchRect );

    index++;
  }
}
示例#24
0
void HSI::createCard(void){
    QImage _cardImage = QImage(QSize(600,600), QImage::Format_ARGB32);
    _cardImage.fill(0x00ff0000);
    //_cardImage.moveTo(10,10);
    
    uint midx, midy, width, height;
    width = _cardImage.width();
    midx = width/2;
    height = _cardImage.height();
    midy = height/2;
    
    
    QPainter p;
    p.setRenderHint(QPainter::Antialiasing, true);
    p.begin(&_cardImage);
    
    p.translate(midx, midy);
    p.setPen(Qt::black);
    
    p.setBrush(Qt::black);
    p.drawChord(-midx,-midy,width,height,0,360*16);
    
    
    p.setPen(Qt::white);
    p.setBrush(Qt::white);
    if(_thickBars > 0) {
        for (float i = 0 ; i <= 360; i+=_thickBars) {
            p.save();
            p.rotate(value2Angle(i));
            p.drawRect(-2.5, -300, 5.0, 30);
            p.restore();
        }
    }
    if(_thinBars > 0) {
        for (float i = 0 ; i <= 360; i+=_thinBars) {
            p.save();
            p.rotate(value2Angle(i));
            p.drawRect(-1.0, -300, 2.0, 20);
            p.restore();
        }
    }
    p.setPen(QColor(200,200,200));
    p.setFont(QFont(QString("Helvetica"), 48, QFont::Bold, false));
    
    if(1) {
        for (float i = 0 ; i < 360; i+=_numbers) {
            p.save();
            p.rotate(value2Angle(i));
            p.save();
            QString lineNumber;
            switch (int(i)) {
                case 0:
                    lineNumber = QString("N");
                    break;
                case 90:
                    lineNumber = QString("E");
                    break;
                case 180:
                    lineNumber = QString("S");
                    break;
                case 270:
                    lineNumber = QString("W");
                    break;
                default:
                    lineNumber = QString::number(i/10);
                    break;
            }
            p.translate(0,-234);
            int width = p.fontMetrics().width(lineNumber);
            int height = p.fontMetrics().height();
            p.drawText(-width/2,-height/2,width,height, Qt::AlignCenter,  lineNumber);
            p.restore();
            p.restore();
        }
    }
    
    
    
    p.end();    
    _card = QPixmap::fromImage(_cardImage, Qt::AutoColor);
    
}
示例#25
0
void FieldView::drawField(QPainter& p, const LogFrame* frame) {
    p.save();

    // reset to center
    p.translate(-Field_Dimensions::Current_Dimensions.FloorLength() / 2.0,
                -Field_Dimensions::Current_Dimensions.FloorWidth() / 2.0);

    p.translate(Field_Dimensions::Current_Dimensions.Border(),
                Field_Dimensions::Current_Dimensions.Border());

    p.setPen(QPen(Qt::white, Field_Dimensions::Current_Dimensions.LineWidth() *
                                 2.0));  // double-width pen for visibility
                                         //(although its less accurate)
    p.setBrush(Qt::NoBrush);
    p.drawRect(QRectF(0, 0, Field_Dimensions::Current_Dimensions.Length(),
                      Field_Dimensions::Current_Dimensions.Width()));

    // set brush alpha to 0
    p.setBrush(QColor(0, 130, 0, 0));

    // reset to center
    p.translate(Field_Dimensions::Current_Dimensions.Length() / 2.0,
                Field_Dimensions::Current_Dimensions.Width() / 2.0);

    // centerline
    p.drawLine(QLineF(0, Field_Dimensions::Current_Dimensions.Width() / 2, 0,
                      -Field_Dimensions::Current_Dimensions.Width() / 2.0));

    // center circle
    p.drawEllipse(
        QRectF(-Field_Dimensions::Current_Dimensions.CenterRadius(),
               -Field_Dimensions::Current_Dimensions.CenterRadius(),
               Field_Dimensions::Current_Dimensions.CenterDiameter(),
               Field_Dimensions::Current_Dimensions.CenterDiameter()));

    p.translate(-Field_Dimensions::Current_Dimensions.Length() / 2.0, 0);

    // goal areas
    p.drawArc(QRectF(-Field_Dimensions::Current_Dimensions.ArcRadius(),
                     -Field_Dimensions::Current_Dimensions.ArcRadius() +
                         Field_Dimensions::Current_Dimensions.GoalFlat() / 2.f,
                     2.f * Field_Dimensions::Current_Dimensions.ArcRadius(),
                     2.f * Field_Dimensions::Current_Dimensions.ArcRadius()),
              -90 * 16, 90 * 16);
    p.drawArc(QRectF(-Field_Dimensions::Current_Dimensions.ArcRadius(),
                     -Field_Dimensions::Current_Dimensions.ArcRadius() -
                         Field_Dimensions::Current_Dimensions.GoalFlat() / 2.f,
                     2.f * Field_Dimensions::Current_Dimensions.ArcRadius(),
                     2.f * Field_Dimensions::Current_Dimensions.ArcRadius()),
              90 * 16, -90 * 16);
    p.drawLine(QLineF(Field_Dimensions::Current_Dimensions.ArcRadius(),
                      -Field_Dimensions::Current_Dimensions.GoalFlat() / 2.f,
                      Field_Dimensions::Current_Dimensions.ArcRadius(),
                      Field_Dimensions::Current_Dimensions.GoalFlat() / 2.f));
    // Penalty Mark
    p.drawEllipse(
        QRectF(-Field_Dimensions::Current_Dimensions.PenaltyDiam() / 2.0f +
                   Field_Dimensions::Current_Dimensions.PenaltyDist(),
               -Field_Dimensions::Current_Dimensions.PenaltyDiam() / 2.0f,
               Field_Dimensions::Current_Dimensions.PenaltyDiam(),
               Field_Dimensions::Current_Dimensions.PenaltyDiam()));

    p.translate(Field_Dimensions::Current_Dimensions.Length(), 0);

    p.drawArc(QRectF(-Field_Dimensions::Current_Dimensions.ArcRadius(),
                     -Field_Dimensions::Current_Dimensions.ArcRadius() +
                         Field_Dimensions::Current_Dimensions.GoalFlat() / 2.f,
                     2.f * Field_Dimensions::Current_Dimensions.ArcRadius(),
                     2.f * Field_Dimensions::Current_Dimensions.ArcRadius()),
              -90 * 16, -90 * 16);
    p.drawArc(QRectF(-Field_Dimensions::Current_Dimensions.ArcRadius(),
                     -Field_Dimensions::Current_Dimensions.ArcRadius() -
                         Field_Dimensions::Current_Dimensions.GoalFlat() / 2.f,
                     2.f * Field_Dimensions::Current_Dimensions.ArcRadius(),
                     2.f * Field_Dimensions::Current_Dimensions.ArcRadius()),
              90 * 16, 90 * 16);
    p.drawLine(QLineF(-Field_Dimensions::Current_Dimensions.ArcRadius(),
                      -Field_Dimensions::Current_Dimensions.GoalFlat() / 2.f,
                      -Field_Dimensions::Current_Dimensions.ArcRadius(),
                      Field_Dimensions::Current_Dimensions.GoalFlat() / 2.f));
    // Penalty Mark
    p.drawEllipse(
        QRectF(-Field_Dimensions::Current_Dimensions.PenaltyDiam() / 2.0f -
                   Field_Dimensions::Current_Dimensions.PenaltyDist(),
               -Field_Dimensions::Current_Dimensions.PenaltyDiam() / 2.0f,
               Field_Dimensions::Current_Dimensions.PenaltyDiam(),
               Field_Dimensions::Current_Dimensions.PenaltyDiam()));

    // goals
    float x[2] = {0, Field_Dimensions::Current_Dimensions.GoalDepth()};
    float y[2] = {Field_Dimensions::Current_Dimensions.GoalWidth() / 2.0f,
                  -Field_Dimensions::Current_Dimensions.GoalWidth() / 2.0f};

    bool flip = frame->blue_team() ^ frame->defend_plus_x();

    QColor goalColor = flip ? Qt::yellow : Qt::blue;
    p.setPen(
        QPen(goalColor,
             Field_Dimensions::Current_Dimensions.LineWidth() *
                 2.0));  // double-width for visibility, not real-life accuracy
    p.drawLine(QLineF(x[0], y[0], x[1], y[0]));
    p.drawLine(QLineF(x[0], y[1], x[1], y[1]));
    p.drawLine(QLineF(x[1], y[1], x[1], y[0]));

    x[0] -= Field_Dimensions::Current_Dimensions.Length();
    x[1] -= Field_Dimensions::Current_Dimensions.Length() +
            2 * Field_Dimensions::Current_Dimensions.GoalDepth();

    goalColor = flip ? Qt::blue : Qt::yellow;
    p.setPen(QPen(goalColor,
                  Field_Dimensions::Current_Dimensions.LineWidth() * 2.0));
    p.drawLine(QLineF(x[0], y[0], x[1], y[0]));
    p.drawLine(QLineF(x[0], y[1], x[1], y[1]));
    p.drawLine(QLineF(x[1], y[1], x[1], y[0]));

    p.restore();
}
示例#26
0
void DAbstractSliderSpinBox::paintPlastique(QPainter& painter)
{
    Q_D(DAbstractSliderSpinBox);

    QStyleOptionSpinBox spinOpts         = spinBoxOptions();
    QStyleOptionProgressBar progressOpts = progressBarOptions();

    style()->drawComplexControl(QStyle::CC_SpinBox, &spinOpts, &painter, d->dummySpinBox);

    painter.save();

    QRect rect = progressOpts.rect.adjusted(2, 0, -2, 0);
    QRect leftRect;

    int progressIndicatorPos = (progressOpts.progress - double(progressOpts.minimum)) / qMax(double(1.0),
                                double(progressOpts.maximum) - progressOpts.minimum) * rect.width();

    if (progressIndicatorPos >= 0 && progressIndicatorPos <= rect.width())
    {
        leftRect = QRect(rect.left(), rect.top(), progressIndicatorPos, rect.height());
    }
    else if (progressIndicatorPos > rect.width())
    {
        painter.setPen(palette().highlightedText().color());
    }
    else
    {
        painter.setPen(palette().buttonText().color());
    }

    QRegion rightRect = rect;
    rightRect = rightRect.subtracted(leftRect);

    QTextOption textOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter);
    textOption.setWrapMode(QTextOption::NoWrap);

    if (!(d->edit && d->edit->isVisible()))
    {
        painter.setClipRegion(rightRect);
        painter.setClipping(true);
        painter.drawText(rect.adjusted(-2, 0, 2, 0), progressOpts.text, textOption);
        painter.setClipping(false);
    }

    if (!leftRect.isNull())
    {
        painter.setPen(palette().highlight().color());
        painter.setBrush(palette().highlight());
        painter.drawRect(leftRect.adjusted(0, 0, 0, -1));

        if (!(d->edit && d->edit->isVisible()))
        {
            painter.setPen(palette().highlightedText().color());
            painter.setClipRect(leftRect.adjusted(0, 0, 1, 0));
            painter.setClipping(true);
            painter.drawText(rect.adjusted(-2, 0, 2, 0), progressOpts.text, textOption);
            painter.setClipping(false);
        }
    }

    painter.restore();
}
示例#27
0
void RealPaintWidget::paintFrameTo( QPainter &to, const QRect &r, qreal frame )
{
	/*qreal currentFrame = layers[currentLayer]->frame();
		QRect viewportRect( rect() );

		if( fixedSize )
		{
			QSize sz = viewportRect.size() - size;
			viewportRect.setSize( size );
		}

		to.setRenderHints( QPainter::Antialiasing |
							QPainter::TextAntialiasing |
							QPainter::SmoothPixmapTransform );

		to.save();
		to.scale( qreal( r.width() ) / qreal( viewportRect.width() ),
					qreal( r.height() ) / qreal( viewportRect.height() ) );

		to.translate( r.x(), r.y() );

		viewportRect.setWidth( viewportRect.width() - 1 );
		viewportRect.setHeight( viewportRect.height() - 1 );

		FILL( background, to, viewportRect );

		to.setPen( QColor( 0, 0, 0 ) );
		to.drawRect( viewportRect );

		int size = layers.size();
		for (int i = 0; i < size; i++) {
			layers[i]->setFrame( frame );
			layers[i]->paint( to );
			layers[i]->setFrame( currentFrame );
		}

		to.restore();*/
	qreal currentFrame = layers[currentLayer]->frame();
	layers[currentLayer]->setFrame( frame );
	QRect viewportRect( rect() );

	if( fixedSize )
	{
		QSize sz = viewportRect.size() - size;
		viewportRect.setSize( size );
	}

	to.setRenderHints( QPainter::Antialiasing |
						QPainter::TextAntialiasing |
						QPainter::SmoothPixmapTransform );

	to.save();
	to.scale( qreal( r.width() ) / qreal( viewportRect.width() ),
				qreal( r.height() ) / qreal( viewportRect.height() ) );

	to.translate( r.x(), r.y() );

	viewportRect.setWidth( viewportRect.width() - 1 );
	viewportRect.setHeight( viewportRect.height() - 1 );

	//FILL( background, to, viewportRect );

	to.setPen( QColor( 0, 0, 0 ) );
	to.drawRect( viewportRect );
	layers[currentLayer]->paint( to );

	layers[currentLayer]->setFrame( currentFrame);
	to.restore();
}
示例#28
0
void RenderGlyph::paint(PaintInfo &paintInfo, int _tx, int _ty)
{
    if(paintInfo.phase != PaintActionForeground)
        return;

    if(style()->visibility() != VISIBLE)
        return;

    _tx += m_x;
    _ty += m_y;

    if((_ty > paintInfo.r.bottom()) || (_ty + m_height <= paintInfo.r.top()))
        return;

    QPainter *p = paintInfo.p;

    const QColor color(style()->color());
    p->setPen(color);

    int xHeight = m_height;
    int bulletWidth = (xHeight + 1) / 2;
    int yoff = (xHeight - 1) / 4;
    QRect marker(_tx, _ty + yoff, bulletWidth, bulletWidth);

    switch(m_type)
    {
        case LDISC:
            p->setBrush(color);
            p->drawEllipse(marker);
            return;
        case LCIRCLE:
            p->setBrush(Qt::NoBrush);
            p->drawEllipse(marker);
            return;
        case LSQUARE:
            p->setBrush(color);
            p->drawRect(marker);
            return;
        case LBOX:
            p->setBrush(Qt::NoBrush);
            p->drawRect(marker);
            return;
        case LDIAMOND:
        {
            static QPointArray diamond(4);
            int x = marker.x();
            int y = marker.y();
            int s = bulletWidth / 2;
            diamond[0] = QPoint(x + s, y);
            diamond[1] = QPoint(x + 2 * s, y + s);
            diamond[2] = QPoint(x + s, y + 2 * s);
            diamond[3] = QPoint(x, y + s);
            p->setBrush(color);
            p->drawConvexPolygon(diamond, 0, 4);
            return;
        }
        case LNONE:
            return;
        default:
            // not a glyph
            assert(false);
    }
}
示例#29
0
void QDeclarativeRectangle::drawRect(QPainter &p)
{
    Q_D(QDeclarativeRectangle);
    if ((d->gradient && d->gradient->gradient())
        || d->radius > width()/2 || d->radius > height()/2
        || width() < 3 || height() < 3) {
        // XXX This path is still slower than the image path
        // Image path won't work for gradients or invalid radius though
        bool oldAA = p.testRenderHint(QPainter::Antialiasing);
        if (d->smooth)
            p.setRenderHint(QPainter::Antialiasing);
        if (d->pen && d->pen->isValid()) {
            QPen pn(QColor(d->pen->color()), d->pen->width());
            pn.setJoinStyle(Qt::MiterJoin);
            p.setPen(pn);
        } else {
            p.setPen(Qt::NoPen);
        }
        if (d->gradient && d->gradient->gradient())
            p.setBrush(*d->gradient->gradient());
        else
            p.setBrush(d->color);
        const int pw = d->pen && d->pen->isValid() ? d->pen->width() : 0;
        QRectF rect;
        if (pw%2)
            rect = QRectF(0.5, 0.5, width()-1, height()-1);
        else
            rect = QRectF(0, 0, width(), height());
        qreal radius = d->radius;
        if (radius > width()/2 || radius > height()/2)
            radius = qMin(width()/2, height()/2);
        if (radius > 0.)
            p.drawRoundedRect(rect, radius, radius);
        else
            p.drawRect(rect);
        if (d->smooth)
            p.setRenderHint(QPainter::Antialiasing, oldAA);
    } else {
        bool oldAA = p.testRenderHint(QPainter::Antialiasing);
        bool oldSmooth = p.testRenderHint(QPainter::SmoothPixmapTransform);
        if (d->smooth)
            p.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform, d->smooth);

        const int pw = d->pen && d->pen->isValid() ? (d->pen->width()+1)/2*2 : 0;

        if (d->radius > 0)
            generateRoundedRect();
        else
            generateBorderedRect();

        int xOffset = (d->rectImage.width()-1)/2;
        int yOffset = (d->rectImage.height()-1)/2;
        Q_ASSERT(d->rectImage.width() == 2*xOffset + 1);
        Q_ASSERT(d->rectImage.height() == 2*yOffset + 1);

        // check whether we've eliminated the center completely
        if (2*xOffset > width()+pw)
            xOffset = (width()+pw)/2;
        if (2*yOffset > height()+pw)
            yOffset = (height()+pw)/2;

        QMargins margins(xOffset, yOffset, xOffset, yOffset);
        QTileRules rules(Qt::StretchTile, Qt::StretchTile);
        //NOTE: even though our item may have qreal-based width and height, qDrawBorderPixmap only supports QRects
        qDrawBorderPixmap(&p, QRect(-pw/2, -pw/2, width()+pw, height()+pw), margins, d->rectImage, d->rectImage.rect(), margins, rules);

        if (d->smooth) {
            p.setRenderHint(QPainter::Antialiasing, oldAA);
            p.setRenderHint(QPainter::SmoothPixmapTransform, oldSmooth);
        }
    }
}
示例#30
0
void PackageCanvas::draw(QPainter & p) {
  if (! visible()) return;
  p.setRenderHint(QPainter::Antialiasing, true);
  QRect r = rect();
  const BasicData * data = browser_node->get_data();  
  const QPixmap * px = 
    ProfiledStereotypes::diagramPixmap(data->get_stereotype(),
				       the_canvas()->zoom());
  FILE * fp = svg();
  
  if (fp != 0)
    fputs("<g>\n", fp);

  if (px != 0) {
    p.setBackgroundMode(::Qt::TransparentMode);
    
    
    int lft = (px->width() < width()) ? r.x() + (width() - px->width())/2 : r.x();
    
    p.drawPixmap(lft, r.y(), *px);
    if (fp != 0)
      // pixmap not really exported in SVG
      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(UmlBlack), lft, r.y(), px->width() - 1, px->height() - 1);
    
    r.moveBy(0, px->height());
    p.setFont(the_canvas()->get_font(UmlNormalBoldFont));
    p.drawText(r, ::Qt::AlignHCenter, browser_node->get_name());
    
    // pixmap not yet exported in SVG
    if (fp != 0)
      draw_text(r, ::Qt::AlignHCenter, browser_node->get_name(),
		p.font(), fp);
    p.setFont(the_canvas()->get_font(UmlNormalFont));
  }
  else {
    QColor bckgrnd = p.backgroundColor();
    QColor co = color(used_color);
    
    p.setBackgroundMode((used_color == UmlTransparent) ? ::Qt::TransparentMode : ::Qt::OpaqueMode);
    p.setBackgroundColor(co);
    p.setFont(the_canvas()->get_font(UmlNormalFont));
    
    QFontMetrics fm(the_canvas()->get_font(UmlNormalFont));
    const int four = (int) (4 * the_canvas()->zoom());
    const int he = fm.height();
    const int shadow = the_canvas()->shadow();
    if ((used_color != UmlTransparent) && (shadow != 0)) {
      r.setRight(r.right() - shadow);
      r.setBottom(r.bottom() - shadow);
    }
    
    r.setWidth(r.width() * 2 / 5);
    r.setHeight(he + four);
    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);
    
    if ((used_color != UmlTransparent) && (shadow != 0)) {
      p.fillRect (r.right(), r.top() + shadow,
		  shadow, r.height() - 1 - shadow,
		  ::Qt::darkGray);
      
      if (fp != 0)
	fprintf(fp, "\t<rect fill=\"#%06x\" stroke=\"none\" stroke-opacity=\"1\""
		" x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" />\n",
		QColor(::Qt::darkGray).rgb()&0xffffff,
		r.right(), r.top() + shadow, shadow - 1, r.height() - 1 - shadow - 1);
    }
    
    const char * name = browser_node->get_name();
    
    if (in_tab) {
      p.drawText(r, ::Qt::AlignCenter, name);
      if (fp != 0)
	draw_text(r, ::Qt::AlignCenter, name,
		  p.font(), fp);
    }
    
    r = rect();
    if ((used_color != UmlTransparent) && (shadow != 0)) {
      r.setRight(r.right() - shadow);
      r.setBottom(r.bottom() - shadow);
    }
    
    r.setTop(r.top() + he + four - 1);
    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);
    
    if ((used_color != UmlTransparent) && (shadow != 0)) {
      p.fillRect (r.right(), r.top() + shadow,
		  shadow, r.height() - 1,
		  ::Qt::darkGray);
      p.fillRect (r.left() + shadow, r.bottom(),
		  r.width() - 1, shadow,
		  ::Qt::darkGray);
      
      if (fp != 0) {
	fprintf(fp, "\t<rect fill=\"#%06x\" stroke=\"none\" stroke-opacity=\"1\""
		" x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" />\n",
		QColor(::Qt::darkGray).rgb()&0xffffff,
		r.right(), r.top() + shadow, shadow - 1, r.height() - 1 - 1);
	
	fprintf(fp, "\t<rect fill=\"#%06x\" stroke=\"none\" stroke-opacity=\"1\""
		" x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" />\n",
		QColor(::Qt::darkGray).rgb()&0xffffff,
		r.left() + shadow, r.bottom(), r.width() - 1 - 1, shadow - 1);
      }
    }
    
    const int three = (int) (3 * the_canvas()->zoom());
    
    r.setTop(r.top() + three);
    
    if (! in_tab) {
      p.drawText(r, ::Qt::AlignHCenter + ::Qt::AlignTop, name);
      if (fp != 0)
	draw_text(r, ::Qt::AlignHCenter + ::Qt::AlignTop, name,
		  p.font(), fp);
      r.setTop(r.top() + he + three);
    }
    
    if (data->get_stereotype()[0]) {
      p.drawText(r, ::Qt::AlignHCenter + ::Qt::AlignTop, 
		 QString("<<") + toUnicode(data->get_short_stereotype()) + ">>");
      if (fp != 0)
	draw_text(r, ::Qt::AlignHCenter + ::Qt::AlignTop, 
		  QString("<<") + toUnicode(data->get_short_stereotype()) + ">>",
		  p.font(), fp);
      r.setTop(r.top() + he + three);
    }
    
    if (full_name != name) {
      p.setFont(the_canvas()->get_font(UmlNormalItalicFont));
      p.drawText(r, ::Qt::AlignHCenter + ::Qt::AlignTop, full_name);
      if (fp != 0)
	draw_text(r, ::Qt::AlignHCenter + ::Qt::AlignTop, full_name,
		  p.font(), fp);
      p.setFont(the_canvas()->get_font(UmlNormalFont));
    }
  
    p.setBackgroundColor(bckgrnd);
  }
  
  if (fp != 0)
    fputs("</g>\n", fp);
  
  if (selected())
    show_mark(p, rect());
}