コード例 #1
0
            public static void Postfix(ref DragTool __instance, ref Vector3 cursorPos)
            {
                if (__instance.Dragging)
                {
                    DragTool.Mode mode    = (DragTool.Mode)AccessTools.Field(typeof(DragTool), "mode").GetValue(__instance);
                    Vector3       downPos = (Vector3)AccessTools.Field(typeof(DragTool), "downPos").GetValue(__instance);

                    if (mode == DragTool.Mode.Box)
                    {
                        HoverTextConfiguration hoverText = __instance.GetComponent <HoverTextConfiguration>();

                        int index = hoverText.ToolName.IndexOf('[');

                        if (index != -1)
                        {
                            hoverText.ToolName = hoverText.ToolName.Remove(index - 1);
                        }

                        var downPosXY   = Grid.PosToXY(downPos);
                        var cursorPosXY = Grid.PosToXY(cursorPos);

                        int x = Mathf.Abs(downPosXY.X - cursorPosXY.X) + 1;
                        int y = Mathf.Abs(downPosXY.Y - cursorPosXY.Y) + 1;

                        string boxSizeInfo = $" [{x}x{y}, {x*y} tiles total]";

                        hoverText.ToolName += boxSizeInfo;
                    }
                }
            }
コード例 #2
0
            public static void Postfix(ref DragTool __instance)
            {
                if ((DragTool.Mode)Traverse.Create(__instance).Method("GetMode").GetValue() != DragTool.Mode.Box)
                {
                    return;
                }

                var sizeVector = ((SpriteRenderer)AccessTools.Field(typeof(DragTool), "areaVisualizerSpriteRenderer")
                                  .GetValue(__instance)).size;

                var visualizerText = AccessTools.Field(typeof(DragTool), "areaVisualizerText");

                if ((Guid)visualizerText.GetValue(__instance) == Guid.Empty)
                {
                    return;
                }

                var roundedSizeVector = new Vector2I(Mathf.RoundToInt(sizeVector.x), Mathf.RoundToInt(sizeVector.y));
                var text = NameDisplayScreen.Instance.GetWorldText((Guid)visualizerText.GetValue(__instance))
                           .GetComponent <LocText>();

                text.text = string.Format(
                    AreaFormat,
                    roundedSizeVector.x,
                    roundedSizeVector.y,
                    roundedSizeVector.x * roundedSizeVector.y
                    );
            }
コード例 #3
0
        /// <summary>
        /// 注册所有工具的相应部分上下文
        /// </summary>
        private void Init()
        {
            _cursor = new Dictionary <string, Cursor>();
            _cursor["Tool_Drag"]      = Cursors.Arrow;
            _cursor["Tool_Rectangle"] = Cursors.Cross;
            _cursor["Tool_Triangle"]  = Cursors.Cross;
            _cursor["Tool_Image"]     = Cursors.Cross;
            _cursor["Tool_QRCode"]    = Cursors.Cross;
            _cursor["Tool_Circle"]    = Cursors.Cross;
            _cursor["Tool_Text"]      = Cursors.IBeam;
            _cursor["Tool_Line"]      = Cursors.Cross;

            _toolType = new Dictionary <string, ToolType>();
            _toolType["Tool_Drag"]      = ToolType.Drag;
            _toolType["Tool_Rectangle"] = ToolType.Rectangle;
            _toolType["Tool_Triangle"]  = ToolType.Triangle;
            _toolType["Tool_Image"]     = ToolType.Image;
            _toolType["Tool_QRCode"]    = ToolType.QRCode;
            _toolType["Tool_Circle"]    = ToolType.Circle;
            _toolType["Tool_Text"]      = ToolType.Text;
            _toolType["Tool_Line"]      = ToolType.Line;

            _paintTool = new Dictionary <string, PaintToolBase>();
            _paintTool["Tool_Line"]      = new LineTool();
            _paintTool["Tool_Drag"]      = new DragTool();
            _paintTool["Tool_Triangle"]  = new TriangleTool();
            _paintTool["Tool_Circle"]    = new CircleTool();
            _paintTool["Tool_Rectangle"] = new RectangleTool();
            _paintTool["Tool_Image"]     = new ImageTool();
            _paintTool["Tool_Text"]      = new TextTool();
        }
コード例 #4
0
        public override ITool CreateFigureTool(IDrawingEditor editor, ITool dt)
        {
            DragTool dragTool = dt as DragTool;

            //when drag is completed update model data
            dragTool.DragCompleted += (object sender, EventArgs e) =>
            {
                this.ExperimentNode.Data.X = this.DisplayBox.X;
                this.ExperimentNode.Data.Y = this.DisplayBox.Y;
            };

            return(base.CreateFigureTool(editor, dt));
        }
