Added RemoveFromSelection action.

common/camera.cpp

@@ -594,7 +594,7 @@ void lcCamera::DrawInterface(lcContext* Context, const lcScene& Scene) const
 	}
 	else
 	{
-		if (IsSelected(LC_CAMERA_SECTION_POSITION))
+		if (IsSelected())
 		{
 			Context->SetLineWidth(2.0f * LineWidth);
 			if (IsFocused(LC_CAMERA_SECTION_POSITION))
@@ -610,7 +610,7 @@ void lcCamera::DrawInterface(lcContext* Context, const lcScene& Scene) const
 
 		Context->DrawIndexedPrimitives(GL_LINES, 40, GL_UNSIGNED_SHORT, 0);
 
-		if (IsSelected(LC_CAMERA_SECTION_TARGET))
+		if (IsSelected())
 		{
 			Context->SetLineWidth(2.0f * LineWidth);
 			if (IsFocused(LC_CAMERA_SECTION_TARGET))
@@ -626,7 +626,7 @@ void lcCamera::DrawInterface(lcContext* Context, const lcScene& Scene) const
 
 		Context->DrawIndexedPrimitives(GL_LINES, 24, GL_UNSIGNED_SHORT, 40 * 2);
 
-		if (IsSelected(LC_CAMERA_SECTION_UPVECTOR))
+		if (IsSelected())
 		{
 			Context->SetLineWidth(2.0f * LineWidth);
 			if (IsFocused(LC_CAMERA_SECTION_UPVECTOR))

common/camera.h

@@ -99,25 +99,6 @@ public:
 		return (mState & LC_CAMERA_SELECTION_MASK) != 0;
 	}
 
-	bool IsSelected(quint32 Section) const override
-	{
-		switch (Section)
-		{
-		case LC_CAMERA_SECTION_POSITION:
-			return (mState & LC_CAMERA_POSITION_SELECTED) != 0;
-			break;
-
-		case LC_CAMERA_SECTION_TARGET:
-			return (mState & LC_CAMERA_TARGET_SELECTED) != 0;
-			break;
-
-		case LC_CAMERA_SECTION_UPVECTOR:
-			return (mState & LC_CAMERA_UPVECTOR_SELECTED) != 0;
-			break;
-		}
-		return false;
-	}
-
 	void SetSelected(bool Selected) override
 	{
 		if (Selected)

common/lc_model.cpp

@@ -1230,7 +1230,7 @@ void lcModel::Paste(bool PasteToCurrentStep)
 	SaveCheckpoint(tr("Pasting"));
 
 	if (SelectedObjects.size() == 1)
-		RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, SelectedObjects.front(), LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
+		RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, std::vector<lcObject*>(), SelectedObjects.front(), LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
 //		ClearSelectionAndSetFocus(SelectedObjects[0], LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
 	else
 		SetSelectionAndFocus(SelectedObjects, nullptr, 0, false);
@@ -1733,11 +1733,11 @@ void lcModel::SubModelAddBoundingBoxPoints(const lcMatrix44& WorldMatrix, std::v
 			Piece->SubModelAddBoundingBoxPoints(WorldMatrix, Points);
 }
 
-void lcModel::RecordSelectionAction(lcModelActionSelectionMode ModelActionSelectionMode, lcObject* FocusObject, uint32_t FocusSection, lcSelectionMode SelectionMode)
+void lcModel::RecordSelectionAction(lcModelActionSelectionMode ModelActionSelectionMode, const std::vector<lcObject*>& Objects, lcObject* FocusObject, uint32_t FocusSection, lcSelectionMode SelectionMode)
 {
 	std::unique_ptr<lcModelActionSelection> ModelActionSelection = std::make_unique<lcModelActionSelection>(ModelActionSelectionMode, mCurrentStep);
 
-	if (ModelActionSelection->Initialize(this, FocusObject, FocusSection, SelectionMode))
+	if (ModelActionSelection->Initialize(this, Objects, FocusObject, FocusSection, SelectionMode))
     	mActionSequence.emplace_back(std::move(ModelActionSelection));
 }
 
@@ -1748,7 +1748,7 @@ void lcModel::RunSelectionAction(const lcModelActionSelection* ModelActionSelect
 
 	auto LoadSelection = [this, ModelActionSelection]()
 	{
-		auto [SelectedObjects, FocusObject, FocusSection] = ModelActionSelection->GetSelection(mPieces, mCameras, mLights);
+		auto [SelectedObjects, FocusObject, FocusSection] = ModelActionSelection->GetPreviousSelection(this);
 
 		SetSelectionAndFocus(SelectedObjects, FocusObject, FocusSection, false);
 	};
@@ -1782,7 +1782,7 @@ void lcModel::RunSelectionAction(const lcModelActionSelection* ModelActionSelect
 					SelectGroup(Piece->GetTopGroup(), Step, true);
 					
 					std::vector<lcObject*> Pieces = GetSelectionModePieces(ModelActionSelection->GetSelectionMode(), Piece, Step);
-					SelectObjects(Pieces, Step);
+					SelectObjects(Pieces, Step, true);
 				}
 			}
 		}
@@ -1811,7 +1811,34 @@ void lcModel::RunSelectionAction(const lcModelActionSelection* ModelActionSelect
 		else
 			LoadSelection();
 		break;
-
+		
+	case lcModelActionSelectionMode::RemoveFromSelection:
+		if (Apply)
+		{
+			std::vector<lcObject*> Objects = ModelActionSelection->GetNewObjects(this);
+			
+			for (lcObject* Object : Objects)
+			{
+				if (!Object->IsSelected())
+					continue;
+				
+				Object->SetSelected(false);
+				
+				if (Object->IsPiece())
+				{
+					lcPiece* Piece = dynamic_cast<lcPiece*>(Object);
+					
+					SelectGroup(Piece->GetTopGroup(), Step, false);
+					
+					std::vector<lcObject*> Pieces = GetSelectionModePieces(ModelActionSelection->GetSelectionMode(), Piece, Step);
+					SelectObjects(Pieces, Step, false);
+				}
+			}
+		}
+		else
+			LoadSelection();
+		break;
+	
 	case lcModelActionSelectionMode::Set:
 		LoadSelection();
 		break;
@@ -2294,9 +2321,9 @@ void lcModel::GroupSelection()
 
 	BeginActionSequence();
 
-	RecordSelectionAction(lcModelActionSelectionMode::Restore, nullptr, 0, lcSelectionMode::Single);
+	RecordSelectionAction(lcModelActionSelectionMode::Restore, std::vector<lcObject*>(), nullptr, 0, lcSelectionMode::Single);
 	RecordGroupPiecesAction(lcModelActionGroupPiecesMode::Group, Dialog.mName);
-	RecordSelectionAction(lcModelActionSelectionMode::Save, nullptr, 0, lcSelectionMode::Single);
+	RecordSelectionAction(lcModelActionSelectionMode::Save, std::vector<lcObject*>(), nullptr, 0, lcSelectionMode::Single);
 
 	EndActionSequence(tr("Group"));
 }
@@ -2328,9 +2355,9 @@ void lcModel::UngroupSelection()
 
 	BeginActionSequence();
 
-	RecordSelectionAction(lcModelActionSelectionMode::Restore, nullptr, 0, lcSelectionMode::Single);
+	RecordSelectionAction(lcModelActionSelectionMode::Restore, std::vector<lcObject*>(), nullptr, 0, lcSelectionMode::Single);
 	RecordGroupPiecesAction(lcModelActionGroupPiecesMode::Ungroup, QString());
-	RecordSelectionAction(lcModelActionSelectionMode::Save, nullptr, 0, lcSelectionMode::Single);
+	RecordSelectionAction(lcModelActionSelectionMode::Save, std::vector<lcObject*>(), nullptr, 0, lcSelectionMode::Single);
 
 	EndActionSequence(tr("Ungroup"));
 }
@@ -2656,7 +2683,7 @@ lcPiece* lcModel::AddPiece(PieceInfo* Info, quint32 Section)
 	}
 
 	gMainWindow->UpdateTimeline(false, false);
-	RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, Piece, LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
+	RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, std::vector<lcObject*>(), Piece, LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
 //	ClearSelectionAndSetFocus(Piece, LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
 
 	SaveCheckpoint(tr("Adding Piece"));
@@ -3216,7 +3243,7 @@ void lcModel::MoveSelectionToModel(lcModel* Model)
 	SaveCheckpoint(tr("New Model"));
 	gMainWindow->UpdateTimeline(false, false);
 //	ClearSelectionAndSetFocus(ModelPiece, LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
-	RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, ModelPiece, LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
+	RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, std::vector<lcObject*>(), ModelPiece, LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
 }
 
 void lcModel::InlineSelectedModels()
