Exemple #1
0
 /// <summary>
 /// Throws exception if endpoints of two arrows do not coincide
 /// </summary>
 /// <param name="x">First arrow</param>
 /// <param name="y">Second arrow</param>
 static public void ThrowEndpointsException(ICategoryArrow x, ICategoryArrow y)
 {
     if ((x.Source != y.Source) | (x.Target != y.Target))
     {
         throw new CategoryException(EndpointsOfTwoArrowsError);
     }
 }
Exemple #2
0
        /// <summary>
        /// The on mouse down event handler
        /// </summary>
        /// <param name="sender">The sender</param>
        /// <param name="e">The event arguments</param>
        private void onMouseDownMoveEventHandler(object sender, MouseEventArgs e)
        {
            if (!e.IsArrowClick())
            {
                return;
            }
            IObjectLabel lab = Label;

            if (lab == null)
            {
                return;
            }
            PanelDesktop  desktop = Parent as PanelDesktop;
            PaletteButton active  = desktop.Tools.Active;

            if (active != null)
            {
                if (active.IsArrow & !(active.ReflectionType == null))
                {
                    try
                    {
                        ICategoryArrow arrow = desktop.Tools.Factory.CreateArrow(active);
                        arrow.Source              = lab.Object;
                        desktop.ActiveArrow       = arrow;
                        desktop.ActiveObjectLabel = lab;
                        return;
                    }
                    catch (Exception ex)
                    {
                        ex.ShowError(10);
                    }
                }
            }
        }
 /// <summary>
 /// Checks connection between first and next arrow
 /// </summary>
 /// <param name="first">The first arrow</param>
 /// <param name="next">The next arrow</param>
 static public void CheckArrowConnection(this ICategoryArrow first, ICategoryArrow next)
 {
     if (first.Source != next.Target)
     {
         throw new CategoryException(TargetSourceArrow);
     }
 }
Exemple #4
0
 /// <summary>
 /// Creates a form for component properties editor
 /// </summary>
 /// <param name="comp">The component</param>
 /// <returns>The result form</returns>
 public override object CreateForm(INamedComponent comp)
 {
     if (comp is IObjectLabel)
     {
         IObjectLabel lab = comp as IObjectLabel;
         // The object of component
         ICategoryObject obj = lab.Object;
         if (obj is Motion6D.SerializablePosition)
         {
             Motion6D.Interfaces.IPosition p = obj as Motion6D.Interfaces.IPosition;
             object o = p.Parameters;
             if (o != null)
             {
                 if (o is Motion6D.PhysicalFieldBase)
                 {
                     return(new Motion6D.UI.Forms.FormField3D(lab, o as Motion6D.PhysicalField3D));
                 }
                 if (o is PhysicalField.SphericalFieldWrapper)
                 {
                     return(new Motion6D.UI.FormSphericalMagnnetic(lab, o as PhysicalField.SphericalFieldWrapper));
                 }
                 if (o is Motion6D.InertialSensorData)
                 {
                     return(new Motion6D.UI.FormInertialSystem(lab, o as Motion6D.InertialSensorData));
                 }
             }
         }
         if (obj is Motion6D.InertialReferenceFrame)
         {
             return(new Motion6D.UI.FormInertia(lab));
         }
         if (obj is Motion6D.ReferenceFrameData)
         {
             return(new Motion6D.UI.Forms.FormFrameData(lab));
         }
         if (obj is Motion6D.RigidReferenceFrame)
         {
             return(new Motion6D.UI.Forms.FormRigidFrame(lab));
         }
         if (obj is Motion6D.AcceleratedPosition)
         {
             return(new Motion6D.UI.FormAcceleratedPoint(lab));
         }
         if (obj is Motion6D.PositionCollectionData)
         {
             return(new FormPointsCollection(lab));
         }
     }
     if (comp is IArrowLabel)
     {
         IArrowLabel    l     = comp as IArrowLabel;
         ICategoryArrow arrow = l.Arrow;
         if (arrow is MechanicalAggregateLink)
         {
             return(new FormAggregateLink(l));
         }
     }
     return(null);
 }
Exemple #5
0
 /// <summary>
 /// Sets labels
 /// </summary>
 /// <param name="c">Collection of arrows</param>
 static public void SetLabels(IEnumerable <IArrowLabel> c)
 {
     foreach (IArrowLabel l in c)
     {
         ICategoryArrow a = l.Arrow;
         a.SetAssociatedObject(l);
     }
 }