コード例 #5
0
        /*
         * private ScopeNodeBase GetScopeUp(ExperimentNode experimentNode, BaseExperiment experiment, double x, double y){
         *  BasicNodeControl componentControl;
         *  ScopeNodeBase scopeUp = null;
         *  ExperimentCanvasPad pad = null;
         *  if (experiment == null)
         *      return null;
         *  foreach (ExperimentNode node in experiment.Vertices)
         *      if (node is ScopeNodeBase && !node.Equals(experimentNode))
         *          if(m_applicationContext.NodeControlFactory.TryGetNodeControl(node, out componentControl)){
         *              ScopeBaseMetadata  scopeBaseMetadata  = node.Data.Metadata as ScopeBaseMetadata;
         *              int xMouse = 0;
         *              int yMouse = 0;
         *              BasicNodeControl internalComponentControl = null;
         *              foreach (ExperimentNode internalNode in scopeBaseMetadata.ComponentGraph.Vertices){
         *                  m_applicationContext.NodeControlFactory.TryGetNodeControl(internalNode, out internalComponentControl) ;
         *                  break;
         *              }
         *              if (internalComponentControl == null)
         *                  return null;
         *                  pad = ExperimentCanvasPadFactory.GetExperimentCanvasPad (m_applicationContext, componentControl);
         *              if (pad == null)
         *                  return null;
         *              pad.ExperimentCanvasWidget.GetPointer(out xMouse, out yMouse);
         *              scopeUp = GetScopeUp(experimentNode, scopeBaseMetadata.ComponentGraph as BaseExperiment, xMouse, yMouse);
         *              if (scopeUp != null)
         *                  return scopeUp;
         *              ScopeNodeControl scopeNodeControl = componentControl as ScopeNodeControl;
         *              if (scopeNodeControl.ContainsPoint (x, y))
         *                  return node as ScopeNodeBase;
         *          }
         *  return null;
         * }
         */
        // END HERZUM SPRINT 2.3 TLAB-60


        public override ITool CreateFigureTool(IPrimaryToolDelegator mainTool, IDrawingEditor editor,
                                               ITool defaultTool, MouseEvent ev)
        {
            DragTool dragTool = defaultTool as DragTool;

            if (dragTool != null)
            {
                //when drag is completed update model data
                dragTool.DragCompleted += (object sender, EventArgs e) =>
                {
                    this.ExperimentNode.Data.X = this.DisplayBox.X;
                    this.ExperimentNode.Data.Y = this.DisplayBox.Y;

                    // HERZUM SPRINT 2.3 TLAB-60
                    int           xMouse    = 0;
                    int           yMouse    = 0;
                    ScopeNodeBase scopeNode = GetScopeUp(ExperimentNode, ExperimentNode.Owner as BaseExperiment, ExperimentNode.Data.X, ExperimentNode.Data.Y);
                    if (scopeNode != null)
                    {
                        ScopeBaseMetadata   scopeBaseMetadata = scopeNode.Data.Metadata as ScopeBaseMetadata;
                        BaseExperiment      experimentTarget  = scopeBaseMetadata.ComponentGraph;
                        BasicNodeControl    componentControl  = null;
                        ExperimentCanvasPad pad = null;
                        foreach (ExperimentNode node in scopeBaseMetadata.ComponentGraph.Vertices)
                        {
                            m_applicationContext.NodeControlFactory.TryGetNodeControl(node, out componentControl);
                            break;
                        }
                        if (componentControl != null)
                        {
                            pad = ExperimentCanvasPadFactory.GetExperimentCanvasPad(m_applicationContext, componentControl);
                        }

                        if (pad != null)
                        {
                            pad.ExperimentCanvasWidget.GetPointer(out xMouse, out yMouse);
                            // HERZUM SPRINT 2.4 TLAB-56 TLAB-57 TLAB-58 TLAB-59 CLASS
                            //TraceLab.Core.Experiments.Clipboard.Cut(ExperimentNode.Owner as BaseExperiment);
                            //TraceLab.Core.Experiments.Clipboard.Paste(experimentTarget,xMouse,yMouse);

                            DragClipboard.Cut(m_applicationContext, ExperimentNode.Owner as BaseExperiment);
                            DragClipboard.Paste(m_applicationContext, experimentTarget, xMouse, yMouse);
                            // END HERZUM SPRINT 2.4 TLAB-56 TLAB-57 TLAB-58 TLAB-59 CLASS
                            pad.DisplayAddedSubgraph(experimentTarget);
                        }
                    }
                    // END HERZUM SPRINT 2.3 TLAB-60
                };
            }
            return(base.CreateFigureTool(mainTool, editor, defaultTool, ev));
        }
コード例 #6
0
ファイル: BasicNodeControl.cs プロジェクト: thbin/TraceLab
        public override ITool CreateFigureTool(IPrimaryToolDelegator mainTool, IDrawingEditor editor,
                                               ITool defaultTool, MouseEvent ev)
        {
            DragTool dragTool = defaultTool as DragTool;

            if (dragTool != null)
            {
                //when drag is completed update model data
                dragTool.DragCompleted += (object sender, EventArgs e) =>
                {
                    this.ExperimentNode.Data.X = this.DisplayBox.X;
                    this.ExperimentNode.Data.Y = this.DisplayBox.Y;
                };
            }

            return(base.CreateFigureTool(mainTool, editor, defaultTool, ev));
        }
コード例 #7
0
    public void GetParentDragTool(Transform child)
    {
        if (child.parent == null)
        {
            return;
        }
        DragTool dragTool = child.parent.GetComponent <DragTool>();

        if (dragTool == null)
        {
            GetParentDragTool(child.parent);
        }
        else
        {
            this.dragTool = dragTool;
        }
    }