///<summary>create a tabitem from a toolboxitem. It init Icon from the tag</summary>
 public SideTabItemDesigner(string name, ToolboxItem tag)
     : base(name, tag)
 {
     CanBeRenamed = false;
     this.Icon = tag.Bitmap;
     ReloadToolBox();
 }

 protected override IComponent[] CreateToolCore(ToolboxItem tool, int x, int y, int width, int height, bool hasLocation, bool hasSize)
 {
     if (tool != null)
     {
         System.Type c = tool.GetType(this.designerHost);
         if (!typeof(ToolStrip).IsAssignableFrom(c))
         {
             ToolStripContainer parent = this.panel.Parent as ToolStripContainer;
             if (parent != null)
             {
                 ToolStripContentPanel contentPanel = parent.ContentPanel;
                 if (contentPanel != null)
                 {
                     PanelDesigner toInvoke = this.designerHost.GetDesigner(contentPanel) as PanelDesigner;
                     if (toInvoke != null)
                     {
                         ParentControlDesigner.InvokeCreateTool(toInvoke, tool);
                     }
                 }
             }
         }
         else
         {
             base.CreateToolCore(tool, x, y, width, height, hasLocation, hasSize);
         }
     }
     return null;
 }

 private static ToolboxItem GetCachedToolboxItem(System.Type itemType)
 {
     ToolboxItem toolboxItem = null;
     if (CachedToolboxItems == null)
     {
         CachedToolboxItems = new Dictionary<System.Type, ToolboxItem>();
     }
     else if (CachedToolboxItems.ContainsKey(itemType))
     {
         return CachedToolboxItems[itemType];
     }
     if (toolboxItem == null)
     {
         toolboxItem = ToolboxService.GetToolboxItem(itemType);
         if (toolboxItem == null)
         {
             toolboxItem = new ToolboxItem(itemType);
         }
     }
     CachedToolboxItems[itemType] = toolboxItem;
     if ((CustomToolStripItemCount > 0) && ((CustomToolStripItemCount * 2) < CachedToolboxItems.Count))
     {
         CachedToolboxItems.Clear();
     }
     return toolboxItem;
 }

        public List<ToolboxItem> GetToolboxItemList()
        {
            List<dynamic> itemMetadataList = new List<dynamic>
            {
                new { DisplayName = "Place", Bitmap = Resources.Place, CommandName = "Place" },
                new { DisplayName = "Transition", Bitmap = Resources.Transition, CommandName = "Transition" },
                new { DisplayName = "AND-split", Bitmap = Resources.AndSplit, CommandName = "AndSplit" },
                new { DisplayName = "OR-split", Bitmap = Resources.OrSplit, CommandName = "OrSplit" },
                new { DisplayName = "AND-join", Bitmap = Resources.AndJoin, CommandName = "AndJoin" },
                new { DisplayName = "OR-join", Bitmap = Resources.OrJoin, CommandName = "OrJoin" },
                new { DisplayName = "Subprocess", Bitmap = Resources.Subprocess, CommandName = "Subprocess" },
            };

            List<ToolboxItem> result = new List<ToolboxItem>();
            foreach (dynamic metadata in itemMetadataList)
            {
                ToolboxItem toolboxItem = new ToolboxItem();
                toolboxItem.Properties.Add(
                    ItemCommandNameProperty,
                    new PetriNetEditorToolboxItemData
                    {
                        CommandName = metadata.CommandName
                    });

                toolboxItem.DisplayName = metadata.DisplayName;
                toolboxItem.Bitmap = metadata.Bitmap;

                result.Add(toolboxItem);
            }

            return result;
        }

		private static SideTab CreateReportingSidetab ()
		{
			SideTab sideTab = new SideTab("ReportDesigner");
			sideTab.CanSaved = false;
			AddPointerToSideTab(sideTab);
			
			// TextItem
			ToolboxItem tb = new ToolboxItem(typeof(ICSharpCode.Reports.Addin.BaseTextItem));
			tb.DisplayName = ResourceService.GetString("SharpReport.Toolbar.TextBox");
			tb.Bitmap = WinFormsResourceService.GetIcon("Icons.16.16.SharpReport.Textbox").ToBitmap();
			sideTab.Items.Add(new SideTabItemDesigner(tb));	
			
			// Row
			tb = new ToolboxItem(typeof(ICSharpCode.Reports.Addin.BaseRowItem));
			tb.Bitmap = WinFormsResourceService.GetBitmap("Icons.16x16.SharpQuery.Table");
			tb.DisplayName = ResourceService.GetString("SharpReport.Toolbar.DataRow");
			sideTab.Items.Add(new SideTabItemDesigner(tb));
			
			
			//BaseTable
			tb.Bitmap = WinFormsResourceService.GetBitmap("Icons.16x16.SharpQuery.Table");
			tb = new ToolboxItem(typeof(ICSharpCode.Reports.Addin.BaseTableItem));
			tb.DisplayName ="Table";
			sideTab.Items.Add(new SideTabItemDesigner(tb));	
			
			
			
			tb.Bitmap = WinFormsResourceService.GetBitmap("Icons.16x16.SharpQuery.Table");
			//BaseDataItem
			tb = new ToolboxItem(typeof(ICSharpCode.Reports.Addin.BaseDataItem));
			tb.DisplayName = ResourceService.GetString("SharpReport.Toolbar.DataField");
			sideTab.Items.Add(new SideTabItemDesigner(tb));	
			
			//Grahics
			// Line
			tb = new ToolboxItem(typeof(ICSharpCode.Reports.Addin.BaseLineItem));
			tb.DisplayName = ResourceService.GetString("SharpReport.Toolbar.Line");
			tb.Bitmap = WinFormsResourceService.GetIcon("Icons.16.16.SharpReport.Line").ToBitmap();
			sideTab.Items.Add(new SideTabItemDesigner(tb));
			
			// Rectangle
			tb = new ToolboxItem(typeof(ICSharpCode.Reports.Addin.BaseRectangleItem));
			tb.DisplayName = ResourceService.GetString("SharpReport.Toolbar.Rectangle");
			tb.Bitmap = GlobalValues.RectangleBitmap();
			sideTab.Items.Add(new SideTabItemDesigner(tb));
			
			// Circle
			tb = new ToolboxItem(typeof(ICSharpCode.Reports.Addin.BaseCircleItem));
			tb.DisplayName = ResourceService.GetString("SharpReport.Toolbar.Circle");
			tb.Bitmap = GlobalValues.CircleBitmap();
			sideTab.Items.Add(new SideTabItemDesigner(tb));
			
		
			// Image
			tb = new ToolboxItem(typeof(ICSharpCode.Reports.Addin.BaseImageItem));
			tb.DisplayName = ResourceService.GetString("SharpReport.Toolbar.Image");
			tb.Bitmap = WinFormsResourceService.GetIcon("Icons.16x16.ResourceEditor.bmp").ToBitmap();
			sideTab.Items.Add(new SideTabItemDesigner(tb));
			return sideTab;
		}

	protected virtual IComponent[] CreateToolCore(ToolboxItem tool, 
					int x, int y, int width, int height,
					bool hasLocation, bool hasSize)
			{
				// TODO
				return null;
			}

		public void AddToolboxItem (ToolboxItem toolboxItem, string category)
		{
			if (!categories.ContainsKey (category))
				categories[category] = new ArrayList ();
			
			System.Diagnostics.Trace.WriteLine ("Adding ToolboxItem: " + toolboxItem.DisplayName + ", " + category);
			((ArrayList) categories[category]).Add (toolboxItem);
		}

        public override void SetSelectedToolboxItem(ToolboxItem toolboxItem)
        {
            if (toolboxItem == null)
                base.SetSelectedToolboxItem(FindToolBoxItem(x => x.DisplayName == "Pointer"));
            else
                base.SetSelectedToolboxItem(toolboxItem);

        }

 public ToolboxPane()
 {
     this.InitializeComponent();
     this.pointer = new ToolboxItem();
     this.pointer.DisplayName = "<Zeiger>";
     this.pointer.Bitmap = new Bitmap(0x10, 0x10);
     this.FillToolbox();
     ListBox list = this.listWindowsForms;
 }

		///<summary>create a tabitem from a toolboxitem. It init Icon and name from the tag</summary>
		public SideTabItemDesigner(ToolboxItem tag) : base(tag.DisplayName, tag)
		{
			if (tag == null) {
				throw new ArgumentNullException("tag");
			}
			CanBeRenamed = false;
			this.Icon = tag.Bitmap;
			ReloadToolBox();
		}

 protected override IComponent[] CreateToolCore(ToolboxItem tool, int x, int y, int width, int height, bool hasLocation, bool hasSize)
 {
     if (this.Selected == null)
     {
         this.Selected = this.splitterPanel1;
     }
     SplitterPanelDesigner toInvoke = (SplitterPanelDesigner) this.designerHost.GetDesigner(this.Selected);
     ParentControlDesigner.InvokeCreateTool(toInvoke, tool);
     return null;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ToolCursor"/> class.
 /// </summary>
 /// <param name="item">A <see cref="ToolboxItem"/> object.</param>
 public ToolCursor(ToolboxItem item)
 {
     this._item = item;
     if (item.Bitmap != null) {
         using (Bitmap bitmap = this.CreateCursor(item.Bitmap)) {
             this._hIcon = bitmap.GetHicon();
             this._cursor = new Cursor(this._hIcon);
         }
     }
 }

        public ToolboxItemToolboxNode(ToolboxItem item)
        {
            this.item = item;
            base.Name = item.DisplayName;
            if (item.Bitmap != null)
                base.Icon = base.ImageToPixbuf (item.Bitmap);

            if (item.AssemblyName != null)
                foreach (System.ComponentModel.CategoryAttribute ca in
                    System.Reflection.Assembly.Load (item.AssemblyName)
                    .GetType (item.TypeName)
                    .GetCustomAttributes (typeof (System.ComponentModel.CategoryAttribute), true))
                    this.Category = ca.Category;
        }

 protected override IComponent[] CreateToolCore(ToolboxItem tool, int x, int y, int width, int height, bool hasLocation, bool hasSize)
 {
     TabControl control = (TabControl) this.Control;
     if (control.SelectedTab == null)
     {
         throw new ArgumentException(System.Design.SR.GetString("TabControlInvalidTabPageType", new object[] { tool.DisplayName }));
     }
     IDesignerHost service = (IDesignerHost) this.GetService(typeof(IDesignerHost));
     if (service != null)
     {
         TabPageDesigner toInvoke = (TabPageDesigner) service.GetDesigner(control.SelectedTab);
         ParentControlDesigner.InvokeCreateTool(toInvoke, tool);
     }
     return null;
 }

        public ToolBoxListItem(ToolboxItem toolBoxItem)
        {
            Size = new Size (150, 20);

            SetStyle (ControlStyles.ResizeRedraw, true);

            Text = toolBoxItem.DisplayName;

            if (toolBoxItem.Bitmap != null)
                image = toolBoxItem.Bitmap;
            else
                image = SystemIcons.Exclamation.ToBitmap ();

            tool_box_item = toolBoxItem;
        }

		///<summary>Load an assembly's controls</summary>
		public SideTabDesigner(SideBarControl sideBar, Category category, IToolboxService toolboxService) : this(sideBar, category.Name, toolboxService)
		{
			foreach (ToolComponent component in category.ToolComponents) {
				if (component.IsEnabled) {
					ToolboxItem toolboxItem = new ToolboxItem();
					toolboxItem.TypeName    = component.FullName;
					toolboxItem.Bitmap      = ToolboxProvider.ComponentLibraryLoader.GetIcon(component);
					toolboxItem.DisplayName = component.Name;
					Assembly asm = component.LoadAssembly();
					toolboxItem.AssemblyName = asm.GetName();
					
					this.Items.Add(new SideTabItemDesigner(toolboxItem));
				}
			}
		}

        /// <summary>
        /// Find the activity, if any, associated with ToolboxItem
        /// </summary>
        private static ActivityItem LookupToolboxItem(ToolboxItem itemToFind, IEnumerable<ActivityAssemblyItem> activityAssemblyItems)
        {
            if (itemToFind == null)
            {
                return null;
            }

            ActivityAssemblyItem hostActivityAssemblyItem =
                activityAssemblyItems.FirstOrDefault(
                    aai => aai.Matches(itemToFind.AssemblyName));

            if (hostActivityAssemblyItem != null)
            {
                return hostActivityAssemblyItem.ActivityItems.FirstOrDefault(ai => ai.FullName == itemToFind.TypeName);
            }
            return null;
        }

		public ToolboxItemToolboxNode (ToolboxItem item)
			: base (item.TypeName, item.AssemblyName.FullName)
		{
			base.Name = item.DisplayName;
			if (item.Bitmap != null)
				base.Icon = ImageToPixbuf (item.Bitmap);
			
			foreach (ToolboxItemFilterAttribute tbfa in item.Filter)
				base.ItemFilters.Add (tbfa);
			
			//we only need to serialise the ToolboxItem if it is non-standard, because we can reliably recreate the two built-in types
			if (item.GetType () == typeof (ToolboxItem))
				toolboxItemType = null; //no-op, but this has consequences 	
			else if (item.GetType () == typeof (System.Web.UI.Design.WebControlToolboxItem))
				toolboxItemType = new TypeReference (typeof (System.Web.UI.Design.WebControlToolboxItem));
			else {
				serializedToolboxItem = SerializeToolboxItem (item);
				toolboxItemType = new TypeReference (item.GetType ());
			} 
		}

 public ToolboxItemContainer(ToolboxItem item)
 {
     if (item == null)
     {
         throw new ArgumentNullException("item");
     }
     this._toolboxItem = item;
     this.UpdateFilter(item);
     this._hashCode = item.DisplayName.GetHashCode();
     if (item.AssemblyName != null)
     {
         this._hashCode ^= item.AssemblyName.GetHashCode();
     }
     if (item.TypeName != null)
     {
         this._hashCode ^= item.TypeName.GetHashCode();
     }
     if (this._hashCode == 0)
     {
         this._hashCode = item.DisplayName.GetHashCode();
     }
 }

		public WebFormsToolboxNode (ToolboxItem item) : base (item)
		{
		}