Esempio n. 1
0
 public MouseElements(MouseElements prototype)
 {
     MouseStartElement  = prototype.MouseStartElement;
     MouseMoveElement   = prototype.MouseMoveElement;
     MouseStartOrigin   = prototype.MouseStartOrigin;
     InteractiveElement = prototype.InteractiveElement;
     InteractiveOrigin  = prototype.InteractiveOrigin;
 }
Esempio n. 2
0
        //Determine if an element can dock
        public virtual bool CanDock(InteractiveMode interactiveMode, MouseElements mouseElements)
        {
            if (interactiveMode == InteractiveMode.Normal)
            {
                //Check is shape or port
                if (mouseElements.MouseMoveElement is Shape || mouseElements.MouseMoveElement is Port)
                {
                    //return false if permission not available to dock
                    if (mouseElements.MouseStartOrigin != null)
                    {
                        Origin origin = mouseElements.MouseStartOrigin;
                        Link   line   = (Link)mouseElements.MouseStartElement;

                        if (mouseElements.MouseMoveElement is Shape)
                        {
                            Shape shape = (Shape)mouseElements.MouseMoveElement;
                            if (shape.Direction == Direction.None)
                            {
                                return(false);
                            }
                            if (origin == line.Start && shape.Direction == Direction.In)
                            {
                                return(false);
                            }
                            if (origin == line.End && shape.Direction == Direction.Out)
                            {
                                return(false);
                            }
                        }

                        if (mouseElements.MouseMoveElement is Port)
                        {
                            Port port = (Port)mouseElements.MouseMoveElement;
                            if (port.Direction == Direction.None)
                            {
                                return(false);
                            }
                            if (origin == line.Start && port.Direction == Direction.In)
                            {
                                return(false);
                            }
                            if (origin == line.End && port.Direction == Direction.Out)
                            {
                                return(false);
                            }
                        }
                    }


                    return(true);
                }
            }
            //Can dock for interactive elements
            else
            {
                if (mouseElements.InteractiveElement is Link)
                {
                    Link line = (Link)mouseElements.InteractiveElement;

                    //Determine if applies to start or end origin
                    if (mouseElements.InteractiveOrigin == line.Start)
                    {
                        if (mouseElements.MouseMoveElement is Shape)
                        {
                            Shape shape = (Shape)mouseElements.MouseMoveElement;
                            if (shape.Direction == Direction.None)
                            {
                                return(false);
                            }
                            if (shape.Direction == Direction.In)
                            {
                                return(false);
                            }
                        }

                        if (mouseElements.MouseMoveElement is Port)
                        {
                            Port port = (Port)mouseElements.MouseMoveElement;
                            if (port.Direction == Direction.None)
                            {
                                return(false);
                            }
                            if (port.Direction == Direction.In)
                            {
                                return(false);
                            }
                        }
                    }
                    else
                    {
                        if (mouseElements.MouseMoveElement is Shape)
                        {
                            Shape shape = (Shape)mouseElements.MouseMoveElement;
                            if (shape.Direction == Direction.None)
                            {
                                return(false);
                            }
                            if (shape.Direction == Direction.Out)
                            {
                                return(false);
                            }
                        }

                        if (mouseElements.MouseMoveElement is Port)
                        {
                            Port port = (Port)mouseElements.MouseMoveElement;
                            if (port.Direction == Direction.None)
                            {
                                return(false);
                            }
                            if (port.Direction == Direction.Out)
                            {
                                return(false);
                            }
                        }
                    }

                    return(true);
                }
            }

            return(false);
        }
