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;
 }

        /// <summary>
        /// The constructor for the ToolDialog
        /// </summary>
        /// <param name="tool">The ITool to create the dialog box for</param>
        /// <param name="modelElements">A list of all model elements</param>
        public ToolDialog(ITool tool, IEnumerable<ModelElement> modelElements)
        {
            // Required by the designer
            InitializeComponent();

            // We store all the element names here and extract the datasets
            foreach (ModelElement me in modelElements)
            {
                if (me as DataElement != null)
                {
                    bool addData = true;
                    foreach (Parameter par in tool.OutputParameters)
                    {
                        if (par.ModelName == (me as DataElement).Parameter.ModelName)
                        {
                            addData = false;
                        }

                        break;
                    }

                    if (addData)
                    {
                        _dataSets.Add(new DataSetArray(me.Name, (me as DataElement).Parameter.Value as IDataSet));
                    }
                }
            }

            Initialize(tool);
        }

        private void InsertTool(ITool tool)
        {
            // Create the view.
            var view = tool.CreateView();
            if (view.DataContext == null) view.DataContext = tool;
            view.HorizontalAlignment = tool.HorizontalAlignment;
            view.VerticalAlignment = tool.VerticalAlignment;

            // Assign the margin (if the generated view did not arrive with an explicitly set value).
            if (view.Margin == default(Thickness)) view.Margin = tool.Parent.DefaultToolMargin;

            // Get the column (and update it's width if required).
            var columnIndex = tool.Parent.GetColumn(tool);
            if (tool is IGridCellWidth)
            {
                toolContainer.ColumnDefinitions[columnIndex].Width = ((IGridCellWidth) tool).ColumnWidth;
            }

            // Assign Row/Column position.
            Grid.SetRow(view, tool.Parent.GetRow(tool));
            Grid.SetColumn(view, columnIndex);

            // Set spans.
            Grid.SetRowSpan(view, tool.Parent.GetRowSpan(tool));
            Grid.SetColumnSpan(view, tool.Parent.GetColumnSpan(tool));

            // Insert into the visual tree.
            toolContainer.Children.Add(view);
        }

 private IActivityToolSchedulingEventCollection GetOrAddToolSchedule(ITool tool)
 {
     if (!_toolSchedules.ContainsKey(tool))
     {
         _toolSchedules.Add(tool, new ActivityToolSchedulingEventCollection(tool));
     }
     return _toolSchedules[tool];
 }

 public Pickup(int x, int y, ITool tool, string text)
 {
     Tool = tool;
     this.text = text;
     X = x;
     startY = Y = y;
     Size = new Point(16, 16);
 }

		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 Inventory(int x, int y, ITool[] tools)
     : this(x, y)
 {
     foreach (ITool tool in tools)
     {
         this.tools.Add(tool);
     }
 }

        /// <summary>
        /// The constructor for the ToolDialog
        /// </summary>
        /// <param name="Tool">The ITool to create the dialog box for</param>
        /// <param name="DataSets">The list of available DataSets available</param>
        public ToolDialog(ITool Tool, List<DataSetArray> DataSets)
        {
            //Required by the designer
            InitializeializeializeComponent();

            _dataSets = DataSets;

            Initialize(Tool);
        }

 private ToolInstance(int id, ITool definition) : this()
 {
     if (id == -1)
     {
         id = this.NextId();
     }
     ID = id;
     Definition = definition;
 }

        public void Show(ITool tool, Action applyCallback, Action cancelCallback)
        {
            this.Content = tool.GetSettingsUI();
            this.Header = tool.ToString().Split('.').Last();

            if (!this.IsOpen && this.Content != null)
            {
              this.Show();
            }
        }

        private void AddPlugin(ITool plugin)
        {
            var tabitem = new TabItem
            {
                Header = plugin.Name,
                Content = plugin.View
            };

            tabControl.Items.Add(tabitem);
        }

 public TinyDiver(ITool tool1, ITool tool2, int x, int y)
     : base(tool1, tool2, x, y)
 {
     Size = new Point(16, 28);
     StandingGrid = new SpriteGrid("tiny_standing", 2, 1);
     WalkingGrid = new SpriteGrid("tiny_walking", 12, 1);
     JumpingGrid = new SpriteGrid("tiny_jumping", 6, 1);
     ClimbingGrid = new SpriteGrid("tiny_climbing", 2, 1);
     Name = "Tiny";
     originalBoatPosition = new Point(250, 224 - Height);
 }

        public static void SetCurrentTool(ITool tool)
        {
            if (currentTool != null)
            {
                currentTool.OnRemove();
            }

            currentTool = tool;

            currentTool.OnAdd();
        }

        private void CreateObject(ITool tool)
        {
            using ( var scope = RecordingServices.DefaultRecorder.OpenScope() )
            {
                var newItem = tool.CreateItem( EditingContext );
                newItem.SetPosition( 100, 100 );

                // We name the scope after we created.
                scope.OperationDescriptor = new NamedOperationDescriptor(string.Format("Creating {0}", newItem.Name));

            }
        }

 /// <summary>
 /// Creates an instance of DLLToolInfo
 /// </summary>
 /// <param name="tool"></param>
 /// <param name="AssemblyFileName"></param>
 /// <param name="ToolClassName"></param>
 /// <param name="DateFileModified">The dane the file was modified</param>
 public DefaultToolProviderToolInfo(ITool tool, string AssemblyFileName, string ToolClassName, DateTime DateFileModified)
 {
     base.Name = tool.Name;
     base.UniqueName = tool.UniqueName;
     base.Description = tool.Description;
     base.ToolTip = tool.ToolTip;
     base.Category = tool.Category;
     base.Icon = tool.Icon;
     _assemblyFileName = AssemblyFileName;
     _toolClassName = ToolClassName;
     _dateFileModified = DateFileModified;
 }

 private IToolInstance GetNextTool(ITool tool)
 {
     foreach (var toolInstanceState in _toolAvailableStates[tool])
     {
         if (toolInstanceState.Value)
         {
             // return first worker that is available
             return _converter.ToolTypes[tool][toolInstanceState.Key];
         }
     }
     return null;
 }

 public FattyDiver(ITool tool1, ITool tool2, int x, int y)
     : base(tool1, tool2, x, y)
 {
     Size = new Point(16, 40);
     StandingGrid = new SpriteGrid("tiny_standing", 2, 1);
     WalkingGrid = new SpriteGrid("tiny_walking", 12, 1);
     JumpingGrid = new SpriteGrid("tiny_jumping", 6, 1);
     ClimbingGrid = new SpriteGrid("fatty_climbing", 2, 1);
     Name = "Fatty";
     originalBoatPosition = new Point(200, 224 - Height);
     Strength = 20;
 }

        public ToolIndex(ITool tool, ToolOptionBase options, string name, Image image, Keys defaultKey)
        {
            Name = name;
            DefaultKeys = defaultKey;

            OptionsPanel = options;
            Tool = tool;
            MenuItem = new ToolStripMenuItem(Name, image);
            MenuItem.Text = name;
            MenuItem.Tag = this;
            Button = new ToolStripButton(image);
            Button.Text = name;
            Button.DisplayStyle = ToolStripItemDisplayStyle.Image;
            Button.Tag = this;
        }

        public ITool m_Tool; //��������axMapControl��IToolʵ��

        #endregion Fields

        #region Constructors

        /// <summary>
        /// ��ʼ������
        /// </summary>
        /// <param name="type">��������</param>
        /// <param name="ipTool">��������axMapControl��IToolʵ��</param>
        public FormDis(MeasureType type,ITool ipTool)
        {
            InitializeComponent();
            this.m_MeasureType = type;
            this.m_Tool = ipTool;
            this.TopMost = true;
            this.WriteLabelText(null);

            if (this.m_Tool.GetType() == typeof(ToolMeasureLength))
            {
                (this.m_Tool as ToolMeasureLength).MyInit();
            }
            if (this.m_Tool.GetType() == typeof(ToolMeasureArea))
            {
                (this.m_Tool as ToolMeasureArea).MyInit();
            }
        }