private DesignerItemViewModelBase GetConnectorDataItem(DiagramViewModel diagramViewModel, int conectorDataItemId, Type connectorDataItemType)
{
DesignerItemViewModelBase dataItem = null;
dataItem = diagramViewModel.Items.Single(x => x.Id == conectorDataItemId) as DesignerItemViewModelBase;
return(dataItem);
}
void DragThumb_DragDelta(object sender, DragDeltaEventArgs e)
{
DesignerItemViewModelBase designerItem = this.DataContext as DesignerItemViewModelBase;
if (designerItem != null && designerItem.IsSelected)
{
double minLeft = double.MaxValue;
double minTop = double.MaxValue;
// we only move DesignerItems
var designerItems = designerItem.SelectedItems;
foreach (DesignerItemViewModelBase item in designerItems.OfType <DesignerItemViewModelBase>())
{
double left = item.Left;
double top = item.Top;
minLeft = double.IsNaN(left) ? 0 : Math.Min(left, minLeft);
minTop = double.IsNaN(top) ? 0 : Math.Min(top, minTop);
double deltaHorizontal = Math.Max(-minLeft, e.HorizontalChange);
double deltaVertical = Math.Max(-minTop, e.VerticalChange);
item.Left += deltaHorizontal;
item.Top += deltaVertical;
}
e.Handled = true;
}
}
private void ExecuteLoadDiagramCommand(object parameter)
{
IsBusy = true;
DiagramItem wholeDiagramToLoad = null;
if (SavedDiagramId == null)
{
messageBoxService.ShowError("You need to select a diagram to load");
return;
}
Task <DiagramViewModel> task = Task.Factory.StartNew <DiagramViewModel>(() =>
{
//ensure that itemsToRemove is cleared ready for any new changes within a session
itemsToRemove = new List <SelectableDesignerItemViewModelBase>();
DiagramViewModel diagramViewModel = new DiagramViewModel();
wholeDiagramToLoad = storageService.FetchDiagram((int)SavedDiagramId.Value);
//load diagram items
foreach (DiagramItemData diagramItemData in wholeDiagramToLoad.DesignerItems)
{
var designerItem = storageService.FetchDiagram(diagramItemData.ItemId);
var viewModel = Activator.CreateInstance(diagramItemData.ItemType) as DesignerItemViewModelBase;
viewModel.Id = designerItem.Id;
viewModel.Parent = diagramViewModel;
//viewModel.Left = designerItem.l
//viewModel.Top = designerItem.t
diagramViewModel.Items.Add(viewModel);
}
//load connection items
foreach (int connectionId in wholeDiagramToLoad.ConnectionIds)
{
Connection connection = storageService.FetchConnection(connectionId);
DesignerItemViewModelBase sourceItem = GetConnectorDataItem(diagramViewModel, connection.SourceId, connection.SourceType);
ConnectorOrientation sourceConnectorOrientation = GetOrientationForConnector(connection.SourceOrientation);
FullyCreatedConnectorInfo sourceConnectorInfo = GetFullConnectorInfo(connection.Id, sourceItem, sourceConnectorOrientation);
DesignerItemViewModelBase sinkItem = GetConnectorDataItem(diagramViewModel, connection.SinkId, connection.SinkType);
ConnectorOrientation sinkConnectorOrientation = GetOrientationForConnector(connection.SinkOrientation);
FullyCreatedConnectorInfo sinkConnectorInfo = GetFullConnectorInfo(connection.Id, sinkItem, sinkConnectorOrientation);
ConnectorViewModel connectionVM = new ConnectorViewModel(connection.Id, diagramViewModel, sourceConnectorInfo, sinkConnectorInfo);
diagramViewModel.Items.Add(connectionVM);
}
return(diagramViewModel);
});
task.ContinueWith((ant) =>
{
this.DiagramViewModel = ant.Result;
IsBusy = false;
messageBoxService.ShowInformation(string.Format("Finished loading Diagram Id : {0}", wholeDiagramToLoad.Id));
}, TaskContinuationOptions.OnlyOnRanToCompletion);
}
private FullyCreatedConnectorInfo GetFullConnectorInfo(int connectorId, DesignerItemViewModelBase dataItem, ConnectorOrientation connectorOrientation)
{
switch (connectorOrientation)
{
case ConnectorOrientation.Left:
return(dataItem.LeftConnector);
case ConnectorOrientation.Right:
return(dataItem.RightConnector);
default:
throw new InvalidOperationException(
string.Format("Found invalid persisted Connector Orientation for Connector Id: {0}", connectorId));
}
}
private DesignerItemViewModelBase GetConnectorDataItem(DiagramViewModel diagramViewModel, int conectorDataItemId, Type connectorDataItemType)
{
DesignerItemViewModelBase dataItem = null;
if (connectorDataItemType == typeof(PersistDesignerItem))
{
dataItem = diagramViewModel.Items.OfType <PersistDesignerItemViewModel>().Single(x => x.Id == conectorDataItemId);
}
if (connectorDataItemType == typeof(SettingsDesignerItem))
{
dataItem = diagramViewModel.Items.OfType <SettingsDesignerItemViewModel>().Single(x => x.Id == conectorDataItemId);
}
return(dataItem);
}
private void LoadPerstistDesignerItems(IDiagramItem wholeDiagramToLoad, IDiagramViewModel diagramViewModel)
{
//load diagram items
foreach (DiagramItemData diagramItemData in wholeDiagramToLoad.DesignerItems)
{
if (diagramItemData.ItemType == typeof(PersistDesignerItem))
{
PersistDesignerItem persistedDesignerItem = databaseAccessService.FetchPersistDesignerItem(diagramItemData.ItemId);
PersistDesignerItemViewModel persistDesignerItemViewModel =
new PersistDesignerItemViewModel(persistedDesignerItem.Id, diagramViewModel, persistedDesignerItem.Left, persistedDesignerItem.Top, persistedDesignerItem.ItemWidth, persistedDesignerItem.ItemHeight, persistedDesignerItem.HostUrl);
diagramViewModel.Items.Add(persistDesignerItemViewModel);
}
if (diagramItemData.ItemType == typeof(SettingsDesignerItem))
{
SettingsDesignerItem settingsDesignerItem = databaseAccessService.FetchSettingsDesignerItem(diagramItemData.ItemId);
SettingsDesignerItemViewModel settingsDesignerItemViewModel =
new SettingsDesignerItemViewModel(settingsDesignerItem.Id, diagramViewModel, settingsDesignerItem.Left, settingsDesignerItem.Top, settingsDesignerItem.ItemWidth, settingsDesignerItem.ItemHeight, settingsDesignerItem.Setting1);
diagramViewModel.Items.Add(settingsDesignerItemViewModel);
}
if (diagramItemData.ItemType == typeof(GroupDesignerItem))
{
GroupDesignerItem groupDesignerItem = databaseAccessService.FetchGroupingDesignerItem(diagramItemData.ItemId);
GroupingDesignerItemViewModel groupingDesignerItemViewModel =
new GroupingDesignerItemViewModel(groupDesignerItem.Id, diagramViewModel, groupDesignerItem.Left, groupDesignerItem.Top, groupDesignerItem.ItemWidth, groupDesignerItem.ItemHeight);
if (groupDesignerItem.DesignerItems != null && groupDesignerItem.DesignerItems.Count > 0)
{
LoadPerstistDesignerItems(groupDesignerItem, groupingDesignerItemViewModel);
}
diagramViewModel.Items.Add(groupingDesignerItemViewModel);
}
}
//load connection items
foreach (int connectionId in wholeDiagramToLoad.ConnectionIds)
{
Connection connection = databaseAccessService.FetchConnection(connectionId);
DesignerItemViewModelBase sourceItem = GetConnectorDataItem(diagramViewModel, connection.SourceId, connection.SourceType);
ConnectorOrientation sourceConnectorOrientation = GetOrientationForConnector(connection.SourceOrientation);
FullyCreatedConnectorInfo sourceConnectorInfo = GetFullConnectorInfo(connection.Id, sourceItem, sourceConnectorOrientation);
DesignerItemViewModelBase sinkItem = GetConnectorDataItem(diagramViewModel, connection.SinkId, connection.SinkType);
ConnectorOrientation sinkConnectorOrientation = GetOrientationForConnector(connection.SinkOrientation);
FullyCreatedConnectorInfo sinkConnectorInfo = GetFullConnectorInfo(connection.Id, sinkItem, sinkConnectorOrientation);
ConnectorViewModel connectionVM = new ConnectorViewModel(connection.Id, diagramViewModel, sourceConnectorInfo, sinkConnectorInfo);
diagramViewModel.Items.Add(connectionVM);
}
}
private Type GetTypeOfDiagramItem(DesignerItemViewModelBase vmType)
{
if (vmType is PersistDesignerItemViewModel)
{
return(typeof(PersistDesignerItem));
}
if (vmType is SettingsDesignerItemViewModel)
{
return(typeof(SettingsDesignerItem));
}
throw new InvalidOperationException(string.Format("Unknown diagram type. Currently only {0} and {1} are supported",
typeof(PersistDesignerItem).AssemblyQualifiedName,
typeof(SettingsDesignerItemViewModel).AssemblyQualifiedName
));
}
void DragThumb_DragDelta(object sender, DragDeltaEventArgs e)
{
DesignerItemViewModelBase designerItem = this.DataContext as DesignerItemViewModelBase;
if (designerItem != null && designerItem.IsSelected)
{
double minLeft = double.MaxValue;
double minTop = double.MaxValue;
// we only move DesignerItems
var designerItems = designerItem.SelectedItems;
foreach (DesignerItemViewModelBase item in designerItems.OfType <DesignerItemViewModelBase>())
{
double left = item.Left;
double top = item.Top;
minLeft = double.IsNaN(left) ? 0 : Math.Min(left, minLeft);
minTop = double.IsNaN(top) ? 0 : Math.Min(top, minTop);
double deltaHorizontal = Math.Max(-minLeft, e.HorizontalChange);
double deltaVertical = Math.Max(-minTop, e.VerticalChange);
item.Left += deltaHorizontal;
item.Top += deltaVertical;
// prevent dragging items out of groupitem
if (item.Parent is IDiagramViewModel && item.Parent is DesignerItemViewModelBase)
{
DesignerItemViewModelBase groupItem = (DesignerItemViewModelBase)item.Parent;
if (item.Left + item.ItemWidth >= groupItem.ItemWidth)
{
item.Left = groupItem.ItemWidth - item.ItemWidth;
}
if (item.Top + item.ItemHeight >= groupItem.ItemHeight)
{
item.Top = groupItem.ItemHeight - item.ItemHeight;
}
}
}
e.Handled = true;
}
}
private void ExecuteGroupCommand(object parameter)
{
if (diagramViewModel.SelectedItems.Count > 0)
{
// if only one selected item is a Grouping item -> ungroup
if (diagramViewModel.SelectedItems[0] is GroupingDesignerItemViewModel && diagramViewModel.SelectedItems.Count == 1)
{
GroupingDesignerItemViewModel groupObject = diagramViewModel.SelectedItems[0] as GroupingDesignerItemViewModel;
foreach (var item in groupObject.Items)
{
if (item is DesignerItemViewModelBase)
{
DesignerItemViewModelBase tmp = (DesignerItemViewModelBase)item;
tmp.Top += groupObject.Top;
tmp.Left += groupObject.Left;
}
diagramViewModel.AddItemCommand.Execute(item);
item.Parent = DiagramViewModel;
}
// "cut" connections between DiagramItems and the Group
List <SelectableDesignerItemViewModelBase> GroupedItemsToRemove = new List <SelectableDesignerItemViewModelBase>();
foreach (var connector in DiagramViewModel.Items.OfType <ConnectorViewModel>())
{
if (groupObject == connector.SourceConnectorInfo.DataItem)
{
GroupedItemsToRemove.Add(connector);
}
if (groupObject == ((FullyCreatedConnectorInfo)connector.SinkConnectorInfo).DataItem)
{
GroupedItemsToRemove.Add(connector);
}
}
GroupedItemsToRemove.Add(groupObject);
foreach (var selectedItem in GroupedItemsToRemove)
{
DiagramViewModel.RemoveItemCommand.Execute(selectedItem);
}
}
else if (diagramViewModel.SelectedItems.Count > 1)
{
double margin = 15;
Rect rekt = PointHelper.GetBoundingRectangle(diagramViewModel.SelectedItems, margin);
GroupingDesignerItemViewModel groupItem = new GroupingDesignerItemViewModel(0, this.diagramViewModel, rekt.Left, rekt.Top);
groupItem.ItemWidth = rekt.Width;
groupItem.ItemHeight = rekt.Height;
foreach (var item in diagramViewModel.SelectedItems)
{
if (item is DesignerItemViewModelBase)
{
DesignerItemViewModelBase tmp = (DesignerItemViewModelBase)item;
tmp.Top -= rekt.Top;
tmp.Left -= rekt.Left;
}
groupItem.Items.Add(item);
item.Parent = groupItem;
}
// "cut" connections between DiagramItems which are going to be grouped and
// Diagramitems which are not going to be grouped
List <SelectableDesignerItemViewModelBase> GroupedItemsToRemove = DiagramViewModel.SelectedItems;
List <SelectableDesignerItemViewModelBase> connectionsToAlsoRemove = new List <SelectableDesignerItemViewModelBase>();
foreach (var connector in DiagramViewModel.Items.OfType <ConnectorViewModel>())
{
if (ItemsToDeleteHasConnector(GroupedItemsToRemove, connector.SourceConnectorInfo))
{
connectionsToAlsoRemove.Add(connector);
}
if (ItemsToDeleteHasConnector(GroupedItemsToRemove, (FullyCreatedConnectorInfo)connector.SinkConnectorInfo))
{
connectionsToAlsoRemove.Add(connector);
}
}
GroupedItemsToRemove.AddRange(connectionsToAlsoRemove);
foreach (var selectedItem in GroupedItemsToRemove)
{
DiagramViewModel.RemoveItemCommand.Execute(selectedItem);
}
diagramViewModel.SelectedItems.Clear();
this.diagramViewModel.Items.Add(groupItem);
}
}
}
public FullyCreatedConnectorInfo(DesignerItemViewModelBase dataItem, ConnectorOrientation orientation)
: base(orientation)
{
DataItem = dataItem;
}
public static int IdMod(DesignerItemViewModelBase item)
{
return(item?.Id ?? -999);
}
private Type GetTypeOfDiagramItem(DesignerItemViewModelBase vmType)
{
return(vmType.GetType());
}
