public void HandleAction(string input, FileAction action)
 {
     switch (action)
     {
         case FileAction.NewFolder:
             {
                 Directory.CreateDirectory(comboDrive.Text + txtAddress.Text + input);
                 ProcessDirectories(new DirectoryInfo(comboDrive.Text + txtAddress.Text));
                 break;
             }
         case FileAction.NewFile:
             {
                 File.Create(comboDrive.Text + txtAddress.Text + input);
                 ProcessDirectories(new DirectoryInfo(comboDrive.Text + txtAddress.Text));
                 break;
             }
         case FileAction.Delete:
             {
                 if (input.ToLower() == listDir.SelectedItems[0].Text.ToLower())
                 {
                     if (Directory.Exists(comboDrive.Text + txtAddress.Text + listDir.SelectedItems[0].Text))
                         Directory.Delete(comboDrive.Text + txtAddress.Text + listDir.SelectedItems[0].Text);
                     else if (File.Exists(comboDrive.Text + txtAddress.Text + listDir.SelectedItems[0].Text))
                         File.Delete(comboDrive.Text + txtAddress.Text + listDir.SelectedItems[0].Text);
                 }
                 else
                     MessageBox.Show("Error: File/Directory does not exsist.");
                 ProcessDirectories(new DirectoryInfo(comboDrive.Text + txtAddress.Text));
                 break;
             }
     }
 }

        /// <summary>
        ///  Gets called after a file action was perforem for example after a rename or copy.
        /// </summary>
        /// <param name="man">ManagerEngine reference that the plugin is assigned to.</param>
        /// <param name="action">File action type.</param>
        /// <param name="file1">File object 1 for example from in a copy operation.</param>
        /// <param name="file2">File object 2 for example to in a copy operation. Might be null in for example a delete.</param>
        /// <returns>true/false if the execution of the event chain should continue execution.</returns>
        public override bool OnFileAction(ManagerEngine man, FileAction action, IFile file1, IFile file2)
        {
            if (action != FileAction.Add)
                return true;

            HttpResponse response = HttpContext.Current.Response;
            HttpRequest request = HttpContext.Current.Request;
            HttpCookie cookie;
            ArrayList chunks;

            if ((cookie = request.Cookies["upl"]) == null)
                cookie = new HttpCookie("upl");

            cookie.Expires = DateTime.Now.AddDays(30);

            if (cookie.Value != null) {
                chunks = new ArrayList(cookie.Value.Split(new char[]{','}));

                if (chunks.IndexOf(man.EncryptPath(file1.AbsolutePath)) == -1)
                    chunks.Add(man.EncryptPath(file1.AbsolutePath));

                cookie.Value = this.Implode(chunks, ",");
            } else
                cookie.Value = man.EncryptPath(file1.AbsolutePath);

            response.Cookies.Remove("upl");
            response.Cookies.Add(cookie);

            return true;
        }

        public void ApplyTo(string startDir, IEnumerable<string> filters, FileAction action)
        {
            var enumerable = filters as IList<string> ?? filters.ToList();
            foreach (var filter in enumerable)
            {
                var files = EnumerateFiles(startDir, filter);
                if (files == null)
                    return;
                foreach (var file in files)
                {
                    action(file);
                }
            } try
            {

                foreach (var directory in Directory.GetDirectories(startDir))
                {
                    ApplyTo(directory, enumerable, action);
                }
            }
            catch (Exception)
            {
                return;
            }
        }

 private void OnFileChange(FileAction action, string fileName, long ticks)
 {
     DateTime minValue;
     if (ticks == 0L)
     {
         minValue = DateTime.MinValue;
     }
     else
     {
         minValue = DateTimeUtil.FromFileTimeToUtc(ticks);
     }
     if (action == FileAction.Dispose)
     {
         if (this._rootCallback.IsAllocated)
         {
             this._rootCallback.Free();
         }
     }
     else if (this._ndirMonCompletionHandle.Handle != IntPtr.Zero)
     {
         using (new ApplicationImpersonationContext())
         {
             this._dirMon.OnFileChange(action, fileName, minValue);
         }
     }
 }

		internal SaveOperationAsyncResult(StorageDevice device, string container, string file, FileAction action, FileMode mode)
		{
			this.storageDevice = device;
			this.containerName = container;
			this.fileName = file;
			this.fileAction = action;
			this.fileMode = mode;
		}

 private void saveBtn_Click(object sender, RoutedEventArgs e)
 {
     var type = (FileAction.ActionType)Enum.Parse(typeof(FileAction.ActionType), operationCmb.Text);
     var action = new FileAction(type, new FileAction.ActionData() { FileName = fileNameCmb.Text, TargetVar = valueCmb.Text });
     var entity = new StepEntity(action);
     entity.Comment = string.Format("File Action {0}", operationCmb.Text);
     Singleton.Instance<SaveData>().AddStepEntity(entity);
 }

 public frmInput(frmMain frmObject, string title, string msg, FileAction action)
 {
     InitializeComponent();
     _obj = frmObject;
     this.Text = title;
     lblInfo.Text = msg;
     _action = action;
     this.Show();
     this.Focus();
 }

 private static bool ExcludedAction(FileAction fileAction)
 {
     switch (fileAction)
     {
         case FileAction.Delete:
         case FileAction.DeleteFrom:
         case FileAction.DeleteInto:
         case FileAction.MoveDelete:
         case FileAction.Purge:
             return true;
         default:
             return false;
     }
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="man"></param>
        /// <param name="action"></param>
        /// <param name="file1"></param>
        /// <param name="file2"></param>
        /// <returns></returns>
        public override bool OnBeforeFileAction(ManagerEngine man, FileAction action, IFile file1, IFile file2)
        {
            ManagerConfig config;

            if (action == FileAction.Delete) {
                config = file1.Config;

                if (config.GetBool("filesystem.delete_format_images", false)) {
                    ImageUtils.DeleteFormatImages(file1.AbsolutePath, config.Get("upload.format"));
                    ImageUtils.DeleteFormatImages(file1.AbsolutePath, config.Get("edit.format"));
                }
            }

            return true;
        }

		/// <summary>
		/// Saves a file asynchronously.
		/// </summary>
		/// <param name="containerName">The name of the container in which to save the file.</param>
		/// <param name="fileName">The file to save.</param>
		/// <param name="saveAction">The save action to perform.</param>
		/// <param name="userState">A state object used to identify the async operation.</param>
		public void SaveAsync(string containerName, string fileName, FileAction saveAction, object userState)
		{
			// increment our pending operations count
			PendingOperationsIncrement();

			// get a FileOperationState and fill it in
			FileOperationState state = GetFileOperationState();
			state.Container = containerName;
			state.File = fileName;
			state.Action = saveAction;
			state.UserState = userState;

			// queue up the work item
			ThreadPool.QueueUserWorkItem(DoSaveAsync, state);
		}

		/// <summary>
		/// Loads a file.
		/// </summary>
		/// <param name="containerName">Used to match the ISaveDevice interface; ignored by the implementation.</param>
		/// <param name="fileName">The file to load.</param>
		/// <param name="loadAction">The load action to perform.</param>
		/// <returns>True if the load completed without error, false otherwise.</returns>
		public bool Load(string containerName, string fileName, FileAction loadAction)
		{
			if (!Directory.Exists(RootDirectory))
				Directory.CreateDirectory(RootDirectory);

			string path = Path.Combine(RootDirectory, fileName);
			try
			{
				using (FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read))
					loadAction(stream);
				return true;
			}
			catch
			{
				return false;
			}
		}

		/// <summary>
		/// Saves a file.
		/// </summary>
		/// <param name="containerName">Used to match the ISaveDevice interface; ignored by the implementation.</param>
		/// <param name="fileName">The file to save.</param>
		/// <param name="saveAction">The save action to perform.</param>
		/// <returns>True if the save completed without errors, false otherwise.</returns>
		public bool Save(string containerName, string fileName, FileAction saveAction)
		{
			if (!Directory.Exists(RootDirectory))
				Directory.CreateDirectory(RootDirectory);

			string path = Path.Combine(RootDirectory, fileName);
			try
			{
				using (FileStream stream = new FileStream(path, FileMode.Create, FileAccess.Write))
					saveAction(stream);
				return true;
			}
			catch 
			{
				return false; 
			}
		}

		/// <summary>
		/// Loads a file.
		/// </summary>
		/// <param name="containerName">The name of the container from which to load the file.</param>
		/// <param name="fileName">The file to load.</param>
		/// <param name="loadAction">The load action to perform.</param>
		public void Load(String containerName, string fileName, FileAction loadAction)
		{
			VerifyIsReady();

			// lock on the storage device so that only one storage operation can occur at a time
			lock (storageDevice)
			{
				// open a container
				using (StorageContainer currentContainer = OpenContainer(containerName))
				{
					// attempt the load
					using (var stream = currentContainer.OpenFile(fileName, FileMode.Open))
					{
						loadAction(stream);
					}
				}
			}
		}

		/// <summary>
		/// Saves a file.
		/// </summary>
		/// <param name="containerName">The name of the container in which to save the file.</param>
		/// <param name="fileName">The file to save.</param>
		/// <param name="saveAction">The save action to perform.</param>
		public void Save(string containerName, string fileName, FileAction saveAction)
		{
			VerifyIsReady();

			// lock on the storage device so that only one storage operation can occur at a time
			lock (storageDevice)
			{
				// open a container
				using (StorageContainer currentContainer = OpenContainer(containerName))
				{
					// attempt the save
					using (var stream = currentContainer.CreateFile(fileName))
					{
						saveAction(stream);
					}
				}
			}
		}

        /// <summary>
        /// Asks the user to choose a file through an OpenFileDialog
        /// </summary>
        /// <param name="action">The action we want to do with the file</param>
        /// <returns>The file name chosen by the user</returns>
        public string ChooseFile(FileAction action)
        {
            FileDialog fileDialog;

            switch (action)
            {
                case FileAction.Save:
                    fileDialog = new SaveFileDialog();
                    break;

                case FileAction.Open:
                    fileDialog = new OpenFileDialog();
                    break;

                default:
                    throw new ArgumentException("The argument should be a valid FileAction enum value.", "action");
            }

            fileDialog.ShowDialog();

            return fileDialog.FileName;
        }

		/// <summary>
		/// Saves a file.
		/// </summary>
		/// <param name="containerName">The name of the container in which to save the file.</param>
		/// <param name="fileName">The file to save.</param>
		/// <param name="saveAction">The save action to perform.</param>
		public void Save(String containerName, string fileName, FileAction saveAction)
		{
			VerifyIsReady();

#if SILVERLIGHT
            throw new NotSupportedException();
#else

			// lock on the storage device so that only one storage operation can occur at a time
			lock (storageDevice)
			{
				// open a container
				using (StorageContainer currentContainer = OpenContainer(containerName))
				{
                  	// attempt the save
					using (var stream = currentContainer.CreateFile(fileName))
					{
						saveAction(stream);
					}
				}
			}
#endif
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="man"></param>
        /// <param name="action"></param>
        /// <param name="file1"></param>
        /// <param name="file2"></param>
        /// <returns></returns>
        public override bool OnFileAction(ManagerEngine man, FileAction action, IFile file1, IFile file2)
        {
            IFile thumbnailFolder, thumbnail;
            ManagerConfig config;

            switch (action) {
                case FileAction.Add:
                    config = file1.Config;

                    if (config.Get("upload.format") != null)
                        ImageUtils.FormatImage(file1.AbsolutePath, config.Get("upload.format"), config.GetInt("upload.autoresize_jpeg_quality", 90));

                    if (config.GetBool("upload.create_thumbnail", true))
                        thumbnail = this.MakeThumb(man, file1);

                    if (config.GetBool("upload.autoresize", false)) {
                        string ext = PathUtils.GetExtension(file1.Name).ToLower();
                        int newWidth, newHeight, configWidth, configHeight;
                        double scale;

                        // Validate format
                        if (ext != "gif" && ext != "jpeg" && ext != "jpg" && ext != "png")
                            return true;

                        MediaInfo imageInfo = new MediaInfo(file1.AbsolutePath);

                        configWidth = config.GetInt("upload.max_width", 1024);
                        configHeight = config.GetInt("upload.max_height", 768);

                        // Needs scaling?
                        if (imageInfo.Width > configWidth || imageInfo.Height > configHeight) {
                            scale = Math.Min(configWidth / (double) imageInfo.Width, configHeight / (double) imageInfo.Height);
                            newWidth = scale > 1 ? imageInfo.Width : (int) Math.Floor(imageInfo.Width * scale);
                            newHeight = scale > 1 ? imageInfo.Height : (int) Math.Floor(imageInfo.Height * scale);

                            ImageUtils.ResizeImage(file1.AbsolutePath, file1.AbsolutePath, newWidth, newHeight, config.GetInt("upload.autoresize_jpeg_quality", 90));
                        }
                    }

                    break;

                case FileAction.Delete:
                    config = file1.Config;

                    if (config.GetBool("thumbnail.delete", true)) {
                        thumbnailFolder = man.GetFile(file1.Parent, config["thumbnail.folder"]);
                        thumbnail = man.GetFile(thumbnailFolder.AbsolutePath, config.Get("thumbnail.prefix", "mcith") + file1.Name);

                        if (thumbnail.Exists)
                            thumbnail.Delete();

                        // Delete empty thumbnail folder
                        if (thumbnailFolder.Exists && thumbnailFolder.ListFiles().Length == 0)
                            thumbnailFolder.Delete();
                    }
                    break;
            }

            return true;
        }

        /// <summary>
        /// Asynchronously uploads a local file specified in the path parameter to the remote FTP server.   
        /// </summary>
        /// <param name="localPath">Path to a file on the local machine.</param>
        /// <param name="action">The type of put action taken.</param>
        /// <remarks>
        /// The file is uploaded to the current working directory on the remote server. 
        /// </remarks>
        /// <seealso cref="PutFileAsyncCompleted"/>
        /// <seealso cref="FtpBase.CancelAsync"/>
        /// <seealso cref="PutFile(string, string, FileAction)"/>
        /// <seealso cref="PutFileUnique(string)"/>
        /// <seealso cref="GetFile(string, string, FileAction)"/>
        /// <seealso cref="GetFileAsync(string, string, FileAction)"/>
        /// <seealso cref="MoveFile"/>
        /// <seealso cref="FxpCopy"/>
        /// <seealso cref="FxpCopyAsync"/>    
        public void PutFileAsync(string localPath, FileAction action)
        {
            if (base.AsyncWorker != null && base.AsyncWorker.IsBusy)
                throw new InvalidOperationException("The FtpClient object is already busy executing another asynchronous operation.  You can only execute one asychronous method at a time.");

            base.CreateAsyncWorker();
            base.AsyncWorker.WorkerSupportsCancellation = true;
            base.AsyncWorker.DoWork += new DoWorkEventHandler(PutFileLocalAsync_DoWork);
            base.AsyncWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(PutFileAsync_RunWorkerCompleted);
            Object[] args = new Object[2];
            args[0] = localPath;
            args[1] = action;
            base.AsyncWorker.RunWorkerAsync(args);
        }

 internal FileChangeEvent(FileAction action, string fileName)
 {
     this.Action = action;
     this.FileName = fileName;
 }

 /// <summary>
 /// Uploads a local file specified in the path parameter to the remote FTP server.   
 /// </summary>
 /// <param name="localPath">Path to a file on the local machine.</param>
 /// <param name="action">The type of put action taken.</param>
 /// <remarks>
 /// The file is uploaded to the current working directory on the remote server. 
 /// </remarks>
 /// <seealso cref="PutFileAsync(string, string, FileAction)"/>
 /// <seealso cref="PutFileUnique(string)"/>
 /// <seealso cref="GetFile(string, string, FileAction)"/>
 /// <seealso cref="GetFileAsync(string, string, FileAction)"/>
 /// <seealso cref="MoveFile"/>
 /// <seealso cref="FxpCopy"/>
 /// <seealso cref="FxpCopyAsync"/>            
 public void PutFile(string localPath, FileAction action)
 {
     using (FileStream fileStream = File.OpenRead(localPath))
     {
         PutFile(fileStream, ExtractPathItemName(localPath), action);
     }
 }