C++/Qt/QBrush

Материал из C\C++ эксперт
Перейти к: навигация, поиск

Basic drawing

<source lang="cpp"> /****************************************************************************

    • Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
    • All rights reserved.
    • Contact: Nokia Corporation (qt-info@nokia.com)
    • This file is part of the examples of the Qt Toolkit.
    • $QT_BEGIN_LICENSE:LGPL$
    • Commercial Usage
    • Licensees holding valid Qt Commercial licenses may use this file in
    • accordance with the Qt Commercial License Agreement provided with the
    • Software or, alternatively, in accordance with the terms contained in
    • a written agreement between you and Nokia.
    • GNU Lesser General Public License Usage
    • Alternatively, this file may be used under the terms of the GNU Lesser
    • General Public License version 2.1 as published by the Free Software
    • Foundation and appearing in the file LICENSE.LGPL included in the
    • packaging of this file. Please review the following information to
    • ensure the GNU Lesser General Public License version 2.1 requirements
    • will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
    • In addition, as a special exception, Nokia gives you certain additional
    • rights. These rights are described in the Nokia Qt LGPL Exception
    • version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
    • GNU General Public License Usage
    • Alternatively, this file may be used under the terms of the GNU
    • General Public License version 3.0 as published by the Free Software
    • Foundation and appearing in the file LICENSE.GPL included in the
    • packaging of this file. Please review the following information to
    • ensure the GNU General Public License version 3.0 requirements will be
    • met: http://www.gnu.org/copyleft/gpl.html.
    • If you have questions regarding the use of this file, please contact
    • Nokia at qt-info@nokia.com.
    • $QT_END_LICENSE$
                                                                                                                                                        • /
  1. ifndef RENDERAREA_H
  2. define RENDERAREA_H
  3. include <QBrush>
  4. include <QPen>
  5. include <QPixmap>
  6. include <QWidget>

class RenderArea : public QWidget { 

   Q_OBJECT

public: 

   enum Shape { Line, Points, Polyline, Polygon, Rect, RoundedRect, Ellipse, Arc,
                Chord, Pie, Path, Text, Pixmap };
   RenderArea(QWidget *parent = 0);
   QSize minimumSizeHint() const;
   QSize sizeHint() const;

public slots: 

   void setShape(Shape shape);
   void setPen(const QPen &pen);
   void setBrush(const QBrush &brush);
   void setAntialiased(bool antialiased);
   void setTransformed(bool transformed);

protected: 

   void paintEvent(QPaintEvent *event);

private: 

   Shape shape;
   QPen pen;
   QBrush brush;
   bool antialiased;
   bool transformed;
   QPixmap pixmap;

};

  1. endif


  1. include <QtGui>
  2. include "renderarea.h"

RenderArea::RenderArea(QWidget *parent) 

   : QWidget(parent)

{ 

   shape = Polygon;
   antialiased = false;
   transformed = false;
   pixmap.load(":/images/qt-logo.png");
   setBackgroundRole(QPalette::Base);
   setAutoFillBackground(true);

}

QSize RenderArea::minimumSizeHint() const { 

   return QSize(100, 100);

}

QSize RenderArea::sizeHint() const { 

   return QSize(400, 200);

}

void RenderArea::setShape(Shape shape) { 

   this->shape = shape;
   update();

}

void RenderArea::setPen(const QPen &pen) { 

   this->pen = pen;
   update();

}

void RenderArea::setBrush(const QBrush &brush) { 

   this->brush = brush;
   update();

}

void RenderArea::setAntialiased(bool antialiased) { 

   this->antialiased = antialiased;
   update();

}

void RenderArea::setTransformed(bool transformed) { 

   this->transformed = transformed;
   update();

}

void RenderArea::paintEvent(QPaintEvent * /* event */) { 

   static const QPoint points[4] = {
       QPoint(10, 80),
       QPoint(20, 10),
       QPoint(80, 30),
       QPoint(90, 70)
   };
   QRect rect(10, 20, 80, 60);
   QPainterPath path;
   path.moveTo(20, 80);
   path.lineTo(20, 30);
   path.cubicTo(80, 0, 50, 50, 80, 80);
   int startAngle = 20 * 16;
   int arcLength = 120 * 16;

   QPainter painter(this);
   painter.setPen(pen);
   painter.setBrush(brush);
   if (antialiased) {
       painter.setRenderHint(QPainter::Antialiasing, true);
       painter.translate(+0.5, +0.5);
   }

   for (int x = 0; x < width(); x += 100) {
       for (int y = 0; y < height(); y += 100) {
           painter.save();
           painter.translate(x, y);

           if (transformed) {
               painter.translate(50, 50);
               painter.rotate(60.0);
               painter.scale(0.6, 0.9);
               painter.translate(-50, -50);
           }

           switch (shape) {
           case Line:
               painter.drawLine(rect.bottomLeft(), rect.topRight());
               break;
           case Points:
               painter.drawPoints(points, 4);
               break;
           case Polyline:
               painter.drawPolyline(points, 4);
               break;
           case Polygon:
               painter.drawPolygon(points, 4);
               break;
           case Rect:
               painter.drawRect(rect);
               break;
           case RoundedRect:
               painter.drawRoundedRect(rect, 25, 25, Qt::RelativeSize);
               break;
           case Ellipse:
               painter.drawEllipse(rect);
               break;
           case Arc:
               painter.drawArc(rect, startAngle, arcLength);
               break;
           case Chord:
               painter.drawChord(rect, startAngle, arcLength);
               break;
           case Pie:
               painter.drawPie(rect, startAngle, arcLength);
               break;
           case Path:
               painter.drawPath(path);
               break;
           case Text:
               painter.drawText(rect, Qt::AlignCenter, tr("Qt by\nNokia"));
               break;
           case Pixmap:
               painter.drawPixmap(10, 10, pixmap);
           }

           painter.restore();
       }
   }
   painter.setPen(palette().dark().color());
   painter.setBrush(Qt::NoBrush);
   painter.drawRect(QRect(0, 0, width() - 1, height() - 1));

}


  1. ifndef WINDOW_H
  2. define WINDOW_H
  3. include <QWidget>