Exemple #6
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="button">Associated button</param>
 /// <param name="arrow">Associated arrow</param>
 /// <param name="source">Associated source</param>
 /// <param name="target">Associated target</param>
 public ArrowLabel(IPaletteButton button, ICategoryArrow arrow,
                   IObjectLabel source, IObjectLabel target) : base(button)
 {
     this.arrow  = arrow;
     this.source = source;
     this.target = target;
     Initialize();
 }
        void Load()
        {
            byte[]        bytesOut;
            Assembly      ass = LibraryObjectWrapper.Load(bytes, out bytesOut);
            IArrowFactory f   = GetFactory(ass);

            theArrow = f[name];
            ICategoryArrow arr = this;

            theArrow.SetAssociatedObject(arr.Object);
        }
Exemple #8
0
 /// <summary>
 /// Crerates arrow label from arrow
 /// </summary>
 /// <param name="arr">The arrow</param>
 /// <returns>The label</returns>
 public virtual IArrowLabelUI CreateLabel(ICategoryArrow arr)
 {
     foreach (IUIFactory f in factories)
     {
         IArrowLabelUI a = f.CreateLabel(arr);
         if (a != null)
         {
             return(a);
         }
     }
     return(null);
 }
Exemple #9
0
 /// <summary>
 /// Gets button from arrow
 /// </summary>
 /// <param name="arrow">The arrow</param>
 /// <returns>The arrow</returns>
 public virtual IPaletteButton GetArrowButton(ICategoryArrow arrow)
 {
     foreach (IUIFactory f in factories)
     {
         IPaletteButton b = f.GetArrowButton(arrow);
         if (b != null)
         {
             return(b);
         }
     }
     return(null);
 }
Exemple #10
0
        /// <summary>
        /// Creates desktop from Xml documet
        /// </summary>
        /// <param name="document">The document</param>
        /// <param name="create">The create function</param>
        /// <returns>The desktop</returns>
        public static PureDesktopPeer LoadFromXml(this XmlDocument document, Func <XmlElement, object> create)
        {
            PureDesktopPeer desktop = new PureDesktopPeer();
            Dictionary <string, IObjectLabel> dictionary = new Dictionary <string, IObjectLabel>();
            XmlElement objs = document.GetElementsByTagName("Objects")[0] as XmlElement;

            foreach (XmlElement e in objs.ChildNodes)
            {
                string name = e.GetAttribute("Name");
                object o    = create(e);
                if (o == null)
                {
                    continue;
                }
                string t = o.GetType() + "";
                string k = "";
                if (t.Equals("DataPerformer.DataLink") | t.Equals("DataPerformer.VectorFormulaConsumer"))
                {
                    k = "Mv";
                }
                PureObjectLabelPeer l = new PureObjectLabelPeer(name, k, t, 0, 0);
                dictionary[name] = l;
                desktop.AddObjectLabel(l, o as ICategoryObject, true);
                l.Desktop = desktop;
            }
            XmlElement arrs = document.GetElementsByTagName("Arrows")[0] as XmlElement;

            foreach (XmlElement e in arrs.ChildNodes)
            {
                string         name = e.GetAttribute("Name");
                ICategoryArrow a    = create(e) as ICategoryArrow;
                if (a == null)
                {
                    continue;
                }
                string s = e.GetAttribute("Source");
                string t = e.GetAttribute("Target");
                if (!dictionary.ContainsKey(s) | !dictionary.ContainsKey(t))
                {
                    continue;
                }
                try
                {
                    desktop.AddArrowWithExistingLabels(a, dictionary[s], dictionary[t], name, "");
                }
                catch (Exception)
                {
                }
            }
            return(desktop);
        }
Exemple #11
0
 /// <summary>
 /// Creates arrow label
 /// </summary>
 /// <param name="button">Corresponding button</param>
 /// <param name="arrow">Corresponding arrow</param>
 /// <param name="source">Soource label</param>
 /// <param name="target">Target label</param>
 /// <returns>The arrow label</returns>
 public virtual IArrowLabelUI CreateArrowLabel(IPaletteButton button, ICategoryArrow arrow, IObjectLabel source, IObjectLabel target)
 {
     foreach (IUIFactory f in factories)
     {
         IArrowLabelUI a = f.CreateArrowLabel(button, arrow, source, target);
         if (a != null)
         {
             return(a);
         }
     }
     if (defaultValue)
     {
         return(factory.CreateArrowLabel(button, arrow, source, target));
     }
     return(null);
 }