@@ -4439,28 +4466,35 @@ std::vector<lcObject*> lcModel::GetSelectionModePieces(lcSelectionMode Selection
 void lcModel::ClearSelection()
 {
 	BeginActionSequence();
-	RecordSelectionAction(lcModelActionSelectionMode::ClearSelection, nullptr, 0, lcSelectionMode::Single);
+	RecordSelectionAction(lcModelActionSelectionMode::ClearSelection, std::vector<lcObject*>(), nullptr, 0, lcSelectionMode::Single);
 	EndActionSequence(tr("Selection"));
 }
 
 void lcModel::ClearSelectionAndSetFocus(lcObject* Object, quint32 Section, lcSelectionMode SelectionMode)
 {
 	BeginActionSequence();
-	RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, Object, Section, SelectionMode);
+	RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, std::vector<lcObject*>(), Object, Section, SelectionMode);
 	EndActionSequence(tr("Selection"));	
 }
 
 void lcModel::SelectAllPieces()
 {
 	BeginActionSequence();
-	RecordSelectionAction(lcModelActionSelectionMode::SelectAllPieces, nullptr, 0, lcSelectionMode::Single);
+	RecordSelectionAction(lcModelActionSelectionMode::SelectAllPieces, std::vector<lcObject*>(), nullptr, 0, lcSelectionMode::Single);
 	EndActionSequence(tr("Selection"));
 }
 
 void lcModel::InvertPieceSelection()
 {
 	BeginActionSequence();
-	RecordSelectionAction(lcModelActionSelectionMode::InvertPieceSelection, nullptr, 0, lcSelectionMode::Single);
+	RecordSelectionAction(lcModelActionSelectionMode::InvertPieceSelection, std::vector<lcObject*>(), nullptr, 0, lcSelectionMode::Single);
+	EndActionSequence(tr("Selection"));
+}
+
+void lcModel::RemoveFromSelection(const std::vector<lcObject*>& Objects, lcSelectionMode SelectionMode)
+{
+	BeginActionSequence();
+	RecordSelectionAction(lcModelActionSelectionMode::RemoveFromSelection, Objects, nullptr, 0, SelectionMode);
 	EndActionSequence(tr("Selection"));
 }
 
