palo/valentina
1
0
Fork 0
mirror of https://gitlab.com/smart-pattern/valentina.git synced 2024-06-26 14:18:12 +02:00
Code Issues Projects Releases Wiki Activity

Dialog make top-level window.

Browse source 
--HG--
branch : develop
This commit is contained in:
dismine 2014-02-06 15:57:23 +02:00
parent 16cf055b4c
commit 544acf4dad
48 changed files with 988 additions and 1118 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/dialogs/dialogs.h
View file

@ -45,8 +45,11 @@
#include "dialogspline.h"
#include "dialogsplinepath.h"
#include "dialogheight.h"
#include "dialogcutarc.h"
#include "dialogcutspline.h"
#include "dialogcutsplinepath.h"
#include "dialoguniondetails.h"
#include "dialogtriangle.h"
#include "dialogpointofintersection.h"
#endif // DIALOGS_H

14
src/dialogs/dialogtool.cpp
View file

@ -46,6 +46,8 @@ DialogTool::DialogTool(const VContainer *data, QWidget *parent)
//Keep synchronize with VAbstractTool styles list!!!
lineStyles<<tr("No line")<<tr("Line")<<tr("Dash Line")<<tr("Dot Line")<<tr("Dash Dot Line")
<<tr("Dash Dot Dot Line");
Qt::WindowFlags flags = windowFlags();
setWindowFlags(flags | Qt::WindowStaysOnTopHint);
}
void DialogTool::closeEvent(QCloseEvent *event)
@ -654,6 +656,18 @@ void DialogTool::UpdateList()
}
}
void DialogTool::ApplicationDeactivate(bool type)
{
// if (type == true)
// {
// this->hide();
// }
// else
// {
// this->show();
// }
}
template <class key, class val>
void DialogTool::ShowVariable(const QHash<key, val> *var)
{

5
src/dialogs/dialogtool.h
View file

@ -177,6 +177,11 @@ public slots:
* @brief UpdateList update lists of variables
*/
void UpdateList();
/**
* @brief ApplicationDeactivate hide and show dialog simultaneously with parent window.
* @param type true - hide, false - show window.
*/
void ApplicationDeactivate(bool type);
protected:
Q_DISABLE_COPY(DialogTool)
/**

237
src/mainwindow.cpp
View file

@ -77,22 +77,11 @@ private:
MainWindow::MainWindow(QWidget *parent)
:QMainWindow(parent), ui(new Ui::MainWindow), pattern(0), doc(0), tool(Tool::ArrowTool), currentScene(0),
sceneDraw(0), sceneDetails(0), mouseCoordinate(0), helpLabel(0), view(0), isInitialized(false), dialogTable(0),
dialogEndLine(QSharedPointer<DialogEndLine>()), dialogLine(QSharedPointer<DialogLine>()),
dialogAlongLine(QSharedPointer<DialogAlongLine>()),
dialogShoulderPoint(QSharedPointer<DialogShoulderPoint>()), dialogNormal(QSharedPointer<DialogNormal>()),
dialogBisector(QSharedPointer<DialogBisector>()),
dialogLineIntersect(QSharedPointer<DialogLineIntersect>()), dialogSpline(QSharedPointer<DialogSpline>()),
dialogArc(QSharedPointer<DialogArc>()), dialogSplinePath(QSharedPointer<DialogSplinePath>()),
dialogPointOfContact(QSharedPointer<DialogPointOfContact>()),
dialogDetail(QSharedPointer<DialogDetail>()), dialogHeight(QSharedPointer<DialogHeight>()),
dialogTriangle(QSharedPointer<DialogTriangle>()),
dialogPointOfIntersection(QSharedPointer<DialogPointOfIntersection>()),
dialogCutSpline(QSharedPointer<DialogCutSpline>()), dialogCutSplinePath (QSharedPointer<DialogCutSplinePath>()),
dialogUnionDetails(QSharedPointer<DialogUnionDetails>()), dialogCutArc(QSharedPointer<DialogCutArc>()),
dialogHistory(0), comboBoxDraws(0), fileName(QString()), changeInFile(false),
mode(Draw::Calculation), currentDrawIndex(0), currentToolBoxIndex(0), drawMode(true)
dialogTool(0), dialogHistory(0), comboBoxDraws(0), fileName(QString()), changeInFile(false),
mode(Draw::Calculation), currentDrawIndex(0), currentToolBoxIndex(0), drawMode(true)
{
ui->setupUi(this);
qApp->installEventFilter(this);
static const char * GENERIC_ICON_TO_CHECK = "document-open";
if (QIcon::hasThemeIcon(GENERIC_ICON_TO_CHECK) == false)
{
@ -287,7 +276,7 @@ void MainWindow::OptionDraw()
template <typename Dialog, typename Func>
void MainWindow::SetToolButton(bool checked, Tool::Tools t, const QString &cursor, const QString &toolTip,
QSharedPointer<Dialog> &dialog, Func closeDialogSlot)
Func closeDialogSlot)
{
if (checked)
{
@ -297,11 +286,13 @@ void MainWindow::SetToolButton(bool checked, Tool::Tools t, const QString &curso
QCursor cur(pixmap, 2, 3);
view->setCursor(cur);
helpLabel->setText(toolTip);
dialog = QSharedPointer<Dialog>(new Dialog(pattern));
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);
dialogTool = new Dialog(pattern, this);
Q_CHECK_PTR(dialogTool);
connect(this, &MainWindow::ApplicationDeactivate, dialogTool, &DialogTool::ApplicationDeactivate);
connect(currentScene, &VMainGraphicsScene::ChoosedObject, dialogTool, &DialogTool::ChoosedObject);
connect(dialogTool, &DialogTool::DialogClosed, this, closeDialogSlot);
connect(dialogTool, &DialogTool::ToolTip, this, &MainWindow::ShowToolTip);
connect(doc, &VDomDocument::FullUpdateFromFile, dialogTool, &DialogTool::UpdateList);
}
else
{
@ -313,192 +304,171 @@ void MainWindow::SetToolButton(bool checked, Tool::Tools t, const QString &curso
}
}
template <typename DrawTool, typename Dialog>
void MainWindow::ClosedDialog(QSharedPointer<Dialog> &dialog, int result)
template <typename DrawTool>
void MainWindow::ClosedDialog(int result)
{
Q_CHECK_PTR(dialogTool);
if (result == QDialog::Accepted)
{
DrawTool::Create(dialog, currentScene, doc, pattern);
DrawTool::Create(dialogTool, currentScene, doc, pattern);
}
ArrowTool();
}
void MainWindow::ToolEndLine(bool checked)
{
SetToolButton(checked, Tool::EndLineTool, ":/cursor/endline_cursor.png", tr("Select point"),
dialogEndLine, &MainWindow::ClosedDialogEndLine);
SetToolButton<DialogEndLine>(checked, Tool::EndLineTool, ":/cursor/endline_cursor.png", tr("Select point"),
&MainWindow::ClosedDialogEndLine);
}
void MainWindow::ClosedDialogEndLine(int result)
{
ClosedDialog<VToolEndLine>(dialogEndLine, result);
ClosedDialog<VToolEndLine>(result);
}
void MainWindow::ToolLine(bool checked)
{
SetToolButton(checked, Tool::LineTool, ":/cursor/line_cursor.png", tr("Select first point"),
dialogLine, &MainWindow::ClosedDialogLine);
SetToolButton<DialogTool>(checked, Tool::LineTool, ":/cursor/line_cursor.png", tr("Select first point"),
&MainWindow::ClosedDialogLine);
}
void MainWindow::ClosedDialogLine(int result)
{
ClosedDialog<VToolLine>(dialogLine, result);
ClosedDialog<VToolLine>(result);
}
void MainWindow::ToolAlongLine(bool checked)
{
SetToolButton(checked, Tool::AlongLineTool, ":/cursor/alongline_cursor.png", tr("Select point"),
dialogAlongLine, &MainWindow::ClosedDialogAlongLine);
SetToolButton<DialogAlongLine>(checked, Tool::AlongLineTool, ":/cursor/alongline_cursor.png", tr("Select point"),
&MainWindow::ClosedDialogAlongLine);
}
void MainWindow::ClosedDialogAlongLine(int result)
{
ClosedDialog<VToolAlongLine>(dialogAlongLine, result);
ClosedDialog<VToolAlongLine>(result);
}
void MainWindow::ToolShoulderPoint(bool checked)
{
SetToolButton(checked, Tool::ShoulderPointTool, ":/cursor/shoulder_cursor.png",
tr("Select first point of line"), dialogShoulderPoint,
&MainWindow::ClosedDialogShoulderPoint);
SetToolButton<DialogShoulderPoint>(checked, Tool::ShoulderPointTool, ":/cursor/shoulder_cursor.png",
tr("Select first point of line"), &MainWindow::ClosedDialogShoulderPoint);
}
void MainWindow::ClosedDialogShoulderPoint(int result)
{
ClosedDialog<VToolShoulderPoint>(dialogShoulderPoint, result);
ClosedDialog<VToolShoulderPoint>(result);
}
void MainWindow::ToolNormal(bool checked)
{
SetToolButton(checked, Tool::NormalTool, ":/cursor/normal_cursor.png",
tr("Select first point of line"), dialogNormal, &MainWindow::ClosedDialogNormal);
SetToolButton<DialogNormal>(checked, Tool::NormalTool, ":/cursor/normal_cursor.png",
tr("Select first point of line"), &MainWindow::ClosedDialogNormal);
}
void MainWindow::ClosedDialogNormal(int result)
{
ClosedDialog<VToolNormal>(dialogNormal, result);
ClosedDialog<VToolNormal>(result);
}
void MainWindow::ToolBisector(bool checked)
{
SetToolButton(checked, Tool::BisectorTool, ":/cursor/bisector_cursor.png",
tr("Select first point of angle"), dialogBisector, &MainWindow::ClosedDialogBisector);
SetToolButton<DialogBisector>(checked, Tool::BisectorTool, ":/cursor/bisector_cursor.png",
tr("Select first point of angle"), &MainWindow::ClosedDialogBisector);
}
void MainWindow::ClosedDialogBisector(int result)
{
ClosedDialog<VToolBisector>(dialogBisector, result);
ClosedDialog<VToolBisector>(result);
}
void MainWindow::ToolLineIntersect(bool checked)
{
SetToolButton(checked, Tool::LineIntersectTool, ":/cursor/intersect_cursor.png",
tr("Select first point of first line"), dialogLineIntersect,
&MainWindow::ClosedDialogLineIntersect);
SetToolButton<DialogLineIntersect>(checked, Tool::LineIntersectTool, ":/cursor/intersect_cursor.png",
tr("Select first point of first line"), &MainWindow::ClosedDialogLineIntersect);
}
void MainWindow::ClosedDialogLineIntersect(int result)
{
ClosedDialog<VToolLineIntersect>(dialogLineIntersect, result);
ClosedDialog<VToolLineIntersect>(result);
}
void MainWindow::ToolSpline(bool checked)
{
SetToolButton(checked, Tool::SplineTool, ":/cursor/spline_cursor.png",
tr("Select first point curve"), dialogSpline, &MainWindow::ClosedDialogSpline);
SetToolButton<DialogSpline>(checked, Tool::SplineTool, ":/cursor/spline_cursor.png",
tr("Select first point curve"), &MainWindow::ClosedDialogSpline);
}
void MainWindow::ClosedDialogSpline(int result)
{
ClosedDialog<VToolSpline>(dialogSpline, result);
ClosedDialog<VToolSpline>(result);
}
void MainWindow::ToolCutSpline(bool checked)
{
SetToolButton(checked, Tool::CutSplineTool, ":/cursor/spline_cut_point_cursor.png",
tr("Select simple curve"), dialogCutSpline, &MainWindow::ClosedDialogCutSpline);
SetToolButton<DialogCutSpline>(checked, Tool::CutSplineTool, ":/cursor/spline_cut_point_cursor.png",
tr("Select simple curve"), &MainWindow::ClosedDialogCutSpline);
}
void MainWindow::ClosedDialogCutSpline(int result)
{
ClosedDialog<VToolCutSpline>(dialogCutSpline, result);
ClosedDialog<VToolCutSpline>(result);
}
void MainWindow::ToolArc(bool checked)
{
SetToolButton(checked, Tool::ArcTool, ":/cursor/arc_cursor.png",
tr("Select point of center of arc"), dialogArc, &MainWindow::ClosedDialogArc);
SetToolButton<DialogArc>(checked, Tool::ArcTool, ":/cursor/arc_cursor.png",
tr("Select point of center of arc"), &MainWindow::ClosedDialogArc);
}
void MainWindow::ClosedDialogArc(int result)
{
ClosedDialog<VToolArc>(dialogArc, result);
ClosedDialog<VToolArc>(result);
}
void MainWindow::ToolSplinePath(bool checked)
{
SetToolButton(checked, Tool::SplinePathTool, ":/cursor/splinepath_cursor.png",
tr("Select point of curve path"), dialogSplinePath, &MainWindow::ClosedDialogSplinePath);
SetToolButton<DialogSplinePath>(checked, Tool::SplinePathTool, ":/cursor/splinepath_cursor.png",
tr("Select point of curve path"), &MainWindow::ClosedDialogSplinePath);
}
void MainWindow::ClosedDialogSplinePath(int result)
{
ClosedDialog<VToolSplinePath>(dialogSplinePath, result);
ClosedDialog<VToolSplinePath>(result);
}
void MainWindow::ToolCutSplinePath(bool checked)
{
SetToolButton(checked, Tool::CutSplinePathTool, ":/cursor/splinepath_cut_point_cursor.png",
tr("Select curve path"), dialogCutSplinePath, &MainWindow::ClosedDialogCutSplinePath);
SetToolButton<DialogCutSplinePath>(checked, Tool::CutSplinePathTool, ":/cursor/splinepath_cut_point_cursor.png",
tr("Select curve path"), &MainWindow::ClosedDialogCutSplinePath);
}
void MainWindow::ClosedDialogCutSplinePath(int result)
{
ClosedDialog<VToolCutSplinePath>(dialogCutSplinePath, result);
ClosedDialog<VToolCutSplinePath>(result);
}
void MainWindow::ToolPointOfContact(bool checked)
{
SetToolButton(checked, Tool::PointOfContact, ":/cursor/pointcontact_cursor.png",
tr("Select first point of line"), dialogPointOfContact,
&MainWindow::ClosedDialogPointOfContact);
SetToolButton<DialogPointOfContact>(checked, Tool::PointOfContact, ":/cursor/pointcontact_cursor.png",
tr("Select first point of line"), &MainWindow::ClosedDialogPointOfContact);
}
void MainWindow::ClosedDialogPointOfContact(int result)
{
ClosedDialog<VToolPointOfContact>(dialogPointOfContact, result);
ClosedDialog<VToolPointOfContact>(result);
}
void MainWindow::ToolDetail(bool checked)
{
if (checked)
{
CancelTool();
tool = Tool::Detail;
QPixmap pixmap("://cursor/new_detail_cursor.png");
QCursor cur(pixmap, 2, 3);
view->setCursor(cur);
helpLabel->setText(tr("Select points, arcs, curves clockwise."));
dialogDetail = QSharedPointer<DialogDetail>(new DialogDetail(pattern));
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);
}
}
SetToolButton<DialogDetail>(checked, Tool::Detail, "://cursor/new_detail_cursor.png",
tr("Select points, arcs, curves clockwise."), &MainWindow::ClosedDialogDetail);
}
void MainWindow::ClosedDialogDetail(int result)
{
if (result == QDialog::Accepted)
{
VToolDetail::Create(dialogDetail, sceneDetails, doc, pattern);
VToolDetail::Create(dialogTool, sceneDetails, doc, pattern);
}
ArrowTool();
doc->FullUpdateTree();
@ -506,63 +476,62 @@ void MainWindow::ClosedDialogDetail(int result)
void MainWindow::ToolHeight(bool checked)
{
SetToolButton(checked, Tool::Height, ":/cursor/height_cursor.png", tr("Select base point"),
dialogHeight, &MainWindow::ClosedDialogHeight);
SetToolButton<DialogHeight>(checked, Tool::Height, ":/cursor/height_cursor.png", tr("Select base point"),
&MainWindow::ClosedDialogHeight);
}
void MainWindow::ClosedDialogHeight(int result)
{
ClosedDialog<VToolHeight>(dialogHeight, result);
ClosedDialog<VToolHeight>(result);
}
void MainWindow::ToolTriangle(bool checked)
{
SetToolButton(checked, Tool::Triangle, ":/cursor/triangle_cursor.png", tr("Select first point of axis"),
dialogTriangle, &MainWindow::ClosedDialogTriangle);
SetToolButton<DialogTriangle>(checked, Tool::Triangle, ":/cursor/triangle_cursor.png",
tr("Select first point of axis"), &MainWindow::ClosedDialogTriangle);
}
void MainWindow::ClosedDialogTriangle(int result)
{
ClosedDialog<VToolTriangle>(dialogTriangle, result);
ClosedDialog<VToolTriangle>(result);
}
void MainWindow::ToolPointOfIntersection(bool checked)
{
SetToolButton(checked, Tool::PointOfIntersection, ":/cursor/pointofintersect_cursor.png",
tr("Select point vertically"),
dialogPointOfIntersection, &MainWindow::ClosedDialogPointOfIntersection);
SetToolButton<DialogPointOfIntersection>(checked, Tool::PointOfIntersection, ":/cursor/pointofintersect_cursor.png",
tr("Select point vertically"), &MainWindow::ClosedDialogPointOfIntersection);
}
void MainWindow::ClosedDialogPointOfIntersection(int result)
{
ClosedDialog<VToolPointOfIntersection>(dialogPointOfIntersection, result);
ClosedDialog<VToolPointOfIntersection>(result);
}
void MainWindow::ToolUnionDetails(bool checked)
{
SetToolButton(checked, Tool::UnionDetails, ":/cursor/union_cursor.png",
tr("Select detail"), dialogUnionDetails, &MainWindow::ClosedDialogUnionDetails);
SetToolButton<DialogUnionDetails>(checked, Tool::UnionDetails, ":/cursor/union_cursor.png", tr("Select detail"),
&MainWindow::ClosedDialogUnionDetails);
//Must disconnect this signal here.
disconnect(doc, &VDomDocument::FullUpdateFromFile, dialogUnionDetails.data(), &DialogUnionDetails::UpdateList);
}
void MainWindow::ToolCutArc(bool checked)
{
SetToolButton(checked, Tool::CutArcTool, ":/cursor/arc_cut_cursor.png",
tr("Select arc"), dialogCutArc, &MainWindow::ClosedDialogCutArc);
}
void MainWindow::ClosedDialogCutArc(int result)
{
ClosedDialog<VToolCutArc>(dialogCutArc, result);
disconnect(doc, &VDomDocument::FullUpdateFromFile, dialogTool, &DialogTool::UpdateList);
}
void MainWindow::ClosedDialogUnionDetails(int result)
{
ClosedDialog<VToolUnionDetails>(dialogUnionDetails, result);
ClosedDialog<VToolUnionDetails>(result);
doc->FullUpdateTree();
}
void MainWindow::ToolCutArc(bool checked)
{
SetToolButton<DialogCutArc>(checked, Tool::CutArcTool, ":/cursor/arc_cut_cursor.png", tr("Select arc"),
&MainWindow::ClosedDialogCutArc);
}
void MainWindow::ClosedDialogCutArc(int result)
{
ClosedDialog<VToolCutArc>(result);
}
void MainWindow::About()
{
QString fullName = QString("Valentina %1").arg(APP_VERSION);
@ -753,6 +722,8 @@ void MainWindow::mouseMove(const QPointF &scenePos)
void MainWindow::CancelTool()
{
delete dialogTool;
dialogTool = 0;
switch ( tool )
{
case Tool::ArrowTool:
@ -764,113 +735,94 @@ void MainWindow::CancelTool()
//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;
case Tool::CutSplineTool:
dialogCutSpline.clear();
ui->toolButtonSplineCutPoint->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::CutSplinePathTool:
dialogCutSplinePath.clear();
ui->toolButtonSplinePathCutPoint->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::UnionDetails:
dialogUnionDetails.clear();
ui->toolButtonUnionDetails->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
break;
case Tool::CutArcTool:
dialogCutArc.clear();
ui->toolButtonArcCutPoint->setChecked(false);
currentScene->setFocus(Qt::OtherFocusReason);
currentScene->clearSelection();
@ -1086,6 +1038,29 @@ void MainWindow::Clear()
SetEnableTool(false);
}
bool MainWindow::eventFilter(QObject *object, QEvent *event)
{
#ifdef Q_CC_GNU
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wswitch-enum"
#endif
switch(event->type())
{
case(QEvent::ApplicationDeactivate):
emit ApplicationDeactivate(true);
break;
case(QEvent::ApplicationActivate):
emit ApplicationDeactivate(false);
break;
default:
break;
}
#ifdef Q_CC_GNU
#pragma GCC diagnostic pop
#endif
return QWidget::eventFilter(object, event);
}
void MainWindow::ActionNew()
{
QProcess *v = new QProcess(this);

44
src/mainwindow.h
View file

@ -361,6 +361,11 @@ signals:
* @param listDetails list of details.
*/
void ModelChosen(QVector<VItem*> listDetails, const QString &fileName);
/**
* @brief ApplicationDeactivate hide and show dialog simultaneously with parent window.
* @param type true - hide, false - show window.
*/
void ApplicationDeactivate(bool type);
protected:
/**
* @brief keyPressEvent handle key press events.
@ -381,6 +386,13 @@ protected:
* @brief Clear reset to default window.
*/
void Clear();
/**
* @brief eventFilter event filter main window.
* @param object object.
* @param event event
* @return true if accept.
*/
bool eventFilter(QObject* object, QEvent* event);
private:
Q_DISABLE_COPY(MainWindow)
/**
@ -428,25 +440,7 @@ private:
*/
bool isInitialized;
DialogIncrements *dialogTable;
QSharedPointer<DialogEndLine> dialogEndLine;
QSharedPointer<DialogLine> dialogLine;
QSharedPointer<DialogAlongLine> dialogAlongLine;
QSharedPointer<DialogShoulderPoint> dialogShoulderPoint;
QSharedPointer<DialogNormal> dialogNormal;
QSharedPointer<DialogBisector> dialogBisector;
QSharedPointer<DialogLineIntersect> dialogLineIntersect;
QSharedPointer<DialogSpline> dialogSpline;
QSharedPointer<DialogArc> dialogArc;
QSharedPointer<DialogSplinePath> dialogSplinePath;
QSharedPointer<DialogPointOfContact> dialogPointOfContact;
QSharedPointer<DialogDetail> dialogDetail;
QSharedPointer<DialogHeight> dialogHeight;
QSharedPointer<DialogTriangle> dialogTriangle;
QSharedPointer<DialogPointOfIntersection> dialogPointOfIntersection;
QSharedPointer<DialogCutSpline> dialogCutSpline;
QSharedPointer<DialogCutSplinePath> dialogCutSplinePath;
QSharedPointer<DialogUnionDetails> dialogUnionDetails;
QSharedPointer<DialogCutArc> dialogCutArc;
DialogTool *dialogTool;
DialogHistory *dialogHistory;
/**
* @brief comboBoxDraws comboc who show name of pattern peaces.
@ -517,11 +511,10 @@ private:
* @param t tool type.
* @param cursor path tool cursor icon.
* @param toolTip first tooltipe.
* @param dialog pointer to dialog.
* @param closeDialogSlot function what handle after close dialog.
*/
void SetToolButton(bool checked, Tool::Tools t, const QString &cursor, const QString &toolTip,
QSharedPointer<Dialog> &dialog, Func closeDialogSlot);
Func closeDialogSlot);
/**
* @brief MinimumScrollBar set scroll bar to minimum.
*/
@ -537,13 +530,12 @@ private:
*/
bool ValidatePattern(const QString &schema, const QString &fileName, QString &errorMsg, qint64 &errorLine,
qint64 &errorColumn) const;
template <typename DrawTool, typename Dialog>
template <typename DrawTool>
/**
* @brief ClosedDialog
* @param dialog
* @param result
* @brief ClosedDialog handle close dialog
* @param result result working dialog.
*/
void ClosedDialog(QSharedPointer<Dialog> &dialog, int result);
void ClosedDialog(int result);
/**
* @brief SafeSaveing safe saving pattern file.
* @param fileName pattern file name.

24
src/tools/drawTools/vdrawtool.cpp
View file

@ -32,13 +32,18 @@ qreal VDrawTool::factor = 1;
VDrawTool::VDrawTool(VDomDocument *doc, VContainer *data, qint64 id)
:VAbstractTool(doc, data, id), ignoreContextMenuEvent(false), ignoreFullUpdate(false),
nameActivDraw(doc->GetNameActivDraw())
nameActivDraw(doc->GetNameActivDraw()), dialog(0)
{
connect(this->doc, &VDomDocument::ChangedActivDraw, this, &VDrawTool::ChangedActivDraw);
connect(this->doc, &VDomDocument::ChangedNameDraw, this, &VDrawTool::ChangedNameDraw);
connect(this->doc, &VDomDocument::ShowTool, this, &VDrawTool::ShowTool);
}
VDrawTool::~VDrawTool()
{
delete dialog;
}
void VDrawTool::ShowTool(qint64 id, Qt::GlobalColor color, bool enable)
{
Q_UNUSED(id);
@ -66,6 +71,23 @@ void VDrawTool::ChangedNameDraw(const QString &oldName, const QString &newName)
}
}
void VDrawTool::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SaveDialog(domElement);
emit FullUpdateTree();
emit toolhaveChange();
}
}
delete dialog;
dialog = 0;
}
void VDrawTool::SetFactor(qreal factor)
{
if (factor <= 2 && factor >= 0.5)

29
src/tools/drawTools/vdrawtool.h
View file

@ -33,6 +33,7 @@
#include <QMenu>
#include <QGraphicsSceneContextMenuEvent>
#include "../../dialogs/dialogtool.h"
/**
* @brief The VDrawTool abstract class for all draw tool.
@ -49,7 +50,7 @@ public:
* @param parent parent object.
*/
VDrawTool(VDomDocument *doc, VContainer *data, qint64 id);
virtual ~VDrawTool() {}
virtual ~VDrawTool();
/**
* @brief setDialog set dialog when user want change tool option.
*/
@ -82,7 +83,7 @@ public slots:
* @brief FullUpdateFromGui refresh tool data after change in options.
* @param result keep result working dialog.
*/
virtual void FullUpdateFromGui(int result)=0;
virtual void FullUpdateFromGui(int result);
/**
* @brief SetFactor set current scale factor of scene.
* @param factor scene scale factor.
@ -105,21 +106,27 @@ protected:
* @brief factor scene scale factor.
*/
static qreal factor;
/**
* @brief dialog dialog options.
*/
DialogTool *dialog;
/**
* @brief AddToCalculation add tool to calculation tag in pattern file.
* @param domElement tag in xml tree.
*/
void AddToCalculation(const QDomElement &domElement);
/**
* @brief SaveDialog save options into file after change in dialog.
*/
virtual void SaveDialog(QDomElement &domElement)=0;
template <typename Dialog, typename Tool>
/**
* @brief ContextMenu show context menu for tool.
* @param dialog dialog option.
* @param tool tool.
* @param event context menu event.
* @param showRemove true - tool have option delete.
*/
void ContextMenu(QSharedPointer<Dialog> &dialog, Tool *tool, QGraphicsSceneContextMenuEvent *event,
bool showRemove = true)
void ContextMenu(Tool *tool, QGraphicsSceneContextMenuEvent *event, bool showRemove = true)
{
Q_CHECK_PTR(tool);
Q_CHECK_PTR(event);
@ -143,14 +150,16 @@ protected:
QAction *selectedAction = menu.exec(event->screenPos());
if (selectedAction == actionOption)
{
dialog = QSharedPointer<Dialog>(new Dialog(getData()));
QGraphicsScene *scene = tool->scene();
QList<QGraphicsView *> list = scene->views();
dialog = new Dialog(getData(), list.first());
connect(qobject_cast< VMainGraphicsScene * >(tool->scene()),
&VMainGraphicsScene::ChoosedObject, dialog.data(), &Dialog::ChoosedObject);
connect(dialog.data(), &Dialog::DialogClosed, tool, &Tool::FullUpdateFromGui);
&VMainGraphicsScene::ChoosedObject, dialog, &DialogTool::ChoosedObject);
connect(dialog, &DialogTool::DialogClosed, tool, &Tool::FullUpdateFromGui);
if (ignoreFullUpdate == false)
{
connect(doc, &VDomDocument::FullUpdateFromFile, dialog.data(), &Dialog::UpdateList);
connect(doc, &VDomDocument::FullUpdateFromFile, dialog, &DialogTool::UpdateList);
}
tool->setDialog();
@ -190,6 +199,8 @@ protected:
item->setPen(QPen(currentColor, widthHairLine/factor));
}
}
private:
Q_DISABLE_COPY(VDrawTool)
};
#endif // VDRAWTOOL_H

