嵌入未来

最新推荐文章于 2022-07-30 16:36:30 发布

火影忍者2222

最新推荐文章于 2022-07-30 16:36:30 发布

阅读量443

点赞数

分类专栏： QT教程文章标签： qt 图形 signal newline class 平台

QT教程专栏收录该内容

37 篇文章 0 订阅

订阅专栏

嵌入未来

yafeilinux.com

致力于Qt及Qt Creator的推广和普及工作！

Qt学习之路(32): 一个简易画板的实现(Graphics View)（转载）

这一次将介绍如何使用Graphics View来实现前面所说的画板。前面说了很多有关Graphics View的好话，但是没有具体的实例很难说究竟好在哪里。现在我们就把前面的内容使用Graphics View重新实现一下，大家可以对比一下看有什么区别。

同前面相似的内容就不再叙述了，我们从上次代码的基础上进行修改，以便符合我们的需要。首先来看MainWindow的代码：

mainwindow.cpp

#include “mainwindow.h”

MainWindow::MainWindow(QWidget *parent)
        : QMainWindow(parent)
{
        QToolBar *bar = this->addToolBar(“Tools”);
        QActionGroup *group = new QActionGroup(bar);

        QAction *drawLineAction = new QAction(“Line”, bar);
        drawLineAction->setIcon(QIcon(“:/line.png”));
        drawLineAction->setToolTip(tr(“Draw a line.”));
        drawLineAction->setStatusTip(tr(“Draw a line.”));
        drawLineAction->setCheckable(true);
        drawLineAction->setChecked(true);
        group->addAction(drawLineAction);

        bar->addAction(drawLineAction);
        QAction *drawRectAction = new QAction(“Rectangle”, bar);
        drawRectAction->setIcon(QIcon(“:/rect.png”));
        drawRectAction->setToolTip(tr(“Draw a rectangle.”));
        drawRectAction->setStatusTip(tr(“Draw a rectangle.”));
        drawRectAction->setCheckable(true);
        group->addAction(drawRectAction);
        bar->addAction(drawRectAction);

QLabel *statusMsg = new QLabel;
statusBar()->addWidget(statusMsg);

        PaintWidget *paintWidget = new PaintWidget(this);
        QGraphicsView *view = new QGraphicsView(paintWidget, this);
        setCentralWidget(view);

        connect(drawLineAction, SIGNAL(triggered()),
                        this, SLOT(drawLineActionTriggered()));
        connect(drawRectAction, SIGNAL(triggered()),
                        this, SLOT(drawRectActionTriggered()));
        connect(this, SIGNAL(changeCurrentShape(Shape::Code)),
                        paintWidget, SLOT(setCurrentShape(Shape::Code)));
}

void MainWindow::drawLineActionTriggered()
{
emit changeCurrentShape(Shape::Line);
}

void MainWindow::drawRectActionTriggered()
{
emit changeCurrentShape(Shape::Rect);
}

由于mainwindow.h的代码与前文相同，这里就不再贴出。而cpp文件里面只有少数几行与前文不同。由于我们使用Graphics View，所以，我们必须把item添加到QGprahicsScene里面。这里，我们创建了scene的对象，而scene对象需要通过view进行观察，因此，我们需要再使用一个QGraphcisView对象，并且把这个view添加到MainWindow里面。

我们把PaintWidget当做一个scene，因此PaintWidget现在是继承QGraphicsScene，而不是前面的QWidget。

paintwidget.h

#ifndef PAINTWIDGET_H
#define PAINTWIDGET_H

#include <QtGui>
#include <QDebug>

#include “shape.h”
#include “line.h”
#include “rect.h”

class PaintWidget : public QGraphicsScene
{
Q_OBJECT

public:
PaintWidget(QWidget *parent = 0);

public slots:
        void setCurrentShape(Shape::Code s)
        {
                if(s != currShapeCode) {
                        currShapeCode = s;
                }
        }

protected:
        void mousePressEvent(QGraphicsSceneMouseEvent *event);
        void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
        void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);

private:
        Shape::Code currShapeCode;
        Shape *currItem;
        bool perm;
};

#endif // PAINTWIDGET_H

paintwidget.cpp

#include “paintwidget.h”

PaintWidget::PaintWidget(QWidget *parent)
: QGraphicsScene(parent), currShapeCode(Shape::Line), currItem(NULL), perm(false)
{

}

