valentina_old/mainwindow.cpp

1237 lines
46 KiB
C++
Raw Normal View History

/****************************************************************************
**
** Copyright (C) 2013 Valentina project All Rights Reserved.
**
** This file is part of Valentina.
**
** Tox 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.
**
** Tox 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/>.
**
****************************************************************************/
2013-06-20 16:09:50 +02:00
#include "mainwindow.h"
#include "ui_mainwindow.h"
2013-07-03 14:29:26 +02:00
#include <QLabel>
#include <QSpinBox>
#include <QScrollBar>
#include <QShowEvent>
2013-07-13 12:51:31 +02:00
#include <QDebug>
#include <QInputDialog>
#include <QFileDialog>
2013-07-25 14:00:51 +02:00
#include <QDebug>
2013-08-05 10:37:56 +02:00
#include "geometry/vspline.h"
#include <QMessageBox>
#include "exception/vexceptionobjecterror.h"
#include "exception/vexceptionconversionerror.h"
#include "exception/vexceptionemptyparameter.h"
#include "exception/vexceptionwrongparameterid.h"
#include "exception/vexceptionuniqueid.h"
2013-06-20 16:09:50 +02:00
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent), ui(new Ui::MainWindow), tool(Tool::ArrowTool), currentScene(0), sceneDraw(0),
2013-08-28 10:55:11 +02:00
sceneDetails(0), mouseCoordinate(0), helpLabel(0), view(0), isInitialized(false), dialogTable(0),
2013-08-20 12:26:02 +02:00
dialogEndLine(QSharedPointer<DialogEndLine>()), dialogLine(QSharedPointer<DialogLine>()),
dialogAlongLine(QSharedPointer<DialogAlongLine>()),
dialogShoulderPoint(QSharedPointer<DialogShoulderPoint>()), dialogNormal(QSharedPointer<DialogNormal>()),
dialogBisector(QSharedPointer<DialogBisector>()),
dialogLineIntersect(QSharedPointer<DialogLineIntersect>()), dialogSpline(QSharedPointer<DialogSpline>()),
2013-08-20 12:26:02 +02:00
dialogArc(QSharedPointer<DialogArc>()), dialogSplinePath(QSharedPointer<DialogSplinePath>()),
dialogPointOfContact(QSharedPointer<DialogPointOfContact>()),
dialogDetail(QSharedPointer<DialogDetail>()), dialogHeight(QSharedPointer<DialogHeight>()),
dialogTriangle(QSharedPointer<DialogTriangle>()),
dialogPointOfIntersection(QSharedPointer<DialogPointOfIntersection>()),
2013-08-28 10:55:11 +02:00
dialogHistory(0), doc(0), data(0), comboBoxDraws(0), fileName(QString()), changeInFile(false),
mode(Draw::Calculation){
2013-06-20 16:09:50 +02:00
ui->setupUi(this);
2013-07-03 14:29:26 +02:00
ToolBarOption();
ToolBarDraws();
2013-07-13 12:51:31 +02:00
QRectF sceneRect = QRectF(0, 0, PaperSize, PaperSize);
2013-08-28 10:55:11 +02:00
sceneDraw = new VMainGraphicsScene(sceneRect);
currentScene = sceneDraw;
connect(sceneDraw, &VMainGraphicsScene::mouseMove, this, &MainWindow::mouseMove);
sceneDetails = new VMainGraphicsScene(sceneRect);
connect(sceneDetails, &VMainGraphicsScene::mouseMove, this, &MainWindow::mouseMove);
view = new VMainGraphicsView();
ui->LayoutView->addWidget(view);
2013-08-28 10:55:11 +02:00
view->setScene(currentScene);
connect(view, &VMainGraphicsView::NewFactor, sceneDraw, &VMainGraphicsScene::SetFactor);
QSizePolicy policy(QSizePolicy::Expanding, QSizePolicy::Expanding);
policy.setHorizontalStretch(12);
view->setSizePolicy(policy);
helpLabel = new QLabel(tr("Create new drawing for start working."));
2013-07-03 14:29:26 +02:00
ui->statusBar->addWidget(helpLabel);
2013-07-25 14:00:51 +02:00
connect(ui->actionArrowTool, &QAction::triggered, this, &MainWindow::ActionAroowTool);
connect(ui->actionDraw, &QAction::triggered, this, &MainWindow::ActionDraw);
connect(ui->actionDetails, &QAction::triggered, this, &MainWindow::ActionDetails);
connect(ui->actionNewDraw, &QAction::triggered, this, &MainWindow::ActionNewDraw);
connect(ui->actionOptionDraw, &QAction::triggered, this, &MainWindow::OptionDraw);
connect(ui->actionSaveAs, &QAction::triggered, this, &MainWindow::ActionSaveAs);
connect(ui->actionSave, &QAction::triggered, this, &MainWindow::ActionSave);
connect(ui->actionOpen, &QAction::triggered, this, &MainWindow::ActionOpen);
connect(ui->actionNew, &QAction::triggered, this, &MainWindow::ActionNew);
connect(ui->actionTable, &QAction::triggered, this, &MainWindow::ActionTable);
2013-08-15 22:39:00 +02:00
connect(ui->toolButtonEndLine, &QToolButton::clicked, this, &MainWindow::ToolEndLine);
connect(ui->toolButtonLine, &QToolButton::clicked, this, &MainWindow::ToolLine);
connect(ui->toolButtonAlongLine, &QToolButton::clicked, this, &MainWindow::ToolAlongLine);
connect(ui->toolButtonShoulderPoint, &QToolButton::clicked, this, &MainWindow::ToolShoulderPoint);
connect(ui->toolButtonNormal, &QToolButton::clicked, this, &MainWindow::ToolNormal);
connect(ui->toolButtonBisector, &QToolButton::clicked, this, &MainWindow::ToolBisector);
connect(ui->toolButtonLineIntersect, &QToolButton::clicked, this, &MainWindow::ToolLineIntersect);
connect(ui->toolButtonSpline, &QToolButton::clicked, this, &MainWindow::ToolSpline);
connect(ui->toolButtonArc, &QToolButton::clicked, this, &MainWindow::ToolArc);
connect(ui->toolButtonSplinePath, &QToolButton::clicked, this, &MainWindow::ToolSplinePath);
2013-08-21 10:03:53 +02:00
connect(ui->toolButtonPointOfContact, &QToolButton::clicked, this, &MainWindow::ToolPointOfContact);
2013-08-28 10:55:11 +02:00
connect(ui->toolButtonNewDetail, &QToolButton::clicked, this, &MainWindow::ToolDetail);
connect(ui->toolButtonHeight, &QToolButton::clicked, this, &MainWindow::ToolHeight);
connect(ui->toolButtonTriangle, &QToolButton::clicked, this, &MainWindow::ToolTriangle);
connect(ui->toolButtonPointOfIntersection, &QToolButton::clicked, this, &MainWindow::ToolPointOfIntersection);
2013-07-13 12:51:31 +02:00
data = new VContainer;
2013-08-29 12:31:50 +02:00
doc = new VDomDocument(data, comboBoxDraws, &mode);
2013-07-13 12:51:31 +02:00
doc->CreateEmptyFile();
connect(doc, &VDomDocument::haveChange, this, &MainWindow::haveChange);
fileName.clear();
changeInFile = false;
2013-07-25 14:00:51 +02:00
//Autosaving file each 5 minutes
QTimer *timer = new QTimer(this);
timer->setTimerType(Qt::VeryCoarseTimer);
connect(timer, &QTimer::timeout, this, &MainWindow::AutoSavePattern);
timer->start(300000);
connect(ui->actionAbout_Qt, &QAction::triggered, this, &MainWindow::AboutQt);
connect(ui->actionAbout_Valentina, &QAction::triggered, this, &MainWindow::About);
connect(ui->actionExit, &QAction::triggered, this, &MainWindow::close);
ui->toolBox->setCurrentIndex(0);
2013-07-13 12:51:31 +02:00
}
2013-07-25 14:00:51 +02:00
void MainWindow::ActionNewDraw(){
2013-07-13 12:51:31 +02:00
QString nameDraw;
bool bOk;
qint32 index;
QString nDraw = QString(tr("Drawing %1")).arg(comboBoxDraws->count()+1);
2013-07-13 12:51:31 +02:00
QInputDialog *dlg = new QInputDialog(this);
dlg->setInputMode( QInputDialog::TextInput );
dlg->setLabelText(tr("Drawing:"));
2013-07-13 12:51:31 +02:00
dlg->setTextEchoMode(QLineEdit::Normal);
dlg->setWindowTitle(tr("Enter a name for the drawing."));
2013-07-13 12:51:31 +02:00
dlg->resize(300,100);
dlg->setTextValue(nDraw);
while(1){
bOk = dlg->exec();
nameDraw = dlg->textValue();
if(!bOk || nameDraw.isEmpty()){
delete dlg;
return;
}
index = comboBoxDraws->findText(nameDraw);
if(index != -1){//we already have this name
qCritical()<<tr("Error. Drawing of same name already exists.");
2013-07-13 12:51:31 +02:00
} else {
break;
}
}
delete dlg;
bOk = doc->appendDraw(nameDraw);
if(bOk == false){
qCritical()<<tr("Error creating drawing with the name")<<nameDraw<<".";
return;
2013-07-13 12:51:31 +02:00
}
2013-08-15 22:39:00 +02:00
disconnect(comboBoxDraws, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &MainWindow::currentDrawChanged);
comboBoxDraws->addItem(nameDraw);
2013-07-13 12:51:31 +02:00
index = comboBoxDraws->findText(nameDraw);
if ( index != -1 ) { // -1 for not found
comboBoxDraws->setCurrentIndex(index);
2013-08-15 22:39:00 +02:00
currentDrawChanged( index );
2013-07-13 12:51:31 +02:00
}
2013-08-15 22:39:00 +02:00
connect(comboBoxDraws, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &MainWindow::currentDrawChanged);
data->ClearObject();
//Create single point
qint64 id = data->AddPoint(VPointF((10+comboBoxDraws->count()*5)*PrintDPI/25.4, 10*PrintDPI/25.4, "А", 5,
10));
VToolSinglePoint *spoint = new VToolSinglePoint(doc, data, id, Tool::FromGui);
2013-08-28 10:55:11 +02:00
sceneDraw->addItem(spoint);
connect(spoint, &VToolPoint::ChoosedTool, sceneDraw, &VMainGraphicsScene::ChoosedItem);
connect(sceneDraw, &VMainGraphicsScene::NewFactor, spoint, &VToolSinglePoint::SetFactor);
QHash<qint64, VDataTool*>* tools = doc->getTools();
2013-08-15 22:39:00 +02:00
tools->insert(id, spoint);
VDrawTool::AddRecord(id, Tool::SinglePointTool, doc);
2013-08-15 22:39:00 +02:00
SetEnableTool(true);
2013-07-17 13:38:11 +02:00
SetEnableWidgets(true);
changeInFile = true;
2013-07-13 12:51:31 +02:00
}
2013-07-25 14:00:51 +02:00
void MainWindow::OptionDraw(){
2013-07-13 12:51:31 +02:00
QString nameDraw;
bool bOk;
qint32 index;
QString nDraw = doc->GetNameActivDraw();
QInputDialog *dlg = new QInputDialog(this);
dlg->setInputMode( QInputDialog::TextInput );
dlg->setLabelText(tr("Drawing:"));
2013-07-13 12:51:31 +02:00
dlg->setTextEchoMode(QLineEdit::Normal);
dlg->setWindowTitle(tr("Enter a new name for the drawing."));
2013-07-13 12:51:31 +02:00
dlg->resize(300,100);
dlg->setTextValue(nDraw);
while(1){
bOk = dlg->exec();
nameDraw = dlg->textValue();
if(!bOk || nameDraw.isEmpty()){
delete dlg;
return;
}
index = comboBoxDraws->findText(nameDraw);
if(index != -1){//we already have this name
qCritical()<<tr("Error. Drawing of same name already exists.");
2013-07-13 12:51:31 +02:00
} else {
break;
}
}
delete dlg;
index = comboBoxDraws->findText(doc->GetNameActivDraw());
if(doc->SetNameDraw(nameDraw)){
comboBoxDraws->setItemText(index, nameDraw);
} else {
QMessageBox::warning(this, tr("Error saving change!!!"), tr("Can't save new name of drawing"));
}
2013-07-03 14:29:26 +02:00
}
template <typename Dialog, typename Func>
void MainWindow::SetToolButton(bool checked, Tool::Tools t, const QString &cursor,
const QString &toolTip, QSharedPointer<Dialog> &dialog,
Func closeDialogSlot){
if(checked){
CanselTool();
tool = t;
QPixmap pixmap(cursor);
QCursor cur(pixmap, 2, 3);
view->setCursor(cur);
helpLabel->setText(toolTip);
dialog = QSharedPointer<Dialog>(new Dialog(data, mode));
2013-08-28 10:55:11 +02:00
connect(currentScene, &VMainGraphicsScene::ChoosedObject, dialog.data(), &Dialog::ChoosedObject);
connect(dialog.data(), &Dialog::DialogClosed, this, closeDialogSlot);
connect(dialog.data(), &Dialog::ToolTip, this, &MainWindow::ShowToolTip);
connect(doc, &VDomDocument::FullUpdateFromFile, dialog.data(), &Dialog::UpdateList);
} else {
if(QToolButton *tButton = qobject_cast< QToolButton * >(this->sender())){
tButton->setChecked(true);
}
}
}
template <typename T>
void MainWindow::AddToolToDetail(T *tool, const qint64 &id, Tool::Tools typeTool,
const qint64 &idDetail){
QHash<qint64, VDataTool*>* tools = doc->getTools();
VToolDetail *det = qobject_cast<VToolDetail*>(tools->value(idDetail));
Q_ASSERT(det != 0);
det->AddTool(tool, id, typeTool);
}
void MainWindow::ToolEndLine(bool checked){
SetToolButton(checked, Tool::EndLineTool, ":/cursor/endline_cursor.png", tr("Select point"),
dialogEndLine, &MainWindow::ClosedDialogEndLine);
2013-07-25 14:00:51 +02:00
}
void MainWindow::ClosedDialogEndLine(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolEndLine::Create(dialogEndLine, currentScene, doc, data);
} else {
VModelingEndLine *endLine = VModelingEndLine::Create(dialogEndLine, doc, data);
AddToolToDetail(endLine, endLine->getId(), Tool::EndLineTool, dialogEndLine->getIdDetail());
}
2013-07-25 14:00:51 +02:00
}
ArrowTool();
}
2013-07-25 20:39:51 +02:00
void MainWindow::ToolLine(bool checked){
SetToolButton(checked, Tool::LineTool, ":/cursor/line_cursor.png", tr("Select first point"),
dialogLine, &MainWindow::ClosedDialogLine);
2013-07-25 20:39:51 +02:00
}
void MainWindow::ClosedDialogLine(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolLine::Create(dialogLine, currentScene, doc, data);
} else {
VModelingLine *line = VModelingLine::Create(dialogLine, doc, data);
AddToolToDetail(line, line->getId(), Tool::LineTool, dialogLine->getIdDetail());
}
2013-07-25 20:39:51 +02:00
}
ArrowTool();
}
2013-07-28 00:18:06 +02:00
void MainWindow::ToolAlongLine(bool checked){
SetToolButton(checked, Tool::AlongLineTool, ":/cursor/alongline_cursor.png", tr("Select point"),
dialogAlongLine, &MainWindow::ClosedDialogAlongLine);
2013-07-28 00:18:06 +02:00
}
void MainWindow::ClosedDialogAlongLine(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolAlongLine::Create(dialogAlongLine, currentScene, doc, data);
} else{
VModelingAlongLine *point = VModelingAlongLine::Create(dialogAlongLine, doc, data);
AddToolToDetail(point, point->getId(), Tool::AlongLineTool, dialogAlongLine->getIdDetail());
}
2013-07-28 00:18:06 +02:00
}
ArrowTool();
}
2013-07-29 14:55:40 +02:00
void MainWindow::ToolShoulderPoint(bool checked){
SetToolButton(checked, Tool::ShoulderPointTool, ":/cursor/shoulder_cursor.png",
tr("Select first point of line"), dialogShoulderPoint,
&MainWindow::ClosedDialogShoulderPoint);
2013-07-29 14:55:40 +02:00
}
void MainWindow::ClosedDialogShoulderPoint(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolShoulderPoint::Create(dialogShoulderPoint, currentScene, doc, data);
} else {
VModelingShoulderPoint *point = VModelingShoulderPoint::Create(dialogShoulderPoint, doc, data);
AddToolToDetail(point, point->getId(), Tool::ShoulderPointTool,
dialogShoulderPoint->getIdDetail());
}
2013-07-29 14:55:40 +02:00
}
ArrowTool();
}
2013-07-30 15:09:34 +02:00
void MainWindow::ToolNormal(bool checked){
SetToolButton(checked, Tool::NormalTool, ":/cursor/normal_cursor.png",
tr("Select first point of line"), dialogNormal, &MainWindow::ClosedDialogNormal);
2013-07-30 15:09:34 +02:00
}
void MainWindow::ClosedDialogNormal(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolNormal::Create(dialogNormal, currentScene, doc, data);
} else {
VModelingNormal *point = VModelingNormal::Create(dialogNormal, doc, data);
AddToolToDetail(point, point->getId(), Tool::NormalTool, dialogNormal->getIdDetail());
}
2013-07-30 15:09:34 +02:00
}
ArrowTool();
}
2013-07-30 20:46:40 +02:00
void MainWindow::ToolBisector(bool checked){
SetToolButton(checked, Tool::BisectorTool, ":/cursor/bisector_cursor.png",
tr("Select first point of angle"), dialogBisector, &MainWindow::ClosedDialogBisector);
2013-07-30 20:46:40 +02:00
}
void MainWindow::ClosedDialogBisector(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolBisector::Create(dialogBisector, currentScene, doc, data);
} else {
VModelingBisector *point = VModelingBisector::Create(dialogBisector, doc, data);
AddToolToDetail(point, point->getId(), Tool::BisectorTool, dialogBisector->getIdDetail());
}
2013-07-30 20:46:40 +02:00
}
ArrowTool();
}
2013-07-31 13:34:39 +02:00
void MainWindow::ToolLineIntersect(bool checked){
SetToolButton(checked, Tool::LineIntersectTool, ":/cursor/intersect_cursor.png",
tr("Select first point of first line"), dialogLineIntersect,
&MainWindow::ClosedDialogLineIntersect);
2013-07-31 13:34:39 +02:00
}
void MainWindow::ClosedDialogLineIntersect(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolLineIntersect::Create(dialogLineIntersect, currentScene, doc, data);
} else {
VModelingLineIntersect *point = VModelingLineIntersect::Create(dialogLineIntersect, doc,
data);
AddToolToDetail(point, point->getId(), Tool::LineIntersectTool,
dialogLineIntersect->getIdDetail());
}
2013-07-31 13:34:39 +02:00
}
ArrowTool();
}
2013-08-05 10:37:56 +02:00
void MainWindow::ToolSpline(bool checked){
SetToolButton(checked, Tool::SplineTool, ":/cursor/spline_cursor.png",
tr("Select first point curve"), dialogSpline, &MainWindow::ClosedDialogSpline);
2013-08-05 10:37:56 +02:00
}
void MainWindow::ClosedDialogSpline(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolSpline::Create(dialogSpline, currentScene, doc, data);
} else {
VModelingSpline *spl = VModelingSpline::Create(dialogSpline, doc, data);
AddToolToDetail(spl, spl->getId(), Tool::SplineTool, dialogSpline->getIdDetail());
}
2013-08-05 10:37:56 +02:00
}
ArrowTool();
}
2013-08-06 09:56:09 +02:00
void MainWindow::ToolArc(bool checked){
SetToolButton(checked, Tool::ArcTool, ":/cursor/arc_cursor.png",
tr("Select point of center of arc"), dialogArc, &MainWindow::ClosedDialogArc);
2013-08-06 09:56:09 +02:00
}
void MainWindow::ClosedDialogArc(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolArc::Create(dialogArc, currentScene, doc, data);
} else {
VModelingArc *arc = VModelingArc::Create(dialogArc, doc, data);
AddToolToDetail(arc, arc->getId(), Tool::ArcTool, dialogArc->getIdDetail());
}
2013-08-06 09:56:09 +02:00
}
ArrowTool();
}
2013-08-09 08:49:34 +02:00
void MainWindow::ToolSplinePath(bool checked){
SetToolButton(checked, Tool::SplinePathTool, ":/cursor/splinepath_cursor.png",
tr("Select point of curve path"), dialogSplinePath,
&MainWindow::ClosedDialogSplinePath);
2013-08-09 08:49:34 +02:00
}
void MainWindow::ClosedDialogSplinePath(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolSplinePath::Create(dialogSplinePath, currentScene, doc, data);
} else {
VModelingSplinePath *spl = VModelingSplinePath::Create(dialogSplinePath, doc, data);
AddToolToDetail(spl, spl->getId(), Tool::SplinePathTool, dialogSplinePath->getIdDetail());
}
2013-08-09 08:49:34 +02:00
}
ArrowTool();
}
2013-08-21 10:03:53 +02:00
void MainWindow::ToolPointOfContact(bool checked){
SetToolButton(checked, Tool::PointOfContact, ":/cursor/pointcontact_cursor.png",
tr("Select first point of line"), dialogPointOfContact,
2013-08-21 10:03:53 +02:00
&MainWindow::ClosedDialogPointOfContact);
}
void MainWindow::ClosedDialogPointOfContact(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolPointOfContact::Create(dialogPointOfContact, currentScene, doc, data);
} else {
VModelingPointOfContact *point = VModelingPointOfContact::Create(dialogPointOfContact, doc,
data);
AddToolToDetail(point, point->getId(), Tool::PointOfContact,
dialogPointOfContact->getIdDetail());
}
2013-08-28 10:55:11 +02:00
}
ArrowTool();
}
void MainWindow::ToolDetail(bool checked){
if(checked){
CanselTool();
tool = Tool::Detail;
2013-08-28 10:55:11 +02:00
QPixmap pixmap("://cursor/new_detail_cursor.png");
QCursor cur(pixmap, 2, 3);
view->setCursor(cur);
helpLabel->setText(tr("Select points, arcs, curves clockwise."));
2013-08-28 10:55:11 +02:00
dialogDetail = QSharedPointer<DialogDetail>(new DialogDetail(data, mode));
connect(currentScene, &VMainGraphicsScene::ChoosedObject, dialogDetail.data(),
&DialogDetail::ChoosedObject);
connect(dialogDetail.data(), &DialogDetail::DialogClosed, this, &MainWindow::ClosedDialogDetail);
connect(doc, &VDomDocument::FullUpdateFromFile, dialogDetail.data(), &DialogDetail::UpdateList);
} else {
if(QToolButton *tButton = qobject_cast< QToolButton * >(this->sender())){
tButton->setChecked(true);
}
}
}
void MainWindow::ClosedDialogDetail(int result){
if(result == QDialog::Accepted){
VToolDetail::Create(dialogDetail, sceneDetails, doc, data);
2013-08-21 10:03:53 +02:00
}
ArrowTool();
}
void MainWindow::ToolHeight(bool checked){
SetToolButton(checked, Tool::Height, ":/cursor/height_cursor.png", tr("Select base point"),
dialogHeight, &MainWindow::ClosedDialogHeight);
}
void MainWindow::ClosedDialogHeight(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolHeight::Create(dialogHeight, currentScene, doc, data);
} else {
VModelingHeight *point = VModelingHeight::Create(dialogHeight, doc, data);
AddToolToDetail(point, point->getId(), Tool::Height, dialogHeight->getIdDetail());
}
}
ArrowTool();
}
void MainWindow::ToolTriangle(bool checked){
SetToolButton(checked, Tool::Triangle, ":/cursor/triangle_cursor.png", tr("Select first point of axis"),
dialogTriangle, &MainWindow::ClosedDialogTriangle);
}
void MainWindow::ClosedDialogTriangle(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolTriangle::Create(dialogTriangle, currentScene, doc, data);
} else {
VModelingTriangle *point = VModelingTriangle::Create(dialogTriangle, doc, data);
AddToolToDetail(point, point->getId(), Tool::Triangle, dialogTriangle->getIdDetail());
}
}
ArrowTool();
}
void MainWindow::ToolPointOfIntersection(bool checked){
SetToolButton(checked, Tool::PointOfIntersection, ":/cursor/pointofintersect_cursor.png",
tr("Select point vertically"),
dialogPointOfIntersection, &MainWindow::ClosedDialogPointOfIntersection);
}
void MainWindow::ClosedDialogPointOfIntersection(int result){
if(result == QDialog::Accepted){
if(mode == Draw::Calculation){
VToolPointOfIntersection::Create(dialogPointOfIntersection, currentScene, doc, data);
} else {
VModelingPointOfIntersection *point = VModelingPointOfIntersection::Create(dialogPointOfIntersection,
doc, data);
AddToolToDetail(point, point->getId(), Tool::PointOfIntersection,
dialogPointOfIntersection->getIdDetail());
}
}
ArrowTool();
}
void MainWindow::About(){
QMessageBox::about(this, tr("About Valentina"), tr("Valentina v.0.1.0"));
}
void MainWindow::AboutQt(){
QMessageBox::aboutQt(this, tr("About Qt"));
}
void MainWindow::ShowToolTip(const QString &toolTip){
helpLabel->setText(toolTip);
}
2013-08-29 12:31:50 +02:00
void MainWindow::tableClosed(){
show();
MinimumScrollBar();
}
2013-07-03 14:29:26 +02:00
void MainWindow::showEvent( QShowEvent *event ){
QMainWindow::showEvent( event );
if( event->spontaneous() ){
return;
}
if(isInitialized){
return;
}
// do your init stuff here
2013-08-29 12:31:50 +02:00
MinimumScrollBar();
2013-07-03 14:29:26 +02:00
isInitialized = true;//first show windows are held
2013-07-03 14:29:26 +02:00
}
void MainWindow::closeEvent(QCloseEvent *event){
if(changeInFile == true){
QMessageBox msgBox;
msgBox.setText(tr("The pattern has been modified."));
msgBox.setInformativeText(tr("Do you want to save your changes?"));
msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);
msgBox.setDefaultButton(QMessageBox::Save);
msgBox.setIcon(QMessageBox::Question);
int ret = msgBox.exec();
switch (ret) {
case QMessageBox::Save:
// Save was clicked
if(fileName.isEmpty()){
ActionSaveAs();
} else {
ActionSave();
}
if(changeInFile){
// We did't save file
event->ignore();
} else {
// We have successfully saved the file
event->accept();
}
break;
case QMessageBox::Discard:
// Don't Save was clicked
event->accept();
break;
case QMessageBox::Cancel:
// Cancel was clicked
event->ignore();
break;
default:
// should never be reached
event->accept();
break;
}
}
}
2013-07-03 14:29:26 +02:00
void MainWindow::ToolBarOption(){
QLabel * labelGrowth = new QLabel;
labelGrowth->setText(tr("Growth: "));
2013-07-03 14:29:26 +02:00
ui->toolBarOption->addWidget(labelGrowth);
2013-06-20 16:09:50 +02:00
QStringList list;
2013-07-03 14:29:26 +02:00
list << "104"<<"110"<<"116"<<"122"<<"128"<<"134"<<"140"<<"146"<<"152"<<"158"<<"164"<<"170"<<"176"
<< "182" << "188";
2013-07-17 13:38:11 +02:00
QComboBox *comboBoxGrow = new QComboBox;
2013-07-03 14:29:26 +02:00
comboBoxGrow->clear();
comboBoxGrow->addItems(list);
comboBoxGrow->setCurrentIndex(12);
ui->toolBarOption->addWidget(comboBoxGrow);
2013-07-17 13:38:11 +02:00
connect(comboBoxGrow,
static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::currentIndexChanged),
this, &MainWindow::ChangedGrowth);
2013-07-03 14:29:26 +02:00
QLabel * labelSize = new QLabel;
labelSize->setText(tr(" Size: "));
2013-07-03 14:29:26 +02:00
ui->toolBarOption->addWidget(labelSize);
list.clear();
2013-06-20 16:09:50 +02:00
list << "28"<<"30"<<"32"<<"34"<<"36"<<"38"<<"40"<<"42"<<"44"<<"46"<<"48"<<"50" << "52" << "54" << "56";
2013-07-17 13:38:11 +02:00
QComboBox *comboBoxSize = new QComboBox;
2013-07-03 14:29:26 +02:00
comboBoxSize->clear();
2013-06-20 16:09:50 +02:00
comboBoxSize->addItems(list);
2013-07-03 14:29:26 +02:00
comboBoxSize->setCurrentIndex(11);
2013-06-20 16:09:50 +02:00
ui->toolBarOption->addWidget(comboBoxSize);
2013-07-17 13:38:11 +02:00
connect(comboBoxSize,
static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::currentIndexChanged),
this, &MainWindow::ChangedSize);
2013-07-03 14:29:26 +02:00
ui->toolBarOption->addSeparator();
mouseCoordinate = new QLabel;
mouseCoordinate ->setText("0, 0");
ui->toolBarOption->addWidget(mouseCoordinate);
}
void MainWindow::ToolBarDraws(){
QLabel * labelNameDraw = new QLabel;
labelNameDraw ->setText(tr("Drawing: "));
2013-07-03 14:29:26 +02:00
ui->toolBarDraws->addWidget(labelNameDraw);
2013-07-13 12:51:31 +02:00
comboBoxDraws = new QComboBox;
2013-07-03 14:29:26 +02:00
ui->toolBarDraws->addWidget(comboBoxDraws);
2013-07-13 12:51:31 +02:00
comboBoxDraws->setSizeAdjustPolicy(QComboBox::AdjustToContents);
connect(comboBoxDraws, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &MainWindow::currentDrawChanged);
2013-07-03 14:29:26 +02:00
2013-07-13 12:51:31 +02:00
ui->toolBarDraws->addAction(ui->actionOptionDraw);
ui->actionOptionDraw->setEnabled(false);
2013-07-17 13:38:11 +02:00
ui->toolBarDraws->addAction(ui->actionTable);
ui->actionTable->setEnabled(false);
2013-08-15 22:39:00 +02:00
ui->toolBarDraws->addAction(ui->actionHistory);
ui->actionHistory->setEnabled(false);
2013-08-29 12:31:50 +02:00
connect(ui->actionHistory, &QAction::triggered, this, &MainWindow::ActionHistory);
ui->toolBarDraws->addAction(ui->actionLayout);
connect(ui->actionLayout, &QAction::triggered, this, &MainWindow::ActionLayout);
2013-07-13 12:51:31 +02:00
}
2013-07-03 14:29:26 +02:00
2013-07-13 12:51:31 +02:00
void MainWindow::currentDrawChanged( int index ){
if(index != -1) {
2013-08-15 22:39:00 +02:00
doc->setCurrentData();
2013-07-13 12:51:31 +02:00
doc->ChangeActivDraw(comboBoxDraws->itemText(index));
}
2013-07-03 14:29:26 +02:00
}
void MainWindow::mouseMove(QPointF scenePos){
QString string = QString("%1, %2")
2013-08-15 22:39:00 +02:00
.arg(static_cast<qint32>(scenePos.x()/PrintDPI*25.4))
.arg(static_cast<qint32>(scenePos.y()/PrintDPI*25.4));
2013-07-03 14:29:26 +02:00
mouseCoordinate->setText(string);
}
void MainWindow::CanselTool(){
switch( tool ){
case Tool::ArrowTool:
ui->actionArrowTool->setChecked(false);
helpLabel->setText("");
break;
case Tool::SinglePointTool:
Q_UNREACHABLE();
//Nothing to do here because we can't create this tool from main window.
break;
case Tool::EndLineTool:
dialogEndLine.clear();
ui->toolButtonEndLine->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::LineTool:
dialogLine.clear();
ui->toolButtonLine->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearFocus();
break;
case Tool::AlongLineTool:
dialogAlongLine.clear();
ui->toolButtonAlongLine->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::ShoulderPointTool:
dialogShoulderPoint.clear();
ui->toolButtonShoulderPoint->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::NormalTool:
dialogNormal.clear();
ui->toolButtonNormal->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::BisectorTool:
dialogBisector.clear();
ui->toolButtonBisector->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::LineIntersectTool:
dialogLineIntersect.clear();
ui->toolButtonLineIntersect->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::SplineTool:
dialogSpline.clear();
ui->toolButtonSpline->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::ArcTool:
dialogArc.clear();
ui->toolButtonArc->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::SplinePathTool:
dialogSplinePath.clear();
ui->toolButtonSplinePath->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::PointOfContact:
dialogPointOfContact.clear();
ui->toolButtonPointOfContact->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::Detail:
dialogDetail.clear();
ui->toolButtonNewDetail->setChecked(false);
break;
case Tool::Height:
dialogHeight.clear();
ui->toolButtonHeight->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::Triangle:
dialogTriangle.clear();
ui->toolButtonTriangle->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::PointOfIntersection:
dialogPointOfIntersection.clear();
ui->toolButtonPointOfIntersection->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
default:
qWarning()<<"Get wrong tool type. Ignore.";
break;
2013-07-03 14:29:26 +02:00
}
}
void MainWindow::ArrowTool(){
CanselTool();
2013-07-13 12:51:31 +02:00
ui->actionArrowTool->setChecked(true);
tool = Tool::ArrowTool;
2013-07-03 14:29:26 +02:00
QCursor cur(Qt::ArrowCursor);
view->setCursor(cur);
2013-07-03 14:29:26 +02:00
helpLabel->setText("");
}
2013-07-25 14:00:51 +02:00
void MainWindow::ActionAroowTool(){
2013-07-03 14:29:26 +02:00
ArrowTool();
2013-06-20 16:09:50 +02:00
}
2013-07-13 12:51:31 +02:00
void MainWindow::keyPressEvent ( QKeyEvent * event ){
switch(event->key()){
case Qt::Key_Escape:
ArrowTool();
break;
}
QMainWindow::keyPressEvent ( event );
}
2013-07-25 14:00:51 +02:00
void MainWindow::ActionDraw(bool checked){
2013-07-13 12:51:31 +02:00
if(checked){
ui->actionDetails->setChecked(false);
/*Save scroll bars value for previous scene.*/
QScrollBar *horScrollBar = view->horizontalScrollBar();
currentScene->setHorScrollBar(horScrollBar->value());
QScrollBar *verScrollBar = view->verticalScrollBar();
currentScene->setVerScrollBar(verScrollBar->value());
2013-08-28 10:55:11 +02:00
currentScene = sceneDraw;
view->setScene(currentScene);
/*Set value for current scene scroll bar.*/
horScrollBar = view->horizontalScrollBar();
horScrollBar->setValue(currentScene->getHorScrollBar());
verScrollBar = view->verticalScrollBar();
verScrollBar->setValue(currentScene->getVerScrollBar());
2013-08-28 10:55:11 +02:00
mode = Draw::Calculation;
2013-08-29 12:31:50 +02:00
doc->setCurrentData();
2013-07-13 12:51:31 +02:00
} else {
ui->actionDraw->setChecked(true);
}
}
2013-07-25 14:00:51 +02:00
void MainWindow::ActionDetails(bool checked){
2013-07-13 12:51:31 +02:00
if(checked){
ui->actionDraw->setChecked(false);
/*Save scroll bars value for previous scene.*/
QScrollBar *horScrollBar = view->horizontalScrollBar();
currentScene->setHorScrollBar(horScrollBar->value());
QScrollBar *verScrollBar = view->verticalScrollBar();
currentScene->setVerScrollBar(verScrollBar->value());
2013-08-28 10:55:11 +02:00
currentScene = sceneDetails;
view->setScene(sceneDetails);
/*Set value for current scene scroll bar.*/
horScrollBar = view->horizontalScrollBar();
horScrollBar->setValue(currentScene->getHorScrollBar());
verScrollBar = view->verticalScrollBar();
verScrollBar->setValue(currentScene->getVerScrollBar());
2013-08-28 10:55:11 +02:00
mode = Draw::Modeling;
2013-07-13 12:51:31 +02:00
} else {
ui->actionDetails->setChecked(true);
}
}
2013-07-25 14:00:51 +02:00
void MainWindow::ActionSaveAs(){
QString filters(tr("Lekalo files (*.xml);;All files (*.*)"));
QString defaultFilter(tr("Lekalo files (*.xml)"));
QString fName = QFileDialog::getSaveFileName(this, tr("Save as"), QDir::homePath(),
filters, &defaultFilter);
if(fName.isEmpty())
return;
2013-07-13 12:51:31 +02:00
if(fName.indexOf(".xml",fName.size()-4)<0){
fName.append(".xml");
}
fileName = fName;
ActionSave();
2013-07-13 12:51:31 +02:00
}
2013-07-25 14:00:51 +02:00
void MainWindow::ActionSave(){
2013-07-13 12:51:31 +02:00
if(!fileName.isEmpty()){
bool result = SafeSaveing(fileName);
if(result){
ui->actionSave->setEnabled(false);
changeInFile = false;
QFileInfo info(fileName);
QString title(info.fileName());
title.append("-Valentina");
setWindowTitle(title);
} else {
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error!"));
msgBox.setText(tr("Error saving file. Can't save file."));
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.setIcon(QMessageBox::Warning);
msgBox.exec();
2013-07-13 12:51:31 +02:00
}
}
}
2013-07-25 14:00:51 +02:00
void MainWindow::ActionOpen(){
QString filter(tr("Lekalo files (*.xml)"));
QString fName = QFileDialog::getOpenFileName(this, tr("Open file"), QDir::homePath(), filter);
if(fName.isEmpty())
return;
if(fileName.isEmpty() && changeInFile == false){
OpenPattern(fName);
} else {
/*Open new copy application*/
QProcess *v = new QProcess(this);
QStringList arguments;
arguments << "-o" << fName;
v->startDetached(QCoreApplication::applicationFilePath (), arguments);
delete v;
2013-07-13 12:51:31 +02:00
}
}
void MainWindow::Clear(){
2013-07-13 12:51:31 +02:00
setWindowTitle("Valentina");
fileName.clear();
2013-07-13 12:51:31 +02:00
data->Clear();
doc->clear();
2013-08-28 10:55:11 +02:00
sceneDraw->clear();
sceneDetails->clear();
2013-07-13 12:51:31 +02:00
CanselTool();
comboBoxDraws->clear();
fileName.clear();
ui->actionOptionDraw->setEnabled(false);
ui->actionSave->setEnabled(false);
2013-07-25 14:00:51 +02:00
SetEnableTool(false);
2013-07-13 12:51:31 +02:00
}
void MainWindow::ActionNew(){
QProcess *v = new QProcess(this);
v->startDetached(QCoreApplication::applicationFilePath ());
delete v;
}
2013-07-13 12:51:31 +02:00
void MainWindow::haveChange(){
if(!fileName.isEmpty()){
ui->actionSave->setEnabled(true);
changeInFile = true;
QFileInfo info(fileName);
QString title(info.fileName());
title.append("*-Valentina");
setWindowTitle(title);
2013-07-13 12:51:31 +02:00
}
}
2013-07-17 13:38:11 +02:00
void MainWindow::ChangedSize(const QString & text){
qint32 size = text.toInt();
data->SetSize(size*10);
doc->FullUpdateTree();
}
void MainWindow::ChangedGrowth(const QString &text){
qint32 growth = text.toInt();
data->SetGrowth(growth*10);
doc->FullUpdateTree();
}
void MainWindow::SetEnableWidgets(bool enable){
ui->actionSaveAs->setEnabled(enable);
ui->actionDraw->setEnabled(enable);
ui->actionDetails->setEnabled(enable);
ui->actionOptionDraw->setEnabled(enable);
2013-07-25 14:00:51 +02:00
if(enable == true && !fileName.isEmpty()){
ui->actionSave->setEnabled(enable);
}
2013-07-17 13:38:11 +02:00
ui->actionTable->setEnabled(enable);
2013-08-15 22:39:00 +02:00
ui->actionHistory->setEnabled(enable);
2013-07-17 13:38:11 +02:00
}
2013-07-25 14:00:51 +02:00
void MainWindow::ActionTable(bool checked){
2013-07-17 13:38:11 +02:00
if(checked){
2013-07-28 00:18:06 +02:00
dialogTable = new DialogIncrements(data, doc, this);
connect(dialogTable, &DialogIncrements::DialogClosed, this,
2013-07-25 14:00:51 +02:00
&MainWindow::ClosedActionTable);
2013-07-17 13:38:11 +02:00
dialogTable->show();
} else {
ui->actionTable->setChecked(true);
dialogTable->activateWindow();
}
}
2013-07-25 14:00:51 +02:00
void MainWindow::ClosedActionTable(){
2013-07-17 13:38:11 +02:00
ui->actionTable->setChecked(false);
delete dialogTable;
}
2013-08-15 22:39:00 +02:00
void MainWindow::ActionHistory(bool checked){
if(checked){
dialogHistory = new DialogHistory(data, doc, this);
dialogHistory->setWindowFlags(Qt::Window);
connect(dialogHistory, &DialogHistory::DialogClosed, this,
&MainWindow::ClosedActionHistory);
dialogHistory->show();
} else {
ui->actionHistory->setChecked(true);
dialogHistory->activateWindow();
}
}
2013-08-29 12:31:50 +02:00
void MainWindow::ActionLayout(bool checked){
Q_UNUSED(checked);
hide();
QVector<VItem*> listDetails;
data->PrepareDetails(listDetails);
emit ModelChosen(listDetails);
}
2013-08-15 22:39:00 +02:00
void MainWindow::ClosedActionHistory(){
ui->actionHistory->setChecked(false);
delete dialogHistory;
}
2013-07-25 14:00:51 +02:00
void MainWindow::SetEnableTool(bool enable){
ui->toolButtonEndLine->setEnabled(enable);
2013-07-25 20:39:51 +02:00
ui->toolButtonLine->setEnabled(enable);
2013-07-28 00:18:06 +02:00
ui->toolButtonAlongLine->setEnabled(enable);
2013-07-29 14:55:40 +02:00
ui->toolButtonShoulderPoint->setEnabled(enable);
2013-07-30 15:09:34 +02:00
ui->toolButtonNormal->setEnabled(enable);
2013-07-30 20:46:40 +02:00
ui->toolButtonBisector->setEnabled(enable);
2013-07-31 13:34:39 +02:00
ui->toolButtonLineIntersect->setEnabled(enable);
2013-08-05 10:37:56 +02:00
ui->toolButtonSpline->setEnabled(enable);
2013-08-06 09:56:09 +02:00
ui->toolButtonArc->setEnabled(enable);
2013-08-09 08:49:34 +02:00
ui->toolButtonSplinePath->setEnabled(enable);
2013-08-21 10:03:53 +02:00
ui->toolButtonPointOfContact->setEnabled(enable);
2013-08-28 10:55:11 +02:00
ui->toolButtonNewDetail->setEnabled(enable);
ui->toolButtonHeight->setEnabled(enable);
ui->toolButtonTriangle->setEnabled(enable);
ui->toolButtonPointOfIntersection->setEnabled(enable);
2013-07-25 14:00:51 +02:00
}
2013-08-29 12:31:50 +02:00
void MainWindow::MinimumScrollBar(){
QScrollBar *horScrollBar = view->horizontalScrollBar();
horScrollBar->setValue(horScrollBar->minimum());
QScrollBar *verScrollBar = view->verticalScrollBar();
verScrollBar->setValue(verScrollBar->minimum());
}
bool MainWindow::SafeSaveing(const QString &fileName) const{
try{
doc->TestUniqueId();
}
catch(const VExceptionUniqueId &e){
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error!"));
msgBox.setText(tr("Error don't unique id."));
msgBox.setInformativeText(e.ErrorMessage());
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.setDetailedText(e.DetailedInformation());
msgBox.setIcon(QMessageBox::Critical);
msgBox.exec();
return false;
}
if(fileName.isEmpty()){
qWarning()<<tr("Got empty file name.");
return false;
}
//Writing in temporary file
QFileInfo tempInfo(fileName);
QString temp = tempInfo.absolutePath() + "/" + tempInfo.baseName() + ".tmp";
qDebug()<<"file "<<fileName<<"temp file "<<temp;
QFile tempFile(temp);
if(tempFile.open(QIODevice::WriteOnly| QIODevice::Truncate)){
const int Indent = 4;
QTextStream out(&tempFile);
doc->save(out, Indent);
tempFile.close();
}
//Replace temp file our
bool result = false;
QFile patternFile(fileName);
// We need here temporary file because we need restore pattern after error of copying temp file.
QTemporaryFile tempOfPattern;
if (tempOfPattern.open()) {
patternFile.copy(tempOfPattern.fileName());
}
if ( !patternFile.exists() || patternFile.remove() ) {
if ( !tempFile.copy(patternFile.fileName()) ){
qCritical()<<tr("Could not copy temp file to pattern file")<<Q_FUNC_INFO;
tempOfPattern.copy(fileName);
result = false;
} else {
result = true;
}
} else {
qCritical()<<tr("Could not remove pattern file")<<Q_FUNC_INFO;
result = false;
}
if(result){
tempFile.remove();
}
return result;
}
void MainWindow::AutoSavePattern(){
if(!fileName.isEmpty() && changeInFile == true){
bool result = SafeSaveing(fileName);
if(result){
ui->actionSave->setEnabled(false);
changeInFile = false;
QFileInfo info(fileName);
QString title(info.fileName());
title.append("-Valentina");
setWindowTitle(title);
}
}
}
2013-07-13 12:51:31 +02:00
MainWindow::~MainWindow(){
2013-07-03 14:29:26 +02:00
CanselTool();
2013-06-20 16:09:50 +02:00
delete ui;
2013-07-13 12:51:31 +02:00
QFile file("lekalo.xml");
if(file.open(QIODevice::WriteOnly | QIODevice::Truncate)){
const int Indent = 4;
QTextStream out(&file);
doc->save(out, Indent);
file.close();
}
delete data;
if(!doc->isNull()){
delete doc;
}
}
void MainWindow::OpenPattern(const QString &fileName){
if(fileName.isEmpty()){
qWarning()<<tr("Can't open pattern file. File name empty")<<Q_FUNC_INFO;
return;
}
QFile file(fileName);
QString errorMsg;
qint32 errorLine = 0;
qint32 errorColumn = 0;
if(file.open(QIODevice::ReadOnly)){
if(doc->setContent(&file, &errorMsg, &errorLine, &errorColumn)){
disconnect(comboBoxDraws, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &MainWindow::currentDrawChanged);
try{
doc->Parse(Document::FullParse, sceneDraw, sceneDetails);
}
catch(const VExceptionObjectError &e){
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error!"));
msgBox.setText(tr("Error parsing file."));
msgBox.setInformativeText(e.ErrorMessage());
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.setDetailedText(e.DetailedInformation());
msgBox.setIcon(QMessageBox::Critical);
msgBox.exec();
file.close();
Clear();
return;
}
catch(const VExceptionConversionError &e){
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error!"));
msgBox.setText(tr("Error can't convert value."));
msgBox.setInformativeText(e.ErrorMessage());
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.setIcon(QMessageBox::Critical);
msgBox.exec();
file.close();
Clear();
return;
}
catch(const VExceptionEmptyParameter &e){
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error!"));
msgBox.setText(tr("Error empty parameter."));
msgBox.setInformativeText(e.ErrorMessage());
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.setDetailedText(e.DetailedInformation());
msgBox.setIcon(QMessageBox::Critical);
msgBox.exec();
file.close();
Clear();
return;
}
catch(const VExceptionWrongParameterId &e){
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error!"));
msgBox.setText(tr("Error wrong id."));
msgBox.setInformativeText(e.ErrorMessage());
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.setDetailedText(e.DetailedInformation());
msgBox.setIcon(QMessageBox::Critical);
msgBox.exec();
file.close();
Clear();
return;
}
catch(const VExceptionUniqueId &e){
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error!"));
msgBox.setText(tr("Error don't unique id."));
msgBox.setInformativeText(e.ErrorMessage());
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.setDetailedText(e.DetailedInformation());
msgBox.setIcon(QMessageBox::Critical);
msgBox.exec();
file.close();
Clear();
return;
}
connect(comboBoxDraws, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
this, &MainWindow::currentDrawChanged);
QString nameDraw = doc->GetNameActivDraw();
qint32 index = comboBoxDraws->findText(nameDraw);
if ( index != -1 ) { // -1 for not found
comboBoxDraws->setCurrentIndex(index);
}
if(comboBoxDraws->count() > 0){
SetEnableTool(true);
} else {
SetEnableTool(false);
}
SetEnableWidgets(true);
} else {
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Error!"));
msgBox.setText(tr("Error parsing pattern file."));
msgBox.setInformativeText(errorMsg);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
QString error = QString(tr("Error in line %1 column %2")).arg(errorLine, errorColumn);
msgBox.setDetailedText(error);
msgBox.exec();
file.close();
Clear();
return;
}
file.close();
}
this->fileName = fileName;
QFileInfo info(fileName);
QString title(info.fileName());
title.append("-Valentina");
setWindowTitle(title);
helpLabel->setText("");
2013-06-20 16:09:50 +02:00
}