@@ -4476,19 +4510,18 @@ void lcModel::DeselectAllObjects()
 		Light->SetSelected(false);
 }
 
-void lcModel::SelectObjects(const std::vector<lcObject*>& Objects, lcStep Step)
+void lcModel::SelectObjects(const std::vector<lcObject*>& Objects, lcStep Step, bool Select)
 {
-    for (lcObject* Object : Objects)
-    {
-        const bool WasSelected = Object->IsSelected();
-        Object->SetSelected(true);
-        
-        if (Object->IsPiece())
-        {
-            if (!WasSelected)
-                SelectGroup(((lcPiece*)Object)->GetTopGroup(), Step, true);
-        }
-    }
+	for (lcObject* Object : Objects)
+	{
+		if (Object->IsSelected() == Select)
+			continue;
+		
+		Object->SetSelected(Select);
+		
+		if (Object->IsPiece())
+			SelectGroup(dynamic_cast<lcPiece*>(Object)->GetTopGroup(), Step, Select);
+	}
 }
 
 void lcModel::SelectGroup(lcGroup* TopGroup, lcStep Step, bool Select)
@@ -4596,75 +4629,6 @@ void lcModel::AddToSelection(const std::vector<lcObject*>& Objects, bool EnableS
 	}
 }
 
-void lcModel::RemoveFromSelection(const std::vector<lcObject*>& Objects)
-{
-	for (lcObject* SelectedObject : Objects)
-	{
-		const bool WasSelected = SelectedObject->IsSelected();
-		SelectedObject->SetSelected(false);
-
-		if (WasSelected && SelectedObject->IsPiece())
-		{
-			lcPiece* Piece = (lcPiece*)SelectedObject;
-
-			if (gMainWindow->GetSelectionMode() == lcSelectionMode::Single)
-				SelectGroup(Piece->GetTopGroup(), mCurrentStep, false);
-			else
-			{
-				std::vector<lcObject*> Pieces = GetSelectionModePieces(gMainWindow->GetSelectionMode(), Piece, mCurrentStep);
-
-				for (lcObject* Object : Pieces)
-				{
-					if (Object->IsSelected())
-					{
-						Object->SetSelected(false);
-						SelectGroup(((lcPiece*)Object)->GetTopGroup(), mCurrentStep, false);
-					}
-				}
-			}
-		}
-	}
-
-	gMainWindow->UpdateSelectedObjects(true);
-	UpdateAllViews();
-}
-
-void lcModel::RemoveFromSelection(const lcObjectSection& ObjectSection)
-{
-	lcObject* SelectedObject = ObjectSection.Object;
-
-	if (!SelectedObject)
-		return;
-
-	const bool WasSelected = SelectedObject->IsSelected();
-
-	SelectedObject->SetSelected(false);
-
-	if (SelectedObject->IsPiece() && WasSelected)
-	{
-		lcPiece* Piece = (lcPiece*)SelectedObject;
-
-		if (gMainWindow->GetSelectionMode() == lcSelectionMode::Single)
-			SelectGroup(Piece->GetTopGroup(), mCurrentStep, false);
-		else
-		{
-			std::vector<lcObject*> Pieces = GetSelectionModePieces(gMainWindow->GetSelectionMode(), Piece, mCurrentStep);
-
-			for (lcObject* Object : Pieces)
-			{
-				if (Object->IsSelected())
-				{
-					Object->SetSelected(false);
-					SelectGroup(((lcPiece*)Object)->GetTopGroup(), mCurrentStep, false);
-				}
-			}
-		}
-	}
-
-	gMainWindow->UpdateSelectedObjects(true);
-	UpdateAllViews();
-}
-
 void lcModel::HideSelectedPieces()
 {
 	BeginActionSequence();
@@ -4903,7 +4867,7 @@ void lcModel::FindReplacePiece(bool SearchForward, bool FindAll, bool Replace)
 		SetSelectionAndFocus(Selection, nullptr, 0, false);
 	else
 //		ClearSelectionAndSetFocus(Focus, LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
-		RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, Focus, LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
+		RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, std::vector<lcObject*>(), Focus, LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
 
 	if (ReplacedCount)
 	{
@@ -5092,7 +5056,7 @@ void lcModel::InsertPieceToolClicked(const std::vector<lcInsertPieceInfo>& Piece
 	
 	EndObjectEditAction(std::move(PieceIndices));
 	
-	RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, Piece, LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
+	RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, std::vector<lcObject*>(), Piece, LC_PIECE_SECTION_POSITION, lcSelectionMode::Single);
 	
 	EndActionSequence(tr("Add Piece"));
 	
@@ -5114,7 +5078,7 @@ void lcModel::InsertCameraToolClicked(const lcVector3& Position)
 	
 	EndObjectEditAction({ mCameras.size() - 1 });
 	
-	RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, Camera, LC_CAMERA_SECTION_POSITION, lcSelectionMode::Single);
+	RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, std::vector<lcObject*>(), Camera, LC_CAMERA_SECTION_POSITION, lcSelectionMode::Single);
 	
 	EndActionSequence(tr("Add Camera"));
 }