73
src/tools/drawTools/vtoolalongline.cpp
View file

@ -28,6 +28,7 @@
#include "vtoolalongline.h"
#include "../../container/calculator.h"
#include "../../dialogs/dialogalongline.h"
const QString VToolAlongLine::ToolType = QStringLiteral("alongLine");
@ -35,8 +36,7 @@ VToolAlongLine::VToolAlongLine(VDomDocument *doc, VContainer *data, qint64 id, c
const qint64 &firstPointId, const qint64 &secondPointId,
const QString &typeLine, const Tool::Sources &typeCreation,
QGraphicsItem *parent)
:VToolLinePoint(doc, data, id, typeLine, formula, firstPointId, 0, parent), secondPointId(secondPointId),
dialogAlongLine(QSharedPointer<DialogAlongLine>())
:VToolLinePoint(doc, data, id, typeLine, formula, firstPointId, 0, parent), secondPointId(secondPointId)
{
if (typeCreation == Tool::FromGui)
@ -62,25 +62,6 @@ void VToolAlongLine::FullUpdateFromFile()
RefreshGeometry();
}
void VToolAlongLine::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, dialogAlongLine->getPointName());
SetAttribute(domElement, AttrTypeLine, dialogAlongLine->getTypeLine());
SetAttribute(domElement, AttrLength, dialogAlongLine->getFormula());
SetAttribute(domElement, AttrFirstPoint, dialogAlongLine->getFirstPointId());
SetAttribute(domElement, AttrSecondPoint, dialogAlongLine->getSecondPointId());
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogAlongLine.clear();
}
void VToolAlongLine::SetFactor(qreal factor)
{
VDrawTool::SetFactor(factor);
@ -90,12 +71,12 @@ void VToolAlongLine::SetFactor(qreal factor)
//cppcheck-suppress unusedFunction
void VToolAlongLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogAlongLine, this, event);
ContextMenu<DialogAlongLine>(this, event);
}
void VToolAlongLine::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogAlongLine, this, event);
ContextMenu<DialogAlongLine>(this, event);
}
void VToolAlongLine::AddToFile()
@ -139,25 +120,41 @@ void VToolAlongLine::RemoveReferens()
VToolLinePoint::RemoveReferens();
}
void VToolAlongLine::setDialog()
void VToolAlongLine::SaveDialog(QDomElement &domElement)
{
Q_ASSERT(dialogAlongLine.isNull() == false);
const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogAlongLine->setTypeLine(typeLine);
dialogAlongLine->setFormula(formula);
dialogAlongLine->setFirstPointId(basePointId, id);
dialogAlongLine->setSecondPointId(secondPointId, id);
dialogAlongLine->setPointName(p->name());
Q_CHECK_PTR(dialog);
DialogAlongLine *dialogTool = qobject_cast<DialogAlongLine*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrName, dialogTool->getPointName());
SetAttribute(domElement, AttrTypeLine, dialogTool->getTypeLine());
SetAttribute(domElement, AttrLength, dialogTool->getFormula());
SetAttribute(domElement, AttrFirstPoint, dialogTool->getFirstPointId());
SetAttribute(domElement, AttrSecondPoint, dialogTool->getSecondPointId());
}
void VToolAlongLine::Create(QSharedPointer<DialogAlongLine> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data)
void VToolAlongLine::setDialog()
{
QString formula = dialog->getFormula();
qint64 firstPointId = dialog->getFirstPointId();
qint64 secondPointId = dialog->getSecondPointId();
QString typeLine = dialog->getTypeLine();
QString pointName = dialog->getPointName();
Q_CHECK_PTR(dialog);
DialogAlongLine *dialogTool = qobject_cast<DialogAlongLine*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogTool->setTypeLine(typeLine);
dialogTool->setFormula(formula);
dialogTool->setFirstPointId(basePointId, id);
dialogTool->setSecondPointId(secondPointId, id);
dialogTool->setPointName(p->name());
}
void VToolAlongLine::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data)
{
Q_CHECK_PTR(dialog);
DialogAlongLine *dialogTool = qobject_cast<DialogAlongLine*>(dialog);
Q_CHECK_PTR(dialogTool);
QString formula = dialogTool->getFormula();
qint64 firstPointId = dialogTool->getFirstPointId();
qint64 secondPointId = dialogTool->getSecondPointId();
QString typeLine = dialogTool->getTypeLine();
QString pointName = dialogTool->getPointName();
Create(0, pointName, typeLine, formula, firstPointId, secondPointId, 5, 10, scene, doc, data,
Document::FullParse, Tool::FromGui);
}

17
src/tools/drawTools/vtoolalongline.h
View file

@ -30,7 +30,6 @@
#define VTOOLALONGLINE_H
#include "vtoollinepoint.h"
#include "../../dialogs/dialogalongline.h"
/**
* @brief The VToolAlongLine class tool for creation point along line.
@ -65,8 +64,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogAlongLine> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -93,11 +91,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief SetFactor set current scale factor of scene.
* @param factor scene scale factor.
@ -126,15 +119,15 @@ protected:
* @brief RemoveReferens decrement value of reference.
*/
virtual void RemoveReferens();
/**
* @brief SaveDialog save options into file after change in dialog.
*/
virtual void SaveDialog(QDomElement &domElement);
private:
/**
* @brief secondPointId id second point of line.
*/
qint64 secondPointId;
/**
* @brief dialogAlongLine dialog.
*/
QSharedPointer<DialogAlongLine> dialogAlongLine;
};
#endif // VTOOLALONGLINE_H

59
src/tools/drawTools/vtoolarc.cpp
View file

