Added dxf export

--HG--
branch : feature
This commit is contained in:
val177 2015-09-07 22:47:02 +03:00
parent c9eb629e8c
commit 80b0f38f0d
9 changed files with 833 additions and 3 deletions

View File

@ -50,6 +50,7 @@ const std::vector<VFrmWithTest> DialogSaveLayout::availFormats = {
VFrmWithTest(tr("Wavefront OBJ (*.obj)"), ".obj"),
VFrmWithTest(tr("PS files (*.ps)"), ".ps", 1), //fixme: use 1 to have exe once tested on 1st run, or any other value to test always as original do
VFrmWithTest(tr("EPS files (*.eps)"), ".eps", 1),
VFrmWithTest(tr("DXF files (*.dxf)"), ".dxf"),
};

View File

@ -30,6 +30,7 @@
#include "core/vapplication.h"
#include "../vpatterndb/vcontainer.h"
#include "../vobj/vobjpaintdevice.h"
#include "../vdxf/vdxfpaintdevice.h"
#include "dialogs/dialoglayoutsettings.h"
#include "../vlayout/vlayoutgenerator.h"
@ -209,7 +210,7 @@ void MainWindowsNoGUI::ExportLayout(const DialogSaveLayout &dialog)
scenes[i]->setBackgroundBrush( *brush );
shadows[i]->setVisible(false);
paper->setPen(QPen(QBrush(Qt::white, Qt::NoBrush), 0.1, Qt::NoPen));
const QStringList suffix = QStringList() << "svg" << "png" << "pdf" << "eps" << "ps" << "obj";
const QStringList suffix = QStringList() << "svg" << "png" << "pdf" << "eps" << "ps" << "obj" << "dxf";
switch (suffix.indexOf(suf))
{
case 0: //svg
@ -234,6 +235,9 @@ void MainWindowsNoGUI::ExportLayout(const DialogSaveLayout &dialog)
ObjFile(name, i);
paper->setVisible(true);
break;
case 6: //dxf
DxfFile(name, i);
break;
default:
qDebug() << "Can't recognize file suffix." << Q_FUNC_INFO;
break;
@ -675,6 +679,23 @@ void MainWindowsNoGUI::ObjFile(const QString &name, int i) const
}
}
//---------------------------------------------------------------------------------------------------------------------
void MainWindowsNoGUI::DxfFile(const QString &name, int i) const
{
QGraphicsRectItem *paper = qgraphicsitem_cast<QGraphicsRectItem *>(papers.at(i));
if (paper)
{
VDxfPaintDevice generator;
generator.setFileName(name);
generator.setSize(paper->rect().size().toSize());
generator.setResolution(static_cast<int>(PrintDPI));
QPainter painter;
painter.begin(&generator);
scenes.at(i)->render(&painter, paper->rect(), paper->rect(), Qt::IgnoreAspectRatio);
painter.end();
}
}
//---------------------------------------------------------------------------------------------------------------------
QVector<QImage> MainWindowsNoGUI::AllSheets()
{

View File

@ -112,6 +112,7 @@ private:
void PsFile(const QString &name, int i)const;
void PdfToPs(const QStringList &params)const;
void ObjFile(const QString &name, int i)const;
void DxfFile(const QString &name, int i)const;
QVector<QImage> AllSheets();

37
src/libs/vdxf/dxfdef.h Normal file
View File

@ -0,0 +1,37 @@
/************************************************************************
**
** @file def.h
** @author Roman Telezhynskyi <dismine(at)gmail.com>
** @date 31 8, 2015
**
** @brief
** @copyright
** This source code is part of the Valentine project, a pattern making
** program, whose allow create and modeling patterns of clothing.
** Copyright (C) 2015 Valentina project
** <https://bitbucket.org/dismine/valentina> All Rights Reserved.
**
** Valentina 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.
**
** Valentina 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 Valentina. If not, see <http://www.gnu.org/licenses/>.
**
*************************************************************************/
#ifndef DXFDEF_H
#define DXFDEF_H
enum class VarMeasurement : unsigned char { English=0, Metric=1 };
//Default drawing units for AutoCAD DesignCenter blocks:
enum class VarInsunits : unsigned char { Inches=1, Millimeters=4, Centimeters=5 };
#endif // DXFDEF_H

View File

@ -4,7 +4,9 @@
SOURCES += \
$$PWD/stable.cpp \
$$PWD/dxflib/dl_dxf.cpp \
$$PWD/dxflib/dl_writer_ascii.cpp
$$PWD/dxflib/dl_writer_ascii.cpp \
$$PWD/vdxfengine.cpp \
$$PWD/vdxfpaintdevice.cpp
HEADERS += \
$$PWD/stable.h \
@ -18,4 +20,7 @@ HEADERS += \
$$PWD/dxflib/dl_extrusion.h \
$$PWD/dxflib/dl_global.h \
$$PWD/dxflib/dl_writer.h \
$$PWD/dxflib/dl_writer_ascii.h
$$PWD/dxflib/dl_writer_ascii.h \
$$PWD/vdxfengine.h \
$$PWD/vdxfpaintdevice.h \
$$PWD/dxfdef.h

View File

@ -0,0 +1,467 @@
/************************************************************************
**
** @file vdxfengine.cpp
** @author Valentina Zhuravska <zhuravska19(at)gmail.com>
** @date 12 8, 2015
**
** @brief
** @copyright
** This source code is part of the Valentine project, a pattern making
** program, whose allow create and modeling patterns of clothing.
** Copyright (C) 2013-2015 Valentina project
** <https://bitbucket.org/dismine/valentina> All Rights Reserved.
**
** Valentina 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.
**
** Valentina 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 Valentina. If not, see <http://www.gnu.org/licenses/>.
**
*************************************************************************/
#include "vdxfengine.h"
#include <QDebug>
#include <QDateTime>
#include <QtMath>
//---------------------------------------------------------------------------------------------------------------------
static inline QPaintEngine::PaintEngineFeatures svgEngineFeatures()
{
#ifdef Q_CC_CLANG
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wsign-conversion"
#endif
return QPaintEngine::PaintEngineFeatures(
QPaintEngine::AllFeatures
& ~QPaintEngine::PatternBrush
& ~QPaintEngine::PerspectiveTransform
& ~QPaintEngine::ConicalGradientFill
& ~QPaintEngine::PorterDuff);
#ifdef Q_CC_CLANG
#pragma clang diagnostic pop
#endif
}
//---------------------------------------------------------------------------------------------------------------------
VDxfEngine::VDxfEngine()
:QPaintEngine(svgEngineFeatures()),
size(), resolution(PrintDPI), matrix(), varMeasurement(VarMeasurement::Metric),
varInsunits(VarInsunits::Centimeters)
{
}
//---------------------------------------------------------------------------------------------------------------------
VDxfEngine::~VDxfEngine()
{
}
//---------------------------------------------------------------------------------------------------------------------
bool VDxfEngine::begin(QPaintDevice *pdev)
{
Q_UNUSED(pdev)
if (size.isValid() == false)
{
qWarning()<<"VDxfEngine::begin(), size is not valid";
return false;
}
dxf = new DL_Dxf();
DL_Codes::version exportVersion = DL_Codes::AC1015;
QByteArray fileNameArray = getFileName().toLocal8Bit();
dw = dxf->out(fileNameArray.data(), exportVersion);
if (dw==NULL)
{
qWarning("VDxfEngine::begin(), can't open file");
return false;
}
dxf->writeHeader(*dw);
dxf->writeComment(*dw, "Valentina DXF File");
dw->dxfString(9, "$ANGDIR"); // 1 = Clockwise angles, 0 = Counterclockwise
dw->dxfInt(70, 0); // Qt use counterclockwise
dw->dxfString(9, "$MEASUREMENT"); // Sets drawing units: 0 = English; 1 = Metric
dw->dxfInt(70, static_cast<int>(varMeasurement));
dw->dxfString(9, "$INSUNITS");
dw->dxfInt(70, static_cast<int>(varInsunits));
QString dateTime = QDateTime::currentDateTime().toString("yyyyMMdd.HHmmsszzz");
dateTime.chop(1);// we need hundredths of a second
dw->dxfString(9, "$TDCREATE");
dw->dxfString(40, dateTime.toUtf8().constData());
dw->sectionEnd();
dw->sectionTables();
dxf->writeVPort(*dw);
dw->tableEnd();
int numberOfLayers = 1;
dw->tableLayers(numberOfLayers);
dxf->writeLayer(*dw,
DL_LayerData("0", 0),
DL_Attributes(
std::string(""), // leave empty
DL_Codes::black, // default color
100, // default width
"CONTINUOUS", // default line style
1.0)); // default line type scale
dw->tableEnd();
dw->sectionEnd();
dw->sectionEntities();
return true;
}
//---------------------------------------------------------------------------------------------------------------------
bool VDxfEngine::end()
{
dw->sectionEnd();
dw->dxfEOF();
dw->close();
delete dw;
delete dxf;
return true;
}
//---------------------------------------------------------------------------------------------------------------------
// cppcheck-suppress unusedFunction
void VDxfEngine::updateState(const QPaintEngineState &state)
{
QPaintEngine::DirtyFlags flags = state.state();
// always stream full gstate, which is not required, but...
flags |= QPaintEngine::AllDirty;
if (flags & QPaintEngine::DirtyTransform)
{
matrix = state.matrix(); // Save new matrix for moving paths
}
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::drawPath(const QPainterPath &path)
{
QPolygonF polygon = path.toFillPolygon(matrix);
if (polygon.size() < 3)
{
return;
}
for (int i=1; i < polygon.count(); i++)
{
dxf->writeLine(
*dw,
DL_LineData(polygon.at(i-1).x(), // start point
getSize().height() - polygon.at(i-1).y(),
0.0,
polygon.at(i).x(), // end point
getSize().height() - polygon.at(i).y(),
0.0),
DL_Attributes("0", getPenColor(), state->pen().width(), getPenStyle(), 1.0));
}
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::drawLines(const QLineF * lines, int lineCount)
{
for (int i = 0; i < lineCount; i++)
{
QPointF p1 = matrix.map(lines[i].p1());
QPointF p2 = matrix.map(lines[i].p2());
dxf->writeLine(
*dw,
DL_LineData(p1.x(), // start point
getSize().height() - p1.y(),
0.0,
p2.x(), // end point
getSize().height() - p2.y(),
0.0),
DL_Attributes("0", getPenColor(), state->pen().width(), getPenStyle(), 1.0));
}
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::drawLines(const QLine * lines, int lineCount)
{
QPaintEngine::drawLines(lines, lineCount);
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode)
{
Q_UNUSED(mode)
for (int i = 1; i < pointCount; i++)
{
QPointF p1 = matrix.map(points[i-1]);
QPointF p2 = matrix.map(points[i]);
dxf->writeLine(
*dw,
DL_LineData(p1.x(), // start point
getSize().height() - p1.y(),
0.0,
p2.x(), // end point
getSize().height() - p2.y(),
0.0),
DL_Attributes("0", getPenColor(), state->pen().width(), getPenStyle(), 1.0));
}
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::drawPolygon(const QPoint *points, int pointCount, QPaintEngine::PolygonDrawMode mode)
{
QPaintEngine::drawPolygon(points, pointCount, mode);
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::drawEllipse(const QRectF & rect)
{
QRectF newRect = matrix.mapRect(rect);
double rotationAngle = atan(matrix.m12()/matrix.m11());
double majorX, majorY; // distanse between center and endpoint of the major axis
double ratio; // ratio of minor axis to major axis
if(rect.width()<= rect.height())
{
majorX = (rect.top() - rect.center().y())*sin(rotationAngle)*matrix.m11()/cos(rotationAngle);
// major axis * sin(rotation angle) * x-scale-factor
majorY = (rect.top() - rect.center().y())*matrix.m22();
// major axis * cos(rotation angle) * y-scale-factor, where y-scale-factor = matrix.m22()/cos(rotationAngle)
ratio = rect.width()/rect.height();
}
else
{
majorX = (rect.right() - rect.center().x())*matrix.m11();
// major axis * cos(rotation angle) * x-scale-factor, where y-scale-factor = matrix.m22()/cos(rotationAngle)
majorY = (rect.right() - rect.center().x())*sin(rotationAngle)*matrix.m22()/cos(rotationAngle);
// major axis * sin(rotation angle) * y-scale-factor
ratio = rect.height()/rect.width();
}
dxf->writeEllipse(
*dw,
DL_EllipseData(newRect.center().x(), // center X
getSize().height() - newRect.center().y(), // center Y
0, // center Z
majorX,
majorY,
0,
ratio,
0,6.28 // startangle and endangle of ellipse in rad
),
DL_Attributes("0", getPenColor(), state->pen().width(), getPenStyle(), 1.0));
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::drawEllipse(const QRect & rect)
{
QPaintEngine::drawEllipse(rect);
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::drawTextItem(const QPointF & p, const QTextItem & textItem)
{
QPointF startPoint = matrix.map(p);
double rotationAngle = atan(matrix.m12()/matrix.m11());
int textSize = textItem.font().pixelSize() == -1 ? textItem.font().pointSize() : textItem.font().pixelSize();
dxf->writeText(
*dw,
DL_TextData(startPoint.x(),
getSize().height() - startPoint.y(),
0,
startPoint.x(),
getSize().height() - startPoint.y(),
0,
textSize * matrix.m11(),
1, // relative X scale factor
0, // flag (0 = default, 2 = Backwards, 4 = Upside down)
0, // Horizontal justification (0 = Left (default), 1 = Center, 2 = Right,)
0, // Vertical justification (0 = Baseline (default), 1 = Bottom, 2 = Middle, 3= Top)
textItem.text().toUtf8().constData(), // text data
textItem.font().family().toUtf8().constData(), // font
-rotationAngle
),
DL_Attributes("0", getPenColor(), state->pen().width(), getPenStyle(), 1.0));
}
//---------------------------------------------------------------------------------------------------------------------
QPaintEngine::Type VDxfEngine::type() const
{
return QPaintEngine::User;
}
//---------------------------------------------------------------------------------------------------------------------
// cppcheck-suppress unusedFunction
void VDxfEngine::drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr)
{
Q_UNUSED(r)
Q_UNUSED(pm)
Q_UNUSED(sr)
}
//---------------------------------------------------------------------------------------------------------------------
QSize VDxfEngine::getSize() const
{
return size;
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::setSize(const QSize &value)
{
Q_ASSERT(!isActive());
size = value;
}
//---------------------------------------------------------------------------------------------------------------------
int VDxfEngine::getResolution() const
{
return resolution;
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::setResolution(int value)
{
Q_ASSERT(!isActive());
resolution = value;
}
//---------------------------------------------------------------------------------------------------------------------
QString VDxfEngine::getFileName() const
{
return fileName;
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::setFileName(const QString &value)
{
Q_ASSERT(!isActive());
fileName = value;
}
//---------------------------------------------------------------------------------------------------------------------
std::string VDxfEngine::getPenStyle()
{
switch (state->pen().style())
{
case Qt::SolidLine:
return "BYLAYER";
break;
case Qt::DashLine:
return "DASHED";
break;
case Qt::DotLine:
return "DOT";
break;
case Qt::DashDotLine:
return "DASHDOT";
break;
case Qt::DashDotDotLine:
return "DIVIDE";
break;
default:
return "BYLAYER";
break;
}
}
//---------------------------------------------------------------------------------------------------------------------
int VDxfEngine::getPenColor()
{
QColor color = state->pen().color();
if(color == Qt::black)
{
return DL_Codes::black;
}
else if(color == Qt::white)
{
return DL_Codes::white;
}
else if(color == Qt::darkGray)
{
return DL_Codes::gray;
}
else if(color == Qt::gray)
{
return DL_Codes::l_gray;
}
else if(color == Qt::darkMagenta)
{
return DL_Codes::magenta;
}
else if(color == Qt::magenta)
{
return DL_Codes::l_magenta;
}
else if(color == Qt::cyan)
{
return DL_Codes::l_cyan;
}
else if(color == Qt::darkCyan)
{
return DL_Codes::cyan;
}
else if(color == Qt::blue)
{
return DL_Codes::l_blue;
}
else if(color == Qt::darkBlue)
{
return DL_Codes::blue;
}
else if(color == Qt::darkGreen)
{
return DL_Codes::green;
}
else if(color == Qt::green)
{
return DL_Codes::l_green;
}
else if(color == Qt::darkRed)
{
return DL_Codes::red;
}
else if(color == Qt::red)
{
return DL_Codes::l_red;
}
else if(color == Qt::yellow)
{
return DL_Codes::yellow;
}
else
{
return DL_Codes::bylayer;
}
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::setMeasurement(const VarMeasurement &var)
{
Q_ASSERT(!isActive());
varMeasurement = var;
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfEngine::setInsunits(const VarInsunits &var)
{
Q_ASSERT(!isActive());
varInsunits = var;
}

View File

@ -0,0 +1,87 @@
/************************************************************************
**
** @file vdxfengine.h
** @author Valentina Zhuravska <zhuravska19(at)gmail.com>
** @date 12 8, 2015
**
** @brief
** @copyright
** This source code is part of the Valentine project, a pattern making
** program, whose allow create and modeling patterns of clothing.
** Copyright (C) 2013-2015 Valentina project
** <https://bitbucket.org/dismine/valentina> All Rights Reserved.
**
** Valentina 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.
**
** Valentina 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 Valentina. If not, see <http://www.gnu.org/licenses/>.
**
*************************************************************************/
#ifndef VDXFENGINE_H
#define VDXFENGINE_H
#include <QPaintEngine>
#include "dxflib/dl_dxf.h"
#include "../vmisc/def.h"
#include "dxfdef.h"
class QTextStream;
class VDxfEngine : public QPaintEngine
{
public:
VDxfEngine();
virtual ~VDxfEngine() Q_DECL_OVERRIDE;
virtual bool begin(QPaintDevice *pdev) Q_DECL_OVERRIDE;
virtual bool end() Q_DECL_OVERRIDE;
virtual void updateState(const QPaintEngineState &state) Q_DECL_OVERRIDE;
virtual void drawPath(const QPainterPath &path) Q_DECL_OVERRIDE;
virtual void drawLines(const QLineF * lines, int lineCount) Q_DECL_OVERRIDE;
virtual void drawLines(const QLine * lines, int lineCount) Q_DECL_OVERRIDE;
virtual void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode) Q_DECL_OVERRIDE;
virtual void drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode) Q_DECL_OVERRIDE;
virtual void drawEllipse(const QRectF & rect) Q_DECL_OVERRIDE;
virtual void drawEllipse(const QRect & rect) Q_DECL_OVERRIDE;
virtual void drawTextItem(const QPointF & p, const QTextItem & textItem) Q_DECL_OVERRIDE;
virtual Type type() const Q_DECL_OVERRIDE;
virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr) Q_DECL_OVERRIDE;
QSize getSize() const;
void setSize(const QSize &value);
int getResolution() const;
void setResolution(int value);
QString getFileName() const;
void setFileName(const QString &value);
std::string getPenStyle();
int getPenColor();
void setMeasurement(const VarMeasurement &var);
void setInsunits(const VarInsunits &var);
private:
Q_DISABLE_COPY(VDxfEngine)
QSize size;
int resolution;
QString fileName;
QMatrix matrix;
DL_Dxf* dxf;
DL_WriterA* dw;
VarMeasurement varMeasurement;
VarInsunits varInsunits;
};
#endif // VDXFENGINE_H

View File

@ -0,0 +1,146 @@
/************************************************************************
**
** @file vdxfpaintdevice.cpp
** @author Valentina Zhuravska <zhuravska19(at)gmail.com>
** @date 12 812, 2015
**
** @brief
** @copyright
** This source code is part of the Valentine project, a pattern making
** program, whose allow create and modeling patterns of clothing.
** Copyright (C) 2013-2015 Valentina project
** <https://bitbucket.org/dismine/valentina> All Rights Reserved.
**
** Valentina 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.
**
** Valentina 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 Valentina. If not, see <http://www.gnu.org/licenses/>.
**
*************************************************************************/
#include "vdxfpaintdevice.h"
#include "vdxfengine.h"
#include <QFile>
//---------------------------------------------------------------------------------------------------------------------
VDxfPaintDevice::VDxfPaintDevice()
:QPaintDevice(), engine(new VDxfEngine()), fileName()
{
}
//---------------------------------------------------------------------------------------------------------------------
VDxfPaintDevice::~VDxfPaintDevice()
{
delete engine;
}
//---------------------------------------------------------------------------------------------------------------------
// cppcheck-suppress unusedFunction
QPaintEngine *VDxfPaintDevice::paintEngine() const
{
return engine;
}
//---------------------------------------------------------------------------------------------------------------------
// cppcheck-suppress unusedFunction
QString VDxfPaintDevice::getFileName() const
{
return fileName;
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfPaintDevice::setFileName(const QString &value)
{
if (engine->isActive())
{
qWarning("VDxfPaintDevice::setFileName(), cannot set file name while Dxf is being generated");
return;
}
fileName = value;
engine->setFileName(fileName);
}
//---------------------------------------------------------------------------------------------------------------------
QSize VDxfPaintDevice::getSize()
{
return engine->getSize();
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfPaintDevice::setSize(const QSize &size)
{
if (engine->isActive())
{
qWarning("VDxfPaintDevice::setSize(), cannot set size while Dxf is being generated");
return;
}
engine->setSize(size);
}
//---------------------------------------------------------------------------------------------------------------------
int VDxfPaintDevice::getResolution() const
{
return engine->getResolution();
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfPaintDevice::setResolution(int dpi)
{
engine->setResolution(dpi);
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfPaintDevice::setMeasurement(const VarMeasurement &var)
{
engine->setMeasurement(var);
}
//---------------------------------------------------------------------------------------------------------------------
void VDxfPaintDevice::setInsunits(const VarInsunits &var)
{
engine->setInsunits(var);
}
//---------------------------------------------------------------------------------------------------------------------
int VDxfPaintDevice::metric(QPaintDevice::PaintDeviceMetric metric) const
{
switch (metric)
{
case QPaintDevice::PdmDepth:
return 32;
case QPaintDevice::PdmWidth:
return engine->getSize().width();
case QPaintDevice::PdmHeight:
return engine->getSize().height();
case QPaintDevice::PdmDpiX:
return engine->getResolution();
case QPaintDevice::PdmDpiY:
return engine->getResolution();
case QPaintDevice::PdmHeightMM:
return qRound(engine->getSize().height() * 25.4 / engine->getResolution());
case QPaintDevice::PdmWidthMM:
return qRound(engine->getSize().width() * 25.4 / engine->getResolution());
case QPaintDevice::PdmNumColors:
return static_cast<int>(0xffffffff);
case QPaintDevice::PdmPhysicalDpiX:
return engine->getResolution();
case QPaintDevice::PdmPhysicalDpiY:
return engine->getResolution();
case QPaintDevice::PdmDevicePixelRatio:
return 1;
default:
qWarning("VDxfPaintDevice::metric(), unhandled metric %d\n", metric);
break;
}
return 0;
}

View File

@ -0,0 +1,65 @@
/************************************************************************
**
** @file vdxfpaintdevice.h
** @author Valentina Zhuravska <zhuravska19(at)gmail.com>
** @date 12 812, 2015
**
** @brief
** @copyright
** This source code is part of the Valentine project, a pattern making
** program, whose allow create and modeling patterns of clothing.
** Copyright (C) 2013-2015 Valentina project
** <https://bitbucket.org/dismine/valentina> All Rights Reserved.
**
** Valentina 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.
**
** Valentina 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 Valentina. If not, see <http://www.gnu.org/licenses/>.
**
*************************************************************************/
#ifndef VDXFPAINTDEVICE_H
#define VDXFPAINTDEVICE_H
#include <QPaintDevice>
#include <QString>
#include "dxfdef.h"
class VDxfEngine;
class VDxfPaintDevice : public QPaintDevice
{
public:
VDxfPaintDevice();
virtual ~VDxfPaintDevice() Q_DECL_OVERRIDE;
virtual QPaintEngine *paintEngine() const Q_DECL_OVERRIDE;
QString getFileName() const;
void setFileName(const QString &value);
QSize getSize();
void setSize(const QSize &size);
int getResolution() const;
void setResolution(int dpi);
void setMeasurement(const VarMeasurement &var);
void setInsunits(const VarInsunits &var);
protected:
virtual int metric(PaintDeviceMetric metric) const Q_DECL_OVERRIDE;
private:
Q_DISABLE_COPY(VDxfPaintDevice)
VDxfEngine *engine;
QString fileName;
};
#endif // VDXFPAINTDEVICE_H