public MultiLineTextTool (IDrawingEditor editor, MultiLineTextFigure fig, ITool dt): base (editor, fig, dt) {	
			_textview = new Gtk.TextView ();
			_textview.Buffer.Changed += new System.EventHandler (ChangedHandler);
			_textview.ModifyFont (fig.PangoLayout.FontDescription.Copy ());
			_textview.RightMargin = 5;
			_textview.Justification = ConvertJustificaton ();
		}
 public PopupMenuTool(IDrawingEditor editor, IPopupMenuFigure figure, ITool defaultTool, ITool delegateTool, bool mainMenu)
     : base(editor, figure, defaultTool)
 {
     _figure = figure;
     DelegateTool = delegateTool;
     primaryMenu = mainMenu;
 }
        public ChangeAttributeCommand(string name, FigureAttribute attribute, 
			object value, IDrawingEditor editor)
            : base(name, editor)
        {
            _attribute = attribute;
            _value     = value;
        }
 public ConnectionCreationTool(IDrawingEditor editor, ConnectionFigure fig)
     : base(editor, fig)
 {
     _connection = fig;
     _connection.StartConnector = null;
     _connection.EndConnector = null;
 }
Example #5
0
 public MultiLineTextTool(IDrawingEditor editor, MultiLineTextFigure fig, ITool dt) : base(editor, fig, dt)
 {
     _textview = new Gtk.TextView();
     _textview.Buffer.Changed += new System.EventHandler(ChangedHandler);
     _textview.ModifyFont(fig.PangoLayout.FontDescription.Copy());
     _textview.RightMargin   = 5;
     _textview.Justification = ConvertJustificaton();
 }
 public StandardDrawingView (IDrawingEditor editor): base () {
     Drawing = new StandardDrawing ();
     Editor = editor;
     Scale = 1.0;
     _selection = new FigureCollection ();
             
     DebugCreateTimer ();
 }
		public SimpleTextTool (IDrawingEditor editor, SimpleTextFigure fig, ITool dt) 
			: base (editor, fig, dt) {
			_entry = new Gtk.Entry ();
			_entry.HasFrame = false;
			_entry.Alignment = 0.5f;
			_entry.Changed += new System.EventHandler (ChangedHandler);
			_entry.ModifyFont (fig.PangoLayout.FontDescription.Copy ());
		}
Example #8
0
        public StandardDrawingView(IDrawingEditor editor) : base()
        {
            Drawing    = new StandardDrawing();
            Editor     = editor;
            Scale      = 1.0;
            _selection = new FigureCollection();

            DebugCreateTimer();
        }
Example #9
0
 public SimpleTextTool(IDrawingEditor editor, SimpleTextFigure fig, ITool dt)
     : base(editor, fig, dt)
 {
     _entry           = new Gtk.Entry();
     _entry.HasFrame  = false;
     _entry.Alignment = 0.5f;
     _entry.Changed  += new System.EventHandler(ChangedHandler);
     _entry.ModifyFont(fig.PangoLayout.FontDescription.Copy());
 }
        public StandardDrawingView(IDrawingEditor editor)
            : base()
        {
            Editor = editor;
            Drawing = new StandardDrawing ();
            ScaleRange = new ScaleRange (5, 0.25, 0.1);
            Scale = 0.75;

            selection = new FigureCollection ();
            DebugCreateTimer ();
        }
Example #11
0
 public override ITool CreateFigureTool(IPrimaryToolDelegator mainTool, IDrawingEditor editor,
                                        ITool defaultTool, MouseEvent ev)
 {
     if (ev.IsRightButtonPressed())
     {
         PopupContextMenu(mainTool, editor, defaultTool, ev);
         return(null);
     }
     else
     {
         return(base.CreateFigureTool(mainTool, editor, defaultTool, ev));
     }
 }
Example #12
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));
        }
Example #13
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));
        }
Example #14
0
        private void PopupContextMenu(IPrimaryToolDelegator mainTool, IDrawingEditor editor, ITool dt, MouseEvent ev)
        {
            m_contextMenu = new Gtk.Menu();
            Gtk.MenuItem editLabel = new Gtk.MenuItem("Edit label");

            editLabel.Activated += delegate(object sender, EventArgs e)
            {
                SimpleTextTool textTool = new SimpleTextTool(editor, this, dt, ev);
                mainTool.DelegateTool = textTool;
                textTool.StartEditing();
            };

            m_contextMenu.Add(editLabel);
            m_contextMenu.ShowAll();

            m_contextMenu.Popup();
        }
Example #15
0
        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));
        }
Example #16
0
 public override ITool CreateFigureTool(IPrimaryToolDelegator mainTool, IDrawingEditor editor,
                                        ITool defaultTool, MouseEvent ev)
 {
     if (ev.IsRightButtonPressed())
     {
         // HERZUM SPRINT 2.6 TLAB-172
         if (IsEditable)
         {
             // END HERZUM SPRINT 2.6 TLAB-172
             PopupContextMenu(mainTool, editor, defaultTool, ev);
         }
         return(null);
     }
     else
     {
         return(base.CreateFigureTool(mainTool, editor, defaultTool, ev));
     }
 }