@ -28,13 +28,14 @@
#include "vtoolarc.h"
#include "../../container/calculator.h"
#include "../../dialogs/dialogarc.h"
const QString VToolArc::TagName = QStringLiteral("arc");
const QString VToolArc::ToolType = QStringLiteral("simple");
VToolArc::VToolArc(VDomDocument *doc, VContainer *data, qint64 id, const Tool::Sources &typeCreation,
QGraphicsItem *parent)
:VDrawTool(doc, data, id), QGraphicsPathItem(parent), dialogArc(QSharedPointer<DialogArc>())
:VDrawTool(doc, data, id), QGraphicsPathItem(parent)
{
const VArc *arc = data->GeometricObject<const VArc *>(id);
QPainterPath path;
@ -58,21 +59,26 @@ VToolArc::VToolArc(VDomDocument *doc, VContainer *data, qint64 id, const Tool::S
void VToolArc::setDialog()
{
Q_ASSERT(dialogArc.isNull() == false);
Q_CHECK_PTR(dialog);
DialogArc *dialogTool = qobject_cast<DialogArc*>(dialog);
Q_CHECK_PTR(dialogTool);
const VArc *arc = VAbstractTool::data.GeometricObject<const VArc *>(id);
dialogArc->SetCenter(arc->GetCenter().id());
dialogArc->SetF1(arc->GetFormulaF1());
dialogArc->SetF2(arc->GetFormulaF2());
dialogArc->SetRadius(arc->GetFormulaRadius());
dialogTool->SetCenter(arc->GetCenter().id());
dialogTool->SetF1(arc->GetFormulaF1());
dialogTool->SetF2(arc->GetFormulaF2());
dialogTool->SetRadius(arc->GetFormulaRadius());
}
void VToolArc::Create(QSharedPointer<DialogArc> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
void VToolArc::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data)
{
qint64 center = dialog->GetCenter();
QString radius = dialog->GetRadius();
QString f1 = dialog->GetF1();
QString f2 = dialog->GetF2();
Q_CHECK_PTR(dialog);
DialogArc *dialogTool = qobject_cast<DialogArc*>(dialog);
Q_CHECK_PTR(dialogTool);
qint64 center = dialogTool->GetCenter();
QString radius = dialogTool->GetRadius();
QString f1 = dialogTool->GetF1();
QString f2 = dialogTool->GetF2();
Create(0, center, radius, f1, f2, scene, doc, data, Document::FullParse, Tool::FromGui);
}
@ -137,24 +143,6 @@ void VToolArc::FullUpdateFromFile()
RefreshGeometry();
}
void VToolArc::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrCenter, QString().setNum(dialogArc->GetCenter()));
SetAttribute(domElement, AttrRadius, dialogArc->GetRadius());
SetAttribute(domElement, AttrAngle1, dialogArc->GetF1());
SetAttribute(domElement, AttrAngle2, dialogArc->GetF2());
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogArc.clear();
}
void VToolArc::ChangedActivDraw(const QString &newName)
{
bool selectable = false;
@ -187,7 +175,7 @@ void VToolArc::SetFactor(qreal factor)
void VToolArc::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogArc, this, event);
ContextMenu<DialogArc>(this, event);
}
void VToolArc::AddToFile()
@ -278,6 +266,17 @@ void VToolArc::keyReleaseEvent(QKeyEvent *event)
QGraphicsItem::keyReleaseEvent ( event );
}
void VToolArc::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogArc *dialogTool = qobject_cast<DialogArc*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrCenter, QString().setNum(dialogTool->GetCenter()));
SetAttribute(domElement, AttrRadius, dialogTool->GetRadius());
SetAttribute(domElement, AttrAngle1, dialogTool->GetF1());
SetAttribute(domElement, AttrAngle2, dialogTool->GetF2());
}
void VToolArc::RefreshGeometry()
{
this->setPen(QPen(currentColor, widthHairLine/factor));

15
src/tools/drawTools/vtoolarc.h
View file

@ -31,7 +31,6 @@
#include "vdrawtool.h"
#include <QGraphicsPathItem>
#include "../../dialogs/dialogarc.h"
#include "../../widgets/vcontrolpointspline.h"
/**
@ -62,8 +61,7 @@ public:
* @param doc dom document container
* @param data container with variables
*/
static void Create(QSharedPointer<DialogArc> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool form GUI.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -87,11 +85,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data after change in options.
* @param result result working options window.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief ChangedActivDraw disable or enable context menu after change active pattern peace.
* @param newName new name active pattern peace.
@ -154,11 +147,11 @@ protected:
* @param event key release event.
*/
virtual void keyReleaseEvent(QKeyEvent * event);
private:
/**
* @brief dialogArc dialog.
* @brief SaveDialog save options into file after change in dialog.
*/
QSharedPointer<DialogArc> dialogArc;
virtual void SaveDialog(QDomElement &domElement);
private:
/**
* @brief RefreshGeometry refresh item on scene.
*/

74
src/tools/drawTools/vtoolbisector.cpp
View file

@ -28,6 +28,7 @@
#include "vtoolbisector.h"
#include "../../container/calculator.h"
#include "../../dialogs/dialogbisector.h"
const QString VToolBisector::ToolType = QStringLiteral("bisector");
@ -35,8 +36,7 @@ VToolBisector::VToolBisector(VDomDocument *doc, VContainer *data, const qint64 &
const QString &typeLine, const QString &formula, const qint64 &firstPointId,
const qint64 &secondPointId, const qint64 &thirdPointId, const Tool::Sources &typeCreation,
QGraphicsItem *parent)
:VToolLinePoint(doc, data, id, typeLine, formula, secondPointId, 0, parent), firstPointId(0),
thirdPointId(0), dialogBisector(QSharedPointer<DialogBisector>())
:VToolLinePoint(doc, data, id, typeLine, formula, secondPointId, 0, parent), firstPointId(0), thirdPointId(0)
{
this->firstPointId = firstPointId;
this->thirdPointId = thirdPointId;
@ -72,25 +72,30 @@ QPointF VToolBisector::FindPoint(const QPointF &firstPoint, const QPointF &secon
void VToolBisector::setDialog()
{
Q_ASSERT(dialogBisector.isNull() == false);
Q_CHECK_PTR(dialog);
DialogBisector *dialogTool = qobject_cast<DialogBisector*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogBisector->setTypeLine(typeLine);
dialogBisector->setFormula(formula);
dialogBisector->setFirstPointId(firstPointId, id);
dialogBisector->setSecondPointId(basePointId, id);
dialogBisector->setThirdPointId(thirdPointId, id);
dialogBisector->setPointName(p->name());
dialogTool->setTypeLine(typeLine);
dialogTool->setFormula(formula);
dialogTool->setFirstPointId(firstPointId, id);
dialogTool->setSecondPointId(basePointId, id);
dialogTool->setThirdPointId(thirdPointId, id);
dialogTool->setPointName(p->name());
}
void VToolBisector::Create(QSharedPointer<DialogBisector> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
void VToolBisector::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data)
{
QString formula = dialog->getFormula();
qint64 firstPointId = dialog->getFirstPointId();
qint64 secondPointId = dialog->getSecondPointId();
qint64 thirdPointId = dialog->getThirdPointId();
QString typeLine = dialog->getTypeLine();
QString pointName = dialog->getPointName();
Q_CHECK_PTR(dialog);
DialogBisector *dialogTool = qobject_cast<DialogBisector*>(dialog);
Q_CHECK_PTR(dialogTool);
QString formula = dialogTool->getFormula();
qint64 firstPointId = dialogTool->getFirstPointId();
qint64 secondPointId = dialogTool->getSecondPointId();
qint64 thirdPointId = dialogTool->getThirdPointId();
QString typeLine = dialogTool->getTypeLine();
QString pointName = dialogTool->getPointName();
Create(0, formula, firstPointId, secondPointId, thirdPointId, typeLine, pointName, 5, 10, scene, doc, data,
Document::FullParse, Tool::FromGui);
}
@ -157,26 +162,6 @@ void VToolBisector::FullUpdateFromFile()
RefreshGeometry();
}
void VToolBisector::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, dialogBisector->getPointName());
SetAttribute(domElement, AttrTypeLine, dialogBisector->getTypeLine());
SetAttribute(domElement, AttrLength, dialogBisector->getFormula());
SetAttribute(domElement, AttrFirstPoint, QString().setNum(dialogBisector->getFirstPointId()));
SetAttribute(domElement, AttrSecondPoint, QString().setNum(dialogBisector->getSecondPointId()));
SetAttribute(domElement, AttrThirdPoint, QString().setNum(dialogBisector->getThirdPointId()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogBisector.clear();
}
void VToolBisector::SetFactor(qreal factor)
{
VDrawTool::SetFactor(factor);
@ -185,12 +170,12 @@ void VToolBisector::SetFactor(qreal factor)
void VToolBisector::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogBisector, this, event);
ContextMenu<DialogBisector>(this, event);
}
void VToolBisector::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogBisector, this, event);
ContextMenu<DialogBisector>(this, event);
}
void VToolBisector::AddToFile()
@ -236,3 +221,16 @@ void VToolBisector::RemoveReferens()
doc->DecrementReferens(thirdPointId);
VToolLinePoint::RemoveReferens();
}
void VToolBisector::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogBisector *dialogTool = qobject_cast<DialogBisector*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrName, dialogTool->getPointName());
SetAttribute(domElement, AttrTypeLine, dialogTool->getTypeLine());
SetAttribute(domElement, AttrLength, dialogTool->getFormula());
SetAttribute(domElement, AttrFirstPoint, QString().setNum(dialogTool->getFirstPointId()));
SetAttribute(domElement, AttrSecondPoint, QString().setNum(dialogTool->getSecondPointId()));
SetAttribute(domElement, AttrThirdPoint, QString().setNum(dialogTool->getThirdPointId()));
}

17
src/tools/drawTools/vtoolbisector.h
View file

@ -30,7 +30,6 @@
#define VTOOLBISECTOR_H
#include "vtoollinepoint.h"
#include "../../dialogs/dialogbisector.h"
/**
* @brief The VToolBisector class tool for creation bisector point.
@ -76,8 +75,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogBisector> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -106,11 +104,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief SetFactor set current scale factor of scene.
* @param factor scene scale factor.
@ -139,6 +132,10 @@ protected:
* @brief RemoveReferens decrement value of reference.
*/
virtual void RemoveReferens();
/**
* @brief SaveDialog save options into file after change in dialog.
*/
virtual void SaveDialog(QDomElement &domElement);
private:
/**
* @brief firstPointId id first point of angle.
@ -148,10 +145,6 @@ private:
* @brief thirdPointId id third point of angle.
*/
qint64 thirdPointId;
/**
* @brief dialogBisector dialog.
*/
QSharedPointer<DialogBisector> dialogBisector;
};
#endif // VTOOLBISECTOR_H

57
src/tools/drawTools/vtoolcutarc.cpp
View file

@ -28,6 +28,7 @@
#include "vtoolcutarc.h"
#include "../../container/calculator.h"
#include "../../dialogs/dialogcutarc.h"
const QString VToolCutArc::ToolType = QStringLiteral("cutArc");
const QString VToolCutArc::AttrArc = QStringLiteral("arc");
@ -35,8 +36,8 @@ const QString VToolCutArc::AttrArc = QStringLiteral("arc");
VToolCutArc::VToolCutArc(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &formula,
const qint64 &arcId, const qint64 &arc1id, const qint64 &arc2id,
const Tool::Sources &typeCreation, QGraphicsItem * parent)
:VToolPoint(doc, data, id, parent), formula(formula), arcId(arcId),
dialogCutArc(QSharedPointer<DialogCutArc>()), firstArc(), secondArc(), arc1id(arc1id), arc2id(arc2id)
:VToolPoint(doc, data, id, parent), formula(formula), arcId(arcId), firstArc(), secondArc(), arc1id(arc1id),
arc2id(arc2id)
{
Q_ASSERT_X(arcId > 0, Q_FUNC_INFO, "arcId <= 0");
Q_ASSERT_X(arc1id > 0, Q_FUNC_INFO, "arc1id <= 0");
@ -66,19 +67,24 @@ VToolCutArc::VToolCutArc(VDomDocument *doc, VContainer *data, const qint64 &id,
void VToolCutArc::setDialog()
{
Q_ASSERT(dialogCutArc.isNull() == false);
Q_CHECK_PTR(dialog);
DialogCutArc *dialogTool = qobject_cast<DialogCutArc*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogCutArc->setFormula(formula);
dialogCutArc->setArcId(arcId, id);
dialogCutArc->setPointName(point->name());
dialogTool->setFormula(formula);
dialogTool->setArcId(arcId, id);
dialogTool->setPointName(point->name());
}
void VToolCutArc::Create(QSharedPointer<DialogCutArc> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
void VToolCutArc::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data)
{
QString pointName = dialog->getPointName();
QString formula = dialog->getFormula();
qint64 arcId = dialog->getArcId();
Q_CHECK_PTR(dialog);
DialogCutArc *dialogTool = qobject_cast<DialogCutArc*>(dialog);
Q_CHECK_PTR(dialogTool);
QString pointName = dialogTool->getPointName();
QString formula = dialogTool->getFormula();
qint64 arcId = dialogTool->getArcId();
Create(0, pointName, formula, arcId, 5, 10, scene, doc, data, Document::FullParse, Tool::FromGui);
}
@ -164,23 +170,6 @@ void VToolCutArc::FullUpdateFromFile()
RefreshGeometry();
}
void VToolCutArc::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, dialogCutArc->getPointName());
SetAttribute(domElement, AttrLength, dialogCutArc->getFormula());
SetAttribute(domElement, AttrArc, QString().setNum(dialogCutArc->getArcId()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogCutArc.clear();
}
void VToolCutArc::ArcChoosed(qint64 id)
{
emit ChoosedTool(id, Scene::Arc);
@ -211,12 +200,12 @@ void VToolCutArc::ChangedActivDraw(const QString &newName)
void VToolCutArc::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogCutArc, this, event);
ContextMenu<DialogCutArc>(this, event);
}
void VToolCutArc::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogCutArc, this, event);
ContextMenu<DialogCutArc>(this, event);
}
void VToolCutArc::AddToFile()
@ -257,6 +246,16 @@ void VToolCutArc::RefreshGeometry()
VToolPoint::RefreshPointGeometry(*VDrawTool::data.GeometricObject<const VPointF *>(id));
}
void VToolCutArc::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogCutArc *dialogTool = qobject_cast<DialogCutArc*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrName, dialogTool->getPointName());
SetAttribute(domElement, AttrLength, dialogTool->getFormula());
SetAttribute(domElement, AttrArc, QString().setNum(dialogTool->getArcId()));
}
void VToolCutArc::RefreshArc(VSimpleArc *sArc, qint64 arcid, SimpleArc::Translation tr)
{
const VArc *arc = VAbstractTool::data.GeometricObject<const VArc *>(arcid);

35
src/tools/drawTools/vtoolcutarc.h
View file

@ -30,7 +30,6 @@
#define VTOOLCUTARC_H
#include "vtoolpoint.h"
#include "../../dialogs/dialogcutarc.h"
#include "../../widgets/vsimplearc.h"
/**
@ -66,8 +65,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogCutArc> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -92,26 +90,21 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief ArcChoosed send signal about selection from cutted arc.
* @param id object id in container.
*/
void ArcChoosed(qint64 id);
void ArcChoosed(qint64 id);
/**
* @brief ChangedActivDraw disable or enable context menu after change active pattern peace.
* @param newName new name active pattern peace.
*/
virtual void ChangedActivDraw(const QString &newName);
virtual void ChangedActivDraw(const QString &newName);
/**
* @brief ShowContextMenu show context menu.
* @param event context menu event.
*/
virtual void ShowContextMenu(QGraphicsSceneContextMenuEvent *event);
virtual void ShowContextMenu(QGraphicsSceneContextMenuEvent *event);
protected:
/**
* @brief contextMenuEvent handle context menu events.
@ -129,29 +122,29 @@ protected:
/**
* @brief RefreshGeometry refresh item on scene.
*/
void RefreshGeometry();
void RefreshGeometry();
/**
* @brief SaveDialog save options into file after change in dialog.
*/
virtual void SaveDialog(QDomElement &domElement);
private:
Q_DISABLE_COPY(VToolCutArc)
/**
* @brief formula keep formula of length
*/
QString formula;
QString formula;
/**
* @brief arcId keep id of arc
*/
qint64 arcId;
/**
* @brief DialogCutSpline pointer to the tool's dialog
*/
QSharedPointer<DialogCutArc> dialogCutArc;
qint64 arcId;
/**
* @brief firstArc first arc after cutting.
*/
VSimpleArc *firstArc;
VSimpleArc *firstArc;
/**
* @brief secondArc second arc after cutting.
*/
VSimpleArc *secondArc;
VSimpleArc *secondArc;
/**
* @brief arc1id id first arc after cutting.
*/
@ -166,7 +159,7 @@ private:
* @param arcid arc id.
* @param tr arc type.
*/
void RefreshArc(VSimpleArc *sArc, qint64 arcid, SimpleArc::Translation tr);
void RefreshArc(VSimpleArc *sArc, qint64 arcid, SimpleArc::Translation tr);
};
#endif // VTOOLCUTARC_H

57
src/tools/drawTools/vtoolcutspline.cpp
View file

