private void OnRenamed(object source, RenamedEventArgs e)
 {
     // Specify what is done when a file is renamed.
     mainForm.addFileChange("File: " + e.OldFullPath + " renamed to " + e.FullPath);
     FileEvent fe = new FileEvent(++eventnum, e.ChangeType, e.FullPath, e.OldFullPath);
     proc.addevent(ref fe);
 }

 private void ProxyRename(object sender, RenamedEventArgs e)
 {
     if (e.Name.ToLowerInvariant() == _localFileName)
     {
         Reparse();
     }
 }

		private void fsWather_Renamed(object sender, RenamedEventArgs e)
		{
			if (Renamed != null)
			{
				Renamed(this, e);
			}
		}

        void FileSystemWatcher_Renamed(object sender, RenamedEventArgs e)
        {
            ListViewItem lvi = GetListViewItem(e.OldFullPath);

            if(lvi != null)
                ListViewItemCreator.SetListViewItemValues(lvi, GetFileSystemInfo(e.FullPath), this.exRepListView);
        }

 private  void OnRenamed(object source, RenamedEventArgs e)
 {
     
     int index = MakeReserve();
     writeLog(e.FullPath + " " + e.ChangeType + " <" + index + ">");
     Console.WriteLine("File: {0} renamed to {1}", e.OldFullPath, e.FullPath);
 }

 private void Watcher_Renamed(object sender, RenamedEventArgs e)
 {
     var delete = new FileSystemEventArgs(WatcherChangeTypes.Deleted, Path.GetDirectoryName(e.OldFullPath), Path.GetFileName(e.OldName));
     var create = new FileSystemEventArgs(WatcherChangeTypes.Created, Path.GetDirectoryName(e.FullPath), Path.GetFileName(e.Name));
     queue.Enqueue(delete);
     queue.Enqueue(create);   
 }

        private async void Renamed(RenamedEventArgs renamedEventArgument, Func<string, bool, Task> updateBundle)
        {
            using (await rwLock.ReadLockAsync())
            {
                if (!_watchedFiles.ContainsKey(renamedEventArgument.OldFullPath) ||
                    !renamedEventArgument.FullPath.StartsWith(ProjectHelpers.GetSolutionFolderPath(), StringComparison.OrdinalIgnoreCase))
                    return;
            }

            HashSet<Tuple<string, FileSystemWatcher>> oldValue;

            using (await rwLock.ReadLockAsync())
            {
                oldValue = _watchedFiles[renamedEventArgument.OldFullPath];
            }

            using (await rwLock.WriteLockAsync())
            {
                _watchedFiles.Remove(renamedEventArgument.OldFullPath);
            }

            _document = await _document.LoadFromFile(renamedEventArgument.FullPath);

            foreach (Tuple<string, FileSystemWatcher> tuple in oldValue)
            {
                tuple.Item2.EnableRaisingEvents = false;

                tuple.Item2.Dispose();

                if (_extensions.Any(e => tuple.Item1.EndsWith(e, StringComparison.OrdinalIgnoreCase)))
                    await AttachFileObserver(_document, _document.FileName, updateBundle);
                else
                    await AttachFileObserver(_document, tuple.Item1, updateBundle);
            }
        }

        /// <summary>
        /// Обработчик события переименования папки
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public static void Rename(object sender, RenamedEventArgs e)
        {
            Model.Dir dir = Model.Dir.FindByPath(e.OldFullPath);
            dir.RenameOnServer(e.FullPath);

            Helpers.ApplicationHelper.SetCurrentTimeToSettings();
        }

 public FileEventArgs(WatcherChangeTypes changeType, string fullname, string name, RenamedEventArgs renameArgs)
 {
     this.ChangeType = changeType;
     this.FullPath = fullname;
     this.Name = name;
     RenameName = renameArgs;
 }

 private void OnRenamed(object sender, RenamedEventArgs e)
 {
     if (!m_bDirty)
     {
         m_bDirty = true;
     }
 }

 public void ProcessActionItems(RenamedEventArgs e, FSEventType type)
 {
     foreach(FswatchRuleActionItem actionitem in this.__actionitems)
     {
         actionitem.InvokeAction(e, type);
     }
 }

 private void OnRenamedInternal(object sender, RenamedEventArgs e)
 {
     _logger.Info("Config file renamed from " + e.OldFullPath + " to " + e.FullPath);
     DirectoryToMonitor = e.FullPath;
     _changeMonitor.Filter = Path.GetFileName(e.FullPath);
     ConfigRenamed(e.OldFullPath, e.FullPath);
 }

 private static void FileRenamed_Handler(object source, RenamedEventArgs e)
 {
     _countFileChangeEvent++;
     Console.WriteLine("FileEvent {0} : {1} - Old Path : {2} New Path : {3}",
         _countFileChangeEvent.ToString("#00"), e.ChangeType, e.OldFullPath, e.FullPath);
     m_timer.Change(TimeoutMillis, System.Threading.Timeout.Infinite);
 }

 private void FolderWatcherTest_Renamed(object sender, RenamedEventArgs e)
 {
     Invoke(new Action(() =>
     {
         listBox2.Items.Add("Renamed " + e.OldFullPath + " => " + e.FullPath + " " + sender.ToString());
     }));
 }

        private void BranchWatcher_Renamed(object sender, RenamedEventArgs e)
        {
            if (!string.Equals(e.Name, "branch", StringComparison.InvariantCultureIgnoreCase))
                return;

            RequestCurrentBadgeRefresh();
        }

 private static void OnRenamed(object source, RenamedEventArgs e)
 {
     var o = e.OldName;
     var n = e.Name;
     LogRepo.Create(Timestamp.Now, e.ChangeType.ToString(), e.FullPath, e.OldName);
     ConsoleLogger.Log(Timestamp.Now + " File: {0} renamed to {1}", o, n);
 }

        private static void OnRenamed(object source, RenamedEventArgs e)
        {
            // Specify what is done when a file is renamed.
            ////console.WriteLine("File: {0} renamed to {1} ", e.OldFullPath, e.FullPath);

            //console.WriteLine("File: {0} {1} to {2} and FileName: {3} finally, Old File Name: {4}", e.OldFullPath, e.ChangeType, e.FullPath, e.Name, e.OldName);

            DataStore.Filenode toBeQueueNode = new DataStore.Filenode();
            toBeQueueNode.setNewPath(e.FullPath);
            toBeQueueNode.setAction(e.ChangeType.ToString());
            toBeQueueNode.setOldPath(e.OldFullPath);
            toBeQueueNode.setCloudDestinationPath(null); //indetermined, requires modification

            /*try
            {
                FileInfo oldfileinfo = new FileInfo(e.OldFullPath);
                FileInfo newfileinfo = new FileInfo(e.FullPath);

                oldfileinfo.Refresh();
                //console.WriteLine("Old File LastWriteTime" + oldfileinfo.LastWriteTime);
                newfileinfo.Refresh();
                //console.WriteLine("New File lastWriteTime" + newfileinfo.LastWriteTime);

                if (oldfileinfo.Exists)
                {
                    //console.WriteLine("Old File Length in Bytes: " + oldfileinfo.Length);
                }

                if (newfileinfo.Exists)
                {
                    //console.WriteLine("New File Length in Bytes: " + newfileinfo.Length);
                }

                if (oldfileinfo.LastWriteTime.CompareTo(newfileinfo.LastWriteTime) < 0)
                {
                    //console.WriteLine("New File Info has later modification time");
                }
                else if (oldfileinfo.LastWriteTime.CompareTo(newfileinfo.LastWriteTime) > 0)
                {
                    //console.WriteLine("Old File Info has later modification time");
                }
                else
                {
                    //they are the same
                    //console.WriteLine("Same Modification Time");
                }

            }
            catch (Exception ex)
            {
                //exception thrown
                //console.WriteLine("Length Write Time Exception");
            }*/

            if (Entry.Entry.checkWave(e.Name) || Entry.Entry.checkTmp(e.Name))
                return;

               Entry.Entry.fileQueue.Enqueue(toBeQueueNode);
        }

 void fsw_Renamed(object sender, RenamedEventArgs e)
 {
     txtActivity.Invoke(
     (MethodInvoker)delegate {
     txtActivity.AppendText(e.ChangeType.ToString() + " : " + e.Name + "\n");
       }
       );
 }

        private void OnRenamed(object source, RenamedEventArgs e)
        {

            // Specify what is done when a file is renamed.
            ReaderFileWip22();
            ReaderFileWip23();
            ReaderFileWip21();
        }

 private static void OnRenamed(object source, RenamedEventArgs ev)
 {
     ProcessChangeOnlyOnce(ev, e =>
     {
         ConsoleWriteLineSeparator();
         Console.WriteLine("RENAMED to: \"{0}\"", RelativePath(e.FullPath));
         ProcessChange(e.FullPath);
     });
 }