@@ -5155,7 +5119,7 @@ void lcModel::InsertLightToolClicked(const lcVector3& Position, lcLightType Ligh
 	
 	EndObjectEditAction({ mLights.size() - 1 });
 	
-	RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, Light, LC_LIGHT_SECTION_POSITION, lcSelectionMode::Single);
+	RecordSelectionAction(lcModelActionSelectionMode::ClearSelectionAndSetFocus, std::vector<lcObject*>(), Light, LC_LIGHT_SECTION_POSITION, lcSelectionMode::Single);
 	
 	EndActionSequence(ActionName);
 }

common/lc_model.h

@@ -327,12 +327,11 @@ public:
 	void ClearSelectionAndSetFocus(lcObject* Object, quint32 Section, lcSelectionMode SelectionMode);
 	void SelectAllPieces();
 	void InvertPieceSelection();
-    // to update:	
+	void RemoveFromSelection(const std::vector<lcObject*>& Objects, lcSelectionMode SelectionMode);
+	// to update:	
 	void FocusOrDeselectObject(const lcObjectSection& ObjectSection);
 	void SetSelectionAndFocus(const std::vector<lcObject*>& Selection, lcObject* Focus, quint32 Section, bool EnableSelectionMode);
 	void AddToSelection(const std::vector<lcObject*>& Objects, bool EnableSelectionMode, bool UpdateInterface);