Example #17
0
        // HERZUM SPRINT 2.3 TLAB-56 TLAB-57 TLAB-58 TLAB-59

        /*
         * private void PopupContextMenu(IPrimaryToolDelegator mainTool, IDrawingEditor editor, ITool dt, MouseEvent ev)
         * {
         *  m_contextMenu = new Gtk.Menu();
         *  Gtk.MenuItem editLabel = new Gtk.MenuItem("Edit label");
         *
         *  editLabel.Activated += delegate(object sender, EventArgs e)
         *  {
         *      SimpleTextTool textTool = new SimpleTextTool(editor, this, dt, ev);
         *      mainTool.DelegateTool = textTool;
         *      textTool.StartEditing();
         *  };
         *
         *  m_contextMenu.Add(editLabel);
         *  m_contextMenu.ShowAll();
         *
         *  m_contextMenu.Popup();
         * }
         */

        private void PopupContextMenu(IPrimaryToolDelegator mainTool, IDrawingEditor editor, ITool dt, MouseEvent ev)
        {
            m_contextMenu = new Gtk.Menu();
            Gtk.MenuItem editLabel = new Gtk.MenuItem("Edit label");
            Gtk.MenuItem copy      = new Gtk.MenuItem("Copy");
            Gtk.MenuItem cut       = new Gtk.MenuItem("Cut");
            // Gtk.MenuItem paste = new Gtk.MenuItem("Paste");

            editLabel.Activated += delegate(object sender, EventArgs e)
            {
                SimpleTextTool textTool = new SimpleTextTool(editor, this, dt, ev);
                mainTool.DelegateTool = textTool;
                textTool.StartEditing();
            };

            copy.Activated += delegate(object sender, EventArgs e)
            {
                Clipboard.Copy(ExperimentNode.Owner as BaseExperiment);
            };

            cut.Activated += delegate(object sender, EventArgs e)
            {
                Clipboard.Cut(ExperimentNode.Owner as BaseExperiment);
            };

            /*
             * paste.Activated += delegate(object sender, EventArgs e)
             * {
             *  Clipboard.Paste(ExperimentNode.Owner as BaseExperiment);
             *  ExperimentCanvasPad ecp = ExperimentCanvasPadFactory.GetExperimentCanvasPad(m_applicationContext, this);
             *  ecp.DisplayAddedSubgraph(ExperimentNode.Owner as BaseExperiment);
             * };
             */

            m_contextMenu.Add(editLabel);
            m_contextMenu.Add(copy);
            m_contextMenu.Add(cut);
            // m_contextMenu.Add(paste);
            m_contextMenu.ShowAll();

            m_contextMenu.Popup();
        }
Example #18
0
 public virtual ITool CreateFigureTool(IDrawingEditor editor, ITool defaultTool)
 {
     return(defaultTool);
 }
Example #19
0
 public PolyLineFigureTool(IDrawingEditor editor, IFigure fig, ITool dt) : base(editor, fig, dt)
 {
 }
Example #20
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);
        }
 public DragCreationTool(IDrawingEditor editor, Figure ptype)
     : base(editor, ptype)
 {
 }
Example #22
0
 public DragCreationTool(IDrawingEditor editor, IFigure ptype) : base(editor, ptype)
 {
 }
Example #23
0
 protected AbstractCommand(string name, IDrawingEditor editor)
 {
     Name          = name;
     DrawingEditor = editor;
 }
Example #24
0
 public ITool CreateFigureTool(IPrimaryToolDelegator mainTool, IDrawingEditor editor, ITool defaultTool, MouseEvent ev)
 {
     return(new CompositeFigureTool(editor, this, defaultTool));
 }
 public override ITool CreateFigureTool(IDrawingEditor editor, ITool dt)
 {
     return new TableTextFigureTool (editor, this, dt);
 }
Example #26
0
 public SimpleTextTool(IDrawingEditor editor, SimpleTextFigure fig, ITool dt, MouseEvent ev)
     : this(editor, fig, dt)
 {
     View = ev.View;
 }
 public SelectAreaTool(IDrawingEditor editor)
     : base(editor)
 {
 }
Example #28
0
 public virtual ITool CreateFigureTool(IPrimaryToolDelegator mainTool, IDrawingEditor editor, ITool defaultTool, MouseEvent ev)
 {
     return(defaultTool);
 }
Example #29
0
 public CompositeFigureTool(IDrawingEditor editor, IFigure fig, ITool dt) : base(editor, fig, dt)
 {
 }
Example #30
0
 public override ITool CreateFigureTool(IDrawingEditor editor, ITool dt)
 {
     return(TextEditable ? new SimpleTextTool(editor, this, dt) : dt);
 }