@ -28,6 +28,7 @@
#include "vtoolcutspline.h"
#include "../../container/calculator.h"
#include "../../dialogs/dialogcutspline.h"
const QString VToolCutSpline::ToolType = QStringLiteral("cutSpline");
const QString VToolCutSpline::AttrSpline = QStringLiteral("spline");
@ -35,8 +36,8 @@ const QString VToolCutSpline::AttrSpline = QStringLiteral("spline");
VToolCutSpline::VToolCutSpline(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &formula,
const qint64 &splineId, const qint64 &spl1id, const qint64 &spl2id,
const Tool::Sources &typeCreation, QGraphicsItem *parent)
:VToolPoint(doc, data, id, parent), formula(formula), splineId(splineId),
dialogCutSpline(QSharedPointer<DialogCutSpline>()), firstSpline(), secondSpline(), spl1id(spl1id), spl2id(spl2id)
:VToolPoint(doc, data, id, parent), formula(formula), splineId(splineId), firstSpline(), secondSpline(),
spl1id(spl1id), spl2id(spl2id)
{
Q_ASSERT_X(splineId > 0, Q_FUNC_INFO, "splineId <= 0");
Q_ASSERT_X(spl1id > 0, Q_FUNC_INFO, "spl1id <= 0");
@ -66,19 +67,24 @@ VToolCutSpline::VToolCutSpline(VDomDocument *doc, VContainer *data, const qint64
void VToolCutSpline::setDialog()
{
Q_ASSERT(dialogCutSpline.isNull() == false);
Q_CHECK_PTR(dialog);
DialogCutSpline *dialogTool = qobject_cast<DialogCutSpline*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogCutSpline->setFormula(formula);
dialogCutSpline->setSplineId(splineId, id);
dialogCutSpline->setPointName(point->name());
dialogTool->setFormula(formula);
dialogTool->setSplineId(splineId, id);
dialogTool->setPointName(point->name());
}
void VToolCutSpline::Create(QSharedPointer<DialogCutSpline> &dialog, VMainGraphicsScene *scene,
void VToolCutSpline::Create(DialogTool *dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data)
{
QString pointName = dialog->getPointName();
QString formula = dialog->getFormula();
qint64 splineId = dialog->getSplineId();
Q_CHECK_PTR(dialog);
DialogCutSpline *dialogTool = qobject_cast<DialogCutSpline*>(dialog);
Q_CHECK_PTR(dialogTool);
QString pointName = dialogTool->getPointName();
QString formula = dialogTool->getFormula();
qint64 splineId = dialogTool->getSplineId();
Create(0, pointName, formula, splineId, 5, 10, scene, doc, data, Document::FullParse, Tool::FromGui);
}
@ -165,23 +171,6 @@ void VToolCutSpline::FullUpdateFromFile()
RefreshGeometry();
}
void VToolCutSpline::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, dialogCutSpline->getPointName());
SetAttribute(domElement, AttrLength, dialogCutSpline->getFormula());
SetAttribute(domElement, AttrSpline, QString().setNum(dialogCutSpline->getSplineId()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogCutSpline.clear();
}
void VToolCutSpline::SplineChoosed(qint64 id)
{
emit ChoosedTool(id, Scene::Spline);
@ -212,12 +201,12 @@ void VToolCutSpline::ChangedActivDraw(const QString &newName)
void VToolCutSpline::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogCutSpline, this, event);
ContextMenu<DialogCutSpline>(this, event);
}
void VToolCutSpline::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogCutSpline, this, event);
ContextMenu<DialogCutSpline>(this, event);
}
void VToolCutSpline::AddToFile()
@ -263,6 +252,16 @@ void VToolCutSpline::RemoveReferens()
doc->DecrementReferens(splineId);
}
void VToolCutSpline::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogCutSpline *dialogTool = qobject_cast<DialogCutSpline*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrName, dialogTool->getPointName());
SetAttribute(domElement, AttrLength, dialogTool->getFormula());
SetAttribute(domElement, AttrSpline, QString().setNum(dialogTool->getSplineId()));
}
void VToolCutSpline::RefreshSpline(VSimpleSpline *spline, qint64 splid, SimpleSpline::Translation tr)
{
const VSpline *spl = VAbstractTool::data.GeometricObject<const VSpline *>(splid);

45
src/tools/drawTools/vtoolcutspline.h
View file

@ -30,7 +30,6 @@
#define VTOOLCUTSPLINE_H
#include "vtoolpoint.h"
#include "../../dialogs/dialogcutspline.h"
#include "../../widgets/vsimplespline.h"
/**
@ -64,8 +63,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogCutSpline> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -90,63 +88,58 @@ public slots:
/**
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result
*/
virtual void FullUpdateFromGui(int result);
virtual void FullUpdateFromFile();
/**
* @brief SplineChoosed send signal about selection from spline.
* @param id object id in container.
*/
void SplineChoosed(qint64 id);
void SplineChoosed(qint64 id);
/**
* @brief ChangedActivDraw disable or enable context menu after change active pattern peace.
* @param newName new name active pattern peace.
*/
virtual void ChangedActivDraw(const QString &newName);
virtual void ChangedActivDraw(const QString &newName);
/**
* @brief ShowContextMenu show context menu.
* @param event context menu event.
*/
virtual void ShowContextMenu(QGraphicsSceneContextMenuEvent *event);
virtual void ShowContextMenu(QGraphicsSceneContextMenuEvent *event);
protected:
/**
* @brief contextMenuEvent handle context menu events.
* @param event context menu event.
*/
virtual void contextMenuEvent ( QGraphicsSceneContextMenuEvent * event );
virtual void contextMenuEvent ( QGraphicsSceneContextMenuEvent * event );
/**
* @brief AddToFile add tag with informations about tool into file.
*/
virtual void AddToFile();
virtual void AddToFile();
/**
* @brief RefreshDataInFile refresh attributes in file. If attributes don't exist create them.
*/
virtual void RefreshDataInFile();
virtual void RefreshDataInFile();
/**
* @brief RefreshGeometry refresh item on scene.
*/
void RefreshGeometry();
void RefreshGeometry();
/**
* @brief RemoveReferens decrement referens value for used objects.
*/
virtual void RemoveReferens();
virtual void RemoveReferens();
/**
* @brief SaveDialog save options into file after change in dialog.
*/
virtual void SaveDialog(QDomElement &domElement);
private:
Q_DISABLE_COPY(VToolCutSpline)
/**
* @brief formula keep formula of length.
*/
QString formula;
QString formula;
/**
* @brief splineId keep id of spline.
*/
qint64 splineId;
/**
* @brief DialogCutSpline pointer to the tool's dialog.
*/
QSharedPointer<DialogCutSpline> dialogCutSpline;
qint64 splineId;
/**
* @brief firstSpline first spline after cutting.
*/
@ -158,18 +151,18 @@ private:
/**
* @brief spl1id id first spline after cutting.
*/
const qint64 spl1id;
const qint64 spl1id;
/**
* @brief spl2id id second spline after cutting.
*/
const qint64 spl2id;
const qint64 spl2id;
/**
* @brief RefreshSpline refresh spline on scene.
* @param spline spline.
* @param splid spline id.
* @param tr spline type.
*/
void RefreshSpline(VSimpleSpline *spline, qint64 splid, SimpleSpline::Translation tr);
void RefreshSpline(VSimpleSpline *spline, qint64 splid, SimpleSpline::Translation tr);
};
#endif // VTOOLCUTSPLINE_H

57
src/tools/drawTools/vtoolcutsplinepath.cpp
View file

@ -28,6 +28,7 @@
#include "vtoolcutsplinepath.h"
#include "../../container/calculator.h"
#include "../../dialogs/dialogcutsplinepath.h"
const QString VToolCutSplinePath::ToolType = QStringLiteral("cutSplinePath");
const QString VToolCutSplinePath::AttrSplinePath = QStringLiteral("splinePath");
@ -36,8 +37,7 @@ VToolCutSplinePath::VToolCutSplinePath(VDomDocument *doc, VContainer *data, cons
const QString &formula, const qint64 &splinePathId,
const qint64 &splPath1id, const qint64 &splPath2id,
const Tool::Sources &typeCreation, QGraphicsItem *parent)
:VToolPoint(doc, data, id, parent), formula(formula), splinePathId(splinePathId),
dialogCutSplinePath(QSharedPointer<DialogCutSplinePath>()), firstSpline(), secondSpline(),
:VToolPoint(doc, data, id, parent), formula(formula), splinePathId(splinePathId), firstSpline(), secondSpline(),
splPath1id (splPath1id), splPath2id(splPath2id)
{
Q_ASSERT_X(splinePathId > 0, Q_FUNC_INFO, "splinePathId <= 0");
@ -68,19 +68,23 @@ VToolCutSplinePath::VToolCutSplinePath(VDomDocument *doc, VContainer *data, cons
void VToolCutSplinePath::setDialog()
{
Q_ASSERT(dialogCutSplinePath.isNull() == false);
Q_CHECK_PTR(dialog);
DialogCutSplinePath *dialogTool = qobject_cast<DialogCutSplinePath*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *point = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogCutSplinePath->setFormula(formula);
dialogCutSplinePath->setSplinePathId(splinePathId, id);
dialogCutSplinePath->setPointName(point->name());
dialogTool->setFormula(formula);
dialogTool->setSplinePathId(splinePathId, id);
dialogTool->setPointName(point->name());
}
void VToolCutSplinePath::Create(QSharedPointer<DialogCutSplinePath> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data)
void VToolCutSplinePath::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data)
{
QString pointName = dialog->getPointName();
QString formula = dialog->getFormula();
qint64 splinePathId = dialog->getSplinePathId();
Q_CHECK_PTR(dialog);
DialogCutSplinePath *dialogTool = qobject_cast<DialogCutSplinePath*>(dialog);
Q_CHECK_PTR(dialogTool);
QString pointName = dialogTool->getPointName();
QString formula = dialogTool->getFormula();
qint64 splinePathId = dialogTool->getSplinePathId();
Create(0, pointName, formula, splinePathId, 5, 10, scene, doc, data, Document::FullParse, Tool::FromGui);
}
@ -242,23 +246,6 @@ void VToolCutSplinePath::FullUpdateFromFile()
RefreshGeometry();
}
void VToolCutSplinePath::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, dialogCutSplinePath->getPointName());
SetAttribute(domElement, AttrLength, dialogCutSplinePath->getFormula());
SetAttribute(domElement, AttrSplinePath, QString().setNum(dialogCutSplinePath->getSplinePathId()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogCutSplinePath.clear();
}
void VToolCutSplinePath::SplineChoosed(qint64 id)
{
emit ChoosedTool(id, Scene::SplinePath);
@ -289,12 +276,12 @@ void VToolCutSplinePath::ChangedActivDraw(const QString &newName)
void VToolCutSplinePath::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogCutSplinePath, this, event);
ContextMenu<DialogCutSplinePath>(this, event);
}
void VToolCutSplinePath::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogCutSplinePath, this, event);
ContextMenu<DialogCutSplinePath>(this, event);
}
void VToolCutSplinePath::AddToFile()
@ -340,6 +327,16 @@ void VToolCutSplinePath::RemoveReferens()
doc->DecrementReferens(splinePathId);
}
void VToolCutSplinePath::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogCutSplinePath *dialogTool = qobject_cast<DialogCutSplinePath*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrName, dialogTool->getPointName());
SetAttribute(domElement, AttrLength, dialogTool->getFormula());
SetAttribute(domElement, AttrSplinePath, QString().setNum(dialogTool->getSplinePathId()));
}
void VToolCutSplinePath::RefreshSpline(VSimpleSpline *spline, qint64 splPathid, SimpleSpline::Translation tr)
{
const VSplinePath *splPath = VAbstractTool::data.GeometricObject<const VSplinePath *>(splPathid);

45
src/tools/drawTools/vtoolcutsplinepath.h
View file

@ -30,7 +30,6 @@
#define VTOOLCUTSPLINEPATH_H
#include "vtoolpoint.h"
#include "../../dialogs/dialogcutsplinepath.h"
#include "../../widgets/vsimplespline.h"
/**
@ -67,8 +66,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogCutSplinePath> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -93,63 +91,58 @@ public slots:
/**
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
virtual void FullUpdateFromFile();
/**
* @brief SplineChoosed send signal about selection splinePath.
* @param id object id in container.
*/
void SplineChoosed(qint64 id);
void SplineChoosed(qint64 id);
/**
* @brief ChangedActivDraw disable or enable context menu after change active pattern peace.
* @param newName new name active pattern peace.
*/
virtual void ChangedActivDraw(const QString &newName);
virtual void ChangedActivDraw(const QString &newName);
/**
* @brief ShowContextMenu show context menu.
* @param event context menu event.
*/
virtual void ShowContextMenu(QGraphicsSceneContextMenuEvent *event);
virtual void ShowContextMenu(QGraphicsSceneContextMenuEvent *event);
protected:
/**
* @brief contextMenuEvent handle context menu events.
* @param event context menu event.
*/
virtual void contextMenuEvent ( QGraphicsSceneContextMenuEvent * event );
virtual void contextMenuEvent ( QGraphicsSceneContextMenuEvent * event );
/**
* @brief AddToFile add tag with informations about tool into file.
*/
virtual void AddToFile();
virtual void AddToFile();
/**
* @brief RefreshDataInFile refresh attributes in file. If attributes don't exist create them.
*/
virtual void RefreshDataInFile();
virtual void RefreshDataInFile();
/**
* @brief RefreshGeometry refresh item on scene.
*/
void RefreshGeometry();
void RefreshGeometry();
/**
* @brief RemoveReferens decrement referens value for used objects.
*/
virtual void RemoveReferens();
virtual void RemoveReferens();
/**
* @brief SaveDialog save options into file after change in dialog.
*/
virtual void SaveDialog(QDomElement &domElement);
private:
Q_DISABLE_COPY(VToolCutSplinePath)
/**
* @brief formula keep formula of length
*/
QString formula;
QString formula;
/**
* @brief splineId keep id of spline.
*/
qint64 splinePathId;
/**
* @brief DialogCutSpline pointer to the tool's dialog.
*/
QSharedPointer<DialogCutSplinePath> dialogCutSplinePath;
qint64 splinePathId;
/**
* @brief firstSpline first splinePath after cutting.
*/
@ -161,18 +154,18 @@ private:
/**
* @brief splPath1id id first splinePath after cutting.
*/
const qint64 splPath1id;
const qint64 splPath1id;
/**
* @brief splPath2id id second splinePath after cutting.
*/
const qint64 splPath2id;
const qint64 splPath2id;
/**
* @brief RefreshSpline refresh splinePath on scene.
* @param spline splinePath.
* @param splPathid splinePath id.
* @param tr splineType type.
*/
void RefreshSpline(VSimpleSpline *spline, qint64 splPathid, SimpleSpline::Translation tr);
void RefreshSpline(VSimpleSpline *spline, qint64 splPathid, SimpleSpline::Translation tr);
};
#endif // VTOOLCUTSPLINEPATH_H

68
src/tools/drawTools/vtoolendline.cpp
View file

@ -29,14 +29,14 @@
#include "vtoolendline.h"
#include "../../widgets/vmaingraphicsscene.h"
#include "../../container/calculator.h"
#include "../../dialogs/dialogendline.h"
const QString VToolEndLine::ToolType = QStringLiteral("endLine");
VToolEndLine::VToolEndLine(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &typeLine,
const QString &formula, const qreal &angle, const qint64 &basePointId,
const Tool::Sources &typeCreation, QGraphicsItem *parent)
:VToolLinePoint(doc, data, id, typeLine, formula, basePointId, angle, parent),
dialogEndLine(QSharedPointer<DialogEndLine>())
:VToolLinePoint(doc, data, id, typeLine, formula, basePointId, angle, parent)
{
if (typeCreation == Tool::FromGui)
@ -51,23 +51,28 @@ VToolEndLine::VToolEndLine(VDomDocument *doc, VContainer *data, const qint64 &id
void VToolEndLine::setDialog()
{
Q_ASSERT(dialogEndLine.isNull() == false);
Q_CHECK_PTR(dialog);
DialogEndLine *dialogTool = qobject_cast<DialogEndLine*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogEndLine->setTypeLine(typeLine);
dialogEndLine->setFormula(formula);
dialogEndLine->setAngle(angle);
dialogEndLine->setBasePointId(basePointId, id);
dialogEndLine->setPointName(p->name());
dialogTool->setTypeLine(typeLine);
dialogTool->setFormula(formula);
dialogTool->setAngle(angle);
dialogTool->setBasePointId(basePointId, id);
dialogTool->setPointName(p->name());
}
void VToolEndLine::Create(QSharedPointer<DialogEndLine> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
void VToolEndLine::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data)
{
QString pointName = dialog->getPointName();
QString typeLine = dialog->getTypeLine();
QString formula = dialog->getFormula();
qreal angle = dialog->getAngle();
qint64 basePointId = dialog->getBasePointId();
Q_CHECK_PTR(dialog);
DialogEndLine *dialogTool = qobject_cast<DialogEndLine*>(dialog);
Q_CHECK_PTR(dialogTool);
QString pointName = dialogTool->getPointName();
QString typeLine = dialogTool->getTypeLine();
QString formula = dialogTool->getFormula();
qreal angle = dialogTool->getAngle();
qint64 basePointId = dialogTool->getBasePointId();
Create(0, pointName, typeLine, formula, angle, basePointId, 5, 10, scene, doc, data, Document::FullParse,
Tool::FromGui);
}
@ -130,31 +135,12 @@ void VToolEndLine::FullUpdateFromFile()
void VToolEndLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogEndLine, this, event);
}
void VToolEndLine::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, dialogEndLine->getPointName());
SetAttribute(domElement, AttrTypeLine, dialogEndLine->getTypeLine());
SetAttribute(domElement, AttrLength, dialogEndLine->getFormula());
SetAttribute(domElement, AttrAngle, QString().setNum(dialogEndLine->getAngle()));
SetAttribute(domElement, AttrBasePoint, QString().setNum(dialogEndLine->getBasePointId()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogEndLine.clear();
ContextMenu<DialogEndLine>(this, event);
}
void VToolEndLine::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogEndLine, this, event);
ContextMenu<DialogEndLine>(this, event);
}
void VToolEndLine::AddToFile()
@ -191,3 +177,15 @@ void VToolEndLine::RefreshDataInFile()
SetAttribute(domElement, AttrBasePoint, basePointId);
}
}
void VToolEndLine::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogEndLine *dialogTool = qobject_cast<DialogEndLine*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrName, dialogTool->getPointName());
SetAttribute(domElement, AttrTypeLine, dialogTool->getTypeLine());
SetAttribute(domElement, AttrLength, dialogTool->getFormula());
SetAttribute(domElement, AttrAngle, QString().setNum(dialogTool->getAngle()));
SetAttribute(domElement, AttrBasePoint, QString().setNum(dialogTool->getBasePointId()));
}

14
src/tools/drawTools/vtoolendline.h
View file

@ -30,7 +30,6 @@
#define VTOOLENDLINE_H
#include "vtoollinepoint.h"
#include "../../dialogs/dialogendline.h"
/**
* @brief The VToolEndLine class tool for creation point on the line end.
@ -65,8 +64,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogEndLine> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -93,11 +91,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief ShowContextMenu show context menu.
* @param event context menu event.
@ -117,11 +110,10 @@ protected:
* @brief RefreshDataInFile refresh attributes in file. If attributes don't exist create them.
*/
virtual void RefreshDataInFile();
private:
/**
* @brief dialogEndLine pointer to the dialog.
* @brief SaveDialog save options into file after change in dialog.
*/
QSharedPointer<DialogEndLine> dialogEndLine;
virtual void SaveDialog(QDomElement &domElement);
};
#endif // VTOOLENDLINE_H

70
src/tools/drawTools/vtoolheight.cpp
View file

