绘图

main.c

#include
#include "painter.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Painter w;
    w.show();
    return a.exec();
}

painter.cpp
#include "painter.h"
#include "ui_painter.h"
#include "scribblearea.h"
#include
#include
#include
#include

Painter::Painter(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Painter)
{
    ui->setupUi(this);
    scribbleArea = new ScribbleArea(this);
    scribbleArea->setCursor(QCursor(Qt::CrossCursor));
    ui->gridLayout->addWidget(scribbleArea,1,0);

    connect(ui->clearButton,SIGNAL(clicked()),
           scribbleArea,SLOT(clearImage()));
    connect(ui->closeButton,SIGNAL(clicked()),this,SLOT(close()));
    connect(ui->spinBox,SIGNAL(valueChanged(int)),this,SLOT(doSetWidth(int)));
}

Painter::~Painter()
{
    delete ui;
}

void Painter::on_changeColorButton_clicked()
{
    QColor color = QColorDialog::getColor();

    if(color.isValid())
    {
        ui->colorLabel->setPalette(QPalette(color));
        scribbleArea->setPenColor(color);
    }
}

void Painter::on_openButton_clicked()
{
    QString file = QFileDialog::getOpenFileName(
                        this, "Open File", "../",
                        "PNG image(*.png);;JPG image(*.jpg);;All Files(*.*)"
                         );
    if(!file.isNull())
    {
        scribbleArea->openImage(file);
    }
}

void Painter::doSetWidth(int w)
{
    scribbleArea->setPenWidth(w);
}

 

#ifndef PAINTER_H
#define PAINTER_H

#include

class ScribbleArea;
namespace Ui {
    class Painter;
}

class Painter : public QWidget {
    Q_OBJECT
public:
    Painter(QWidget *parent = 0);
    ~Painter();

    ScribbleArea *scribbleArea;

public slots:
    void on_changeColorButton_clicked();
    void on_openButton_clicked();
    void doSetWidth(int);

private:
    Ui::Painter *ui;
    QImage image;
};

#endif // PAINTER_H

 

#include
#include "scribblearea.h"

ScribbleArea::ScribbleArea(QWidget *parent)
    : QWidget(parent)
{
    //setAttribute(Qt::WA_StaticContents);
    modified = false;
    scribbling = false;
    myPenWidth = 5;
    myPenColor = Qt::red;
    //drawLineTo(QPoint(100,100));
}

bool ScribbleArea::openImage(const QString &fileName)
{
    qDebug()<<"in openImage";
    drawLineTo(QPoint(400,100));
    QImage loadedImage;
    if (!loadedImage.load(fileName))
        return false;

    QSize newSize = loadedImage.size().expandedTo(size());
    resizeImage(&loadedImage, newSize);
    image = loadedImage;
    modified = false;
    update();

    return true;
}

bool ScribbleArea::saveImage(const QString &fileName, const char *fileFormat)
{
    QImage visibleImage = image;
    resizeImage(&visibleImage, size());

    if (visibleImage.save(fileName, fileFormat)) {
        modified = false;
        return true;
    } else {
        return false;
    }
}

void ScribbleArea::setPenColor(const QColor &newColor)
{

    //drawLineTo(QPoint(100,100));
    myPenColor = newColor;
}

void ScribbleArea::setPenWidth(int newWidth)
{
    drawLineTo(QPoint(100,100));
    myPenWidth = newWidth;
}

void ScribbleArea::clearImage()
{
    image.fill(qRgb(255, 255, 255));
    modified = true;
    update();
}

void ScribbleArea::mousePressEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton) {
        lastPoint = event->pos();
        scribbling = true;
    }
}

void ScribbleArea::mouseMoveEvent(QMouseEvent *event)
{
    if ((event->buttons() & Qt::LeftButton) && scribbling)
        drawLineTo(event->pos());
}

void ScribbleArea::mouseReleaseEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton && scribbling) {
        drawLineTo(event->pos());
        scribbling = false;
    }
}

void ScribbleArea::paintEvent(QPaintEvent * /* event */)
{
    QPainter painter(this);
    painter.drawImage(QPoint(0, 0), image);
}

void ScribbleArea::resizeEvent(QResizeEvent *event)
{
    if (width() > image.width() || height() > image.height()) {
        int newWidth = qMax(width() + 128, image.width());
        int newHeight = qMax(height() + 128, image.height());
        resizeImage(&image, QSize(newWidth, newHeight));
        update();
    }
    QWidget::resizeEvent(event);
}

void ScribbleArea::drawLineTo(const QPoint &endPoint)
{
    QImage *image1 =  new QImage(200,200,QImage::Format_RGB32);
    QPainter painter1(image1);
    painter1.setPen(Qt::NoPen);
    qDebug()<<"aaa";
    QPainter painter(&image);
    painter.setPen(QPen(myPenColor, myPenWidth, Qt::SolidLine, Qt::RoundCap,
                        Qt::RoundJoin));
    painter.drawLine(lastPoint, endPoint);
    modified = true;

    int rad = (myPenWidth / 2) + 2;
    update(QRect(lastPoint, endPoint).normalized()
                                     .adjusted(-rad, -rad, +rad, +rad));
    lastPoint = endPoint;
}

void ScribbleArea::resizeImage(QImage *image, const QSize &newSize)
{
    if (image->size() == newSize)
        return;

    QImage newImage(newSize, QImage::Format_RGB32);
    newImage.fill(qRgb(255, 255, 255));
    QPainter painter(&newImage);
    painter.drawImage(QPoint(0, 0), *image);
    *image = newImage;
}

void ScribbleArea::print()
{
    QPrinter printer(QPrinter::HighResolution);
 
    QPrintDialog *printDialog = new QPrintDialog(&printer, this);
    if (printDialog->exec() == QDialog::Accepted) {
        QPainter painter(&printer);
        QRect rect = painter.viewport();
        QSize size = image.size();
        size.scale(rect.size(), Qt::KeepAspectRatio);
        painter.setViewport(rect.x(), rect.y(), size.width(), size.height());
        painter.setWindow(image.rect());
        painter.drawImage(0, 0, image);
    }
}

#ifndef SCRIBBLEAREA_H
#define SCRIBBLEAREA_H

#include
#include
#include
#include

class ScribbleArea : public QWidget
{
    Q_OBJECT

public:
    ScribbleArea(QWidget *parent = 0);

    bool openImage(const QString &fileName);
    bool saveImage(const QString &fileName, const char *fileFormat);
    void setPenColor(const QColor &newColor);
    void setPenWidth(int newWidth);

    bool isModified() const { return modified; }
    QColor penColor() const { return myPenColor; }
    int penWidth() const { return myPenWidth; }
    QImage ii;

public slots:
    void clearImage();
    void print();

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

private:
    void drawLineTo(const QPoint &endPoint);
    void resizeImage(QImage *image, const QSize &newSize);

    bool modified;
    bool scribbling;
    int myPenWidth;
    QColor myPenColor;
    QImage image;
    QPoint lastPoint;
};

#endif