-	void RemoveFromSelection(const std::vector<lcObject*>& Objects);
-	void RemoveFromSelection(const lcObjectSection& ObjectSection);
 
 	void HideSelectedPieces();
 	void HideUnselectedPieces();
@@ -406,7 +405,7 @@ public:
 protected:
 	void DeleteModel();
 
-	void RecordSelectionAction(lcModelActionSelectionMode ModelActionSelectionMode, lcObject* FocusObject, uint32_t FocusSection, lcSelectionMode SelectionMode);
+	void RecordSelectionAction(lcModelActionSelectionMode ModelActionSelectionMode, const std::vector<lcObject*>& Objects, lcObject* FocusObject, uint32_t FocusSection, lcSelectionMode SelectionMode);
 	void RunSelectionAction(const lcModelActionSelection* ModelActionSelection, bool Apply);
 	void BeginObjectEditAction(lcModelActionObjectEditMode ModelActionObjectEditMode, const lcCamera* Camera);
 	void EndObjectEditAction(std::vector<size_t>&& ObjectIndices = std::vector<size_t>(), std::vector<size_t>&& GroupIndices = std::vector<size_t>());
@@ -430,7 +429,7 @@ protected:
 	
 	std::vector<lcObject*> GetSelectionModePieces(lcSelectionMode SelectionMode, const lcPiece* SelectedPiece, lcStep Step) const;
 	void DeselectAllObjects();
-	void SelectObjects(const std::vector<lcObject*>& Objects, lcStep Step);
+	void SelectObjects(const std::vector<lcObject*>& Objects, lcStep Step, bool Select);
 	void SelectGroup(lcGroup* TopGroup, lcStep Step, bool Select);
 
 	size_t AddPiece(lcPiece* Piece);

common/lc_modelaction.cpp

@@ -173,13 +173,13 @@ bool lcModelAction::LoadHistoryBuffer(const QByteArray& Buffer, lcModel* Model,
 				return false;
 			
 			const std::unique_ptr<lcLight>& Light = Lights[LightIndex];
-			
+
 			if (!Light->LoadUndoData(Stream, Model))
 				return false;
 		}
-	}		
-		
-	return true;	
+	}
+
+	return true;
 }
 
 lcModelActionSelection::lcModelActionSelection(lcModelActionSelectionMode Mode, lcStep Step)