QT_BEGIN_NAMESPACE class QCheckBox; class QComboBox; class QLabel; class QSpinBox; QT_END_NAMESPACE class RenderArea;

class Window : public QWidget { 

   Q_OBJECT

public: 

   Window();

private slots: 

   void shapeChanged();
   void penChanged();
   void brushChanged();

private: 

   RenderArea *renderArea;
   QLabel *shapeLabel;
   QLabel *penWidthLabel;
   QLabel *penStyleLabel;
   QLabel *penCapLabel;
   QLabel *penJoinLabel;
   QLabel *brushStyleLabel;
   QLabel *otherOptionsLabel;
   QComboBox *shapeComboBox;
   QSpinBox *penWidthSpinBox;
   QComboBox *penStyleComboBox;
   QComboBox *penCapComboBox;
   QComboBox *penJoinComboBox;
   QComboBox *brushStyleComboBox;
   QCheckBox *antialiasingCheckBox;
   QCheckBox *transformationsCheckBox;

};

  1. endif


  1. include <QtGui>
  2. include "renderarea.h"
  3. include "window.h"

const int IdRole = Qt::UserRole;

Window::Window() { 

   renderArea = new RenderArea;
   shapeComboBox = new QComboBox;
   shapeComboBox->addItem(tr("Polygon"), RenderArea::Polygon);
   shapeComboBox->addItem(tr("Rectangle"), RenderArea::Rect);
   shapeComboBox->addItem(tr("Rounded Rectangle"), RenderArea::RoundedRect);
   shapeComboBox->addItem(tr("Ellipse"), RenderArea::Ellipse);
   shapeComboBox->addItem(tr("Pie"), RenderArea::Pie);
   shapeComboBox->addItem(tr("Chord"), RenderArea::Chord);
   shapeComboBox->addItem(tr("Path"), RenderArea::Path);
   shapeComboBox->addItem(tr("Line"), RenderArea::Line);
   shapeComboBox->addItem(tr("Polyline"), RenderArea::Polyline);
   shapeComboBox->addItem(tr("Arc"), RenderArea::Arc);
   shapeComboBox->addItem(tr("Points"), RenderArea::Points);
   shapeComboBox->addItem(tr("Text"), RenderArea::Text);
   shapeComboBox->addItem(tr("Pixmap"), RenderArea::Pixmap);
   shapeLabel = new QLabel(tr("&Shape:"));
   shapeLabel->setBuddy(shapeComboBox);

   penWidthSpinBox = new QSpinBox;
   penWidthSpinBox->setRange(0, 20);
   penWidthSpinBox->setSpecialValueText(tr("0 (cosmetic pen)"));
   penWidthLabel = new QLabel(tr("Pen &Width:"));
   penWidthLabel->setBuddy(penWidthSpinBox);

   penStyleComboBox = new QComboBox;
   penStyleComboBox->addItem(tr("Solid"), Qt::SolidLine);
   penStyleComboBox->addItem(tr("Dash"), Qt::DashLine);
   penStyleComboBox->addItem(tr("Dot"), Qt::DotLine);
   penStyleComboBox->addItem(tr("Dash Dot"), Qt::DashDotLine);
   penStyleComboBox->addItem(tr("Dash Dot Dot"), Qt::DashDotDotLine);
   penStyleComboBox->addItem(tr("None"), Qt::NoPen);
   penStyleLabel = new QLabel(tr("&Pen Style:"));
   penStyleLabel->setBuddy(penStyleComboBox);
   penCapComboBox = new QComboBox;
   penCapComboBox->addItem(tr("Flat"), Qt::FlatCap);
   penCapComboBox->addItem(tr("Square"), Qt::SquareCap);
   penCapComboBox->addItem(tr("Round"), Qt::RoundCap);
   penCapLabel = new QLabel(tr("Pen &Cap:"));
   penCapLabel->setBuddy(penCapComboBox);
   penJoinComboBox = new QComboBox;
   penJoinComboBox->addItem(tr("Miter"), Qt::MiterJoin);
   penJoinComboBox->addItem(tr("Bevel"), Qt::BevelJoin);
   penJoinComboBox->addItem(tr("Round"), Qt::RoundJoin);
   penJoinLabel = new QLabel(tr("Pen &Join:"));
   penJoinLabel->setBuddy(penJoinComboBox);

   brushStyleComboBox = new QComboBox;
   brushStyleComboBox->addItem(tr("Linear Gradient"),
           Qt::LinearGradientPattern);
   brushStyleComboBox->addItem(tr("Radial Gradient"),
           Qt::RadialGradientPattern);
   brushStyleComboBox->addItem(tr("Conical Gradient"),
           Qt::ConicalGradientPattern);
   brushStyleComboBox->addItem(tr("Texture"), Qt::TexturePattern);
   brushStyleComboBox->addItem(tr("Solid"), Qt::SolidPattern);
   brushStyleComboBox->addItem(tr("Horizontal"), Qt::HorPattern);
   brushStyleComboBox->addItem(tr("Vertical"), Qt::VerPattern);
   brushStyleComboBox->addItem(tr("Cross"), Qt::CrossPattern);
   brushStyleComboBox->addItem(tr("Backward Diagonal"), Qt::BDiagPattern);
   brushStyleComboBox->addItem(tr("Forward Diagonal"), Qt::FDiagPattern);
   brushStyleComboBox->addItem(tr("Diagonal Cross"), Qt::DiagCrossPattern);
   brushStyleComboBox->addItem(tr("Dense 1"), Qt::Dense1Pattern);
   brushStyleComboBox->addItem(tr("Dense 2"), Qt::Dense2Pattern);
   brushStyleComboBox->addItem(tr("Dense 3"), Qt::Dense3Pattern);
   brushStyleComboBox->addItem(tr("Dense 4"), Qt::Dense4Pattern);
   brushStyleComboBox->addItem(tr("Dense 5"), Qt::Dense5Pattern);
   brushStyleComboBox->addItem(tr("Dense 6"), Qt::Dense6Pattern);
   brushStyleComboBox->addItem(tr("Dense 7"), Qt::Dense7Pattern);
   brushStyleComboBox->addItem(tr("None"), Qt::NoBrush);
   brushStyleLabel = new QLabel(tr("&Brush Style:"));
   brushStyleLabel->setBuddy(brushStyleComboBox);

   otherOptionsLabel = new QLabel(tr("Other Options:"));

   antialiasingCheckBox = new QCheckBox(tr("&Antialiasing"));

   transformationsCheckBox = new QCheckBox(tr("&Transformations"));

   connect(shapeComboBox, SIGNAL(activated(int)),
           this, SLOT(shapeChanged()));
   connect(penWidthSpinBox, SIGNAL(valueChanged(int)),
           this, SLOT(penChanged()));
   connect(penStyleComboBox, SIGNAL(activated(int)),
           this, SLOT(penChanged()));
   connect(penCapComboBox, SIGNAL(activated(int)),
           this, SLOT(penChanged()));
   connect(penJoinComboBox, SIGNAL(activated(int)),
           this, SLOT(penChanged()));
   connect(brushStyleComboBox, SIGNAL(activated(int)),
           this, SLOT(brushChanged()));
   connect(antialiasingCheckBox, SIGNAL(toggled(bool)),
           renderArea, SLOT(setAntialiased(bool)));
   connect(transformationsCheckBox, SIGNAL(toggled(bool)),
           renderArea, SLOT(setTransformed(bool)));

   QGridLayout *mainLayout = new QGridLayout;

   mainLayout->setColumnStretch(0, 1);
   mainLayout->setColumnStretch(3, 1);
   mainLayout->addWidget(renderArea, 0, 0, 1, 4);
   mainLayout->setRowMinimumHeight(1, 6);
   mainLayout->addWidget(shapeLabel, 2, 1, Qt::AlignRight);
   mainLayout->addWidget(shapeComboBox, 2, 2);
   mainLayout->addWidget(penWidthLabel, 3, 1, Qt::AlignRight);
   mainLayout->addWidget(penWidthSpinBox, 3, 2);
   mainLayout->addWidget(penStyleLabel, 4, 1, Qt::AlignRight);
   mainLayout->addWidget(penStyleComboBox, 4, 2);
   mainLayout->addWidget(penCapLabel, 5, 1, Qt::AlignRight);
   mainLayout->addWidget(penCapComboBox, 5, 2);
   mainLayout->addWidget(penJoinLabel, 6, 1, Qt::AlignRight);
   mainLayout->addWidget(penJoinComboBox, 6, 2);
   mainLayout->addWidget(brushStyleLabel, 7, 1, Qt::AlignRight);
   mainLayout->addWidget(brushStyleComboBox, 7, 2);
   mainLayout->setRowMinimumHeight(8, 6);
   mainLayout->addWidget(otherOptionsLabel, 9, 1, Qt::AlignRight);
   mainLayout->addWidget(antialiasingCheckBox, 9, 2);
   mainLayout->addWidget(transformationsCheckBox, 10, 2);
   setLayout(mainLayout);
   shapeChanged();
   penChanged();
   brushChanged();
   antialiasingCheckBox->setChecked(true);
   setWindowTitle(tr("Basic Drawing"));

}

