public DropDownToolbarItem(IDropDownAction action, IconSize iconSize)
		{
			_action = action;

			_actionEnabledChangedHandler = new EventHandler(OnActionEnabledChanged);
			_actionVisibleChangedHandler = new EventHandler(OnActionVisibleChanged);
			_actionAvailableChangedHandler = new EventHandler(OnActionAvailableChanged);
			_actionLabelChangedHandler = new EventHandler(OnActionLabelChanged);
			_actionTooltipChangedHandler = new EventHandler(OnActionTooltipChanged);
			_actionIconSetChangedHandler = new EventHandler(OnActionIconSetChanged);

			_action.EnabledChanged += _actionEnabledChangedHandler;
			_action.VisibleChanged += _actionVisibleChangedHandler;
			_action.AvailableChanged += _actionAvailableChangedHandler;
			_action.LabelChanged += _actionLabelChangedHandler;
			_action.TooltipChanged += _actionTooltipChangedHandler;
			_action.IconSetChanged += _actionIconSetChangedHandler;

			_iconSize = iconSize;

			this.Text = _action.Label;
			this.Enabled = _action.Enabled;
			this.Visible = _action.Visible;
			this.ToolTipText = _action.Tooltip;

			UpdateVisibility();
			UpdateEnablement();
			UpdateIcon();

			this.ShowDropDownArrow = true;

			this.DropDown = new ContextMenuStrip();
			this.DropDown.ImageScalingSize = StandardIconSizes.Small;
			this.DropDownOpening += new EventHandler(OnDropDownOpening);
		}

        /// <summary>
        /// Resolves icon of the file.
        /// </summary>
        /// <param name="fileExtensionName">The file extension name.</param>
        /// <param name="iconSize">The icon size.</param>
        /// <returns></returns>
        public Stream ResolveIcon(string fileExtensionName, IconSize iconSize)
        {
            string iconManifestPath = string.Empty;
            switch (iconSize)
            {
                case IconSize.Pixel16x16:
                    iconManifestPath = string.Format(SmallIconManifestPathTemplate, fileExtensionName.ToLower());
                    break;
                case IconSize.Pixel50x50:
                    iconManifestPath = string.Format(LargeIconManifestPathTemplate, fileExtensionName.ToLower());
                    break;
            }

            Stream stream = typeof(FileIconApi).Assembly.GetManifestResourceStream(iconManifestPath);
            if (stream == null || stream.Length == 0)
            {
                switch (iconSize)
                {
                    case IconSize.Pixel16x16:
                        stream = typeof(FileIconApi).Assembly.GetManifestResourceStream(SmallMiscellaneousIconManifestPath);
                        break;
                    case IconSize.Pixel50x50:
                        stream = typeof(FileIconApi).Assembly.GetManifestResourceStream(LargeMiscellaneousIconManifestPath);
                        break;
                }
            }

            return stream;
        }

        public static Bitmap GetIconData(string iconId, IconSize iconSize)
        {
            var hash = StockIconCodon.ComputeHashCode(iconId, iconSize);
            if (IconData.ContainsKey(hash))
                return IconData[hash];

            if (!IconStock.ContainsKey(hash))
               throw new Exception("Icon "+iconId+" not available!");

            var iconCodon = IconStock[hash];

            if (!string.IsNullOrEmpty (iconCodon.Resource) || !string.IsNullOrEmpty (iconCodon.File)) {
                Bitmap bitmap;
                Stream stream;
                if (iconCodon.Resource != null)
                    stream = iconCodon.Addin.GetResource (iconCodon.Resource);
                else
                    stream = File.OpenRead (iconCodon.Addin.GetFilePath (iconCodon.File));
                using (stream) {
                    if (stream == null || stream.Length < 0) {
                        throw new Exception(string.Format("Did not find resource '{0}' in addin '{1}' for icon '{2}'",
                                                    iconCodon.Resource, iconCodon.Addin.Id, iconCodon.StockId));
                    }
                    bitmap = (Bitmap) Image.FromStream(stream);
                }

                IconData[hash] = bitmap;
            }

            return IconData[hash];
        }

        public static ImageSource GetDirectoryIcon(string path, int iconIndex, IconSize size = IconSize.Small)
        {
            ImageSource imageSource = null;

                if (IconsDictionary.TryGetValue(iconIndex, out imageSource))
                {
                    return imageSource;
                }
                Int32Rect sizeRect;
                WinAPI.SHGFI flags;
                if (IconSize.Small == size)
                {
                    flags = commonFlags | WinAPI.SHGFI.SHGFI_SMALLICON;
                    sizeRect = new Int32Rect(0, 0, 16, 16);
                }
                else
                {
                    flags = commonFlags | WinAPI.SHGFI.SHGFI_LARGEICON;
                    sizeRect = new Int32Rect(0, 0, 32, 32);
                }
                WinAPI.SHFILEINFO shfileinfo = new WinAPI.SHFILEINFO();
                WinAPI.SHGetFileInfo(path, 256, out shfileinfo, (uint) Marshal.SizeOf(shfileinfo), flags);
                if (shfileinfo.hIcon == IntPtr.Zero)
                {
                    return GetIcon(path);
                }
                imageSource = Imaging.CreateBitmapSourceFromHIcon(shfileinfo.hIcon, sizeRect,
                    BitmapSizeOptions.FromEmptyOptions());
                IconsDictionary.Add(iconIndex, imageSource);
                WinAPI.DestroyIcon(shfileinfo.hIcon);
                shfileinfo.hIcon = IntPtr.Zero;

                return imageSource;
        }

        /// <summary>
        /// Returns an icon for a given file - indicated by the Name parameter.
        /// </summary>
        /// <param Name="Name">Pathname for file.</param>
        /// <param Name="size">Large or small</param>
        /// <param Name="linkOverlay">Whether to include the link icon</param>
        /// <returns>System.Drawing.Icon</returns>
        public static Icon GetFileIcon(string name, IconSize size, bool linkOverlay)
        {
            Shell32.SHFILEINFO shfi = new Shell32.SHFILEINFO();
            uint flags = Shell32.SHGFI_ICON | Shell32.SHGFI_USEFILEATTRIBUTES;

            if (linkOverlay) flags += Shell32.SHGFI_LINKOVERLAY;

            /* Check the size specified for return. */
            if (IconSize.Small == size)
            {
                flags += Shell32.SHGFI_SMALLICON;
            }
            else
            {
                flags += Shell32.SHGFI_LARGEICON;
            }

            Shell32.SHGetFileInfo(name,
                                  Shell32.FILE_ATTRIBUTE_NORMAL,
                                  ref shfi,
                                  (uint)Marshal.SizeOf(shfi),
                                  flags);

            Icon.FromHandle(shfi.hIcon); // Load the icon from an HICON handle

            // Now clone the icon, so that it can be successfully stored in an ImageList
            Icon icon = (Icon)Icon.FromHandle(shfi.hIcon).Clone();
            return icon;
        }

        /// <summary>
        /// Returns an icon for a given file - indicated by the name parameter.
        /// </summary>
        /// <param name="name">Pathname for file.</param>
        /// <param name="size">Large or small</param>
        /// <param name="linkOverlay">Whether to include the link icon</param>
        /// <returns>Icon</returns>
        public static Icon GetFileIcon(string name, IconSize size, bool linkOverlay)
        {
            var shfi = new Shell32.SHFILEINFO();
            var flags = Shell32.SHGFI_ICON | Shell32.SHGFI_USEFILEATTRIBUTES;

            if (linkOverlay) flags += Shell32.SHGFI_LINKOVERLAY;

            /* Check the size specified for return. */
            if (IconSize.Small == size) {
                flags += Shell32.SHGFI_SMALLICON;
            } else {
                flags += Shell32.SHGFI_LARGEICON;
            }

            //Shell32.SHGetFileInfo(name,
            //    Shell32.FILE_ATTRIBUTE_NORMAL,
            //    ref shfi,
            //    (uint)Marshal.SizeOf(shfi),
            //    flags);

            //// Copy (clone) the returned icon to a new object, thus allowing us to clean-up properly
            //var icon = (Icon)Icon.FromHandle(shfi.hIcon).Clone();
            //User32.DestroyIcon(shfi.hIcon);		// Cleanup
            //return icon;
            return GetIcon(flags, name, Shell32.FILE_ATTRIBUTE_NORMAL);
        }

        public Bitmap GetImage(IconSize imageSize)
        {
            if (!File.Exists(_imagePath))
                return null;

            if (PathEx.HasExtension(_imagePath, FileExtensions.Executable) ||
                PathEx.HasExtension(_imagePath, FileExtensions.Shortcut) ||
                PathEx.HasExtension(_imagePath, FileExtensions.Icon))
            {
                return GetIcon(imageSize);
            }

            try
            {
                return new Bitmap(_imagePath);
            }
            catch (ArgumentException ex)
            {
                // Unable to convert to an image, assume it's an exe/ico/lnk file even though the extension is wrong.
                if (Log.IsDebugEnabled)
                    Log.DebugFormat("Failed to convert {0} to a image, trying to convert to an icon instead: {1}", _imagePath, ex);

                return GetIcon(imageSize);
            }
            catch (IOException ex)
            {
                // Unable to convert to an image, assume it's an exe/ico/lnk file even though the extension is wrong.
                if (Log.IsDebugEnabled)
                    Log.DebugFormat("Failed to convert {0} to a image, trying to convert to an icon instead: {1}", _imagePath, ex);

                return GetIcon(imageSize);
            }
        }

        protected Bitmap GetFileBasedFSBitmap(string ext, IconSize size)
        {
            string lookup = tempPath;
            Bitmap folderBitmap = KeyToBitmap(lookup, size);
            if (ext != "")
            {
                ext = ext.Substring(0, 1).ToUpper() + ext.Substring(1).ToLower();

                using (Graphics g = Graphics.FromImage(folderBitmap))
                {
                    g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;

                    Font font = new Font("Comic Sans MS", folderBitmap.Width / 5, System.Drawing.FontStyle.Bold | System.Drawing.FontStyle.Italic);
                    float height = g.MeasureString(ext, font).Height;
                    float rightOffset = folderBitmap.Width / 5;

                    if (size == IconSize.small)
                    {
                        font = new Font("Arial", 5, System.Drawing.FontStyle.Bold);
                        height = g.MeasureString(ext, font).Height;
                        rightOffset = 0;
                    }


                    g.DrawString(ext, font,
                                System.Drawing.Brushes.Black,
                                new RectangleF(0, folderBitmap.Height - height, folderBitmap.Width - rightOffset, height),
                                new StringFormat(StringFormatFlags.DirectionRightToLeft));

                }
            }

            return folderBitmap;
        }

        /// <summary>
        /// Get Windows-Icon for the Extension of a file
        /// </summary>
        /// <param name="Extension">ext of tile</param>
        /// <param name="Size">IconSize</param>
        /// <returns>Icon for this extension</returns>
        public static Icon IconFromExtension(string Extension, IconSize Size)
        {
            Icon icon = null;
            try
            {
                //add '.' if necessary
                if (Extension[0] != '.') Extension = '.' + Extension;

                //search registry for the file extension
                RegistryKey Root = Registry.ClassesRoot;
                RegistryKey ExtensionKey = Root.OpenSubKey(Extension);
                ExtensionKey.GetValueNames();
                RegistryKey appKey = Root.OpenSubKey(ExtensionKey.GetValue("").ToString());

                //gets the name of the file that has the icon.
                string IconLocation = appKey.OpenSubKey("DefaultIcon").GetValue("").ToString();
                string[] IconPath = IconLocation.Split(',');

                if (IconPath[1] == null) IconPath[1] = "0";
                IntPtr[] Large = new IntPtr[1];
                IntPtr[] Small = new IntPtr[1];

                //extracts the icon from the file.
                ExtractIconEx(IconPath[0], Convert.ToInt16(IconPath[1]), Large, Small, 1);
                icon = Size == IconSize.Large ? Icon.FromHandle(Large[0]) : Icon.FromHandle(Small[0]);
            }
            catch (Exception e)
            {
                Util.Debug("Icon konnte nicht extrahiert werden!", e);
            }
            return icon;
        }

        /// <summary>
        ///		Get system icon for specified folder/file
        /// </summary>
        /// <param name="path"> Full path to a folder or file </param>
        /// <param name="type"> Type: folder or file </param>
        /// <param name="size"> Icon size: small or large</param>
        /// <param name="isOpen"> Is open icon (applicable for folders only) </param>
        /// <returns></returns>
        public static Icon GetIcon(string path, ItemType type, IconSize size, bool isOpen)
        {
            var flags = SHGFI_ICON | SHGFI_USEFILEATTRIBUTES;
            var attribute = (type == ItemType.Folder) ? FILE_ATTRIBUTE_DIRECTORY : FILE_ATTRIBUTE_FILE;
            if (isOpen)
                flags += SHGFI_OPENICON;

            if (size == IconSize.Small)
                flags += SHGFI_SMALLICON;
            else
                flags += SHGFI_LARGEICON;

            var shfi = new SHFileInfo();
            var res = SHGetFileInfo(path, attribute, out shfi, (uint)Marshal.SizeOf(shfi), flags);
            if (Equals(res, IntPtr.Zero))
                throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
            try
            {
                Icon.FromHandle(shfi.hIcon);
                return (Icon)Icon.FromHandle(shfi.hIcon).Clone();
            }
            finally
            {
                DestroyIcon(shfi.hIcon);
            }
        }

 public thumbnailInfo(WriteableBitmap b, string path, IconSize size, int rol)
 {
     bitmap = b;
     fullPath = path;
     iconsize = size;
     roll = rol;
 }

		public TextBoxToolbarItem(ITextBoxAction action, IconSize iconSize)
		{
			_action = action;

			_actionEnabledChangedHandler = new EventHandler(OnActionEnabledChanged);
			_actionVisibleChangedHandler = new EventHandler(OnActionVisibleChanged);
			_actionAvailableChangedHandler = new EventHandler(OnActionAvailableChanged);
			_actionLabelChangedHandler = new EventHandler(OnActionLabelChanged);
			_actionTooltipChangedHandler = new EventHandler(OnActionTooltipChanged);
			_actionIconSetChangedHandler = new EventHandler(OnActionIconSetChanged);
			_actionTextBoxValueChangedHandler = new EventHandler(OnActionTextBoxValueChanged);
			_actionCueTextChangedHandler = new EventHandler(OnActionCueTextChanged);

			_action.EnabledChanged += _actionEnabledChangedHandler;
			_action.VisibleChanged += _actionVisibleChangedHandler;
			_action.AvailableChanged += _actionAvailableChangedHandler;
			_action.LabelChanged += _actionLabelChangedHandler;
			_action.TooltipChanged += _actionTooltipChangedHandler;
			_action.IconSetChanged += _actionIconSetChangedHandler;
			_action.TextValueChanged += _actionTextBoxValueChangedHandler;
			_action.CueTextChanged += _actionCueTextChangedHandler;

			_iconSize = iconSize;

			this.Text = _action.TextValue;
			this.Enabled = _action.Enabled;
			SetTooltipText();
			UpdateCueBanner();
			UpdateVisibility();
			UpdateEnablement();
			UpdateIcon();

		}

 /// <summary>
 ///     The current Windows default Folder Icon in the given Size (Large/Small) as System.Drawing.Icon.
 /// </summary>
 /// <param name="size">The Size of the Icon (Small or Large).</param>
 /// <param name="folderType">The folderTypeIcon (closed or Open).</param>
 /// <returns>The Folder Icon as System.Drawing.Icon.</returns>
 public static Icon GetDefaultDirectoryIcon(IconSize size, FolderType folderType)
 {
     var flags = ShgfiIcon | ShgfiUsefileattributes;
     if (FolderType.Open == folderType)
     {
         flags += ShgfiOpenicon;
     }
     if (IconSize.Small == size)
     {
         flags += ShgfiSmallicon;
     }
     else
     {
         flags += ShgfiLargeicon;
     }
     var shfi = new Structs.Shfileinfo();
     var res = DllImports.SHGetFileInfo(@"C:\Windows", FileAttributeDirectory, out shfi, (uint) Marshal.SizeOf(shfi), flags);
     if (res == IntPtr.Zero)
     {
         throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
     }
     Icon.FromHandle(shfi.hIcon);
     var icon = (Icon) Icon.FromHandle(shfi.hIcon).Clone();
     DllImports.DestroyIcon(shfi.hIcon);
     return icon;
 }

        /// <summary>
        /// Returns an icon for a given file - indicated by the name parameter</summary>
        /// <param name="name">Pathname for file</param>
        /// <param name="size">Large or small icon</param>
        /// <param name="linkOverlay">Whether to include the link icon</param>
        /// <returns>Icon</returns>
        public static Icon GetFileIcon(string name, IconSize size, bool linkOverlay)
        {
            Shell32.SHFILEINFO shfi = new Shell32.SHFILEINFO();
            uint flags = Shell32.SHGFI_ICON | Shell32.SHGFI_USEFILEATTRIBUTES;

            if (linkOverlay) flags += Shell32.SHGFI_LINKOVERLAY;

            // Check the size specified for return.
            if (IconSize.Small == size)
            {
                flags += Shell32.SHGFI_SMALLICON;
            }
            else
            {
                flags += Shell32.SHGFI_LARGEICON;
            }

            Shell32.SHGetFileInfo(name,
                Shell32.FILE_ATTRIBUTE_NORMAL,
                ref shfi,
                (uint)System.Runtime.InteropServices.Marshal.SizeOf(shfi),
                flags);

            // Copy (clone) the returned icon to a new object, thus allowing us to clean-up properly
            Icon icon = (Icon)Icon.FromHandle(shfi.hIcon).Clone();
            User32.DestroyIcon(shfi.hIcon);        // Cleanup
            return icon;
        }

        public static System.Drawing.Icon GetFolderIcon(string name, IconSize size, FolderType folderType)
        {
            Shell32.SHFILEINFO shfi = new Shell32.SHFILEINFO();
            uint flags = Shell32.SHGFI_ICON | Shell32.SHGFI_USEFILEATTRIBUTES;

            if (FolderType.Open == folderType)
            {
                flags += Shell32.SHGFI_OPENICON;
            }

            //if (true == linkOverlay) flags += Shell32.SHGFI_LINKOVERLAY;

            /* Check the size specified for return. */
            if (IconSize.Small == size)
            {
                flags += Shell32.SHGFI_SMALLICON;
            }
            else
            {
                flags += Shell32.SHGFI_LARGEICON;
            }

            Shell32.SHGetFileInfo(name,
                Shell32.FILE_ATTRIBUTE_DIRECTORY,
                ref shfi,
                (uint)System.Runtime.InteropServices.Marshal.SizeOf(shfi),
                flags);

            // Copy (clone) the returned icon to a new object, thus allowing us to clean-up properly
            System.Drawing.Icon icon = (System.Drawing.Icon)System.Drawing.Icon.FromHandle(shfi.hIcon).Clone();
            User32.DestroyIcon(shfi.hIcon);		// Cleanup
            return icon;
        }

        /// <summary>
        /// Obtains system folder icon</summary>
        /// <param name="size">Specifies large or small icons</param>
        /// <param name="folderType">Specifies open or closed FolderType</param>
        /// <returns>System folder icon</returns>
        public static Icon GetFolderIcon(IconSize size, FolderType folderType)
        {
            // Need to add size check, although errors generated at present!
            uint flags = Shell32.SHGFI_ICON | Shell32.SHGFI_USEFILEATTRIBUTES;

            if (FolderType.Open == folderType)
            {
                flags += Shell32.SHGFI_OPENICON;
            }

            if (IconSize.Small == size)
            {
                flags += Shell32.SHGFI_SMALLICON;
            }
            else
            {
                flags += Shell32.SHGFI_LARGEICON;
            }

            // Get the folder icon
            Shell32.SHFILEINFO shfi = new Shell32.SHFILEINFO();
            Shell32.SHGetFileInfo(null,
                Shell32.FILE_ATTRIBUTE_DIRECTORY,
                ref shfi,
                (uint)System.Runtime.InteropServices.Marshal.SizeOf(shfi),
                flags);

            Icon.FromHandle(shfi.hIcon);    // Load the icon from an HICON handle

            // Now clone the icon, so that it can be successfully stored in an ImageList
            Icon icon = (Icon)Icon.FromHandle(shfi.hIcon).Clone();

            User32.DestroyIcon(shfi.hIcon);        // Cleanup
            return icon;
        }

 public thumbnailInfo(WriteableBitmap b, string k, IconSize size, int rol)
 {
     bitmap = b;
     key = k;
     iconsize = size;
     roll = rol;
 }

        private Icon GetFileIcon(string fileName, IconSize size)
        {
            IntPtr iconPtr;
            Icon ret = null;
            SHFILEINFO shinfo = new SHFILEINFO();
                        
            uint flags = Win32.SHGFI_ICON;
            /* Check the size specified for return. */
            if (size == IconSize.Small)
                flags += Win32.SHGFI_SMALLICON;            
            else            
                flags += Win32.SHGFI_LARGEICON;

            
            iconPtr = Win32.SHGetFileInfo(fileName, 0,
                ref shinfo, (uint)Marshal.SizeOf(shinfo), flags);

            if (iconPtr != IntPtr.Zero)
            {
                // Copy (clone) the returned icon to a new object, thus allowing us to clean-up properly
                ret = (System.Drawing.Icon)System.Drawing.Icon.FromHandle(shinfo.hIcon).Clone();
                // Cleanup
                Win32.DestroyIcon(shinfo.hIcon);
            }

            return ret;
        }

		public Icon GetStaticIcon(StaticIconType type, IconSize size)
		{
			ShellIcon.IconSize iconSize;
			switch (size)
			{
				case IconSize.Large:
					iconSize = ShellIcon.IconSize.Large;
					break;
				case IconSize.Small:
					iconSize = ShellIcon.IconSize.Small;
					break;
				default:
					throw new NotSupportedException();
			}

			ShellIcon.FolderType folderType;
			switch (type)
			{
				case StaticIconType.OpenDirectory:
					folderType = ShellIcon.FolderType.Open;
					break;
				case StaticIconType.CloseDirectory:
					folderType = ShellIcon.FolderType.Closed;
					break;
				default:
					throw new NotSupportedException();
			}
			
			SD.Icon icon = ShellIcon.GetFolderIcon(iconSize, folderType);
			return new Icon(new IconHandler(icon));
		}

 public static Icon GetIcon(string path, ItemType type, IconSize size, ItemState state)
 {
     var flags = (uint)(Interop.SHGFI_ICON | Interop.SHGFI_USEFILEATTRIBUTES);
     var attribute = (uint)(object.Equals(type, ItemType.Folder) ? Interop.FILE_ATTRIBUTE_DIRECTORY : Interop.FILE_ATTRIBUTE_FILE);
     if (object.Equals(type, ItemType.Folder) && object.Equals(state, ItemState.Open))
     {
         flags += Interop.SHGFI_OPENICON;
     }
     if (object.Equals(size, IconSize.Small))
     {
         flags += Interop.SHGFI_SMALLICON;
     }
     else
     {
         flags += Interop.SHGFI_LARGEICON;
     }
     var shfi = new SHFileInfo();
     var res = Interop.SHGetFileInfo(path, attribute, out shfi, (uint)Marshal.SizeOf(shfi), flags);
     if (object.Equals(res, IntPtr.Zero)) throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
     try
     {
         Icon.FromHandle(shfi.hIcon);
         return (Icon)Icon.FromHandle(shfi.hIcon).Clone();
     }
     catch
     {
         throw;
     }
     finally
     {
         Interop.DestroyIcon(shfi.hIcon);
     }
 }