public TranslateAdorner(DesignerCanvas canvas)
: base(canvas)
{
this.canvas = canvas;
stroke = new Pen(new SolidColorBrush(Colors.DarkGray), 3);
}
public ComplexPropertyRelation(DesignerCanvas canvas, TypeBaseDesigner fromTypeDesigner, TypeBaseDesigner toTypeDesigner, FrameworkElement fromItem, int fromItemIndex)
: base(canvas, fromTypeDesigner, toTypeDesigner)
{
FromItem = fromItem;
FromItemIndex = fromItemIndex;
InitializeComponent();
SetBinding(XYProperty, new Binding { Source = this, Converter = new ComplexPropertyRelationToXYConverter() });
}
public ElasticBandAdorner(DesignerCanvas canvas, Point startPoint)
: base(canvas)
{
this.canvas = canvas;
this.startPoint = startPoint;
fill = new SolidColorBrush(Colors.CornflowerBlue) { Opacity = 0.2 };
stroke = new Pen(new SolidColorBrush(Colors.CornflowerBlue), 1.0d);
}
public PlacementAdorner(DesignerCanvas canvas, Point startPoint)
: base(canvas)
{
this.startPoint = startPoint;
fill = new SolidColorBrush(Colors.CornflowerBlue) { Opacity = 0.2 };
stroke = new Pen(new SolidColorBrush(Colors.CornflowerBlue), 1.0d);
stroke.DashStyle = new DashStyle(Enumerable.Repeat(2.0d, 2), 0);
}
public RubberbandAdorner(DesignerCanvas designerCanvas)
: base(designerCanvas)
{
rubberband = new Rectangle()
{
Stroke = Brushes.Navy,
StrokeThickness = 1 / ZoomFactor,
StrokeDashArray = new DoubleCollection(new double[] { 2 })
};
}
public void DecrementEdgeCount()
{
--EdgeCount;
if (EdgeCount == 0)
{
DesignerCanvas canvas = (Application.Current.MainWindow as MainWindow).designerCanvas;
canvas.Children.Remove(this);
this.Source = null;
this.Sink = null;
}
}
public static Connection add_Connection(this DesignerCanvas designerCanvas, DesignerItem designerItem1, DesignerItem designerItem2, string position1, string position2)
{
return((Connection)designerCanvas.wpfInvoke(
() => {
var connector1 = designerItem1.connector(position1);
var connector2 = designerItem2.connector(position2);
var connection = new DiagramDesigner.Connection(connector1, connector2);
designerCanvas.Children.Add(connection);
return connection;
}));
}
internal ConnectorInfo GetInfo()
{
ConnectorInfo info = new ConnectorInfo();
info.DesignerItemLeft = DesignerCanvas.GetLeft(this.ParentDesignerItem);
info.DesignerItemTop = DesignerCanvas.GetTop(this.ParentDesignerItem);
info.DesignerItemSize = new Size(this.ParentDesignerItem.ActualWidth, this.ParentDesignerItem.ActualHeight);
info.Orientation = this.Orientation;
info.Position = this.Position;
return(info);
}
protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
{
base.OnMouseLeftButtonDown(e);
DesignerCanvas canvas = GetDesignerCanvas(this);
if (canvas != null)
{
// position relative to DesignerCanvas
this.dragStartPoint = new Point?(e.GetPosition(canvas));
e.Handled = true;
}
}
/// <summary>
/// Add given relationship to diagrram
/// </summary>
/// <param name="relationship">Relationship</param>
/// <param name="canvas">Canvas for relationship add</param>
/// <returns>Task for async execution</returns>
public async Task AddRelationship(RelationshipModel relationship, DesignerCanvas canvas)
{
ConnectionInfoViewModel vm = new ConnectionInfoViewModel();
vm.DesignerCanvas = canvas;
vm.RelationshipModel = relationship;
vm.SourceViewModel = ViewModel.TableViewModels.FirstOrDefault(t => t.Model.Equals(relationship.Source));
vm.DestinationViewModel = ViewModel.TableViewModels.FirstOrDefault(t => t.Model.Equals(relationship.Destination));
await vm.BuildConnection3(ViewModel);
ViewModel.ConnectionInfoViewModels.Add(vm);
}
internal void RefreshPosition()
{
parentCanvas = DesignerCanvas.FindDesignerCanvas(this);
if (parentCanvas == null)
{
return;
}
var z = parentCanvas.Zoom / 100.0;
var p = PolyLine.Points[VertexIndex];
SetValue(Canvas.LeftProperty, p.X * z);
SetValue(Canvas.TopProperty, p.Y * z);
}
public static string save(this DesignerCanvas designerCanvas, string targetFile)
{
return((string)designerCanvas.wpfInvoke(
() => {
var xElementForSave = designerCanvas.getXElementForSave();
xElementForSave.Save(targetFile);
if (targetFile.fileExists())
{
return targetFile;
}
return "";
}));
}
public Association(ICSharpCode.Data.EDMDesigner.Core.EDMObjects.CSDL.Association.Association csdlAssociation, DesignerCanvas canvas, TypeBaseDesigner fromTypeDesigner, TypeBaseDesigner toTypeDesigner, FrameworkElement fromItem, FrameworkElement toItem, int fromItemIndex, int toItemIndex)
: base(canvas, fromTypeDesigner, toTypeDesigner)
{
CSDLAssociation = csdlAssociation;
FromItem = fromItem;
ToItem = toItem;
FromItemIndex = fromItemIndex;
ToItemIndex = toItemIndex;
InitializeComponent();
InitContextMenuCommandBindings();
SetBinding(XYProperty, new Binding { Source = this, Converter = new AssociationToXYConverter() });
SetBinding(OpacityProperty, new Binding("IsCompletlyMapped") { Source = CSDLAssociation.Mapping, Converter = new BoolToOpacityConverter(), ConverterParameter = 0.3 });
}
/// <summary>
/// Dragging
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnDragDelta(object sender, DragDeltaEventArgs e)
{
if (_item != null && _canvas != null && _item.IsSelected)
{
double maxDeltaVertical = _canvas.ActualHeight - (DesignerCanvas.GetTop(_item) + _item.ActualHeight);
double maxDeltaHorizontal = _canvas.ActualWidth - (DesignerCanvas.GetLeft(_item) + _item.ActualWidth);
var minDeltaVertical = _item.ActualHeight - _item.MinHeight;
var minDeltaHorizontal = _item.ActualWidth - _item.MinWidth;
double deltaVertical;
switch (VerticalAlignment)
{
case VerticalAlignment.Bottom:
deltaVertical = e.VerticalChange > 0 && e.VerticalChange >= maxDeltaVertical
? 0
: Math.Min(-e.VerticalChange, minDeltaVertical);
_item.Height = _item.ActualHeight - (int)deltaVertical;
_item.ViewModel.Height = _item.Height;
break;
case VerticalAlignment.Top:
deltaVertical = (int)Math.Min(Math.Max(-DesignerCanvas.GetTop(_item), e.VerticalChange), minDeltaVertical);
var topPos = DesignerCanvas.GetTop(_item) + deltaVertical;
DesignerCanvas.SetTop(_item, topPos);
_item.Height = _item.ActualHeight - deltaVertical;
_item.ViewModel.Height = _item.Height;
_item.ViewModel.Top = topPos;
break;
}
double deltaHorizontal;
switch (HorizontalAlignment)
{
case HorizontalAlignment.Left:
deltaHorizontal = (int)Math.Min(Math.Max(-DesignerCanvas.GetLeft(_item), e.HorizontalChange), minDeltaHorizontal);
var leftPos = DesignerCanvas.GetLeft(_item) + deltaHorizontal;
DesignerCanvas.SetLeft(_item, leftPos);
_item.Width = _item.ActualWidth - deltaHorizontal;
_item.ViewModel.Width = _item.Width;
_item.ViewModel.Left = leftPos;
break;
case HorizontalAlignment.Right:
deltaHorizontal = e.HorizontalChange > 0 && e.HorizontalChange >= maxDeltaHorizontal ? 0 : (int)Math.Min(-e.HorizontalChange, minDeltaHorizontal);
_item.Width = _item.ActualWidth - deltaHorizontal;
_item.ViewModel.Width = _item.Width;
break;
}
}
}
/// <summary>
/// Drag of thumb started
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ResizeThumb_DragStarted(object sender, DragStartedEventArgs e)
{
_item = DataContext as TableContent;
if (_item != null)
{
_canvas = VisualTreeHelper.GetParent(_item) as DesignerCanvas;
if (_canvas != null)
{
_connections = VisualTreeHelperEx.FindAncestorByType <DatabaseModelDesigner>(_canvas).ViewModel.ConnectionInfoViewModels.Where(t => t.SourceViewModel.Equals(_item.TableViewModel) || t.DestinationViewModel.Equals(_item.TableViewModel)).ToList();
}
_item.TableViewModel.OnPositionAndMeasureChangesStarted();
}
}
private void DeletePlane()
{
if (ActivPlane == null)
{
return;
}
DesignerCanvas dc = ActivPlane;
ActivPlane = VisiblePlanes.Where(x => x != ActivPlane).LastOrDefault();
Planes.Remove(dc);
RefreshPlaneStates();
}
void DragThumb_DragDelta(object sender, DragDeltaEventArgs e)
{
DesignerItem designerItem = this.DataContext as DesignerItem;
DesignerCanvas designer = VisualTreeHelper.GetParent(designerItem) as DesignerCanvas;
if (designerItem != null && designer != null && designerItem.IsSelected)
{
double minLeft = double.MaxValue;
double minTop = double.MaxValue;
// we only move DesignerItems
var designerItems = from item in designer.SelectedItems
where item is DesignerItem
select item;
foreach (DesignerItem item in designerItems)
{
double left = Canvas.GetLeft(item);
double top = Canvas.GetTop(item);
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);
foreach (DesignerItem item in designerItems)
{
double left = Canvas.GetLeft(item);
double top = Canvas.GetTop(item);
if (double.IsNaN(left))
{
left = 0;
}
if (double.IsNaN(top))
{
top = 0;
}
Canvas.SetLeft(item, left + deltaHorizontal);
Canvas.SetTop(item, top + deltaVertical);
}
designer.InvalidateMeasure();
e.Handled = true;
}
}
private void ResizeThumb_DragStarted(object sender, DragStartedEventArgs e)
{
double[] oldValue;
this.DesignerItem = DataContext as DesignerItem;
if (this.DesignerItem != null)
{
this.DesignerCanvas = VisualTreeHelper.GetParent(this.DesignerItem) as DesignerCanvas;
if (this.DesignerCanvas != null)
{
oldValueList.Clear();
foreach (DesignerItem item in this.DesignerCanvas.SelectedItems)
{
item.canvas = this.DesignerCanvas;
Point p = new Point();
//p = item.TranslatePoint(
//new Point(0,0),
// this.DesignerCanvas);
// item.centerPoint = item.TranslatePoint(
//new Point(item.ActualWidth/2,
// item.ActualHeight/ 2),
// this.DesignerCanvas);
Point startPoint = Mouse.GetPosition(this.DesignerCanvas);
item.StartVector = Point.Subtract(startPoint, item.centerPoint);
item.RotateTransform = item.RenderTransform as RotateTransform;
if (item.RotateTransform == null)
{
item.RenderTransform = new RotateTransform(0);
item.InitialAngle = 0;
}
else
{
item.InitialAngle = item.RotateTransform.Angle;
}
oldValue = new double[5] {
item.GetHashCode(), item.ActualWidth, item.ActualHeight, Canvas.GetLeft(item), Canvas.GetTop(item)
};
oldValueList.Add(oldValue);
}
}
}
}
protected virtual void OnDesignerCanvasChanged(DesignerCanvas oldDesignerCanvas, DesignerCanvas newDesignerCanvas)
{
if (oldDesignerCanvas != null)
{
newDesignerCanvas.LayoutUpdated -= new EventHandler(this.DesignerCanvas_LayoutUpdated);
newDesignerCanvas.MouseWheel -= new MouseWheelEventHandler(this.DesignerCanvas_MouseWheel);
}
if (newDesignerCanvas != null)
{
newDesignerCanvas.LayoutUpdated += new EventHandler(this.DesignerCanvas_LayoutUpdated);
newDesignerCanvas.MouseWheel += new MouseWheelEventHandler(this.DesignerCanvas_MouseWheel);
newDesignerCanvas.LayoutTransform = this.scaleTransform;
}
}
public void UpdateZIndex(DesignerCanvas mgr)
{
var ordered = (from UIElement item in mgr.Children
orderby Panel.GetZIndex(item)
select item).ToList();
for (var i = 0; i < ordered.Count; i++)
{
if (Panel.GetZIndex(ordered[i]) == int.MinValue)
{
continue;
}
Panel.SetZIndex(ordered[i], i);
}
}
/// <summary>
/// If is grid enabled, snap to intersects
/// </summary>
private void SnapToGrid()
{
if (_canvas.IsGridEnabled)
{
int cellWidth = DesignerCanvas.GridCellWidth;
var selected = _canvas.SelectedTables.ToArray();
double topConnectionLimit = double.MaxValue;
double bottomConnectionLimit = double.MaxValue;
double leftConnectionLimit = double.MaxValue;
double rightConnectionLimit = double.MaxValue;
foreach (TableContent item in _canvas.SelectedTables)
{
foreach (ConnectionInfoViewModel model in _connections.Where(t => t.SourceViewModel.Equals(item.TableViewModel)))
{
ConnectionInfoViewModel.GetConnectionLimits(ref topConnectionLimit, ref bottomConnectionLimit, ref leftConnectionLimit, ref rightConnectionLimit, model.SourceConnector, model);
}
foreach (ConnectionInfoViewModel model in _connections.Where(t => t.DestinationViewModel.Equals(item.TableViewModel)))
{
ConnectionInfoViewModel.GetConnectionLimits(ref topConnectionLimit, ref bottomConnectionLimit, ref leftConnectionLimit, ref rightConnectionLimit, model.DestinationConnector, model);
}
}
foreach (TableContent item in selected)
{
double top = item.TableViewModel.Top;
double left = item.TableViewModel.Left;
double bottom = top + item.TableViewModel.Height;
double right = left + item.TableViewModel.Width;
double approxCellTop = Math.Round(top / cellWidth, MidpointRounding.AwayFromZero) * cellWidth;
double approxCellLeft = Math.Round(left / cellWidth, MidpointRounding.AwayFromZero) * cellWidth;
if (WillSnapToGridBrokeConnections(topConnectionLimit, leftConnectionLimit, bottomConnectionLimit, rightConnectionLimit, top, left, bottom, right, approxCellTop, approxCellLeft))
{
continue;
}
DesignerCanvas.SetLeft(item, approxCellLeft);
DesignerCanvas.SetTop(item, approxCellTop);
item.TableViewModel.Left = approxCellLeft;
item.TableViewModel.Top = approxCellTop;
}
}
}
protected override void OnMouseMove(MouseEventArgs e)
{
base.OnMouseMove(e);
if (IsEdit == false)
{
return;
}
DataObject dataObject;
if (e.LeftButton != MouseButtonState.Pressed)
{
this.dragStartPoint = null;
return;
}
DesignerCanvas canvas = Common.FindVisualParent <DesignerCanvas>(this) as DesignerCanvas;
if (canvas != null)
{
object o = this.InputHitTest(e.GetPosition(this));
if (this.InputHitTest(e.GetPosition(this)) is Run || this.InputHitTest(e.GetPosition(this)) is FlowDocument || this.InputHitTest(e.GetPosition(this)) is Paragraph)
{
return;
}
if (Common.FindVisualParent <jg.Editor.Library.Control.ControlTopicDrag>((DependencyObject)this.InputHitTest(e.GetPosition(this))) != null)
{
return;
}
dataObject = new DataObject();
dataObject.SetData("TOOLBOXITEM", this);
if (this.Content is Control.ControlMessage)
{
return;
}
if (this.Content is Control.ControlLine)
{
return;
}
if (!(this.Content is Control.ControlTextGrid))
{
DragDrop.DoDragDrop(this, dataObject, DragDropEffects.Copy);
}
}
}
/// <summary>
/// 设置此Document处于选中状态
/// </summary>
/// <param name="document"></param>
public static void SetDocumentSelected(CanvasDocument document)
{
Window1 mainWindow = GetMainWindow();
foreach (CanvasDocument doc in mainWindow.DockingManager.Items)
{
if (doc.Equals(document))
{
mainWindow.DockingManager.SelectedItem = doc;
currentCanvas = doc.Canvas;
//显示鼠标坐标
mainWindow.statusBar.DataContext = currentCanvas;
break;
}
}
}
private void ShowAdorner()
{
// the ConnectionAdorner is created once for each Connection
if (this.connectionAdorner == null)
{
DesignerCanvas designer = VisualTreeHelper.GetParent(this) as DesignerCanvas;
AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(this);
if (adornerLayer != null)
{
this.connectionAdorner = new ConnectionAdorner(designer, this);
adornerLayer.Add(this.connectionAdorner);
}
}
this.connectionAdorner.Visibility = Visibility.Visible;
}
public ConnectionAdorner(DesignerCanvas designer, Connection connection)
: base(designer)
{
this.designerCanvas = designer;
adornerCanvas = new Canvas();
this.visualChildren = new VisualCollection(this);
this.visualChildren.Add(adornerCanvas);
this.connection = connection;
this.connection.PropertyChanged += new PropertyChangedEventHandler(AnchorPositionChanged);
InitializeDragThumbs();
drawingPen = new Pen(Brushes.LightSlateGray, 1);
drawingPen.LineJoin = PenLineJoin.Round;
}
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
_canvas = this.Template.FindName("PART_DesignerCanvas", this) as DesignerCanvas;
if (_canvas == null)
{
throw new InvalidProgramException("ModelingDesigner 的模板中必须要有命名为 PART_DesignerCanvas 的 DesignerCanvas 元素。");
}
_canvas.SelectionChanged += (o, e) => this.OnSelectionChanged();
_canvas.DragLineCompleted += _canvas_DragLineCompleted;
//在首次加载时，把所有元素加入到画布中。
AddElementsIntoCanvas();
}
public SelectionService(DesignerCanvas canvas)
{
_designerCanvas = canvas;
if (_dragResizeAdorner == null)
{
// create rubberband adorner
var adornerLayer = AdornerLayer.GetAdornerLayer(_designerCanvas);
_dragResizeAdorner = new DragResizeAdorner(_designerCanvas);
if (adornerLayer != null)
{
adornerLayer.Add(_dragResizeAdorner);
}
}
}
private void CenterPointThumb_DragDelta(object sender, DragDeltaEventArgs e)
{
Point dragDelta = new Point(e.HorizontalChange, e.VerticalChange);
if (this.designerItem != null && this._parent != null)
{
if (this._transform != null)
{
dragDelta = _transform.Transform(dragDelta);
}
DesignerCanvas.SetLeft(this, DesignerCanvas.GetLeft(this) + dragDelta.X);
DesignerCanvas.SetTop(this, DesignerCanvas.GetTop(this) + dragDelta.Y);
e.Handled = true;
}
}
internal void SetCanvas(Controls.DesignerCanvas canvas)
{
if (_ParentCanvas != null)
{
_ParentCanvas.ZoomChanged -= ParentCanvas_ZoomChanged;
}
_ParentCanvas = canvas;
if (canvas != null)
{
canvas.ZoomChanged += ParentCanvas_ZoomChanged;
}
if (canvas != null)
{
OnUpdateLayout();
}
}
private void ResizeThumb_DragStarted(object sender, DragStartedEventArgs e)
{
parentCanvas = DesignerCanvas.FindDesignerCanvas(this);
var destControl = DataContext as IBoxCanvasItem;
if (parentCanvas != null && destControl != null)
{
var adornerLayer = AdornerLayer.GetAdornerLayer(this);
if (adornerLayer != null)
{
Debug.Assert(sizeAdorner == null);
sizeAdorner = new SizeAdorner(destControl);
parentCanvas.AddAdorner(sizeAdorner);
}
}
}
void DragThumb_DragDelta(object sender, DragDeltaEventArgs e)
{
CircuitPart circuitPart = this.DataContext as CircuitPart;
DesignerCanvas designer = VisualTreeHelper.GetParent(circuitPart) as DesignerCanvas;
if (circuitPart != null && designer != null && circuitPart.IsSelected)
{
double minLeft = double.MaxValue;
double minTop = double.MaxValue;
// we only move CircuitPart
var circuitParts = designer.SelectionService.CurrentSelection.OfType <CircuitPart>();
foreach (CircuitPart item in circuitParts)
{
double left = Canvas.GetLeft(item);
double top = Canvas.GetTop(item);
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);
foreach (CircuitPart item in circuitParts)
{
double left = Canvas.GetLeft(item);
double top = Canvas.GetTop(item);
if (double.IsNaN(left))
{
left = 0;
}
if (double.IsNaN(top))
{
top = 0;
}
Canvas.SetLeft(item, left + deltaHorizontal);
Canvas.SetTop(item, top + deltaVertical);
}
designer.InvalidateMeasure();
e.Handled = true;
}
}
/// <summary>
/// Add existing realtionships for given table
/// </summary>
/// <param name="model">Table</param>
/// <param name="canvas">Canvas for relationship add</param>
/// <returns>Task for async execution</returns>
public async Task AddRelationShipsForTable(TableModel model, DesignerCanvas canvas)
{
var ctx = new DatabaseContext(SessionProvider.Instance.ConnectionType);
var relationships =
await Task.Run(
() =>
ctx.ListRelationshipsForTable(model.Title, ViewModel.TableViewModels.Select(t => t.Model))
.Where(t => !ViewModel.ConnectionInfoViewModels.Any(s => s.RelationshipModel.Name.Equals(t.Name))));
//var relationships = ctx.ListRelationshipsForTable(model.Title, ViewModel.TableViewModels.Select(t => t.Model)).Where(t => !ViewModel.ConnectionInfoViewModels.Any(s => s.RelationshipModel.Name.Equals(t.Name)));
foreach (RelationshipModel relationship in relationships)
{
await AddRelationship(relationship, canvas);
}
}
/// <summary>
/// Mouse drag started
/// </summary>
/// <param name="sender"></param>
/// <param name="dragStartedEventArgs"></param>
private void OnDragStarted(object sender, DragStartedEventArgs dragStartedEventArgs)
{
_item = DataContext as TableContent;
if (_item != null)
{
_canvas = VisualTreeHelper.GetParent(_item) as DesignerCanvas;
if (_canvas != null)
{
_connections = VisualTreeHelperEx.FindAncestorByType <DatabaseModelDesigner>(_canvas).ViewModel.ConnectionInfoViewModels
.Where(t => !(t.DestinationViewModel.IsSelected && t.SourceViewModel.IsSelected))
.ToList();
}
_item.TableViewModel.OnPositionAndMeasureChangesStarted();
_item.TableViewModel.IsMoving = true;
}
}
/// <summary>
/// 已经开始拖放
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MoveThumb_DragStarted(object sender, DragStartedEventArgs e)
{
this._beMovedItem = DataContext as DesignerItem;
sp = Mouse.GetPosition(this._parent);
if (this._beMovedItem != null)
{
this._parent = VisualTreeHelper.GetParent(this._beMovedItem) as DesignerCanvas;
this._transform = this._beMovedItem.RenderTransform as RotateTransform;
AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(this._parent);
if (adornerLayer != null)
{
this._infoAdorner = new LocationInfoAdorner(this._beMovedItem);
adornerLayer.Add(this._infoAdorner);
}
}
}
//private bool _isSelectedEvent;
public ElementsViewModel(DesignerCanvas designerCanvas)
{
//_isSelectedEvent = false;
ServiceFactoryBase.Events.GetEvent<ElementAddedEvent>().Unsubscribe(OnElementAdded);
ServiceFactoryBase.Events.GetEvent<ElementRemovedEvent>().Unsubscribe(OnElementRemoved);
ServiceFactoryBase.Events.GetEvent<ElementChangedEvent>().Unsubscribe(OnElementChanged);
ServiceFactoryBase.Events.GetEvent<ElementSelectedEvent>().Unsubscribe(OnElementSelected);
ServiceFactoryBase.Events.GetEvent<ElementAddedEvent>().Subscribe(OnElementAdded);
ServiceFactoryBase.Events.GetEvent<ElementRemovedEvent>().Subscribe(OnElementRemoved);
ServiceFactoryBase.Events.GetEvent<ElementChangedEvent>().Subscribe(OnElementChanged);
ServiceFactoryBase.Events.GetEvent<ElementSelectedEvent>().Subscribe(OnElementSelected);
DesignerCanvas = designerCanvas;
Elements = new ObservableCollection<ElementBaseViewModel>();
Update();
}
public static T add_DesignerItem <T>(this DesignerCanvas designerCanvas, string newControlContent, int top, int left, int width, int height)
where T : UIElement
{
return((T)designerCanvas.wpfInvoke <DesignerCanvas, T>(
() => {
try
{
var newControl = (T)typeof(T).ctor();
return designerCanvas.add_UIElement(newControl, newControlContent, top, left, width, height);
}
catch (Exception ex)
{
ex.log("in DesignerCanvas add_DesignerItem");
}
return default(T);
}));
}
/// <summary>
/// Dragging
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnDragDelta(object sender, DragDeltaEventArgs e)
{
if (_item != null && _canvas != null && _item.IsSelected)
{
double minLeft = double.MaxValue;
double minTop = double.MaxValue;
double maxTop = double.MinValue;
double maxLeft = double.MinValue;
LabelContent[] selected = _canvas.SelectedLabels.ToArray();
foreach (LabelContent item in selected)
{
minLeft = Math.Min(DesignerCanvas.GetLeft(item), minLeft);
minTop = Math.Min(DesignerCanvas.GetTop(item), minTop);
maxLeft = Math.Max(DesignerCanvas.GetLeft(item) + item.ActualWidth, maxLeft);
maxTop = Math.Max(DesignerCanvas.GetTop(item) + item.ActualHeight, maxTop);
}
double deltaHorizontal = (int)Math.Max(-minLeft, e.HorizontalChange);
double deltaVertical = (int)Math.Max(-minTop, e.VerticalChange);
if (deltaHorizontal + maxLeft > _canvas.ActualWidth)
{
deltaHorizontal = 0;
}
if (deltaVertical + maxTop > _canvas.ActualHeight)
{
deltaVertical = 0;
}
foreach (LabelContent item in selected)
{
var leftPos = DesignerCanvas.GetLeft(item) + deltaHorizontal;
var topPos = DesignerCanvas.GetTop(item) + deltaVertical;
DesignerCanvas.SetLeft(item, leftPos);
DesignerCanvas.SetTop(item, topPos);
item.ViewModel.Left = leftPos;
item.ViewModel.Top = topPos;
}
e.Handled = true;
}
}
/// <summary>
/// Synchronize current diagram with DB
/// </summary>
/// <param name="canvas">Canvas with diagram</param>
/// <returns>Task for async execution</returns>
public async Task RefreshDiagram(DesignerCanvas canvas)
{
var ctx = new DatabaseContext(SessionProvider.Instance.ConnectionType);
IEnumerable <TableModel> tables = await Task.Run(() => ctx.ListTables());
IEnumerable <string> foreignKeys = await Task.Run(() => ctx.ListAllForeignKeys());
var tablesForDelete = ViewModel.TableViewModels.Where(t => !tables.Any(s => s.Id.Equals(t.Model.Id))).ToList();
tablesForDelete.ForEach(t => ViewModel.TableViewModels.Remove(t));
var relationsForDelete =
ViewModel.ConnectionInfoViewModels.Where(t => !foreignKeys.Any(s => s.Equals(t.RelationshipModel.Name))).ToList();
relationsForDelete.ForEach(t => ViewModel.ConnectionInfoViewModels.Remove(t));
foreach (TableModel table in tables)
{
var ft = ViewModel.TableViewModels.FirstOrDefault(t => t.Model.Id.Equals(table.Id));
if (ft == null)
{
continue;
}
ft.Model.Title = table.Title;
}
foreach (TableViewModel viewModel in ViewModel.TableViewModels)
{
TableModel model = await Task.Run(() => ctx.ReadTableDetails(viewModel.Model.Id, viewModel.Model.Title));
viewModel.Model.RefreshModel(model);
IEnumerable <RelationshipModel> relationshipModels = await Task.Run(() => ctx.ListRelationshipsForTable(viewModel.Model.Title, ViewModel.TableViewModels.Select(t => t.Model)));
IEnumerable <RelationshipModel> filtered = relationshipModels.Where(t => !ViewModel.ConnectionInfoViewModels.Any(s => s.RelationshipModel.Name.Equals(t.Name)));
foreach (RelationshipModel relationshipModel in filtered)
{
await AddRelationship(relationshipModel, canvas);
}
}
}
public InheritanceRelation(DesignerCanvas canvas, EntityTypeDesigner fromTypeDesigner, EntityTypeDesigner toTypeDesigner, Func<EntityTypeDesigner> getToEntityTypeDesigner)
:base(canvas, fromTypeDesigner, toTypeDesigner)
{
InitializeComponent();
InitContextMenuCommandBindings();
SetBinding(XYProperty, new Binding { Source = this, Converter = new InheritanceRelationToXYConverter() });
fromTypeDesigner.EntityType.BaseTypeChanged +=
() =>
{
ToTypeDesigner = getToEntityTypeDesigner();
if (ToTypeDesigner != null)
{
RedoXYBinding();
OnAssociationCoordonatesChanged();
RedoBindings();
}
};
}
public RubberbandAdorner(DesignerCanvas designerCanvas, Point? dragStartPoint)
: base(designerCanvas)
{
this.designerCanvas = designerCanvas;
this.startPoint = dragStartPoint;
this.adornerCanvas = new Canvas();
this.adornerCanvas.Background = Brushes.Transparent;
this.visuals = new VisualCollection(this);
this.visuals.Add(this.adornerCanvas);
this.rubberband = new Rectangle();
this.rubberband.Stroke = Brushes.Navy;
this.rubberband.StrokeThickness = 1;
this.rubberband.StrokeDashArray = new DoubleCollection(new double[] { 2 });
this.adornerCanvas.Children.Add(this.rubberband);
}
public ElipseAdorner(DesignerCanvas designerCanvas)
: base(designerCanvas)
{
}
public ToolboxViewModel(DesignerCanvas designerCanvas)
{
DesignerCanvas = designerCanvas;
RegisterInstruments();
EventManager.RegisterClassHandler(typeof(Window), Keyboard.KeyDownEvent, new KeyEventHandler(OnKeyEventHandler), true);
}
public PolylineAdorner(DesignerCanvas designerCanvas)
: base(designerCanvas)
{
}
public RectangleAdorner(DesignerCanvas designerCanvas)
: base(designerCanvas)
{
}
public DesignerItem(DesignerCanvas canvas)
{
this.canvas = canvas;
}
public PolygonAdorner(DesignerCanvas designerCanvas)
: base(designerCanvas)
{
}
public TextBoxAdorner(DesignerCanvas designerCanvas)
: base(designerCanvas)
{
}
public RelationBase(DesignerCanvas canvas, TypeBaseDesigner fromTypeDesigner, TypeBaseDesigner toTypeDesigner)
{
Canvas = canvas;
FromTypeDesigner = fromTypeDesigner;
ToTypeDesigner = toTypeDesigner;
}
public GridLineAdorner(DesignerCanvas designerCanvas, Orientation orientation)
: base(designerCanvas)
{
Orientation = orientation;
}