void PaintWidget::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
        switch(currShapeCode)
        {
        case Shape::Line:
                {
                        Line *line = new Line;
                        currItem = line;
                        addItem(line);
                        break;
                }
        case Shape::Rect:
                {
                        Rect *rect = new Rect;
                        currItem = rect;
                        addItem(rect);
                        break;
                }
        }
        if(currItem) {
                currItem->startDraw(event);
                perm = false;
        }
        QGraphicsScene::mousePressEvent(event);
}

void PaintWidget::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
        if(currItem && !perm) {
                currItem->drawing(event);
        }
        QGraphicsScene::mouseMoveEvent(event);
}

void PaintWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
perm = true;
QGraphicsScene::mouseReleaseEvent(event);
}

我们把继承自QWidget改成继承自QGraphicsScene，同样也会有鼠标事件，只不过在这里我们把鼠标事件全部转发给具体的item进行处理。这个我们会在下面的代码中看到。另外一点是，每一个鼠标处理函数都包含了调用其父类函数的语句。

shape.h

#ifndef SHAPE_H
#define SHAPE_H

#include <QtGui>

class Shape
{
public:

        enum Code {
                Line,
                Rect
        };

Shape();

virtual void startDraw(QGraphicsSceneMouseEvent * event) = 0;
virtual void drawing(QGraphicsSceneMouseEvent * event) = 0;
};

#endif // SHAPE_H

shape.cpp

#include “shape.h”

Shape::Shape()
{
}

Shape类也有了变化：还记得我们曾经说过，Qt内置了很多item，因此我们不必全部重写这个item。所以，我们要使用Qt提供的类，就不需要在我们的类里面添加新的数据成员了。这样，我们就有了不带有额外的数据成员的Shape。那么，为什么还要提供Shape呢？因为我们在scene的鼠标事件中需要修改这些数据成员，如果没有这个父类，我们就需要按照Code写一个长长的switch来判断是那一个图形，这样是很麻烦的。所以我们依然创建了一个公共的父类，只要调用这个父类的draw函数即可。

line.h

#ifndef LINE_H
#define LINE_H

#include <QGraphicsLineItem>
#include “shape.h”

class Line : public Shape, public QGraphicsLineItem
{
public:
Line();

void startDraw(QGraphicsSceneMouseEvent * event);
void drawing(QGraphicsSceneMouseEvent * event);
};

#endif // LINE_H

line.cpp

#include “line.h”

Line::Line()
{
}

void Line::startDraw(QGraphicsSceneMouseEvent * event)
{
setLine(QLineF(event->scenePos(), event->scenePos()));
}

void Line::drawing(QGraphicsSceneMouseEvent * event)
{
QLineF newLine(line().p1(), event->scenePos());
setLine(newLine);
}

Line类已经和前面有了变化，我们不仅仅继承了Shape，而且继承了QGraphicsLineItem类。这里我们使用了C++的多继承机制。这个机制是很危险的，很容易发生错误，但是这里我们的Shape并没有继承其他的类，只要函数没有重名，一般而言是没有问题的。如果不希望出现不推荐的多继承(不管怎么说，多继承虽然危险，但它是符合面向对象理论的)，那就就想办法使用组合机制。我们之所以使用多继承，目的是让Line类同时具有Shape和QGraphicsLineItem的性质，从而既可以直接添加到QGraphicsScene中，又可以调用startDraw()等函数。

同样的还有Rect这个类：

rect.h

#ifndef RECT_H
#define RECT_H

#include <QGraphicsRectItem>
#include “shape.h”

class Rect : public Shape, public QGraphicsRectItem
{
public:
Rect();

void startDraw(QGraphicsSceneMouseEvent * event);
void drawing(QGraphicsSceneMouseEvent * event);
};

#endif // RECT_H

rect.cpp

#include “rect.h”

Rect::Rect()
{
}

void Rect::startDraw(QGraphicsSceneMouseEvent * event)
{
setRect(QRectF(event->scenePos(), QSizeF(0, 0)));
}

void Rect::drawing(QGraphicsSceneMouseEvent * event)
{
        QRectF r(rect().topLeft(),
                         QSizeF(event->scenePos().x() – rect().topLeft().x(), event->scenePos().y() – rect().topLeft().y()));
        setRect(r);
}