@@ -187,25 +187,64 @@ lcModelActionSelection::lcModelActionSelection(lcModelActionSelectionMode Mode,
 {
 }
 
-bool lcModelActionSelection::Initialize(const lcModel* Model, lcObject* FocusObject, uint32_t FocusSection, lcSelectionMode SelectionMode)
+bool lcModelActionSelection::Initialize(const lcModel* Model, const std::vector<lcObject*>& Objects, lcObject* FocusObject, uint32_t FocusSection, lcSelectionMode SelectionMode)
 {
-	if (!HasChanges(Model, FocusObject, FocusSection))
+	if (!HasChanges(Model, Objects, FocusObject, FocusSection))
 		return false;
-	
+
 	mSelectionMode = SelectionMode;
 
-	SaveSelection(Model);
+	SavePreviousSelection(Model);
+	SaveNewObjects(Objects, Model);
 	SaveNewFocusObject(Model, FocusObject, FocusSection);
 	
 	return true;
 }
 
-bool lcModelActionSelection::HasChanges(const lcModel* Model, lcObject* FocusObject, uint32_t FocusSection) const
+size_t lcModelActionSelection::GetObjectIndex(const lcObject* Object, const lcModel* Model)
+{
+	switch (Object->GetType())
+	{
+		case lcObjectType::Piece:
+		{
+			const std::vector<std::unique_ptr<lcPiece>>& Pieces = Model->GetPieces();
+		
+			for (size_t PieceIndex = 0; PieceIndex < Pieces.size(); PieceIndex++)
+				if (Pieces[PieceIndex].get() == Object)
+					return PieceIndex;
+		}
+		break;
+		
+	case lcObjectType::Camera:
+		{
+			const std::vector<std::unique_ptr<lcCamera>>& Cameras = Model->GetCameras();
+		
+			for (size_t CameraIndex = 0; CameraIndex < Cameras.size(); CameraIndex++)
+				if (Cameras[CameraIndex].get() == Object)
+					return CameraIndex;
+		}
+		break;
+		
+	case lcObjectType::Light:
+		{
+			const std::vector<std::unique_ptr<lcLight>>& Lights = Model->GetLights();
+		
+			for (size_t LightIndex = 0; LightIndex < Lights.size(); LightIndex++)
+				if (Lights[LightIndex].get() == Object)
+					return LightIndex;
+		}
+		break;
+	}
+
+	return SIZE_T_MAX;
+}
+
+bool lcModelActionSelection::HasChanges(const lcModel* Model, const std::vector<lcObject*>& Objects, lcObject* FocusObject, uint32_t FocusSection) const
 {
 	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();
-	
+
 	switch (mMode)
 	{
 	case lcModelActionSelectionMode::ClearSelection:
@@ -243,16 +282,23 @@ bool lcModelActionSelection::HasChanges(const lcModel* Model, lcObject* FocusObj
 		
 		return false;
 		
+	case lcModelActionSelectionMode::RemoveFromSelection:
+		for (lcObject* Object : Objects)
+			if (Object->IsSelected())
+				return true;
+		
+		return false;
+		
 	case lcModelActionSelectionMode::Set:
 	case lcModelActionSelectionMode::Save:
 	case lcModelActionSelectionMode::Restore:
 		break;
 	}
 	
-	return true;	
+	return true;
 }
 
-void lcModelActionSelection::SaveSelection(const lcModel* Model)
+void lcModelActionSelection::SavePreviousSelection(const lcModel* Model)
 {
 	const std::vector<std::unique_ptr<lcPiece>>& Pieces = Model->GetPieces();
 	const std::vector<std::unique_ptr<lcCamera>>& Cameras = Model->GetCameras();
@@ -312,61 +358,54 @@ void lcModelActionSelection::SaveSelection(const lcModel* Model)
 	}
 }
 
+void lcModelActionSelection::SaveNewObjects(const std::vector<lcObject*>& Objects, const lcModel* Model)
+{
+	mNewObjects.clear();
+	mNewObjects.reserve(Objects.size());
+	
+	for (lcObject* Object : Objects)
+		mNewObjects.emplace_back(GetObjectIndex(Object, Model), Object->GetType());
+}
+
 void lcModelActionSelection::SaveNewFocusObject(const lcModel* Model, lcObject* FocusObject, uint32_t FocusSection)
 {
 	if (!FocusObject)
 		return;
-	
+
 	mNewFocusSection = FocusSection;
 	mNewFocusObjectType = FocusObject->GetType();
+	mNewFocusIndex = GetObjectIndex(FocusObject, Model);
+}
+
+std::vector<lcObject*> lcModelActionSelection::GetNewObjects(const lcModel* Model) const
+{
+	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();
+	std::vector<lcObject*> Objects;
 	
-	switch (FocusObject->GetType())
+	for (auto [ObjectIndex, ObjectType] : mNewObjects)
 	{
-	case lcObjectType::Piece:
+		switch (ObjectType)
 		{
-			const std::vector<std::unique_ptr<lcPiece>>& Pieces = Model->GetPieces();
-		
-			for (size_t PieceIndex = 0; PieceIndex < Pieces.size(); PieceIndex++)
-			{
-				if (Pieces[PieceIndex].get() == FocusObject)
-				{
-					mNewFocusIndex = PieceIndex;
-					break;
-				}
-			}
+		case lcObjectType::Piece:
+			if (ObjectIndex < Pieces.size())
+				Objects.push_back(Pieces[ObjectIndex].get());
+			break;
+			
+		case lcObjectType::Camera:
+			if (ObjectIndex < Cameras.size())
+				Objects.push_back(Cameras[ObjectIndex].get());
+			break;
+			
+		case lcObjectType::Light:
+			if (ObjectIndex < Lights.size())
+				Objects.push_back(Lights[ObjectIndex].get());
+			break;
 		}
-		break;
-		
-	case lcObjectType::Camera:
-		{
-			const std::vector<std::unique_ptr<lcCamera>>& Cameras = Model->GetCameras();
-		
-			for (size_t CameraIndex = 0; CameraIndex < Cameras.size(); CameraIndex++)
-			{
-				if (Cameras[CameraIndex].get() == FocusObject)
-				{
-					mNewFocusIndex = CameraIndex;
-					break;
-				}
-			}
-		}
-		break;
-		
-	case lcObjectType::Light:
-		{
-			const std::vector<std::unique_ptr<lcLight>>& Lights = Model->GetLights();
-		
-			for (size_t LightIndex = 0; LightIndex < Lights.size(); LightIndex++)
-			{
-				if (Lights[LightIndex].get() == FocusObject)
-				{
-					mNewFocusIndex = LightIndex;
-					break;
-				}
-			}
-		}
-		break;
 	}
+	
+	return Objects;
 }
 
 lcObject* lcModelActionSelection::GetNewFocusObject(const lcModel* Model) const
@@ -404,8 +443,12 @@ lcObject* lcModelActionSelection::GetNewFocusObject(const lcModel* Model) const
 	return nullptr;
 }
 
