Ejemplo n.º 1
0
Archivo: Editor.cs Proyecto: Joxx0r/ATF
        /// <summary>
        /// Finish MEF intialization for the component by creating DomNode tree for application data.</summary>
        void IInitializable.Initialize()
        {
            m_mainform.Shown += (sender, e) =>
                {
                    // create root node.
                    var rootNode = new DomNode(Schema.gameType.Type, Schema.gameRootElement);
                    rootNode.SetAttribute(Schema.gameType.nameAttribute, "Game");

                    // create Orc game object and add it to rootNode.
                    var orc = CreateOrc();
                    rootNode.GetChildList(Schema.gameType.gameObjectChild).Add(orc);

                    // add a child Orc.
                    var orcChildList = orc.GetChildList(Schema.orcType.orcChild);
                    orcChildList.Add(CreateOrc("Child Orc1"));

                    rootNode.InitializeExtensions();

                    var edContext = rootNode.Cast<GameEditingContext>();
                    edContext.Set(orc);

                    // set active context and select orc object.
                    m_contextRegistry.ActiveContext = rootNode;
                    
                };
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Returns whether two nodes can be connected. "from" and "to" refer to the corresponding
        /// properties in IGraphEdge, not to a dragging operation, for example.</summary>
        /// <param name="fromNode">"From" node</param>
        /// <param name="fromRoute">"From" edge route</param>
        /// <param name="toNode">"To" node</param>
        /// <param name="toRoute">"To" edge route</param>
        /// <returns>Whether the "from" node/route can be connected to the "to" node/route</returns>
        public bool CanConnect(ScriptNode fromNode, ICircuitPin fromRoute, ScriptNode toNode, ICircuitPin toRoute)
        {
            var editableGraphContainer =
                DomNode.Cast <VisualScriptEditingContext>() as IEditableGraphContainer <Element, Wire, ICircuitPin>;

            return(editableGraphContainer.CanConnect(fromNode, fromRoute, toNode, toRoute));
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Performs initialization when the adapter's node is set</summary>
        protected override void OnNodeSet()
        {
            m_document = DomNode.Cast <IDocument>();
            m_document.DirtyChanged += document_DirtyChanged;

            base.OnNodeSet();
        }
Ejemplo n.º 4
0
        private bool IsContained(DomNode element, DomNode container)
        {
            if (container.Is <Circuit>())
            {
                return(true);
            }

            if (m_moveElementBehavior == MoveElementBehavior.MoveConstrainToCursorContainment‎)
            {
                // since container is the drop target, the cursor must be over the container when CanMove() is called
                return(true);
            }
            else if (m_moveElementBehavior == MoveElementBehavior.MoveConstrainToContainerBounds)
            {
                AdaptableControl control = m_viewingContext.Cast <AdaptableControl>();

                var offset = GetRelativeOffset(element.Parent.Cast <ICircuitContainer>(), container.Cast <ICircuitContainer>());

                // get bound in local space
                var elemLocalBound      = GetLocalBound(control, element.Cast <Element>());
                var containerLocalBound = GetLocalBound(control, container.Cast <Element>());

                elemLocalBound.Offset(offset);

                containerLocalBound.Location = new PointF(0, GetTitleHeight(control));
                containerLocalBound.Height  -= GetLabelHeight(control);// exclude bottom label area

                elemLocalBound.Offset(GetSubContentOffset(control));

                return(containerLocalBound.Contains(elemLocalBound));
            }
            return(false);
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Finish MEF intialization for the component by creating DomNode tree for application data.</summary>
        void IInitializable.Initialize()
        {
            m_mainform.Shown += (sender, e) =>
            {
                // create root node.
                var rootNode = new DomNode(GameSchema.gameType.Type, GameSchema.gameRootElement);
                rootNode.SetAttribute(GameSchema.gameType.nameAttribute, "Game");

                // create Orc game object and add it to rootNode.
                var orc = CreateOrc();
                rootNode.GetChildList(GameSchema.gameType.gameObjectChild).Add(orc);

                // add a child Orc.
                var orcChildList = orc.GetChildList(GameSchema.orcType.orcChild);
                orcChildList.Add(CreateOrc("Child Orc1"));

                rootNode.InitializeExtensions();

                var edContext = rootNode.Cast <GameEditingContext>();
                edContext.Set(orc);

                // set active context and select orc object.
                m_contextRegistry.ActiveContext = rootNode;
            };
        }
Ejemplo n.º 6
0
 private void AddNode(DomNode node)
 {
     if (node.Is <Group>())
     {
         node.Cast <Group>().Changed += GroupChanged;
     }
 }
Ejemplo n.º 7
0
        /// <summary>
        /// Disconnects the edge</summary>
        /// <param name="edge">Edge to disconnect</param>
        public void Disconnect(ScriptNodeConnection edge)
        {
            var editableGraphContainer =
                DomNode.Cast <VisualScriptEditingContext>() as IEditableGraphContainer <Element, Wire, ICircuitPin>;

            editableGraphContainer.Disconnect(edge);
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Can a container be resized</summary>
        /// <param name="container">Container to resize</param>
        /// <param name="borderPart">Part of border to resize</param>
        /// <returns>True iff the container border can be resized</returns>
        bool IEditableGraphContainer <ScriptNode, ScriptNodeConnection, ICircuitPin> .CanResize(object container, DiagramBorder borderPart)
        {
            var editableGraphContainer =
                DomNode.Cast <VisualScriptEditingContext>() as IEditableGraphContainer <Element, Wire, ICircuitPin>;

            return(editableGraphContainer.CanResize(container, borderPart));
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Connects the "from" node/route to the "to" node/route by creating an IGraphEdge whose
        /// "from" node is "fromNode", "to" node is "toNode", etc.</summary>
        /// <param name="fromNode">"From" node</param>
        /// <param name="fromRoute">"From" edge route</param>
        /// <param name="toNode">"To" node</param>
        /// <param name="toRoute">"To" edge route</param>
        /// <param name="existingEdge">Existing edge that is being reconnected, or null if new edge</param>
        /// <returns>New edge connecting the "from" node/route to the "to" node/route</returns>
        public ScriptNodeConnection Connect(ScriptNode fromNode, ICircuitPin fromRoute, ScriptNode toNode, ICircuitPin toRoute, ScriptNodeConnection existingEdge)
        {
            var editableGraphContainer =
                DomNode.Cast <VisualScriptEditingContext>() as IEditableGraphContainer <Element, Wire, ICircuitPin>;

            return(editableGraphContainer.Connect(fromNode, fromRoute, toNode, toRoute, existingEdge).Cast <ScriptNodeConnection>());
        }
Ejemplo n.º 10
0
        private void m_gameDocumentRegistry_DocumentRemoved(object sender, ItemRemovedEventArgs <IGameDocument> e)
        {
            IGameDocument document = e.Item;

            document.DirtyChanged -= m_document_DirtyChanged;
            document.UriChanged   -= m_document_UriChanged;

            IGame game = document.Cast <IGame>();

            if (document == m_designView.Context.Cast <IGameDocument>())
            {// master document.
                IGrid        grid       = document.As <IGame>().Grid;
                GridRenderer gridRender = grid.Cast <GridRenderer>();
                gridRender.DeleteVertexBuffer();
                m_designView.Context = null;
                GameEngine.DestroyObject(game.Cast <NativeObjectAdapter>());
                GameEngine.Clear();
            }
            else
            {// sub document.
                DomNode masterNode            = m_gameDocumentRegistry.MasterDocument.As <DomNode>();
                DomNode rooFolderNode         = game.RootGameObjectFolder.Cast <DomNode>();
                NativeGameWorldAdapter gworld = masterNode.Cast <NativeGameWorldAdapter>();
                gworld.Remove(masterNode, rooFolderNode, masterNode.Type.GetChildInfo("gameObjectFolder"));
            }
        }
Ejemplo n.º 11
0
        // an element is eligible to move into another container only it first moves out its current container
        private bool IsSelfContainedOrIntersected(DomNode element, DomNode container)
        {
            // the moving element should first move out of the  parent container next to the common ancestor
            var commonAncestor   = DomNode.GetLowestCommonAncestor(element, container);
            var currentContainer = element.Lineage.First(x => x.Parent == commonAncestor);

            if (element == currentContainer)
            {
                return(false); // no self containing
            }
            var control             = m_viewingContext.Cast <AdaptableControl>();
            var elemLocalBound      = GetLocalBound(control, element.Cast <Element>());
            var containerLocalBound = GetLocalBound(control, currentContainer.Cast <Element>());

            containerLocalBound.Location = new PointF(0, GetTitleHeight(control));
            containerLocalBound.Height  -= GetLabelHeight(control);// exclude bottom label area

            elemLocalBound.Offset(GetSubContentOffset(control));
            bool contained = containerLocalBound.Contains(elemLocalBound);

            containerLocalBound.Height -= GetTitleHeight(control);// no subcontent offset if element is moved out of the current container
            bool intersected = containerLocalBound.IntersectsWith(elemLocalBound);

            return(contained || intersected);
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Resize a container</summary>
        /// <param name="container">Container to resize</param>
        /// <param name="newWidth">New container width</param>
        /// <param name="newHeight">New container height</param>
        void IEditableGraphContainer <ScriptNode, ScriptNodeConnection, ICircuitPin> .Resize(object container, int newWidth, int newHeight)
        {
            var editableGraphContainer =
                DomNode.Cast <VisualScriptEditingContext>() as IEditableGraphContainer <Element, Wire, ICircuitPin>;

            editableGraphContainer.Resize(container, newWidth, newHeight);
        }
Ejemplo n.º 13
0
        private void m_gameDocumentRegistry_DocumentAdded(object sender, ItemInsertedEventArgs <IGameDocument> e)
        {
            IGameDocument document = e.Item;
            IGame         game     = document.Cast <IGame>();

            if (document == m_gameDocumentRegistry.MasterDocument)
            {
                NativeObjectAdapter gameLevel = document.Cast <NativeObjectAdapter>();
                GameEngine.CreateObject(gameLevel);
                GameEngine.SetGameLevel(gameLevel);
                gameLevel.UpdateNativeOjbect();

                //create vertex buffer for grid.
                IGrid        grid       = document.As <IGame>().Grid;
                GridRenderer gridRender = grid.Cast <GridRenderer>();
                gridRender.CreateVertices();

                m_designView.Context = document.Cast <IGameContext>();
            }
            DomNode masterNode    = m_gameDocumentRegistry.MasterDocument.As <DomNode>();
            DomNode rooFolderNode = game.RootGameObjectFolder.Cast <DomNode>();

            NativeGameWorldAdapter gworld = masterNode.Cast <NativeGameWorldAdapter>();

            gworld.Insert(masterNode, rooFolderNode, masterNode.Type.GetChildInfo("gameObjectFolder"), -1);
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Connects the "from" node/route to the "to" node/route by creating an IGraphEdge whose
        /// "from" node is "fromNode", "to" node is "toNode", etc.</summary>
        /// <param name="fromNode">"From" node</param>
        /// <param name="fromRoute">"From" edge route</param>
        /// <param name="toNode">"To" node</param>
        /// <param name="toRoute">"To" edge route</param>
        /// <param name="existingEdge">Existing edge that is being reconnected, or null if new edge</param>
        /// <returns>New edge connecting the "from" node/route to the "to" node/route</returns>
        public Connection Connect(Module fromNode, ICircuitPin fromRoute, Module toNode, ICircuitPin toRoute, Connection existingEdge)
        {
            var editableGraphContainer =
                DomNode.Cast <CircuitEditingContext>() as IEditableGraphContainer <Element, Wire, ICircuitPin>;

            return(editableGraphContainer.Connect(fromNode, fromRoute, toNode, toRoute, existingEdge).Cast <Connection>());
        }
Ejemplo n.º 15
0
        /// <summary>Gets whether the edge can be disconnected</summary>
        /// <param name="edge">Edge to disconnect</param>
        /// <returns>Whether the edge can be disconnected</returns>
        public bool CanDisconnect(Connection edge)
        {
            var editableGraphContainer =
                DomNode.Cast <CircuitEditingContext>() as IEditableGraphContainer <Element, Wire, ICircuitPin>;

            return(editableGraphContainer.CanDisconnect(edge));
        }
Ejemplo n.º 16
0
        /// <summary>
        /// Performs one-time initialization when this adapter's DomNode property is set.
        /// The DomNode property is only ever set once for the lifetime of this adapter.</summary>
        protected override void OnNodeSet()
        {
            base.OnNodeSet();
            var editingContext = DomNode.Cast <EditingContext>();

            editingContext.DirtyChanged += (sender, args) => Dirty = editingContext.Dirty;
        }
Ejemplo n.º 17
0
        /// <summary>
        /// Finish MEF intialization for the component by creating DomNode tree for application data.</summary>
        void IInitializable.Initialize()
        {
            m_mainform.Shown += (sender, e) =>
            {
                // create root node.
                var rootNode = new DomNode(Schema.gameType.Type, Schema.gameRootElement);
                rootNode.SetAttribute(Schema.gameType.nameAttribute, "Game");

                // create Orc game object and add it to rootNode.
                var orc1 = CreateOrc("Orc1");
                rootNode.GetChildList(Schema.gameType.gameObjectChild).Add(orc1);

                // add a child Orc.
                var orcChildList = orc1.GetChildList(Schema.orcType.orcChild);
                orcChildList.Add(CreateOrc("Child Orc1"));


                var orc2 = CreateOrc("Orc2");
                rootNode.GetChildList(Schema.gameType.gameObjectChild).Add(orc2);


                rootNode.InitializeExtensions();


                // set active context and select orc object.
                m_contextRegistry.ActiveContext = rootNode;

                var selectionContext = rootNode.Cast <ISelectionContext>();
                selectionContext.Set(new AdaptablePath <object>(orc1.GetPath()));
            };
        }
Ejemplo n.º 18
0
        /// <summary>
        /// Move the given nodes into the container</summary>
        /// <param name="newParent">New container</param>
        /// <param name="movingObjects">Nodes to move</param>
        void IEditableGraphContainer <ScriptNode, ScriptNodeConnection, ICircuitPin> .Move(object newParent, IEnumerable <object> movingObjects)
        {
            var editableGraphContainer =
                DomNode.Cast <VisualScriptEditingContext>() as IEditableGraphContainer <Element, Wire, ICircuitPin>;

            editableGraphContainer.Move(newParent, movingObjects);
        }
Ejemplo n.º 19
0
 private void RemoveNode(DomNode node)
 {
     if (node.Is <Group>())
     {
         node.Cast <Group>().Changed -= GroupChanged;
     }
 }
        protected override void OnNodeSet()
        {
            base.OnNodeSet();

            // Only adapt to ICurve.
            if (!DomNode.Is <ICurve>())
            {
                throw new InvalidOperationException("This adapter can only attach to instance of type that implements ICurve");
            }

            DomNode.ChildInserting += (sender, e) =>
            {
                var cp = e.Child.As <IControlPoint>();
                if (cp != null)
                {
                    // check curve limit.
                    var curve = DomNode.Cast <ICurve>();
                    if (cp.X < curve.MinX ||
                        cp.X > curve.MaxX ||
                        cp.Y < curve.MinY ||
                        cp.Y > curve.MaxY)
                    {
                        throw new InvalidTransactionException("Cannot add control-point outside curve limits".Localize());
                    }
                }
            };

            DomNode.AttributeChanged += (sender, e) =>
            {
                try
                {
                    // prevent re-entry
                    if (m_validating)
                    {
                        return;
                    }
                    m_validating = true;

                    var pt    = e.DomNode.As <IControlPoint>();
                    var curve = pt == null ? null : pt.Parent;
                    if (curve != null)
                    {
                        // keep x and y within curve limits.
                        if (e.AttributeInfo.Equivalent(UISchema.controlPointType.xAttribute))
                        {
                            pt.X = MathUtil.Clamp((float)e.NewValue, curve.MinX, curve.MaxX);
                        }
                        else if (e.AttributeInfo.Equivalent(UISchema.controlPointType.yAttribute))
                        {
                            pt.Y = MathUtil.Clamp((float)e.NewValue, curve.MinY, curve.MaxY);
                        }
                    }
                }
                finally
                {
                    m_validating = false;
                }
            };
        }
Ejemplo n.º 21
0
        /// <summary>
        /// Performs initialization when the adapter is connected to the viewing context's DomNode.
        /// Raises the Observer NodeSet event and performs custom processing.</summary>
        protected override void OnNodeSet()
        {
            // this adapter is registered on document and root statechart
            m_statechart = DomNode.Cast <Statechart>();
            m_document   = DomNode.Cast <Document>();

            base.OnNodeSet();
        }
Ejemplo n.º 22
0
        /// <summary>
        /// Constructs descriptive name of circuit item. Debugging Helper method.</summary>
        /// <param name="domNode">DomNode of circuit item</param>
        /// <returns>Descriptive name of circuit item</returns>
        static public string GetDomNodeName(DomNode domNode)
        {
            string result = string.Empty;

            if (domNode.Is <Element>())
            {
                result = domNode.Cast <Element>().Name;
            }
            else if (domNode.Is <GroupPin>())
            {
                result = "Group Pin : " + domNode.Cast <GroupPin>().Name;
            }
            else if (domNode.Is <Wire>())
            {
                var connection = domNode.Cast <Wire>();
                int inputPinIndex, outputPinIndex;
                // during undo/redo, the pin index may temporarily out of range, need to check index before call OutputPin|InputPin
                if (connection.IsValid(out inputPinIndex, out outputPinIndex))
                {
                    result = "Edge from " + connection.OutputElement.Name + "[" + connection.OutputPin.Name + "]" +
                             " to " + connection.InputElement.Name + "[" + connection.InputPin.Name + "]";
                }
                else
                {
                    result = "Edge from " + connection.OutputElement.Name + "[" + outputPinIndex + "]" +
                             " to " + connection.InputElement.Name + "[" + inputPinIndex + "]";
                }
            }
            else if (domNode.Is <Circuit>())
            {
                var doc = domNode.As <IDocument>();
                if (doc != null && doc.Uri != null)
                {
                    result = "Circuit " + Path.GetFileNameWithoutExtension(doc.Uri.LocalPath);
                }
                else
                {
                    result = "Circuit " + domNode.GetId();
                }
            }
            if (result == string.Empty)
            {
                result = domNode.GetId() ?? domNode.ToString();
            }
            return(result);
        }
Ejemplo n.º 23
0
        // Scan for all sub-circuits that are referenced directly or indirectly by a module in
        //  the root of the document
        public override void Write(DomNode root, Stream stream, Uri uri)
        {
            m_usedSubCircuits = new HashSet<Sce.Atf.Controls.Adaptable.Graphs.SubCircuit>();

            foreach (var module in root.Cast<Circuit>().Elements)
                FindUsedSubCircuits(module.DomNode);

            base.Write(root, stream, uri);
        }
Ejemplo n.º 24
0
 /// <summary>
 /// Unregisters the Control from the IContextRegistry and IControlHostService and disposes
 /// it and sets the circuitNode's ViewingContext's Control property to null.</summary>
 private void UnregisterControl(DomNode circuitNode, Control control)
 {
     //it's OK if the CircuitEditingContext was already removed or wasn't added to IContextRegistry.
     m_contextRegistry.RemoveContext(circuitNode.As <CircuitEditingContext>());
     m_controlHostService.UnregisterControl(control);
     control.Visible = false;
     control.Dispose();
     m_circuitNodeControls.Remove(circuitNode);
     circuitNode.Cast <ViewingContext>().Control = null;
 }
Ejemplo n.º 25
0
        // Scan for all sub-circuits that are referenced directly or indirectly by a module in
        //  the root of the document
        public override void Write(DomNode root, Stream stream, Uri uri)
        {
            #pragma warning disable 618 //mastered sub-circuits are obsolete
            m_usedSubCircuits = new HashSet<Sce.Atf.Controls.Adaptable.Graphs.SubCircuit>();
            foreach (var module in root.Cast<Circuit>().Elements)
                FindUsedSubCircuits(module.DomNode);
            #pragma warning restore 618

            base.Write(root, stream, uri);
        }
Ejemplo n.º 26
0
        /// <summary>
        /// Gets item's display information</summary>
        /// <param name="item">Item being displayed</param>
        /// <param name="info">Item info, to fill out</param>
        public void GetInfo(object item, ItemInfo info)
        {
            DomNode node = item as DomNode;

            if (node != null)
            {
                if (node.Type == UISchema.UIRefType.Type)
                {
                    info.ImageIndex = info.GetImageList().Images.IndexOfKey(Resources.RefImage);
                    string   label    = string.Empty;
                    UIRef    uiRef    = node.As <UIRef>();
                    UIObject uiTarget = uiRef.UIObject;
                    if (uiTarget != null)
                    {
                        label = uiTarget.Name;
                    }

                    info.Label = "[" + label + "]";
                }
                else if (node.Is <Curve>())
                {
                    Curve cv = node.Cast <Curve>();
                    info.Label      = string.IsNullOrWhiteSpace(cv.DisplayName) ? cv.Name : cv.DisplayName;
                    info.ImageIndex = info.GetImageList().Images.IndexOfKey(Resources.CurveImage);
                }
                else
                {
                    NodeTypePaletteItem paletteItem = node.Type.GetTag <NodeTypePaletteItem>();
                    if (paletteItem != null)
                    {
                        info.ImageIndex = info.GetImageList().Images.IndexOfKey(paletteItem.ImageName);
                    }

                    info.Label = node.GetId();
                }

                info.IsLeaf = !GetChildren(item).Any();
            }
            else
            {
                EmptyRef emptyRef = item as EmptyRef;
                if (emptyRef != null)
                {
                    info.Label      = "Ref";
                    info.ImageIndex = info.GetImageList().Images.IndexOfKey(Resources.RefEmptyImage);
                    info.IsLeaf     = true;
                }
            }

            if (string.IsNullOrEmpty(info.Label))
            {
                throw new ArgumentException("info.lable");
            }
        }
Ejemplo n.º 27
0
        /// <summary>
        /// Performs initialization when the adapter is connected to the group's DomNode.
        /// Raises the DomNodeAdapter NodeSet event and performs custom processing:
        /// creates a DomNodeListAdapter for various circuit elements.</summary>
        protected override void OnNodeSet()
        {
            m_modules     = new DomNodeListAdapter <ScriptNode>(DomNode, groupType.moduleChild);
            m_connections = new DomNodeListAdapter <ScriptNodeConnection>(DomNode, groupType.connectionChild);
            new DomNodeListAdapter <ScriptAnnotation>(DomNode, groupType.annotationChild);
            new DomNodeListAdapter <ScriptGroupSocket>(DomNode, groupType.inputChild);
            new DomNodeListAdapter <ScriptGroupSocket>(DomNode, groupType.outputChild);
            m_thisModule = DomNode.Cast <ScriptNode>();

            base.OnNodeSet();
        }
Ejemplo n.º 28
0
        /// <summary>
        /// Performs initialization when the adapter is connected to the group's DomNode.
        /// Raises the DomNodeAdapter NodeSet event and performs custom processing:
        /// creates a DomNodeListAdapter for various circuit elements.</summary>
        protected override void OnNodeSet()
        {
            m_modules     = new DomNodeListAdapter <Module>(DomNode, Schema.groupType.moduleChild);
            m_connections = new DomNodeListAdapter <Connection>(DomNode, Schema.groupType.connectionChild);
            new DomNodeListAdapter <Annotation>(DomNode, Schema.groupType.annotationChild);
            new DomNodeListAdapter <GroupPin>(DomNode, Schema.groupType.inputChild);
            new DomNodeListAdapter <GroupPin>(DomNode, Schema.groupType.outputChild);
            m_thisModule = DomNode.Cast <Module>();

            base.OnNodeSet();
        }
Ejemplo n.º 29
0
        /// <summary>
        /// Can given modules be moved into a new container</summary>
        /// <param name="newParent">New module parent</param>
        /// <param name="movingObjects">Objects being moved</param>
        /// <returns>True iff objects can be moved to new parent</returns>
        bool IEditableGraphContainer <ScriptNode, ScriptNodeConnection, ICircuitPin> .CanMove(object newParent, IEnumerable <object> movingObjects)
        {
            if (newParent.Is <IReference <ScriptNode> >())
            {
                return(false);
            }
            var editableGraphContainer =
                DomNode.Cast <VisualScriptEditingContext>() as IEditableGraphContainer <Element, Wire, ICircuitPin>;

            return(editableGraphContainer.CanMove(newParent, movingObjects));
        }
Ejemplo n.º 30
0
        // Scan for all sub-circuits that are referenced directly or indirectly by a module in
        //  the root of the document
        public override void Write(DomNode root, Stream stream, Uri uri)
        {
            #pragma warning disable 618 //mastered sub-circuits are obsolete
            m_usedSubCircuits = new HashSet <Sce.Atf.Controls.Adaptable.Graphs.SubCircuit>();
            foreach (var module in root.Cast <Circuit>().Elements)
            {
                FindUsedSubCircuits(module.DomNode);
            }
            #pragma warning restore 618

            base.Write(root, stream, uri);
        }
Ejemplo n.º 31
0
        /// <summary>
        /// Gets the bounding rectangle of all circuit items in client coordinates</summary>
        /// <returns>Bounding rectangle of all circuit items in client coordinates</returns>
        public Rectangle GetBounds()
        {
            if (m_graph == null)
            {
                return(Rectangle.Empty);
            }
            IEnumerable <object> items = m_graph.Nodes;
            var annoDiagram            = m_graph.As <IAnnotatedDiagram>();

            if (annoDiagram != null)
            {
                items = items.Concat(annoDiagram.Annotations);
            }
            Rectangle bounds = GetBounds(items);


            if (DomNode.Is <Group>())
            {
                // include group pins y range
                var group = DomNode.Cast <Group>();

                int yMin = int.MaxValue;
                int yMax = int.MinValue;

                foreach (var pin in group.InputGroupPins.Concat(group.OutputGroupPins))
                {
                    var grpPin = pin.Cast <GroupPin>();
                    if (grpPin.Bounds.Y < yMin)
                    {
                        yMin = grpPin.Bounds.Y;
                    }
                    if (grpPin.Bounds.Y > yMax)
                    {
                        yMax = grpPin.Bounds.Y;
                    }
                }

                // transform y range to client space
                if (yMin != int.MaxValue && yMax != int.MinValue)
                {
                    var transformAdapter = m_control.Cast <ITransformAdapter>();
                    var minPt            = Matrix3x2F.TransformPoint(transformAdapter.Transform, new PointF(0, yMin));
                    var maxPt            = Matrix3x2F.TransformPoint(transformAdapter.Transform, new PointF(0, yMax));

                    yMin = (int)minPt.Y;
                    yMax = (int)maxPt.Y;
                    int width  = bounds.Width;
                    int height = yMax - yMin + 1;
                    bounds = Rectangle.Union(bounds, new Rectangle(bounds.X, yMin, width, height));
                }
            }
            return(bounds);
        }
Ejemplo n.º 32
0
        /// <summary>
        /// Reads in the data for an EventSequenceDocument from the given stream</summary>
        /// <remarks>This method proves the concept that a document can be persisted in a custom
        /// file format that is not XML.</remarks>
        /// <param name="stream">Stream with event sequence data</param>
        /// <returns>A valid EventSequenceDocument if successful or null if the stream's data is invalid</returns>
        public static EventSequenceDocument Read(Stream stream)
        {
            using (StreamReader reader = new StreamReader(stream))
            {
                string line = reader.ReadLine();
                if (line != "eventSequence")
                {
                    return(null);
                }

                DomNode root             = new DomNode(DomTypes.eventSequenceType.Type, DomTypes.eventSequenceRootElement);
                bool    readLineForEvent = true;
                while (true)
                {
                    // The root has a sequence of children that are eventType nodes.
                    if (readLineForEvent)
                    {
                        line = reader.ReadLine();
                    }
                    if (string.IsNullOrEmpty(line))
                    {
                        break;
                    }
                    readLineForEvent = true;
                    DomNode eventNode;
                    if (!ReadEvent(line, out eventNode))
                    {
                        break;
                    }
                    root.GetChildList(DomTypes.eventSequenceType.eventChild).Add(eventNode);

                    // Each eventType node may have zero or more resourceType nodes.
                    while (true)
                    {
                        line = reader.ReadLine();
                        if (string.IsNullOrEmpty(line))
                        {
                            break;
                        }
                        DomNode resourceNode;
                        if (!ReadResource(line, out resourceNode))
                        {
                            // might be a line for an event
                            readLineForEvent = false;
                            break;
                        }
                        eventNode.GetChildList(DomTypes.eventType.resourceChild).Add(resourceNode);
                    }
                }

                return(root.Cast <EventSequenceDocument>());
            }
        }
Ejemplo n.º 33
0
Archivo: Layer.cs Proyecto: ldh9451/XLE
 public bool AddChild(object child)
 {
     bool added = false;
     ILayer layer = child.As<ILayer>();
     if (layer != null)
     {
         if (!Layers.Contains(layer))
         {
             Layers.Add(layer);
             added = true;
         }
     }
     else
     {
         IReference<IGameObject> reference = child.As<IReference<IGameObject>>();
         if (reference != null)
         {
             if (reference.Target != null
                 && !this.Contains(reference.Target)
                 && !GameObjectReferences.Contains(reference))
             {
                 GameObjectReferences.Add(reference);
                 added = true;
             }
         }
         else
         {
             IGameObject gameObject = child.As<IGameObject>();
             if (gameObject != null && !this.Contains(gameObject))
             {
                 DomNode referenceNode = new DomNode(Schema.gameObjectReferenceType.Type);
                 reference = referenceNode.Cast<IReference<IGameObject>>();
                 reference.Target = gameObject;
                 GameObjectReferences.Add(reference);
                 added = true;
             }
         }
     }
     return added;
 }
Ejemplo n.º 34
0
        private void Init()
        {
            NativeObjectAdapter curLevel = GameEngine.GetGameLevel();
            try
            {
                // create new document by creating a Dom node of the root type defined by the schema                 
                DomNode rootNode = new DomNode(m_schemaLoader.GameType, m_schemaLoader.GameRootElement);
                INameable nameable = rootNode.Cast<INameable>();
                nameable.Name = "ThumbnailGenerator";

                NativeObjectAdapter gameLevel = rootNode.Cast<NativeObjectAdapter>();
                GameEngine.CreateObject(gameLevel);
                GameEngine.SetGameLevel(gameLevel);
                gameLevel.UpdateNativeOjbect();
                NativeGameWorldAdapter gworld = rootNode.Cast<NativeGameWorldAdapter>();

                m_game = rootNode.Cast<IGame>();
                IGameObjectFolder rootFolder = m_game.RootGameObjectFolder;                
                m_renderSurface = new TextureRenderSurface(96, 96);
                m_renderState = new RenderState();
                m_renderState.RenderFlag = GlobalRenderFlags.Solid | GlobalRenderFlags.Textured | GlobalRenderFlags.Lit | GlobalRenderFlags.Shadows;


            }
            finally
            {
                GameEngine.SetGameLevel(curLevel);
            }


            m_mainWindow.Closed += delegate
            {
                GameEngine.DestroyObject(m_game.Cast<NativeObjectAdapter>());
                m_renderSurface.Dispose();
                m_renderState.Dispose();
            };

        }
Ejemplo n.º 35
0
 public static Character New(ChildInfo childInfo)
 {
     DomNode node = new DomNode(Schema.characterType.Type, childInfo);
     return node.Cast<Character>();
 }
Ejemplo n.º 36
0
        private void Init()
        {
            if (m_game != null) 
                return;

            NativeObjectAdapter curLevel = GameEngine.GetGameLevel();
            try
            {
                // create new document by creating a Dom node of the root type defined by the schema                 
                DomNode rootNode = new DomNode(m_schemaLoader.GameType, m_schemaLoader.GameRootElement);
                INameable nameable = rootNode.As<INameable>();
                nameable.Name = "Game";
                NativeObjectAdapter gameLevel = rootNode.Cast<NativeObjectAdapter>();
                GameEngine.CreateObject(gameLevel);
                GameEngine.SetGameLevel(gameLevel);
                gameLevel.UpdateNativeOjbect();
                NativeGameWorldAdapter gworld = rootNode.Cast<NativeGameWorldAdapter>();
                m_game = rootNode.Cast<IGame>();
                IGameObjectFolder rootFolder = m_game.RootGameObjectFolder;
                m_renderSurface.Game = m_game;

            }
            finally
            {
                GameEngine.SetGameLevel(curLevel);
            }


            m_mainWindow.Closed += delegate
            {
                GameEngine.DestroyObject(m_game.Cast<NativeObjectAdapter>());
                m_renderSurface.Dispose();
            };
        }
Ejemplo n.º 37
0
        // Create circuit DOM hierarchy programmatically
        static public DomNode CreateTestCircuitProgrammatically(SchemaLoader schemaLoader)
        {
            var rootNode = new DomNode(Schema.circuitDocumentType.Type, Schema.circuitRootElement);        
            // create an empty root prototype folder( required child by schema)
            rootNode.SetChild(
                Schema.circuitDocumentType.prototypeFolderChild,
                new DomNode(Schema.prototypeFolderType.Type));
            
            var circuit = rootNode.Cast<Circuit>();

            var inputFiles = new DomNode(Schema.groupType.Type).Cast<Group>();
            inputFiles.Id = "groupInputFiles";
            inputFiles.Name = "Input Files".Localize();
            inputFiles.Bounds = new Rectangle(64, 96, 0, 0); // set node location, size will be auto-computed
 
            var firstWavgGroup = new DomNode(Schema.groupType.Type).Cast<Group>();
            firstWavgGroup.Id = "first.Wav";
            firstWavgGroup.Name = "first".Localize("as in, 'the first file'") + ".wav";

            var buttonType = schemaLoader.GetNodeType(Schema.NS + ButtonTypeName);
            var button1 = new DomNode(buttonType).Cast<Module>();
            button1.Id = "button1";
            button1.Bounds = new Rectangle(0, 0, 0, 0);

            var button2 = new DomNode(buttonType).Cast<Module>();
            button2.Bounds = new Rectangle(0, 64, 0, 0);
            button2.Id = "button2";

            firstWavgGroup.Elements.Add(button1);
            firstWavgGroup.Elements.Add(button2);
            firstWavgGroup.Expanded = true;
            firstWavgGroup.Update();


            var secondWavgGroup = new DomNode(Schema.groupType.Type).Cast<Group>();
            secondWavgGroup.Id = "second.Wav";
            secondWavgGroup.Name = "second".Localize("as in, 'the second file'") + ".wav";

            var button3 = new DomNode(buttonType).Cast<Module>();
            button3.Id = "button3";
            button3.Bounds = new Rectangle(0, 0, 0, 0);

            var button4 = new DomNode(buttonType).Cast<Module>();
            button4.Bounds = new Rectangle(0, 64, 0, 0);
            button4.Id = "button4";

            secondWavgGroup.Elements.Add(button3);
            secondWavgGroup.Elements.Add(button4);
            secondWavgGroup.Expanded = true;
            secondWavgGroup.Update();
            secondWavgGroup.Bounds = new Rectangle(0, 224, 0, 0);
  
            inputFiles.Elements.Add(firstWavgGroup);
            inputFiles.Elements.Add(secondWavgGroup);
            inputFiles.Update();
            inputFiles.Expanded = true;

            circuit.Elements.Add(inputFiles);


            var structure = new DomNode(Schema.groupType.Type).Cast<Group>();
            structure.Id = "structure".Localize("this is the name of a group of circuit elements; the name is arbitrary");
            structure.Name = "structure".Localize("this is the name of a group of circuit elements; the name is arbitrary");
            structure.Bounds = new Rectangle(352, 96, 0, 0); 
 

            var subStream0 = new DomNode(Schema.groupType.Type).Cast<Group>();
            subStream0.Id = "subStream0".Localize("this is the name of a group of circuit elements; the name is arbitrary");
            subStream0.Name = "sub-stream 0".Localize("this is the name of a group of circuit elements; the name is arbitrary");

            var lightType = schemaLoader.GetNodeType(Schema.NS + LightTypeName);

            var light1 = new DomNode(lightType).Cast<Module>();
            light1.Id = "light1";
            light1.Bounds = new Rectangle(0, 0, 0, 0);

            var light2 = new DomNode(lightType).Cast<Module>();
            light2.Id = "light2";
            light2.Bounds = new Rectangle(0, 64, 0, 0);

            var light3 = new DomNode(lightType).Cast<Module>();
            light3.Id = "light3";
            light3.Bounds = new Rectangle(0, 128, 0, 0);

            var light4 = new DomNode(lightType).Cast<Module>();
            light4.Id = "light4";
            light4.Bounds = new Rectangle(0, 192, 0, 0);

            var light5 = new DomNode(lightType).Cast<Module>();
            light5.Id = "light5";
            light5.Bounds = new Rectangle(0, 256, 0, 0);

            var light6 = new DomNode(lightType).Cast<Module>();
            light6.Id = "light6";
            light6.Bounds = new Rectangle(0, 320, 0, 0);


            subStream0.Elements.Add(light1);
            subStream0.Elements.Add(light2);
            subStream0.Elements.Add(light3);
            subStream0.Elements.Add(light4);
            subStream0.Elements.Add(light5);
            subStream0.Elements.Add(light6);
            subStream0.Expanded = true;
            subStream0.Update(); // this will generate group pins needed for edge connection


            structure.Elements.Add(subStream0);
            structure.Expanded = true;
            structure.Update();

            circuit.Elements.Add(structure);

            // Note on 11/12/2013: adding wires currently crashes. Nested circuit groups aren't officially supported anyways.
            // make some edges betwen InputFiles & structure
            //var connection0 = CircuitAddEdge(inputFiles, 0, structure, 0);
            //circuit.Wires.Add(connection0);
            //var connection1 = CircuitAddEdge(inputFiles, 1, structure, 1);
            //circuit.Wires.Add(connection1);
            //var connection2 = CircuitAddEdge(inputFiles, 2, structure, 3);
            //circuit.Wires.Add(connection2);
            //var connection3 = CircuitAddEdge(inputFiles, 3, structure, 5);
            //circuit.Wires.Add(connection3);

            return rootNode;
        }
Ejemplo n.º 38
0
        /// <summary>
        /// Projects the ghost</summary>
        private void ProjectGhost(DomNode ghost, 
            Ray3F rayw,
            HitRecord? hit)
        {

            ITransformable xformnode = ghost.Cast<ITransformable>();
            IBoundable bnode  = ghost.As<IBoundable>();
            AABB box = bnode.BoundingBox;
            
            Vec3F pt;
            if (hit.HasValue && hit.Value.hasNormal)
            {
                Vec3F rad = box.Radius;
                Vec3F norm = hit.Value.normal;
                Vec3F absNorm = Vec3F.Abs(norm);
                Vec3F offset = Vec3F.ZeroVector;
                
                if (absNorm.X > absNorm.Y)
                {
                    if (absNorm.X > absNorm.Z)
                        offset.X = norm.X > 0 ? rad.X : -rad.X;
                    else
                        offset.Z = norm.Z > 0 ? rad.Z : -rad.Z;                        
                }
                else
                {
                    if (absNorm.Y > absNorm.Z)
                        offset.Y = norm.Y > 0 ? rad.Y : -rad.Y;
                    else
                        offset.Z = norm.Z > 0 ? rad.Z : -rad.Z;                        
                        
                }                
                Vec3F localCenter = box.Center - xformnode.Translation;
                pt = hit.Value.hitPt + (offset - localCenter);
            }
            else
            {
                float offset = 6.0f * box.Radius.Length;
                pt = rayw.Origin + offset * rayw.Direction;
            }
                                          
            if (ViewType == ViewTypes.Front)
                pt.Z = 0.0f;
            else if (ViewType == ViewTypes.Top)
                pt.Y = 0.0f;
            else if (ViewType == ViewTypes.Left)
                pt.X = 0.0f;           
            xformnode.Translation = pt;

        }
Ejemplo n.º 39
0
 /// <summary>
 /// Unregisters the Control from the IContextRegistry and IControlHostService and disposes
 /// it and sets the circuitNode's ViewingContext's Control property to null.</summary>
 private void UnregisterControl(DomNode circuitNode, Control control)
 {
     //it's OK if the CircuitEditingContext was already removed or wasn't added to IContextRegistry.
     m_contextRegistry.RemoveContext(circuitNode.As<CircuitEditingContext>());
     m_controlHostService.UnregisterControl(control);
     control.Visible = false;
     control.Dispose();
     m_circuitNodeControls.Remove(circuitNode);
     circuitNode.Cast<ViewingContext>().Control = null;
 }
Ejemplo n.º 40
0
 public static Settings New(ChildInfo childInfo)
 {
     DomNode node = new DomNode(Schema.settingsType.Type, childInfo);
     return node.Cast<Settings>();
 }
Ejemplo n.º 41
0
        /// <summary>
        /// Reads in the data for an EventSequenceDocument from the given stream</summary>
        /// <remarks>This method proves the concept that a document can be persisted in a custom
        /// file format that is not XML.</remarks>
        /// <param name="stream">Stream with event sequence data</param>
        /// <returns>A valid EventSequenceDocument if successful or null if the stream's data is invalid</returns>
        public static EventSequenceDocument Read(Stream stream)
        {
            using (StreamReader reader = new StreamReader(stream))
            {
                string line = reader.ReadLine();
                if (line != "eventSequence")
                    return null;

                DomNode root = new DomNode(DomTypes.eventSequenceType.Type, DomTypes.eventSequenceRootElement);
                bool readLineForEvent = true;
                while (true)
                {
                    // The root has a sequence of children that are eventType nodes.
                    if (readLineForEvent)
                        line = reader.ReadLine();
                    if (string.IsNullOrEmpty(line))
                        break;
                    readLineForEvent = true;
                    DomNode eventNode;
                    if (!ReadEvent(line, out eventNode))
                        break;
                    root.GetChildList(DomTypes.eventSequenceType.eventChild).Add(eventNode);

                    // Each eventType node may have zero or more resourceType nodes.
                    while (true)
                    {
                        line = reader.ReadLine();
                        if (string.IsNullOrEmpty(line))
                            break;
                        DomNode resourceNode;
                        if (!ReadResource(line, out resourceNode))
                        {
                            // might be a line for an event
                            readLineForEvent = false;
                            break;
                        }
                        eventNode.GetChildList(DomTypes.eventType.resourceChild).Add(resourceNode);
                    }
                }

                return root.Cast<EventSequenceDocument>();
            }
        }