Line和Rect类的逻辑都比较清楚，和前面的基本类似。所不同的是，Qt并没有使用我们前面定义的两个Qpoint对象记录数据，而是在QGraphicsLineItem中使用QLineF，在QGraphicsRectItem中使用QRectF记录数据。这显然比我们的两个点的数据记录高级得多。其实，我们也完全可以使用这样的数据结构去重定义前面那些Line之类。

这样，我们的程序就修改完毕了。运行一下你会发现，几乎和前面的实现没有区别。这里说“几乎”，是在第一个点画下的时候，scene会移动一段距离。这是因为scene是自动居中的，由于我们把Line的第一个点设置为(0, 0)，因此当我们把鼠标移动后会有一个偏移。

看到这里或许并没有显示出Graphics View的优势。不过，建议在Line或者Rect的构造函数里面加上下面的语句，

setFlag(QGraphicsItem::ItemIsMovable, true);
setFlag(QGraphicsItem::ItemIsSelectable, true);

此时，你的Line和Rect就已经支持选中和拖放了！值得试一试哦！不过，需要注意的是，我们重写了scene的鼠标控制函数，所以这里的拖动会很粗糙，甚至说是不正确，你需要动动脑筋重新设计我们的类啦！

本文出自 “豆子空间” 博客，请务必保留此出处http://devbean.blog.51cto.com/448512/244181

本文出自 51CTO.COM技术博客

分类： Qt转载文章日期：四月 30th, 2010. No Comments.

Qt学习之路(31): 一个简易画板的实现(QWidget)（转载）

说实话，本来我是没有打算放一个很大的例子的，一则比较复杂，二来或许需要很多次才能说得完。不过，现在已经说完了绘图部分，所以计划还是上一个这样的例子。这里我会只做出一个简单的画板程序，大体上就是能够画直线和矩形吧。这样，我计划分成两种实现，一是使用普通的QWidget作为画板，第二则是使用Graphcis View Framework来实现。因为前面有朋友说不大明白Graphics View的相关内容，所以计划如此。

好了，现在先来看看我们的主体框架。我们的框架还是使用Qt Creator创建一个Gui Application工程。

简单的main()函数就不再赘述了，这里首先来看MainWindow。顺便说一下，我一般不会使用ui文件，所以这些内容都是手写的。首先先来看看最终的运行结果：

或许很简单，但是至少我们能够把前面所说的各种知识串连起来，这也就达到目的了。

现在先来看看MainWindow的代码：

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QtGui>

#include “shape.h”
#include “paintwidget.h”

class MainWindow : public QMainWindow
{
Q_OBJECT

public:
MainWindow(QWidget *parent = 0);

signals:
void changeCurrentShape(Shape::Code newShape);

private slots:
void drawLineActionTriggered();
void drawRectActionTriggered();

};

#endif // MAINWINDOW_H

mainwindow.cpp

#include “mainwindow.h”

