private void MakeBlack()
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.EditColor);
this.BeginUpdate();
this.ColorModel.Color = Colors.Black;
this.EndUpdate();
}
private void OnSplitterResized(object sender, DragDeltaEventArgs args)
{
SplitterGrip splitterGrip = args.OriginalSource as SplitterGrip;
if (splitterGrip == null)
{
return;
}
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.ResizePalette);
args.Handled = true;
for (int index = 0; index < this.InternalChildren.Count; ++index)
{
if (this.InternalChildren[index].IsAncestorOf((DependencyObject)splitterGrip))
{
double pixelAmount = this.Orientation == Orientation.Horizontal ? args.HorizontalChange : args.VerticalChange;
switch (splitterGrip.ResizeBehavior)
{
case GridResizeBehavior.CurrentAndNext:
this.ResizeChildren(index, index + 1, pixelAmount);
continue;
case GridResizeBehavior.PreviousAndCurrent:
this.ResizeChildren(index - 1, index, pixelAmount);
continue;
case GridResizeBehavior.PreviousAndNext:
this.ResizeChildren(index - 1, index + 1, pixelAmount);
continue;
default:
throw new InvalidOperationException("BasedOnAlignment is not a valid resize behavior");
}
}
}
}
private void HidePalettes()
{
List <ViewElement> list = Enumerable.ToList <ViewElement>(this.HideableViews);
if (!Enumerable.Any <ViewElement>((IEnumerable <ViewElement>)list))
{
return;
}
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.TogglePalettes);
Microsoft.VisualStudio.PlatformUI.Shell.View activeView = ViewManager.Instance.ActiveView;
if (list.Contains((ViewElement)activeView))
{
this.SavedActiveView = activeView;
}
foreach (ViewElement viewElement in list)
{
ExpressionView expressionView = viewElement as ExpressionView;
if (expressionView != null)
{
expressionView.WasSelectedBeforeAutoHide = expressionView.IsSelected;
}
}
foreach (ViewElement viewElement in list)
{
DockOperations.AutoHide(viewElement);
}
}
private void RestorePalettes()
{
List <ViewElement> list = Enumerable.ToList <ViewElement>(this.AutoHiddenViews);
if (!Enumerable.Any <ViewElement>((IEnumerable <ViewElement>)list))
{
return;
}
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.TogglePalettes);
foreach (ViewElement element in list)
{
DockOperations.SnapToBookmark(element);
}
foreach (ViewElement viewElement in list)
{
ExpressionView expressionView = viewElement as ExpressionView;
if (expressionView != null)
{
expressionView.IsSelected = expressionView.WasSelectedBeforeAutoHide;
}
}
if (this.SavedActiveView != null && this.SavedActiveView.WindowProfile == ViewManager.Instance.WindowProfile)
{
ViewManager.Instance.ActiveView = this.SavedActiveView;
}
this.SavedActiveView = (Microsoft.VisualStudio.PlatformUI.Shell.View)null;
}
private void MakeInitialColor()
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.EditColor);
this.BeginUpdate();
this.ColorModel.Color = this.InitialColor;
this.EndUpdate();
}
private void MakeLastColor()
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.EditColor);
this.BeginUpdate();
this.ColorModel.CopyFrom(this.LastColorModel);
this.EndUpdate();
}
private void SetActiveView(IView view)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.SwitchView);
IDocumentView documentView = view as IDocumentView;
DocumentService.Item obj = documentView != null ? this.items[documentView.Document] : (DocumentService.Item)null;
this.SetActiveDocumentAndView(view, obj);
}
private void ExpandoSplitter_DragDelta(object sender, DragDeltaEventArgs e)
{
if (!(this.Parent is Grid))
{
return;
}
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.ResizePalette);
this.MoveSplitter(e.HorizontalChange, e.VerticalChange);
}
private static void ZoomPropertyChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.AdjustZoom);
Artboard artboard = (Artboard)dependencyObject;
artboard.UpdateChildren();
if (artboard.ZoomChanged == null)
{
return;
}
artboard.ZoomChanged((object)artboard, EventArgs.Empty);
}
public override void Execute()
{
List <SceneElement> list = Enumerable.ToList <SceneElement>(this.ApplicableElements);
if (!Enumerable.Any <SceneElement>((IEnumerable <SceneElement>)list))
{
throw new InvalidOperationException();
}
this.SceneView.DesignerContext.AnnotationsOptionsModel.InitAuthorInfoIfNeeded();
PerformanceUtility.MeasurePerformanceUntilRender(list.Count != 1 || list[0] != this.SceneView.ViewModel.RootNode ? PerformanceEvent.AnnotationCreationAttached : PerformanceEvent.AnnotationCreationFloating);
this.AnnotationService.Create((IEnumerable <SceneElement>)list, true);
}
private void Me_Click(object sender, RoutedEventArgs e)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.CommandBarCheckBoxClicked);
bool flag = true;
object commandProperty = this.commandService.GetCommandProperty(this.command, "IsChecked");
if (commandProperty != null)
{
flag = !(bool)commandProperty;
}
this.commandService.SetCommandProperty(this.command, "IsChecked", flag);
}
protected override bool OnDrag(Point dragStartPosition, Point dragCurrentPosition, bool scrollNow)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.EditPath);
if (this.currentEditingElement != null && this.pathPartAdorner != null)
{
this.MoveSelection();
this.ActiveView.EnsureVisible(dragCurrentPosition, scrollNow);
if (this.IsEditTransactionOpen)
{
this.UpdateEditTransaction();
}
}
return(true);
}
protected override void OnBegin(PathEditContext pathEditContext, MouseDevice mouseDevice)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.EditPath);
Point viewRootCoordinates = this.GetPointInViewRootCoordinates(mouseDevice, false);
PathFigureEditor pathFigureEditor = new PathFigureEditor(pathEditContext.GetPathFigure(this.Path), this.PathEditorTarget.PathDiffChangeList, pathEditContext.FigureIndex);
Matrix elementTransformToRoot = this.EditingElementTransformToRoot;
int partIndex = pathEditContext.PartIndex;
Point closestPoint;
double distanceSquared;
double ofUpstreamSegment = pathFigureEditor.GetClosestPointOfUpstreamSegment(partIndex, viewRootCoordinates, elementTransformToRoot, Tolerances.CurveFlatteningTolerance, out closestPoint, out distanceSquared);
this.InsertPoint(pathEditContext, ofUpstreamSegment);
base.OnBegin(pathEditContext, mouseDevice);
this.End();
}
public override void Execute()
{
this.HandleBasicExceptions(() => {
string str = base.SelectProject(StringTable.OpenProjectDialogTitle);
if (!string.IsNullOrEmpty(str))
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.OpenProjectInner);
ISolution solution = this.ProjectManager().OpenSolution(DocumentReference.Create(str), true, true);
PerformanceUtility.MarkInterimStep(PerformanceEvent.OpenProjectInner, "Finished loading, now closing all projects.");
if (solution != null)
{
this.ProjectManager().DefaultOpenProjectPath = Path.GetDirectoryName(Path.GetDirectoryName(solution.DocumentReference.Path));
}
}
});
}
protected override void Initialize()
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.MultipleElementRotate);
this.FireNotifications(false);
CanonicalDecomposition canonicalDecomposition = this.EditingElementSet.CalculateSharedTransform();
this.UnsnappedAngle = canonicalDecomposition.RotationAngle;
this.initialBounds = this.EditingElementSet.Bounds;
this.intialRenderTransformOrigin = this.EditingElementSet.RenderTransformOrigin;
this.initialSharedTransform = canonicalDecomposition;
this.initialElementSetCenter = this.EditingElementSet.RenderTransformOriginInElementCoordinates;
foreach (SceneElement element in this.EditingElementSet.Elements)
{
this.initialTransforms[element] = new CanonicalTransform((Transform)element.GetComputedValueAsWpf(element.Platform.Metadata.CommonProperties.RenderTransform));
this.elementsToElement[element] = ElementUtilities.GetInverseMatrix(this.EditingElementSet.GetTransformToElementSpaceFromMemberElement(element));
}
this.initialArtboardOrigin = this.EditingElement.DesignerContext.ActiveView.Artboard.ArtboardBounds.TopLeft;
}
protected virtual void UpdateAdorners(DragAbsoluteEventArgs args, FloatingElement floatingElement, IList <DockSiteType> types, ViewElement element)
{
DockManager.DockSiteHitTestResult hitElement = this.FindHitElement(args.ScreenPoint, (Predicate <DockManager.DockSite>)(s =>
{
if (s.Visual != floatingElement)
{
return(!(s.Visual is DockAdornerWindow));
}
return(false);
}));
ICollection <DockAdornerWindow> addedAdorners = (ICollection <DockAdornerWindow>) new List <DockAdornerWindow>();
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.DisplayDockingAdorner);
if (hitElement != null)
{
addedAdorners = this.AddAdorners(hitElement.DockSite, hitElement.VisualHit, types, element);
}
this.ClearAdorners((Predicate <Visual>)(visual => !addedAdorners.Contains(visual as DockAdornerWindow)));
}
private void OnActivateCommand()
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.ActivateProjectItem);
INamedProject namedProject = base.Services.ProjectManager().CurrentSolution.FindProjectContainingOpenItem(this.projectItem.DocumentReference);
if (namedProject != null && namedProject != this.ProjectItem.Project)
{
base.Services.MessageDisplayService().ShowError(StringTable.ProjectItemAlreadyOpenMessage);
return;
}
IView activeView = base.Services.ViewService().ActiveView;
if (!this.projectItem.DocumentType.CanView)
{
if (this.projectItem is FolderStandIn || this.projectItem.DocumentType == base.Services.DocumentTypes()[DocumentTypeNamesHelper.Folder])
{
this.IsExpanded = !this.IsExpanded;
return;
}
if (activeView != null && this.projectItem.DocumentType.CanInsertTo(this.projectItem, activeView))
{
this.projectItem.DocumentType.AddToDocument(this.projectItem, activeView);
return;
}
if (Microsoft.Expression.Framework.Documents.PathHelper.FileExists(this.projectItem.DocumentReference.Path))
{
CommandTarget commandTarget = base.Services.ProjectManager() as CommandTarget;
if (commandTarget != null)
{
string str = "Project_EditExternally";
commandTarget.SetCommandProperty(str, "TargetDocument", this.ProjectItem);
commandTarget.Execute(str, CommandInvocationSource.Palette);
}
}
}
else
{
using (IDisposable disposable = TemporaryCursor.SetWaitCursor())
{
this.projectItem.OpenView(true);
}
}
}
private bool CreateAndExecuteCodeAidAction(TextCompositionEventArgs e, bool matchingModeOnly)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.TextInsertLetter);
if (this.completionBroker == null)
{
return(false);
}
CodeAidContext codeAidContext = this.CreateCodeAidContext();
CodeAidAction action = this.codeAidEngine.ProcessTextInput(e.Text, codeAidContext);
if (!action.IsNone)
{
this.ExecuteCodeAidAction(action, matchingModeOnly);
}
if (!action.TestFlag(CodeAidActionType.EatInput) && !matchingModeOnly)
{
this.editorOperations.InsertText(e.Text, this.undoHistory);
}
return(true);
}
protected override bool OnButtonDown(Point pointerPosition)
{
PerformanceUtility.StartPerformanceSequence(PerformanceEvent.ResizeElement);
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.ResizeViaAdorners);
this.EnsureEditTransaction();
this.CreateSubTransaction();
this.layoutRoundingOverride.SetValue((IEnumerable <SceneElement>) this.EditingElementSet.Elements, false);
this.elementToDocumentTransform = this.ComputeElementToDocumentTransform();
this.startBounds = this.BaseEditingElement.GetComputedTightBounds();
this.startBoundsInParent = this.ActiveView.GetActualBoundsInParent(this.BaseEditingElement.Visual);
this.startPointerPosition = this.ActiveAdorner.GetAnchorPoint(Matrix.Identity);
this.adornerOffset = this.startPointerPosition * this.elementToDocumentTransform - pointerPosition;
this.startTransform = new CanonicalTransform((Transform)this.EditingElement.GetComputedValueAsWpf(Base2DElement.RenderTransformProperty));
this.startCenter = this.BaseEditingElement.RenderTransformOriginInElementCoordinates;
this.constrainAspectRatio = this.ShouldConstrainAspectRatio;
this.scaleAroundCenter = this.ShouldScaleAroundCenter;
this.currentPointerPosition = this.startPointerPosition;
this.UpdateCenter();
this.Initialize();
return(true);
}
protected override void OnBegin(PathEditContext pathEditContext, MouseDevice mouseDevice)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.EditPath);
Vector lastTangent = this.LastTangent;
base.OnBegin(pathEditContext, mouseDevice);
PathGeometryEditor pathGeometryEditor = this.BeginEditing();
Matrix elementTransformToRoot = this.EditingElementTransformToRoot;
Point lastPoint = this.GetLastPoint(pathEditContext.FigureIndex);
Point point1 = elementTransformToRoot.Transform(lastPoint);
Vector vector = this.GetPointInViewRootCoordinates(mouseDevice, true) - point1;
Size devicePixelSize = DeviceUtilities.GetDevicePixelSize(this.View.Zoom);
if (Math.Abs(vector.X) < devicePixelSize.Width / 2.0)
{
vector.X = 0.0;
}
if (Math.Abs(vector.Y) < devicePixelSize.Height / 2.0)
{
vector.Y = 0.0;
}
Vector correspondingVector = ElementUtilities.GetCorrespondingVector(vector, elementTransformToRoot, this.IsShiftDown ? this.AxisConstraint : (AxisConstraint)null);
Point point2 = lastPoint + correspondingVector;
if (VectorUtilities.IsZero(lastTangent))
{
pathGeometryEditor.AppendLineSegment(point2, pathEditContext.FigureIndex);
}
else
{
Point q = lastPoint + lastTangent;
pathGeometryEditor.AppendCubicBezier(q, point2, point2, pathEditContext.FigureIndex);
}
int figureIndex = pathEditContext.FigureIndex;
PathFigure figure = this.Path.Figures[figureIndex];
this.PathEditContext = new PathEditContext(figureIndex, PathFigureUtilities.PointCount(figure) - 1);
this.Initialize(elementTransformToRoot.Transform(point2), true, elementTransformToRoot);
}
protected override void OnSubmenuOpened(RoutedEventArgs e)
{
base.OnSubmenuOpened(e);
int count = this.Items.Count;
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.OpenCommandBarDynamicMenu);
IEnumerable enumerable = (IEnumerable)this.commandService.GetCommandProperty(this.command, "Items");
bool flag = false;
foreach (object newItem in enumerable)
{
this.Items.Add(newItem);
flag = true;
}
if (!flag)
{
return;
}
for (int index = 0; index < count; ++index)
{
this.Items.RemoveAt(0);
}
}
public void PerformDrop(DragAbsoluteEventArgs args)
{
DragUndockHeader dragUndockHeader = args.OriginalSource as DragUndockHeader;
FloatingWindow floatingWindow = Microsoft.VisualStudio.PlatformUI.ExtensionMethods.FindAncestor <FloatingWindow>((Visual)dragUndockHeader);
DockManager.DockSiteHitTestResult hitElement = this.FindHitElement(args.ScreenPoint, (Predicate <DockManager.DockSite>)(s => s.Visual != floatingWindow));
if (hitElement != null)
{
DockSiteAdorner ancestorOrSelf1 = Microsoft.VisualStudio.PlatformUI.ExtensionMethods.FindAncestorOrSelf <DockSiteAdorner>(hitElement.VisualHit);
DockAdornerWindow ancestorOrSelf2 = Microsoft.VisualStudio.PlatformUI.ExtensionMethods.FindAncestorOrSelf <DockAdornerWindow>(hitElement.VisualHit);
DockTarget dockTarget = Microsoft.VisualStudio.PlatformUI.ExtensionMethods.FindAncestorOrSelf <DockTarget>(hitElement.VisualHit);
DockDirection dockDirection = DockDirection.Fill;
bool flag = false;
bool createDocumentGroup = false;
if (floatingWindow != null && this.IsValidFillPreviewOperation(dockTarget, dragUndockHeader.ViewElement))
{
dockDirection = DockDirection.Fill;
flag = true;
}
if (ancestorOrSelf1 != null && ancestorOrSelf2 != null && ancestorOrSelf2.AdornedElement != null)
{
dockDirection = ancestorOrSelf1.DockDirection;
dockTarget = ancestorOrSelf2.AdornedElement as DockTarget;
if (DockOperations.AreDockRestrictionsFulfilled(dragUndockHeader.ViewElement, dockTarget.TargetElement))
{
flag = true;
createDocumentGroup = ancestorOrSelf1.CreatesDocumentGroup;
}
}
if (flag)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.DockPalette);
dockTarget.RaiseEvent((RoutedEventArgs) new FloatingElementDockedEventArgs(DockManager.FloatingElementDockedEvent, dragUndockHeader.ViewElement, dockDirection, createDocumentGroup));
}
}
this.ClearAdorners();
}
public override SceneNode CreateAndSetBindingOrData(SceneNodeProperty property)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.DatabindCommand);
SceneNode sceneNode = (SceneNode)((object[])this.Objects)[0];
SceneNode target;
if (property.Reference.Count == 1 || this.IsTextRange)
{
target = sceneNode;
}
else
{
using (SceneEditTransaction editTransaction = sceneNode.ViewModel.CreateEditTransaction("Build local value tree", true))
{
sceneNode.EnsureNodeTree(property.Reference, true, true);
editTransaction.Commit();
}
PropertyReference propertyReference = property.Reference.Subreference(0, property.Reference.Count - 2);
target = sceneNode.GetLocalValueAsSceneNode(propertyReference);
}
ReferenceStep lastStep = property.Reference.LastStep;
return(DataBindingDialog.CreateAndSetBindingOrData(this.designerContext, target, lastStep));
}
public static SceneNode CreateClrObjectDataSource(out string dataSourceName, out Type dataSourceType, DataPanelModel model)
{
SceneNode sceneNode = (SceneNode)null;
dataSourceName = (string)null;
dataSourceType = (Type)null;
ClrObjectDataSourceDialog dataSourceDialog = new ClrObjectDataSourceDialog(model);
bool?nullable = dataSourceDialog.ShowDialog();
if ((!nullable.GetValueOrDefault() ? 0 : (nullable.HasValue ? true : false)) != 0)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.AddClrDataSource);
dataSourceType = dataSourceDialog.ObjectType;
dataSourceName = dataSourceDialog.DataSourceName;
if (dataSourceDialog.ObjectType != (Type)null)
{
dataSourceName = dataSourceName.Trim();
SceneViewModel activeSceneViewModel = model.DesignerContext.ActiveSceneViewModel;
DocumentNode node = (DocumentNode)activeSceneViewModel.Document.DocumentContext.CreateNode(dataSourceDialog.ObjectType);
sceneNode = activeSceneViewModel.GetSceneNode(node);
}
}
return(sceneNode);
}
private void InitializeActiveCompletionSession()
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.XamlIntellisenseCreateMenu);
this.activeSessionStartPoint = this.textView.TextBuffer.CurrentSnapshot.CreateTrackingPoint(this.textView.Caret.Position.Index, PointTrackingMode.Negative);
this.activeSession.Committed += new EventHandler(this.ActiveSession_Committed);
this.activeSession.Dismissed += new EventHandler(this.ActiveSession_Dismissed);
this.activeSession.Presenter.ReleaseKeyboard();
if (this.activeSession.Completions.Count == 1)
{
CompletionSelectionOptions selectionOptions = CompletionSelectionOptions.Unique;
if (this.activeSession.Completions[0].ApplicableTo.GetSpan(this.textView.TextBuffer.CurrentSnapshot).Length == 0)
{
this.activeSession.SetSelectionStatus(this.activeSession.Completions[0], selectionOptions | CompletionSelectionOptions.Selected);
}
else
{
this.CompletionSessionMatchTrackingWorker();
}
}
else
{
this.CompletionSessionMatchTrackingWorker();
}
}
private void SetActiveItem(DocumentService.Item item)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.SwitchView);
this.SetActiveDocumentAndView(item == null || item.Views.Count <= 0 ? (IView)null : item.Views[0], item);
}
protected override void OnSubmenuOpened(RoutedEventArgs e)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.OpenCommandBarMenu);
this.UpdateState();
}
private void BindingSourcesView_CurrentChanging(object sender, CurrentChangingEventArgs e)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.SwitchDataSourceType);
}
private void ModifyTextValue(IViewTextRange textRange, PropertyReference propertyReference, int index, object value, SceneNode.Modification modification)
{
if (value is Microsoft.Expression.DesignModel.DocumentModel.DocumentNode || value is MarkupExtension)
{
return;
}
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.TextSetProperty);
value = RichTextBoxRangeElement.GetUpdatedComplexProperty(textRange, propertyReference, index, value, modification);
ReferenceStep firstStep = propertyReference.FirstStep;
IProperty property = textRange.Platform.Metadata.ResolveProperty((IPropertyId)firstStep);
if (property != null)
{
if (modification == SceneNode.Modification.ClearValue)
{
value = this.ViewModel.DefaultView.ConvertToWpfValue(this.ViewModel.DefaultView.ConvertFromWpfPropertyReference(propertyReference).LastStep.GetDefaultValue(typeof(object)));
}
if (property.Equals((object)RichTextBoxRangeElement.TextIndentPropertyId) && (double)value < 0.0)
{
value = (object)0.0;
}
textRange.ApplyPropertyValue((IPropertyId)property, value);
bool flag = RichTextBoxElement.IsParagraphProperty(propertyReference);
PropertyReference propertyReference1 = DesignTimeProperties.GetShadowPropertyReference(propertyReference, (ITypeId)this.Type);
if (propertyReference1 != null && !DesignTimeProperties.UseShadowPropertyForInstanceBuilding(this.ViewModel.Document.DocumentContext.TypeResolver, (IPropertyId)propertyReference1.FirstStep))
{
propertyReference1 = (PropertyReference)null;
}
if (modification == SceneNode.Modification.ClearValue && propertyReference1 == null)
{
propertyReference1 = propertyReference;
}
if (propertyReference1 != null)
{
IViewTextElement viewTextElement1 = (IViewTextElement)null;
if (textRange.Start.CompareTo(textRange.End) != 0 || textRange.Start.CompareTo(((IViewTextElement)textRange.Start.Parent).ContentStart) != 0 && textRange.Start.CompareTo(((IViewTextElement)textRange.Start.Parent).ContentEnd) != 0)
{
for (IViewTextPointer viewTextPointer = textRange.Start; viewTextPointer != null && viewTextPointer.CompareTo(textRange.End) <= 0; viewTextPointer = viewTextPointer.GetNextInsertionPosition(LogicalDirection.Forward))
{
IViewTextElement viewTextElement2 = viewTextPointer.Parent as IViewTextElement;
if (viewTextElement2 != null && (viewTextElement1 == null || viewTextElement1.PlatformSpecificObject != viewTextElement2.PlatformSpecificObject))
{
viewTextElement1 = viewTextElement2;
if (viewTextElement1 != null && (flag && viewTextElement1 is Paragraph || !flag && viewTextElement1 is Run))
{
if (modification == SceneNode.Modification.ClearValue)
{
propertyReference1.ClearValue((object)viewTextElement1);
}
else
{
propertyReference1.SetValue((object)viewTextElement1, value);
}
}
}
}
}
}
}
if (property.Equals((object)RichTextBoxRangeElement.ForegroundProperty) || property.Equals((object)RichTextBoxRangeElement.TextElementForegroundProperty))
{
TextBlockEditProxy textBlockEditProxy = this.TextEditProxy as TextBlockEditProxy;
if (textBlockEditProxy != null)
{
textBlockEditProxy.UpdateCaretBrush();
}
}
if (this.TextEditProxy == null)
{
return;
}
this.TextEditProxy.Serialize();
this.TextEditProxy.UpdateDocumentModel();
}
public virtual SceneNode CreateInstance(ITypeId instanceType, ISceneInsertionPoint insertionPoint, Rect rect, OnCreateInstanceAction action)
{
PerformanceUtility.StartPerformanceSequence(PerformanceEvent.PropertyInspectorFromCreate);
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.CreateElement);
SceneView sceneView = this.sceneView;
if (sceneView == null || !sceneView.IsEditable || insertionPoint == null)
{
return((SceneNode)null);
}
SceneNode rawInstance = this.CreateRawInstance(instanceType);
if (rawInstance == null || !insertionPoint.CanInsert((ITypeId)rawInstance.Type))
{
return((SceneNode)null);
}
if (rect.IsEmpty)
{
rect = new Rect(0.0, 0.0, double.NaN, double.NaN);
}
if (double.IsInfinity(rect.Width))
{
rect.Width = double.NaN;
}
if (double.IsInfinity(rect.Height))
{
rect.Height = double.NaN;
}
using (this.ViewModel.ForceBaseValue())
{
using (SceneEditTransaction editTransaction = this.ViewModel.CreateEditTransaction(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.UndoUnitCreateControlFormat, new object[1]
{
(object)instanceType.Name
})))
{
IExpandable expandable = insertionPoint.SceneElement as IExpandable;
if (expandable != null)
{
insertionPoint.SceneNode.SetValue(expandable.ExpansionProperty, (object)true);
}
bool flag = this.ShouldUseDefaultInitializer && Enumerable.Any <FeatureProvider>(DefaultTypeInstantiator.GetDefaultInitializers(rawInstance));
IList <SceneNode> nodes = (IList <SceneNode>)null;
if (!flag)
{
nodes = this.CreateNodeTreeOnInsertion(rawInstance);
this.ApplyBeforeInsertionDefaultsToElements(nodes, rawInstance, new DefaultTypeInstantiator.SceneElementNamingCallback(DefaultTypeInstantiator.TypeNameCallback));
}
SceneNode layoutTarget = DefaultTypeInstantiator.GetLayoutTarget(rawInstance);
SceneElement selectionTarget = DefaultTypeInstantiator.GetSelectionTarget(rawInstance);
this.ViewModel.ElementSelectionSet.Clear();
insertionPoint.Insert(rawInstance);
editTransaction.Update();
this.ApplyDefaultInitializers(rawInstance);
if (action != null)
{
action(rawInstance);
editTransaction.Update();
}
if (!flag)
{
this.ApplyAfterInsertionDefaultsToElements(nodes, rawInstance);
}
SceneElement sceneElement1 = layoutTarget as SceneElement;
EffectNode effectNode = layoutTarget as EffectNode;
if (sceneElement1 != null && sceneElement1.IsViewObjectValid)
{
if (selectionTarget != null)
{
this.ViewModel.ElementSelectionSet.SetSelection(selectionTarget);
}
this.SetLayout(insertionPoint, rect, rawInstance, layoutTarget, editTransaction);
}
else if (effectNode != null)
{
this.ViewModel.ChildPropertySelectionSet.SetSelection((SceneNode)effectNode);
}
else
{
for (SceneNode sceneNode = layoutTarget; sceneNode != null; sceneNode = sceneNode.Parent)
{
SceneElement sceneElement2 = sceneNode as SceneElement;
if (sceneElement2 != null && sceneElement2.Visual != null && sceneElement2.Visual is IViewVisual)
{
this.sceneView.EnsureVisible(sceneElement2.Visual);
break;
}
}
}
if (this.ViewModel.DesignerContext.AmbientPropertyManager != null)
{
this.ViewModel.DesignerContext.AmbientPropertyManager.ApplyAmbientProperties(rawInstance);
}
editTransaction.Commit();
}
}
return(rawInstance);
}