@ -27,14 +27,14 @@
*************************************************************************/
#include "vtoolheight.h"
#include "../../dialogs/dialogheight.h"
const QString VToolHeight::ToolType = QStringLiteral("height");
VToolHeight::VToolHeight(VDomDocument *doc, VContainer *data, const qint64 &id, const QString &typeLine,
const qint64 &basePointId, const qint64 &p1LineId, const qint64 &p2LineId,
const Tool::Sources &typeCreation, QGraphicsItem * parent)
:VToolLinePoint(doc, data, id, typeLine, QString(), basePointId, 0, parent),
dialogHeight(QSharedPointer<DialogHeight>()), p1LineId(p1LineId), p2LineId(p2LineId)
:VToolLinePoint(doc, data, id, typeLine, QString(), basePointId, 0, parent), p1LineId(p1LineId), p2LineId(p2LineId)
{
ignoreFullUpdate = true;
if (typeCreation == Tool::FromGui)
@ -49,24 +49,29 @@ VToolHeight::VToolHeight(VDomDocument *doc, VContainer *data, const qint64 &id,
void VToolHeight::setDialog()
{
Q_ASSERT(dialogHeight.isNull() == false);
Q_CHECK_PTR(dialog);
DialogHeight *dialogTool = qobject_cast<DialogHeight*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogHeight->setTypeLine(typeLine);
dialogHeight->setBasePointId(basePointId, id);
dialogHeight->setP1LineId(p1LineId, id);
dialogHeight->setP2LineId(p2LineId, id);
dialogHeight->setPointName(p->name());
dialogTool->setTypeLine(typeLine);
dialogTool->setBasePointId(basePointId, id);
dialogTool->setP1LineId(p1LineId, id);
dialogTool->setP2LineId(p2LineId, id);
dialogTool->setPointName(p->name());
}
void VToolHeight::Create(QSharedPointer<DialogHeight> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
void VToolHeight::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data)
{
disconnect(doc, &VDomDocument::FullUpdateFromFile, dialog.data(), &DialogHeight::UpdateList);
QString pointName = dialog->getPointName();
QString typeLine = dialog->getTypeLine();
qint64 basePointId = dialog->getBasePointId();
qint64 p1LineId = dialog->getP1LineId();
qint64 p2LineId = dialog->getP2LineId();
Q_CHECK_PTR(dialog);
DialogHeight *dialogTool = qobject_cast<DialogHeight*>(dialog);
Q_CHECK_PTR(dialogTool);
disconnect(doc, &VDomDocument::FullUpdateFromFile, dialogTool, &DialogHeight::UpdateList);
QString pointName = dialogTool->getPointName();
QString typeLine = dialogTool->getTypeLine();
qint64 basePointId = dialogTool->getBasePointId();
qint64 p1LineId = dialogTool->getP1LineId();
qint64 p2LineId = dialogTool->getP2LineId();
Create(0, pointName, typeLine, basePointId, p1LineId, p2LineId, 5, 10, scene, doc, data,
Document::FullParse, Tool::FromGui);
}
@ -134,33 +139,14 @@ void VToolHeight::FullUpdateFromFile()
}
void VToolHeight::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, dialogHeight->getPointName());
SetAttribute(domElement, AttrTypeLine, dialogHeight->getTypeLine());
SetAttribute(domElement, AttrBasePoint, QString().setNum(dialogHeight->getBasePointId()));
SetAttribute(domElement, AttrP1Line, QString().setNum(dialogHeight->getP1LineId()));
SetAttribute(domElement, AttrP2Line, QString().setNum(dialogHeight->getP2LineId()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogHeight.clear();
}
void VToolHeight::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogHeight, this, event);
ContextMenu<DialogHeight>(this, event);
}
void VToolHeight::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogHeight, this, event);
ContextMenu<DialogHeight>(this, event);
}
void VToolHeight::AddToFile()
@ -198,3 +184,15 @@ void VToolHeight::RefreshDataInFile()
SetAttribute(domElement, AttrP2Line, p2LineId);
}
}
void VToolHeight::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogHeight *dialogTool = qobject_cast<DialogHeight*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrName, dialogTool->getPointName());
SetAttribute(domElement, AttrTypeLine, dialogTool->getTypeLine());
SetAttribute(domElement, AttrBasePoint, QString().setNum(dialogTool->getBasePointId()));
SetAttribute(domElement, AttrP1Line, QString().setNum(dialogTool->getP1LineId()));
SetAttribute(domElement, AttrP2Line, QString().setNum(dialogTool->getP2LineId()));
}

17
src/tools/drawTools/vtoolheight.h
View file

@ -30,7 +30,6 @@
#define VTOOLHEIGHT_H
#include "vtoollinepoint.h"
#include "../../dialogs/dialogheight.h"
/**
* @brief The VToolHeight class tool for creation point of height. Help find point of projection onto line.
@ -65,8 +64,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogHeight> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool
* @param _id tool id, 0 if tool doesn't exist yet.
@ -100,11 +98,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief ShowContextMenu show context menu.
* @param event context menu event.
@ -123,12 +116,12 @@ protected:
/**
* @brief RefreshDataInFile refresh attributes in file. If attributes don't exist create them.
*/
virtual void RefreshDataInFile();
private:
virtual void RefreshDataInFile();
/**
* @brief dialogHeight dialog.
* @brief SaveDialog save options into file after change in dialog.
*/
QSharedPointer<DialogHeight> dialogHeight;
virtual void SaveDialog(QDomElement &domElement);
private:
/**
* @brief p1LineId id first point of line.
*/

48
src/tools/drawTools/vtoolline.cpp
View file

@ -27,13 +27,13 @@
*************************************************************************/
#include "vtoolline.h"
#include "../../dialogs/dialogline.h"
const QString VToolLine::TagName = QStringLiteral("line");
VToolLine::VToolLine(VDomDocument *doc, VContainer *data, qint64 id, qint64 firstPoint, qint64 secondPoint,
const Tool::Sources &typeCreation, QGraphicsItem *parent)
:VDrawTool(doc, data, id), QGraphicsLineItem(parent), firstPoint(firstPoint), secondPoint(secondPoint),
dialogLine(QSharedPointer<DialogLine>())
:VDrawTool(doc, data, id), QGraphicsLineItem(parent), firstPoint(firstPoint), secondPoint(secondPoint)
{
ignoreFullUpdate = true;
//Line
@ -58,15 +58,20 @@ VToolLine::VToolLine(VDomDocument *doc, VContainer *data, qint64 id, qint64 firs
void VToolLine::setDialog()
{
dialogLine->setFirstPoint(firstPoint);
dialogLine->setSecondPoint(secondPoint);
Q_CHECK_PTR(dialog);
DialogLine *dialogTool = qobject_cast<DialogLine*>(dialog);
Q_CHECK_PTR(dialogTool);
dialogTool->setFirstPoint(firstPoint);
dialogTool->setSecondPoint(secondPoint);
}
void VToolLine::Create(QSharedPointer<DialogLine> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data)
void VToolLine::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data)
{
qint64 firstPoint = dialog->getFirstPoint();
qint64 secondPoint = dialog->getSecondPoint();
Q_CHECK_PTR(dialog);
DialogLine *dialogTool = qobject_cast<DialogLine*>(dialog);
Q_CHECK_PTR(dialogTool);
qint64 firstPoint = dialogTool->getFirstPoint();
qint64 secondPoint = dialogTool->getSecondPoint();
Create(0, firstPoint, secondPoint, scene, doc, data, Document::FullParse, Tool::FromGui);
}
@ -111,22 +116,6 @@ void VToolLine::FullUpdateFromFile()
RefreshGeometry();
}
void VToolLine::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrFirstPoint, QString().setNum(dialogLine->getFirstPoint()));
SetAttribute(domElement, AttrSecondPoint, QString().setNum(dialogLine->getSecondPoint()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogLine.clear();
}
void VToolLine::ShowTool(qint64 id, Qt::GlobalColor color, bool enable)
{
ShowItem(this, id, color, enable);
@ -158,7 +147,7 @@ void VToolLine::ChangedActivDraw(const QString &newName)
void VToolLine::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogLine, this, event);
ContextMenu<DialogLine>(this, event);
}
void VToolLine::AddToFile()
@ -230,6 +219,15 @@ void VToolLine::keyReleaseEvent(QKeyEvent *event)
QGraphicsItem::keyReleaseEvent ( event );
}
void VToolLine::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogLine *dialogTool = qobject_cast<DialogLine*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrFirstPoint, QString().setNum(dialogTool->getFirstPoint()));
SetAttribute(domElement, AttrSecondPoint, QString().setNum(dialogTool->getSecondPoint()));
}
void VToolLine::RefreshGeometry()
{
QDomElement domElement = doc->elementById(QString().setNum(id));

16
src/tools/drawTools/vtoolline.h
View file

@ -63,8 +63,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogLine> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -90,11 +89,6 @@ public slots:
* @param newName new name active pattern peace.
*/
virtual void ChangedActivDraw(const QString &newName);
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief ShowTool highlight tool.
* @param id object id in container
@ -147,6 +141,10 @@ protected:
* @param event key realse event.
*/
virtual void keyReleaseEvent(QKeyEvent * event);
/**
* @brief SaveDialog save options into file after change in dialog.
*/
virtual void SaveDialog(QDomElement &domElement);
private:
/**
* @brief firstPoint id first line point.
@ -156,10 +154,6 @@ private:
* @brief secondPoint id second line point.
*/
qint64 secondPoint;
/**
* @brief dialogLine dialog.
*/
QSharedPointer<DialogLine> dialogLine;
/**
* @brief RefreshGeometry refresh item on scene.
*/

68
src/tools/drawTools/vtoollineintersect.cpp
View file

@ -27,6 +27,7 @@
*************************************************************************/
#include "vtoollineintersect.h"
#include "../../dialogs/dialoglineintersect.h"
const QString VToolLineIntersect::ToolType = QStringLiteral("lineIntersect");
@ -35,7 +36,7 @@ VToolLineIntersect::VToolLineIntersect(VDomDocument *doc, VContainer *data, cons
const qint64 &p2Line2, const Tool::Sources &typeCreation,
QGraphicsItem *parent)
:VToolPoint(doc, data, id, parent), p1Line1(p1Line1), p2Line1(p2Line1), p1Line2(p1Line2),
p2Line2(p2Line2), dialogLineIntersect(QSharedPointer<DialogLineIntersect>())
p2Line2(p2Line2)
{
ignoreFullUpdate = true;
if (typeCreation == Tool::FromGui)
@ -50,23 +51,27 @@ VToolLineIntersect::VToolLineIntersect(VDomDocument *doc, VContainer *data, cons
void VToolLineIntersect::setDialog()
{
Q_ASSERT(dialogLineIntersect.isNull() == false);
Q_CHECK_PTR(dialog);
DialogLineIntersect *dialogTool = qobject_cast<DialogLineIntersect*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogLineIntersect->setP1Line1(p1Line1);
dialogLineIntersect->setP2Line1(p2Line1);
dialogLineIntersect->setP1Line2(p1Line2);
dialogLineIntersect->setP2Line2(p2Line2);
dialogLineIntersect->setPointName(p->name());
dialogTool->setP1Line1(p1Line1);
dialogTool->setP2Line1(p2Line1);
dialogTool->setP1Line2(p1Line2);
dialogTool->setP2Line2(p2Line2);
dialogTool->setPointName(p->name());
}
void VToolLineIntersect::Create(QSharedPointer<DialogLineIntersect> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data)
void VToolLineIntersect::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data)
{
qint64 p1Line1Id = dialog->getP1Line1();
qint64 p2Line1Id = dialog->getP2Line1();
qint64 p1Line2Id = dialog->getP1Line2();
qint64 p2Line2Id = dialog->getP2Line2();
QString pointName = dialog->getPointName();
Q_CHECK_PTR(dialog);
DialogLineIntersect *dialogTool = qobject_cast<DialogLineIntersect*>(dialog);
Q_CHECK_PTR(dialogTool);
qint64 p1Line1Id = dialogTool->getP1Line1();
qint64 p2Line1Id = dialogTool->getP2Line1();
qint64 p1Line2Id = dialogTool->getP1Line2();
qint64 p2Line2Id = dialogTool->getP2Line2();
QString pointName = dialogTool->getPointName();
Create(0, p1Line1Id, p2Line1Id, p1Line2Id, p2Line2Id, pointName, 5, 10, scene, doc, data,
Document::FullParse, Tool::FromGui);
}
@ -139,25 +144,6 @@ void VToolLineIntersect::FullUpdateFromFile()
RefreshPointGeometry(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
}
void VToolLineIntersect::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, dialogLineIntersect->getPointName());
SetAttribute(domElement, AttrP1Line1, QString().setNum(dialogLineIntersect->getP1Line1()));
SetAttribute(domElement, AttrP2Line1, QString().setNum(dialogLineIntersect->getP2Line1()));
SetAttribute(domElement, AttrP1Line2, QString().setNum(dialogLineIntersect->getP1Line2()));
SetAttribute(domElement, AttrP2Line2, QString().setNum(dialogLineIntersect->getP2Line2()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogLineIntersect.clear();
}
void VToolLineIntersect::SetFactor(qreal factor)
{
VDrawTool::SetFactor(factor);
@ -166,12 +152,12 @@ void VToolLineIntersect::SetFactor(qreal factor)
void VToolLineIntersect::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogLineIntersect, this, event);
ContextMenu<DialogLineIntersect>(this, event);
}
void VToolLineIntersect::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogLineIntersect, this, event);
ContextMenu<DialogLineIntersect>(this, event);
}
void VToolLineIntersect::AddToFile()
@ -216,3 +202,15 @@ void VToolLineIntersect::RemoveReferens()
doc->DecrementReferens(p1Line2);
doc->DecrementReferens(p2Line2);
}
void VToolLineIntersect::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogLineIntersect *dialogTool = qobject_cast<DialogLineIntersect*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrName, dialogTool->getPointName());
SetAttribute(domElement, AttrP1Line1, QString().setNum(dialogTool->getP1Line1()));
SetAttribute(domElement, AttrP2Line1, QString().setNum(dialogTool->getP2Line1()));
SetAttribute(domElement, AttrP1Line2, QString().setNum(dialogTool->getP1Line2()));
SetAttribute(domElement, AttrP2Line2, QString().setNum(dialogTool->getP2Line2()));
}

17
src/tools/drawTools/vtoollineintersect.h
View file

@ -30,7 +30,6 @@
#define VTOOLLINEINTERSECT_H
#include "vtoolpoint.h"
#include "../../dialogs/dialoglineintersect.h"
/**
* @brief The VToolLineIntersect class help find point intersection lines.
@ -65,8 +64,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogLineIntersect> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -93,11 +91,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief SetFactor set current scale factor of scene.
* @param factor scene scale factor.
@ -126,6 +119,10 @@ protected:
* @brief RemoveReferens decrement value of reference.
*/
virtual void RemoveReferens();
/**
* @brief SaveDialog save options into file after change in dialog.
*/
virtual void SaveDialog(QDomElement &domElement);
private:
/**
* @brief p1Line1 id first point first line.
@ -143,10 +140,6 @@ private:
* @brief p2Line2 id second point second line.
*/
qint64 p2Line2;
/**
* @brief dialogLineIntersect dialog.
*/
QSharedPointer<DialogLineIntersect> dialogLineIntersect;
};
#endif // VTOOLLINEINTERSECT_H

74
src/tools/drawTools/vtoolnormal.cpp
View file

@ -28,6 +28,7 @@
#include "vtoolnormal.h"
#include "../../container/calculator.h"
#include "../../dialogs/dialognormal.h"
const QString VToolNormal::ToolType = QStringLiteral("normal");
@ -35,7 +36,7 @@ VToolNormal::VToolNormal(VDomDocument *doc, VContainer *data, const qint64 &id,
const QString &formula, const qreal &angle, const qint64 &firstPointId,
const qint64 &secondPointId, const Tool::Sources &typeCreation, QGraphicsItem *parent)
:VToolLinePoint(doc, data, id, typeLine, formula, firstPointId, angle, parent),
secondPointId(secondPointId), dialogNormal(QSharedPointer<DialogNormal>())
secondPointId(secondPointId)
{
if (typeCreation == Tool::FromGui)
@ -50,25 +51,29 @@ VToolNormal::VToolNormal(VDomDocument *doc, VContainer *data, const qint64 &id,
void VToolNormal::setDialog()
{
Q_ASSERT(dialogNormal.isNull() == false);
Q_CHECK_PTR(dialog);
DialogNormal *dialogTool = qobject_cast<DialogNormal*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogNormal->setTypeLine(typeLine);
dialogNormal->setFormula(formula);
dialogNormal->setAngle(angle);
dialogNormal->setFirstPointId(basePointId, id);
dialogNormal->setSecondPointId(secondPointId, id);
dialogNormal->setPointName(p->name());
dialogTool->setTypeLine(typeLine);
dialogTool->setFormula(formula);
dialogTool->setAngle(angle);
dialogTool->setFirstPointId(basePointId, id);
dialogTool->setSecondPointId(secondPointId, id);
dialogTool->setPointName(p->name());
}
void VToolNormal::Create(QSharedPointer<DialogNormal> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data)
void VToolNormal::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data)
{
QString formula = dialog->getFormula();
qint64 firstPointId = dialog->getFirstPointId();
qint64 secondPointId = dialog->getSecondPointId();
QString typeLine = dialog->getTypeLine();
QString pointName = dialog->getPointName();
qreal angle = dialog->getAngle();
Q_CHECK_PTR(dialog);
DialogNormal *dialogTool = qobject_cast<DialogNormal*>(dialog);
Q_CHECK_PTR(dialogTool);
QString formula = dialogTool->getFormula();
qint64 firstPointId = dialogTool->getFirstPointId();
qint64 secondPointId = dialogTool->getSecondPointId();
QString typeLine = dialogTool->getTypeLine();
QString pointName = dialogTool->getPointName();
qreal angle = dialogTool->getAngle();
Create(0, formula, firstPointId, secondPointId, typeLine, pointName, angle, 5, 10, scene, doc, data,
Document::FullParse, Tool::FromGui);
}
@ -142,26 +147,6 @@ void VToolNormal::FullUpdateFromFile()
RefreshGeometry();
}
void VToolNormal::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, dialogNormal->getPointName());
SetAttribute(domElement, AttrTypeLine, dialogNormal->getTypeLine());
SetAttribute(domElement, AttrLength, dialogNormal->getFormula());
SetAttribute(domElement, AttrAngle, QString().setNum(dialogNormal->getAngle()));
SetAttribute(domElement, AttrFirstPoint, QString().setNum(dialogNormal->getFirstPointId()));
SetAttribute(domElement, AttrSecondPoint, QString().setNum(dialogNormal->getSecondPointId()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogNormal.clear();
}
void VToolNormal::SetFactor(qreal factor)
{
VDrawTool::SetFactor(factor);
@ -170,12 +155,12 @@ void VToolNormal::SetFactor(qreal factor)
void VToolNormal::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogNormal, this, event);
ContextMenu<DialogNormal>(this, event);
}
void VToolNormal::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogNormal, this, event);
ContextMenu<DialogNormal>(this, event);
}
void VToolNormal::AddToFile()
@ -220,3 +205,16 @@ void VToolNormal::RemoveReferens()
doc->DecrementReferens(secondPointId);
VToolLinePoint::RemoveReferens();
}
void VToolNormal::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogNormal *dialogTool = qobject_cast<DialogNormal*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrName, dialogTool->getPointName());
SetAttribute(domElement, AttrTypeLine, dialogTool->getTypeLine());
SetAttribute(domElement, AttrLength, dialogTool->getFormula());
SetAttribute(domElement, AttrAngle, QString().setNum(dialogTool->getAngle()));
SetAttribute(domElement, AttrFirstPoint, QString().setNum(dialogTool->getFirstPointId()));
SetAttribute(domElement, AttrSecondPoint, QString().setNum(dialogTool->getSecondPointId()));
}

19
src/tools/drawTools/vtoolnormal.h
View file

@ -30,7 +30,6 @@
#define VTOOLNORMAL_H
#include "vtoollinepoint.h"
#include "../../dialogs/dialognormal.h"
/**
* @brief The VToolNormal class tool for creation point on normal. Normal begin from first point of line.
@ -67,8 +66,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogNormal> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -107,11 +105,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief SetFactor set current scale factor of scene.
* @param factor scene scale factor.
@ -135,20 +128,20 @@ protected:
/**
* @brief RefreshDataInFile refresh attributes in file. If attributes don't exist create them.
*/
virtual void RefreshDataInFile();
virtual void RefreshDataInFile();
/**
* @brief RemoveReferens decrement value of reference.
*/
virtual void RemoveReferens();
/**
* @brief SaveDialog save options into file after change in dialog.
*/
virtual void SaveDialog(QDomElement &domElement);
private:
/**
* @brief secondPointId id second line point.
*/
qint64 secondPointId;
/**
* @brief dialogNormal dialog.
*/
QSharedPointer<DialogNormal> dialogNormal;
};
#endif // VTOOLNORMAL_H