Exemple #12
0
        private void MouseDown(object sender, MouseEventArgs e)
        {
            if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
            {
                label.Selected = !label.Selected;
                return;
            }
            if (e.Button == MouseButtons.Right)
            {
                if (label is IShowForm)
                {
                    IShowForm sf = label as IShowForm;
                    sf.Show();
                    return;
                }
            }

            /*  if (EditorRectangle.Contains(e.X, e.Y))
             * {
             *    return;
             * }*/
            PaletteButton active = pDesktop.Tools.Active;

            if (active != null)
            {
                if (active.IsArrow & (active.ReflectionType != null))
                {
                    try
                    {
                        ICategoryArrow arrow = pDesktop.Tools.Factory.CreateArrow(active);
                        arrow.Source               = label.Object;
                        pDesktop.ActiveArrow       = arrow;
                        pDesktop.ActiveObjectLabel = label;
                        return;
                    }
                    catch (Exception ex)
                    {
                        ex.ShowError(10);
                        return;
                    }
                }
            }
            IsMoved = true;
            pDesktop.SetBlocking(true);
            mouseX = e.X;
            mouseY = e.Y;
        }
Exemple #13
0
        /// <summary>
        /// Adds arrow with existing source and target
        /// </summary>
        /// <param name="arrow">Arrow</param>
        /// <param name="source">Source</param>
        /// <param name="target">Target</param>
        /// <param name="name">Arrow name</param>
        /// <param name="kind">Arrow kind</param>
        /// <returns>Added arrow</returns>
        public IArrowLabel AddArrowWithExistingLabels(ICategoryArrow arrow,
                                                      IObjectLabel source, IObjectLabel target, string name, string kind)
        {
            source.Object.Object = source;
            target.Object.Object = target;
            IArrowLabel arrowLabel = new PureArrowLabelPeer(name, kind, arrow.GetType().FullName, 0, 0);

            arrowLabel.Desktop = this;
            arrowLabel.Arrow   = arrow;
            arrow.Object       = arrowLabel;
            arrowLabel.Source  = source;
            arrowLabel.Target  = target;
            arrowLabel.Arrow   = arrow;
            arrow.Source       = source.Object;
            arrow.Target       = target.Object;
            arrows.Add(arrowLabel);
            return(arrowLabel);
        }
Exemple #14
0
 public override object CreateForm(INamedComponent component)
 {
     if (component is IArrowLabel)
     {
         IArrowLabel    lab   = component as IArrowLabel;
         ICategoryArrow arrow = lab.Arrow;
     }
     if (component is IObjectLabel)
     {
         IObjectLabel lab = component as IObjectLabel;
         // The object of component
         ICategoryObject obj = lab.Object;
         if (obj is Services.MeteoService)
         {
             return(new Forms.FormMeteo(obj));
         }
     }
     return(null);
 }
Exemple #15
0
 public override object CreateForm(INamedComponent comp)
 {
     if (comp is IArrowLabel)
     {
         IArrowLabel    lab   = comp as IArrowLabel;
         ICategoryArrow arrow = lab.Arrow;
     }
     if (comp is IObjectLabel)
     {
         IObjectLabel lab = comp as IObjectLabel;
         // The object of component
         ICategoryObject obj = lab.Object;
         if (obj is ControlSystems.Data.RationalTransformControlSystemData)
         {
             return(CreateControlSystemForm(lab));
         }
     }
     return(null);
 }
Exemple #16
0
        /// <summary>
        /// The on mouse down event handler
        /// </summary>
        /// <param name="sender">The sender</param>
        /// <param name="e">The event arguments</param>
        protected void onMouseDownMoveEventHandler(object sender, MouseEventArgs e)
        {
            if ((ModifierKeys & Keys.Shift) == Keys.Shift)
            {
                return;
            }
            if (!StaticExtensionDiagramUIForms.IsArrowClick(e))
            {
                return;
            }
            if (EditorRectangle.Contains(e.X, e.Y))
            {
                return;
            }
            PaletteButton active = Desktop.Tools.Active;

            if (active != null)
            {
                if (active.IsArrow & active.ReflectionType != null)
                {
                    try
                    {
                        ICategoryArrow arrow = Desktop.Tools.Factory.CreateArrow(active);
                        arrow.Source              = Object;
                        Desktop.ActiveArrow       = arrow;
                        Desktop.ActiveObjectLabel = this;
                        return;
                    }
                    catch (Exception ex)
                    {
                        ex.ShowError(10);
                        return;
                    }
                }
            }
            isMoved         = true;
            Desktop.IsMoved = true;
            Desktop.SetBlocking(true);
            mouseX = e.X;
            mouseY = e.Y;
        }
