/IZWebFileManager/FileManagerController.cs

// Copyright (C) 2006 Igor Zelmanovich <izwebfilemanager@gmail.com>

//

// This program is free software; you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation; either version 2 of the License, or

// (at your option) any later version.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



using System;

using System.Collections.Generic;

using System.Text;

using System.Web.UI;

using System.ComponentModel;

using System.Resources;

using IZ.WebFileManager.Components;

using System.Collections;

using System.Web.UI.WebControls;

using System.Collections.ObjectModel;

using System.IO;

using System.Web;

using System.Security.Permissions;

using System.Threading;

using System.Drawing;

using System.Globalization;

using System.Text.RegularExpressions;

using System.Runtime.Serialization;

using System.Drawing.Design;

using System.Web.Configuration;

using System.Security;



namespace IZ.WebFileManager

{

	[PersistChildren (false)]

	[ParseChildren (true)]

	public sealed partial class FileManagerController : Control, ICallbackEventHandler, IPostBackEventHandler

	{

		#region Fields



		internal static readonly Unit SmallImageWidth = 16;

		internal static readonly Unit SmallImageHeight = 16;

		internal static readonly Unit LargeImageWidth = 32;

		internal static readonly Unit LargeImageHeight = 32;

		static readonly Hashtable _imageExtension;

		static readonly bool _supportThumbnails;

		const string ThumbnailHandler = "IZWebFileManagerThumbnailHandler.ashx";



		Hashtable _fileExtensions;

		Hashtable _specialFolderPaths;

		ArrayList _hiddenFilesArray;

		Style _hiddenItemStyle;

		ArrayList _prohibitedFilesArray;

		readonly FileTypeCollection _fileTypeCollection = new FileTypeCollection ();

		readonly NewDocumentTemplateCollection _templates = new NewDocumentTemplateCollection ();

		readonly RootDirectoryCollection _rootDirectories = new RootDirectoryCollection ();

		readonly SpecialFolderCollection _specialFolders = new SpecialFolderCollection ();



		string _defaultFolderSmallImage;

		string _defaultFolderLargeImage;

		string _defaultFileSmallImage;

		string _defaultFileLargeImage;

		string _defaultRootFolderSmallImage;

		string _defaultRootFolderLargeImage;

		Dictionary<ToolbarImages, string> _toolbarImages;

		bool _toolbarImagesInitialized;

		bool _defailtsInitialized;



		string _callbackResult;

		string _callbackCommandArgument;

		FileManagerCommands _callbackCommand;

		FileManagerControlBase _callbackControl;



		#endregion



		#region Properties



		internal bool SupportThumbnails {

			get { return _supportThumbnails; }

		}



		[Themeable (false)]

		[Localizable (false)]

		[DefaultValue (false)]

		[Category ("Behavior")]

		public bool AllowOverwrite {

			get { return ViewState ["AllowOverwrite"] == null ? false : (bool) ViewState ["AllowOverwrite"]; }

			set { ViewState ["AllowOverwrite"] = value; }

		}



		[Themeable (false)]

		[Localizable (false)]

		[DefaultValue (true)]

		[Category ("Behavior")]

		public bool AllowUpload {

			get { return ViewState ["AllowUpload"] == null ? true : (bool) ViewState ["AllowUpload"]; }

			set { ViewState ["AllowUpload"] = value; }

		}



		/// <summary>

		/// When is set true, Delete, Move and Rename are not allowed, Default value it true.

		/// </summary>

		[Themeable (false)]

		[Localizable (false)]

		[DefaultValue (true)]

		[Category ("Behavior")]

		public bool AllowDelete {

			get { return ViewState ["AllowDelete"] == null ? true : (bool) ViewState ["AllowDelete"]; }

			set { ViewState ["AllowDelete"] = value; }

		}



		[Themeable (false)]

		[Localizable (false)]

		[DefaultValue (false)]

		[Category ("Behavior")]

		public bool ReadOnly {

			get { return ViewState ["ReadOnly"] == null ? false : (bool) ViewState ["ReadOnly"]; }

			set { ViewState ["ReadOnly"] = value; }

		}



		[Themeable (false)]

		[Localizable (false)]

		[DefaultValue (false)]

		[Category ("Behavior")]

		public bool DownloadOnDoubleClick {

			get { return ViewState ["DownloadOnDoubleClick"] == null ? false : (bool) ViewState ["DownloadOnDoubleClick"]; }

			set { ViewState ["DownloadOnDoubleClick"] = value; }

		}



		[DefaultValue ("IZWebFileManagerResource")]

		[Category ("Data")]

		public string ResourceClassKey {

			get { return ((ViewState ["ResourceClassKey"] == null) ? "IZWebFileManagerResource" : (string) ViewState ["ResourceClassKey"]); }

			set { ViewState ["ResourceClassKey"] = value; }

		}



		[DefaultValue (null)]

		[Category ("Appearance")]

		[Themeable (true)]

		public CultureInfo Culture {

			get { return ((ViewState ["Culture"] == null) ? null : (CultureInfo) ViewState ["Culture"]); }

			set { ViewState ["Culture"] = value; }

		}



		public Boolean IsRightToLeft { get { return CurrentUICulture.TextInfo.IsRightToLeft; } }



		[Browsable (false)]

		public CultureInfo CurrentUICulture { get { return Culture == null ? CultureInfo.CurrentUICulture : Culture; } }



		[DefaultValue ("")]

		[Category ("Action")]

		[Themeable (false)]

		[Localizable (false)]

		public string ClientOpenItemFunction {

			get { return ((ViewState ["ClientOpenItemFunction"] == null) ? String.Empty : (string) ViewState ["ClientOpenItemFunction"]); }

			set { ViewState ["ClientOpenItemFunction"] = value; }

		}



		[DefaultValue ("")]

		[Category ("Behavior")]

		[Themeable (false)]

		[Localizable (false)]

		public string HiddenFiles {

			get { return ((ViewState ["HiddenFiles"] == null) ? String.Empty : (string) ViewState ["HiddenFiles"]); }

			set { ViewState ["HiddenFiles"] = value; }

		}



		[DefaultValue ("")]

		[Category ("Behavior")]

		[Themeable (false)]

		[Localizable (false)]

		public string HiddenFilesAndFoldersPrefix {

			get { return (string) (ViewState ["HiddenFolderPrefix"] ?? String.Empty); }

			set { ViewState ["HiddenFolderPrefix"] = value; }

		}



		[DefaultValue (false)]

		[Category ("Behavior")]

		[Themeable (false)]

		[Localizable (false)]

		public bool ShowHiddenFilesAndFolders {

			get { return (bool) (ViewState ["ShowHiddenFolders"] ?? false); }

			set { ViewState ["ShowHiddenFolders"] = value; }

		}



		internal ArrayList HiddenFilesArray {

			get {

				if (_hiddenFilesArray == null)

					_hiddenFilesArray = InitExtensionsArray (HiddenFiles);

				return _hiddenFilesArray;

			}

		}



		internal Style HiddenItemStyle {

			get {

				if (_hiddenItemStyle == null) {

					_hiddenItemStyle = new HiddenItemStyle ();

				}

				return _hiddenItemStyle;

			}

		}



		[DefaultValue ("")]

		[Category ("Behavior")]

		[Themeable (false)]

		[Localizable (false)]

		public string ProhibitedFiles {

			get { return ((ViewState ["ProhibitedFiles"] == null) ? String.Empty : (string) ViewState ["ProhibitedFiles"]); }

			set { ViewState ["ProhibitedFiles"] = value; }

		}



