screenie.cpp

/* This file is part of the Screenie project.
   Screenie is a simple fancy screenshot composer.

   Copyright (C) 2008 Ariya Hidayat <ariya.hidayat@gmail.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License along
   with this program; if not, write to the Free Software Foundation,
   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include <QtGui>

#include "ui_parameters.h"
#include "ui_help.h"

// Create a reflected version of the image, along with gradient translucency
static QPixmap reflected(const QPixmap& img, int offsetPercent)
{
    QLinearGradient gradient(QPoint(0, 0), QPoint(0, img.height()));
    gradient.setColorAt(qMin(1.0, offsetPercent/100.0), Qt::black);
    gradient.setColorAt(0, Qt::white);

    QImage mask = img.toImage();
    QPainter painter(&mask);
    painter.setCompositionMode(QPainter::CompositionMode_Source);
    painter.fillRect(mask.rect(), gradient);
    painter.end();

    QImage reflection = img.toImage().mirrored();
    reflection.setAlphaChannel(mask);

    return QPixmap::fromImage(reflection);
}

// Add a reflection to the image and return a new image
static QPixmap reflectionAdded(const QPixmap& img, int opacityPercent, int offsetPercent)
{
    QPixmap result(img.width(), img.height()*2);
    result.fill(Qt::transparent);

    QPainter painter(&result);
    painter.drawPixmap(0, 0, img);
    painter.setOpacity(qMin(1.0, opacityPercent/100.0));
    painter.drawPixmap(0, img.height(), reflected(img, offsetPercent));
    painter.end();

    return result;
}

// Create a stub image with big '?' in the middle
static QPixmap defaultImage()
{
    QPixmap m_defaultImage = QPixmap(400, 300);

    QLinearGradient gradient(QPoint(0, 0), QPoint(0, m_defaultImage.height()));
    gradient.setColorAt(0, QColor(192, 192, 192));
    gradient.setColorAt(1, QColor(128, 128, 128));
    QPainter p(&m_defaultImage);
    p.fillRect(m_defaultImage.rect(), gradient);
    p.setPen(QPen(QColor(96, 96, 96), 3, Qt::SolidLine));
    p.drawRect(m_defaultImage.rect());
    QFont font;
    font.setPixelSize(100);
    p.setFont(font);
    p.setPen(Qt::white);
    p.drawText(m_defaultImage.rect(), Qt::AlignCenter, "?");
    p.end();

    return m_defaultImage;
}

class Screenie: public QWidget
{
public:
    Screenie();
    ~Screenie();
    void loadImage(int index, const QPixmap& image);
    void dragEnterEvent(QDragEnterEvent*);
    void dropEvent(QDropEvent* event);
    void paintEvent(QPaintEvent*);
    void resizeEvent(QResizeEvent*);
    void mouseReleaseEvent(QMouseEvent*);

    void setupUI();
    void recreateReflection();
    void render(QPainter*);

private:
    QPixmap m_centerImage;
    QPixmap m_leftImage;
    QPixmap m_rightImage;

    void paintLeftImage(QPainter*, const int, const int);
    void paintCenterImage(QPainter*, const int, const int);
    void paintRightImage(QPainter*, const int, const int);

    Ui::ParametersForm* parameters;

    bool m_useReflection;
    int m_reflectionOpacity;
    int m_reflectionOffset;
    bool m_useBackground;
    QColor m_backgroundColor;
    QBrush m_checkerBoard;
};

Screenie::Screenie(): m_useReflection(true), m_reflectionOpacity(100), m_reflectionOffset(40),
m_useBackground(true)
{
    m_centerImage = reflectionAdded(defaultImage(), m_reflectionOpacity, m_reflectionOffset);
    m_leftImage = m_rightImage = m_centerImage;

    setAcceptDrops(true);

    setAttribute(Qt::WA_StaticContents, true);

    setupUI();
    resize(900, 500);
    update();
}

Screenie::~Screenie()
{
    delete parameters;
}

void Screenie::setupUI()
{
    parameters = new Ui::ParametersForm;
    QWidget* toolWidget = new QWidget(this);
    toolWidget->setWindowFlags(Qt::Tool | Qt::WindowTitleHint);
    parameters->setupUi(toolWidget);
    toolWidget->show();
    toolWidget->adjustSize();

    QWidget* helpWidget = new QWidget(this);
    helpWidget->setWindowFlags(Qt::Tool | Qt::WindowTitleHint | Qt::WindowSystemMenuHint);
    Ui::HelpForm helpForm;
    helpForm.setupUi(helpWidget);
    helpWidget->show();
    helpWidget->adjustSize();

    connect(parameters->leftImageBox, SIGNAL(toggled(bool)), SLOT(update()));
    connect(parameters->centerImageBox, SIGNAL(toggled(bool)), SLOT(update()));
    connect(parameters->rightImageBox, SIGNAL(toggled(bool)), SLOT(update()));
    connect(parameters->reflectionBox, SIGNAL(toggled(bool)), SLOT(update()));
    connect(parameters->backgroundBox, SIGNAL(toggled(bool)), SLOT(update()));

    connect(parameters->leftOffsetSlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->leftDistanceSlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->leftAngleSlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->centerOffsetSlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->centerDistanceSlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->centerAngleSlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->rightOffsetSlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->rightDistanceSlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->rightAngleSlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->reflectionOpacitySlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->reflectionOffsetSlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->backgroundRedSlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->backgroundGreenSlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->backgroundBlueSlider, SIGNAL(sliderMoved(int)), SLOT(update()));
    connect(parameters->redSpinBox, SIGNAL(valueChanged(int)), SLOT(update()));
    connect(parameters->greenSpinBox, SIGNAL(valueChanged(int)), SLOT(update()));
    connect(parameters->blueSpinBox, SIGNAL(valueChanged(int)), SLOT(update()));
}

QPixmap upperHalf(const QPixmap& img)
{
    return img.copy(0, 0, img.width(), img.height()/2);
}

void Screenie::recreateReflection()
{
    if (m_useReflection) {
        m_leftImage = reflectionAdded(upperHalf(m_leftImage), m_reflectionOpacity, m_reflectionOffset);
        m_centerImage = reflectionAdded(upperHalf(m_centerImage), m_reflectionOpacity, m_reflectionOffset);
        m_rightImage = reflectionAdded(upperHalf(m_rightImage), m_reflectionOpacity, m_reflectionOffset);
    } else {
        m_leftImage = reflectionAdded(upperHalf(m_leftImage), 1, 0);
        m_centerImage = reflectionAdded(upperHalf(m_centerImage), 1, 0);
        m_rightImage = reflectionAdded(upperHalf(m_rightImage), 1, 0);
    }
}

void Screenie::loadImage(int index, const QPixmap& image)
{
    QPixmap img = image;
    if (img.isNull()) {
        qDebug() << "Can not load null image!";
        return;
    }

    if ((img.width() > 640) || (img.height() > 480)) {
        qDebug() << "Image is too large. Rescaling....";
        img = img.scaled(640, 480, Qt::KeepAspectRatio, Qt::SmoothTransformation);
    }

    img = reflectionAdded(img, m_reflectionOpacity, m_reflectionOffset);
    setWindowTitle("Screenshot Composer");

    switch(index) {
        case 0:
             m_leftImage = img;
             break;
        case 1:
             m_centerImage = img;
             break;
        case 2:
             m_rightImage = img;
             break;
        default:
             m_centerImage = img;
             break;
    }

    update();
}

void Screenie::dragEnterEvent(QDragEnterEvent* event)
{
    if (event->mimeData()->hasFormat("text/uri-list"))
        event->acceptProposedAction();
}

void Screenie::dropEvent(QDropEvent* event)
{
    int index = 1;
    int cx = width()/2;
    int cw = m_centerImage.width();
    if (event->pos().x() < cx - cw/2)
        index = 0;
    if (event->pos().x() > cx + cw/2)
        index = 2;

    QList<QUrl> urls = event->mimeData()->urls();
    if (urls.count()) {
        QPixmap img;
        QString fname = urls[0].toLocalFile();

        if (event->mimeData()->hasImage())
            img = qvariant_cast<QPixmap>(event->mimeData()->imageData());
        else
            img = QPixmap(fname);

        if (img.isNull())
            setWindowTitle(QString("Can not load %1").arg(fname));
        else
            loadImage(index, img);

        event->acceptProposedAction();
    }
}

void Screenie::paintEvent(QPaintEvent*)
{
    QBrush bgbrush;

    m_useBackground = parameters->backgroundBox->isChecked();
    if (m_useBackground) {
        int red = parameters->backgroundRedSlider->value();
        int green = parameters->backgroundGreenSlider->value();
        int blue = parameters->backgroundBlueSlider->value();
        m_backgroundColor = QColor(red, green, blue);
        bgbrush = QBrush(m_backgroundColor);
    } else {
        if (m_checkerBoard.style() == Qt::NoBrush) {
            QImage checker(16, 16, QImage::Format_ARGB32_Premultiplied);
            QPainter painter(&checker);
            painter.fillRect(checker.rect(), QColor(153, 153, 153));
            painter.fillRect(0, 0, 8, 8, QColor(102, 102, 102));
            painter.fillRect(8, 8, 8, 8, QColor(102, 102, 102));
            painter.end();
            m_checkerBoard.setTextureImage(checker);
        }
        bgbrush = m_checkerBoard;
    }

    QPalette pal = palette();
    pal.setBrush(backgroundRole(), bgbrush);
    setPalette(pal);

    if ((m_reflectionOpacity != parameters->reflectionOpacitySlider->value()) ||
        (m_reflectionOffset != parameters->reflectionOffsetSlider->value()) ||
        (m_useReflection != parameters->reflectionBox->isChecked())) {
        m_reflectionOpacity = parameters->reflectionOpacitySlider->value();
        m_reflectionOffset = parameters->reflectionOffsetSlider->value();
        m_useReflection = parameters->reflectionBox->isChecked();
        recreateReflection();
    }

    QPainter painter(this);
    render(&painter);

    parameters->leftOffsetSlider->setMaximum(width()/2);
    parameters->rightOffsetSlider->setMaximum(width()/2);
}

void Screenie::render(QPainter* painter)
{
    painter->setRenderHint(QPainter::Antialiasing, true);
    painter->setRenderHint(QPainter::SmoothPixmapTransform, true);
    int cx = width()/2;
    int cy = height()*2/3;

    int leftDistance = parameters->leftDistanceSlider->value();
    int centerDistance = parameters->centerDistanceSlider->value();
    int rightDistance = parameters->rightDistanceSlider->value();

    if (leftDistance > centerDistance && leftDistance > rightDistance) {
        paintLeftImage(painter, cx, cy);
        if (centerDistance > rightDistance) {
            paintCenterImage(painter, cx, cy);
            paintRightImage(painter, cx, cy);
        } else {
            paintRightImage(painter, cx, cy);
            paintCenterImage(painter, cx, cy);
        }
    } else if(centerDistance > leftDistance && centerDistance > rightDistance) {
        paintCenterImage(painter, cx, cy);
        if (leftDistance > rightDistance) {
            paintLeftImage(painter, cx, cy);
            paintRightImage(painter, cx, cy);
        } else {
            paintRightImage(painter, cx, cy);
            paintLeftImage(painter, cx, cy);
        }
    } else {
        paintRightImage(painter, cx, cy);
        if (leftDistance > centerDistance) {
            paintLeftImage(painter, cx, cy);
            paintCenterImage(painter, cx, cy);
        } else {
            paintCenterImage(painter, cx, cy);
            paintLeftImage(painter, cx, cy);
        }
    }
}

void Screenie::paintLeftImage(QPainter *painter, const int cx, const int cy)
{
    if (parameters->leftImageBox->isChecked()) {
        QTransform transform;
        painter->save();
        qreal leftScale = 1 - (qreal)parameters->leftDistanceSlider->value()/200.0;
        transform = QTransform().scale(leftScale, leftScale);
        transform.translate(0, -m_leftImage.height()/4);
        transform.rotate(parameters->leftAngleSlider->value(), Qt::YAxis);
        transform.translate(0, m_leftImage.height()/4);
        int dx = parameters->leftOffsetSlider->value();
        int dy = parameters->leftDistanceSlider->value();
        painter->setTransform(transform * QTransform().translate(cx-dx,cy-dy), true);
        painter->drawPixmap(-m_leftImage.width()/2, -m_leftImage.height()/2, m_leftImage);
        painter->restore();
    }
}

void Screenie::paintCenterImage(QPainter *painter, const int cx, const int cy)
{
    if (parameters->centerImageBox->isChecked()) {
        QTransform transform;
        painter->save();
        qreal centerScale = 1 - (qreal)parameters->centerDistanceSlider->value()/200.0;
        transform = QTransform().scale(centerScale, centerScale);
        transform.translate(0, -m_centerImage.height()/4);
        transform.rotate(parameters->centerAngleSlider->value(), Qt::YAxis);
        transform.translate(0, m_centerImage.height()/4);
        int dx = parameters->centerOffsetSlider->value();
        int dy = parameters->centerDistanceSlider->value();
        painter->setTransform(transform * QTransform().translate(cx+dx,cy-dy), true);
        painter->drawPixmap(-m_centerImage.width()/2, -m_centerImage.height()/2, m_centerImage);
        painter->restore();
    }
}

void Screenie::paintRightImage(QPainter *painter, const int cx, const int cy)
{
    if (parameters->rightImageBox->isChecked()) {
        QTransform transform;
        painter->save();
        qreal rightScale = 1 - (qreal)parameters->rightDistanceSlider->value()/200.0;
        transform = QTransform().scale(rightScale, rightScale);
        transform.translate(0, -m_rightImage.height()/4);
        transform.rotate(parameters->rightAngleSlider->value(), Qt::YAxis);
        transform.translate(0, m_rightImage.height()/4);
        int dx = parameters->rightOffsetSlider->value();
        int dy = parameters->rightDistanceSlider->value();
        painter->setTransform(transform * QTransform().translate(cx+dx,cy-dy), true);
        painter->drawPixmap(-m_rightImage.width()/2, -m_rightImage.height()/2, m_rightImage);
        painter->restore();
    }
}

void Screenie::resizeEvent(QResizeEvent*)
{
    QTimer::singleShot(500, this, SLOT(update()));
}

void Screenie::mouseReleaseEvent(QMouseEvent* event)
{
    if (event->button() != Qt::RightButton)
        return;

    QString filter = "Portable Network Graphics (*.png)";
    QString fileName = QFileDialog::getSaveFileName(this, tr("Save"), QString(), filter);
    if (fileName.isNull())
        return;

    QImage image(width(), height(), QImage::Format_ARGB32_Premultiplied);
    image.fill(0);
    QPainter painter(&image);
    if (m_useBackground)
        painter.fillRect(image.rect(), m_backgroundColor);
    render(&painter);
    painter.end();
    image.save(fileName, "png");
}

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

    /* Load translation try from /usr/share/screenie, then ./l10n/screenie then ./ */
    QString locale = QLocale::system().name();
    QTranslator translator;
    if (translator.load(QString("screenie_") + locale, "/usr/share/screenie/") == false) {
      if (translator.load(QString("l10n/screenie_") + locale) == false) {
        translator.load(QString("screenie_") + locale);
      }
    }
    app.installTranslator(&translator);

    /* Load the system translator to get the Save dialog translated */
    QTranslator qtTranslator;
    qtTranslator.load(QString("qt_") + locale, QLibraryInfo::location(QLibraryInfo::TranslationsPath));
    app.installTranslator(&qtTranslator);

    Screenie widget;
    widget.setWindowIcon(QIcon(":/screenie.png"));
    widget.show();

    switch(argc) {
        case 2:
            widget.loadImage(1, QPixmap(argv[1]));
            break;
        case 3:
            widget.loadImage(0, QPixmap(argv[1]));
            widget.loadImage(1, QPixmap(argv[2]));
            break;
        case 4:
            widget.loadImage(0, QPixmap(argv[1]));
            widget.loadImage(1, QPixmap(argv[2]));
            widget.loadImage(2, QPixmap(argv[3]));
            break;
    }

    return app.exec();
}