Exemple #17
0
 /// <summary>
 /// Removes itself
 /// </summary>
 /// <param name="removeForm">The "should remove properties editor" flag</param>
 public void Remove(bool removeForm)
 {
     if (Desktop == null)
     {
         return;
     }
     Desktop.Tools.RemoveArrowNode(this);
     RemoveFromComponent();
     pair.Remove(this);
     pair.Refresh();
     if (removeForm)
     {
         RemoveForm();
     }
     if (Arrow is IRemovableObject)
     {
         IRemovableObject obj = Arrow as IRemovableObject;
         obj.RemoveObject();
     }
     arrow = null;
     GC.Collect();
 }
Exemple #18
0
        public override void CheckOrder(IDesktop desktop)
        {
            Control desk = desktop as Control;

            foreach (Control c in desk.Controls)
            {
                if (!(c is ArrowLabel))
                {
                    continue;
                }
                ArrowLabel     l = c as ArrowLabel;
                ICategoryArrow a = l.Arrow;
                if (!(a is DataLink))
                {
                    continue;
                }
                if (l.Source.Root.Ord < l.Target.Root.Ord)
                {
                    a.Throw(new Exception(DataLink.SetProviderBefore));
                }
            }
        }
Exemple #19
0
 private void buttonUpdate_Click(object sender, System.EventArgs e)
 {
     try
     {
         if (component is IObjectLabel)
         {
             IObjectLabel    lab = component as IObjectLabel;
             ICategoryObject obj = lab.Object;
             if (obj is IUpdatableObject)
             {
                 IUpdatableObject updatable = obj as IUpdatableObject;
                 if (updatable.Update != null)
                 {
                     updatable.Update();
                 }
             }
         }
         else if (component is IArrowLabel)
         {
             IArrowLabel    lab   = component as IArrowLabel;
             ICategoryArrow arrow = lab.Arrow;
             if (arrow is IUpdatableObject)
             {
                 IUpdatableObject updatable = arrow as IUpdatableObject;
                 if (updatable.Update != null)
                 {
                     updatable.Update();
                 }
             }
         }
     }
     catch (Exception ex)
     {
         ex.ShowError(10);
     }
 }
Exemple #20
0
 /// <summary>
 /// Creates an arrow the corresponds to button
 /// </summary>
 /// <param name="button">The button</param>
 /// <returns>Created arrow</returns>
 public virtual ICategoryArrow CreateArrow(IPaletteButton button)
 {
     foreach (IUIFactory f in factories)
     {
         ICategoryArrow a = f.CreateArrow(button);
         if (a != null)
         {
             return(a);
         }
     }
     if (defaultValue)
     {
         Type t = button.ReflectionType;
         if (t != null)
         {
             ConstructorInfo cons = t.GetConstructor(new System.Type[0]);
             if (cons != null)
             {
                 return(cons.Invoke(null) as ICategoryArrow);
             }
         }
     }
     return(null);
 }
Exemple #21
0
        /// <summary>
        /// Gets image of arrow
        /// </summary>
        /// <param name="arrow">The arrow</param>
        /// <returns>The image</returns>
        public static Image GetImage(ICategoryArrow arrow)
        {
            INamedComponent c = arrow.Object as INamedComponent;

            return(GetImage(c));
        }
 IArrowLabelUI IDefaultLabelFactory.CreateArrowLabel(IPaletteButton button, ICategoryArrow arrow, IObjectLabel source, IObjectLabel target)
 {
     return(new ArrowLabel(button, arrow, source, target));
 }
