public static SceneElement ChooseElementForBehavior(SceneElement root, ITypeId constraintType)
{
PathTargetDialog pathTargetDialog = new PathTargetDialog(root, (SceneElement)null, StringTable.SelectElementDialogTitle, StringTable.SelectElementDialogInfoText, new PathTargetDialog.PathTargetValidator(PathTargetDialog.ValidateBehaviorTargets), constraintType);
bool? nullable = pathTargetDialog.ShowDialog();
if ((!nullable.GetValueOrDefault() ? 0 : (nullable.HasValue ? true : false)) != 0 && pathTargetDialog.model.SelectedElement != null)
{
return(pathTargetDialog.model.SelectedElement.Element);
}
return((SceneElement)null);
}
protected virtual double GetNativeHeight(SceneElement element)
{
double val2 = double.PositiveInfinity;
Base2DElement context = element.Parent as Base2DElement;
if (context != null && context.IsViewObjectValid)
{
val2 = context.GetComputedBounds(context).Height;
}
return(Math.Min(100.0, val2));
}
private BaseFrameworkElement GetEditableTextElementAtPoint(Point point)
{
SceneElement elementAtPoint = this.ActiveView.GetElementAtPoint(point, new HitTestModifier(this.GetContainingTextElement), new InvisibleObjectHitTestModifier(SceneView.SmartInvisiblePanelSelect), (ICollection <BaseFrameworkElement>)null);
BaseFrameworkElement frameworkElement = (BaseFrameworkElement)null;
if (elementAtPoint != null && TextEditProxyFactory.IsEditableElement(elementAtPoint) && !elementAtPoint.IsLocked)
{
frameworkElement = elementAtPoint as BaseFrameworkElement;
}
return(frameworkElement);
}
public static SceneElement ChooseElement(SceneElement root, SceneElement path)
{
PathTargetDialog pathTargetDialog = new PathTargetDialog(root, path, StringTable.SelectElementDialogTitle, StringTable.SelectElementDialogInfoText, new PathTargetDialog.PathTargetValidator(PathTargetDialog.AllowAllTargets), (ITypeId)null);
bool? nullable = pathTargetDialog.ShowDialog();
if ((!nullable.GetValueOrDefault() ? 0 : (nullable.HasValue ? true : false)) != 0 && pathTargetDialog.model.SelectedElement != null)
{
return(pathTargetDialog.model.SelectedElement.Element);
}
return((SceneElement)null);
}
private static void SetAutoLayoutRounding(SceneElement element, bool auto)
{
if (auto)
{
element.SetValue(DesignTimeProperties.LayoutRoundingProperty, (object)LayoutRoundingHelper.AutoLayoutRoundingValue);
}
else
{
element.ClearValue(DesignTimeProperties.LayoutRoundingProperty);
}
}
public void Attach(ToolBehaviorContext toolContext, SceneElement containerElement)
{
this.CheckAttached(false);
this.toolContext = toolContext;
this.snapLineAdornerSet = new SnapLineAdornerSet(this.toolContext, containerElement);
if (this.toolContext.View == null)
{
return;
}
this.toolContext.View.AdornerLayer.Add((IAdornerSet)this.snapLineAdornerSet);
}
public static string RenderElement(SceneElement element)
{
SceneWriter output = new SceneWriter();
OutputAttribute outputAttr = OutputAttribute.Combine(element.GetAllAttributes <OutputAttribute>());
ElementContext sceneContext =
new ElementContext(new ElementContext(null, new Scene()), element, outputAttr);
sceneContext.LoadChildren(true);
sceneContext.Write(output);
return(output.ToString());
}
/// <summary>
/// Pushes the effect onto the specified parent element.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="parentElement">The parent element.</param>
public override void Push(OpenGL gl, SceneElement parentElement)
{
// Create a combined mask.
AttributeMask attributeFlags = AttributeMask.None;
// accum buffer attribute already added to CSharpGL.
attributeFlags |= accumBufferAttributes.AreAnyAttributesSet() ? accumBufferAttributes.AttributeFlags : AttributeMask.None;
// accum buffer attribute already added to CSharpGL except one.
attributeFlags |= colorBufferAttributes.AreAnyAttributesSet() ? colorBufferAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= currentAttributes.AreAnyAttributesSet() ? currentAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= depthBufferAttributes.AreAnyAttributesSet() ? depthBufferAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= enableAttributes.AreAnyAttributesSet() ? enableAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= fogAttributes.AreAnyAttributesSet() ? fogAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= lightingAttributes.AreAnyAttributesSet() ? lightingAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= lineAttributes.AreAnyAttributesSet() ? lineAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= pointAttributes.AreAnyAttributesSet() ? pointAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= polygonAttributes.AreAnyAttributesSet() ? polygonAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= evalAttributes.AreAnyAttributesSet() ? evalAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= hintAttributes.AreAnyAttributesSet() ? hintAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= listAttributes.AreAnyAttributesSet() ? listAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= pixelModeAttributes.AreAnyAttributesSet() ? pixelModeAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= polygonStippleAttributes.AreAnyAttributesSet() ? polygonStippleAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= scissorAttributes.AreAnyAttributesSet() ? scissorAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= stencilBufferAttributes.AreAnyAttributesSet() ? stencilBufferAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= textureAttributes.AreAnyAttributesSet() ? textureAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= transformAttributes.AreAnyAttributesSet() ? transformAttributes.AttributeFlags : AttributeMask.None;
attributeFlags |= viewportAttributes.AreAnyAttributesSet() ? viewportAttributes.AttributeFlags : AttributeMask.None;
// Push the attribute stack.
gl.PushAttrib((uint)attributeFlags);
// Set the attributes.
accumBufferAttributes.SetAttributes(gl);
colorBufferAttributes.SetAttributes(gl);
currentAttributes.SetAttributes(gl);
depthBufferAttributes.SetAttributes(gl);
enableAttributes.SetAttributes(gl);
fogAttributes.SetAttributes(gl);
lightingAttributes.SetAttributes(gl);
lineAttributes.SetAttributes(gl);
pointAttributes.SetAttributes(gl);
polygonAttributes.SetAttributes(gl);
evalAttributes.SetAttributes(gl);
hintAttributes.SetAttributes(gl);
listAttributes.SetAttributes(gl);
pixelModeAttributes.SetAttributes(gl);
polygonStippleAttributes.SetAttributes(gl);
scissorAttributes.SetAttributes(gl);
stencilBufferAttributes.SetAttributes(gl);
textureAttributes.SetAttributes(gl);
transformAttributes.SetAttributes(gl);
viewportAttributes.SetAttributes(gl);
}
public virtual ISceneInsertionPoint Create(object data)
{
if (this.Context != null && this.Item != null)
{
SceneElement dropTargetInfo = this.GetDropTargetInfo(this.Context.AllowedEffects, this.Context.Descriptor);
if (dropTargetInfo != null)
{
return(dropTargetInfo.InsertionPointForProperty(this.GetContentPropertyFromDragDescriptor(this.Context.Descriptor)));
}
}
return((ISceneInsertionPoint)null);
}
private static bool ValidateBehaviorTargets(bool isRoot, SceneElement target, SceneElement path, ITypeId constraintType)
{
if (isRoot || !target.CanNameElement)
{
return(false);
}
if (constraintType != null)
{
return(constraintType.IsAssignableFrom((ITypeId)target.Type));
}
return(true);
}
private static bool ShouldConsiderLayoutRoundingAdjustment(SceneElement element)
{
if (element == null)
{
return(false);
}
if (element.ViewModel.AnimationEditor.IsRecording && !element.ViewModel.IsForcingBaseValue)
{
return(element.ViewModel.AnimationEditor.CanAnimateLayout);
}
return(true);
}
internal static int GetMaxChildrenForElement(SceneElement element, IProperty property = null)
{
if (property == null)
{
property = element.DefaultContentProperty;
}
if (!element.IsContainer && property == element.DefaultContentProperty)
{
return(0);
}
return(element.GetCollectionForProperty((IPropertyId)property).FixedCapacity ?? int.MaxValue);
}
protected BaseFrameworkElement GetHitElement(Point point, IList <BaseFrameworkElement> ignoredElements)
{
SceneElement elementAtPoint = this.ActiveView.GetElementAtPoint(point, new HitTestModifier(this.GetUnlockedAncestorInEditingContainer), (InvisibleObjectHitTestModifier)null, (ICollection <BaseFrameworkElement>)ignoredElements);
BaseFrameworkElement frameworkElement = elementAtPoint as BaseFrameworkElement;
Base3DElement base3Delement = elementAtPoint as Base3DElement;
if (base3Delement != null)
{
frameworkElement = (BaseFrameworkElement)base3Delement.Viewport;
}
return(frameworkElement);
}
private Vector SnapRect(Rect rectSnap, SceneElement container, Vector offset, EdgeFlags edgeFlags)
{
if (this.SnappingEngine == null)
{
return(new Vector(0.0, 0.0));
}
if (!this.SnappingEngine.IsStarted)
{
this.StartSnappingEngine();
}
return(this.SnappingEngine.SnapRect(rectSnap, container, offset, edgeFlags));
}
public void Update(AdornerElementSet adornerElementSet, AdornerLayer adornerLayer, AdornerLayer.ElementInfoUpdateSource source)
{
SceneElement primaryElement = adornerElementSet.PrimaryElement;
bool flag = false;
if (!adornerLayer.SceneView.IsInArtboard(primaryElement))
{
return;
}
Size size2 = primaryElement.Visual != null?adornerLayer.SceneView.GetRenderSize(primaryElement.Visual) : Size.Empty;
Transform transform = (Transform) new MatrixTransform(adornerElementSet.CalculatePrimaryElementTransformMatrixToAdornerLayer());
Matrix matrix = transform == null ? Matrix.Identity : transform.Value;
Point renderTransformOrigin = adornerElementSet.RenderTransformOrigin;
if (!AdornerLayer.ElementInfo.AreClose(renderTransformOrigin, this.sharedCenter) || !AdornerLayer.ElementInfo.AreClose(this.lastRenderSize, size2) || (this.primaryElementMatrix != matrix || adornerElementSet.IsPrimaryTransformNonAffine))
{
flag = true;
this.sharedCenter = renderTransformOrigin;
this.lastRenderSize = size2;
this.primaryElementMatrix = matrix;
}
ISceneInsertionPoint sceneInsertionPoint = adornerElementSet.PrimaryElement.ViewModel.ActiveSceneInsertionPoint;
if (flag || source == AdornerLayer.ElementInfoUpdateSource.LayoutUpdated && adornerElementSet.NeedsUpdate)
{
adornerElementSet.Update();
this.matrix = adornerElementSet.GetTransformMatrixToAdornerLayer();
foreach (AdornerSet adornerSet in this.adornerSets)
{
this.UpdateMatrix(adornerSet, adornerLayer);
}
if (this.adornerSet3DContainer != null)
{
this.adornerSet3DContainer.SetMatrix(this.matrix);
}
if (sceneInsertionPoint != null && primaryElement.ParentElement is GridElement && (primaryElement.ParentElement == sceneInsertionPoint.SceneElement && primaryElement.ViewModel.IsInGridDesignMode))
{
adornerLayer.InvalidateAdornerVisuals(primaryElement.ParentElement);
}
}
if (!(primaryElement is Base3DElement) || sceneInsertionPoint == null)
{
return;
}
Base3DElement base3Delement = sceneInsertionPoint.SceneElement as Base3DElement;
if (base3Delement == null)
{
return;
}
adornerLayer.InvalidateAdornerVisuals((SceneElement)base3Delement);
}
/// <summary>
/// Get picked primitive by <paramref name="stageVertexID"/> as the last vertex that constructs the primitive.
/// </summary>
/// <param name="stageVertexID">The last vertex that constructs the primitive.</param>
/// <returns></returns>
public IPickedGeometry Pick(uint stageVertexID)
{
if (stageVertexID < 0)
{
return(null);
}
SceneElement element = this.SceneContainer;
IPickedGeometry pickedGeometry = Pick(element, stageVertexID);
return(pickedGeometry);
}
private string GetCandidateName(SceneElement element)
{
if (element == null)
{
return(string.Empty);
}
SceneNode root = element.StoryboardContainer as SceneNode ?? this.view.ViewModel.RootNode;
SceneNodeIDHelper sceneNodeIdHelper = new SceneNodeIDHelper(element.ViewModel, root);
string namePrefix = SceneNodeIDHelper.DefaultNamePrefixForType((ITypeId)element.Type);
return(sceneNodeIdHelper.GetValidElementID((SceneNode)element, namePrefix));
}
/// <summary>
/// Pops the specified parent element.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="parentElement">The parent element.</param>
public override void Pop(OpenGL gl, SceneElement parentElement)
{
LookAtCamera camera = parentElement.TraverseToRootElement().ParentScene.CurrentCamera as LookAtCamera;
if (camera != null)
{
gl.Viewport(0, 0, result[2], result[3]);
}
// Pop the stack.
gl.PopMatrix();
}
private static SceneElement ChangeLayoutType(SceneElement sourceElement, ITypeId layoutType, ref SceneElement elementContainingChildren)
{
IDocumentRoot documentRoot = sourceElement.DocumentNode.DocumentRoot;
IDocumentContext documentContext = documentRoot.DocumentContext;
SceneViewModel viewModel = sourceElement.ViewModel;
Size size = Size.Empty;
BaseFrameworkElement frameworkElement = sourceElement as BaseFrameworkElement;
if (frameworkElement != null)
{
size = frameworkElement.GetComputedTightBounds().Size;
}
using (viewModel.ForceBaseValue())
{
SceneElement sceneElement = (SceneElement)viewModel.CreateSceneNode(layoutType);
using (viewModel.DisableUpdateChildrenOnAddAndRemove())
{
using (viewModel.DisableDrawIntoState())
{
viewModel.AnimationEditor.DeleteAllAnimations((SceneNode)sourceElement);
Dictionary <IPropertyId, SceneNode> properties = SceneElementHelper.StoreProperties((SceneNode)sourceElement);
Dictionary <IPropertyId, List <SceneNode> > storedChildren = ChangeLayoutTypeCommand.StoreChildren(sourceElement);
if (sourceElement.DocumentNode == documentRoot.RootNode)
{
documentRoot.RootNode = sceneElement.DocumentNode;
sceneElement.DocumentNode.NameScope = new DocumentNodeNameScope();
}
else
{
ISceneNodeCollection <SceneNode> collectionContainer = sourceElement.GetCollectionContainer();
int index = collectionContainer.IndexOf((SceneNode)sourceElement);
sourceElement.Remove();
collectionContainer.Insert(index, (SceneNode)sceneElement);
}
SceneElementHelper.ApplyProperties((SceneNode)sceneElement, properties);
elementContainingChildren = ChangeLayoutTypeCommand.ApplyChildren(sceneElement, storedChildren, size);
}
}
if (sceneElement is GridElement || sceneElement is CanvasElement)
{
ILayoutDesigner designerForChild = sceneElement.ViewModel.GetLayoutDesignerForChild(sceneElement, true);
if ((designerForChild.GetWidthConstraintMode((BaseFrameworkElement)sceneElement) & LayoutConstraintMode.CanvasLike) != LayoutConstraintMode.NonOverlappingGridlike)
{
sceneElement.SetValue(BaseFrameworkElement.WidthProperty, (object)size.Width);
}
if ((designerForChild.GetHeightConstraintMode((BaseFrameworkElement)sceneElement) & LayoutConstraintMode.CanvasLike) != LayoutConstraintMode.NonOverlappingGridlike)
{
sceneElement.SetValue(BaseFrameworkElement.HeightProperty, (object)size.Height);
}
}
return(sceneElement);
}
}
private AnnotationEditor.ReferenceInfo References_InsertedHandler(object sender, SceneNode basisNode, object basisContent, SceneNode newPathNode)
{
SceneElement sceneElement = (SceneElement)newPathNode.Parent;
IEnumerable <string> enumerable = AnnotationUtils.ParseAnnotationReferences(((DocumentPrimitiveNode)newPathNode.DocumentNode).GetValue <string>());
return(new AnnotationEditor.ReferenceInfo()
{
ReferenceOwner = sceneElement,
ReferencedAnnotationIds = Enumerable.ToList <string>(enumerable),
ReferencedAnnotations = this.ComputeReferencedAnnotations(enumerable)
});
}
public static double GetStrokeWidth(SceneElement element)
{
if (element.GetComputedValue(ShapeElement.StrokeProperty) != null)
{
double d = (double)element.GetComputedValue(ShapeElement.StrokeThicknessProperty);
if (!double.IsNaN(d) && !double.IsInfinity(d))
{
return(d);
}
}
return(0.0);
}
public virtual Rect GetElementBounds(SceneElement sceneElement)
{
if (sceneElement == null || sceneElement.ViewTargetElement == null)
{
return(Rect.Empty);
}
Rect actualBounds = sceneElement.ViewModel.DefaultView.GetActualBounds(sceneElement.ViewTargetElement);
Matrix computedTransformToRoot = sceneElement.ViewModel.DefaultView.GetComputedTransformToRoot(sceneElement);
actualBounds.Transform(computedTransformToRoot);
return(actualBounds);
}
public override void Execute()
{
using (SceneEditTransaction editTransaction = this.SceneViewModel.CreateEditTransaction(StringTable.UndoUnitCreateGroup))
{
SceneElement selectionToSet = this.GroupElements();
if (selectionToSet != null)
{
this.SceneViewModel.ElementSelectionSet.SetSelection(selectionToSet);
}
editTransaction.Commit();
}
}
private Breadcrumb FindBreadcrumb(SceneElement targetElement)
{
foreach (Breadcrumb breadcrumb in (Collection <Breadcrumb>) this.Trail)
{
DocumentNodePath selectedElementPath = breadcrumb.SelectedElementPath;
if (selectedElementPath != null && selectedElementPath.Equals((object)targetElement.DocumentNodePath))
{
return(breadcrumb);
}
}
return((Breadcrumb)null);
}
private bool DoHitTestOverArtboard(Point artboardPoint)
{
bool flag = false;
if (this.view.Artboard.ArtboardBounds.Contains(artboardPoint))
{
this.topElement = this.view.GetSelectableElementAtPoint(artboardPoint, SelectionFor3D.Deep, false);
if (this.topElement == null)
{
this.topElement = this.view.GetElementAtPoint(artboardPoint, new HitTestModifier(this.view.GetSelectableElement), (InvisibleObjectHitTestModifier)null, (ICollection <BaseFrameworkElement>)null);
}
if (this.topElement != null)
{
if (this.elementSelectionStrategy.CanSelectElement(this.topElement))
{
this.editor.Cursor = this.cursor;
flag = true;
}
if (this.previewHighlighter.PreviewElement != this.topElement)
{
if (this.topElement.IsNamed)
{
this.feedbackAdorner.Text = this.topElement.Name;
}
else if (flag)
{
this.feedbackAdorner.Text = string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.NamingNotification, new object[2]
{
(object)this.topElement.DisplayNameNoTextContent,
(object)this.GetCandidateName(this.topElement)
});
}
else
{
this.feedbackAdorner.Text = this.topElement.DisplayNameNoTextContent;
}
this.feedbackAdorner.DrawAdorner();
this.previewHighlighter.PreviewElement = this.topElement;
}
}
else
{
this.feedbackAdorner.CloseAdorner();
this.previewHighlighter.PreviewElement = (SceneElement)null;
}
}
else
{
this.previewHighlighter.PreviewElement = (SceneElement)null;
}
return(flag);
}
private void CreateInstance(Point dropPoint, ResourceEntryItem resource, IType type)
{
ISceneInsertionPoint pointFromPosition = this.ActiveSceneViewModel.GetActiveSceneInsertionPointFromPosition(new InsertionPointContext(dropPoint));
TypeAsset typeAsset = new TypeAsset(type);
if (!typeAsset.CanCreateInstance(pointFromPosition))
{
return;
}
this.ToolBehaviorContext.SnappingEngine.Start(this.ToolBehaviorContext, (BaseFrameworkElement)null, (IList <BaseFrameworkElement>)null);
dropPoint = this.ToolBehaviorContext.SnappingEngine.SnapPoint(dropPoint, EdgeFlags.All);
this.ToolBehaviorContext.SnappingEngine.Stop();
Matrix inverseMatrix = ElementUtilities.GetInverseMatrix(this.ActiveView.GetComputedTransformToRoot(pointFromPosition.SceneElement));
dropPoint *= inverseMatrix;
using (SceneEditTransaction editTransaction = this.ActiveDocument.CreateEditTransaction(StringTable.CreateResourceViaToolUndoUnit))
{
using (this.ActiveSceneViewModel.DesignerContext.AmbientPropertyManager.SuppressApplyAmbientProperties())
{
typeAsset.CreateInstance(this.ActiveSceneViewModel.DesignerContext.LicenseManager, pointFromPosition, new Rect(dropPoint, new Size(double.PositiveInfinity, double.PositiveInfinity)), (OnCreateInstanceAction)(sceneNode =>
{
SceneElement targetElement = sceneNode as SceneElement;
if (targetElement == null)
{
return;
}
if (resource is StyleResourceItem)
{
this.ApplyResourceOnExistingElement(targetElement, BaseFrameworkElement.StyleProperty, resource);
}
else if (resource is ControlTemplateResourceItem)
{
this.ApplyResourceOnExistingElement(targetElement, ControlElement.TemplateProperty, resource);
}
else if (resource is DrawingImageResourceItem)
{
this.ApplyResourceOnExistingElement(targetElement, ImageElement.SourceProperty, resource);
}
else
{
if (!(resource is BrushResourceItem))
{
return;
}
this.ApplyResourceOnExistingElement(targetElement, ShapeElement.FillProperty, resource);
targetElement.SetValue(ShapeElement.StrokeProperty, (object)null);
}
}));
editTransaction.Commit();
}
}
}
internal AnnotationSceneNode CreateAnnotation(IEnumerable <SceneElement> targets)
{
Artboard artboard = this.sceneViewModel.DefaultView.Artboard;
SceneElement sceneElement = Enumerable.First <SceneElement>(targets);
int num = Enumerable.Count <SceneElement>(targets);
bool treatTopLeftAsCenter = num > 1 || sceneElement.Equals((object)sceneElement.ViewModel.RootNode);
AnnotationSceneNode annotation;
using (SceneEditTransaction editTransaction = sceneElement.ViewModel.CreateEditTransaction(StringTable.AddAnnotationUndoUnit))
{
annotation = AnnotationManagerSceneNode.CreateAnnotation((SceneNode)sceneElement);
foreach (SceneElement element in Enumerable.Skip <SceneElement>(targets, 1))
{
AnnotationUtils.AddAnnotationReference(element, annotation);
}
Point point1;
if (treatTopLeftAsCenter)
{
Rect rect = Rect.Empty;
if (num > 1 || !sceneElement.Equals((object)annotation.ViewModel.RootNode))
{
rect = artboard.GetElementListBounds(targets);
}
if (rect.IsEmpty)
{
rect = artboard.ArtboardBounds;
}
point1 = new Point(rect.Left + rect.Width / 2.0, rect.Top + rect.Height / 2.0);
}
else
{
point1 = artboard.GetElementBounds(sceneElement).TopRight;
}
Point point2 = RoundingHelper.RoundPosition(point1);
annotation.Left = point2.X;
annotation.Top = point2.Y;
string authorName = this.AnnotationService.DesignerContext.AnnotationsOptionsModel.AuthorName;
if (!string.IsNullOrEmpty(authorName))
{
annotation.Author = authorName;
}
string authorInitials = this.AnnotationService.DesignerContext.AnnotationsOptionsModel.AuthorInitials;
if (!string.IsNullOrEmpty(authorInitials))
{
annotation.AuthorInitials = authorInitials;
}
AnnotationUtils.SetSerialNumber(annotation);
editTransaction.Commit();
}
this.CreateAnnotationVisual(annotation).Initialize(treatTopLeftAsCenter);
return(annotation);
}
protected override void RefreshInstance(SceneElement element, SceneDocument sceneDocument, string url)
{
ImageElement imageElement = element as ImageElement;
if (imageElement == null)
{
return;
}
string uri = imageElement.Uri;
imageElement.Uri = (string)null;
imageElement.Uri = uri;
}
private void ClearLayoutProperties(IEnumerable <IPropertyId> properties, SceneElement element)
{
DocumentCompositeNode documentCompositeNode = element.DocumentNode as DocumentCompositeNode;
foreach (IPropertyId propertyId in properties)
{
IProperty property = element.ViewModel.ProjectContext.ResolveProperty(propertyId);
if (property != null)
{
documentCompositeNode.ClearValue((IPropertyId)property);
}
}
}
public bool CanSelectElement(SceneElement element)
{
if (element == null)
{
return(false);
}
if (this.lastElement != element)
{
this.lastElement = element;
this.lastCanSelectResult = element.CanNameElement && MiniSourceBindingDialogModel.AnyBindableProperties((SceneNode)element, this.targetProperty.PropertyType);
}
return(this.lastCanSelectResult);
}
/// <summary>
/// Pushes the effect onto the specified parent element.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="parentElement">The parent element.</param>
public override void Push(OpenGL gl, SceneElement parentElement)
{
// Use this shader object.
gl.UseProgram(ProgramObject);
}
private void sceneControl1_MouseClick(object sender, MouseEventArgs e)
{
// Do a hit test.
SelectedSceneElement = null;
listBox1.Items.Clear();
var itemsHit = sceneControl1.Scene.DoHitTest(e.X, e.Y);
foreach (var item in itemsHit)
listBox1.Items.Add(item);
if (listBox1.Items.Count >0)
{
listBox1.SetSelected(0, true);
// listBox1_SelectedIndexChanged(this, null);
}
}
/// <summary>
/// Handles the AfterSelect event of the treeView1 control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.Forms.TreeViewEventArgs"/> instance containing the event data.</param>
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
SelectedSceneElement = e.Node.Tag as SceneElement;
}
/// <summary>
/// Adds the element to tree.
/// </summary>
/// <param name="sceneElement">The scene element.</param>
/// <param name="nodes">The nodes.</param>
private void AddElementToTree(SceneElement sceneElement, TreeNodeCollection nodes)
{
// Add the element.
TreeNode newNode = new TreeNode()
{
Text = sceneElement.Name,
Tag = sceneElement
};
nodes.Add(newNode);
// Add each child.
foreach (var element in sceneElement.Children)
AddElementToTree(element, newNode.Nodes);
}
/// <summary>
/// Renders the element.
/// </summary>
/// <param name="gl">The gl.</param>
/// <param name="renderMode">The render mode.</param>
public void RenderElement(SceneElement sceneElement, RenderMode renderMode)
{
// If the element is disabled, we're done.
if (sceneElement.IsEnabled == false)
return;
// Push each effect.
foreach (var effect in sceneElement.Effects)
if(effect.IsEnabled)
effect.Push(gl, sceneElement);
// If the element can be bound, bind it.
if (sceneElement is IBindable)
((IBindable)sceneElement).Bind(gl);
// If the element has an object space, transform into it.
if (sceneElement is IHasObjectSpace)
((IHasObjectSpace)sceneElement).PushObjectSpace(gl);
// If the element has a material, push it.
if (sceneElement is IHasMaterial && ((IHasMaterial)sceneElement).Material != null)
((IHasMaterial)sceneElement).Material.Push(gl);
// If the element can be rendered, render it.
if (sceneElement is IRenderable)
((IRenderable)sceneElement).Render(gl, renderMode);
// If the element has a material, pop it.
if (sceneElement is IHasMaterial && ((IHasMaterial)sceneElement).Material != null)
((IHasMaterial)sceneElement).Material.Pop(gl);
// IF the element is volume bound and we are rendering volumes, render the volume.
if (RenderBoundingVolumes && sceneElement is IVolumeBound)
((IVolumeBound)sceneElement).BoundingVolume.Render(gl, renderMode);
// Recurse through the children.
foreach (var childElement in sceneElement.Children)
RenderElement(childElement, renderMode);
// If the element has an object space, transform out of it.
if (sceneElement is IHasObjectSpace)
((IHasObjectSpace)sceneElement).PopObjectSpace(gl);
// Pop each effect.
for (int i = sceneElement.Effects.Count - 1; i >= 0; i--)
if(sceneElement.Effects[i].IsEnabled)
sceneElement.Effects[i].Pop(gl, sceneElement);
}
/// <summary>
/// Renders the element for hit test.
/// </summary>
/// <param name="sceneElement">The scene element.</param>
/// <param name="hitMap">The hit map.</param>
/// <param name="currentName">Current hit name.</param>
private void RenderElementForHitTest(SceneElement sceneElement,
Dictionary<uint, SceneElement> hitMap, ref uint currentName)
{
// If the element is disabled, we're done.
// Also, never hit test the current camera.
if (sceneElement.IsEnabled == false || sceneElement == currentCamera)
return;
// Push each effect.
foreach (var effect in sceneElement.Effects)
if (effect.IsEnabled)
effect.Push(gl, sceneElement);
// If the element has an object space, transform into it.
if (sceneElement is IHasObjectSpace)
((IHasObjectSpace)sceneElement).PushObjectSpace(gl);
// If the element is volume bound, render the volume.
if (sceneElement is IVolumeBound)
{
// Load and map the name.
gl.LoadName(currentName);
hitMap[currentName] = sceneElement;
// Render the bounding volume.
((IVolumeBound)sceneElement).BoundingVolume.Render(gl, RenderMode.HitTest);
// Increment the name.
currentName++;
}
// Recurse through the children.
foreach (var childElement in sceneElement.Children)
RenderElementForHitTest(childElement, hitMap, ref currentName);
// If the element has an object space, transform out of it.
if (sceneElement is IHasObjectSpace)
((IHasObjectSpace)sceneElement).PopObjectSpace(gl);
// Pop each effect.
for (int i = sceneElement.Effects.Count - 1; i >= 0; i--)
if (sceneElement.Effects[i].IsEnabled)
sceneElement.Effects[i].Pop(gl, sceneElement);
}
/// <summary>
/// Pops the effect off the specified parent element.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="parentElement">The parent element.</param>
public override void Pop(OpenGL gl, SceneElement parentElement)
{
// Un-use this shader object.
gl.UseProgram(0);
}
private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{
SelectedSceneElement = listBox1.SelectedItem as SceneElement;
}