Example #31
0
 public SelectAreaTool(IDrawingEditor editor) : base(editor)
 {
 }
 public MenuTool(IDrawingEditor editor, Figure figure)
     : base(editor)
 {
     this.figure = figure;
 }
 public RedoCommand(string name, IDrawingEditor editor)
     : base(name, editor)
 {
 }
 public SimpleTextTool(IDrawingEditor editor, SimpleTextFigure fig, ITool dt, MouseEvent ev)
     : this(editor, fig, dt)
 {
     View = ev.View;
 }
 public TableTextFigureTool(IDrawingEditor editor, IFigure fig, ITool dt)
     : base(editor, fig, dt)
 {
 }
		public BringToFrontCommand (string name, IDrawingEditor editor): base (name, editor) {
		}
Example #37
0
 public SelectionTool(IDrawingEditor editor) : base(editor)
 {
 }
Example #38
0
 protected AbstractTool(IDrawingEditor editor)
 {
     Editor   = editor;
     Undoable = true;
 }
        public override ITool CreateFigureTool(IPrimaryToolDelegator mainTool, IDrawingEditor editor, 
                                               ITool defaultTool, MouseEvent ev)
        {
            return (TextEditable) ? new SimpleTextTool (editor, this, defaultTool) : defaultTool;
		}
Example #40
0
 public UndoCommand(string name, IDrawingEditor editor) : base(name, editor)
 {
 }
 public FigureTool(IDrawingEditor editor, Figure fig, ITool dt)
     : base(editor)
 {
     DefaultTool = dt;
     Figure = fig;
 }
Example #42
0
 public DragTool(IDrawingEditor editor, IFigure anchor) : base(editor)
 {
     AnchorFigure = anchor;
 }
 public override ITool CreateFigureTool(IDrawingEditor editor, ITool dt)
 {
     return TextEditable ? new SimpleTextTool (editor, this, dt) : dt;
 }
Example #44
0
 public override ITool CreateFigureTool(IDrawingEditor editor, ITool dt)
 {
     return(new CompositeFigureTool(editor, this, dt));
 }
Example #45
0
 public SelectionTool (IDrawingEditor editor): base (editor) {
 }
Example #46
0
 public override ITool CreateFigureTool(IDrawingEditor editor, ITool dt)
 {
     return new MultiLineTextTool (editor, _text, dt);
 }
Example #47
0
 public ConnectionCreationTool(IDrawingEditor editor, IConnectionFigure fig) : base(editor, fig)
 {
     _connection = fig;
     _connection.DisconnectStart();
     _connection.DisconnectEnd();
 }
 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);
 }
Example #49
0
 public ITool CreateFigureTool(IPrimaryToolDelegator mainTool, IDrawingEditor editor, ITool defaultTool, MouseEvent ev)
 {
     return((TextEditable) ? new MultiLineTextTool(editor, this, defaultTool) : defaultTool);
 }
Example #50
0
		public TextTool (IDrawingEditor editor, SimpleTextFigure fig, ITool dt) 
			: base (editor, fig, dt) {
		}
Example #51
0
 public CreationTool(IDrawingEditor editor, IFigure ptype) : base(editor)
 {
     Prototype = ptype;
 }
Example #52
0
 public HandleTracker(IDrawingEditor editor, IHandle anchor) : base(editor)
 {
     _anchorHandle = anchor;
 }
		public DuplicateCommand (string name, IDrawingEditor editor) : base (name, editor) {
		}
Example #54
0
 public AnalogClockTool(IDrawingEditor editor, AnalogClockFigure fig, ITool dt)
     : base(editor, fig, dt)
 {
     _figure   = fig;
     _selected = AnalogClockHandSelected.Hour;
 }
Example #55
0
 public PanTool(IDrawingEditor editor, Cursor defaultCursor): base (editor) 
 {
     m_defaultCursor = defaultCursor;
     Gtk.Widget widget = (Gtk.Widget) editor.View;
     widget.GdkWindow.Cursor = m_defaultCursor;
 }
Example #56
0
 public FigureTool(IDrawingEditor editor, IFigure fig, ITool dt) : base(editor)
 {
     DefaultTool = dt;
     Figure      = fig;
 }
 public PolyLineFigureTool(IDrawingEditor editor, Figure fig, ITool dt)
     : base(editor, fig, dt)
 {
 }
Example #58
0
 public override ITool CreateFigureTool(IDrawingEditor editor, ITool defaultTool)
 {
     return new PopupMenuTool (editor, this, defaultTool, base.CreateFigureTool (editor, defaultTool));
 }
		public SelectAllCommand (string name, IDrawingEditor editor) : base (name, editor) {
		}
		public HandleTracker (IDrawingEditor editor, IHandle anchor): base (editor) {
			_anchorHandle = anchor;
		}