Exemple #23
0
        private void MouseUp(object sender, MouseEventArgs e)
        {
            Control caption = sender as Control;

            IsMoved = false;
            pDesktop.SetBlocking(false);
            PanelDesktop   Desktop = pDesktop;
            ICategoryArrow arrow   = Desktop.ActiveArrow;

            if (!StaticExtensionDiagramUIForms.IsArrowClick(e))
            {
                return;
            }
            try
            {
                if (arrow == null)
                {
                    pDesktop.Redraw();
                    return;
                }
                int x = this.label.X + caption.Left + e.X;
                int y = this.label.Y + caption.Top + e.Y;
                for (int i = 0; i < Desktop.Controls.Count; i++)
                {
                    if (!(Desktop.Controls[i] is IChildObjectLabel) & !(Desktop.Controls[i] is IObjectLabelUI))
                    {
                        continue;
                    }
                    Control c = Desktop.Controls[i];
                    bool    hor = x <c.Left | x> c.Left + c.Width;
                    bool    vert = y <c.Top | y> c.Top + c.Height;
                    if (hor | vert)
                    {
                        continue;
                    }
                    IObjectLabel label = null;
                    if (Desktop.Controls[i] is IObjectLabelUI)
                    {
                        label = Desktop.Controls[i] as IObjectLabel;
                    }
                    else
                    {
                        IChildObjectLabel child = Desktop.Controls[i] as IChildObjectLabel;
                        label = child.Label;
                    }

                    arrow.Target = label.Object;
                    IArrowLabel lab = Desktop.Tools.Factory.CreateArrowLabel(Desktop.Tools.Active, arrow, this.label, label);
                    lab.Arrow.SetAssociatedObject(lab);
                    Desktop.AddArrowLabel(lab);
                    break;
                }
            }
            catch (Exception ex)
            {
                ex.ShowError(10);
                if (arrow != null)
                {
                    if (arrow is IRemovableObject)
                    {
                        IRemovableObject rem = arrow as IRemovableObject;
                        rem.RemoveObject();
                    }
                }
                ex.ShowError(1);
            }
            Desktop.ActiveArrow = null;
            Desktop.Redraw();
        }
Exemple #24
0
 /// <summary>
 /// Creates arrow label
 /// </summary>
 /// <param name="button">Corresponding button</param>
 /// <param name="arrow">Corresponding arrow</param>
 /// <param name="source">Soource label</param>
 /// <param name="target">Target label</param>
 /// <returns>The arrow label</returns>
 public virtual IArrowLabelUI CreateArrowLabel(IPaletteButton button, ICategoryArrow arrow, IObjectLabel source, IObjectLabel target)
 {
     return(null);
 }
Exemple #25
0
 /// <summary>
 /// Crerates arrow label from arrow
 /// </summary>
 /// <param name="arr">The arrow</param>
 /// <returns>The label</returns>
 public virtual IArrowLabelUI CreateLabel(ICategoryArrow arr)
 {
     return(null);
 }
Exemple #26
0
 /// <summary>
 /// Gets button from arrow
 /// </summary>
 /// <param name="arrow">The arrow</param>
 /// <returns>The arrow</returns>
 public virtual IPaletteButton GetArrowButton(ICategoryArrow arrow)
 {
     return(null);
 }
Exemple #27
0
        /// <summary>
        /// The on mouse up event handler
        /// </summary>
        /// <param name="sender">The sender</param>
        /// <param name="e">The event arguments</param>
        protected void onMouseUpMoveEventHandler(object sender, MouseEventArgs e)
        {
            isMoved         = false;
            Desktop.IsMoved = false;
            Desktop.SetBlocking(false);
            ICategoryArrow arrow = Desktop.ActiveArrow;

            if (!e.IsArrowClick())
            {
                return;
            }
            try
            {
                if (arrow == null)
                {
                    Desktop.Redraw();
                    return;
                }
                int x = Left + e.X;
                int y = Top + e.Y;
                for (int i = 0; i < Desktop.Controls.Count; i++)
                {
                    if (!(Desktop.Controls[i] is IChildObjectLabel) & !(Desktop.Controls[i] is IObjectLabel))
                    {
                        continue;
                    }
                    Control c = Desktop.Controls[i];
                    bool    hor = x <c.Left | x> c.Left + c.Width;
                    bool    vert = y <c.Top | y> c.Top + c.Height;
                    if (hor | vert)
                    {
                        continue;
                    }
                    IObjectLabel label = null;
                    if (Desktop.Controls[i] is IObjectLabel)
                    {
                        label = Desktop.Controls[i] as IObjectLabel;
                    }
                    else
                    {
                        IChildObjectLabel child = Desktop.Controls[i] as IChildObjectLabel;
                        label = child.Label;
                    }

                    arrow.Target = label.Object;
                    IArrowLabel lab = Desktop.Tools.Factory.CreateArrowLabel(Desktop.Tools.Active, arrow, this, label);
                    lab.Arrow.SetAssociatedObject(lab);
                    Desktop.AddArrowLabel(lab);
                    break;
                }
            }
            catch (Exception ex)
            {
                ex.ShowError(10);
                if (arrow != null)
                {
                    if (arrow is IRemovableObject)
                    {
                        IRemovableObject rem = arrow as IRemovableObject;
                        rem.RemoveObject();
                    }
                }
                ex.ShowError(1);;
            }
            Desktop.ActiveArrow = null;
            Desktop.Redraw();
        }