5
src/tools/drawTools/vtoolpoint.h
View file

@ -60,11 +60,6 @@ public slots:
* @param newName new name active pattern peace.
*/
virtual void ChangedActivDraw(const QString &newName);
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result) = 0;
/**
* @brief ShowTool highlight tool.
* @param id object id in container.

68
src/tools/drawTools/vtoolpointofcontact.cpp
View file

@ -28,6 +28,7 @@
#include "vtoolpointofcontact.h"
#include "../../container/calculator.h"
#include "../../dialogs/dialogpointofcontact.h"
const QString VToolPointOfContact::ToolType = QStringLiteral("pointOfContact");
@ -36,7 +37,7 @@ VToolPointOfContact::VToolPointOfContact(VDomDocument *doc, VContainer *data, co
const qint64 &firstPointId, const qint64 &secondPointId,
const Tool::Sources &typeCreation, QGraphicsItem *parent)
: VToolPoint(doc, data, id, parent), arcRadius(radius), center(center), firstPointId(firstPointId),
secondPointId(secondPointId), dialogPointOfContact(QSharedPointer<DialogPointOfContact>())
secondPointId(secondPointId)
{
if (typeCreation == Tool::FromGui)
{
@ -50,13 +51,15 @@ VToolPointOfContact::VToolPointOfContact(VDomDocument *doc, VContainer *data, co
void VToolPointOfContact::setDialog()
{
Q_ASSERT(dialogPointOfContact.isNull() == false);
Q_CHECK_PTR(dialog);
DialogPointOfContact *dialogTool = qobject_cast<DialogPointOfContact*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogPointOfContact->setRadius(arcRadius);
dialogPointOfContact->setCenter(center, id);
dialogPointOfContact->setFirstPoint(firstPointId, id);
dialogPointOfContact->setSecondPoint(secondPointId, id);
dialogPointOfContact->setPointName(p->name());
dialogTool->setRadius(arcRadius);
dialogTool->setCenter(center, id);
dialogTool->setFirstPoint(firstPointId, id);
dialogTool->setSecondPoint(secondPointId, id);
dialogTool->setPointName(p->name());
}
QPointF VToolPointOfContact::FindPoint(const qreal &radius, const QPointF &center, const QPointF &firstPoint,
@ -85,14 +88,16 @@ QPointF VToolPointOfContact::FindPoint(const qreal &radius, const QPointF &cente
return pArc;
}
void VToolPointOfContact::Create(QSharedPointer<DialogPointOfContact> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data)
void VToolPointOfContact::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data)
{
QString radius = dialog->getRadius();
qint64 center = dialog->getCenter();
qint64 firstPointId = dialog->getFirstPoint();
qint64 secondPointId = dialog->getSecondPoint();
QString pointName = dialog->getPointName();
Q_CHECK_PTR(dialog);
DialogPointOfContact *dialogTool = qobject_cast<DialogPointOfContact*>(dialog);
Q_CHECK_PTR(dialogTool);
QString radius = dialogTool->getRadius();
qint64 center = dialogTool->getCenter();
qint64 firstPointId = dialogTool->getFirstPoint();
qint64 secondPointId = dialogTool->getSecondPoint();
QString pointName = dialogTool->getPointName();
Create(0, radius, center, firstPointId, secondPointId, pointName, 5, 10, scene, doc, data,
Document::FullParse, Tool::FromGui);
}
@ -162,25 +167,6 @@ void VToolPointOfContact::FullUpdateFromFile()
RefreshPointGeometry(*VAbstractTool::data.GeometricObject<const VPointF *>(id));
}
void VToolPointOfContact::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, dialogPointOfContact->getPointName());
SetAttribute(domElement, AttrRadius, dialogPointOfContact->getRadius());
SetAttribute(domElement, AttrCenter, QString().setNum(dialogPointOfContact->getCenter()));
SetAttribute(domElement, AttrFirstPoint, QString().setNum(dialogPointOfContact->getFirstPoint()));
SetAttribute(domElement, AttrSecondPoint, QString().setNum(dialogPointOfContact->getSecondPoint()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogPointOfContact.clear();
}
void VToolPointOfContact::SetFactor(qreal factor)
{
VDrawTool::SetFactor(factor);
@ -189,12 +175,12 @@ void VToolPointOfContact::SetFactor(qreal factor)
void VToolPointOfContact::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogPointOfContact, this, event);
ContextMenu<DialogPointOfContact>(this, event);
}
void VToolPointOfContact::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogPointOfContact, this, event);
ContextMenu<DialogPointOfContact>(this, event);
}
void VToolPointOfContact::AddToFile()
@ -238,3 +224,15 @@ void VToolPointOfContact::RemoveReferens()
doc->DecrementReferens(firstPointId);
doc->DecrementReferens(secondPointId);
}
void VToolPointOfContact::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogPointOfContact *dialogTool = qobject_cast<DialogPointOfContact*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrName, dialogTool->getPointName());
SetAttribute(domElement, AttrRadius, dialogTool->getRadius());
SetAttribute(domElement, AttrCenter, QString().setNum(dialogTool->getCenter()));
SetAttribute(domElement, AttrFirstPoint, QString().setNum(dialogTool->getFirstPoint()));
SetAttribute(domElement, AttrSecondPoint, QString().setNum(dialogTool->getSecondPoint()));
}

19
src/tools/drawTools/vtoolpointofcontact.h
View file

@ -30,7 +30,6 @@
#define VTOOLPOINTOFCONTACT_H
#include "vtoolpoint.h"
#include "../../dialogs/dialogpointofcontact.h"
/**
* @brief The VToolPointOfContact class tool for creation point intersection line and arc.
@ -75,8 +74,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogPointOfContact> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -103,11 +101,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief SetFactor set current scale factor of scene.
* @param factor scene scale factor.
@ -131,11 +124,15 @@ protected:
/**
* @brief RefreshDataInFile refresh attributes in file. If attributes don't exist create them.
*/
virtual void RefreshDataInFile();
virtual void RefreshDataInFile();
/**
* @brief RemoveReferens decrement value of reference.
*/
virtual void RemoveReferens();
/**
* @brief SaveDialog save options into file after change in dialog.
*/
virtual void SaveDialog(QDomElement &domElement);
private:
/**
* @brief radius string with formula radius arc.
@ -153,10 +150,6 @@ private:
* @brief secondPointId id second line point.
*/
qint64 secondPointId;
/**
* @brief dialogPointOfContact dialog.
*/
QSharedPointer<DialogPointOfContact> dialogPointOfContact;
};
#endif // VTOOLPOINTOFCONTACT_H

58
src/tools/drawTools/vtoolpointofintersection.cpp
View file

@ -27,14 +27,14 @@
*************************************************************************/
#include "vtoolpointofintersection.h"
#include "../../dialogs/dialogpointofintersection.h"
const QString VToolPointOfIntersection::ToolType = QStringLiteral("pointOfIntersection");
VToolPointOfIntersection::VToolPointOfIntersection(VDomDocument *doc, VContainer *data, const qint64 &id,
const qint64 &firstPointId, const qint64 &secondPointId,
const Tool::Sources &typeCreation, QGraphicsItem *parent)
:VToolPoint(doc, data, id, parent), firstPointId(firstPointId), secondPointId(secondPointId),
dialogPointOfIntersection(QSharedPointer<DialogPointOfIntersection>())
:VToolPoint(doc, data, id, parent), firstPointId(firstPointId), secondPointId(secondPointId)
{
ignoreFullUpdate = true;
if (typeCreation == Tool::FromGui)
@ -49,19 +49,24 @@ VToolPointOfIntersection::VToolPointOfIntersection(VDomDocument *doc, VContainer
void VToolPointOfIntersection::setDialog()
{
Q_ASSERT(dialogPointOfIntersection.isNull() == false);
Q_CHECK_PTR(dialog);
DialogPointOfIntersection *dialogTool = qobject_cast<DialogPointOfIntersection*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogPointOfIntersection->setFirstPointId(firstPointId, id);
dialogPointOfIntersection->setSecondPointId(secondPointId, id);
dialogPointOfIntersection->setPointName(p->name());
dialogTool->setFirstPointId(firstPointId, id);
dialogTool->setSecondPointId(secondPointId, id);
dialogTool->setPointName(p->name());
}
void VToolPointOfIntersection::Create(QSharedPointer<DialogPointOfIntersection> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data)
void VToolPointOfIntersection::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data)
{
qint64 firstPointId = dialog->getFirstPointId();
qint64 secondPointId = dialog->getSecondPointId();
QString pointName = dialog->getPointName();
Q_CHECK_PTR(dialog);
DialogPointOfIntersection *dialogTool = qobject_cast<DialogPointOfIntersection*>(dialog);
Q_CHECK_PTR(dialogTool);
qint64 firstPointId = dialogTool->getFirstPointId();
qint64 secondPointId = dialogTool->getSecondPointId();
QString pointName = dialogTool->getPointName();
Create(0, pointName, firstPointId, secondPointId, 5, 10, scene, doc, data, Document::FullParse, Tool::FromGui);
}
@ -112,26 +117,9 @@ void VToolPointOfIntersection::FullUpdateFromFile()
VToolPoint::RefreshPointGeometry(*VDrawTool::data.GeometricObject<const VPointF *>(id));
}
void VToolPointOfIntersection::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, dialogPointOfIntersection->getPointName());
SetAttribute(domElement, AttrFirstPoint, QString().setNum(dialogPointOfIntersection->getFirstPointId()));
SetAttribute(domElement, AttrSecondPoint, QString().setNum(dialogPointOfIntersection->getSecondPointId()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogPointOfIntersection.clear();
}
void VToolPointOfIntersection::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogPointOfIntersection, this, event);
ContextMenu<DialogPointOfIntersection>(this, event);
}
void VToolPointOfIntersection::RemoveReferens()
@ -142,7 +130,7 @@ void VToolPointOfIntersection::RemoveReferens()
void VToolPointOfIntersection::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogPointOfIntersection, this, event);
ContextMenu<DialogPointOfIntersection>(this, event);
}
void VToolPointOfIntersection::AddToFile()
@ -175,3 +163,13 @@ void VToolPointOfIntersection::RefreshDataInFile()
SetAttribute(domElement, AttrSecondPoint, secondPointId);
}
}
void VToolPointOfIntersection::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogPointOfIntersection *dialogTool = qobject_cast<DialogPointOfIntersection*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrName, dialogTool->getPointName());
SetAttribute(domElement, AttrFirstPoint, QString().setNum(dialogTool->getFirstPointId()));
SetAttribute(domElement, AttrSecondPoint, QString().setNum(dialogTool->getSecondPointId()));
}

17
src/tools/drawTools/vtoolpointofintersection.h
View file

@ -30,7 +30,6 @@
#define VTOOLPOINTOFINTERSECTION_H
#include "vtoolpoint.h"
#include "../../dialogs/dialogpointofintersection.h"
/**
* @brief The VToolPointOfIntersection class tool for creation point intersection two lines.
@ -63,8 +62,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogPointOfIntersection> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -89,11 +87,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief ShowContextMenu show context menu.
* @param event context menu event.
@ -117,6 +110,10 @@ protected:
* @brief RefreshDataInFile refresh attributes in file. If attributes don't exist create them.
*/
virtual void RefreshDataInFile();
/**
* @brief SaveDialog save options into file after change in dialog.
*/
virtual void SaveDialog(QDomElement &domElement);
private:
Q_DISABLE_COPY(VToolPointOfIntersection)
/**
@ -127,10 +124,6 @@ private:
* @brief secondPointId id second line point.
*/
qint64 secondPointId;
/**
* @brief dialogPointOfIntersection dialog.
*/
QSharedPointer<DialogPointOfIntersection> dialogPointOfIntersection;
};
#endif // VTOOLPOINTOFINTERSECTION_H

75
src/tools/drawTools/vtoolshoulderpoint.cpp
View file

@ -28,6 +28,7 @@
#include "vtoolshoulderpoint.h"
#include "../../container/calculator.h"
#include "../../dialogs/dialogshoulderpoint.h"
const QString VToolShoulderPoint::ToolType = QStringLiteral("shoulder");
@ -35,8 +36,7 @@ VToolShoulderPoint::VToolShoulderPoint(VDomDocument *doc, VContainer *data, cons
const QString &typeLine, const QString &formula, const qint64 &p1Line,
const qint64 &p2Line, const qint64 &pShoulder, const Tool::Sources &typeCreation,
QGraphicsItem * parent)
:VToolLinePoint(doc, data, id, typeLine, formula, p1Line, 0, parent), p2Line(p2Line), pShoulder(pShoulder),
dialogShoulderPoint(QSharedPointer<DialogShoulderPoint>())
:VToolLinePoint(doc, data, id, typeLine, formula, p1Line, 0, parent), p2Line(p2Line), pShoulder(pShoulder)
{
if (typeCreation == Tool::FromGui)
{
@ -50,14 +50,16 @@ VToolShoulderPoint::VToolShoulderPoint(VDomDocument *doc, VContainer *data, cons
void VToolShoulderPoint::setDialog()
{
Q_ASSERT(dialogShoulderPoint.isNull() == false);
Q_CHECK_PTR(dialog);
DialogShoulderPoint *dialogTool = qobject_cast<DialogShoulderPoint*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogShoulderPoint->setTypeLine(typeLine);
dialogShoulderPoint->setFormula(formula);
dialogShoulderPoint->setP1Line(basePointId, id);
dialogShoulderPoint->setP2Line(p2Line, id);
dialogShoulderPoint->setPShoulder(pShoulder, id);
dialogShoulderPoint->setPointName(p->name());
dialogTool->setTypeLine(typeLine);
dialogTool->setFormula(formula);
dialogTool->setP1Line(basePointId, id);
dialogTool->setP2Line(p2Line, id);
dialogTool->setPShoulder(pShoulder, id);
dialogTool->setPointName(p->name());
}
QPointF VToolShoulderPoint::FindPoint(const QPointF &p1Line, const QPointF &p2Line, const QPointF &pShoulder,
@ -87,15 +89,17 @@ QPointF VToolShoulderPoint::FindPoint(const QPointF &p1Line, const QPointF &p2Li
}
}
void VToolShoulderPoint::Create(QSharedPointer<DialogShoulderPoint> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data)
void VToolShoulderPoint::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data)
{
QString formula = dialog->getFormula();
qint64 p1Line = dialog->getP1Line();
qint64 p2Line = dialog->getP2Line();
qint64 pShoulder = dialog->getPShoulder();
QString typeLine = dialog->getTypeLine();
QString pointName = dialog->getPointName();
Q_CHECK_PTR(dialog);
DialogShoulderPoint *dialogTool = qobject_cast<DialogShoulderPoint*>(dialog);
Q_CHECK_PTR(dialogTool);
QString formula = dialogTool->getFormula();
qint64 p1Line = dialogTool->getP1Line();
qint64 p2Line = dialogTool->getP2Line();
qint64 pShoulder = dialogTool->getPShoulder();
QString typeLine = dialogTool->getTypeLine();
QString pointName = dialogTool->getPointName();
Create(0, formula, p1Line, p2Line, pShoulder, typeLine, pointName, 5, 10, scene, doc, data,
Document::FullParse, Tool::FromGui);
}
@ -165,26 +169,6 @@ void VToolShoulderPoint::FullUpdateFromFile()
RefreshGeometry();
}
void VToolShoulderPoint::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, dialogShoulderPoint->getPointName());
SetAttribute(domElement, AttrTypeLine, dialogShoulderPoint->getTypeLine());
SetAttribute(domElement, AttrLength, dialogShoulderPoint->getFormula());
SetAttribute(domElement, AttrP1Line, QString().setNum(dialogShoulderPoint->getP1Line()));
SetAttribute(domElement, AttrP2Line, QString().setNum(dialogShoulderPoint->getP2Line()));
SetAttribute(domElement, AttrPShoulder, QString().setNum(dialogShoulderPoint->getPShoulder()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogShoulderPoint.clear();
}
void VToolShoulderPoint::SetFactor(qreal factor)
{
VDrawTool::SetFactor(factor);
@ -193,12 +177,12 @@ void VToolShoulderPoint::SetFactor(qreal factor)
void VToolShoulderPoint::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogShoulderPoint, this, event);
ContextMenu<DialogShoulderPoint>(this, event);
}
void VToolShoulderPoint::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogShoulderPoint, this, event);
ContextMenu<DialogShoulderPoint>(this, event);
}
void VToolShoulderPoint::AddToFile()
@ -244,3 +228,16 @@ void VToolShoulderPoint::RemoveReferens()
doc->DecrementReferens(pShoulder);
VToolLinePoint::RemoveReferens();
}
void VToolShoulderPoint::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogShoulderPoint *dialogTool = qobject_cast<DialogShoulderPoint*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrName, dialogTool->getPointName());
SetAttribute(domElement, AttrTypeLine, dialogTool->getTypeLine());
SetAttribute(domElement, AttrLength, dialogTool->getFormula());
SetAttribute(domElement, AttrP1Line, QString().setNum(dialogTool->getP1Line()));
SetAttribute(domElement, AttrP2Line, QString().setNum(dialogTool->getP2Line()));
SetAttribute(domElement, AttrPShoulder, QString().setNum(dialogTool->getPShoulder()));
}

19
src/tools/drawTools/vtoolshoulderpoint.h
View file

@ -30,7 +30,6 @@
#define VTOOLSHOULDERPOINT_H
#include "vtoollinepoint.h"
#include "../../dialogs/dialogshoulderpoint.h"
/**
* @brief The VToolShoulderPoint class tool for creation point on shoulder. This tool for special situation, when you
@ -77,8 +76,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogShoulderPoint> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -106,11 +104,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief SetFactor set current scale factor of scene.
* @param factor scene scale factor.
@ -134,11 +127,15 @@ protected:
/**
* @brief RefreshDataInFile refresh attributes in file. If attributes don't exist create them.
*/
virtual void RefreshDataInFile();
virtual void RefreshDataInFile();
/**
* @brief RemoveReferens decrement value of reference.
*/
virtual void RemoveReferens();
/**
* @brief SaveDialog save options into file after change in dialog.
*/
virtual void SaveDialog(QDomElement &domElement);
private:
/**
* @brief p2Line id second line point.
@ -148,10 +145,6 @@ private:
* @brief pShoulder id shoulder line point.
*/
qint64 pShoulder;
/**
* @brief dialogShoulderPoint dialog.
*/
QSharedPointer<DialogShoulderPoint> dialogShoulderPoint;
};
#endif // VTOOLSHOULDERPOINT_H