Esempio n. 3
0
        //Methods
        public virtual void Scale()
        {
            float sx = 1; //scale
            float sy = 1;
            float mx = 0; //movement as a result of scale
            float my = 0;

            foreach (Element element in Elements)
            {
                if (element.Visible)
                {
                    //Scale shapes
                    if (element is Shape)
                    {
                        Shape shape       = element as Shape;             //a clone of the original shape, contained in the list
                        Shape actionshape = shape.ActionElement as Shape; //the actual shape being moved

                        if (actionshape.AllowScale)
                        {
                            if (Controller.Model.Route != null)
                            {
                                Controller.Model.Route.Reform();
                            }

                            PointF saveLocation = shape.Location;
                            SizeF  saveSize     = shape.Size;

                            //Reset the ports
                            foreach (Port port in shape.Ports.Values)
                            {
                                Port actionPort = (Port)actionshape.Ports[port.Key];
                                port.SuspendValidation();
                                port.Location = actionPort.Location;
                                port.ResumeValidation();
                            }

                            //Reset shape location and size
                            shape.Location = actionshape.Location;                          //reset location
                            shape.SetSize(actionshape.Size, actionshape.InternalRectangle); //reset to original size

                            //Reset children of a complex shape
                            if (shape is ComplexShape)
                            {
                                ComplexShape complex = (ComplexShape)shape;

                                foreach (Solid solid in complex.Children.Values)
                                {
                                    Solid actionSolid = (Solid)solid.ActionElement;

                                    solid.Location = actionSolid.Location;                          //reset location
                                    solid.SetSize(actionSolid.Size, actionSolid.InternalRectangle); //reset to original size
                                }
                            }

                            //Scale Right x
                            if (MouseElements.MouseHandle.Type == HandleType.TopRight || MouseElements.MouseHandle.Type == HandleType.Right || MouseElements.MouseHandle.Type == HandleType.BottomRight)
                            {
                                sx = ((Dx) / shape.ActionElement.Bounds.Width) + 1;
                            }
                            //Scale Bottom y
                            if (MouseElements.MouseHandle.Type == HandleType.BottomLeft || MouseElements.MouseHandle.Type == HandleType.Bottom || MouseElements.MouseHandle.Type == HandleType.BottomRight)
                            {
                                sy = ((Dy) / shape.ActionElement.Bounds.Height) + 1;
                            }
                            //Scale Left x
                            if (MouseElements.MouseHandle.Type == HandleType.TopLeft || MouseElements.MouseHandle.Type == HandleType.Left || MouseElements.MouseHandle.Type == HandleType.BottomLeft)
                            {
                                sx = ((-Dx) / shape.ActionElement.Bounds.Width) + 1;
                                mx = Dx;
                                if (shape.Bounds.Width * sx < shape.MinimumSize.Width)
                                {
                                    mx = (shape.ActionElement.Bounds.Width - shape.MinimumSize.Width);
                                }
                                if (shape.Bounds.Width * sx > shape.MaximumSize.Width)
                                {
                                    mx = (shape.ActionElement.Bounds.Width - shape.MaximumSize.Width);
                                }
                            }
                            //Scale Top y
                            if (MouseElements.MouseHandle.Type == HandleType.TopLeft || MouseElements.MouseHandle.Type == HandleType.Top || MouseElements.MouseHandle.Type == HandleType.TopRight)
                            {
                                sy = ((-Dy) / shape.ActionElement.Bounds.Height) + 1;
                                my = Dy;
                                if (shape.Bounds.Height * sy < shape.MinimumSize.Height)
                                {
                                    my = (shape.ActionElement.Bounds.Height - shape.MinimumSize.Height);
                                }
                                if (shape.Bounds.Height * sy > shape.MaximumSize.Height)
                                {
                                    my = (shape.ActionElement.Bounds.Height - shape.MaximumSize.Height);
                                }
                            }

                            shape.Scale(sx, sy, mx, my, KeepAspect || shape.KeepAspect);

                            //Restore shape bounds if not correct
                            if (!Controller.BoundsCheck(shape.Location, 0, 0))
                            {
                                shape.Location = saveLocation;
                                shape.Size     = saveSize;
                            }
                        }
                    }

                    //Move line origins
                    if (element is Link)
                    {
                        if (element is ComplexLine)
                        {
                            ComplexLine line       = (ComplexLine)element;
                            ComplexLine actionline = (ComplexLine)line.ActionElement;
                            Segment     segment;
                            Segment     actionSegment;

                            if (MouseElements.MouseHandle.Type == HandleType.Origin)
                            {
                                for (int i2 = 0; i2 < line.Segments.Count; i2++)
                                {
                                    segment       = line.Segments[i2];
                                    actionSegment = actionline.Segments[i2];

                                    if (actionSegment.Start == MouseElements.MouseStartOrigin)
                                    {
                                        if (Controller.BoundsCheck(actionSegment.Start.Location, Dx, Dy))
                                        {
                                            segment.Start.Location = (PointF)actionline.Points[i2]; //Resets the location
                                            segment.Start.Move(Dx, Dy);
                                            line.DrawPath();
                                        }
                                        break;
                                    }

                                    if (actionSegment.End == MouseElements.MouseStartOrigin)
                                    {
                                        if (Controller.BoundsCheck(actionSegment.End.Location, Dx, Dy))
                                        {
                                            segment.End.Location = (PointF)actionline.Points[i2 + 1]; //Resets the location
                                            segment.End.Move(Dx, Dy);
                                            line.DrawPath();
                                        }
                                        break;
                                    }
                                }
                            }

                            //Add the segment and reset the handle to an origin handle
                            if (MouseElements.MouseHandle.Type == HandleType.Expand)
                            {
                                //Find the segment
                                ExpandHandle expand = MouseElements.MouseHandle as ExpandHandle;

                                //Get origin locations
                                PointF start = line.GetOriginLocation(expand.Segment.Start, expand.Segment.End);
                                PointF end   = line.GetOriginLocation(expand.Segment.End, expand.Segment.Start);

                                Origin origin       = new Origin(new PointF(start.X + ((end.X - start.X) / 2), start.Y + ((end.Y - start.Y) / 2)));
                                Origin actionOrigin = new Origin(new PointF(origin.Location.X, origin.Location.Y));

                                line.AddSegment(expand.Index + 1, origin);
                                actionline.AddSegment(expand.Index + 1, actionOrigin);

                                MouseElements.MouseHandle = new Handle(HandleType.Origin);

                                //Set up mouse elements
                                MouseElements = new MouseElements(MouseElements);
                                MouseElements.MouseStartOrigin = actionOrigin;
                                //diagram.SetMouseElements(mouseElements);
                            }
                        }
                        else if (element is Connector)
                        {
                            Connector line       = element as Connector;
                            Connector actionLine = element.ActionElement as Connector;

                            //Move start or end of connector
                            if (MouseElements.MouseHandle.Type == HandleType.Origin)
                            {
                                Origin origin = null;
                                PointF point  = new PointF();

                                //Get the origin point
                                if (actionLine.Start == MouseElements.MouseStartOrigin && actionLine.Start.AllowMove)
                                {
                                    origin = line.Start;
                                    point  = (PointF)actionLine.Points[0];
                                }
                                if (actionLine.End == MouseElements.MouseStartOrigin && actionLine.End.AllowMove)
                                {
                                    origin = line.End;
                                    point  = (PointF)actionLine.Points[actionLine.Points.Count - 1];
                                }

                                if (origin != null)
                                {
                                    if (Controller.BoundsCheck(point, Dx, Dy))
                                    {
                                        //Offset the origin point
                                        origin.Location = new PointF(point.X + Dx, point.Y + Dy);

                                        //Set to shape if current mouse element is shape
                                        if (MouseElements.IsDockable() && Controller.CanDock(InteractiveMode, MouseElements))
                                        {
                                            if (MouseElements.MouseMoveElement is Shape)
                                            {
                                                origin.Shape = MouseElements.MouseMoveElement as Shape;
                                            }
                                            else if (MouseElements.MouseMoveElement is Port)
                                            {
                                                origin.Port = MouseElements.MouseMoveElement as Port;
                                            }
                                        }

                                        line.CalculateRoute();
                                    }
                                }
                            }
                            //Move a connector segment
                            else if (MouseElements.MouseHandle.Type == HandleType.UpDown || MouseElements.MouseHandle.Type == HandleType.LeftRight)
                            {
                                ConnectorHandle handle = MouseElements.MouseHandle as ConnectorHandle;

                                if (handle != null)
                                {
                                    PointF start = (PointF)actionLine.Points[handle.Index - 1];
                                    PointF end   = (PointF)actionLine.Points[handle.Index];

                                    //Move the two segment points and place them back in the correct place
                                    if (MouseElements.MouseHandle.Type == HandleType.UpDown)
                                    {
                                        if (Controller.BoundsCheck(start, 0, Dy) && Controller.BoundsCheck(end, 0, Dy))
                                        {
                                            start.Y += Dy;
                                            end.Y   += Dy;

                                            //Update the line
                                            line.Points[handle.Index - 1] = start;
                                            line.Points[handle.Index]     = end;
                                        }
                                    }
                                    else if (MouseElements.MouseHandle.Type == HandleType.LeftRight)
                                    {
                                        if (Controller.BoundsCheck(end, Dx, 0) && Controller.BoundsCheck(end, Dx, 0))
                                        {
                                            start.X += Dx;
                                            end.X   += Dx;

                                            //Update the line
                                            line.Points[handle.Index - 1] = start;
                                            line.Points[handle.Index]     = end;
                                        }
                                    }
                                }
                            }
                        }
                        else if (element is Curve)
                        {
                            Curve curve       = (Curve)element;
                            Curve actionCurve = (Curve)curve.ActionElement;

                            if (MouseElements.MouseStartOrigin == actionCurve.Start && actionCurve.Start.AllowMove)
                            {
                                if (Controller.BoundsCheck(actionCurve.FirstPoint, Dx, Dy))
                                {
                                    curve.Start.Location = actionCurve.FirstPoint; //Resets the location
                                    curve.Start.Move(Dx, Dy);
                                }
                            }
                            else if (MouseElements.MouseStartOrigin == actionCurve.End && actionCurve.End.AllowMove)
                            {
                                if (Controller.BoundsCheck(actionCurve.LastPoint, Dx, Dy))
                                {
                                    curve.End.Location = actionCurve.LastPoint; //Resets the location
                                    curve.End.Move(Dx, Dy);
                                }
                            }
                            else
                            {
                                //Move control points
                                int index = 0;
                                foreach (PointF point in actionCurve.ControlPoints)
                                {
                                    PointF location = new PointF(point.X - actionCurve.Bounds.X, point.Y - actionCurve.Bounds.Y);

                                    if (MouseElements.MouseHandle != null && MouseElements.MouseHandle.Path != null && MouseElements.MouseHandle.Path.IsVisible(location))
                                    {
                                        curve.ControlPoints[index] = new PointF(actionCurve.ControlPoints[index].X + Dx, actionCurve.ControlPoints[index].Y + Dy);
                                        break;
                                    }
                                    index++;
                                }
                            }
                        }
                        else if (element is Link)
                        {
                            Link line       = (Link)element;
                            Link actionline = (Link)line.ActionElement;

                            if (MouseElements.MouseStartOrigin == actionline.Start && actionline.Start.AllowMove)
                            {
                                if (Controller.BoundsCheck(actionline.FirstPoint, Dx, Dy))
                                {
                                    line.Start.Location = actionline.FirstPoint; //Resets the location
                                    line.Start.Move(Dx, Dy);
                                }
                            }
                            if (MouseElements.MouseStartOrigin == actionline.End && actionline.End.AllowMove)
                            {
                                if (Controller.BoundsCheck(actionline.LastPoint, Dx, Dy))
                                {
                                    line.End.Location = actionline.LastPoint; //Resets the location
                                    line.End.Move(Dx, Dy);
                                }
                            }
                        }

                        //Update docking
                        if (MouseElements.MouseMoveElement != null && MouseElements.IsDockable() && Controller.CanDock(InteractiveMode, MouseElements))
                        {
                            Link line       = (Link)element;
                            Link actionline = (Link)line.ActionElement;

                            if (MouseElements.MouseMoveElement is Shape)
                            {
                                if (MouseElements.MouseStartOrigin == actionline.Start && actionline.Start.AllowMove)
                                {
                                    line.Start.Shape = MouseElements.MouseMoveElement as Shape;
                                }
                                if (MouseElements.MouseStartOrigin == actionline.End && actionline.End.AllowMove)
                                {
                                    line.End.Shape = MouseElements.MouseMoveElement as Shape;
                                }
                            }
                            else if (MouseElements.MouseMoveElement is Port)
                            {
                                if (MouseElements.MouseStartOrigin == actionline.Start && actionline.Start.AllowMove)
                                {
                                    line.Start.Port = MouseElements.MouseMoveElement as Port;
                                }
                                if (MouseElements.MouseStartOrigin == actionline.End && actionline.End.AllowMove)
                                {
                                    line.End.Port = MouseElements.MouseMoveElement as Port;
                                }
                            }
                        }

                        Link clone = element as Link;
                        clone.DrawPath(); //Update the action path
                    }
                }
            }
        }
