async void RenameSubmit_Clicked(object sender, EventArgs e)
{
var newname = input.Text.Trim();
if (!WindowsNamingRules.IsNameCorrect(newname))
{
await DisplayAlert(Resource.Error, Resource.UnacceptableSymbols, Resource.Ok);
return;
}
_ = input.Hide();
if (newname == Name)
{
return;
}
IsBusy = true;
var result = await DataBase.Manager.EditNameAsync(Name, newname);
IsBusy = false;
if (result == DataBase.ReturnCode.Success)
{
Renamed?.Invoke(this, new RenameEventArgs(Name, newname));
Name = newname;
}
else
{
await DisplayAlert(Resource.Error, Resource.RenamingError + " " + result.GetDescription(), Resource.Ok);
}
}
private void HandleChange(string oldDirectoryName, string newDirectoryName)
{
var wasRepository = WasRepository(oldDirectoryName, out var oldRepository);
var isRepository = IsRepository(newDirectoryName, out var newRepository);
var isNameChanged = !string.Equals(oldDirectoryName, newDirectoryName, StringComparison.OrdinalIgnoreCase);
if (wasRepository && isRepository)
{
if (isNameChanged)
{
_repositories.Remove(oldDirectoryName);
_repositories[newRepository.Name] = newRepository;
Renamed?.Invoke(oldRepository, newRepository);
}
}
else if (wasRepository)
{
_repositories.Remove(oldDirectoryName);
Removed?.Invoke(oldRepository);
}
else if (isRepository)
{
_repositories[newRepository.Name] = newRepository;
Added?.Invoke(newRepository);
}
}
internal void OnRenamed(object sender, RenamedEventArgs e)
{
if (e.FullPath.EndsWith(".module.dll"))
{
Renamed?.Invoke(null, new ModuleEventArgs(e.ChangeType, e.FullPath.Replace(e.Name, String.Empty), e.Name, e.OldName));
}
}
/// <summary>
/// Renames the project with the specified name.
/// </summary>
/// <param name="name">The name.</param>
public void Rename(string name)
{
var oldName = Name;
var newName = name;
Renamed?.Invoke(this, new RenamedProjectEventArgs(oldName, newName));
}
private void RaiseEventForChange([NotNull] FakeFileSystemVersionedChange change)
{
string rootDirectory = change.RootDirectory.GetText();
switch (change.ChangeType)
{
case WatcherChangeTypes.Created:
{
Created?.Invoke(this, new FileSystemEventArgs(change.ChangeType, rootDirectory, change.RelativePath));
break;
}
case WatcherChangeTypes.Deleted:
{
Deleted?.Invoke(this, new FileSystemEventArgs(change.ChangeType, rootDirectory, change.RelativePath));
break;
}
case WatcherChangeTypes.Changed:
{
Changed?.Invoke(this, new FileSystemEventArgs(change.ChangeType, rootDirectory, change.RelativePath));
break;
}
case WatcherChangeTypes.Renamed:
{
Renamed?.Invoke(this,
new RenamedEventArgs(change.ChangeType, rootDirectory, change.RelativePath,
change.PreviousRelativePathInRename));
break;
}
}
}
public void Rename(string name, string fullName, string description)
{
_name = name;
_fullName = fullName;
_description = description;
Renamed?.Invoke(this, name, fullName, description);
}
private void watcher_Renamed(object sender, RenamedEventArgs e)
{
if (reIgnore.IsMatch(e.FullPath))
{
return;
}
Renamed?.Invoke(this, e);
}
public void VirtualDesktopRenamed(IVirtualDesktop pDesktop, string chName)
{
var desktop = pDesktop.ToVirtualDesktop();
desktop._name = chName;
Renamed?.Invoke(this, new VirtualDesktopRenamedEventArgs(desktop, chName));
}
/// <summary>
/// Raises the <see cref="Renamed"/> event.
/// </summary>
/// <param name="args">Arguments for the event.</param>
public void RaiseRenamed(FileRenamedEventArgs args)
{
if (!ShouldRaiseEvent(args))
{
return;
}
Renamed?.Invoke(this, args);
}
public static void RaiseRenamed(object sender, VirtualDesktop pDesktop, string name)
{
var oldName = pDesktop.Name;
pDesktop.SetNameToCache(name);
var args = new VirtualDesktopRenamedEventArgs(pDesktop, oldName, name);
Renamed?.Invoke(sender, args);
}
public void RenameDir(string source, string newSource)
{
WriteDebugLog("INFO", $"RenameDir {source} => {newSource}");
try
{
Directory.Move(Win32Path(PathDoc2Repo(source)), Win32Path(PathDoc2Repo(newSource)));
}
catch (Exception ex) { WriteDebugLog("ERROR", ex); }
Renamed?.Invoke(this, newSource);
}
private void OnChanged(object s, FileSystemEventArgs e)
{
if (e.FullPath != TempPath)
{
return;
}
if (e.ChangeType != WatcherChangeTypes.Changed)
{
return;
}
try
{
var newFiles = File.ReadAllLines(TempPath);
var filesChanged = 0;
for (var i = 0; i < FileList.Length; i++)
{
var oldFileName = FileList[i];
var newFileName = newFiles[i];
if (oldFileName == newFileName)
{
continue;
}
File.Move(oldFileName, newFileName);
filesChanged++;
}
Renamed?.Invoke(this, new RenamedEventArgs(filesChanged));
}
catch (Exception ex)
{
using var dialog = new TaskDialog()
{
Caption = "Renamer",
Icon = TaskDialogStandardIcon.Error,
Text = "An error has occured while renaming files.",
DetailsCollapsedLabel = "Show exception details",
DetailsExpandedLabel = "Hide exception details",
DetailsExpandedText = ex.ToString(),
StandardButtons = TaskDialogStandardButtons.Ok
};
dialog.Show();
}
finally
{
File.Delete(TempPath);
}
Watcher.Dispose();
}
public FileSystemWatcherWrapper(string path, string filter = null, bool recursive = false)
{
this.path = path;
this.filter = filter;
fileSystemWatcher = filter == null ? new FileSystemWatcher(path) : new FileSystemWatcher(path, filter);
fileSystemWatcher.IncludeSubdirectories = recursive;
fileSystemWatcher.Changed += (sender, args) => Changed?.Invoke(sender, args);
fileSystemWatcher.Created += (sender, args) => Created?.Invoke(sender, args);
fileSystemWatcher.Deleted += (sender, args) => Deleted?.Invoke(sender, args);
fileSystemWatcher.Error += (sender, args) => Error?.Invoke(sender, args);
fileSystemWatcher.Renamed += (sender, args) => Renamed?.Invoke(sender, args);
}
public void Rename(string source, string newSource)
{
string src = GetIdByName(source);
bool exist = false;
lock (Files)
{
exist = Files.ContainsKey(src);
if (exist)
{
var vers = Files[src];
Files.Remove(src);
foreach (RepoFile f in vers)
{
f.SourceRename(newSource);
}
string newid = GetIdByName(newSource);
if (Files.ContainsKey(newid))
{
var currVers = Files[newid];
foreach (var i in vers)
{
bool repoFileExist = false;
foreach (var j in currVers)
{
if (GetIdByName(i.FullName) == GetIdByName(j.FullName))
{
repoFileExist = true; break;
}
}
if (!repoFileExist)
{
currVers.Add(i);
}
}
}
else
{
Files.Add(GetIdByName(newSource), vers);
}
}
}
if (exist)
{
Renamed?.Invoke(this, newSource);
}
else
{
MakeCopy(newSource);
}
}
internal void Rename(string newName)
{
XmlHelper req = new XmlHelper("<Request/>");
req.AddElement(".", "ContractName", this.Contract.Name);
req.AddElement(".", "PackageName", this.Name);
req.AddElement(".", "NewPackageName", newName);
MainForm.CurrentProject.SendRequest("UDSManagerService.RenamePackage", new Envelope(req));
this.Name = newName;
if (Renamed != null)
{
Renamed.Invoke(this, EventArgs.Empty);
}
}
public void RenameDir(string source, string newSource)
{
if (source[1] != ':')
{
throw new ArgumentException("不支持的路径格式", nameof(source));
}
if (newSource[1] != ':')
{
throw new ArgumentException("不支持的路径格式", nameof(newSource));
}
string src = GetIdByName(source) + Path.DirectorySeparatorChar,
newsrc = GetIdByName(newSource) + Path.DirectorySeparatorChar;
Directory.Move(Win32PathPrefix + Path.Combine(RepoPath, source[0] + source.Substring(2)),
Win32PathPrefix + Path.Combine(RepoPath, newSource[0] + newSource.Substring(2)));
lock (Files)
{
Dictionary <string, List <RepoFile> > adds = new Dictionary <string, List <RepoFile> >();
List <string> removes = new List <string>();
foreach (var f in Files)
{
if (f.Key.StartsWith(src))
{
removes.Add(f.Key);
foreach (var rf in f.Value)
{
rf.SourceRenameDir(source, newSource);
}
adds.Add(newsrc + f.Key.Substring(src.Length), f.Value);
}
}
foreach (var f in removes)
{
Files.Remove(f);
}
foreach (var f in adds)
{
Files.Add(f.Key, f.Value);
}
}
Renamed?.Invoke(this, newSource);
}
internal void Rename(string newName)
{
XmlHelper req = new XmlHelper("<Request/>");
req.AddElement(".", "ContractName", this.Name);
req.AddElement(".", "NewContractName", newName);
MainForm.CurrentProject.SendRequest("UDSManagerService.RenameContract", new Envelope(req));
XmlHelper pref = new XmlHelper(MainForm.CurrentProject.Preference);
XmlElement e = pref.GetElement("Property[@Name='UDS']/Contract[@Name='" + this.Name + "']");
e.SetAttribute("Name", newName);
MainForm.CurrentProject.UpdateProjectPreference(pref.GetElement("."));
this.Name = newName;
if (Renamed != null)
{
Renamed.Invoke(this, EventArgs.Empty);
}
}
internal void Rename(string newName)
{
newName = newName.ToLower();
XmlHelper req = new XmlHelper("<Request/>");
req.AddElement(".", "TableName", this.Name);
req.AddElement(".", "NewName", newName);
MainForm.CurrentProject.SendRequest("UDTService.DDL.RenameTable", new Envelope(req));
XmlHelper pref = new XmlHelper(MainForm.CurrentProject.Preference);
XmlElement e = pref.GetElement("Property[@Name='UDT']/UDT[@Name='" + this.Name + "']");
e.SetAttribute("Name", newName);
MainForm.CurrentProject.UpdateProjectPreference(pref.GetElement("."));
this.Name = newName;
if (Renamed != null)
{
Renamed.Invoke(this, EventArgs.Empty);
}
}
public void Rename(string source, string newSource)
{
WriteDebugLog("INFO", $"Rename {source} => {newSource}");
var newName = Path.GetFileNameWithoutExtension(newSource);
foreach (var ver in FindVersions(source))
{
try
{
string verName = Path.GetFileName(ver);
string newPath = Win32Path(
Path.Combine(Path.GetDirectoryName(ver),
newName + verName.Substring(verName.LastIndexOf('_'))));
if (File.Exists(newPath))
{
new FileInfo(newPath).Attributes &= ~FileAttributes.ReadOnly;
File.Delete(newPath);
}
File.Move(Win32Path(ver), newPath);
}
catch (Exception ex) { WriteDebugLog("ERROR", ex); }
}
Renamed?.Invoke(this, newSource);
}
private void WatcherEvent(object sender, FileSystemEventArgs e)
{
if (_lastFileChangePath?.FullPath == e.FullPath && DateTime.Now.Subtract(_lastFileChangeTime).TotalMilliseconds <= _bufferTimeInMilliseconds)
{
return;
}
_lastFileChangePath = e;
_lastFileChangeTime = DateTime.Now;
switch (e.ChangeType)
{
case WatcherChangeTypes.Changed:
Changed?.Invoke(sender, e);
break;
case WatcherChangeTypes.Created:
Created?.Invoke(sender, e);
break;
case WatcherChangeTypes.Deleted:
Deleted?.Invoke(sender, e);
break;
case WatcherChangeTypes.Renamed:
Renamed?.Invoke(sender, e);
break;
default:
Changed?.Invoke(sender, e);
Created?.Invoke(sender, e);
Deleted?.Invoke(sender, e);
Renamed?.Invoke(sender, e);
break;
}
}
private void handleEvents(object sender, FSEventStreamEventsArgs args)
{
foreach (var e in args.Events) {
if ((e.Flags & FSEventStreamEventFlags.ItemModified) != 0) {
if (Filter?.Invoke(e.Path) ?? true) {
Changed?.Invoke(e.Path);
}
}
if ((e.Flags & FSEventStreamEventFlags.ItemCreated) != 0) {
if (Filter?.Invoke(e.Path) ?? true) {
Created?.Invoke(e.Path);
}
}
if ((e.Flags & FSEventStreamEventFlags.ItemRemoved) != 0) {
if (Filter?.Invoke(e.Path) ?? true) {
Deleted?.Invoke(e.Path);
}
}
if ((e.Flags & FSEventStreamEventFlags.ItemRenamed) != 0) {
if (((e.Flags & FSEventStreamEventFlags.ItemIsFile) != 0 && System.IO.File.Exists(e.Path)) ||
((e.Flags & FSEventStreamEventFlags.ItemIsDir) != 0 && System.IO.Directory.Exists(e.Path))) {
if (lastRenameEvent != null && lastRenameEvent.Value.Id == e.Id - 1) {
Renamed?.Invoke (lastRenameEvent.Value.Path, e.Path);
lastRenameEvent = null;
} else {
Created?.Invoke(e.Path);
}
} else {
CleanLastRenameEvent();
lastRenameEvent = e;
continue;
}
}
CleanLastRenameEvent();
}
}
internal void OnRenamed(FileWatcher sender, RenamedEventArgs e)
{
Renamed?.Invoke(sender, e);
}
protected internal virtual void OnRenamed(MFnDagNode dagNode)
{
Renamed?.Invoke(this, dagNode);
}
protected virtual void OnRenamed(IEnumerable <LogMessage> logs)
{
Renamed?.Invoke(this, logs);
}
protected virtual void OnRenamed(Object sender, RenamedEventArgs fileSystemEventArgs)
{
Renamed?.Invoke(sender, fileSystemEventArgs);
}
protected void OnRenamed(object sender, RenamedEventArgs args)
{
Renamed?.Invoke(sender, args);
}
protected virtual void OnRenamed(RenamedEventArgs e)
{
Renamed?.Invoke(this, e);
}
private void OnRenamed(EventArgs e)
{
Renamed?.Invoke(this, e);
}
private void OnRenamed(FileModel file)
{
Renamed?.Invoke(this, new RenamedFileEventArgs <FileModel> {
RenamedItem = file
});
}
public void Rename(string path, string newName) => Renamed?.Invoke(this, new RenamedEventArgs(WatcherChangeTypes.Renamed, PathUtils.GetFolderPath(path), newName, PathUtils.GetName(path)));