-std::tuple<std::vector<lcObject*>, lcObject*, uint32_t> lcModelActionSelection::GetSelection(const std::vector<std::unique_ptr<lcPiece>>& Pieces, const std::vector<std::unique_ptr<lcCamera>>& Cameras, const std::vector<std::unique_ptr<lcLight>>& Lights) const
+std::tuple<std::vector<lcObject*>, lcObject*, uint32_t> lcModelActionSelection::GetPreviousSelection(const lcModel* Model) const
 {
+	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();
+	
 	std::vector<lcObject*> SelectedObjects;
 	lcObject* FocusObject = nullptr;
 

common/lc_modelaction.h

@@ -25,6 +25,7 @@ enum class lcModelActionSelectionMode
 	ClearSelectionAndSetFocus,
 	SelectAllPieces,
 	InvertPieceSelection,
+	RemoveFromSelection,
 	Set,
 	Save,
 	Restore
@@ -36,7 +37,7 @@ public:
 	lcModelActionSelection(lcModelActionSelectionMode Mode, lcStep Step);
 	virtual ~lcModelActionSelection() = default;
 	
-	bool Initialize(const lcModel* Model, lcObject* FocusObject, uint32_t FocusSection, lcSelectionMode SelectionMode);
+	bool Initialize(const lcModel* Model, const std::vector<lcObject*>& Objects, lcObject* FocusObject, uint32_t FocusSection, lcSelectionMode SelectionMode);
 	
 	lcModelActionSelectionMode GetMode() const
 	{
@@ -58,12 +59,15 @@ public:
 		return mNewFocusSection;
 	}
 	
+	std::vector<lcObject*> GetNewObjects(const lcModel* Model) const;
 	lcObject* GetNewFocusObject(const lcModel* Model) const;
-	std::tuple<std::vector<lcObject*>, lcObject*, uint32_t> GetSelection(const std::vector<std::unique_ptr<lcPiece>>& Pieces, const std::vector<std::unique_ptr<lcCamera>>& Cameras, const std::vector<std::unique_ptr<lcLight>>& Lights) const;
+	std::tuple<std::vector<lcObject*>, lcObject*, uint32_t> GetPreviousSelection(const lcModel* Model) const;
 
 protected:
-	bool HasChanges(const lcModel* Model, lcObject* FocusObject, uint32_t FocusSection) const;
-	void SaveSelection(const lcModel* Model);
+	static size_t GetObjectIndex(const lcObject* Object, const lcModel* Model);
+	bool HasChanges(const lcModel* Model, const std::vector<lcObject*>& Objects, lcObject* FocusObject, uint32_t FocusSection) const;
+	void SavePreviousSelection(const lcModel* Model);
+	void SaveNewObjects(const std::vector<lcObject*>& Objects, const lcModel* Model);
 	void SaveNewFocusObject(const lcModel* Model, lcObject* FocusObject, uint32_t FocusSection);
 	
 	std::vector<size_t> mPreviousSelectedPieces;
@@ -73,6 +77,7 @@ protected:
 	uint32_t mPreviousFocusSection = 0;
 	lcObjectType mPreviousFocusObjectType = (lcObjectType)0;
 	
+	std::vector<std::pair<size_t, lcObjectType>> mNewObjects;
 	size_t mNewFocusIndex = SIZE_MAX;
 	uint32_t mNewFocusSection = 0;
 	lcObjectType mNewFocusObjectType = (lcObjectType)0;

common/lc_view.cpp

@@ -2423,7 +2423,7 @@ void lcView::StopTracking(bool Accept)
 			if (mMouseModifiers & Qt::ControlModifier)
 				ActiveModel->AddToSelection(Objects, true, true);
 			else if (mMouseModifiers & Qt::ShiftModifier)
-				ActiveModel->RemoveFromSelection(Objects);
+				ActiveModel->RemoveFromSelection(Objects, lcSelectionMode::Single);
 			else
 				ActiveModel->SetSelectionAndFocus(Objects, nullptr, 0, true);
 		}
