electron-rare/leocad
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Share code between step and mouse tool actions.

Browse Source
This commit is contained in:
Leonardo Zide
2025-12-04 18:50:10 -08:00
parent 4de6c095e4
commit 7febca8558
3 changed files with 112 additions and 193 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/lc_model.cpp
+12 -54
View File
@@ -1757,7 +1757,7 @@ void lcModel::BeginMouseToolAction(lcTool Tool, lcView* View)
case lcTool::Pan:
case lcTool::RotateView:
case lcTool::Roll:
ModelActionMouseTool->SetCameraStartState(View->GetCamera());
ModelActionMouseTool->SaveCameraStartState(View->GetCamera());
break;
case lcTool::ZoomRegion:
@@ -1810,7 +1810,7 @@ void lcModel::EndMouseToolAction(lcTool Tool, lcView* View, const QString& Descr
case lcTool::Pan:
case lcTool::RotateView:
case lcTool::Roll:
ModelActionMouseTool->SetCameraEndState(View->GetCamera());
ModelActionMouseTool->SaveCameraEndState(View->GetCamera());
break;
case lcTool::ZoomRegion:
@@ -1853,6 +1853,7 @@ void lcModel::RunMouseToolAction(const lcModelActionMouseTool* ModelActionMouseT
ModelActionMouseTool->LoadSelectionEndState(this);
else
ModelActionMouseTool->LoadSelectionStartState(this);
SetCurrentStep(mCurrentStep);
break;
@@ -1867,10 +1868,10 @@ void lcModel::RunMouseToolAction(const lcModelActionMouseTool* ModelActionMouseT
case lcTool::Roll:
if (lcCamera* Camera = GetCamera(ModelActionMouseTool->GetCameraName()))
{
const QByteArray& State = Apply ? ModelActionMouseTool->GetEndState() : ModelActionMouseTool->GetStartState();
QDataStream Stream(const_cast<QByteArray*>(&State), QIODevice::ReadOnly);
Camera->LoadUndoData(Stream);
if (Apply)
ModelActionMouseTool->LoadCameraEndState(Camera);
else
ModelActionMouseTool->LoadCameraStartState(Camera);
SetCurrentStep(mCurrentStep);
}
@@ -2229,11 +2230,11 @@ void lcModel::RecordStepAction(lcModelActionStepMode Mode, lcStep Step)
{
std::unique_ptr<lcModelActionStep> ModelActionStep = std::make_unique<lcModelActionStep>(Mode, Step);
ModelActionStep->SaveState(mPieces, mCameras, mLights);
ModelActionStep->SaveModelState(this);
RunStepAction(ModelActionStep.get(), true);
mActionSequence.emplace_back(std::move(ModelActionStep));
mActionSequence.emplace_back(std::move(ModelActionStep));
}
void lcModel::RunStepAction(const lcModelActionStep* ModelActionStep, bool Apply)
@@ -2280,50 +2281,7 @@ void lcModel::RunStepAction(const lcModelActionStep* ModelActionStep, bool Apply
}
else
{
const std::vector<QByteArray>& PieceStates = ModelActionStep->GetPieceStates();
if (PieceStates.size() != mPieces.size())
return;
for (size_t PieceIndex = 0; PieceIndex < mPieces.size(); PieceIndex++)
{
const QByteArray& PieceState = PieceStates[PieceIndex];
lcPiece* Piece = mPieces[PieceIndex].get();
QDataStream Stream(const_cast<QByteArray*>(&PieceState), QIODevice::ReadOnly);
Piece->LoadUndoData(Stream);
}
const std::vector<QByteArray>& CameraStates = ModelActionStep->GetCameraStates();
if (CameraStates.size() != mCameras.size())
return;
for (size_t CameraIndex = 0; CameraIndex < mCameras.size(); CameraIndex++)
{
const QByteArray& CameraState = CameraStates[CameraIndex];
lcCamera* Camera = mCameras[CameraIndex].get();
QDataStream Stream(const_cast<QByteArray*>(&CameraState), QIODevice::ReadOnly);
Camera->LoadUndoData(Stream);
}
const std::vector<QByteArray>& LightStates = ModelActionStep->GetLightStates();
if (LightStates.size() != mLights.size())
return;
for (size_t LightIndex = 0; LightIndex < mLights.size(); LightIndex++)
{
const QByteArray& LightState = LightStates[LightIndex];
lcLight* Light = mLights[LightIndex].get();
QDataStream Stream(const_cast<QByteArray*>(&LightState), QIODevice::ReadOnly);
Light->LoadUndoData(Stream);
}
ModelActionStep->LoadModelState(this);
}
SetCurrentStep(mCurrentStep);
common/lc_modelaction.cpp
+86 -102
View File
@@ -7,6 +7,63 @@
#include "pieceinf.h"
#include "lc_colors.h"
void lcModelAction::SaveUndoBuffer(QByteArray& Buffer, const lcModel* Model, bool SelectedOnly)
{
QDataStream Stream(&Buffer, QIODevice::WriteOnly);
const std::vector<std::unique_ptr<lcPiece>>& Pieces = Model->GetPieces();
const std::vector<std::unique_ptr<lcCamera>>& Cameras = Model->GetCameras();
const std::vector<std::unique_ptr<lcLight>>& Lights = Model->GetLights();
size_t PieceCount = Pieces.size(), CameraCount = Cameras.size(), LightCount = Lights.size();
Stream << PieceCount;
Stream << CameraCount;
Stream << LightCount;
for (const std::unique_ptr<lcPiece>& Piece : Pieces)
if (!SelectedOnly || Piece->IsSelected())
Piece->SaveUndoData(Stream);
for (const std::unique_ptr<lcCamera>& Camera : Cameras)
if (!SelectedOnly || Camera->IsSelected())
Camera->SaveUndoData(Stream);
for (const std::unique_ptr<lcLight>& Light : Lights)
if (!SelectedOnly || Light->IsSelected())
Light->SaveUndoData(Stream);
}
void lcModelAction::LoadUndoBuffer(const QByteArray& Buffer, lcModel* Model, bool SelectedOnly)
{
QDataStream Stream(const_cast<QByteArray*>(&Buffer), QIODevice::ReadOnly);
const std::vector<std::unique_ptr<lcPiece>>& Pieces = Model->GetPieces();
const std::vector<std::unique_ptr<lcCamera>>& Cameras = Model->GetCameras();
const std::vector<std::unique_ptr<lcLight>>& Lights = Model->GetLights();
size_t PieceCount, CameraCount, LightCount;
Stream >> PieceCount;
Stream >> CameraCount;
Stream >> LightCount;
if (PieceCount != Pieces.size() || CameraCount != Cameras.size() || LightCount != Lights.size())
return;
for (const std::unique_ptr<lcPiece>& Piece : Pieces)
if (!SelectedOnly || Piece->IsSelected())
Piece->LoadUndoData(Stream);
for (const std::unique_ptr<lcCamera>& Camera : Cameras)
if (!SelectedOnly || Camera->IsSelected())
Camera->LoadUndoData(Stream);
for (const std::unique_ptr<lcLight>& Light : Lights)
if (!SelectedOnly || Light->IsSelected())
Light->LoadUndoData(Stream);
}
lcModelActionSelection::lcModelActionSelection(lcModelActionSelectionMode Mode)
: mMode(Mode)
{
@@ -112,98 +169,54 @@ lcModelActionMouseTool::lcModelActionMouseTool(lcTool Tool)
{
}
void lcModelActionMouseTool::SetCameraStartState(const lcCamera* Camera)
void lcModelActionMouseTool::SaveCameraStartState(const lcCamera* Camera)
{
QDataStream Stream(&mStartState, QIODevice::WriteOnly);
QDataStream Stream(&mStartBuffer, QIODevice::WriteOnly);
Camera->SaveUndoData(Stream);
mCameraName = Camera->GetName();
}
void lcModelActionMouseTool::SetCameraEndState(const lcCamera* Camera)
void lcModelActionMouseTool::LoadCameraStartState(lcCamera* Camera) const
{
QDataStream Stream(&mEndState, QIODevice::WriteOnly);
QDataStream Stream(const_cast<QByteArray*>(&mStartBuffer), QIODevice::ReadOnly);
Camera->LoadUndoData(Stream);
}
void lcModelActionMouseTool::SaveCameraEndState(const lcCamera* Camera)
{
QDataStream Stream(&mEndBuffer, QIODevice::WriteOnly);
Camera->SaveUndoData(Stream);
}
void lcModelActionMouseTool::LoadCameraEndState(lcCamera* Camera) const
{
QDataStream Stream(const_cast<QByteArray*>(&mEndBuffer), QIODevice::ReadOnly);
Camera->LoadUndoData(Stream);
}
void lcModelActionMouseTool::SaveSelectionStartState(const lcModel* Model)
{
SaveSelectionState(Model, mStartState);
SaveUndoBuffer(mStartBuffer, Model, true);
}
void lcModelActionMouseTool::LoadSelectionStartState(lcModel* Model) const
{
LoadSelectionState(Model, mStartState);
}
void lcModelActionMouseTool::LoadSelectionEndState(lcModel* Model) const
{
LoadSelectionState(Model, mEndState);
LoadUndoBuffer(mStartBuffer, Model, true);
}
void lcModelActionMouseTool::SaveSelectionEndState(const lcModel* Model)
{
SaveSelectionState(Model, mEndState);
SaveUndoBuffer(mEndBuffer, Model, true);
}
void lcModelActionMouseTool::SaveSelectionState(const lcModel* Model, QByteArray& State)
void lcModelActionMouseTool::LoadSelectionEndState(lcModel* Model) const
{
QTextStream Stream(&State, QIODevice::WriteOnly);
Model->SaveLDraw(Stream, false, 0);
}
void lcModelActionMouseTool::LoadSelectionState(lcModel* Model, const QByteArray& State)
{
QBuffer Buffer(const_cast<QByteArray*>(&State));
Buffer.open(QIODevice::ReadOnly);
std::unique_ptr<lcModel> SavedModel = std::make_unique<lcModel>(QString(), Model->GetProject(), false);
SavedModel->LoadLDraw(Buffer, Model->GetProject());
const std::vector<std::unique_ptr<lcPiece>>& Pieces = Model->GetPieces();
const std::vector<std::unique_ptr<lcPiece>>& SavedPieces = SavedModel->GetPieces();
if (Pieces.size() != SavedPieces.size())
return;
for (size_t PieceIndex = 0; PieceIndex < Pieces.size(); PieceIndex++)
{
lcPiece* Piece = Pieces[PieceIndex].get();
if (Piece->IsSelected())
Piece->CopyProperties(*SavedPieces[PieceIndex].get());
}
const std::vector<std::unique_ptr<lcCamera>>& Cameras = Model->GetCameras();
const std::vector<std::unique_ptr<lcCamera>>& SavedCameras = SavedModel->GetCameras();
if (Cameras.size() != SavedCameras.size())
return;
for (size_t CameraIndex = 0; CameraIndex < Cameras.size(); CameraIndex++)
{
lcCamera* Camera = Cameras[CameraIndex].get();
if (Camera->IsSelected())
Camera->CopyProperties(*SavedCameras[CameraIndex].get());
}
const std::vector<std::unique_ptr<lcLight>>& Lights = Model->GetLights();
const std::vector<std::unique_ptr<lcLight>>& SavedLights = SavedModel->GetLights();
if (Lights.size() != SavedLights.size())
return;
for (size_t LightIndex = 0; LightIndex < Lights.size(); LightIndex++)
{
lcLight* Light = Lights[LightIndex].get();
if (Light->IsSelected())
Light->CopyProperties(*SavedLights[LightIndex].get());
}
LoadUndoBuffer(mEndBuffer, Model, true);
}
lcModelActionAddPieces::lcModelActionAddPieces(lcStep Step, lcModelActionAddPieceSelectionMode SelectionMode)
@@ -259,41 +272,12 @@ lcModelActionStep::lcModelActionStep(lcModelActionStepMode Mode, lcStep Step)
{
}
void lcModelActionStep::SaveState(const std::vector<std::unique_ptr<lcPiece>>& Pieces, const std::vector<std::unique_ptr<lcCamera>>& Cameras, const std::vector<std::unique_ptr<lcLight>>& Lights)
void lcModelActionStep::SaveModelState(const lcModel* Model)
{
mPieceStates.resize(Pieces.size());
for (size_t PieceIndex = 0; PieceIndex < Pieces.size(); PieceIndex++)
{
QByteArray& PieceState = mPieceStates[PieceIndex];
const lcPiece* Piece = Pieces[PieceIndex].get();
QDataStream Stream(&PieceState, QIODevice::WriteOnly);
Piece->SaveUndoData(Stream);
}
SaveUndoBuffer(mUndoBuffer, Model, false);
}
mCameraStates.resize(Cameras.size());
for (size_t CameraIndex = 0; CameraIndex < Cameras.size(); CameraIndex++)
{
QByteArray& CameraState = mCameraStates[CameraIndex];
const lcCamera* Camera = Cameras[CameraIndex].get();
QDataStream Stream(&CameraState, QIODevice::WriteOnly);
Camera->SaveUndoData(Stream);
}
mLightStates.resize(Lights.size());
for (size_t LightIndex = 0; LightIndex < Lights.size(); LightIndex++)
{
QByteArray& LightState = mLightStates[LightIndex];
const lcLight* Light = Lights[LightIndex].get();
QDataStream Stream(&LightState, QIODevice::WriteOnly);
Light->SaveUndoData(Stream);
}
void lcModelActionStep::LoadModelState(lcModel* Model) const
{
LoadUndoBuffer(mUndoBuffer, Model, false);
}
common/lc_modelaction.h
+14 -37
View File
@@ -12,6 +12,10 @@ class lcModelAction
public:
lcModelAction() = default;
virtual ~lcModelAction() = default;
protected:
static void SaveUndoBuffer(QByteArray& Buffer, const lcModel* Model, bool SelectedOnly);
static void LoadUndoBuffer(const QByteArray& Buffer, lcModel* Model, bool SelectedOnly);
};
enum class lcModelActionSelectionMode
@@ -52,24 +56,16 @@ public:
lcModelActionMouseTool(lcTool Tool);
virtual ~lcModelActionMouseTool() = default;
void SaveCameraStartState(const lcCamera* Camera);
void LoadCameraStartState(lcCamera* Camera) const;
void SaveCameraEndState(const lcCamera* Camera);
void LoadCameraEndState(lcCamera* Camera) const;
void SaveSelectionStartState(const lcModel* Model);
void LoadSelectionStartState(lcModel* Model) const;
void SaveSelectionEndState(const lcModel* Model);
void LoadSelectionEndState(lcModel* Model) const;
void SetCameraStartState(const lcCamera* Camera);
void SetCameraEndState(const lcCamera* Camera);
const QByteArray& GetStartState() const
{
return mStartState;
}
const QByteArray& GetEndState() const
{
return mEndState;
}
lcTool GetTool() const
{
return mTool;
@@ -81,13 +77,10 @@ public:
}
protected:
static void SaveSelectionState(const lcModel* Model, QByteArray& State);
static void LoadSelectionState(lcModel* Model, const QByteArray& State);
lcTool mTool;
QString mCameraName;
QByteArray mStartState;
QByteArray mEndState;
QByteArray mStartBuffer;
QByteArray mEndBuffer;
};
enum class lcModelActionAddPieceSelectionMode
@@ -249,27 +242,11 @@ public:
return mStep;
}
void SaveState(const std::vector<std::unique_ptr<lcPiece>>& Pieces, const std::vector<std::unique_ptr<lcCamera>>& Cameras, const std::vector<std::unique_ptr<lcLight>>& Lights);
void SaveModelState(const lcModel* Model);
void LoadModelState(lcModel* Model) const;
const std::vector<QByteArray>& GetPieceStates() const
{
return mPieceStates;
}
const std::vector<QByteArray>& GetCameraStates() const
{
return mCameraStates;
}
const std::vector<QByteArray>& GetLightStates() const
{
return mLightStates;
}
protected:
std::vector<QByteArray> mPieceStates;
std::vector<QByteArray> mCameraStates;
std::vector<QByteArray> mLightStates;
QByteArray mUndoBuffer;
lcModelActionStepMode mMode;
lcStep mStep;
};