Exemple #28
0
        /// <summary>
        /// The on mouse up event handler
        /// </summary>
        /// <param name="sender">The sender</param>
        /// <param name="e">The event arguments</param>
        protected void onMouseUpArrow(object sender, MouseEventArgs e)
        {
            //isMoved = false;
            PanelDesktop   desktop = Parent as PanelDesktop;
            ICategoryArrow arrow   = desktop.ActiveArrow;

            if (!StaticExtensionDiagramUIForms.IsArrowClick(e))
            {
                return;
            }
            if (!(nc is IObjectLabel))
            {
                return;
            }
            IObjectLabel    ol  = nc as IObjectLabel;
            ICategoryObject obj = ol.Object;

            try
            {
                if (arrow == null)
                {
                    return;
                }
                int x = Left + e.X;
                int y = Top + e.Y;
                for (int i = 0; i < desktop.Controls.Count; i++)
                {
                    if (!(desktop.Controls[i] is ChildObjectLabel) & !(desktop.Controls[i] is ObjectLabel))
                    {
                        continue;
                    }
                    Control c = desktop.Controls[i];
                    bool    hor = x <c.Left | x> c.Left + c.Width;
                    bool    vert = y <c.Top | y> c.Top + c.Height;
                    if (hor | vert)
                    {
                        continue;
                    }
                    IObjectLabel label = null;
                    if (desktop.Controls[i] is IObjectLabel)
                    {
                        label = desktop.Controls[i] as IObjectLabel;
                    }
                    else
                    {
                        ChildObjectLabel child = desktop.Controls[i] as ChildObjectLabel;
                        label = child.Label;
                    }
                    arrow.Target = label.Object;
                    ArrowLabel lab =
                        desktop.Tools.Factory.CreateArrowLabel(desktop.Tools.Active,
                                                               arrow, ol, label) as ArrowLabel;
                    lab.Arrow.Object = lab;
                    desktop.AddArrowLabel(lab);
                    break;
                }
            }
            catch (Exception ex)
            {
                ex.ShowError(10);
                if (arrow != null)
                {
                    if (arrow is IRemovableObject)
                    {
                        IRemovableObject rem = arrow as IRemovableObject;
                        rem.RemoveObject();
                    }
                }
                ex.ShowError(1);
            }
            desktop.ActiveArrow = null;
            desktop.Redraw();
        }
Exemple #29
0
 /// <summary>
 /// Deserialization constructor
 /// </summary>
 /// <param name="info">Serialization info</param>
 /// <param name="context">Streaming context</param>
 public ArrowLabel(SerializationInfo info, StreamingContext context) : base(info, context)
 {
     arrow        = (ICategoryArrow)info.GetValue("Arrow", typeof(object));
     sourceNumber = (int)info.GetValue("SourceNumber", typeof(int));
     targetNumber = (int)info.GetValue("TargetNumber", typeof(int));
 }
Exemple #30
0
        /*public XmlElement CreateXml(XmlDocument doc)
         * {
         *  XmlElement el = doc.CreateElement("SwitchLink");
         *  return el;
         * }*/



        /// <summary>
        /// Composes this arrow "f" with next arrow "g"
        /// </summary>
        /// <param name="category"> The category of arrow</param>
        /// <param name="next"> The next arrow "g" </param>
        /// <returns>Composition "fg" </returns>
        public ICategoryArrow Compose(ICategory category, ICategoryArrow next)
        {
            return(null);
        }