@@ -2575,7 +2575,10 @@ void lcView::OnButtonDown(lcTrackButton TrackButton)
 			if (mMouseModifiers & Qt::ControlModifier)
 				ActiveModel->FocusOrDeselectObject(ObjectSection);
 			else if (mMouseModifiers & Qt::ShiftModifier)
-				ActiveModel->RemoveFromSelection(ObjectSection);
+		    {
+			    if (ObjectSection.Object)
+				    ActiveModel->RemoveFromSelection({ ObjectSection.Object }, gMainWindow->GetSelectionMode());
+		    }
 			else
 				ActiveModel->ClearSelectionAndSetFocus(ObjectSection.Object, ObjectSection.Section, gMainWindow->GetSelectionMode());
 
@@ -2739,7 +2742,10 @@ void lcView::OnLeftButtonDoubleClick()
 	if (mMouseModifiers & Qt::ControlModifier)
 		ActiveModel->FocusOrDeselectObject(ObjectSection);
 	else if (mMouseModifiers & Qt::ShiftModifier)
-		ActiveModel->RemoveFromSelection(ObjectSection);
+	{
+		if (ObjectSection.Object)
+			ActiveModel->RemoveFromSelection({ ObjectSection.Object }, gMainWindow->GetSelectionMode());
+	}
 	else
 		ActiveModel->ClearSelectionAndSetFocus(ObjectSection.Object, ObjectSection.Section, gMainWindow->GetSelectionMode());
 }

common/light.cpp

@@ -905,7 +905,7 @@ void lcLight::SetupLightMatrix(lcContext* Context) const
 	const lcPreferences& Preferences = lcGetPreferences();
 	const float LineWidth = Preferences.mLineWidth;
 
-	if (IsSelected(LC_LIGHT_SECTION_POSITION))
+	if (IsSelected())
 	{
 		const lcVector4 SelectedColor = lcVector4FromColor(Preferences.mObjectSelectedColor);
 		const lcVector4 FocusedColor = lcVector4FromColor(Preferences.mObjectFocusedColor);
@@ -1066,7 +1066,7 @@ void lcLight::DrawTarget(lcContext* Context) const
 	const lcPreferences& Preferences = lcGetPreferences();
 	const float LineWidth = Preferences.mLineWidth;
 
-	if (IsSelected(LC_LIGHT_SECTION_TARGET))
+	if (IsSelected())
 	{
 		const lcVector4 SelectedColor = lcVector4FromColor(Preferences.mObjectSelectedColor);
 		const lcVector4 FocusedColor = lcVector4FromColor(Preferences.mObjectFocusedColor);

common/light.h

@@ -81,13 +81,6 @@ public:
 		return mSelected;
 	}
 
-	bool IsSelected(quint32 Section) const override
-	{
-		Q_UNUSED(Section);
-
-		return mSelected;
-	}
-
 	void SetSelected(bool Selected) override
 	{
 		mSelected = Selected;

common/object.h

@@ -88,7 +88,6 @@ public:
 	}
 
 	virtual bool IsSelected() const = 0;
-	virtual bool IsSelected(quint32 Section) const = 0;
 	virtual void SetSelected(bool Selected) = 0;
 	virtual bool IsFocused() const = 0;
 	virtual bool IsFocused(quint32 Section) const = 0;

common/piece.h

@@ -41,13 +41,6 @@ public:
 		return mSelected;
 	}
 
-	bool IsSelected(quint32 Section) const override
-	{
-		Q_UNUSED(Section);
-
-		return mSelected;
-	}
-
 	void SetSelected(bool Selected) override
 	{
 		mSelected = Selected;