void Window::shapeChanged() { 

   RenderArea::Shape shape = RenderArea::Shape(shapeComboBox->itemData(
           shapeComboBox->currentIndex(), IdRole).toInt());
   renderArea->setShape(shape);

}

void Window::penChanged() { 

   int width = penWidthSpinBox->value();
   Qt::PenStyle style = Qt::PenStyle(penStyleComboBox->itemData(
           penStyleComboBox->currentIndex(), IdRole).toInt());
   Qt::PenCapStyle cap = Qt::PenCapStyle(penCapComboBox->itemData(
           penCapComboBox->currentIndex(), IdRole).toInt());
   Qt::PenJoinStyle join = Qt::PenJoinStyle(penJoinComboBox->itemData(
           penJoinComboBox->currentIndex(), IdRole).toInt());
   renderArea->setPen(QPen(Qt::blue, width, style, cap, join));

}

void Window::brushChanged() { 

   Qt::BrushStyle style = Qt::BrushStyle(brushStyleComboBox->itemData(
           brushStyleComboBox->currentIndex(), IdRole).toInt());

   if (style == Qt::LinearGradientPattern) {
       QLinearGradient linearGradient(0, 0, 100, 100);
       linearGradient.setColorAt(0.0, Qt::white);
       linearGradient.setColorAt(0.2, Qt::green);
       linearGradient.setColorAt(1.0, Qt::black);
       renderArea->setBrush(linearGradient);

   } else if (style == Qt::RadialGradientPattern) {
       QRadialGradient radialGradient(50, 50, 50, 70, 70);
       radialGradient.setColorAt(0.0, Qt::white);
       radialGradient.setColorAt(0.2, Qt::green);
       radialGradient.setColorAt(1.0, Qt::black);
       renderArea->setBrush(radialGradient);
   } else if (style == Qt::ConicalGradientPattern) {
       QConicalGradient conicalGradient(50, 50, 150);
       conicalGradient.setColorAt(0.0, Qt::white);
       conicalGradient.setColorAt(0.2, Qt::green);
       conicalGradient.setColorAt(1.0, Qt::black);
       renderArea->setBrush(conicalGradient);

   } else if (style == Qt::TexturePattern) {
       renderArea->setBrush(QBrush(QPixmap(":/images/brick.png")));

   } else {
       renderArea->setBrush(QBrush(Qt::green, style));
   }

}


  1. include <QApplication>
  2. include "window.h"