45
src/tools/drawTools/vtoolsinglepoint.cpp
View file

@ -27,12 +27,13 @@
*************************************************************************/
#include "vtoolsinglepoint.h"
#include "../../dialogs/dialogsinglepoint.h"
const QString VToolSinglePoint::ToolType = QStringLiteral("single");
VToolSinglePoint::VToolSinglePoint (VDomDocument *doc, VContainer *data, qint64 id, const Tool::Sources &typeCreation,
QGraphicsItem * parent )
:VToolPoint(doc, data, id, parent), dialogSinglePoint(QSharedPointer<DialogSinglePoint>())
:VToolPoint(doc, data, id, parent)
{
baseColor = Qt::red;
currentColor = baseColor;
@ -53,9 +54,11 @@ VToolSinglePoint::VToolSinglePoint (VDomDocument *doc, VContainer *data, qint64
void VToolSinglePoint::setDialog()
{
Q_ASSERT(dialogSinglePoint.isNull() == false);
Q_CHECK_PTR(dialog);
DialogSinglePoint *dialogTool = qobject_cast<DialogSinglePoint*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogSinglePoint->setData(p->name(), p->toQPointF());
dialogTool->setData(p->name(), p->toQPointF());
}
void VToolSinglePoint::AddToFile()
@ -131,6 +134,18 @@ void VToolSinglePoint::decrementReferens()
}
}
void VToolSinglePoint::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogSinglePoint *dialogTool = qobject_cast<DialogSinglePoint*>(dialog);
Q_CHECK_PTR(dialogTool);
QPointF p = dialogTool->getPoint();
QString name = dialogTool->getName();
SetAttribute(domElement, AttrName, name);
SetAttribute(domElement, AttrX, QString().setNum(toMM(p.x())));
SetAttribute(domElement, AttrY, QString().setNum(toMM(p.y())));
}
void VToolSinglePoint::setColorLabel(const Qt::GlobalColor &color)
{
namePoint->setBrush(color);
@ -139,7 +154,7 @@ void VToolSinglePoint::setColorLabel(const Qt::GlobalColor &color)
void VToolSinglePoint::contextMenuEvent ( QGraphicsSceneContextMenuEvent * event )
{
ContextMenu(dialogSinglePoint, this, event, false);
ContextMenu<DialogSinglePoint>(this, event, false);
}
void VToolSinglePoint::FullUpdateFromFile()
@ -148,26 +163,6 @@ void VToolSinglePoint::FullUpdateFromFile()
RefreshPointGeometry(point);
}
void VToolSinglePoint::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QPointF p = dialogSinglePoint->getPoint();
QString name = dialogSinglePoint->getName();
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, name);
SetAttribute(domElement, AttrX, QString().setNum(toMM(p.x())));
SetAttribute(domElement, AttrY, QString().setNum(toMM(p.y())));
//I don't now why but signal does not work.
doc->FullUpdateTree();
emit toolhaveChange();
}
}
dialogSinglePoint.clear();
}
void VToolSinglePoint::ChangedActivDraw(const QString &newName)
{
if (nameActivDraw == newName)
@ -192,5 +187,5 @@ void VToolSinglePoint::SetFactor(qreal factor)
void VToolSinglePoint::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogSinglePoint, this, event, false);
ContextMenu<DialogSinglePoint>(this, event, false);
}

12
src/tools/drawTools/vtoolsinglepoint.h
View file

@ -30,7 +30,6 @@
#define VTOOLSINGLEPOINT_H
#include "vtoolpoint.h"
#include "../../dialogs/dialogsinglepoint.h"
/**
* @brief The VToolSinglePoint class tool for creation pattern base point. Obly base point can move. All object
@ -60,11 +59,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief ChangedActivDraw disable or enable context menu after change active pattern peace.
* @param newName new name active pattern peace.
@ -115,11 +109,11 @@ protected:
* @param tool tool what me delete.
*/
virtual void DeleteTool(QGraphicsItem *tool){Q_UNUSED(tool)}
private:
/**
* @brief dialogSinglePoint dialog.
* @brief SaveDialog save options into file after change in dialog.
*/
QSharedPointer<DialogSinglePoint> dialogSinglePoint;
virtual void SaveDialog(QDomElement &domElement);
private:
/**
* @brief setColorLabel change color for label and label line.
* @param color new color.

115
src/tools/drawTools/vtoolspline.cpp
View file

@ -28,14 +28,14 @@
#include "vtoolspline.h"
#include "../../geometry/vspline.h"
#include "../../dialogs/dialogspline.h"
const QString VToolSpline::TagName = QStringLiteral("spline");
const QString VToolSpline::ToolType = QStringLiteral("simple");
VToolSpline::VToolSpline(VDomDocument *doc, VContainer *data, qint64 id, const Tool::Sources &typeCreation,
QGraphicsItem *parent)
:VDrawTool(doc, data, id), QGraphicsPathItem(parent), dialogSpline(QSharedPointer<DialogSpline>()),
controlPoints(QVector<VControlPointSpline *>())
:VDrawTool(doc, data, id), QGraphicsPathItem(parent), controlPoints(QVector<VControlPointSpline *>())
{
ignoreFullUpdate = true;
@ -77,27 +77,32 @@ VToolSpline::VToolSpline(VDomDocument *doc, VContainer *data, qint64 id, const T
void VToolSpline::setDialog()
{
Q_ASSERT(dialogSpline.isNull() == false);
Q_CHECK_PTR(dialog);
DialogSpline *dialogTool = qobject_cast<DialogSpline*>(dialog);
Q_CHECK_PTR(dialogTool);
const VSpline *spl = VAbstractTool::data.GeometricObject<const VSpline *>(id);
dialogSpline->setP1(spl->GetP1().id());
dialogSpline->setP4(spl->GetP4().id());
dialogSpline->setAngle1(spl->GetAngle1());
dialogSpline->setAngle2(spl->GetAngle2());
dialogSpline->setKAsm1(spl->GetKasm1());
dialogSpline->setKAsm2(spl->GetKasm2());
dialogSpline->setKCurve(spl->GetKcurve());
dialogTool->setP1(spl->GetP1().id());
dialogTool->setP4(spl->GetP4().id());
dialogTool->setAngle1(spl->GetAngle1());
dialogTool->setAngle2(spl->GetAngle2());
dialogTool->setKAsm1(spl->GetKasm1());
dialogTool->setKAsm2(spl->GetKasm2());
dialogTool->setKCurve(spl->GetKcurve());
}
void VToolSpline::Create(QSharedPointer<DialogSpline> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
void VToolSpline::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data)
{
qint64 p1 = dialog->getP1();
qint64 p4 = dialog->getP4();
qreal kAsm1 = dialog->getKAsm1();
qreal kAsm2 = dialog->getKAsm2();
qreal angle1 = dialog->getAngle1();
qreal angle2 = dialog->getAngle2();
qreal kCurve = dialog->getKCurve();
Q_CHECK_PTR(dialog);
DialogSpline *dialogTool = qobject_cast<DialogSpline*>(dialog);
Q_CHECK_PTR(dialogTool);
qint64 p1 = dialogTool->getP1();
qint64 p4 = dialogTool->getP4();
qreal kAsm1 = dialogTool->getKAsm1();
qreal kAsm2 = dialogTool->getKAsm2();
qreal angle1 = dialogTool->getAngle1();
qreal angle2 = dialogTool->getAngle2();
qreal kCurve = dialogTool->getKCurve();
Create(0, p1, p4, kAsm1, kAsm2, angle1, angle2, kCurve, scene, doc, data, Document::FullParse,
Tool::FromGui);
}
@ -144,44 +149,6 @@ void VToolSpline::FullUpdateFromFile()
RefreshGeometry();
}
void VToolSpline::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
VPointF point1 = *VAbstractTool::data.GeometricObject<const VPointF *>(dialogSpline->getP1());
VPointF point4 = *VAbstractTool::data.GeometricObject<const VPointF *>(dialogSpline->getP4());
VSpline spl = VSpline (point1, point4, dialogSpline->getAngle1(), dialogSpline->getAngle2(),
dialogSpline->getKAsm1(), dialogSpline->getKAsm2(), dialogSpline->getKCurve());
disconnect(controlPoints[0], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition);
disconnect(controlPoints[1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition);
controlPoints[0]->setPos(spl.GetP2());
controlPoints[1]->setPos(spl.GetP3());
connect(controlPoints[0], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition);
connect(controlPoints[1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition);
spl = VSpline (point1, controlPoints[0]->pos(), controlPoints[1]->pos(), point4, dialogSpline->getKCurve());
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrPoint1, spl.GetP1().id());
SetAttribute(domElement, AttrPoint4, spl.GetP4().id());
SetAttribute(domElement, AttrAngle1, spl.GetAngle1());
SetAttribute(domElement, AttrAngle2, spl.GetAngle2());
SetAttribute(domElement, AttrKAsm1, spl.GetKasm1());
SetAttribute(domElement, AttrKAsm2, spl.GetKasm2());
SetAttribute(domElement, AttrKCurve, spl.GetKcurve());
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogSpline.clear();
}
void VToolSpline::ControlPointChangePosition(const qint32 &indexSpline, const SplinePoint::Position &position,
const QPointF &pos)
{
@ -205,12 +172,13 @@ void VToolSpline::ControlPointChangePosition(const qint32 &indexSpline, const Sp
SetAttribute(domElement, AttrKAsm2, QString().setNum(spl.GetKasm2()));
SetAttribute(domElement, AttrKCurve, QString().setNum(spl.GetKcurve()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
void VToolSpline::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogSpline, this, event);
ContextMenu<DialogSpline>(this, event);
}
void VToolSpline::AddToFile()
@ -306,6 +274,39 @@ void VToolSpline::keyReleaseEvent(QKeyEvent *event)
QGraphicsItem::keyReleaseEvent ( event );
}
void VToolSpline::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogSpline *dialogTool = qobject_cast<DialogSpline*>(dialog);
Q_CHECK_PTR(dialogTool);
VPointF point1 = *VAbstractTool::data.GeometricObject<const VPointF *>(dialogTool->getP1());
VPointF point4 = *VAbstractTool::data.GeometricObject<const VPointF *>(dialogTool->getP4());
VSpline spl = VSpline (point1, point4, dialogTool->getAngle1(), dialogTool->getAngle2(),
dialogTool->getKAsm1(), dialogTool->getKAsm2(), dialogTool->getKCurve());
disconnect(controlPoints[0], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition);
disconnect(controlPoints[1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition);
controlPoints[0]->setPos(spl.GetP2());
controlPoints[1]->setPos(spl.GetP3());
connect(controlPoints[0], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition);
connect(controlPoints[1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSpline::ControlPointChangePosition);
spl = VSpline (point1, controlPoints[0]->pos(), controlPoints[1]->pos(), point4, dialogTool->getKCurve());
SetAttribute(domElement, AttrPoint1, spl.GetP1().id());
SetAttribute(domElement, AttrPoint4, spl.GetP4().id());
SetAttribute(domElement, AttrAngle1, spl.GetAngle1());
SetAttribute(domElement, AttrAngle2, spl.GetAngle2());
SetAttribute(domElement, AttrKAsm1, spl.GetKasm1());
SetAttribute(domElement, AttrKAsm2, spl.GetKasm2());
SetAttribute(domElement, AttrKCurve, spl.GetKcurve());
}
void VToolSpline::RefreshGeometry()
{
this->setPen(QPen(currentColor, widthHairLine/factor));

15
src/tools/drawTools/vtoolspline.h
View file

@ -31,7 +31,6 @@
#include "vdrawtool.h"
#include <QGraphicsPathItem>
#include "../../dialogs/dialogspline.h"
#include "../../widgets/vcontrolpointspline.h"
#include "../../geometry/vsplinepath.h"
@ -63,8 +62,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogSpline> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -107,11 +105,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile ();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui ( int result );
/**
* @brief ControlPointChangePosition handle change position control point.
* @param indexSpline position spline in spline list.
@ -182,11 +175,11 @@ protected:
* @param event key release event.
*/
virtual void keyReleaseEvent(QKeyEvent * event);
private:
/**
* @brief dialogSpline dialog.
* @brief SaveDialog save options into file after change in dialog.
*/
QSharedPointer<DialogSpline> dialogSpline;
virtual void SaveDialog(QDomElement &domElement);
private:
/**
* @brief controlPoints list pointers of control points.
*/

92
src/tools/drawTools/vtoolsplinepath.cpp
View file

