BitmapExport.cpp

/*
 * This file is part of layoutie.
 *
 * layoutie 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 3 of the License, or
 * (at your option) any later version.
 *
 * layoutie 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 layoutie. If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include "BitmapExport.h"
#include "ui_BitmapExport.h"
#include "BoardScene.h"

#include "Settings.h"
#include <QMessageBox>
#include <QFileDialog>
#include <QGLWidget>

static const float cCentimetersPerInch = 2.54; // cm per inch

BitmapExport::BitmapExport(QWidget* inParent, const SLFormat::Board* inBoard)
 : QDialog(inParent), ui(new Ui::BitmapExport), mBoard(inBoard)
{
 ui->setupUi(this);

 if (QGLFormat::hasOpenGL())
 {
 ui->graphicsView->setViewport(new QGLWidget(QGLFormat(QGL::SampleBuffers | QGL::Rgba | QGL::AlphaChannel)));
 ui->graphicsView->setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
 ui->graphicsView->setRenderHint(QPainter::HighQualityAntialiasing);

 ui->graphicsView->setFrameStyle(QFrame::NoFrame); // semitransparent frame causes artifacts when using OpenGL
 }

 ui->graphicsView->setRenderHint(QPainter::Antialiasing);

 mScene = new BoardScene(const_cast<SLFormat::Board*>(mBoard), ui->graphicsView);
 ui->graphicsView->setScene(mScene);

 mLayerCheckBoxes[0] = ui->layer0CheckBox;
 mLayerCheckBoxes[1] = ui->layer1CheckBox;
 mLayerCheckBoxes[2] = ui->layer2CheckBox;
 mLayerCheckBoxes[3] = ui->layer3CheckBox;
 mLayerCheckBoxes[4] = ui->layer4CheckBox;
 mLayerCheckBoxes[5] = ui->layer5CheckBox;
 mLayerCheckBoxes[6] = ui->layer6CheckBox;

 for (unsigned layer = 0; layer < SLFormat::Board::cNumberLayers; layer++)
 {
 mLayerCheckBoxes[layer]->setText(gSettings().layerName(layer));
 mLayerCheckBoxes[layer]->setChecked(mBoard->isLayerVisible(layer));
 mLayerCheckBoxes[layer]->setEnabled(mBoard->isLayerEnabled(layer));
 connect(mLayerCheckBoxes[layer], SIGNAL(toggled(bool)), SLOT(updateView()));
 }

 connect(ui->showGridCheckBox, SIGNAL(toggled(bool)), SLOT(updateView()));
 connect(ui->drillHolesCheckBox, SIGNAL(toggled(bool)), SLOT(updateView()));

 updateView();

 connect(ui->resolutionSlider, SIGNAL(valueChanged(int)), SLOT(resolutionSliderChanged(int)));
 connect(ui->resolutionEdit, SIGNAL(textChanged(QString)), SLOT(resolutionEditChanged(QString)));
 connect(ui->resolutionUnitsComboBox, SIGNAL(currentIndexChanged(int)), SLOT(resolutionUnitsChanged()));
 resolutionUnitsChanged();
 resolutionSliderChanged(ui->resolutionSlider->value());

 connect(ui->buttonBox, SIGNAL(accepted()), SLOT(accepted()));
 connect(ui->buttonBox, SIGNAL(rejected()), SLOT(rejected()));

 gSettings().restoreSettings(this);
}

BitmapExport::~BitmapExport()
{
 gSettings().saveSettings(this);
 delete ui;
}

void BitmapExport::resizeEvent(QResizeEvent* inEvent)
{
 QDialog::resizeEvent(inEvent);
 int borderWidth = ui->graphicsView->lineWidth() + 5;
 float scaleFactor = (ui->graphicsView->rect().width() - 2 * borderWidth) / mScene->sceneRect().width();
 float scaleFactor2 = (ui->graphicsView->rect().height() - 2 * borderWidth) / mScene->sceneRect().height();
 if (scaleFactor > scaleFactor2)
 scaleFactor = scaleFactor2;
 ui->graphicsView->resetTransform();
 ui->graphicsView->scale(scaleFactor, scaleFactor);
}

void BitmapExport::updateView()
{
 mScene->showGrid(ui->showGridCheckBox->isChecked());
 mScene->showDrillHoles(ui->drillHolesCheckBox->isChecked());

 for (unsigned layer = 0; layer < SLFormat::Board::cNumberLayers; layer++)
 {
 mScene->showLayer(layer, mLayerCheckBoxes[layer]->isChecked());
 }

 ui->graphicsView->update();
}

void BitmapExport::resolutionUnitsChanged()
{
 const int maxDPI = 1200;
 const int minDPI = 300;
 const int singleStep = 10;
 const int pageStep = 100;

 const bool inches = ui->resolutionUnitsComboBox->currentIndex() == 0;
 if (inches)
 {
 int res = ui->resolutionSlider->value() * cCentimetersPerInch; // translate to inches from cm
 ui->resolutionSlider->setMinimum(minDPI);
 ui->resolutionSlider->setMaximum(maxDPI);
 ui->resolutionSlider->setSingleStep(singleStep);
 ui->resolutionSlider->setPageStep(pageStep);
 ui->resolutionSlider->setValue(res);
 }
 else
 {
 int res = ui->resolutionSlider->value() / cCentimetersPerInch; // translate to centimeters from inches
 ui->resolutionSlider->setMinimum(minDPI / cCentimetersPerInch);
 ui->resolutionSlider->setMaximum(maxDPI / cCentimetersPerInch);
 ui->resolutionSlider->setSingleStep(singleStep / cCentimetersPerInch);
 ui->resolutionSlider->setPageStep(pageStep / cCentimetersPerInch);
 ui->resolutionSlider->setValue(res);
 }
}

void BitmapExport::resolutionEditChanged(const QString& inValue)
{
 bool ok;
 int value = inValue.toInt(&ok);
 if (ok)
 {
 ui->resolutionSlider->setValue(value);
 }
}

void BitmapExport::resolutionSliderChanged(int inValue)
{
 ui->resolutionEdit->setText(QString::number(inValue));
}

void BitmapExport::accepted()
{
 bool ok;
 double pixelsPerCm = ui->resolutionEdit->text().toInt(&ok);
 if (!ok)
 {
 QMessageBox::critical(this, tr("Error"), tr("Wrong image resolution.\nPlease set the correct value."));
 ui->resolutionEdit->setFocus();
 return;
 }
 const bool inches = ui->resolutionUnitsComboBox->currentIndex() == 0;
 if (inches)
 pixelsPerCm /= cCentimetersPerInch;

 QString fileName = QFileDialog::getSaveFileName(this, tr("Export bitmap"), QDir::currentPath(), tr("BMP image (*.bmp);;JPG image (*.jpg), PNG image (*.png)"));
 if (fileName.isEmpty())
 {
 return;
 }

 qApp->setOverrideCursor(QCursor(Qt::WaitCursor));

 QFile file(fileName);
 if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate))
 {
 qApp->restoreOverrideCursor();
 QMessageBox::critical(this, tr("Error"), tr("Failed to save image.\n%1.") . arg(file.errorString()));
 return;
 }

 int w = mBoard->size().x / 1000 * pixelsPerCm;
 int h = mBoard->size().y / 1000 * pixelsPerCm;
 QImage image(w, h, QImage::Format_ARGB32);
 QPainter p(&image);
 if (ui->antialiasingCheckBox->isChecked())
 p.setRenderHint(QPainter::Antialiasing);
 mScene->render(&p);
 if (!image.save(&file))
 {
 qApp->restoreOverrideCursor();
 QMessageBox::critical(this, tr("Error"), tr("Failed to save image.\n%1.") . arg(file.errorString()) );
 return;
 }

 setResult(QDialog::DialogCode::Accepted);
 close();
 qApp->restoreOverrideCursor();
}

void BitmapExport::rejected()
{
 setResult(QDialog::DialogCode::Rejected);
 close();
}

void BitmapExport::getResolution(int& outUnits, int& outRes)
{
 outUnits = ui->resolutionUnitsComboBox->currentIndex();

 bool ok;
 outRes = ui->resolutionEdit->text().toInt(&ok);
 if (!ok)
 {
 outRes = ui->resolutionSlider->value();
 }
}

void BitmapExport::setResolution(int inUnits, int inRes)
{
 if (inUnits < 0 || inUnits >= ui->resolutionUnitsComboBox->count())
 inUnits = 0;
 ui->resolutionUnitsComboBox->setCurrentIndex(inUnits);

 if (inRes < ui->resolutionSlider->minimum() || inRes > ui->resolutionSlider->maximum())
 inRes = ui->resolutionSlider->minimum();
 ui->resolutionSlider->setValue(inRes);
}