Esempio n. 4
0
        public override void Execute()
        {
            if (Elements == null)
            {
                return;
            }

            MouseElements mouseElements = MouseElements;

            foreach (Element element in Elements)
            {
                if (element.Visible)
                {
                    if (element.ActionElement == null)
                    {
                        throw new ComponentException("Element action may not be null.");
                    }
                    if (element is Shape)
                    {
                        Shape shape       = (Shape)element;
                        Shape actionShape = (Shape)element.ActionElement;

                        //Round values if appropriate
                        if (Controller.RoundPixels)
                        {
                            shape.Location = Point.Round(shape.Location);
                            shape.Size     = System.Drawing.Size.Round(shape.Size);
                        }

                        //Move and scale. Shape size property does not check equality
                        if (!actionShape.Location.Equals(shape.Location))
                        {
                            actionShape.Location = shape.Location;                                               //new PointF(shape.X,shape.Y);
                        }
                        if (!actionShape.Size.Equals(shape.Size))
                        {
                            actionShape.Size = shape.Size;
                        }

                        //Update children of a complex shape
                        if (shape is ComplexShape)
                        {
                            ComplexShape complex = (ComplexShape)shape;

                            foreach (Solid solid in complex.Children.Values)
                            {
                                Solid actionSolid = (Solid)solid.ActionElement;
                                actionSolid.SetPath(solid.GetPath());
                                actionSolid.SetRectangle(solid.Location);
                                actionSolid.SetTransformRectangle(solid.Location);
                            }
                        }
                    }

                    //Update rotation
                    if (element is ITransformable)
                    {
                        ITransformable transform       = element as ITransformable;
                        ITransformable actionTransform = element.ActionElement as ITransformable;

                        if (actionTransform.Rotation != transform.Rotation)
                        {
                            actionTransform.Rotation = transform.Rotation;
                        }
                    }

                    if (element is Port)
                    {
                        Port port       = (Port)element;
                        Port actionPort = (Port)element.ActionElement;

                        //Move and scale. Port size property does not check equality
                        if (!actionPort.Location.Equals(port.Location))
                        {
                            actionPort.Location = port.Location;                                             //new PointF(port.X,port.Y);
                        }
                        //Update the port percentage
                        IPortContainer ports = (IPortContainer)actionPort.Parent;
                        ports.GetPortPercentage(actionPort, actionPort.Location);
                    }

                    //Update the locations of the line origins
                    if (element is Link)
                    {
                        Link clone = (Link)element;

                        //Undock any origins
                        if (mouseElements.MouseStartOrigin != null && mouseElements.MouseStartOrigin.Docked && mouseElements.MouseStartOrigin.AllowMove)
                        {
                            Origin origin = mouseElements.MouseStartOrigin;
                            if (origin == origin.Parent.Start)
                            {
                                origin.Location = origin.Parent.FirstPoint;
                            }
                            if (origin == origin.Parent.End)
                            {
                                origin.Location = origin.Parent.LastPoint;
                            }
                        }

                        if (element is ComplexLine)
                        {
                            ComplexLine complexLine   = (ComplexLine)element;
                            ComplexLine actionLine    = (ComplexLine)element.ActionElement;
                            Segment     segment       = null;
                            Segment     actionSegment = null;

                            for (int i = 0; i < complexLine.Segments.Count; i++)
                            {
                                segment       = complexLine.Segments[i];
                                actionSegment = actionLine.Segments[i];
                                if (!actionSegment.Start.Docked)
                                {
                                    actionSegment.Start.Location = segment.Start.Location;
                                }
                            }

                            //Update end of last segment
                            if (segment != null && actionSegment != null && !actionSegment.End.Docked)
                            {
                                actionSegment.End.Location = segment.End.Location;
                            }

                            actionLine.DrawPath();
                            actionLine.LocatePorts();
                        }
                        else if (element is Curve)
                        {
                            Curve curve       = (Curve)element;
                            Curve actionCurve = (Curve)element.ActionElement;

                            if (!actionCurve.Start.Docked)
                            {
                                actionCurve.Start.Location = curve.Start.Location;
                            }
                            if (!actionCurve.End.Docked)
                            {
                                actionCurve.End.Location = curve.End.Location;
                            }

                            actionCurve.ControlPoints = curve.ControlPoints;
                            actionCurve.DrawPath();
                            actionCurve.LocatePorts();
                        }
                        else if (element is Connector)
                        {
                            //Update connector oblong handle
                            if (mouseElements.MouseHandle.Type == HandleType.UpDown || mouseElements.MouseHandle.Type == HandleType.LeftRight)
                            {
                                Connector connectorLine = element as Connector;
                                Connector actionLine    = element.ActionElement as Connector;

                                //Get the two points of the segment
                                ConnectorHandle handle = mouseElements.MouseHandle as ConnectorHandle;
                                if (handle != null)
                                {
                                    actionLine.Points[handle.Index - 1] = (PointF)connectorLine.Points[handle.Index - 1];
                                    actionLine.Points[handle.Index]     = (PointF)connectorLine.Points[handle.Index];
                                    actionLine.RefinePoints();
                                    actionLine.DrawPath();
                                    actionLine.LocatePorts();
                                    actionLine.CreateHandles();
                                }
                            }
                            //Update start or end of connector
                            else if (mouseElements.MouseHandle.Type == HandleType.Origin)
                            {
                                Connector connectorLine = element as Connector;
                                Connector actionLine    = element.ActionElement as Connector;

                                actionLine.SetPoints(connectorLine.Points);
                                actionLine.RefinePoints();

                                //Set origins
                                if (!actionLine.Start.Docked)
                                {
                                    actionLine.Start.Location = connectorLine.FirstPoint;
                                }
                                if (!actionLine.End.Docked)
                                {
                                    actionLine.End.Location = connectorLine.LastPoint;
                                }

                                actionLine.GetPortPercentages();
                                actionLine.DrawPath();
                                actionLine.LocatePorts();
                            }
                            //Move all points if connector is not connected
                            else if (mouseElements.MouseHandle.Type == HandleType.Move)
                            {
                                Connector connectorLine = element as Connector;
                                Connector actionLine    = element.ActionElement as Connector;

                                if (actionLine.AllowMove && !actionLine.Start.Docked && !actionLine.End.Docked)
                                {
                                    actionLine.Points.Clear();

                                    foreach (PointF point in connectorLine.Points)
                                    {
                                        actionLine.Points.Add(point);
                                    }

                                    actionLine.DrawPath();
                                    actionLine.LocatePorts();
                                }
                            }
                        }
                        else
                        {
                            Link line       = (Link)element;
                            Link actionLine = (Link)element.ActionElement;

                            //Round values if appropriate
                            if (Controller.RoundPixels)
                            {
                                line.Start.Location = Point.Round(line.Start.Location);
                                line.End.Location   = Point.Round(line.End.Location);
                            }

                            if (!actionLine.Start.Docked)
                            {
                                actionLine.Start.Location = line.Start.Location;
                            }
                            if (!actionLine.End.Docked)
                            {
                                actionLine.End.Location = line.End.Location;
                            }

                            actionLine.DrawPath();
                            actionLine.LocatePorts();
                        }
                    }

                    if (element is Port)
                    {
                        Port actionPort = element as Port;
                        Port port       = actionPort.ActionElement as Port;

                        port.Location = actionPort.Location;
                    }
                }
            }

            //Update the line docking
            if (mouseElements != null && mouseElements.MouseStartOrigin != null && mouseElements.MouseStartOrigin.AllowMove && mouseElements.MouseMoveElement != null && mouseElements.IsDockable() && Controller.CanDock(InteractiveMode, mouseElements))
            {
                Link line = mouseElements.MouseStartElement as Link;

                //Dock start to shape
                if (mouseElements.MouseStartOrigin == line.Start && mouseElements.MouseMoveElement is Shape)
                {
                    line.Start.Shape = mouseElements.MouseMoveElement as Shape;
                }
                //Dock end to shape
                if (mouseElements.MouseStartOrigin == line.End && mouseElements.MouseMoveElement is Shape)
                {
                    line.End.Shape = mouseElements.MouseMoveElement as Shape;
                }
                //Dock start to port
                if (mouseElements.MouseStartOrigin == line.Start && mouseElements.MouseMoveElement is Port)
                {
                    line.Start.Port = mouseElements.MouseMoveElement as Port;
                }
                //Dock end to port
                if (mouseElements.MouseStartOrigin == line.End && mouseElements.MouseMoveElement is Port)
                {
                    line.End.Port = mouseElements.MouseMoveElement as Port;
                }
            }

            Executed = true;
        }