protected override void Activate(ModelItem item)
{
base.Activate(item);
CurrentItem = item;
View = DesignerView.FromContext(Context);
View.PreviewMouseLeftButtonDown += OnPreviewMouseLeftButtonDown;
}
public ActionResult Delete(Guid id)
{
JobCardManager manager = new JobCardManager();
DesignerView designer = manager.GetDesigner(id);
return(View(designer));
}
public static Vector ComputePositionDeltaInTarget(DesignerView dview, ViewItem target, Point startPosition, Point currentPosition)
{
GeneralTransform generalTransform = target.TransformFromVisual((Visual)dview);
Point point = generalTransform.Transform(startPosition);
return(generalTransform.Transform(currentPosition) - point);
}
public override bool EvaluateLayout(DesignerView view, UIElement adorner)
{
if (view == null)
{
throw new ArgumentNullException("view");
}
if (adorner == null)
{
throw new ArgumentNullException("adorner");
}
BaseAdornerLayout.GetCache((DependencyObject)adorner).DesignerView = view;
BaseAdornerLayout.EnsureActualValues((DependencyObject)adorner);
ViewItem element = AdornerProperties.GetView((DependencyObject)adorner);
if (BaseAdornerLayout.IsAdornableElement(view, element))
{
object obj = adorner.ReadLocalValue(BaseAdornerLayout.OriginalVisibilityProperty);
if (obj != DependencyProperty.UnsetValue)
{
adorner.SetValue(UIElement.VisibilityProperty, obj);
adorner.ClearValue(BaseAdornerLayout.OriginalVisibilityProperty);
}
}
else
{
if (element != (ViewItem)null && adorner.ReadLocalValue(BaseAdornerLayout.OriginalVisibilityProperty) == DependencyProperty.UnsetValue)
{
adorner.SetValue(BaseAdornerLayout.OriginalVisibilityProperty, (object)adorner.Visibility);
adorner.Visibility = Visibility.Collapsed;
}
element = (ViewItem)null;
}
BaseAdornerLayout.CheckAndInvalidateAdorner(view, element, adorner);
return(true);
}
private bool UpdateContentEnabled()
{
DesignerView parentContentPane = FindDependencyParent.FindParent <DesignerView>(this);
var dataContext = parentContentPane?.DataContext;
if (dataContext != null)
{
if (dataContext.GetType().Name == "ServiceTestViewModel")
{
if (ContentDesignerTemplate != null)
{
if (ContentDesignerTemplate.Parent.GetType().Name != "ForeachDesigner" &&
ContentDesignerTemplate.Parent.GetType().Name != "SequenceDesigner" &&
ContentDesignerTemplate.Parent.GetType().Name != "SelectAndApplyDesigner")
{
ContentDesignerTemplate.IsEnabled = false;
}
ContentDesignerTemplate.RightButtons.Clear();
ContentDesignerTemplate.LeftButtons.Clear();
}
}
return(true);
}
return(false);
}
protected override void OnViewChanged(DesignerView view)
{
base.OnViewChanged(view);
ActivityDesigner designer = (base.ActiveView != null) ? base.ActiveView.AssociatedDesigner : null;
if (designer.Activity is FaultHandlersActivity)
{
this.Header.Text = System.Workflow.Activities.DR.GetString("WorkflowExceptions");
this.HelpText = string.Empty;
}
else if (designer.Activity is EventHandlersActivity)
{
this.Header.Text = System.Workflow.Activities.DR.GetString("WorkflowEvents");
this.HelpText = string.Empty;
}
else if (designer.Activity is CompensationHandlerActivity)
{
this.Header.Text = System.Workflow.Activities.DR.GetString("WorkflowCompensation");
this.HelpText = string.Empty;
}
else if (designer.Activity is CancellationHandlerActivity)
{
this.Header.Text = System.Workflow.Activities.DR.GetString("WorkflowCancellation");
this.HelpText = string.Empty;
}
else
{
this.Header.Text = System.Workflow.Activities.DR.GetString("StartSequentialWorkflow");
this.HelpText = System.Workflow.Activities.DR.GetString("SequentialWorkflowHelpText");
}
}
// Determine whether the view of a ModelItem is expanded without querying the view itself - the view may have not been constructed.
internal static bool IsViewExpanded(ModelItem modelItem, EditingContext context)
{
if (modelItem == null)
{
return(false);
}
bool isDesignerExpanded = true;
bool isDesignerPinned = false;
object isExpandedViewState = GetViewStateService(context).RetrieveViewState(modelItem, ExpandViewStateKey);
object isPinnedViewState = GetViewStateService(context).RetrieveViewState(modelItem, WorkflowViewElement.PinnedViewStateKey);
if (isExpandedViewState != null)
{
isDesignerExpanded = (bool)isExpandedViewState;
}
if (isPinnedViewState != null)
{
isDesignerPinned = (bool)isPinnedViewState;
}
DesignerView designerView = context.Services.GetService <DesignerView>();
return(ShouldShowExpanded(IsBreadcrumbRoot(modelItem, context), DoesParentAlwaysExpandChildren(modelItem, context),
DoesParentAlwaysCollapseChildren(modelItem, context), isDesignerExpanded, designerView.ShouldExpandAll, designerView.ShouldCollapseAll, isDesignerPinned));
}
public SearchToolTipAdorner(UIElement adornedElement, DesignerView designerView, string text)
: base(adornedElement)
{
this.scrollViewerToScreenDistance = designerView.ScrollViewer.PointToScreen(new Point(0, 0)).Y;;
tooltip = new Border
{
Background = new SolidColorBrush(WorkflowDesignerColors.DesignerViewBackgroundColor),
BorderBrush = new SolidColorBrush(WorkflowDesignerColors.WorkflowViewElementBorderColor),
BorderThickness = new Thickness(1),
CornerRadius = new CornerRadius(4),
Margin = new Thickness(10),
Child = new TextBlock
{
Foreground = new SolidColorBrush(WorkflowDesignerColors.WorkflowViewElementCaptionColor),
Margin = new Thickness(4, 0, 4, 0),
MaxWidth = 300,
Text = text,
TextWrapping = TextWrapping.Wrap,
TextTrimming = TextTrimming.CharacterEllipsis
},
Effect = new DropShadowEffect
{
Color = Colors.Black,
BlurRadius = 4,
Opacity = 0.5
},
};
tooltip.Measure(new Size(Double.PositiveInfinity, Double.PositiveInfinity));
}
protected override Size ArrangeOverride(Size arrangeSize)
{
Performance.StartTiming(PerformanceMarks.AdornerArrange);
if (VisualTreeHelper.GetParent((DependencyObject)this) != null)
{
if (this._needEvaluateLayout)
{
this._needEvaluateLayout = false;
this._evaluateLayoutList = (List <UIElement>)null;
this.EvaluateLayout();
}
else if (this._evaluateLayoutList != null)
{
List <UIElement> list = this._evaluateLayoutList;
this._evaluateLayoutList = (List <UIElement>)null;
DesignerView currentDesignerView = this.CurrentDesignerView;
foreach (UIElement adorner in list)
{
AdornerProperties.GetLayout((DependencyObject)adorner).EvaluateLayout(currentDesignerView, adorner);
}
}
foreach (UIElement adorner in this.InternalChildren)
{
AdornerProperties.GetLayout((DependencyObject)adorner).Arrange(adorner);
}
}
Performance.StopTiming(PerformanceMarks.AdornerArrange);
return(arrangeSize);
}
protected override void Activate(ModelItem item)
{
designObject = item.GetCurrentValue() as LinkableControl;//获得被点击的控件对象
if (designObject != null)
{
designCanvas = designObject.Parent as Panel;
DesignerView v = DesignerView.FromContext(Context);
adorner = new ControlAdorner(designObject);
adorner.RenderTransform = new ScaleTransform(v.ZoomLevel, v.ZoomLevel);
foreach (var pin in adorner.Children)
{
pin.MouseLeftButtonDown += new MouseButtonEventHandler(Pin_MouseLeftButtonDown); //按下左键选中hitPin，开始拖动
pin.MouseMove += new MouseEventHandler(Pin_MouseMove); //移动鼠标，开始找寻目标连接节点
}
AdornerPanel.SetAdornerHorizontalAlignment(adorner, AdornerHorizontalAlignment.Stretch);
AdornerPanel.SetAdornerVerticalAlignment(adorner, AdornerVerticalAlignment.Stretch);
_panel.Children.Add(adorner);
Adorners.Add(_panel);
v.ZoomLevelChanged += (s, e) => { adorner.RenderTransform = new ScaleTransform(v.ZoomLevel, v.ZoomLevel); };
}
base.Activate(item);
}
private static void UpdateTypeArgument(ModelItem modelItem, Type value)
{
if (value != null)
{
Type oldModelItemType = modelItem.ItemType;
Fx.Assert(oldModelItemType.GetGenericArguments().Count() == 1, "we only support changing a single type parameter ?");
Type newModelItemType = oldModelItemType.GetGenericTypeDefinition().MakeGenericType(value);
Fx.Assert(newModelItemType != null, "New model item type needs to be non null or we cannot proceed further");
ModelItem newModelItem = ModelFactory.CreateItem(modelItem.GetEditingContext(), Activator.CreateInstance(newModelItemType));
MorphHelper.MorphObject(modelItem, newModelItem);
MorphHelper.MorphProperties(modelItem, newModelItem);
if (oldModelItemType.IsSubclassOf(typeof(Activity)) && newModelItemType.IsSubclassOf(typeof(Activity)))
{
if (string.Equals((string)modelItem.Properties["DisplayName"].ComputedValue, GetActivityDefaultName(oldModelItemType), StringComparison.Ordinal))
{
newModelItem.Properties["DisplayName"].SetValue(GetActivityDefaultName(newModelItemType));
}
}
DesignerView designerView = modelItem.GetEditingContext().Services.GetService <DesignerView>();
if (designerView != null)
{
Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Render, (Action)(() =>
{
if (designerView.RootDesigner != null && ((WorkflowViewElement)designerView.RootDesigner).ModelItem == modelItem)
{
designerView.MakeRootDesigner(newModelItem, true);
}
Selection.SelectOnly(modelItem.GetEditingContext(), newModelItem);
}));
}
}
}
public void SetDesigner(WorkflowDesigner designer)
{
if (_designer != null)
{
mSearchBox.Text = String.Empty;
SetCommandTarget(null);
_designer.View.PreviewKeyDown -= new KeyEventHandler(View_PreviewKeyDown);
this.mContentControl.Content = null;
_textBlockComparer = null;
_designerPresenter = null;
_mainScrollViewer = null;
}
_designer = designer;
if (designer != null)
{
// set some view params to hide stuff and expand all items
DesignerView designerView = _designer.Context.Services.GetService <DesignerView>();
designerView.WorkflowShellBarItemVisibility = ShellBarItemVisibility.None;
designerView.ShouldExpandAll = false;
designerView.ShouldCollapseAll = true;
RuleDesignerHelper.HideExpandCollapseControl(designerView);
RuleDesignerHelper.ChangeRuleContentAlighment(designerView);
_mainScrollViewer = LogicalTreeHelper.FindLogicalNode(designerView, "scrollViewer") as ScrollViewer; // NOXLATE
_designerPresenter = LogicalTreeHelper.FindLogicalNode(_mainScrollViewer, "designerPresenter") as FrameworkElement; // NOXLATE
_textBlockComparer = new TextBlockComparer(_designerPresenter);
this.mContentControl.Content = designer.View;
designer.View.PreviewKeyDown += new KeyEventHandler(View_PreviewKeyDown);
SetCommandTarget(designerView);
}
}
protected override void OnViewChanged(DesignerView view)
{
base.OnViewChanged(view);
ActivityDesigner hostedDesigner = (ActiveView != null) ? ActiveView.AssociatedDesigner : null;
if (hostedDesigner.Activity is FaultHandlersActivity)
{
Header.Text = DR.GetString(DR.WorkflowExceptions);
HelpText = String.Empty;
}
else if (hostedDesigner.Activity is EventHandlersActivity)
{
Header.Text = DR.GetString(DR.WorkflowEvents);
HelpText = String.Empty;
}
else if (hostedDesigner.Activity is CompensationHandlerActivity)
{
Header.Text = DR.GetString(DR.WorkflowCompensation);
HelpText = String.Empty;
}
else if (hostedDesigner.Activity is CancellationHandlerActivity)
{
Header.Text = DR.GetString(DR.WorkflowCancellation);
HelpText = String.Empty;
}
else
{
Header.Text = DR.GetString(DR.StartSequentialWorkflow);
HelpText = DR.GetString(DR.SequentialWorkflowHelpText);
}
}
internal static DataObject DoDragMoveImpl(IEnumerable <WorkflowViewElement> draggedViewElements, Point referencePoint)
{
List <ModelItem> draggedModelItems = new List <ModelItem>();
bool first = true;
WorkflowViewElement viewElement = null;
foreach (WorkflowViewElement view in draggedViewElements)
{
if (view != null)
{
if (first)
{
viewElement = view;
first = false;
}
draggedModelItems.Add(view.ModelItem);
view.IsHitTestVisible = false;
}
}
DataObject dataObject = new DataObject(ModelItemsDataFormat, draggedModelItems);
// For compatiblity
if (viewElement != null)
{
dataObject.SetData(ModelItemDataFormat, viewElement.ModelItem);
dataObject.SetData(CompositeViewFormat, GetCompositeView(viewElement));
}
dataObject.SetData(DragAnchorPointFormat, referencePoint);
if (viewElement != null)
{
DesignerView designerView = viewElement.Context.Services.GetService <DesignerView>();
ViewElementDragShadow dragShadow = new ViewElementDragShadow(designerView.scrollableContent, draggedViewElements, referencePoint, designerView.ZoomFactor);
designerView.BeginDragShadowTracking(dragShadow);
//whenever drag drop fails - ensure getting rid of drag shadow
try
{
DragDrop.DoDragDrop(designerView, dataObject, DragDropEffects.Move | DragDropEffects.Copy | DragDropEffects.Scroll | DragDropEffects.Link);
}
catch
{
//let the caller handle exception
throw;
}
finally
{
designerView.EndDragShadowTracking(dragShadow);
foreach (WorkflowViewElement view in draggedViewElements)
{
if (view != null)
{
view.IsHitTestVisible = true;
}
}
}
}
return(dataObject);
}
private static bool IsAdornableElement(DesignerView view, ViewItem element)
{
if (element != (ViewItem)null)
{
return(element.IsDescendantOf((Visual)view));
}
return(false);
}
internal static Vector GetZoomRounding(DesignerView dview)
{
Vector invertZoomFactor = DesignerUtilities.GetInvertZoomFactor(dview);
invertZoomFactor.X = Math.Round(invertZoomFactor.X, 3);
invertZoomFactor.Y = Math.Round(invertZoomFactor.Y, 3);
return(invertZoomFactor);
}
void SetCommandTarget(DesignerView view)
{
this.mCopyBtn.CommandTarget = view;
this.mCutBtn.CommandTarget = view;
this.mPasteBtn.CommandTarget = view;
this.mRedoBtn.CommandTarget = view;
this.mUndoBtn.CommandTarget = view;
}
public void Attach(DesignerView viewContent)
{
if (viewContent == null)
{
throw new ArgumentNullException("viewContent");
}
LoggingService.Info("DesignerGenerator:Attach");
this.viewContent = viewContent;
}
public static void MakeRootDesigner(WorkflowViewElement wve)
{
DesignerView designerView = wve.Context.Services.GetService <DesignerView>();
if (!wve.Equals(designerView.RootDesigner))
{
designerView.MakeRootDesigner(wve.ModelItem);
}
}
protected void SaveGlobalState()
{
DesignerView designerView = context.Services.GetService <DesignerView>();
if (designerView != null && designerView.RootDesigner != null)
{
designerRoot = ((WorkflowViewElement)designerView.RootDesigner).ModelItem;
}
}
public static void Delete(EditingContext context)
{
if (context == null)
{
throw FxTrace.Exception.AsError(new ArgumentNullException("context"));
}
Selection selection = context.Items.GetValue <Selection>();
if (null != selection)
{
bool selectRoot = false;
DesignerView designerView = context.Services.GetService <DesignerView>();
var toDelete = selection.SelectedObjects.Where(p => null != p.View && p.View is WorkflowViewElement && !p.View.Equals(designerView.RootDesigner));
if (toDelete.Count() > 0)
{
using (EditingScope es = (EditingScope)toDelete.FirstOrDefault().BeginEdit(SR.DeleteOperationEditingScopeDescription))
{
Dictionary <ICompositeView, List <ModelItem> > containerToModelItemsDict = new Dictionary <ICompositeView, List <ModelItem> >();
List <ModelItem> modelItemsPerContainer;
foreach (var item in toDelete)
{
ICompositeView container = (ICompositeView)DragDropHelper.GetCompositeView((WorkflowViewElement)item.View);
if (null != container)
{
if (!containerToModelItemsDict.TryGetValue(container, out modelItemsPerContainer))
{
modelItemsPerContainer = new List <ModelItem>();
containerToModelItemsDict.Add(container, modelItemsPerContainer);
}
modelItemsPerContainer.Add(item);
}
}
foreach (ICompositeView container in containerToModelItemsDict.Keys)
{
container.OnItemsDelete(containerToModelItemsDict[container]);
selectRoot = true;
}
if (selectRoot)
{
DesignerView view = context.Services.GetService <DesignerView>();
if (null != view)
{
WorkflowViewElement rootView = view.RootDesigner as WorkflowViewElement;
if (rootView != null)
{
Selection.SelectOnly(context, rootView.ModelItem);
}
}
}
es.Complete();
}
}
}
}
void SetShowExpandedBindings()
{
MultiBinding multiBinding = new MultiBinding();
//Bind to ModelItem
Binding modelItemBinding = new Binding();
modelItemBinding.Source = this;
modelItemBinding.Path = new PropertyPath(WorkflowViewElement.ModelItemProperty);
//Bind to IsRootDesigner
Binding isRootDesignerBinding = new Binding();
isRootDesignerBinding.Source = this;
isRootDesignerBinding.Path = new PropertyPath(WorkflowViewElement.IsRootDesignerProperty);
//Bind to DesignerView.ExpandAll
Binding expandAllBinding = new Binding();
DesignerView view = this.Context.Services.GetService <DesignerView>();
expandAllBinding.Source = view;
expandAllBinding.Path = new PropertyPath(DesignerView.ShouldExpandAllProperty);
//Bind to DesignerView.CollapseAll
Binding collapseAllBinding = new Binding();
collapseAllBinding.Source = view;
collapseAllBinding.Path = new PropertyPath(DesignerView.ShouldCollapseAllProperty);
//Bind to ExpandState
Binding expandStateBinding = new Binding();
expandStateBinding.Source = this;
expandStateBinding.Path = new PropertyPath(WorkflowViewElement.ExpandStateProperty);
//Bind to PinState
Binding pinStateBinding = new Binding();
pinStateBinding.Source = this;
pinStateBinding.Path = new PropertyPath(WorkflowViewElement.PinStateProperty);
//Bind to self
Binding selfBinding = new Binding();
selfBinding.Source = this;
//Bind to container (to recalculate on drag-drop.)
Binding containerBinding = new Binding();
containerBinding.Source = this;
containerBinding.Path = new PropertyPath(DragDropHelper.DragSourceProperty);
multiBinding.Bindings.Add(modelItemBinding);
multiBinding.Bindings.Add(isRootDesignerBinding);
multiBinding.Bindings.Add(expandAllBinding);
multiBinding.Bindings.Add(collapseAllBinding);
multiBinding.Bindings.Add(expandStateBinding);
multiBinding.Bindings.Add(pinStateBinding);
multiBinding.Bindings.Add(selfBinding);
multiBinding.Bindings.Add(containerBinding);
multiBinding.Mode = BindingMode.OneWay;
multiBinding.Converter = new ShowExpandedMultiValueConverter();
BindingOperations.SetBinding(this, WorkflowViewElement.ShowExpandedProperty, multiBinding);
}
internal static Transform GetSelectionFrameTransformToDesignerView(EditingContext context, ViewItem view)
{
DesignerView designerView = DesignerView.FromContext(context);
if (designerView == null)
{
return(Transform.Identity);
}
return(TransformUtil.GetSelectionFrameTransformToParentVisual(view, (Visual)designerView));
}
public DesignerViewAutomationPeer(DesignerView view)
: base((UIElement)view)
{
if (view == null)
{
return;
}
this._owner = view;
this.Context = this._owner.Context;
}
internal static double GetInvertZoom(DesignerView dview)
{
Vector scaleFromTransform = TransformUtil.GetScaleFromTransform(dview.GetZoomTransform());
if (scaleFromTransform.X == 0.0)
{
return(0.0);
}
return(1.0 / scaleFromTransform.X);
}
void MakeRootDesigner()
{
DesignerView designerView = this.Context.Services.GetService <DesignerView>();
if (!this.Equals(designerView.RootDesigner))
{
designerView.MakeRootDesigner(this.ModelItem);
this.leftMouseButtonDown = false;
}
}
internal static Vector GetZoomFactor(EditingContext context)
{
DesignerView designerView = DesignerView.FromContext(context);
if (designerView == null)
{
return(new Vector(1.0, 1.0));
}
return(TransformUtil.GetScaleFromTransform(designerView.GetZoomTransform()));
}
internal static Transform GetSelectionFrameTransformToDesignerView(DependencyObject view)
{
DesignerView designerView = TransformUtil.GetDesignerView(view);
if (designerView == null)
{
return(Transform.Identity);
}
return(TransformUtil.GetSelectionFrameTransformToParentVisual(view, (Visual)designerView));
}
public static void ChangeRuleContentAlighment(DesignerView designerView)
{
Viewbox viewBox = LogicalTreeHelper.FindLogicalNode(designerView, "viewBox") as Viewbox; // NOXLATE
if (viewBox != null)
{
viewBox.HorizontalAlignment = HorizontalAlignment.Left;
viewBox.VerticalAlignment = VerticalAlignment.Top;
}
}
public void DeleteDesigner(DesignerView designer)
{
using (DigiFusionEntities db = new DigiFusionEntities())
{
Designer designerDb = db.Designers.Single(x => x.DesignerID == designer.DesignerID);;
designerDb.IsDeleted = true;
db.SaveChanges();
}
}
public static DesignerCanvas GetDesignerCanvas(EDMDesignerViewContent container, EDMView edmView, DesignerView designerView)
{
DesignerCanvas designerCanvas = null;
//if (designerView == null)
//{
// EntityTypeDesigner.Init = true;
// designerView = new DesignerView();
// designerView.ArrangeTypeDesigners = true;
// designerView.Name = edmView.Name;
// designerView.Zoom = 100;
// if (edmView.CSDL.CSDL != null)
// {
// foreach (UIEntityType entityType in edmView.CSDL.EntityTypes)
// {
// designerView.AddTypeDesigner(new EntityTypeDesigner(entityType) { IsExpanded = true });
// }
// }
// EntityTypeDesigner.Init = false;
//}
if (designerView != null && _designerCanvas.ContainsKey(designerView))
{
designerCanvas = _designerCanvas[designerView];
var parent = designerCanvas.Parent as DesignerCanvasPreview;
if (parent != null)
parent.Content = null;
else
((ContentControl)designerCanvas.Parent).Content = null;
}
else
{
designerCanvas = new DesignerCanvas(container) { EDMView = edmView, DesignerView = designerView, Background = Brushes.White };
_designerCanvas.Add(designerView, designerCanvas);
}
return designerCanvas;
}
public static DesignerView Read(EDMView edmView, Func<UIEntityType, ITypeDesigner> createEntityDesignerFromUIType, Func<UIComplexType, ITypeDesigner> createComplexDesignerFromUIType, XElement designerViewXElement)
{
EDMDesignerChangeWatcher.Init = true;
var designerView = new DesignerView()
{
Name = designerViewXElement.Attribute("Name").Value,
Zoom = int.Parse(designerViewXElement.Attribute("Zoom").Value)
};
var arrange = designerViewXElement.Attribute("Arrange");
if (arrange != null)
designerView.ArrangeTypeDesigners = bool.Parse(arrange.Value);
IEnumerable<XElement> designerTypeXElements = designerViewXElement.Elements("DesignerType");
foreach (var designerTypeXElement in designerTypeXElements)
{
var name = designerTypeXElement.Attribute("Name").Value;
ITypeDesigner typeDesigner;
var entityType = edmView.CSDL.EntityTypes.FirstOrDefault(et => et.Name == name);
if (entityType != null)
typeDesigner = createEntityDesignerFromUIType(entityType);
else
{
var complexType = edmView.CSDL.ComplexTypes.FirstOrDefault(ct => ct.Name == name);
if (complexType == null)
continue;
typeDesigner = createComplexDesignerFromUIType(complexType);
}
var leftAttribute = designerTypeXElement.Attribute("Left").Value;
if (leftAttribute != null)
typeDesigner.Left = double.Parse(leftAttribute, CultureInfo.InvariantCulture);
var topAttribute = designerTypeXElement.Attribute("Top").Value;
if (topAttribute != null)
typeDesigner.Top = double.Parse(topAttribute, CultureInfo.InvariantCulture);
var isExpandedAttribute = designerTypeXElement.Attribute("IsExpanded");
if (isExpandedAttribute != null)
{
RoutedEventHandler loaded = null;
loaded = delegate
{
EDMDesignerChangeWatcher.Init = true;
typeDesigner.IsExpanded = bool.Parse(isExpandedAttribute.Value);
typeDesigner.Loaded -= loaded;
EDMDesignerChangeWatcher.Init = false;
};
typeDesigner.Loaded += loaded;
}
designerView.TypeDesignersLocations.Add(typeDesigner);
}
EDMDesignerChangeWatcher.Init = false;
return designerView;
}
private static XElement Write(DesignerView designerView)
{
XElement designerViewElement = new XElement("DesignerView",
new XAttribute("Name", designerView.Name),
new XAttribute("Zoom", designerView.Zoom));
foreach (ITypeDesigner uiType in designerView)
{
designerViewElement.Add(new XElement("DesignerType",
new XAttribute("Name", uiType.UIType.Name),
new XAttribute("Left", uiType.Left),
new XAttribute("Top", uiType.Top),
new XAttribute("IsExpanded", uiType.IsExpanded)));
}
return designerViewElement;
}
