Exemplo n.º 1
0
        /// <summary>
        /// Saves the document at the given URI</summary>
        /// <param name="document">Document to save</param>
        /// <param name="uri">New document URI</param>
        public void Save(IDocument document, Uri uri)
        {
            CircuitDocument circuitDocument = (CircuitDocument)document;
            string          filePath        = uri.LocalPath;
            FileMode        fileMode        = File.Exists(filePath) ? FileMode.Truncate : FileMode.OpenOrCreate;

            using (FileStream stream = new FileStream(filePath, fileMode))
            {
                var writer = new CircuitWriter(m_schemaLoader.TypeCollection);
                writer.Write(circuitDocument.DomNode, stream, uri);
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// Does a command</summary>
        /// <param name="commandTag">Command</param>
        public void DoCommand(object commandTag)
        {
            var context = m_contextRegistry.GetActiveContext <CircuitEditingContext>();

            if (CommandTag.CreateMaster.Equals(commandTag))
            {
                SubCircuitInstance subCircuitInstance = null;

                var  masterContext = context.DomNode.GetRoot().Cast <CircuitEditingContext>();
                bool success       = context.DoTransaction(delegate
                {
                    // create SubCircuit, and SubCircuitInstance of it
                    subCircuitInstance = CreateMaster(context);
                    context.Insert(new DataObject(new object[] { subCircuitInstance }));
                },
                                                           "Master".Localize("this is the name of a command"));

                // Because multiple EditingContexts can be modifying the Document, and each EditingContext has
                //  its own undo/redo history, we can't record this change in any EditingContext. The reason we
                //  can't is because TransactionContext stores the child index and uses that to undo/redo.
                //  If transactions are undone out-of-order, these indexes will no longer be correct and can
                //  cause bad behavior or unhandled exceptions.
                // Since we still want the validators to run in order to implement unique naming, we can simply
                //  turn off the recording in the HistoryContext.
                if (success)
                {
                    masterContext.Recording = false;
                    try
                    {
                        masterContext.DoTransaction(delegate
                        {
                            CircuitDocument circuitDocument = masterContext.Cast <CircuitDocument>();
                            circuitDocument.SubCircuits.Add(subCircuitInstance.SubCircuit);
                        },
                                                    "no undo/redo for this part of 'Master'");
                    }
                    finally
                    {
                        masterContext.Recording = true;
                    }
                }
            }
            else if (CommandTag.ExpandMaster.Equals(commandTag))
            {
                context.DoTransaction(delegate
                {
                    // get the last selected SubCircuitInstance and expand its master in its place
                    SubCircuitInstance subCircuitInstance = context.Selection.GetLastSelected <SubCircuitInstance>();
                    object[] subCircuitContents           = ExpandMaster(context, subCircuitInstance);
                    context.Insert(new DataObject(subCircuitContents));
                }, "Unmaster".Localize("this is the name of a command"));
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// Notifies the client that its Control has been activated. Activation occurs when
        /// the Control gets focus, or a parent "host" Control gets focus.</summary>
        /// <param name="control">Client Control that was activated</param>
        /// <remarks>This method is only called by IControlHostService if the Control was previously
        /// registered for this IControlHostClient.</remarks>
        public void Activate(Control control)
        {
            AdaptableControl adaptableControl = (AdaptableControl)control;
            var context = adaptableControl.ContextAs <CircuitEditingContext>();

            m_contextRegistry.ActiveContext = context;

            CircuitDocument circuitDocument = context.As <CircuitDocument>();

            if (circuitDocument != null)
            {
                m_documentRegistry.ActiveDocument = circuitDocument;
            }
        }
Exemplo n.º 4
0
        /// <summary>
        /// Requests permission to close the client's Control.
        /// Allows user to save document before closing it.</summary>
        /// <param name="control">Client Control to be closed</param>
        /// <returns>True if the Control either can close or is already closed. False to cancel.</returns>
        /// <remarks>
        /// 1. This method is only called by IControlHostService if the Control was previously
        /// registered for this IControlHostClient.
        /// 2. If true is returned, the IControlHostService calls its own
        /// UnregisterControl. The IControlHostClient has to call RegisterControl again
        /// if it wants to re-register this Control.</remarks>
        public bool Close(Control control)
        {
            var adaptableControl = (AdaptableControl)control;

            bool            closed          = true;
            CircuitDocument circuitDocument = adaptableControl.ContextAs <CircuitDocument>();

            if (circuitDocument != null)
            {
                closed = m_documentService.Close(circuitDocument);
                if (closed)
                {
                    Close(circuitDocument);
                }
            }
            else
            {
                // We don't care if the control was already unregistered. 'closed' should be true.
                m_circuitControlRegistry.UnregisterControl(control);
            }
            return(closed);
        }
Exemplo n.º 5
0
        /// <summary>
        /// Opens or creates a document at the given URI.
        /// Creates and configures with control adapters D2dAdaptableControl to display subcircuit</summary>
        /// <param name="uri">Document URI</param>
        /// <returns>Document, or null if the document couldn't be opened or created</returns>
        public IDocument Open(Uri uri)
        {
            DomNode node     = null;
            string  filePath = uri.LocalPath;

            if (File.Exists(filePath))
            {
                // read existing document using standard XML reader
                using (FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
                {
                    CircuitReader reader = new CircuitReader(m_schemaLoader);
                    node = reader.Read(stream, uri);
                }
            }
            else
            {
                // create new document by creating a Dom node of the root type defined by the schema
                node = new DomNode(Schema.circuitDocumentType.Type, Schema.circuitRootElement);
                // create an empty root prototype folder
                node.SetChild(
                    Schema.circuitDocumentType.prototypeFolderChild,
                    new DomNode(Schema.prototypeFolderType.Type));
            }

            CircuitDocument circuitCircuitDocument = null;

            if (node != null)
            {
                // now that the data is complete, initialize all other extensions to the Dom data
                node.InitializeExtensions();

                AdaptableControl control = CreateCircuitControl(node);
                control.AddHelp("https://github.com/SonyWWS/ATF/wiki/Adaptable-Controls".Localize());

                var viewingContext = node.Cast <ViewingContext>();
                viewingContext.Control = control;

                circuitCircuitDocument = node.Cast <CircuitDocument>();
                string      fileName    = Path.GetFileName(filePath);
                ControlInfo controlInfo = new ControlInfo(fileName, filePath, StandardControlGroup.Center);

                //Set IsDocument to true to prevent exception in command service if two files with the
                //  same name, but in different directories, are opened.
                controlInfo.IsDocument = true;

                circuitCircuitDocument.ControlInfo = controlInfo;
                circuitCircuitDocument.Uri         = uri;

                var editingContext = node.Cast <CircuitEditingContext>();
                editingContext.GetLocalBound       = GetLocalBound;
                editingContext.GetWorldOffset      = GetWorldOffset;
                editingContext.GetTitleHeight      = GetTitleHeight;
                editingContext.GetLabelHeight      = GetLabelHeight;
                editingContext.GetSubContentOffset = GetSubContentOffset;

                control.Context             = editingContext;
                editingContext.SchemaLoader = m_schemaLoader; // schema needed for cut and paste between applications

                m_circuitControlRegistry.RegisterControl(node, control, controlInfo, this);
                SkinService.ApplyActiveSkin(control);
                // Set the zoom and translation to show the existing items (if any).
                var enumerableContext = editingContext.Cast <IEnumerableContext>();
                if (viewingContext.CanFrame(enumerableContext.Items))
                {
                    viewingContext.Frame(enumerableContext.Items);
                }

                //var viewingAdapter = control.As<ViewingAdapter>();
                // enable toggle after initial frame operation.
                //  viewingAdapter.ToggleFramingEnabled = true; // toggle frame/unframe.
            }

            return(circuitCircuitDocument);
        }
Exemplo n.º 6
0
        private void control_DoubleClick(object sender, EventArgs e)
        {
            AdaptableControl d2dHoverControl = (AdaptableControl)sender;
            Point            clientPoint     = d2dHoverControl.PointToClient(Control.MousePosition);

            D2dGraphAdapter <Module, Connection, ICircuitPin> graphAdapter =
                d2dHoverControl.As <D2dGraphAdapter <Module, Connection, ICircuitPin> >();
            GraphHitRecord <Module, Connection, ICircuitPin> hitRecord = graphAdapter.Pick(clientPoint);
            SubCircuitInstance subCircuitInstance = Adapters.As <SubCircuitInstance>(hitRecord.Node);

            if (subCircuitInstance != null)
            {
                var subCircuit = subCircuitInstance.SubCircuit;

                var viewingContext = subCircuit.Cast <ViewingContext>();
                if (viewingContext.Control != null)
                {
                    // sub-circuit is already open, just show control
                    m_controlHostService.Show(viewingContext.Control);
                }
                else
                {
                    // create new circuit editing control for sub-circuit
                    AdaptableControl subCircuitControl = CreateCircuitControl(subCircuit.DomNode);
                    viewingContext.Control = subCircuitControl;

                    CircuitDocument circuitDocument = subCircuitInstance.DomNode.GetRoot().As <CircuitDocument>();
                    string          filePath        = circuitDocument.Uri.LocalPath;
                    string          fileName        = Path.GetFileNameWithoutExtension(filePath);
                    string          subCircuitName  = subCircuit.Name;
                    string          name            = fileName + ":" + subCircuitName;
                    string          description     = filePath + "#" + subCircuitName;

                    var editingContext = subCircuit.DomNode.Cast <CircuitEditingContext>();
                    editingContext.GetLocalBound       = GetLocalBound;
                    editingContext.GetWorldOffset      = GetWorldOffset;
                    editingContext.GetTitleHeight      = GetTitleHeight;
                    editingContext.GetLabelHeight      = GetLabelHeight;
                    editingContext.GetSubContentOffset = GetSubContentOffset;

                    subCircuitControl.Context   = editingContext;
                    editingContext.SchemaLoader = m_schemaLoader; // schema needed for cut and paste between applications

                    ControlInfo controlInfo = new ControlInfo(name, description, StandardControlGroup.Center);
                    m_circuitControlRegistry.RegisterControl(subCircuit.DomNode, subCircuitControl, controlInfo, this);
                }
            }
            else
            {
                Group subGraph          = null;
                var   subGraphReference = hitRecord.Node.As <GroupInstance>();
                if (subGraphReference != null)
                {
                    DialogResult checkResult = DialogResult.No; //direct editing
                    if (checkResult == DialogResult.No)
                    {
                        subGraph = subGraphReference.Target.Cast <Group>();
                        var graphValidator = subGraphReference.DomNode.GetRoot().Cast <CircuitValidator>();
                        graphValidator.UpdateTemplateInfo(subGraph);
                    }
                }
                else
                {
                    subGraph = hitRecord.Node.As <Group>();
                }
                if (subGraph != null)
                {
                    var viewingContext = subGraph.Cast <ViewingContext>();
                    if (viewingContext.Control != null)
                    {
                        // sub-graph is already open, just show control
                        m_controlHostService.Show(viewingContext.Control);
                    }
                    else
                    {
                        // create new circuit editing control for sub-circuit
                        AdaptableControl subCircuitControl = CreateCircuitControl(subGraph.DomNode);
                        viewingContext.Control = subCircuitControl;

                        // use group’s hierarchy as control name
                        string name  = string.Empty;
                        bool   first = true;
                        foreach (var domNode in subGraph.DomNode.GetPath())
                        {
                            if (domNode.Is <Group>())
                            {
                                if (first)
                                {
                                    name  = domNode.Cast <Group>().Name;
                                    first = false;
                                }
                                else
                                {
                                    name += "/" + domNode.Cast <Group>().Name;
                                }
                            }
                        }

                        string description = name;

                        var editingContext = subGraph.DomNode.Cast <CircuitEditingContext>();
                        editingContext.GetLocalBound       = GetLocalBound;
                        editingContext.GetWorldOffset      = GetWorldOffset;
                        editingContext.GetTitleHeight      = GetTitleHeight;
                        editingContext.GetLabelHeight      = GetLabelHeight;
                        editingContext.GetSubContentOffset = GetSubContentOffset;

                        subCircuitControl.Context   = editingContext;
                        editingContext.SchemaLoader = m_schemaLoader; // schema needed for cut and paste between applications

                        ControlInfo controlInfo = new ControlInfo(name, description, StandardControlGroup.Center);
                        //controlInfo.Docking = new ControlInfo.DockingInfo() // smart docking behavior
                        //{
                        //    GroupTag = subGraph.DomNode.Lineage.AsIEnumerable<Group>().Last(),// use the top-level parent group
                        //    Order = subGraph.Level
                        //};
                        m_circuitControlRegistry.RegisterControl(subGraph.DomNode, subCircuitControl, controlInfo, this);

                        var enumerableContext = subGraph.DomNode.Cast <CircuitEditingContext>().Cast <IEnumerableContext>();
                        var items             = (enumerableContext != null) ? enumerableContext.Items : null;
                        subCircuitControl.As <IViewingContext>().Frame(items);
                    }
                }
            }
        }