private void FolderSelectionChanged(object sender, EventArgs e)
 {
     if (inboxRadioButton.Checked)
     {
         this.folderSelectionLabel.Text = "Look in Inbox Folder";
         folderTypeSelection = FolderType.Inbox;
     }
     else if (sentRadioButton.Checked)
     {
         this.folderSelectionLabel.Text = "Look in Sent Items Folder";
         folderTypeSelection = FolderType.Sent;
     }
     else if (outboxRadioButton.Checked)
     {
         this.folderSelectionLabel.Text = "Look in Outbox Folder";
         folderTypeSelection = FolderType.Outbox;
     }
     else
     {
         this.folderSelectionLabel.Text = string.Empty;
         folderTypeSelection = FolderType.None;
     }
     BuildWorkflow(WizardStep.None);
     ResetButtons();
 }

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

 public int AddFolderIcon(FolderType type)
 {
     string text = "folder_" + type.ToString();
     int result;
     if (this._extensionList.ContainsKey(text))
     {
         result = (int)this._extensionList[text];
     }
     else
     {
         int count = ((ImageList)this._imageLists[0]).Images.Count;
         if (this._manageBothSizes)
         {
             ((ImageList)this._imageLists[0]).Images.Add(IconReader.GetFolderIcon(IconSize.Small, type));
             ((ImageList)this._imageLists[1]).Images.Add(IconReader.GetFolderIcon(IconSize.Large, type));
         }
         else
         {
             ((ImageList)this._imageLists[0]).Images.Add(IconReader.GetFolderIcon(this._iconSize, type));
         }
         this.AddExtension(text, count);
         result = count;
     }
     return result;
 }

        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 PagedList<TravelerMessage> ListMessages(Guid travelerID, FolderType folder, int index = 0, int count = 10)
 {
     Traveler traveler = _repository.FindBy<Traveler>(t => t.TravelerID == travelerID);
     if (traveler == null) throw new TravelerNotFoundException();
     if (traveler.HasMessagesInFolder(folder))
         return traveler.Messages.Where(m => m.FolderID == (int)folder).ToPagedList(index, count);
     else
         return new PagedList<TravelerMessage>();
 }

        /// <summary>
        /// http://apidocs.mailchimp.com/api/2.0/folders/del.php
        /// </summary>
        /// <returns></returns>
        public Task<MailChimpServiceResponse> Delete(string name, int id, FolderType type)
        {
            var url = Urls.Folder + "/del.json";

            var request = new
            {
                fid = id,
                type = type
            };

            return Execute(url, request);
        }

        public GoogleDriveProviderInfo(int id, string providerKey, string customerTitle, string token, Guid owner, FolderType rootFolderType, DateTime createOn)
        {
            if (string.IsNullOrEmpty(providerKey)) throw new ArgumentNullException("providerKey");
            if (string.IsNullOrEmpty(token)) throw new ArgumentException("Token can't be null");

            ID = id;
            CustomerTitle = customerTitle;
            Owner = owner == Guid.Empty ? SecurityContext.CurrentAccount.ID : owner;

            ProviderKey = providerKey;
            _token = OAuth20Token.FromJson(token);
            _rootFolderType = rootFolderType;
            _createOn = createOn;
        }

        /// <summary>
        /// 以 FolderType 查詢實體存放資料夾
        /// </summary>
        /// <param name="folderType">資料夾類型</param>
        /// <param name="isCreate">是否建立資料夾</param>
        /// <returns>實體存放資料夾(絕對路徑)</returns>
        public DirectoryInfo GetStorageDirectory(FolderType folderType, bool isCreate)
        {
            string rootPath = GetStoragePath(FolderType.ROOT);
            string storagePath = GetStoragePath(folderType);
            m_Log.Debug("rootPath = " + rootPath);
            m_Log.Debug("storagePath = " + storagePath);
            DirectoryInfo dir = new DirectoryInfo(Path.Combine(rootPath, storagePath));

            if (isCreate && !dir.Exists)
            {
                dir.Create();
            }

            return dir;
        }

        public InventoryFolderBase GetFolderForType(UUID userID, FolderType type)
        {
            Dictionary<FolderType, InventoryFolderBase> ff = null;
            if (m_FolderTypes.TryGetValue(userID, out ff))
            {
                InventoryFolderBase f = null;

                lock (ff)
                {
                    if (ff.TryGetValue(type, out f))
                        return f;
                }
            }

            return null;
        }

        public SharePointProviderInfo(int id, string providerKey, string customerTitle, AuthData authData, Guid owner,
                                      FolderType rootFolderType, DateTime createOn)
        {
            if (string.IsNullOrEmpty(providerKey))
                throw new ArgumentNullException("providerKey");
            if (!string.IsNullOrEmpty(authData.Login) && string.IsNullOrEmpty(authData.Password))
                throw new ArgumentNullException("password", "Password can't be null");

            ID = id;
            ProviderKey = providerKey;
            CustomerTitle = customerTitle;
            Owner = owner == Guid.Empty ? SecurityContext.CurrentAccount.ID : owner;
            RootFolderType = rootFolderType;
            CreateOn = createOn;
            RootFolderId = MakeId();

            InitClientContext(authData);
        }

        public void Cache(UUID userID, FolderType type, InventoryFolderBase folder)
        {
            Dictionary<FolderType, InventoryFolderBase> ff = null;
            if (!m_FolderTypes.TryGetValue(userID, out ff))
            {
                ff = new Dictionary<FolderType, InventoryFolderBase>();
                m_FolderTypes.Add(userID, ff, CACHE_EXPIRATION_SECONDS);
            }

            // We need to lock here since two threads could potentially retrieve the same dictionary
            // and try to add a folder for that type simultaneously.  Dictionary<>.Add() is not described as thread-safe in the SDK
            // even if the folders are identical.
            lock (ff)
            {
                if (!ff.ContainsKey(type))
                    ff.Add(type, folder);
            }
        }

        public SharpBoxProviderInfo(int id, string providerKey, string customerTitle, AuthData authData, Guid owner, FolderType rootFolderType, DateTime createOn)
        {
            if (string.IsNullOrEmpty(providerKey))
                throw new ArgumentNullException("providerKey");
            if (string.IsNullOrEmpty(authData.Token) && string.IsNullOrEmpty(authData.Password))
                throw new ArgumentNullException("token", "Both token and password can't be null");
            if (!string.IsNullOrEmpty(authData.Login) && string.IsNullOrEmpty(authData.Password) && string.IsNullOrEmpty(authData.Token))
                throw new ArgumentNullException("password", "Password can't be null");

            ID = id;
            CustomerTitle = customerTitle;
            Owner = owner == Guid.Empty ? SecurityContext.CurrentAccount.ID : owner;

            _providerKey = (nSupportedCloudConfigurations) Enum.Parse(typeof (nSupportedCloudConfigurations), providerKey, true);
            _authData = authData;
            _rootFolderType = rootFolderType;
            _createOn = createOn;
        }

        /// <summary>
        /// http://apidocs.mailchimp.com/api/2.0/folders/add.php
        /// </summary>
        /// <returns></returns>
        public Task<MailChimpServiceResponse> AddAsync(string name, FolderType type)
        {
            var url = Urls.Folder + "/add.json";

            var request = new
            {
                name = name,
                type = Enum.GetName(typeof(FolderType), type).ToLowerInvariant()
            };

            return Execute(url, request).ContinueWith(t =>
            {
                // add an extra level of validation
                if (t.Result.IsSuccesful)
                    t.Result.IsSuccesful = t.Result.Json["complete"]
                                                   .ToObject<bool>();

                return t.Result;
            });
        }

 public static Icon GetFolderIcon(IconSize size, FolderType folderType)
 {
     uint num = 272u;
     if (FolderType.Open == folderType)
     {
         num |= 2u;
     }
     if (IconSize.Small == size)
     {
         num |= 1u;
     }
     else
     {
         num = num;
     }
     Shell32.SHFILEINFO sHFILEINFO = default(Shell32.SHFILEINFO);
     Shell32.SHGetFileInfo(Environment.CurrentDirectory, 16u, ref sHFILEINFO, (uint)Marshal.SizeOf(sHFILEINFO), num);
     Icon.FromHandle(sHFILEINFO.hIcon);
     Icon result = (Icon)Icon.FromHandle(sHFILEINFO.hIcon).Clone();
     User32.DestroyIcon(sHFILEINFO.hIcon);
     return result;
 }

        public static Icon GetFolderIcon(string path, IconSize size, FolderType folderType)
        {
            // Need to add size check, although errors generated at present!
            uint flags = SHGFI_ICON | SHGFI_USEFILEATTRIBUTES;

            if (FolderType.Open == folderType)
            {
                flags += SHGFI_OPENICON;
            }
            if (IconSize.Small == size)
            {
                flags += SHGFI_SMALLICON;
            }
            else
            {
                flags += SHGFI_LARGEICON;
            }
            // Get the folder icon
            var shfi = new SHFILEINFO();

            var res = SHGetFileInfo(path,
                FILE_ATTRIBUTE_DIRECTORY,
                out shfi,
                (uint)Marshal.SizeOf(shfi),
                flags);

            if (res == IntPtr.Zero)
                throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());

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

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

            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();

            // Flag SHGFI_USEFILEATTRIBUTES prevents SHGetFileInfo() from attempting
            // to access the path specified by the first argument.  However, passing 
            // some sort of non-null string is still required, or the call will fail.
            Shell32.SHGetFileInfo("C:\\Windows",
                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 static Icon ForGenericFolder(IconSize size, FolderType folderType)
        {
            // Need to add size check, although errors generated at present!
            NativeMethods.FileInfoFlags flags = NativeMethods.FileInfoFlags.SHGFI_ICON | NativeMethods.FileInfoFlags.SHGFI_USEFILEATTRIBUTES;

            if (FolderType.Open == folderType)
                flags |= NativeMethods.FileInfoFlags.SHGFI_OPENICON;

            flags |= (IconSize.Small == size) ? NativeMethods.FileInfoFlags.SHGFI_SMALLICON : NativeMethods.FileInfoFlags.SHGFI_LARGEICON;

            NativeMethods.SHFILEINFO shfi = new NativeMethods.SHFILEINFO();
            NativeMethods.SHGetFileInfo(
                null,
                NativeMethods.FILE_ATTRIBUTE_DIRECTORY,
                out shfi,
                (uint)Marshal.SizeOf(shfi),
                flags
                );

            Icon icon = (Icon)Icon.FromHandle(shfi.hIcon).Clone();
            NativeMethods.DestroyIcon(shfi.hIcon);		// Cleanup
            return icon;
        }

        public InventoryFolderBase GetFolderForType(UUID principalID, FolderType type)
        {
            Dictionary<string,object> ret = MakeRequest("GETFOLDERFORTYPE",
                    new Dictionary<string,object> {
                        { "PRINCIPAL", principalID.ToString() },
                        { "TYPE", ((int)type).ToString() }
                    });

            if (!CheckReturn(ret))
                return null;

            return BuildFolder((Dictionary<string, object>)ret["folder"]);
        }

 public IEnumerable<Folder> Search(string text, FolderType folderType)
 {
     return TryGetFolderDao().Search(text, folderType);
 }