MainWindow::MainWindow(QWidget *parent)
        : QMainWindow(parent)
{
        QToolBar *bar = this->addToolBar(“Tools”);
        QActionGroup *group = new QActionGroup(bar);

QLabel *statusMsg = new QLabel;
statusBar()->addWidget(statusMsg);

PaintWidget *paintWidget = new PaintWidget(this);
setCentralWidget(paintWidget);

void MainWindow::drawLineActionTriggered()
{
emit changeCurrentShape(Shape::Line);
}

void MainWindow::drawRectActionTriggered()
{
emit changeCurrentShape(Shape::Rect);
}

应该说，从以往的学习中可以看出，这里的代码没有什么奇怪的了。我们在MainWindow类里面声明了一个信号，changeCurrentShape(Shape::Code)，用于按钮按下后通知画图板。注意，QActio的triggered()信号是没有参数的，因此，我们需要在QAction的槽函数中重新emit我们自己定义的信号。构造函数里面创建了两个QAction，一个是drawLineAction，一个是drawRectAction，分别用于绘制直线和矩形。MainWindow的中心组件是PainWidget，也就是我们的画图板。下面来看看PaintWidget类：

paintwidget.h

#ifndef PAINTWIDGET_H
#define PAINTWIDGET_H

#include <QtGui>
#include <QDebug>
#include “shape.h”
#include “line.h”
#include “rect.h”

class PaintWidget : public QWidget
{
Q_OBJECT

public:
PaintWidget(QWidget *parent = 0);

public slots:
        void setCurrentShape(Shape::Code s)
        {
                if(s != currShapeCode) {
                        currShapeCode = s;
                }
        }

protected:
        void paintEvent(QPaintEvent *event);
        void mousePressEvent(QMouseEvent *event);
        void mouseMoveEvent(QMouseEvent *event);
        void mouseReleaseEvent(QMouseEvent *event);

private:
        Shape::Code currShapeCode;
        Shape *shape;
        bool perm;
        QList<Shape*> shapeList;
};

#endif // PAINTWIDGET_H

paintwidget.cpp

#include “paintwidget.h”

PaintWidget::PaintWidget(QWidget *parent)
: QWidget(parent), currShapeCode(Shape::Line), shape(NULL), perm(false)
{
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
}

void PaintWidget::paintEvent(QPaintEvent *event)
{
        QPainter painter(this);
        painter.setBrush(Qt::white);
        painter.drawRect(0, 0, size().width(), size().height());
        foreach(Shape * shape, shapeList) {
                shape->paint(painter);
        }
        if(shape) {
                shape->paint(painter);
        }
}

void PaintWidget::mousePressEvent(QMouseEvent *event)
{
        switch(currShapeCode)
        {
        case Shape::Line:
                {
                        shape = new Line;
                        break;
                }
        case Shape::Rect:
                {
                        shape = new Rect;
                        break;
                }
        }
        if(shape != NULL) {
                perm = false;
                shapeList<<shape;
                shape->setStart(event->pos());
                shape->setEnd(event->pos());
        }
}

void PaintWidget::mouseMoveEvent(QMouseEvent *event)
{
        if(shape && !perm) {
                shape->setEnd(event->pos());
                update();
        }
}

void PaintWidget::mouseReleaseEvent(QMouseEvent *event)
{
perm = true;
}

PaintWidget类定义了一个slot，用于接收改变后的新的ShapeCode。最主要的是，PaintWidget重定义了三个关于鼠标的事件：mousePressEvent，mouseMoveEvent和mouseReleaseEvent。

我们来想象一下如何绘制一个图形：图形的绘制与鼠标操作息息相关。以画直线为例，首先我们需要按下鼠标，确定直线的第一个点，所以在mousePressEvent里面，我们让shape保存下start点。然后在鼠标按下的状态下移动鼠标，此时，直线就会发生变化，实际上是直线的终止点在随着鼠标移动，所以在mouseMoveEvent中我们让shape保存下end点，然后调用update()函数，这个函数会自动调用paintEvent()函数，显示出我们绘制的内容。最后，当鼠标松开时，图形绘制完毕，我们将一个标志位置为true，此时说明这个图形绘制完毕。

为了保存我们曾经画下的图形，我们使用了一个List。每次按下鼠标时，都会把图形存入这个List。可以看到，我们在paintEvent()函数中使用了foreach遍历了这个List，绘制出历史图形。foreach是Qt提供的一个宏，用于遍历集合中的元素。

最后我们来看看Shape类。

shape.h

#ifndef SHAPE_H
#define SHAPE_H

#include <QtGui>

class Shape
{
public:

        enum Code {
                Line,
                Rect
        };

Shape();

        void setStart(QPoint s)
        {
                start = s;
        }

        void setEnd(QPoint e)
        {
                end = e;
        }

        QPoint startPoint()
        {
                return start;
        }

        QPoint endPoint()
        {
                return end;
        }

void virtual paint(QPainter & painter) = 0;

protected:
QPoint start;
QPoint end;
};

#endif // SHAPE_H

shape.cpp

#include “shape.h”

Shape::Shape()
{
}

Shape类最重要的就是保存了start和end两个点。为什么只要这两个点呢？因为我们要绘制的是直线和矩形。对于直线来说，有了两个点就可以确定这条直线，对于矩形来说，有了两个点作为左上角的点和右下角的点也可以确定这个矩形，因此我们只要保存两个点，就足够保存这两种图形的位置和大小的信息。paint()函数是Shape类的一个纯虚函数，子类都必须实现这个函数。我们现在有两个子类：Line和Rect，分别定义如下：

line.h

#ifndef LINE_H
#define LINE_H

#include “shape.h”

class Line : public Shape
{
public:
Line();

void paint(QPainter &painter);
};

#endif // LINE_H

line.cpp

#include “line.h”

Line::Line()
{
}

void Line::paint(QPainter &painter)
{
painter.drawLine(start, end);
}

rect.h

#ifndef RECT_H
#define RECT_H

#include “shape.h”

class Rect : public Shape
{
public:
Rect();

void paint(QPainter &painter);
};

#endif // RECT_H

rect.cpp

#include “rect.h”

Rect::Rect()
{
}

void Rect::paint(QPainter &painter)
{
painter.drawRect(start.x(), start.y(),
end.x() – start.x(), end.y() – start.y());
}

使用paint()函数，根据两个点的数据，Line和Rect都可以绘制出它们自身来。此时就可以看出，我们之所以要建立一个Shape作为父类，因为这两个类有几乎完全相似的数据对象，并且从语义上来说，Line、Rect与Shape也完全是一个is-a的关系。如果你想要添加颜色等的信息，完全可以在Shape类进行记录。这也就是类层次结构的好处。

代码很多也会比较乱，附件里面是整个工程的文件，有兴趣的朋友不妨看看哦！

本文出自 “豆子空间” 博客，请务必保留此出处http://devbean.blog.51cto.com/448512/243546

本文出自 51CTO.COM技术博客

分类： Qt转载文章日期：四月 30th, 2010. No Comments.

Qt学习之路(30): Graphics View Framework（转载）

现在基本上也已经到了2D绘图部分的尾声，所谓重头戏都是在最后压轴的，现在我们就要来看看在绘图部分功能最强大的Graphics View。我们经常说KDE桌面，新版本的KDE桌面就是建立在Graphics View的基础之上，可见其强大之处。

Qt的白皮书里面这样写道：“Qt Graphics View 提供了用于管理和交互大量定制的 2D 图形对象的平面以及可视化显示对象的视图 widget，并支持缩放和旋转功能。Graphics View 使用 BSP（二进制空间划分）树形可非常快速地找到对象，因此即使是包含百万个对象的大型场景，也能实时图形化显示。”

Graphics View是一个基于item的M-V架构的框架。

基于item意思是，它的每一个组件都是一个item。这是与QPainter的状态机不同。回忆一下，使用QPainter绘图多是采用一种面向过程的描述方式，首先使用drawLine()画一条直线，然后使用drawPolygon()画一个多边形；而对于Graphics View来说，相同的过程可以是，首先创建一个场景scene，然后创建一个line对象和一个polygon对象，再使用scene的add()函数将line和polygon添加到scene，最后通过视口view就可以看到了。乍看起来，后者似乎更加复杂，但是，如果你的图像中包含了成千上万的直线、多边形之类，管理这些对象要比管理QPainter的draw语句容易得多。并且，这些图形对象也更加符合面向对象的设计要求：一个很复杂的图形可以很方便的复用。

M-V架构的意思是，Graphics View提供一个model和一个view。所谓model就是我们添加的种种对象，所谓view就是我们观察这些对象的视口。同一个model可以由很多view从不同的角度进行观察，这是很常见的需求。使用QPainter就很难实现这一点，这需要很复杂的计算，而Qt的Graphics View就可以很容易的实现。

Graphics View提供了一个QGraphicsScene作为场景，即是我们添加图形的空间，相当于整个世界；一个QGraphicsView作为视口，也就是我们观察的窗口，相当于照相机的取景框，这个取景框可以覆盖整个场景，也可以是场景的一部分；一些QGraphicsItem作为图形元件，以便scene添加，Qt内置了很多图形，比如line、polygon等，都是继承自QGraphicsItem。

下面我们来看一下代码：

#include <QtGui>

class DrawApp : public QWidget {
public:
DrawApp();
protected:
void paintEvent(QPaintEvent *event);
};

DrawApp::DrawApp()
{

}

void DrawApp::paintEvent(QPaintEvent *event)
{
QPainter painter(this);
painter.drawLine(10, 10, 150, 300);
}

int main(int argc, char *argv[])
{
        QApplication a(argc, argv);
        QGraphicsScene *scene = new QGraphicsScene;
        scene->addLine(10, 10, 150, 300);
        QGraphicsView *view = new QGraphicsView(scene);
        view->resize(500, 500);
        view->setWindowTitle(“Graphics View”);
        view->show();

        DrawApp *da = new DrawApp;
        da->resize(500, 500);
        da->setWindowTitle(“QWidget”);
        da->show();
        return a.exec();
}

为了突出重点，我们就直接include了QtGui，不过在实际应用中不建议这么做。这里提供了直线的两种实现：一个是DrawApp使用我们前面介绍的技术，重写paintEvent()函数，这里就不在赘述，重点来看main()函数里面的实现。

首先，我们创建了一个QGraphicsScene作为场景，然后在scene中添加了一个直线，这样就把我们需要的图形元件放到了scene中。然后创建一个QGraphicsView对象进行观察。就这样，我们就是用Graphics View搭建了一个最简单的应用。运行这个程序来看结果：

第一张图是Graphics View的，第二个是DrawApp的。虽然这两个直线是同样的坐标，但是，DrawApp按照原始坐标绘制出了直线，而Graphics View则按照坐标绘制出直线之后，自动将直线居中显示在view视口。你可以通过拖动Graphics View来看直线是一直居中显示的。

这里仅仅是一个很简单的对比，不过你已经可以看到Graphics View功能的强大。仅这一个居中的操作，如果你是用QPainter，就需要很大的计算量了！当然，如果你不需要这种居中，Graphics View也是可以像QPainter绘制的一样进行显示的。

本文出自 “豆子空间” 博客，请务必保留此出处http://devbean.blog.51cto.com/448512/241186

本文出自 51CTO.COM技术博客

分类： Qt转载文章日期：四月 30th, 2010. No Comments.

Qt学习之路(29): 绘图设备（转载）

绘图设备是指继承QPainterDevice的子类。Qt一共提供了四个这样的类，分别是QPixmap、QBitmap、QImage和QPicture。其中，QPixmap专门为图像在屏幕上的显示做了优化，而QBitmap是QPixmap的一个子类，它的色深限定为1，你可以使用QPixmap的isQBitmap()函数来确定这个QPixmap是不是一个QBitmap。QImage专门为图像的像素级访问做了优化。QPicture则可以记录和重现QPainter的各条命令。下面我们将分两部分介绍这四种绘图设备。
QPixmap继承了QPaintDevice，因此，你可以使用QPainter直接在上面绘制图形。QPixmap也可以接受一个字符串作为一个文件的路径来显示这个文件，比如你想在程序之中打开png、jpeg之类的文件，就可以使用QPixmap。使用QPainter的drawPixmap()函数可以把这个文件绘制到一个QLabel、QPushButton或者其他的设备上面。QPixmap是针对屏幕进行特殊优化的，因此，它与实际的底层显示设备息息相关。注意，这里说的显示设备并不是硬件，而是操作系统提供的原生的绘图引擎。所以，在不同的操作系统平台下，QPixmap的显示可能会有所差别。

QPixmap提供了静态的grabWidget()和grabWindow()函数，用于将自身图像绘制到目标上。同时，在使用QPixmap时，你可以直接使用传值也不需要传指针，因为QPixmap提供了“隐式数据共享”。关于这一点，我们会在以后的章节中详细描述，这里只要知道传递QPixmap不必须使用指针就好了。

QBitmap继承自QPixmap，因此具有QPixmap的所有特性。QBitmap的色深始终为1. 色深这个概念来自计算机图形学，是指用于表现颜色的二进制的位数。我们知道，计算机里面的数据都是使用二进制表示的。为了表示一种颜色，我们也会使用二进制。比如我们要表示8种颜色，需要用3个二进制位，这时我们就说色深是3. 因此，所谓色深为1，也就是使用1个二进制位表示颜色。1个位只有两种状态：0和1，因此它所表示的颜色就有两种，黑和白。所以说，QBitmap实际上是只有黑白两色的图像数据。

由于QBitmap色深小，因此只占用很少的存储空间，所以适合做光标文件和笔刷。

下面我们来看同一个图像文件在QPixmap和QBitmap下的不同表现：

void PaintedWidget::paintEvent(QPaintEvent *event)
{
        QPainter painter(this);
        QPixmap pixmap(“Cat.png”);
        QBitmap bitmap(“Cat.png”);
        painter.drawPixmap(10, 10, 128, 128, pixmap);
        painter.drawPixmap(140, 10, 128, 128, bitmap);
        QPixmap pixmap2(“Cat2.png”);
        QBitmap bitmap2(“Cat2.png”);
        painter.drawPixmap(10, 140, 128, 128, pixmap2);
        painter.drawPixmap(140, 140, 128, 128, bitmap2);
}

先来看一下运行结果：

这里我们给出了两张png图片。Cat.png是没有透明色的纯白背景，而Cat2.png是具有透明色的背景。我们分别使用QPixmap和QBitmap来加载它们。注意看它们的区别：白色的背景在Qbitmap中消失了，而透明色在QBitmap中转换成了黑色；其他颜色则是使用点的疏密程度来体现的。

QPixmap使用底层平台的绘制系统进行绘制，无法提供像素级别的操作，而QImage则是使用独立于硬件的绘制系统，实际上是自己绘制自己，因此提供了像素级别的操作，并且能够在不同系统之上提供一个一致的显示形式。

如上图所示(出自Qt API文档)，我们声明了一个QImage对象，大小是3 x 3，颜色模式是RGB32，即使用32位数值表示一个颜色的RGB值，也就是说每种颜色使用8位。然后我们对每个像素进行颜色赋值，从而构成了这个图像。你可以把QImage想象成一个RGB颜色的二维数组，记录了每一像素的颜色。

最后一个需要说明的是QPicture。这是一个可以记录和重现QPainter命令的绘图设备。QPicture将QPainter的命令序列化到一个IO设备，保存为一个平台独立的文件格式。这种格式有时候会是“元文件(meta-files)”。Qt的这种格式是二进制的，不同于某些本地的元文件，Qt的pictures文件没有内容上的限制，只要是能够被QPainter绘制的元素，不论是字体还是pixmap，或者是变换，都可以保存进一个picture中。

QPicture是平台无关的，因此它可以使用在多种设备之上，比如svg、pdf、ps、打印机或者屏幕。回忆下我们这里所说的QPaintDevice，实际上是说可以有QPainter绘制的对象。QPicture使用系统的分辨率，并且可以调整QPainter来消除不同设备之间的显示差异。

如果我们要记录下QPainter的命令，首先要使用QPainter::begin()函数，将QPicture实例作为参数传递进去，以便告诉系统开始记录，记录完毕后使用QPainter::end()命令终止。代码示例如下：

QPicture picture;
QPainter painter;
painter.begin(&picture);              // paint in picture
painter.drawEllipse(10,20, 80,70); // draw an ellipse
painter.end();                           // painting done
picture.save(“drawing.pic”);         // save picture

如果我们要重现命令，首先要使用QPicture::load()函数进行装载：

QPicture picture;
picture.load(“drawing.pic”); // load picture
QPainter painter;
painter.begin(&myImage); // paint in myImage
painter.drawPicture(0, 0, picture); // draw the picture at (0,0)
painter.end();

本文出自 “豆子空间” 博客，请务必保留此出处http://devbean.blog.51cto.com/448512/239845

本文出自 51CTO.COM技术博客

分类： Qt转载文章日期：四月 30th, 2010. No Comments.

Qt学习之路(28): 坐标变换（转载）

经过前面的章节，我们已经能够画出一些东西来，主要就是使用QPainter的相关函数。今天，我们要看的是QPainter的坐标系统。

同很多坐标系统一样，QPainter的默认坐标的原点(0, 0)位于屏幕的左上角，X轴正方向是水平向右，Y轴正方向是竖直向下。在这个坐标系统中，每个像素占据1 x 1的空间。你可以把它想象成是一张坐标值，其中的每个小格都是1个像素。这么说来，一个像素的中心实际上是一个“半像素坐标系”，也就是说，像素(x, y)的中心位置其实是在(x + 0.5, y + 0.5)的位置上。因此，如果我们使用QPainter在(100, 100)处绘制一个像素，那么，这个像素的中心坐标是(100.5, 100.5)。

这种细微的差别在实际应用中，特别是对坐标要求精确的系统中是很重要的。首先，只有在禁止反走样，也就是默认状态下，才会有这0.5像素的偏移；如果使用了反走样，那么，我们画(100, 100)位置的像素时，QPainter会在(99.5, 99.5)，(99.5, 100.5)，(100.5, 99.5)和(100.5, 100.5)四个位置绘制一个亮色的像素，这么产生的效果就是在这四个像素的焦点处(100, 100)产生了一个像素。如果不需要这个特性，就需要将QPainter的坐标系平移(0.5, 0.5)。

这一特性在绘制直线、矩形等图形的时候都会用到。下图给出了在没有反走样技术时，使用drawRect(2, 2, 6, 5)绘制一个矩形的示例。在No Pen的情况下，请注意矩形左上角的像素是在(2, 2)，其中心位置是在(2.5, 2.5)的位置。然后注意下有不同的Pen的值的绘制样式，在Pen宽为1时，实际画出的矩形的面积是7 x 6的(图出自C++ GUI Programming with Qt4, 2nd Edition)：

在具有反走样时，使用drawRect(2, 2, 6, 5)的效果如下(图出自C++ GUI Programming with Qt4, 2nd Edition)：

注意我们前面说过，通过平移QPainter的坐标系来消除着0.5像素的差异。下面给出了使用drawRect(2.5, 2.5, 6, 5)在反走样情况下绘制的矩形(图出自C++ GUI Programming with Qt4, 2nd Edition)：

请对比与上图的区别。

在上述的QPainter的默认坐标系下，QPainter提供了视口(viewport)窗口(window)机制，用于绘制与绘制设备的大小和分辨率无关的图形。视口和窗口是紧密的联系在一起的，它们一般都是矩形。视口是由物理坐标确定其大小，而窗口则是由逻辑坐标决定。我们在使用QPainter进行绘制时，传给QPainter的是逻辑坐标，然后，Qt的绘图机制会使用坐标变换将逻辑坐标转换成物理坐标后进行绘制。

通常，视口和窗口的坐标是一致的。比如一个600 x 800的widget(这是一个widget，或许是一个对话框，或许是一个面板等等)，默认情况下，视口和窗口都是一个320 x 200的矩形，原点都在(0, 0)，此时，视口和窗口的坐标是相同的。

注意到QPainter提供了setWindow()和setViewport()函数，用来设置视口和窗口的矩形大小。比如，在上面所述的320 x 200的widget中，我们要设置一个从(-50, -50)到(+50, +50)，原点在中心的矩形窗口，就可以使用

painter.setWindow(-50, -50, 100, 100);

其中，(-50, -50)指明了原点，100, 100指明了窗口的长和宽。这里的“指明原点”意思是，逻辑坐标的(-50, -50)对应着物理坐标的(0, 0)；“长和宽”说明，逻辑坐标系下的长100，宽100实际上对应物理坐标系的长320，宽200。

或许你已经发现这么一个好处，我们可以随时改变window的范围，而不改变底层物理坐标系。这就是前面所说的，视口与窗口的作用：“绘制与绘制设备的大小和分辨率无关的图形”，如下图所示(图出自C++ GUI Programming with Qt4, 2nd Edition)：

除了视口与窗口的变化，QPainter还提供了一个“世界坐标系”，同样也可以变换图形。所不同的是，视口与窗口实际上是统一图形在两个坐标系下的表达，而世界坐标系的变换是通过改变坐标系来平移、缩放、旋转、剪切图形。为了清楚起见，我们来看下面一个例子：

void PaintedWidget::paintEvent(QPaintEvent *event)
{
        QPainter painter(this);
        QFont font(“Courier”, 24);
        painter.setFont(font);
        painter.drawText(50, 50, “Hello, world!”);
        QTransform transform;
        transform.rotate(+45.0);
        painter.setWorldTransform(transform);
        painter.drawText(60, 60, “Hello, world!”);
}

为了显示方便，我在这里使用了QFont改变了字体。QPainter的drawText()函数提供了绘制文本的功能。它有几种重载形式，我们使用了其中的一种，即制定文本的坐标然后绘制。需要注意的是，这里的坐标是文字左下角的坐标(特别提醒这一点，因为很多绘图系统，比如Java2D都是把左上角作为坐标点的)！下面是运行结果：

我们使用QTransform做了一个rotate变换。这个变换就是旋转，而且是顺时针旋转45度。然后我们使用这个变换设置了QPainter的世界坐标系，注意到QPainter是一个状态机，所以这种变换并不会改变之前的状态，因此只有第二个Hello, world!被旋转了。确切的说，被旋转的是坐标系而不是这个文字！请注意体会这两种说法的不同。

火影忍者2222

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
嵌入未来

嵌入未来yafeilinux.com致力于Qt及Qt Creator的推广和普及工作！我的主页Qt教程及软件单片机教程PHP+MySql教程资源下载最近更新Qt学习之路(32): 一个简易画板的实现(Graphics View)（转载）版权声明：原创作品，允许转载，转载时请务必以超链接形式标明文章原始出处、作者信息
复制链接

扫一扫

专栏目录