int main(int argc, char *argv[]) { 

   Q_INIT_RESOURCE(basicdrawing);
   QApplication app(argc, argv);
   Window window;
   window.show();
   return app.exec();

} 


 </source>


Create brush

<source lang="cpp"> /****************************************************************************

    • Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
    • All rights reserved.
    • Contact: Nokia Corporation (qt-info@nokia.com)
    • This file is part of the documentation of the Qt Toolkit.
    • $QT_BEGIN_LICENSE:LGPL$
    • Commercial Usage
    • Licensees holding valid Qt Commercial licenses may use this file in
    • accordance with the Qt Commercial License Agreement provided with the
    • Software or, alternatively, in accordance with the terms contained in
    • a written agreement between you and Nokia.
    • GNU Lesser General Public License Usage
    • Alternatively, this file may be used under the terms of the GNU Lesser
    • General Public License version 2.1 as published by the Free Software
    • Foundation and appearing in the file LICENSE.LGPL included in the
    • packaging of this file. Please review the following information to
    • ensure the GNU Lesser General Public License version 2.1 requirements
    • will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
    • In addition, as a special exception, Nokia gives you certain additional
    • rights. These rights are described in the Nokia Qt LGPL Exception
    • version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
    • GNU General Public License Usage
    • Alternatively, this file may be used under the terms of the GNU
    • General Public License version 3.0 as published by the Free Software
    • Foundation and appearing in the file LICENSE.GPL included in the
    • packaging of this file. Please review the following information to
    • ensure the GNU General Public License version 3.0 requirements will be
    • met: http://www.gnu.org/copyleft/gpl.html.
    • If you have questions regarding the use of this file, please contact
    • Nokia at qt-info@nokia.com.
    • $QT_END_LICENSE$
                                                                                                                                                        • /
  1. include <QtGui>

int main(int argv, char **args) { 

   QApplication app(argv, args);
   QRadialGradient gradient(50, 50, 50, 50, 50);
   gradient.setColorAt(0, QColor::fromRgbF(0, 1, 0, 1));
   gradient.setColorAt(1, QColor::fromRgbF(0, 0, 0, 0));
   QBrush brush(gradient);
   QWidget widget;
   QPalette palette;
   palette.setBrush(widget.backgroundRole(), brush);
   widget.setPalette(palette);
   widget.show();
   return app.exec();

} 


 </source>


Paint with QBrush

<source lang="cpp">

  1. include <QtGui>

int main(int argv, char **args) { 

   QApplication app(argv, args);
   QLinearGradient linearGrad(QPointF(100, 100), QPointF(200, 200));
   linearGrad.setColorAt(0, Qt::black);
   linearGrad.setColorAt(1, Qt::white);
   QBrush brush(linearGrad);
       QPainter painter;
       QPen pen(Qt::red, 2);                 // red solid line, 2 pixels wide
       painter.setPen(pen);              // set the red, wide pen
       painter.drawRect(40,30, 200,100); // draw a rectangle
       painter.setPen(Qt::blue);             // set blue pen, 0 pixel width
       painter.drawLine(40,30, 240,130); // draw a diagonal in rectangle
       painter.end();                    // painting done
   QWidget widget;
   QPalette palette;
   palette.setBrush(widget.backgroundRole(), brush);
   widget.setPalette(palette);
   widget.show();
   return app.exec();

} 


 </source>


Set push button checkable to true

<source lang="cpp">

  1. include <QtGui>

int main(int argc, char* argv[]) { 

 QApplication app(argc, argv);
 QDialog dlg;
 QPushButton *btn = new QPushButton(QObject::tr("Expand/Collapse"),&dlg);
 btn->setCheckable(true);
 QVBoxLayout *lay = new QVBoxLayout(&dlg);
 lay->addWidget(btn);
 QLabel *ext = new QLabel(QObject::tr("Extension"));
 dlg.setExtension(ext);
 QObject::connect(btn, SIGNAL(toggled(bool)),&dlg, SLOT(showExtension(bool)));
 dlg.exec();
 return app.exec();

} 


 </source>


Using Pen and Brush to draw

<source lang="cpp">

  1. include <QtGui>

int main(int argc, char* argv[]) { 

 QApplication app(argc, argv);
 QRect r(0,0, 100, 100);
 QPixmap pm(r.size());
 pm.fill();
 QPainter p(&pm);
 p.setRenderHint(QPainter::Antialiasing, true);
 QPen pen(Qt::red, 2);
 p.setPen(pen);
 QBrush brush(Qt::blue);
 p.setBrush(brush);
 QRect ri = r.adjusted(10,10,-10,-10)
 p.drawEllipse(ri);
 QLabel l;
 l.setPixmap(pm);
 l.show();
 return app.exec();

} 


 </source>
Источник — «http://cppe.ru/index.php?title=C%2B%2B/Qt/QBrush&oldid=1063»