		internal ArrayList ProhibitedFilesArray {

			get {

				if (_prohibitedFilesArray == null)

					_prohibitedFilesArray = InitExtensionsArray (ProhibitedFiles);

				return _prohibitedFilesArray;

			}

		}



		[MergableProperty (false)]

		[Category ("Behavior")]

		[PersistenceMode (PersistenceMode.InnerProperty)]

		[Localizable (false)]

		[Themeable (false)]

		public RootDirectoryCollection RootDirectories {

			get { return _rootDirectories; }

		}



		[MergableProperty (false)]

		[Category ("Behavior")]

		[PersistenceMode (PersistenceMode.InnerProperty)]

		[Localizable (false)]

		[Themeable (false)]

		public SpecialFolderCollection SpecialFolders {

			get { return _specialFolders; }

		}



		[MergableProperty (false)]

		[PersistenceMode (PersistenceMode.InnerProperty)]

		[Category ("Behavior")]

		[Localizable (false)]

		[Themeable (false)]

		public NewDocumentTemplateCollection Templates {

			get { return _templates; }

		}



		[MergableProperty (false)]

		[PersistenceMode (PersistenceMode.InnerProperty)]

		[Category ("Behavior")]

		[Localizable (false)]

		[Themeable (false)]

		public FileTypeCollection FileTypes {

			get { return _fileTypeCollection; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string FileSmallImageUrl {

			get { return ViewState ["FileSmallIconUrl"] == null ? String.Empty : (string) ViewState ["FileSmallIconUrl"]; }

			set { ViewState ["FileSmallIconUrl"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string FileLargeImageUrl {

			get { return ViewState ["FileLargeIconUrl"] == null ? String.Empty : (string) ViewState ["FileLargeIconUrl"]; }

			set { ViewState ["FileLargeIconUrl"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string FolderSmallImageUrl {

			get { return ViewState ["FolderSmallIconUrl"] == null ? String.Empty : (string) ViewState ["FolderSmallIconUrl"]; }

			set { ViewState ["FolderSmallIconUrl"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string FolderLargeImageUrl {

			get { return ViewState ["FolderLargeIconUrl"] == null ? String.Empty : (string) ViewState ["FolderLargeIconUrl"]; }

			set { ViewState ["FolderLargeIconUrl"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string RootFolderSmallImageUrl {

			get { return ViewState ["RootFolderSmallIconUrl"] == null ? String.Empty : (string) ViewState ["RootFolderSmallIconUrl"]; }

			set { ViewState ["RootFolderSmallIconUrl"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string RootFolderLargeImageUrl {

			get { return ViewState ["RootFolderLargeIconUrl"] == null ? String.Empty : (string) ViewState ["RootFolderLargeIconUrl"]; }

			set { ViewState ["RootFolderLargeIconUrl"] = value; }

		}



		[DefaultValue ("")]

		[Bindable (true)]

		public string ImagesFolder {

			get { return ViewState ["IconsFolder"] == null ? String.Empty : (string) ViewState ["IconsFolder"]; }

			set { ViewState ["IconsFolder"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string CopyImageUrl {

			get { return ViewState ["CopyIconUrl"] == null ? String.Empty : (string) ViewState ["CopyIconUrl"]; }

			set { ViewState ["CopyIconUrl"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string MoveImageUrl {

			get { return ViewState ["MoveIconUrl"] == null ? String.Empty : (string) ViewState ["MoveIconUrl"]; }

			set { ViewState ["MoveIconUrl"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string DeleteImageUrl {

			get { return ViewState ["DeleteIconUrl"] == null ? String.Empty : (string) ViewState ["DeleteIconUrl"]; }

			set { ViewState ["DeleteIconUrl"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string RenameImageUrl {

			get { return ViewState ["RenameIconUrl"] == null ? String.Empty : (string) ViewState ["RenameIconUrl"]; }

			set { ViewState ["RenameIconUrl"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string FolderUpImageUrl {

			get { return ViewState ["FolderUpIconUrl"] == null ? String.Empty : (string) ViewState ["FolderUpIconUrl"]; }

			set { ViewState ["FolderUpIconUrl"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string NewFolderImageUrl {

			get { return ViewState ["NewFolderImageUrl"] == null ? String.Empty : (string) ViewState ["NewFolderImageUrl"]; }

			set { ViewState ["NewFolderImageUrl"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string ViewImageUrl {

			get { return ViewState ["ViewIconUrl"] == null ? String.Empty : (string) ViewState ["ViewIconUrl"]; }

			set { ViewState ["ViewIconUrl"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string ProcessImageUrl {

			get { return ViewState ["ProcessIconUrl"] == null ? String.Empty : (string) ViewState ["ProcessIconUrl"]; }

			set { ViewState ["ProcessIconUrl"] = value; }

		}



		[Editor ("System.Web.UI.Design.ImageUrlEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof (UITypeEditor))]

		[DefaultValue ("")]

		[UrlProperty]

		[Bindable (true)]

		public string RefreshImageUrl {

			get { return ViewState ["RefreshImageUrl"] == null ? String.Empty : (string) ViewState ["RefreshImageUrl"]; }

			set { ViewState ["RefreshImageUrl"] = value; }

		}



		#endregion



		static FileManagerController () {

			_imageExtension = new Hashtable (StringComparer.OrdinalIgnoreCase);

			object o = new object ();

			_imageExtension [".gif"] = o;

			_imageExtension [".jpg"] = o;

			_imageExtension [".jpeg"] = o;

			_imageExtension [".png"] = o;



			try {

				HttpHandlerActionCollection handlers = ((HttpHandlersSection) WebConfigurationManager.GetSection ("system.web/httpHandlers")).Handlers;

				foreach (HttpHandlerAction action in handlers)

					if (String.Compare (action.Path, ThumbnailHandler, StringComparison.OrdinalIgnoreCase) == 0) {

						_supportThumbnails = true;

						break;

					}

			}

			catch (SecurityException) {

				_supportThumbnails = true;

			}

		}



		protected override void OnPreRender (EventArgs e) {

			base.OnPreRender (e);



			Page.ClientScript.RegisterClientScriptBlock (typeof (FileManagerController), "WebFileManager_DoCallback", GetDoCallbackScript (), true);

			Page.ClientScript.RegisterClientScriptResource (typeof (FileManagerController), "IZ.WebFileManager.resources.FileManagerController.js");

			Page.ClientScript.RegisterStartupScript (typeof (FileManagerController), ClientID, GetInitInstanceScript (), true);



			RegisterResources ();



			EnsureDefaults ();



			// register hidden item style

			if (!String.IsNullOrEmpty (HiddenFilesAndFoldersPrefix) || !String.IsNullOrEmpty (HiddenFiles))

				if (Page.Header != null)

					Page.Header.StyleSheet.RegisterStyle (HiddenItemStyle, this);

		}



		internal void EnsureToolbarImages () {

			if (_toolbarImagesInitialized)

				return;

			_toolbarImagesInitialized = true;

			InitToolbarImages ();

		}



		private void InitToolbarImages () {

			bool isImagesFolder = ImagesFolder.Length > 0;

			string imagesFolder = EnsureEndsWithSlash (ImagesFolder);

			_toolbarImages = new Dictionary<ToolbarImages, string> ();



			// Copy icon

			if (CopyImageUrl.Length > 0)

				_toolbarImages [ToolbarImages.Copy] = ResolveUrl (CopyImageUrl);

			else if (isImagesFolder)

				_toolbarImages [ToolbarImages.Copy] = ResolveUrl (imagesFolder + "Copy.gif");

			else

				_toolbarImages [ToolbarImages.Copy] = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.Copy.gif");



			// Delete icon

			if (DeleteImageUrl.Length > 0)

				_toolbarImages [ToolbarImages.Delete] = ResolveUrl (DeleteImageUrl);

			else if (isImagesFolder)

				_toolbarImages [ToolbarImages.Delete] = ResolveUrl (imagesFolder + "Delete.gif");

			else

				_toolbarImages [ToolbarImages.Delete] = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.Delete.gif");



			// Move icon

			if (MoveImageUrl.Length > 0)

				_toolbarImages [ToolbarImages.Move] = ResolveUrl (MoveImageUrl);

			else if (isImagesFolder)

				_toolbarImages [ToolbarImages.Move] = ResolveUrl (imagesFolder + "Move.gif");

			else

				_toolbarImages [ToolbarImages.Move] = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.Move.gif");



			// Rename icon

			if (RenameImageUrl.Length > 0)

				_toolbarImages [ToolbarImages.Rename] = ResolveUrl (RenameImageUrl);

			else if (isImagesFolder)

				_toolbarImages [ToolbarImages.Rename] = ResolveUrl (imagesFolder + "Rename.gif");

			else

				_toolbarImages [ToolbarImages.Rename] = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.Rename.gif");



			// Rename icon

			if (NewFolderImageUrl.Length > 0)

				_toolbarImages [ToolbarImages.NewFolder] = ResolveUrl (NewFolderImageUrl);

			else if (isImagesFolder)

				_toolbarImages [ToolbarImages.NewFolder] = ResolveUrl (imagesFolder + "NewFolder.gif");

			else

				_toolbarImages [ToolbarImages.NewFolder] = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.NewFolder.gif");



			// View icon

			if (ViewImageUrl.Length > 0)

				_toolbarImages [ToolbarImages.View] = ResolveUrl (ViewImageUrl);

			else if (isImagesFolder)

				_toolbarImages [ToolbarImages.View] = ResolveUrl (imagesFolder + "View.gif");

			else

				_toolbarImages [ToolbarImages.View] = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.View.gif");



			// FolderUp icon

			if (FolderUpImageUrl.Length > 0)

				_toolbarImages [ToolbarImages.FolderUp] = ResolveUrl (FolderUpImageUrl);

			else if (isImagesFolder)

				_toolbarImages [ToolbarImages.FolderUp] = ResolveUrl (imagesFolder + "FolderUp.gif");

			else

				_toolbarImages [ToolbarImages.FolderUp] = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.FolderUp.gif");



			// Process icon

			if (ProcessImageUrl.Length > 0)

				_toolbarImages [ToolbarImages.Process] = ResolveUrl (ProcessImageUrl);

			else if (isImagesFolder)

				_toolbarImages [ToolbarImages.Process] = ResolveUrl (imagesFolder + "Process.gif");

			else

				_toolbarImages [ToolbarImages.Process] = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.Process.gif");



			// Refresh icon

			if (RefreshImageUrl.Length > 0)

				_toolbarImages [ToolbarImages.Refresh] = ResolveUrl (RefreshImageUrl);

			else if (isImagesFolder)

				_toolbarImages [ToolbarImages.Refresh] = ResolveUrl (imagesFolder + "Refresh.gif");

			else

				_toolbarImages [ToolbarImages.Refresh] = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.Refresh.gif");

		}



		internal void EnsureDefaults () {

			if (_defailtsInitialized)

				return;

			_defailtsInitialized = true;

			InitDefaults ();

		}



		private void InitDefaults () {

			bool isImagesFolder = ImagesFolder.Length > 0;

			string imagesFolder = EnsureEndsWithSlash (ImagesFolder);



			if (RootFolderSmallImageUrl.Length > 0)

				_defaultRootFolderSmallImage = ResolveUrl (RootFolderSmallImageUrl);

			else if (isImagesFolder)

				_defaultRootFolderSmallImage = ResolveUrl (imagesFolder + "RootFolderSmall.gif");

			else

				_defaultRootFolderSmallImage = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.RootFolderSmall.gif");



			if (RootFolderLargeImageUrl.Length > 0)

				_defaultRootFolderLargeImage = ResolveUrl (RootFolderLargeImageUrl);

			else if (isImagesFolder)

				_defaultRootFolderLargeImage = ResolveUrl (imagesFolder + "RootFolderLarge.gif");

			else

				_defaultRootFolderLargeImage = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.RootFolderLarge.gif");



			if (FolderSmallImageUrl.Length > 0)

				_defaultFolderSmallImage = ResolveUrl (FolderSmallImageUrl);

			else if (isImagesFolder)

				_defaultFolderSmallImage = ResolveUrl (imagesFolder + "FolderSmall.gif");

			else

				_defaultFolderSmallImage = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.FolderSmall.gif");



			if (FolderLargeImageUrl.Length > 0)

				_defaultFolderLargeImage = ResolveUrl (FolderLargeImageUrl);

			else if (isImagesFolder)

				_defaultFolderLargeImage = ResolveUrl (imagesFolder + "FolderLarge.gif");

			else

				_defaultFolderLargeImage = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.FolderLarge.gif");



			if (FileSmallImageUrl.Length > 0)

				_defaultFileSmallImage = ResolveUrl (FileSmallImageUrl);

			else if (isImagesFolder)

				_defaultFileSmallImage = ResolveUrl (imagesFolder + "FileSmall.gif");

			else

				_defaultFileSmallImage = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.FileSmall.gif");



			if (FileLargeImageUrl.Length > 0)

				_defaultFileLargeImage = ResolveUrl (FileLargeImageUrl);

			else if (isImagesFolder)

				_defaultFileLargeImage = ResolveUrl (imagesFolder + "FileLarge.gif");

			else

				_defaultFileLargeImage = Page.ClientScript.GetWebResourceUrl (typeof (FileManagerController), "IZ.WebFileManager.resources.FileLarge.gif");

		}



		string EnsureEndsWithSlash (string path) {

			if (!path.EndsWith ("/"))

				return path + "/";

			return path;

		}



		private void InitFileTypes () {

			_fileExtensions = new Hashtable (StringComparer.OrdinalIgnoreCase);



			foreach (FileType fileType in FileTypes) {

				string [] exts = fileType.Extensions.Split (new char [] { ',' }, StringSplitOptions.RemoveEmptyEntries);

				foreach (string ext in exts) {

					_fileExtensions [ext.Trim ().Trim ('.')] = fileType;

				}

			}

		}



		private void InitSpecialFolders () {

			_specialFolderPaths = new Hashtable (StringComparer.OrdinalIgnoreCase);



			foreach (SpecialFolder folder in SpecialFolders) {

				if (folder.DirectoryPath.Length > 0) {

					string path = Page.MapPath (folder.DirectoryPath);

					_specialFolderPaths [path] = folder;

					if (path.EndsWith ("/"))

						path.TrimEnd ('/');

					else

						path = path + "/";

					_specialFolderPaths [path] = folder;

				}

			}

		}



		private static ArrayList InitExtensionsArray (string extList) {

			string [] exts = extList.Split (',');

			ArrayList array = new ArrayList ();

			foreach (string ext in exts) {

				array.Add (ext.Trim ().ToLower (CultureInfo.InvariantCulture).TrimStart ('.'));

			}

			return array;

		}



		internal FileType GetFileType (FileInfo file) {

			if (_fileExtensions == null)

				InitFileTypes ();

			string ext = file.Extension.TrimStart ('.');

			return (FileType) _fileExtensions [ext];

		}



		public string GetResourceString (string name, string defaultValue) {

			try {

				string value = (string) HttpContext.GetGlobalResourceObject (ResourceClassKey, name, CurrentUICulture);

				if (value == null)

					return defaultValue;

				return value;

			}

			catch (MissingManifestResourceException) {

				return defaultValue;

			}

		}



		internal void AddDirectionAttribute (HtmlTextWriter writer) {

			writer.AddAttribute (HtmlTextWriterAttribute.Dir, IsRightToLeft ? "rtl" : "ltr");

			writer.AddStyleAttribute (HtmlTextWriterStyle.Direction, IsRightToLeft ? "rtl" : "ltr");

		}



		internal const string ClientScriptObjectNamePrefix = "WFM_";

		private string GetInitInstanceScript () {

			return "var " + ClientScriptObjectNamePrefix + ClientID + "=new FileManagerController('" + ClientID + "','" + UniqueID + "','" + EventArgumentSplitter + "');\r\n";

		}



		private string GetDoCallbackScript () {

			StringBuilder sb = new StringBuilder ();

			sb.AppendLine ("function WebFileManager_DoCallback(target, argument, clientCallback, context, clientErrorCallback) {");

			sb.AppendLine (Page.ClientScript.GetCallbackEventReference ("target", "argument", "clientCallback", "context", "clientErrorCallback", false) + ";");

			sb.AppendLine ("}");



			return sb.ToString ();

		}



		internal string GetCommandEventReference (Control control, string command, string arg) {

			return ClientScriptObjectNamePrefix + ClientID + ".On" + command + "(" + ClientScriptObjectNamePrefix + control.ClientID + "," + arg + ")";

		}



		#region ICallbackEventHandler Members



		string GetCallbackResult () {

			EnsureDefaults ();



			switch (_callbackCommand) {

			case FileManagerCommands.Refresh:

				_callbackResult = _callbackControl.RenderContents ();

				break;

			case FileManagerCommands.FileViewSort:

				_callbackResult = _callbackControl.RenderContents ();

				break;

			case FileManagerCommands.FileViewChangeView:

				_callbackResult = _callbackControl.RenderContents ();

				break;

			case FileManagerCommands.FileViewShowInGroups:

				_callbackResult = _callbackControl.RenderContents ();

				break;

			}



			return _callbackResult;

		}



		void RaiseCallbackEvent (string eventArgument) {

			if (eventArgument == null)

				return;



			// Parse eventArgument

			string [] args = eventArgument.Split (new char [] { EventArgumentSplitter }, 3);

			_callbackControl = (FileManagerControlBase) fileMangerControls [args [0]];

			_callbackCommand = (FileManagerCommands) Enum.Parse (typeof (FileManagerCommands), args [1]);

			_callbackCommandArgument = null;

			if (args.Length > 2)

				_callbackCommandArgument = args [2];



			switch (_callbackCommand) {

			case FileManagerCommands.Refresh:

				break;

			case FileManagerCommands.FileViewSort:

				break;

			case FileManagerCommands.FileViewChangeView:

				break;

			case FileManagerCommands.FileViewShowInGroups:

				break;

			case FileManagerCommands.FileViewNavigate:

				_callbackResult = ProcessFileViewNavigate (_callbackControl.ResolveFileManagerItemInfo (DecodeURIComponent (_callbackCommandArgument)));

				break;

			case FileManagerCommands.ExecuteCommand:

				string [] inds = _callbackCommandArgument.Split (':');

				_callbackResult = ProcessExecuteCommand (_callbackControl.SelectedItems, int.Parse (inds [0], null), int.Parse (inds [1], null));

				break;

			default:

				if (ReadOnly)

					_callbackResult = String.Empty;

				else {

					switch (_callbackCommand) {

					case FileManagerCommands.Rename:

						if (!AllowDelete) {

							_callbackResult = String.Empty;

							break;

						}

						string [] paths = _callbackCommandArgument.Split (EventArgumentSplitter);

						_callbackResult = ProcessRename (_callbackControl.ResolveFileManagerItemInfo (DecodeURIComponent (paths [0])), DecodeURIComponent (paths [1]));

						break;

					case FileManagerCommands.NewDocument:

						int index = int.Parse (_callbackCommandArgument, null);

						NewDocumentTemplate template = Templates [index];

						FileManagerItemInfo dir = _callbackControl.GetCurrentDirectory ();

						_callbackResult = ProcessNewDocument (dir, template);

						break;

					case FileManagerCommands.NewFolder:

						_callbackResult = ProcessNewFolder (_callbackControl.GetCurrentDirectory ());

						break;

					case FileManagerCommands.SelectedItemsDelete:

						if (!AllowDelete) {

							_callbackResult = String.Empty;

							break;

						}

						EvaluateSelectedItemsActionCommand (IZ.WebFileManager.SelectedItemsAction.Delete);

						break;

					case FileManagerCommands.SelectedItemsCopyTo:

						EvaluateSelectedItemsActionCommand (IZ.WebFileManager.SelectedItemsAction.Copy);

						break;

					case FileManagerCommands.SelectedItemsMoveTo:

						if (!AllowDelete) {

							_callbackResult = String.Empty;

							break;

						}

						EvaluateSelectedItemsActionCommand (IZ.WebFileManager.SelectedItemsAction.Move);

						break;

					default:

						String message = "Not Implemented Command \"{0}\"";

						throw new ArgumentException (String.Format (null, message, _callbackCommand));

					}

				}

				break;

			}

		}



		private void EvaluateSelectedItemsActionCommand (SelectedItemsAction action) {

			_callbackResult = ProcessSelectedItemsAction (_callbackControl.CurrentDirectory, _callbackControl.ResolveFileManagerItemInfo (DecodeURIComponent (_callbackCommandArgument)), _callbackControl.SelectedItems, action);

		}



		private string ProcessSelectedItemsAction (FileManagerItemInfo srcDir, FileManagerItemInfo destDir, FileManagerItemInfo [] items, SelectedItemsAction action) {

			if (items.Length == 0)

				return "";



			SelectedItemsActionCancelEventArgs cancelArg = new SelectedItemsActionCancelEventArgs (action);

			foreach (FileManagerItemInfo item in items) {

				if (item.Directory.Exists && destDir.Directory.FullName.StartsWith (item.Directory.FullName, StringComparison.InvariantCultureIgnoreCase))

					return ClientMessageEventReference (GetResourceString ("DestinationFolderIsSubfolder", "The destination folder is a subfolder of the source folder."));

				cancelArg.SelectedItems.Add (item);

			}

			cancelArg.DestinationDirectory = destDir;

			OnSelectedItemsAction (cancelArg);

			if (cancelArg.Cancel) {

				return ClientMessageEventReference (cancelArg.ClientMessage);

			}



			StringBuilder sb = new StringBuilder ();



			switch (action) {

			case IZ.WebFileManager.SelectedItemsAction.Delete:

				if (ProcessSelectedItemsDelete (items))

					AddFolderTreeRefreshEventReference (sb, srcDir);

				break;

			case IZ.WebFileManager.SelectedItemsAction.Move:

				destDir.EnsureDirectoryExists ();

				if (ProcessSelectedItemsMoveTo (destDir, items)) {

					AddFolderTreeRequireRefreshEventReference (sb, srcDir, destDir);

					AddFolderTreeNavigateEventReference (sb, srcDir);

				}

				break;

			case IZ.WebFileManager.SelectedItemsAction.Copy:

				destDir.EnsureDirectoryExists ();

				if (ProcessSelectedItemsCopyTo (destDir, items)) {

					AddFolderTreeRequireRefreshEventReference (sb, srcDir, destDir);

					AddFolderTreeNavigateEventReference (sb, srcDir);

				}

				break;

			}





			SelectedItemsActionEventArgs args = new SelectedItemsActionEventArgs ();

			OnSelectedItemsActionComplete (args);



			sb.AppendLine (ClientRefreshEventReference);

			return sb.ToString ();



		}



		private bool ProcessSelectedItemsMoveTo (FileManagerItemInfo destDir, FileManagerItemInfo [] items) {

			bool b = false;

			foreach (FileManagerItemInfo item in items) {

				if (item.Directory.Exists) {

					b = true;

					DirectoryInfo dir = item.Directory;

					if (String.Compare (dir.Parent.FullName.TrimEnd (Path.DirectorySeparatorChar), destDir.PhysicalPath.TrimEnd (Path.DirectorySeparatorChar), true) == 0)

						continue;



					string newName;

					if (AllowOverwrite)

						newName = dir.Name;

					else

						newName = GetNotDuplicatedFolderName (destDir, dir.Name);

					string newPath = Path.Combine (destDir.PhysicalPath, newName);

					xDirectory.Copy (dir.FullName, newPath, true);

					dir.Delete (true);

				}

				else if (item.File.Exists) {

					FileInfo file = item.File;

					if (String.Compare (file.Directory.FullName.TrimEnd (Path.DirectorySeparatorChar), destDir.PhysicalPath.TrimEnd (Path.DirectorySeparatorChar), true) == 0)

						continue;



					string newName;

					if (AllowOverwrite)

						newName = file.Name;

					else

						newName = GetNotDuplicatedFileName (destDir, Path.GetFileNameWithoutExtension (file.FullName), file.Extension);

					string newPath = Path.Combine (destDir.PhysicalPath, newName);

					file.CopyTo (newPath, AllowOverwrite);

					file.Delete ();

				}

			}

			return b;

		}



		private bool ProcessSelectedItemsCopyTo (FileManagerItemInfo destDir, FileManagerItemInfo [] items) {

			bool b = false;

			foreach (FileManagerItemInfo item in items) {

				if (item.Directory.Exists) {

					b = true;

					DirectoryInfo dir = item.Directory;

					string newName;

					if (AllowOverwrite && String.Compare (dir.Parent.FullName.TrimEnd (Path.DirectorySeparatorChar), destDir.PhysicalPath.TrimEnd (Path.DirectorySeparatorChar), true) != 0)

						newName = dir.Name;

					else

						newName = GetNotDuplicatedFolderName (destDir, dir.Name);

					string newPath = Path.Combine (destDir.PhysicalPath, newName);

					xDirectory.Copy (dir.FullName, newPath, true);

				}

				else if (item.File.Exists) {

					FileInfo file = item.File;

					string newName;

					if (AllowOverwrite && String.Compare (file.Directory.FullName.TrimEnd (Path.DirectorySeparatorChar), destDir.PhysicalPath.TrimEnd (Path.DirectorySeparatorChar), true) != 0)

						newName = file.Name;

					else

						newName = GetNotDuplicatedFileName (destDir, Path.GetFileNameWithoutExtension (file.FullName), file.Extension);

					string newPath = Path.Combine (destDir.PhysicalPath, newName);

					file.CopyTo (newPath, AllowOverwrite);

				}

			}

			return b;

		}



		private bool ProcessSelectedItemsDelete (FileManagerItemInfo [] items) {

			bool b = false;

			foreach (FileManagerItemInfo item in items) {

				if (item.File.Exists)

					item.File.Delete ();

				else if (item.Directory.Exists) {

					b = true;

					item.Directory.Delete (true);

				}

			}

			return b;

		}



		private String ClientRefreshEventReference { get { return ClientScriptObjectNamePrefix + ClientID + ".OnRefresh(context,null)"; } }

		private string ClientMessageEventReference (string message) {

			string clientMessage = message;

			if (clientMessage == null || clientMessage.Length == 0)

				clientMessage = GetResourceString ("CannotCompleteOperation", "Cannot Complete Operation.");



			return "alert(decodeURIComponent('" + EncodeURIComponent (clientMessage) + "'))";

		}



		private string ProcessRename (FileManagerItemInfo fileManagerItemInfo, string newName) {

			RenameCancelEventArgs cancelArg = new RenameCancelEventArgs ();

			cancelArg.FileManagerItem = fileManagerItemInfo;

			cancelArg.NewName = newName;

			OnItemRenaming (cancelArg);

			if (cancelArg.Cancel) {

				return ClientMessageEventReference (cancelArg.ClientMessage);

			}



			if (cancelArg.NewName == null || cancelArg.NewName.Length == 0 || cancelArg.NewName.StartsWith (".")) {

				return ClientMessageEventReference (GetResourceString ("MustTypeFileName", "You must type a file name."));

			}



			if (!Validate (cancelArg.NewName)) {

				return ClientMessageEventReference (GetResourceString ("NotAllowedCharacters", "A file name cannot contain any of the following characters: \\/:*?\"<>|"));

			}



			if (fileManagerItemInfo.File.Exists) {

				string newFileExt = Path.GetExtension (cancelArg.NewName).ToLower (CultureInfo.InvariantCulture).TrimStart ('.');

				if (newFileExt.Length == 0 ||

					HiddenFilesArray.Contains (newFileExt) ||

					ProhibitedFilesArray.Contains (newFileExt))

					cancelArg.NewName += fileManagerItemInfo.File.Extension;

			}



			FileManagerItemInfo renamedItem = ResolveFileManagerItemInfo (fileManagerItemInfo.FileManagerPath.Substring (0, fileManagerItemInfo.FileManagerPath.LastIndexOf ('/')) + "/" + cancelArg.NewName);

			if (renamedItem.Directory.Exists || renamedItem.File.Exists) {

				string fileExistsMessage = GetResourceString ("CannotRenameFile", "Cannot rename file: A file with the name you specified already exists. Specify a different file name.");

				return ClientMessageEventReference (fileExistsMessage);

			}



			bool b = false;

			if (fileManagerItemInfo.Directory.Exists) {

				b = true;

				fileManagerItemInfo.Directory.MoveTo (renamedItem.PhysicalPath);

			}

			else if (fileManagerItemInfo.File.Exists) {

				fileManagerItemInfo.File.MoveTo (renamedItem.PhysicalPath);

			}



			RenameEventArgs arg = new RenameEventArgs ();

			arg.FileManagerItem = renamedItem;

			OnItemRenamed (arg);



			StringBuilder sb = new StringBuilder ();

			if (b)

				AddFolderTreeRefreshEventReference (sb, _callbackControl.CurrentDirectory);

			sb.AppendLine (ClientRefreshEventReference);

			return sb.ToString ();

		}



		internal static bool Validate (string name) {

			// \/:*?"<>|

			return !name.Contains ("\\") &&

				!name.Contains ("/") &&

				!name.Contains (":") &&

				!name.Contains ("*") &&

				!name.Contains ("?") &&

				!name.Contains ("\"") &&

				!name.Contains ("<") &&

				!name.Contains (">") &&

				!name.Contains ("|");



		}



		internal static string DecodeURIComponent (string str) {

			string res = HttpUtility.UrlDecode (str);

			return res;

		}

		internal static string EncodeURIComponent (string str) {

			string res = HttpUtility.UrlEncode (str);

			res = res.Replace ("+", "%20");

			res = res.Replace ("'", "%27");

			return res;

		}

		internal static string DecodeURI (string str) {

			string res = HttpUtility.UrlDecode (str);

			return res;

		}

		internal static string EncodeURI (string str) {

			string res = HttpUtility.UrlPathEncode (str);

			res = res.Replace ("+", "%20");

			return res;

		}



		string ProcessFileViewNavigate (FileManagerItemInfo item) {

			if (item.Directory.Exists) {

				StringBuilder sb = new StringBuilder ();

				AddFolderTreeNavigateEventReference (sb, item);

				sb.AppendLine ("var dir = '" + EncodeURIComponent (item.FileManagerPath) + "'");

				sb.AppendLine ("WebForm_GetElementById(context.ClientID+'_Directory').value = dir;");

				sb.AppendLine ("var address = WebForm_GetElementById(context.ClientID+'_Address');");

				sb.AppendLine ("if(address) address.value = decodeURIComponent(dir);");

				sb.AppendLine (ClientRefreshEventReference);

				return sb.ToString ();

			}

			else if (item.File.Exists) {

				return ProcessExecuteCommand (new FileManagerItemInfo [] { item }, 0, 0);

			}

			else

				return ClientMessageEventReference (GetResourceString ("CannotFindFile", "Cannot find file, Make sure the path is correct."));

		}



		internal string [] GetPathHashCodes (string fileManagerPath) {

			fileManagerPath = VirtualPathUtility.RemoveTrailingSlash (fileManagerPath);

			List<string> list = new List<string> ();

			int index = fileManagerPath.IndexOf ('/', 1);

			while (index > 0) {

				list.Add (GetPathHashCode (fileManagerPath.Substring (0, index)));

				index = fileManagerPath.IndexOf ('/', index + 1);

			}

			list.Add (GetPathHashCode (fileManagerPath));

			return list.ToArray ();

		}



		internal string GetPathHashCode (string fileManagerPath) {

			return VirtualPathUtility.RemoveTrailingSlash (fileManagerPath).ToLower ().GetHashCode ().ToString ("x");

		}



		private string ProcessExecuteCommand (FileManagerItemInfo [] items, int group, int index) {

			if (items.Length == 0)

				return "";



			if (group == 0) {

				FileManagerItemInfo item = items [0];



				if (item.Directory.Exists)

					return ProcessFileViewNavigate (item);



				// Default Command

				if (index == -1)

					return ProcessOpenCommand (item);

				else if (index == -2)

					return ProcessDownloadCommand (item);



				FileType ft = GetFileType (item.File);

				if (ft == null || ft.Commands.Count <= index)

					return DownloadOnDoubleClick ? ProcessDownloadCommand (item) : ProcessOpenCommand (item);



				return ProcessCommand (item, ft.Commands [index]);

			}

			else {

			}





			return "";

		}



		private string ProcessDownloadCommand (FileManagerItemInfo item) {

			String script = Page.ClientScript.GetPostBackEventReference (this, "Download:" + EncodeURIComponent (item.FileManagerPath)) + ";" +

				"theForm.__EVENTTARGET.value = '';theForm.__EVENTARGUMENT.value = '';";

			return script;

		}



		private string ProcessCommand (FileManagerItemInfo item, FileManagerCommand fileManagerCommand) {

			ExecuteCommandEventArgs arg = new ExecuteCommandEventArgs (fileManagerCommand.CommandName, fileManagerCommand.CommandArgument);

			arg.Items.Add (item);

			//arg.Command = fileManagerCommand;



			OnExecuteCommand (arg);



			return arg.ClientScript;

		}



		private string ProcessOpenCommand (FileManagerItemInfo item) {

			StringBuilder sb = new StringBuilder ();



			if (ClientOpenItemFunction.Length > 0) {

				sb.AppendLine (ClientOpenItemFunction + "('" + EncodeURI (item.VirtualPath) + "')");

			}

			else {

				sb.AppendLine ("var href = '" + EncodeURIComponent (item.VirtualPath) + "';");

				sb.AppendLine ("window.open(decodeURIComponent(href),'_blank');");

			}

			return sb.ToString ();

		}



		string ResolveAbsolutePath (ref string fileManagerPath) {

			Regex reg = new Regex (@"^((?<rootPath>/[^/]+)|(\[(?<rootIndex>\d+)\]))(?<dirPath>/.*)?");

			Match match = reg.Match (fileManagerPath);

			if (!match.Success)

				goto _throw;

			RootDirectory rootDirectory;

			string dirPath = match.Groups ["dirPath"].Value;

			string rootPath = match.Groups ["rootPath"].Value;

			string rootIndex = match.Groups ["rootIndex"].Value;

			if (!String.IsNullOrEmpty (rootPath))

				rootDirectory = RootDirectories [rootPath.Substring (1)];

			else {

				int index = Int32.Parse (rootIndex);

				if (index >= RootDirectories.Count)

					goto _throw;

				rootDirectory = RootDirectories [index];

				rootPath = "/" + rootDirectory.TextInternal;

			}

			if (rootDirectory == null)

				goto _throw;

			dirPath = Normalize (dirPath);

			fileManagerPath = rootPath + dirPath;

			string rootVPath = VirtualPathUtility.RemoveTrailingSlash (ResolveUrl (rootDirectory.DirectoryPath));

			string vPath = rootVPath + dirPath;



			return vPath;



		_throw:

			throw new ArgumentException ("Invalid file manager path.");

		}



		public FileManagerItemInfo ResolveFileManagerItemInfo (string fileManagerPath) {

			string virtualPath = ResolveAbsolutePath (ref fileManagerPath);

			string phisicalPath = Page.MapPath (virtualPath);

			return new FileManagerItemInfo (fileManagerPath, virtualPath, phisicalPath);

		}



		internal string ProcessFileUpload (FileManagerItemInfo destDir, System.Web.HttpPostedFile uploadedFile) {

			string script;

			if (AllowUpload)

				ProcessFileUpload (destDir, uploadedFile, out script);

			else

				script = ClientMessageEventReference (null);

			return script;

		}



		internal bool ProcessFileUpload (FileManagerItemInfo destDir, System.Web.HttpPostedFile uploadedFile, out string script) {

			UploadFileCancelEventArgs cancelArg = new UploadFileCancelEventArgs ();

			cancelArg.DestinationDirectory = destDir;

			cancelArg.PostedFile = uploadedFile;

			OnFileUploading (cancelArg);



			if (cancelArg.Cancel) {

				script = ClientMessageEventReference (cancelArg.ClientMessage);

				return false;

			}



			string saveName = cancelArg.SaveName;

			string fileNameWithoutExtension = saveName.Substring (0, saveName.LastIndexOf ('.'));

			string extension = saveName.Substring (saveName.LastIndexOf ('.'));



			string ext = extension.ToLower (CultureInfo.InvariantCulture).TrimStart ('.');

			if (HiddenFilesArray.Contains (ext) ||

					ProhibitedFilesArray.Contains (ext)) {

				script = ClientMessageEventReference (null);

				return false;

			}



			string newFileName = GetNotDuplicatedFileName (destDir, fileNameWithoutExtension, extension);

			FileManagerItemInfo itemInfo = ResolveFileManagerItemInfo (VirtualPathUtility.AppendTrailingSlash (destDir.FileManagerPath) + newFileName);



			uploadedFile.SaveAs (itemInfo.PhysicalPath);



			UploadFileEventArgs arg = new UploadFileEventArgs ();

			arg.UploadedFile = itemInfo;

			OnFileUploaded (arg);



			script = ClientRefreshEventReference;

			return true;

		}



		private static string GetNotDuplicatedFileName (FileManagerItemInfo destDir, string fileNameWithoutExtension, string extension) {

			string fileName = fileNameWithoutExtension;

			int i = 1;

			string originNewFileName = fileNameWithoutExtension;

			while (File.Exists (Path.Combine (destDir.PhysicalPath, fileName + extension))) {

				fileName = originNewFileName + "(" + i + ")";

				i++;

			}

			return fileName + extension;

		}



		private static string GetNotDuplicatedFolderName (FileManagerItemInfo destDir, string folderName) {

			string newFolderName = folderName;

			int i = 1;

			string originNewFolderName = folderName;

			while (Directory.Exists (Path.Combine (destDir.PhysicalPath, newFolderName))) {

				newFolderName = originNewFolderName + "(" + i + ")";

				i++;

			}

			return newFolderName;

		}



		private string ProcessNewFolder (FileManagerItemInfo destDir) {

			NewFolderCancelEventArgs cancelArg = new NewFolderCancelEventArgs ();

			cancelArg.DestinationDirectory = destDir;

			OnNewFolderCreating (cancelArg);



			if (cancelArg.Cancel) {

				return ClientMessageEventReference (cancelArg.ClientMessage);

			}



			string folderName = GetResourceString ("New_Folder_Name", "New Folder");



			string newFolderName = GetNotDuplicatedFolderName (destDir, folderName);



			FileManagerItemInfo itemInfo = ResolveFileManagerItemInfo (VirtualPathUtility.AppendTrailingSlash (destDir.FileManagerPath) + newFolderName);

			itemInfo.EnsureDirectoryExists ();



			NewFolderEventArgs arg = new NewFolderEventArgs ();

			arg.NewFolder = itemInfo;

			OnNewFolderCreated (arg);



			StringBuilder sb = new StringBuilder ();

			AddFolderTreeRefreshEventReference (sb, destDir);

			sb.AppendLine (ClientRefreshEventReference);

			return sb.ToString ();

		}



		void AddFolderTreeNavigateEventReference (StringBuilder sb, FileManagerItemInfo itemInfo) {

			sb.AppendLine ("var folderTree = window['WFM_' + context.ClientID + '_FolderTree'];");

			sb.AppendLine ("if(folderTree) {folderTree.Navigate (['" + String.Join ("','", GetPathHashCodes (itemInfo.FileManagerPath)) + "'],0);}");

		}



		void AddFolderTreeRefreshEventReference (StringBuilder sb, FileManagerItemInfo itemInfo) {

			sb.AppendLine ("var folderTree = window['WFM_' + context.ClientID + '_FolderTree'];");

			sb.AppendLine ("if(folderTree) {folderTree.Refresh ('" + GetPathHashCode (itemInfo.FileManagerPath) + "');}");

		}



		void AddFolderTreeRequireRefreshEventReference (StringBuilder sb, FileManagerItemInfo srcInfo, FileManagerItemInfo destInfo) {

			sb.AppendLine ("var folderTree = window['WFM_' + context.ClientID + '_FolderTree'];");

			sb.AppendLine ("if(folderTree) {folderTree.RequireRefresh (['" + GetPathHashCode (srcInfo.FileManagerPath) + "','" + String.Join ("','", GetPathHashCodes (destInfo.FileManagerPath)) + "']);}");

		}



		private string ProcessNewDocument (FileManagerItemInfo destDir, NewDocumentTemplate template) {

			NewDocumentCancelEventArgs cancelArg = new NewDocumentCancelEventArgs ();

			cancelArg.DestinationDirectory = destDir;

			cancelArg.Template = template;

			OnNewDocumentCreating (cancelArg);



			if (cancelArg.Cancel) {

				return ClientMessageEventReference (cancelArg.ClientMessage);

			}



			if (template.MasterFileUrl.Length == 0)

				return "";



			FileInfo masterFile = new FileInfo (Page.MapPath (template.MasterFileUrl));

			if (!masterFile.Exists)

				return "";



			string newFileName = template.NewFileName;

			if (newFileName.Length == 0)

				newFileName = template.Name;



			int i = 1;

			string originNewFileName = newFileName;

			while (File.Exists (Path.Combine (destDir.PhysicalPath, newFileName + masterFile.Extension))) {

				newFileName = originNewFileName + "(" + i + ")";

				i++;

			}

			newFileName = newFileName + masterFile.Extension;

			FileManagerItemInfo itemInfo = ResolveFileManagerItemInfo (VirtualPathUtility.AppendTrailingSlash (destDir.FileManagerPath) + newFileName);

			FileInfo newDocument = masterFile.CopyTo (itemInfo.PhysicalPath);



			NewDocumentEventArgs arg = new NewDocumentEventArgs ();

			arg.Template = template;

			arg.NewDocument = itemInfo;

			OnNewDocumentCreated (arg);



			return ClientRefreshEventReference;

		}



		#endregion





		Hashtable fileMangerControls = new Hashtable ();

		internal void RegisterComponent (FileManagerControlBase control) {

			fileMangerControls [control.ClientID] = control;

		}



		internal const char EventArgumentSplitter = ':';



		internal string GetItemSmallImage (FileSystemInfo fsi) {

			DirectoryInfo dir = fsi as DirectoryInfo;

			if (dir != null)

				return GetFolderSmallImage (dir);

			else

				return GetFileSmallImage ((FileInfo) fsi);

		}



		SpecialFolder GetSpecialFolder (DirectoryInfo dir) {

			if (_specialFolderPaths == null)

				InitSpecialFolders ();

			return (SpecialFolder) _specialFolderPaths [dir.FullName];

		}



		[System.Diagnostics.CodeAnalysis.SuppressMessage ("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "dir")]

		internal string GetFolderSmallImage (DirectoryInfo dir) {

			if (dir == null)

				return _defaultFolderSmallImage;

			SpecialFolder folder = GetSpecialFolder (dir);

			if (folder != null && folder.SmallImageUrl.Length > 0)

				return ResolveUrl (folder.SmallImageUrl);

			return _defaultFolderSmallImage;

		}



		internal string GetFolderSmallImage () {

			return GetFolderSmallImage (null);

		}



		internal string GetFileSmallImage () {

			return GetFileSmallImage (null);

		}



		internal string GetFileSmallImage (FileInfo file) {

			if (file == null)

				return _defaultFileSmallImage;

			FileType fileType = GetFileType (file);

			if (fileType != null && fileType.SmallImageUrl.Length > 0)

				return ResolveUrl (fileType.SmallImageUrl);

			return _defaultFileSmallImage;

		}



		internal string GetItemLargeImage (FileSystemInfo fsi) {

			DirectoryInfo dir = fsi as DirectoryInfo;

			if (dir != null)

				return GetFolderLargeImage (dir);

			else

				return GetFileLargeImage ((FileInfo) fsi);

		}



		internal string GetItemThumbnailImage (FileSystemInfo fsi, FileManagerItemInfo currentDirectory) {

			FileInfo file = fsi as FileInfo;

			if (file == null)

				return GetFolderLargeImage ((DirectoryInfo) fsi);



			if (IsImage (file))

				return ResolveUrl ("~/" + ThumbnailHandler + "?" + HttpUtility.UrlEncode (currentDirectory.VirtualPath + "/" + file.Name));



			return GetFileLargeImage (file);

		}



		bool IsImage (FileInfo file) {

			return _imageExtension [file.Extension] != null;

		}



		private string GetFileLargeImage (FileInfo file) {

			if (file == null)

				return _defaultFileLargeImage;

			FileType fileType = GetFileType (file);

			if (fileType != null && fileType.LargeImageUrl.Length > 0)

				return ResolveUrl (fileType.LargeImageUrl);

			return _defaultFileLargeImage;

		}

		private string GetFileLargeImage () {

			return GetFileLargeImage (null);

		}

		[System.Diagnostics.CodeAnalysis.SuppressMessage ("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "dir")]

		private string GetFolderLargeImage (DirectoryInfo dir) {

			if (dir == null)

				return _defaultFolderLargeImage;

			SpecialFolder folder = GetSpecialFolder (dir);

			if (folder != null && folder.LargeImageUrl.Length > 0)

				return ResolveUrl (folder.LargeImageUrl);

			return _defaultFolderLargeImage;

		}



		private string GetRootFolderLargeImage (RootDirectory rootDir) {

			if (rootDir == null)

				return _defaultRootFolderLargeImage;

			if (rootDir.LargeImageUrl.Length > 0)

				return rootDir.LargeImageUrl;

			return _defaultRootFolderLargeImage;

		}



		internal string GetRootFolderSmallImage () {

			return GetRootFolderSmallImage (null);

		}



		internal string GetRootFolderSmallImage (RootDirectory rootDir) {

			if (rootDir == null)

				return _defaultRootFolderSmallImage;

			if (rootDir.SmallImageUrl.Length > 0)

				return rootDir.SmallImageUrl;

			return _defaultRootFolderSmallImage;

		}



		internal string GetToolbarImage (ToolbarImages image) {

			EnsureToolbarImages ();

			return _toolbarImages [image];

		}



		internal void RegisterResources () {

			string initScript = "var " + ClientScriptObjectNamePrefix + ClientID + "DeleteConfirm" + "='" + EncodeURIComponent (GetResourceString ("DeleteConfirm", "Are you sure you want to delete selected items?")) + "';\r\n" +

				"var " + ClientScriptObjectNamePrefix + ClientID + "SelectDestination" + "='" + EncodeURIComponent (GetResourceString ("SelectDestination", "Select destination directory")) + "';\r\n";

			Page.ClientScript.RegisterStartupScript (typeof (FileManagerController), ClientID + "Resources", initScript, true);

		}



		#region IPostBackEventHandler Members



		void IPostBackEventHandler.RaisePostBackEvent (string eventArgument) {

			RaisePostBackEvent (eventArgument);

		}



		void RaisePostBackEvent (string eventArgument) {

			string [] args = eventArgument.Split (new char [] { ':' }, 2);

			switch (args [0]) {

			case "Download":

				FileManagerItemInfo fmi = ResolveFileManagerItemInfo (DecodeURIComponent (args [1]));

					var e= new DownloadFileCancelEventArgs() {DownloadFile = fmi};

					OFileDownload(e);

					if (!e.Cancel)

					{

						string file = fmi.PhysicalPath;

						if (File.Exists(file))

						{

							Page.Response.Clear();

							Page.Response.ContentType = "application/octet-stream";

							Page.Response.AddHeader("Content-Disposition",

							                        "attachment;filename=" + EncodeURIComponent(Path.GetFileName(file)));

							Page.Response.Flush();

							Page.Response.WriteFile(file);

						}

						Page.Response.End ();

					}

				break;

			}

		}



		private void OFileDownload(DownloadFileCancelEventArgs e)

		{

			if (FileDownload != null)

				FileDownload(this, e);

		}



		#endregion



		protected override object SaveViewState () {

			object [] states = new object [5];



			states [0] = base.SaveViewState ();

			states [1] = ((IStateManager) RootDirectories).SaveViewState ();

			states [2] = ((IStateManager) FileTypes).SaveViewState ();

			states [3] = ((IStateManager) Templates).SaveViewState ();

			states [4] = ((IStateManager) SpecialFolders).SaveViewState ();



			for (int i = 0; i < states.Length; i++) {

				if (states [i] != null)

					return states;

			}

			return null;

		}



		protected override void LoadViewState (object savedState) {

			if (savedState == null)

				return;



			object [] states = (object []) savedState;



			base.LoadViewState (states [0]);

			((IStateManager) RootDirectories).LoadViewState (states [1]);

			((IStateManager) FileTypes).LoadViewState (states [2]);

			((IStateManager) Templates).LoadViewState (states [3]);

			((IStateManager) SpecialFolders).LoadViewState (states [4]);

		}



		protected override void TrackViewState () {

			base.TrackViewState ();



			((IStateManager) RootDirectories).TrackViewState ();

			((IStateManager) FileTypes).TrackViewState ();

			((IStateManager) Templates).TrackViewState ();

			((IStateManager) SpecialFolders).TrackViewState ();

		}



		#region ICallbackEventHandler Members



		string ICallbackEventHandler.GetCallbackResult () {

			return GetCallbackResult ();

		}



		void ICallbackEventHandler.RaiseCallbackEvent (string eventArgument) {

			RaiseCallbackEvent (eventArgument);

		}



		#endregion



		static char [] path_sep = { '/' };



		static string Normalize (string path) {



			if (path.Length == 1) // '/' 

				return path;



			path = Canonize (path);



			int dotPos = path.IndexOf ('.');

			while (dotPos >= 0) {

				if (++dotPos == path.Length)

					break;



				char nextChar = path [dotPos];



				if ((nextChar == '/') || (nextChar == '.'))

					break;



				dotPos = path.IndexOf ('.', dotPos);

			}



			if (dotPos < 0)

				return path;



			bool ends_with_slash = false;



			if (path [path.Length - 1] == '/')

				ends_with_slash = true;



			string [] parts = path.Split (path_sep, StringSplitOptions.RemoveEmptyEntries);

			int end = parts.Length;



			int dest = 0;



			for (int i = 0; i < end; i++) {

				string current = parts [i];

				if (current == ".")

					continue;



				if (current == "..") {

					dest--;



					if (dest < 0)

						dest = 0;

					continue;

				}



				parts [dest] = current;



				dest++;

			}



			StringBuilder str = new StringBuilder ();



			for (int i = 0; i < dest; i++) {

				str.Append ('/');

				str.Append (parts [i]);

			}



			if (str.Length > 0) {

				if (ends_with_slash)

					str.Append ('/');

			}

			else {

				return "/";

			}



			return str.ToString ();

		}



		static string Canonize (string path) {

			int index = -1;

			for (int i = 0; i < path.Length; i++) {

				if ((path [i] == '\\') || (path [i] == '/' && (i + 1) < path.Length && (path [i + 1] == '/' || path [i + 1] == '\\'))) {

					index = i;

					break;

				}

			}

			if (index < 0)

				return path;



			StringBuilder sb = new StringBuilder (path.Length);

			sb.Append (path, 0, index);



			for (int i = index; i < path.Length; i++) {

				if (path [i] == '\\' || path [i] == '/') {

					int next = i + 1;

					if (next < path.Length && (path [next] == '\\' || path [next] == '/'))

						continue;

					sb.Append ('/');

				}

				else {

					sb.Append (path [i]);

				}

			}



			return sb.ToString ();

		}



	}

}