/// <summary>
/// Method to invoke when the Paste command is executed.
/// </summary>
private void Paste()
{
System.Windows.Forms.IDataObject dataObject = System.Windows.Forms.Clipboard.GetDataObject();
if (dataObject != null && SelectedItems.Count == 1)
{
if (dataObject.GetDataPresent(ClipboardFormatName.Name))
{
var parent = SelectedItem;
DeselectAll();
var data = dataObject.GetData(ClipboardFormatName.Name) as List <ElementModel>;
if (data != null)
{
foreach (var elementModel in data)
{
if (parent.ElementModel.Equals(elementModel) || parent.Children.Contains(elementModel))
{
continue;
}
//if(elementModel.Parents.Contains(parent.ElementModel.Id)) continue; //Don't add another copy
PropModelServices.Instance().FindOrCreateElementModelTree(elementModel, parent.ElementModel);
}
}
OnModelsChanged();
SelectModels(new[] { parent });
}
}
}
/// <summary>
/// Method to invoke when the OpenProp command is executed.
/// </summary>
private async void OpenProp()
{
var dependencyResolver = this.GetDependencyResolver();
var openFileService = dependencyResolver.Resolve <IOpenFileService>();
openFileService.IsMultiSelect = false;
openFileService.InitialDirectory = _lastOpenFolderPath;
openFileService.Filter = "Prop Files(*.prp)|*.prp";
openFileService.FileName = string.Empty;
if (await openFileService.DetermineFileAsync())
{
string path = openFileService.FileNames.First();
if (!string.IsNullOrEmpty(path))
{
_lastOpenFolderPath = Path.GetDirectoryName(path);
Prop p = PropModelServices.Instance().LoadProp(path);
if (p != null)
{
Prop = p;
FilePath = path;
ClearDirtyFlag();
}
else
{
//Alert user
}
}
}
}
/// <summary>
/// Method to invoke when the AddLight command is executed.
/// </summary>
private void AddLight(Point p)
{
var target = ElementTreeViewModel.SelectedItem;
var model = PropModelServices.Instance().AddLight(target?.ElementModel, p);
if (model == null)
{
return;
}
DrawingPanelViewModel.RefreshLightViewModels();
ElementOrderViewModel.RefreshElementLeafViewModels();
if (model == target?.ElementModel)
{
ElementTreeViewModel.SelectModels(new[] { target });
}
else
{
var vms = ElementModelLookUpService.Instance.GetModels(model.Id);
var viewModel = vms.First();
var parent = viewModel.ParentViewModel as ElementModelViewModel;
if (parent != null)
{
ElementTreeViewModel.SelectModels(new[] { parent });
parent.IsExpanded = true;
}
}
}
public bool SubstitutionRenameSelectedItems()
{
if (SelectedItems.Count <= 1)
{
return(false);
}
List <string> oldNames = new List <string>(SelectedItems.Select(x => x.Name).ToArray());
SubstitutionRenamer renamer = new SubstitutionRenamer(oldNames);
if (renamer.ShowDialog() == DialogResult.OK)
{
for (int i = 0; i < SelectedItems.Count; i++)
{
if (i >= renamer.Names.Count)
{
Logging.Warn("Bulk renaming elements, and ran out of new names!");
break;
}
SelectedItems[i].Name = PropModelServices.Instance().Uniquify(renamer.Names[i], 2, SelectedItems[i].ElementModel);
}
return(true);
}
return(false);
}
public void DeleteSelectedLights()
{
var lightstoDelete = SelectedItems.Select(l => l.Light).ToList();
DeselectAll();
PropModelServices.Instance().RemoveLights(lightstoDelete);
RefreshLightViewModels();
}
/// <summary>
/// Method to invoke when the EditFocusLost command is executed.
/// </summary>
private void DoneEditing()
{
if (PropModelServices.Instance().IsNameDuplicated(ElementModel.Name))
{
ElementModel.Name = PropModelServices.Instance().Uniquify(ElementModel.Name);
}
IsEditing = false;
IsDirty = true;
}
private void Assemble(Dictionary <int, ModelNode> modelNodes, List <SubModel> subModels, int nodeSize)
{
Dictionary <int, ElementModel> lightNodes = new Dictionary <int, ElementModel>();
foreach (var subModel in subModels)
{
var group = PropModelServices.Instance().CreateNode(subModel.Name);
if (subModel.FaceInfo.FaceComponent != FaceComponent.None)
{
group.FaceComponent = subModel.FaceInfo.FaceComponent;
}
foreach (var smRange in subModel.Ranges)
{
var start = smRange.Start < smRange.End ? smRange.Start : smRange.End;
var end = smRange.Start < smRange.End ? smRange.End : smRange.Start;
for (int i = start; i <= end; i++)
{
if (modelNodes.ContainsKey(i))
{
var modelNode = modelNodes[i];
modelNodes.Remove(i);
var lightNode = PropModelServices.Instance().AddLightNode(group, new Point(modelNode.X + Offset, modelNode.Y + Offset), modelNode.Order, nodeSize);
if (!lightNodes.ContainsKey(modelNode.Order))
{
lightNodes.Add(modelNode.Order, lightNode);
}
}
else
{
//We have probably already associated it with another group so look it up
ElementModel lightNode;
if (lightNodes.TryGetValue(i, out lightNode))
{
PropModelServices.Instance().AddToParent(lightNode, group);
}
}
}
}
}
if (modelNodes.Any())
{
ElementModel em = null;
if (subModels.Any())
{
//Create a group to hold the stuff that was not included in the submodels
em = PropModelServices.Instance().CreateNode("Other");
}
foreach (var modelNode in modelNodes.OrderBy(x => x.Value.Order))
{
PropModelServices.Instance().AddLightNode(em, new Point(modelNode.Value.X + Offset, modelNode.Value.Y + Offset),
modelNode.Value.Order, nodeSize);
}
}
}
public void RemoveFromParent()
{
var parentVm = ParentViewModel as ElementModelViewModel;
if (parentVm != null)
{
PropModelServices.Instance().RemoveFromParent(ElementModel, parentVm.ElementModel);
IsDirty = true;
}
}
private async Task <Prop> LoadModelFileAsync(string filePath)
{
Prop p = null;
XmlReaderSettings settings = new XmlReaderSettings();
settings.Async = true;
using (XmlReader reader = XmlReader.Create(filePath, settings))
{
await reader.MoveToContentAsync();
if ("custommodel".Equals(reader.Name) && reader.HasAttributes)
{
string name = reader.GetAttribute("name");
p = PropModelServices.Instance().CreateProp(name);
//These are the size of the grid near as I can tell
//We will use them to gauge a scale.
int x, y;
int.TryParse(reader.GetAttribute("parm1"), out x);
int.TryParse(reader.GetAttribute("parm2"), out y);
CalculateScale(x, y);
int nodeSize;
int.TryParse(reader.GetAttribute("PixelSize"), out nodeSize);
string model = reader.GetAttribute("CustomModel");
List <SubModel> subModels = new List <SubModel>();
while (reader.Read())
{
if ("subModel".Equals(reader.Name))
{
SubModel sm = new SubModel();
sm.Name = reader.GetAttribute("name");
sm.Layout = reader.GetAttribute("layout");
var type = reader.GetAttribute("type");
switch (type)
{
case "ranges":
sm.Type = SubModelType.Ranges;
sm.Ranges = ParseRanges(reader.GetAttribute("line0"));
break;
}
subModels.Add(sm);
}
}
var modelNodes = await CreateModelNodesAsync(model);
Assemble(modelNodes, subModels, nodeSize);
}
}
return(p);
}
/// <summary>
/// Method to invoke when the DecreaseLightSize command is executed.
/// </summary>
private void DecreaseLightSize()
{
foreach (var lightViewModel in SelectedItems)
{
var em = PropModelServices.Instance().GetElementModel(lightViewModel.Light.ParentModelId);
if (em != null)
{
em.LightSize--;
}
}
}
/// <summary>
/// Method to invoke when the CreateNode command is executed.
/// </summary>
private void CreateNode()
{
var result = RequestNewGroupName(PropModelServices.Instance().Uniquify(SelectedItem.ElementModel.Name));
if (result.Result == MessageResult.OK)
{
PropModelServices.Instance().CreateNode(result.Response, SelectedItem.ElementModel);
//Ensure parent is expanded
SelectedItem.IsExpanded = true;
}
}
/// <summary>
/// Method to invoke when the NewProp command is executed.
/// </summary>
private void NewProp()
{
MessageBoxService mbs = new MessageBoxService();
var result = mbs.GetUserInput("Please enter the model name.", "Create Model", "New Prop");
if (result.Result == MessageResult.OK)
{
Prop = PropModelServices.Instance().CreateProp(result.Response);
FilePath = string.Empty;
}
}
/// <summary>
/// Method to invoke when the CreateGroup command is executed.
/// </summary>
private void CreateGroup()
{
var result = RequestNewGroupName(String.Empty);
if (result.Result == MessageResult.OK)
{
var elementsToGroup = SelectedItems.Select(x => x.ElementModel).ToList();
DeselectAll();
PropModelServices.Instance().CreateGroupForElementModels(result.Response, elementsToGroup);
OnModelsChanged();
}
}
private void LoadPropFromPath(string path)
{
Prop p = PropModelServices.Instance().LoadProp(path);
if (p != null)
{
Prop = p;
FilePath = path;
ClearDirtyFlag();
}
else
{
//Alert user
}
}
/// <summary>
/// Method to invoke when the TemplateRename command is executed.
/// </summary>
private void TemplateRename()
{
if (SelectedItems.Count == 1)
{
MessageBoxService mbs = new MessageBoxService();
var result = mbs.GetUserInput("Please enter the new name.", "Rename", SelectedItems[0].ElementModel.Name);
if (result.Result == MessageResult.OK)
{
SelectedItems.First().Name = PropModelServices.Instance().Uniquify(result.Response);
}
}
else
{
PatternRenameSelectedItems();
}
}
/// <summary>
/// Method to invoke when the NewProp command is executed.
/// </summary>
private void NewProp()
{
MessageBoxService mbs = new MessageBoxService();
var result = mbs.GetUserInput("Please enter the model name.", "Create Model", "New Prop");
if (result.Result == MessageResult.OK)
{
var name = result.Response;
if (!Regex.IsMatch(name, TokenPattern))
{
name = $"{name} {{1}}";
}
Prop = PropModelServices.Instance().CreateProp(name);
FilePath = string.Empty;
}
}
protected override void ValidateFields(List <IFieldValidationResult> validationResults)
{
if (string.IsNullOrEmpty(ElementModel.Name))
{
validationResults.Add(FieldValidationResult.CreateError(nameof(ElementModel.Name), "Name can not be empty"));
}
else if (PropModelServices.Instance().IsNameDuplicated(ElementModel.Name))
{
validationResults.Add(FieldValidationResult.CreateError(nameof(ElementModel.Name), "Duplicate name"));
}
if (ElementModel.LightSize <= 0)
{
validationResults.Add(FieldValidationResult.CreateError(nameof(ElementModel.LightSize), "Light size must be > 0"));
}
}
/// <summary>
/// Method to invoke when the LoadImage command is executed.
/// </summary>
private async void LoadImage()
{
var dependencyResolver = this.GetDependencyResolver();
var openFileService = dependencyResolver.Resolve <IOpenFileService>();
openFileService.IsMultiSelect = false;
openFileService.InitialDirectory = Environment.SpecialFolder.MyPictures.ToString();
openFileService.Filter = "Image Files(*.JPG;*.GIF;*.PNG)|*.JPG;*.GIF;*.PNG|All files (*.*)|*.*";
if (await openFileService.DetermineFileAsync())
{
string path = openFileService.FileNames.First();
if (!string.IsNullOrEmpty(path))
{
PropModelServices.Instance().SetImage(path);
}
}
}
/// <summary>
/// Method to invoke when the MatchLightSize command is executed.
/// </summary>
private void MatchLightSize()
{
if (SelectedItems.Count < 2)
{
return;
}
var lvmReference = SelectedItems.First();
var emReference = PropModelServices.Instance().GetElementModel(lvmReference.Light.ParentModelId);
foreach (var lightViewModel in SelectedItems.Skip(1))
{
var em = PropModelServices.Instance().GetElementModel(lightViewModel.Light.ParentModelId);
if (em != null)
{
em.LightSize = emReference.LightSize;
}
}
}
/// <summary>
/// Method to invoke when the SaveModelAs command is executed.
/// </summary>
private async void SaveModelAs()
{
ModifiedDate = DateTime.Now;
var dependencyResolver = this.GetDependencyResolver();
var saveFileService = dependencyResolver.Resolve <ISaveFileService>();
saveFileService.Filter = "Prop Files(*.prp)|*.prp";
saveFileService.CheckPathExists = true;
saveFileService.InitialDirectory = PropModelServices.Instance().ModelsFolder;
saveFileService.FileName = CleanseNameString(Prop.Name);
if (await saveFileService.DetermineFileAsync())
{
// User selected a file
if (PropModelPersistenceService.SaveModel(Prop, saveFileService.FileName))
{
FilePath = saveFileService.FileName;
ClearDirtyFlag();
}
}
}
public void DeleteSelectedLights()
{
var lightstoDelete = SelectedItems.Select(l => l.Light).ToList();
if (lightstoDelete.Any())
{
var dependencyResolver = this.GetDependencyResolver();
var mbs = dependencyResolver.Resolve <IMessageBoxService>();
var response = mbs.GetUserConfirmation(
"Deleting lights will remove them from all any/all groups they are part of. Are you sure?",
"Delete lights");
if (response.Result == MessageResult.OK)
{
DeselectAll();
PropModelServices.Instance().RemoveLights(lightstoDelete);
RefreshLightViewModels();
OnLightModelsChanged();
}
}
}
/// <summary>
/// Method to invoke when the MoveToGroup command is executed.
/// </summary>
private void MoveToGroup()
{
var result = RequestNewGroupName(String.Empty);
if (result.Result == MessageResult.OK)
{
var pms = PropModelServices.Instance();
//See if we are moving all items and can place the new group them under our parent group.
ElementModel parentForGroup = null;
var firstParentViewModel = SelectedItems.First().ParentViewModel as ElementModelViewModel;
if (firstParentViewModel != null && !firstParentViewModel.Children.Except(SelectedItems.Select(x => x.ElementModel)).Any())
{
parentForGroup = firstParentViewModel?.ElementModel;
}
var parentToJoin = pms.CreateNode(result.Response, parentForGroup);
foreach (var elementModelViewModel in SelectedItems.ToList())
{
elementModelViewModel.IsSelected = false;
ElementModel parentToLeave = (elementModelViewModel.ParentViewModel as ElementModelViewModel)?.ElementModel;
if (parentToLeave != null)
{
pms.AddToParent(elementModelViewModel.ElementModel, parentToJoin);
pms.RemoveFromParent(elementModelViewModel.ElementModel, parentToLeave);
}
}
OnModelsChanged();
DeselectAll();
var newModel = ElementModelLookUpService.Instance.GetModels(parentToJoin.Id);
if (newModel != null && newModel.Any())
{
newModel.First().IsExpanded = true;
SelectModels(newModel);
}
}
}
internal void RefreshLightViewModels()
{
_elementModelMap.Clear();
LightNodes.Clear();
SelectedItems.Clear();
foreach (var elementModel in PropModelServices.Instance().GetLeafNodes())
{
//See if we already have a lvm list for this element.
if (!_elementModelMap.ContainsKey(elementModel.Id))
{
List <LightViewModel> lightViewModels = new List <LightViewModel>();
//Build the lvm for these lights
foreach (var elementModelLight in elementModel.Lights)
{
var lvm = new LightViewModel(elementModelLight);
lightViewModels.Add(lvm);
}
_elementModelMap.Add(elementModel.Id, lightViewModels);
}
}
LightNodes.AddRange(_elementModelMap.Values.SelectMany(x => x.ToArray()));
}
/// <summary>
/// Method to invoke when the Cut command is executed.
/// </summary>
private void Cut()
{
List <ElementModel> clipData = new List <ElementModel>();
clipData.AddRange(SelectedItems.Select(x => x.ElementModel).ToList());
IDataObject dataObject = new DataObject(ClipboardFormatName);
dataObject.SetData(clipData);
Clipboard.SetDataObject(dataObject, true);
var itemsToCut = SelectedItems.ToList();
DeselectAll();
foreach (var elementModelViewModel in itemsToCut)
{
var parentToLeave = elementModelViewModel.ParentViewModel as ElementModelViewModel;
if (parentToLeave != null)
{
PropModelServices.Instance().RemoveFromParent(elementModelViewModel.ElementModel, parentToLeave.ElementModel);
}
}
OnModelsChanged();
}
/// <summary>
/// Method to invoke when the PasteAsNew command is executed.
/// </summary>
private void PasteAsNew()
{
System.Windows.Forms.IDataObject dataObject = System.Windows.Forms.Clipboard.GetDataObject();
if (dataObject != null && SelectedItems.Count == 1)
{
if (dataObject.GetDataPresent(ClipboardFormatName.Name))
{
var parent = SelectedItem;
MessageBoxService mbs = new MessageBoxService();
var result = mbs.GetUserInput("Please enter the new name.", "Paste As New", PropModelServices.Instance().Uniquify(parent.Name));
if (result.Result == MessageResult.OK)
{
DeselectAll();
var newElementModels = new List <ElementModelViewModel>();
var data = dataObject.GetData(ClipboardFormatName.Name) as List <ElementModel>;
if (data != null)
{
foreach (var elementModel in data)
{
var em = PropModelServices.Instance().CreateElementModelTree(elementModel, parent.ElementModel, result.Response);
var evm = ElementModelLookUpService.Instance.GetModels(em.Id);
if (evm != null)
{
newElementModels.AddRange(evm);
}
}
}
OnModelsChanged();
SelectModels(newElementModels);
}
}
}
}
private async Task <Prop> LoadModelFileAsync(string filePath)
{
Prop p = null;
XmlReaderSettings settings = new XmlReaderSettings();
settings.Async = true;
using (XmlReader reader = XmlReader.Create(filePath, settings))
{
await reader.MoveToContentAsync();
if ("custommodel".Equals(reader.Name) && reader.HasAttributes)
{
string name = reader.GetAttribute("name");
p = PropModelServices.Instance().CreateProp(name);
p.CreatedBy = @"xModel Import";
//These are the size of the grid near as I can tell
//We will use them to gauge a scale.
int x, y;
int.TryParse(reader.GetAttribute("parm1"), out x);
int.TryParse(reader.GetAttribute("parm2"), out y);
CalculateScale(x, y);
int nodeSize;
int.TryParse(reader.GetAttribute("PixelSize"), out nodeSize);
string model = reader.GetAttribute("CustomModel");
List <SubModel> subModels = new List <SubModel>();
while (reader.Read())
{
if (reader.NodeType != XmlNodeType.Element)
{
continue;
}
if ("subModel".Equals(reader.Name))
{
SubModel sm = new SubModel();
sm.Name = reader.GetAttribute("name");
sm.Layout = reader.GetAttribute("layout");
var type = reader.GetAttribute("type");
switch (type)
{
case "ranges":
sm.Type = SubModelType.Ranges;
sm.Ranges = ProcessRanges(reader); //ParseRanges(reader.GetAttribute("line0"));
break;
}
subModels.Add(sm);
}
else if ("faceInfo".Equals(reader.Name))
{
var type = reader.GetAttribute("Type");
if (!string.IsNullOrEmpty(type) && type.Equals("NodeRange"))
{
foreach (var attribute in FaceInfo.Attributes)
{
var range = reader.GetAttribute(attribute.Key);
if (!string.IsNullOrEmpty(range))
{
SubModel sm = new SubModel();
sm.Name = attribute.Key;
sm.Type = SubModelType.Ranges;
sm.Ranges = new List <RangeGroup> {
ParseRanges(range)
};
sm.FaceInfo = new FaceInfo(attribute.Value);
subModels.Add(sm);
}
}
}
}
}
var modelNodes = await CreateModelNodesAsync(model);
Assemble(modelNodes, subModels, nodeSize);
}
else
{
var dependencyResolver = this.GetDependencyResolver();
var ms = dependencyResolver.Resolve <IMessageService>();
await ms.ShowErrorAsync($"Unsupported model type: {reader.Name}. \nImport only supports custom model types at this time.", "Model import error");
}
}
return(p);
}
private void Assemble(Dictionary <int, ModelNode> modelNodes, List <SubModel> subModels, int nodeSize)
{
Dictionary <int, ElementModel> lightNodes = new Dictionary <int, ElementModel>();
foreach (var subModel in subModels)
{
var subModelGroup = PropModelServices.Instance().CreateNode(subModel.Name);
if (subModel.FaceInfo.FaceComponent != FaceComponent.None)
{
subModelGroup.FaceComponent = subModel.FaceInfo.FaceComponent;
}
bool addRangeGroup = subModel.Ranges.Count > 1;
int rangeGroupIndex = 1;
var subModelRangeGroup = subModelGroup;
foreach (var rangeGroup in subModel.Ranges)
{
if (addRangeGroup)
{
subModelRangeGroup = PropModelServices.Instance().CreateNode($"{subModelGroup.Name} {rangeGroupIndex}", subModelGroup);
}
foreach (var smRange in rangeGroup.Ranges)
{
int inc = smRange.Start > smRange.End ? -1 : 1;
for (int i = smRange.Start; ; i = i + inc)
{
if (inc > 0 && i > smRange.End)
{
break;
}
if (inc < 0 && i < smRange.End)
{
break;
}
if (modelNodes.ContainsKey(i))
{
var modelNode = modelNodes[i];
modelNodes.Remove(i);
var lightNode = PropModelServices.Instance().AddLightNode(subModelRangeGroup, new Point(modelNode.X + Offset, modelNode.Y + Offset), modelNode.Order, nodeSize);
if (!lightNodes.ContainsKey(modelNode.Order))
{
lightNodes.Add(modelNode.Order, lightNode);
}
}
else
{
//We have probably already associated it with another group so look it up
ElementModel lightNode;
if (lightNodes.TryGetValue(i, out lightNode))
{
PropModelServices.Instance().AddToParent(lightNode, subModelRangeGroup);
}
}
}
}
rangeGroupIndex++;
}
}
if (modelNodes.Any())
{
ElementModel em = null;
if (subModels.Any())
{
//Create a group to hold the stuff that was not included in the submodels
em = PropModelServices.Instance().CreateNode("Other");
}
foreach (var modelNode in modelNodes.OrderBy(x => x.Value.Order))
{
PropModelServices.Instance().AddLightNode(em, new Point(modelNode.Value.X + Offset, modelNode.Value.Y + Offset),
modelNode.Value.Order, nodeSize);
}
}
}
public PropEditorViewModel()
{
FilePath = String.Empty;
Prop = PropModelServices.Instance().CreateProp();
}
/// <inheritdoc />
public void Drop(IDropInfo dropInfo)
{
var models = dropInfo.Data as IList <ElementModelViewModel>;
if (models != null)
{
var pms = PropModelServices.Instance();
var targetModel = dropInfo.TargetItem as ElementModelViewModel;
var targetModelParent = targetModel?.ParentViewModel as ElementModelViewModel;
SelectedItems.Clear();
if (targetModel != null)
{
foreach (var elementModelViewModel in models.Reverse())
{
elementModelViewModel.IsSelected = false;
if (dropInfo.Effects == DragDropEffects.Move)
{
//Get our parent
var sourceModelParent = elementModelViewModel.ParentViewModel as ElementModelViewModel;
if (dropInfo.InsertPosition == RelativeInsertPosition.BeforeTargetItem)
{
//We are inserting into a range.
//Ensure the parent is a group node.
if (sourceModelParent != null && sourceModelParent.ElementModel.IsGroupNode && targetModelParent != null)
{
if (sourceModelParent == targetModelParent)
{
//Our parent is the same so we can just move it within the parent
pms.MoveWithinParent(sourceModelParent.ElementModel, elementModelViewModel.ElementModel, dropInfo.InsertIndex);
elementModelViewModel.IsSelected = true;
}
else
{
//We are moving to a new parent
pms.InsertToParent(elementModelViewModel.ElementModel, targetModelParent.ElementModel, dropInfo.InsertIndex);
pms.RemoveFromParent(elementModelViewModel.ElementModel, sourceModelParent.ElementModel);
SelectModelWithParent(elementModelViewModel, targetModelParent);
}
}
}
else if (dropInfo.InsertPosition == RelativeInsertPosition.AfterTargetItem)
{
//We are inserting into a range.
//Ensure the parent is a group node.
if (sourceModelParent != null && sourceModelParent.ElementModel.IsGroupNode && targetModelParent != null)
{
if (sourceModelParent == targetModelParent)
{
//We can just move it
pms.MoveWithinParent(sourceModelParent.ElementModel, elementModelViewModel.ElementModel, dropInfo.InsertIndex - 1);
elementModelViewModel.IsSelected = true;
}
else
{
//We are moving to a new parent
pms.InsertToParent(elementModelViewModel.ElementModel, targetModelParent.ElementModel, dropInfo.InsertIndex);
pms.RemoveFromParent(elementModelViewModel.ElementModel, sourceModelParent.ElementModel);
SelectModelWithParent(elementModelViewModel, targetModelParent);
}
}
}
else
{
//We are on the center and adding to a group hopefully
//Ensure the target is a group node.
if (targetModel.ElementModel.IsGroupNode && sourceModelParent != null &&
targetModel.ElementModel != sourceModelParent.ElementModel) //We are not adding to our own parent.
{
pms.AddToParent(elementModelViewModel.ElementModel, targetModel.ElementModel);
pms.RemoveFromParent(elementModelViewModel.ElementModel, sourceModelParent.ElementModel);
SelectModelWithParent(elementModelViewModel, targetModel);
}
else
{
Logging.Warn($"Attempt to add item {elementModelViewModel.ElementModel.Name} to a non group node.");
}
}
}
}
}
}
}