@ -27,14 +27,14 @@
*************************************************************************/
#include "vtoolsplinepath.h"
#include "../../dialogs/dialogsplinepath.h"
const QString VToolSplinePath::TagName = QStringLiteral("spline");
const QString VToolSplinePath::ToolType = QStringLiteral("path");
VToolSplinePath::VToolSplinePath(VDomDocument *doc, VContainer *data, qint64 id, const Tool::Sources &typeCreation,
QGraphicsItem *parent)
:VDrawTool(doc, data, id), QGraphicsPathItem(parent), dialogSplinePath(QSharedPointer<DialogSplinePath>()),
controlPoints(QVector<VControlPointSpline *>())
:VDrawTool(doc, data, id), QGraphicsPathItem(parent), controlPoints(QVector<VControlPointSpline *>())
{
ignoreFullUpdate = true;
const VSplinePath *splPath = data->GeometricObject<const VSplinePath *>(id);
@ -77,15 +77,19 @@ VToolSplinePath::VToolSplinePath(VDomDocument *doc, VContainer *data, qint64 id,
void VToolSplinePath::setDialog()
{
Q_ASSERT(dialogSplinePath.isNull() == false);
Q_CHECK_PTR(dialog);
DialogSplinePath *dialogTool = qobject_cast<DialogSplinePath*>(dialog);
Q_CHECK_PTR(dialogTool);
const VSplinePath *splPath = VAbstractTool::data.GeometricObject<const VSplinePath *>(id);
dialogSplinePath->SetPath(*splPath);
dialogTool->SetPath(*splPath);
}
void VToolSplinePath::Create(QSharedPointer<DialogSplinePath> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data)
void VToolSplinePath::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data)
{
VSplinePath *path = new VSplinePath(dialog->GetPath());
Q_CHECK_PTR(dialog);
DialogSplinePath *dialogTool = qobject_cast<DialogSplinePath*>(dialog);
Q_CHECK_PTR(dialogTool);
VSplinePath *path = new VSplinePath(dialogTool->GetPath());
Q_CHECK_PTR(path);
for (qint32 i = 0; i < path->CountPoint(); ++i)
{
@ -129,45 +133,6 @@ void VToolSplinePath::FullUpdateFromFile()
RefreshGeometry();
}
void VToolSplinePath::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
VSplinePath splPath = dialogSplinePath->GetPath();
for (qint32 i = 1; i<=splPath.Count(); ++i)
{
VSpline spl = splPath.GetSpline(i);
qint32 j = i*2;
disconnect(controlPoints[j-2], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSplinePath::ControlPointChangePosition);
disconnect(controlPoints[j-1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSplinePath::ControlPointChangePosition);
controlPoints[j-2]->setPos(spl.GetP2());
controlPoints[j-1]->setPos(spl.GetP3());
connect(controlPoints[j-2], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSplinePath::ControlPointChangePosition);
connect(controlPoints[j-1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSplinePath::ControlPointChangePosition);
spl = VSpline (spl.GetP1(), controlPoints[j-2]->pos(), controlPoints[j-1]->pos(), spl.GetP4(),
splPath.getKCurve());
CorectControlPoints(spl, splPath, i);
CorectControlPoints(spl, splPath, i);
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrKCurve, QString().setNum(splPath.getKCurve()));
UpdatePathPoint(domElement, splPath);
emit FullUpdateTree();
emit toolhaveChange();
}
}
}
dialogSplinePath.clear();
}
void VToolSplinePath::ControlPointChangePosition(const qint32 &indexSpline, const SplinePoint::Position &position,
const QPointF &pos)
{
@ -189,6 +154,7 @@ void VToolSplinePath::ControlPointChangePosition(const qint32 &indexSpline, cons
SetAttribute(domElement, AttrKCurve, QString().setNum(splPath.getKCurve()));
UpdatePathPoint(domElement, splPath);
emit FullUpdateTree();
emit toolhaveChange();
}
}
@ -256,7 +222,7 @@ void VToolSplinePath::SetFactor(qreal factor)
void VToolSplinePath::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogSplinePath, this, event);
ContextMenu<DialogSplinePath>(this, event);
}
void VToolSplinePath::AddToFile()
@ -382,6 +348,38 @@ void VToolSplinePath::keyReleaseEvent(QKeyEvent *event)
QGraphicsItem::keyReleaseEvent ( event );
}
void VToolSplinePath::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogSplinePath *dialogTool = qobject_cast<DialogSplinePath*>(dialog);
Q_CHECK_PTR(dialogTool);
VSplinePath splPath = dialogTool->GetPath();
for (qint32 i = 1; i<=splPath.Count(); ++i)
{
VSpline spl = splPath.GetSpline(i);
qint32 j = i*2;
disconnect(controlPoints[j-2], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSplinePath::ControlPointChangePosition);
disconnect(controlPoints[j-1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSplinePath::ControlPointChangePosition);
controlPoints[j-2]->setPos(spl.GetP2());
controlPoints[j-1]->setPos(spl.GetP3());
connect(controlPoints[j-2], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSplinePath::ControlPointChangePosition);
connect(controlPoints[j-1], &VControlPointSpline::ControlPointChangePosition, this,
&VToolSplinePath::ControlPointChangePosition);
spl = VSpline (spl.GetP1(), controlPoints[j-2]->pos(), controlPoints[j-1]->pos(), spl.GetP4(),
splPath.getKCurve());
CorectControlPoints(spl, splPath, i);
CorectControlPoints(spl, splPath, i);
}
SetAttribute(domElement, AttrKCurve, QString().setNum(splPath.getKCurve()));
UpdatePathPoint(domElement, splPath);
}
void VToolSplinePath::RefreshGeometry()
{
this->setPen(QPen(currentColor, widthHairLine/factor));

15
src/tools/drawTools/vtoolsplinepath.h
View file

@ -31,7 +31,6 @@
#include "vdrawtool.h"
#include <QGraphicsPathItem>
#include "../../dialogs/dialogsplinepath.h"
#include "../../widgets/vcontrolpointspline.h"
/**
@ -62,8 +61,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogSplinePath> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -99,11 +97,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief ControlPointChangePosition handle change position control point.
* @param indexSpline position spline in spline list.
@ -174,11 +167,11 @@ protected:
* @param event key release event.
*/
virtual void keyReleaseEvent(QKeyEvent * event);
private:
/**
* @brief dialogSplinePath dialog.
* @brief SaveDialog save options into file after change in dialog.
*/
QSharedPointer<DialogSplinePath> dialogSplinePath;
virtual void SaveDialog(QDomElement &domElement);
private:
/**
* @brief controlPoints list pointers of control points.
*/

68
src/tools/drawTools/vtooltriangle.cpp
View file

@ -27,6 +27,7 @@
*************************************************************************/
#include "vtooltriangle.h"
#include "../../dialogs/dialogtriangle.h"
const QString VToolTriangle::ToolType = QStringLiteral("triangle");
@ -34,7 +35,7 @@ VToolTriangle::VToolTriangle(VDomDocument *doc, VContainer *data, const qint64 &
const qint64 &axisP1Id, const qint64 &axisP2Id, const qint64 &firstPointId,
const qint64 &secondPointId, const Tool::Sources &typeCreation, QGraphicsItem *parent)
:VToolPoint(doc, data, id, parent), axisP1Id(axisP1Id), axisP2Id(axisP2Id), firstPointId(firstPointId),
secondPointId(secondPointId), dialogTriangle(QSharedPointer<DialogTriangle>())
secondPointId(secondPointId)
{
ignoreFullUpdate = true;
if (typeCreation == Tool::FromGui)
@ -49,23 +50,28 @@ VToolTriangle::VToolTriangle(VDomDocument *doc, VContainer *data, const qint64 &
void VToolTriangle::setDialog()
{
Q_ASSERT(dialogTriangle.isNull() == false);
Q_CHECK_PTR(dialog);
DialogTriangle *dialogTool = qobject_cast<DialogTriangle*>(dialog);
Q_CHECK_PTR(dialogTool);
const VPointF *p = VAbstractTool::data.GeometricObject<const VPointF *>(id);
dialogTriangle->setAxisP1Id(axisP1Id, id);
dialogTriangle->setAxisP2Id(axisP2Id, id);
dialogTriangle->setFirstPointId(firstPointId, id);
dialogTriangle->setSecondPointId(secondPointId, id);
dialogTriangle->setPointName(p->name());
dialogTool->setAxisP1Id(axisP1Id, id);
dialogTool->setAxisP2Id(axisP2Id, id);
dialogTool->setFirstPointId(firstPointId, id);
dialogTool->setSecondPointId(secondPointId, id);
dialogTool->setPointName(p->name());
}
void VToolTriangle::Create(QSharedPointer<DialogTriangle> &dialog, VMainGraphicsScene *scene,
void VToolTriangle::Create(DialogTool *dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data)
{
qint64 axisP1Id = dialog->getAxisP1Id();
qint64 axisP2Id = dialog->getAxisP2Id();
qint64 firstPointId = dialog->getFirstPointId();
qint64 secondPointId = dialog->getSecondPointId();
QString pointName = dialog->getPointName();
Q_CHECK_PTR(dialog);
DialogTriangle *dialogTool = qobject_cast<DialogTriangle*>(dialog);
Q_CHECK_PTR(dialogTool);
qint64 axisP1Id = dialogTool->getAxisP1Id();
qint64 axisP2Id = dialogTool->getAxisP2Id();
qint64 firstPointId = dialogTool->getFirstPointId();
qint64 secondPointId = dialogTool->getSecondPointId();
QString pointName = dialogTool->getPointName();
Create(0, pointName, axisP1Id, axisP2Id, firstPointId, secondPointId, 5, 10, scene, doc, data,
Document::FullParse, Tool::FromGui);
}
@ -165,29 +171,9 @@ void VToolTriangle::FullUpdateFromFile()
VToolPoint::RefreshPointGeometry(*VDrawTool::data.GeometricObject<const VPointF *>(id));
}
void VToolTriangle::FullUpdateFromGui(int result)
{
if (result == QDialog::Accepted)
{
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
SetAttribute(domElement, AttrName, dialogTriangle->getPointName());
SetAttribute(domElement, AttrAxisP1, QString().setNum(dialogTriangle->getAxisP1Id()));
SetAttribute(domElement, AttrAxisP2, QString().setNum(dialogTriangle->getAxisP2Id()));
SetAttribute(domElement, AttrFirstPoint, QString().setNum(dialogTriangle->getFirstPointId()));
SetAttribute(domElement, AttrSecondPoint, QString().setNum(dialogTriangle->getSecondPointId()));
emit FullUpdateTree();
emit toolhaveChange();
}
}
dialogTriangle.clear();
}
void VToolTriangle::ShowContextMenu(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogTriangle, this, event);
ContextMenu<DialogTriangle>(this, event);
}
void VToolTriangle::RemoveReferens()
@ -200,7 +186,7 @@ void VToolTriangle::RemoveReferens()
void VToolTriangle::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
ContextMenu(dialogTriangle, this, event);
ContextMenu<DialogTriangle>(this, event);
}
void VToolTriangle::AddToFile()
@ -237,3 +223,15 @@ void VToolTriangle::RefreshDataInFile()
SetAttribute(domElement, AttrSecondPoint, secondPointId);
}
}
void VToolTriangle::SaveDialog(QDomElement &domElement)
{
Q_CHECK_PTR(dialog);
DialogTriangle *dialogTool = qobject_cast<DialogTriangle*>(dialog);
Q_CHECK_PTR(dialogTool);
SetAttribute(domElement, AttrName, dialogTool->getPointName());
SetAttribute(domElement, AttrAxisP1, QString().setNum(dialogTool->getAxisP1Id()));
SetAttribute(domElement, AttrAxisP2, QString().setNum(dialogTool->getAxisP2Id()));
SetAttribute(domElement, AttrFirstPoint, QString().setNum(dialogTool->getFirstPointId()));
SetAttribute(domElement, AttrSecondPoint, QString().setNum(dialogTool->getSecondPointId()));
}

17
src/tools/drawTools/vtooltriangle.h
View file

@ -30,7 +30,6 @@
#define VTOOLTRIANGLE_H
#include "vtoolpoint.h"
#include "../../dialogs/dialogtriangle.h"
/**
* @brief The VToolTriangle class tool for what find point intersection two foots right triangle.
@ -65,8 +64,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogTriangle> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -103,11 +101,6 @@ public slots:
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile();
/**
* @brief FullUpdateFromGui refresh tool data from change options.
* @param result result working dialog.
*/
virtual void FullUpdateFromGui(int result);
/**
* @brief ShowContextMenu show context menu.
* @param event context menu event.
@ -131,6 +124,10 @@ protected:
* @brief RefreshDataInFile refresh attributes in file. If attributes don't exist create them.
*/
virtual void RefreshDataInFile();
/**
* @brief SaveDialog save options into file after change in dialog.
*/
virtual void SaveDialog(QDomElement &domElement);
private:
Q_DISABLE_COPY(VToolTriangle)
/**
@ -149,10 +146,6 @@ private:
* @brief secondPointId id second triangle point, what lies on the hypotenuse.
*/
qint64 secondPointId;
/**
* @brief dialogTriangle dialog.
*/
QSharedPointer<DialogTriangle> dialogTriangle;
};
#endif // VTOOLTRIANGLE_H

44
src/tools/vtooldetail.cpp
View file

@ -42,8 +42,7 @@ const QString VToolDetail::NodeTypeModeling = QStringLiteral("Modeling");
VToolDetail::VToolDetail(VDomDocument *doc, VContainer *data, const qint64 &id, const Tool::Sources &typeCreation,
VMainGraphicsScene *scene, QGraphicsItem *parent)
:VAbstractTool(doc, data, id), QGraphicsPathItem(parent), dialogDetail(QSharedPointer<DialogDetail>()),
sceneDetails(scene)
:VAbstractTool(doc, data, id), QGraphicsPathItem(parent), dialog(0), sceneDetails(scene)
{
VDetail detail = data->GetDetail(id);
for (ptrdiff_t i = 0; i< detail.CountNode(); ++i)
@ -80,17 +79,26 @@ VToolDetail::VToolDetail(VDomDocument *doc, VContainer *data, const qint64 &id,
}
}
void VToolDetail::setDialog()
VToolDetail::~VToolDetail()
{
Q_ASSERT(dialogDetail.isNull() == false);
VDetail detail = VAbstractTool::data.GetDetail(id);
dialogDetail->setDetails(detail);
delete dialog;
}
void VToolDetail::Create(QSharedPointer<DialogDetail> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data)
void VToolDetail::setDialog()
{
VDetail detail = dialog->getDetails();
Q_CHECK_PTR(dialog);
DialogDetail *dialogTool = qobject_cast<DialogDetail*>(dialog);
Q_CHECK_PTR(dialogTool);
VDetail detail = VAbstractTool::data.GetDetail(id);
dialogTool->setDetails(detail);
}
void VToolDetail::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data)
{
Q_CHECK_PTR(dialog);
DialogDetail *dialogTool = qobject_cast<DialogDetail*>(dialog);
Q_CHECK_PTR(dialogTool);
VDetail detail = dialogTool->getDetails();
VDetail det;
for (ptrdiff_t i = 0; i< detail.CountNode(); ++i)
{
@ -176,7 +184,10 @@ void VToolDetail::FullUpdateFromGui(int result)
QDomElement domElement = doc->elementById(QString().setNum(id));
if (domElement.isElement())
{
VDetail det = dialogDetail->getDetails();
Q_CHECK_PTR(dialog);
DialogDetail *dialogTool = qobject_cast<DialogDetail*>(dialog);
Q_CHECK_PTR(dialogTool);
VDetail det = dialogTool->getDetails();
SetAttribute(domElement, AttrName, det.getName());
SetAttribute(domElement, AttrSupplement, QString().setNum(det.getSeamAllowance()));
SetAttribute(domElement, AttrClosed, QString().setNum(det.getClosed()));
@ -201,7 +212,8 @@ void VToolDetail::FullUpdateFromGui(int result)
emit toolhaveChange();
}
}
dialogDetail.clear();
delete dialog;
dialog = 0;
}
void VToolDetail::AddToFile()
@ -322,12 +334,14 @@ void VToolDetail::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
QAction *selectedAction = menu.exec(event->screenPos());
if (selectedAction == actionOption)
{
dialogDetail = QSharedPointer<DialogDetail>(new DialogDetail(getData()));
QGraphicsScene *scene = this->scene();
QList<QGraphicsView *> list = scene->views();
dialog = new DialogDetail(getData(), list.first());
connect(qobject_cast< VMainGraphicsScene * >(this->scene()), &VMainGraphicsScene::ChoosedObject,
dialogDetail.data(), &DialogDetail::ChoosedObject);
connect(dialogDetail.data(), &DialogDetail::DialogClosed, this, &VToolDetail::FullUpdateFromGui);
dialog, &DialogTool::ChoosedObject);
connect(dialog, &DialogTool::DialogClosed, this, &VToolDetail::FullUpdateFromGui);
setDialog();
dialogDetail->show();
dialog->show();
}
if (selectedAction == actionRemove)
{

85
src/tools/vtooldetail.h
View file

@ -40,22 +40,22 @@ class VToolDetail: public VAbstractTool, public QGraphicsPathItem
{
Q_OBJECT
public:
/**
* @brief VToolDetail constructor.
* @param doc dom document container
* @param data container with variables
* @param id object id in container
* @param typeCreation way we create this tool.
* @param scene pointer to scene.
* @param parent parent object
*/
VToolDetail(VDomDocument *doc, VContainer *data, const qint64 &id,
const Tool::Sources &typeCreation, VMainGraphicsScene *scene,
QGraphicsItem * parent = 0);
/**
* @brief VToolDetail constructor.
* @param doc dom document container
* @param data container with variables
* @param id object id in container
* @param typeCreation way we create this tool.
* @param scene pointer to scene.
* @param parent parent object
*/
VToolDetail(VDomDocument *doc, VContainer *data, const qint64 &id, const Tool::Sources &typeCreation,
VMainGraphicsScene *scene, QGraphicsItem * parent = 0);
~VToolDetail();
/**
* @brief setDialog set dialog when user want change tool option.
*/
virtual void setDialog();
virtual void setDialog();
template<typename T>
/**
* @brief CreateNode create new node for detail.
@ -79,8 +79,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogDetail> &dialog, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
@ -91,94 +90,94 @@ public:
* @param parse parser file mode.
* @param typeCreation way we create this tool.
*/
static void Create(const qint64 &_id, const VDetail &newDetail, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data, const Document::Documents &parse,
const Tool::Sources &typeCreation);
static const QString TagName;
static const QString TagNode;
static const QString AttrSupplement;
static const QString AttrClosed;
static const QString AttrWidth;
static const QString AttrIdObject;
static const QString AttrNodeType;
static const QString NodeTypeContour;
static const QString NodeTypeModeling;
static void Create(const qint64 &_id, const VDetail &newDetail, VMainGraphicsScene *scene,
VDomDocument *doc, VContainer *data, const Document::Documents &parse,
const Tool::Sources &typeCreation);
static const QString TagName;
static const QString TagNode;
static const QString AttrSupplement;
static const QString AttrClosed;
static const QString AttrWidth;
static const QString AttrIdObject;
static const QString AttrNodeType;
static const QString NodeTypeContour;
static const QString NodeTypeModeling;
/**
* @brief Remove full delete detail.
*/
void Remove();
void Remove();
public slots:
/**
* @brief FullUpdateFromFile update tool data form file.
*/
virtual void FullUpdateFromFile ();
virtual void FullUpdateFromFile ();
/**
* @brief FullUpdateFromGui refresh tool data after change in options.
* @param result keep result working dialog.
*/
virtual void FullUpdateFromGui(int result);
virtual void FullUpdateFromGui(int result);
protected:
/**
* @brief AddToFile add tag with informations about tool into file.
*/
virtual void AddToFile ();
virtual void AddToFile ();
/**
* @brief RefreshDataInFile refresh attributes in file. If attributes don't exist create them.
*/
virtual void RefreshDataInFile();
virtual void RefreshDataInFile();
/**
* @brief itemChange handle detail change.
* @param change change
* @param value value
* @return new value.
*/
virtual QVariant itemChange ( GraphicsItemChange change, const QVariant &value );
virtual QVariant itemChange ( GraphicsItemChange change, const QVariant &value );
/**
* @brief mouseReleaseEvent handle mouse release events.
* @param event mouse release event.
*/
virtual void mouseReleaseEvent ( QGraphicsSceneMouseEvent * event );
virtual void mouseReleaseEvent ( QGraphicsSceneMouseEvent * event );
/**
* @brief contextMenuEvent handle context menu events.
* @param event context menu event.
*/
virtual void contextMenuEvent ( QGraphicsSceneContextMenuEvent * event );
virtual void contextMenuEvent ( QGraphicsSceneContextMenuEvent * event );
/**
* @brief RemoveReferens decrement value of reference.
*/
virtual void RemoveReferens();
virtual void RemoveReferens();
/**
* @brief keyReleaseEvent handle key release events.
* @param event key release event.
*/
virtual void keyReleaseEvent(QKeyEvent * event);
virtual void keyReleaseEvent(QKeyEvent * event);
private:
Q_DISABLE_COPY(VToolDetail)
/**
* @brief dialogDetail dialog.
* @brief dialog dialog options.
*/
QSharedPointer<DialogDetail> dialogDetail;
DialogTool *dialog;
/**
* @brief sceneDetails pointer to the scene.
*/
VMainGraphicsScene *sceneDetails;
VMainGraphicsScene *sceneDetails;
/**
* @brief RefreshGeometry refresh item on scene.
*/
void RefreshGeometry ();
void RefreshGeometry ();
/**
* @brief AddNode add node to the file.
* @param domElement tag in xml tree.
* @param node node of detail.
*/
void AddNode(QDomElement &domElement, const VNodeDetail &node);
void AddNode(QDomElement &domElement, const VNodeDetail &node);
template <typename Tool>
/**
* @brief InitTool initial node item on scene
* @param scene pointer to scene.
* @param node node of detail.
*/
void InitTool(VMainGraphicsScene *scene, const VNodeDetail &node);
void InitTool(VMainGraphicsScene *scene, const VNodeDetail &node);
};
#endif // VTOOLDETAIL_H

16
src/tools/vtooluniondetails.cpp
View file

@ -402,14 +402,16 @@ void VToolUnionDetails::BiasRotatePoint(VPointF *point, const qreal &dx, const q
point->setY(line.p2().y());
}
void VToolUnionDetails::Create(QSharedPointer<DialogUnionDetails> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data)
void VToolUnionDetails::Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data)
{
VDetail d1 = data->GetDetail(dialog->getD1());
VDetail d2 = data->GetDetail(dialog->getD2());
ptrdiff_t indexD1 = dialog->getIndexD1();
ptrdiff_t indexD2 = dialog->getIndexD2();
Create(0, d1, d2, dialog->getD1(), dialog->getD2(), indexD1, indexD2, scene, doc, data, Document::FullParse,
Q_CHECK_PTR(dialog);
DialogUnionDetails *dialogTool = qobject_cast<DialogUnionDetails*>(dialog);
Q_CHECK_PTR(dialogTool);
VDetail d1 = data->GetDetail(dialogTool->getD1());
VDetail d2 = data->GetDetail(dialogTool->getD2());
ptrdiff_t indexD1 = dialogTool->getIndexD1();
ptrdiff_t indexD2 = dialogTool->getIndexD2();
Create(0, d1, d2, dialogTool->getD1(), dialogTool->getD2(), indexD1, indexD2, scene, doc, data, Document::FullParse,
Tool::FromGui);
}

3
src/tools/vtooluniondetails.h
View file

@ -64,8 +64,7 @@ public:
* @param doc dom document container.
* @param data container with variables.
*/
static void Create(QSharedPointer<DialogUnionDetails> &dialog, VMainGraphicsScene *scene, VDomDocument *doc,
VContainer *data);
static void Create(DialogTool *dialog, VMainGraphicsScene *scene, VDomDocument *doc, VContainer *data);
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.