public void OpenDirectory(string path) { this.directory = null; BeginUpdate(); Items.Clear(); try { foreach (string fileName in Directory.GetFiles(path)) { string ext = Path.GetExtension(fileName).ToLower(); if (supportedExtensions.Contains(ext)) { FileNode node = new FileNode(fileName); node.ImageIndex = GetIconName(fileName); Items.Add(node); } } } catch (Exception) { } finally { EndUpdate(); } }
public OAVSProjectItem(FileNode fileNode) { if (fileNode == null) throw new ArgumentNullException("fileNode"); this._fileNode = fileNode; }
public void ApplyLogRecordsFilter(FileNode fileNode = null) { var selectedNodes = _fileBrowser.SelectedItems.OfType<FileNode>().ToArray(); if (fileNode != null && !selectedNodes.Contains(fileNode)) { return; } var logRecords = _logTableService.LogTable.Records; var oldRecords = logRecords.ToArray(); var filteredRecords = FilterRecords(Filter, selectedNodes).ToArray(); _dispatcherService.Invoke(() => { using (logRecords.SuspendChangeNotifications()) { logRecords.ReplaceRange(filteredRecords); } foreach (var record in logRecords.Except(oldRecords)) { record.FileNode.IsExpanded = true; } }, true); }
public void ShouldListEntireTree() { // arrange IFile childFile; IFile rootFile; IFile folder = mockWalker.MockFolder("2", "folder", childFile = Utils.MockFile("3", "file.txt", "text/plain") ); IFile rootFolder = mockWalker.MockFolder("root", "root", rootFile = Utils.MockFile("4", "hello.png", "image/png"), folder); IFileNode expected = new FileNode( Utils.MockFolder("root", "root"), new[] { new FileNode(rootFile), new FileNode(folder, new List<IFileNode> { new FileNode(childFile) }) }); // act var result = walker.ListRecurse("root"); // assert Assert.AreEqual(expected, result); }
public void TestMetadata() { Dictionary<string, string> metadata = new Dictionary<string, string>(); metadata.Add(FileOp.NextCIdentifierString(random), FileOp.NextNormalString(random)); metadata.Add(FileOp.NextCIdentifierString(random), FileOp.NextNormalString(random)); Test.Info("Metadata is ====================="); foreach (var keyValue in metadata) { Test.Info("name:{0} value:{1}", keyValue.Key, keyValue.Value); } DMLibDataInfo sourceDataInfo = new DMLibDataInfo(string.Empty); FileNode fileNode = new FileNode(DMLibTestBase.FileName) { SizeInByte = DMLibTestBase.FileSizeInKB * 1024L, Metadata = metadata }; sourceDataInfo.RootNode.AddFileNode(fileNode); var result = this.ExecuteTestCase(sourceDataInfo, new TestExecutionOptions<DMLibDataInfo>()); Test.Assert(result.Exceptions.Count == 0, "Verify no exception is thrown."); Test.Assert(DMLibDataHelper.Equals(sourceDataInfo, result.DataInfo), "Verify transfer result."); }
private void RefreshDevices() { tv_dirs.Nodes.Clear(); lv_files.Clear(); if ( devices != null ) { foreach ( Device dev in devices ) dev.Close(); } devices = Device.GetPhysicalDevices(); foreach ( Device dev in devices ) { TreeNode root_node = new TreeNode( dev.DeviceName ); root_node.ImageIndex = 0; root_node.SelectedImageIndex = 0; tv_dirs.Nodes.Add( root_node ); List< FileSystem > filesystems = dev.GetFileSystems(); foreach ( FileSystem fs in filesystems ) { FileNode node = new FileNode( fs.GetRootDir(), true ); root_node.Nodes.Add( node ); } root_node.Expand(); } }
public override FileNode read(string path, string flags, int offset, int length) { if (path == "") { return this.myroot; } else if (getWorkPathArray(path)[1] == "ctl") { return null; } else if (getWorkPathArray(path)[1] == "new") { return null; } else { int count = 0; while(count < this.myWindows.Count && this.myWindows[count].Name != getWorkPathArray(path)[1]) { count++; } if(this.myWindows[count].Name == getWorkPathArray(path)[1]) { FileNode winNode = new FileNode(getWorkPathArray(path)[1], fileTypes.Directory); return winNode; } else return null; } }
private void LoadImage(FileNode node, ListView targetListView) { var key = node.File.FullName; var item = targetListView.Items.Add(key, node.File.Name, DefaultImageKey); node.BlockingLoadImage(); ImageList.Images.Add(key, node.Image); item.ImageKey = key; }
private void DoValidation(FileNode fileNode, int expectedErrors) { PropertyInfo fileNameInfo = typeof(FileNode).GetProperty("FileName"); FileValidationAttribute attr = new FileValidationAttribute(); List<ValidationError> errors = new List<ValidationError>(); attr.Validate(fileNode, fileNameInfo, errors, ServiceProvider); Assert.AreEqual(expectedErrors, errors.Count); }
public static void WaitUntilFileCreated(string rootPath, FileNode fileNode, DataAdaptor<DMLibDataInfo> dataAdaptor, DMLibDataType dataType, int timeoutInSec = 300) { Func<bool> checkFileCreated = null; if (dataType == DMLibDataType.Local) { string filePath = dataAdaptor.GetAddress() + fileNode.GetLocalRelativePath(); checkFileCreated = () => { return File.Exists(filePath); }; } else if (dataType == DMLibDataType.PageBlob || dataType == DMLibDataType.AppendBlob) { CloudBlobDataAdaptor blobAdaptor = dataAdaptor as CloudBlobDataAdaptor; checkFileCreated = () => { CloudBlob cloudBlob = blobAdaptor.GetCloudBlobReference(rootPath, fileNode); return cloudBlob.Exists(options: HelperConst.DefaultBlobOptions); }; } else if (dataType == DMLibDataType.BlockBlob) { CloudBlobDataAdaptor blobAdaptor = dataAdaptor as CloudBlobDataAdaptor; checkFileCreated = () => { CloudBlockBlob blockBlob = blobAdaptor.GetCloudBlobReference(rootPath, fileNode) as CloudBlockBlob; try { return blockBlob.DownloadBlockList(BlockListingFilter.All, options: HelperConst.DefaultBlobOptions).Any(); } catch (StorageException) { return false; } }; } else if (dataType == DMLibDataType.CloudFile) { CloudFileDataAdaptor fileAdaptor = dataAdaptor as CloudFileDataAdaptor; checkFileCreated = () => { CloudFile cloudFile = fileAdaptor.GetCloudFileReference(rootPath, fileNode); return cloudFile.Exists(options: HelperConst.DefaultFileOptions); }; } else { Test.Error("Unexpected data type: {0}", DMLibTestContext.SourceType); } MultiDirectionTestHelper.WaitUntil(checkFileCreated, timeoutInSec); }
public void EnsureCanWriteToAValidFile() { string fileName = Path.GetTempFileName(); FileNode fileNode = new FileNode(fileName); using (File.Create(fileName)) { } DoValidation(fileNode, 0); if (File.Exists(fileName)) File.Delete(fileName); }
public static void printAllFileEntries(FileNode Root) { Console.WriteLine("Node: " + Root.NodeName); foreach (RARC.FileEntry f in Root.Files) { Console.WriteLine(" Entry:" + f.FileName); } foreach (RARC.FileNode n in Root.ChildNodes) printAllFileEntries(n); }
public void FileCount_FolderWithOneFile() { IFileBase fileInfo = Utils.MockFolder("root", "root"); IFileBase childFileInfo = Utils.MockFile("file", "file", "text/plain"); IFileNode fileNode = new FileNode(fileInfo, new List<IFileNode> { new FileNode(childFileInfo) }); Assert.AreEqual(1, fileNode.FileCount()); }
public void ShouldCopyChildren() { IFileBase fileInfo = Mock.Of<IFileBase>(f => f.Id == "parent"); IFileBase childFileInfo = Mock.Of<IFileBase>(f => f.Id == "child"); FileNode fileNode = new FileNode(fileInfo, new List<IFileNode> { new FileNode(childFileInfo) }); Assert.AreEqual("child", fileNode.Children[0].Id); }
public static void AddOneFileInBytes(DirNode dirNode, string fileName, long fileSizeInB, FileAttributes? fa = null, DateTime? lmt = null) { FileNode fileNode = new FileNode(fileName) { SizeInByte = fileSizeInB, FileAttr = fa, LastModifiedTime = lmt, }; dirNode.AddFileNode(fileNode); }
public static void AddMultipleFilesDifferentSize(DirNode dirNode, string filePrefix, int[] fileSizes) { for (int i = 0; i < fileSizes.Length; ++i) { FileNode fileNode = new FileNode(filePrefix + "_" + i) { SizeInByte = fileSizes[i] * 1024 }; dirNode.AddFileNode(fileNode); } }
public void ShouldListEmptyFolder() { // arrange mockWalker.MockFolder("root", "root"); var expected = new FileNode(Utils.MockFolder("root", "root")); // act var result = walker.ListRecurse("root"); // assert Assert.AreEqual(expected, result); Assert.AreEqual(0, result.Children.Count); }
public void ShouldListSingleFile() { // arrange var mockFile = Utils.MockFile("fileId", "file.txt", "text/plain"); var expected = new FileNode(mockFile); // act var result = walker.ListRecurse(mockFile); // assert Assert.AreEqual(expected, result); Assert.AreEqual(0, result.Children.Count); }
public static void Start() { AppDomain.CurrentDomain.UnhandledException += LogException; URL url = new URL(ConfigurationManager.AppSettings["URL"]); fileNodeImpl = new FileNodeImpl(url); fileNodeImpl.Create(); isStop = false; while (!isStop) { Thread.Sleep(10000); } Log.WriteDebug("File server started."); }
public BEdit(bitboardWorld world, string path) { this.myWorld = world; InitializeComponent(); if (path != "" && path != null) { this.currentPath = path; this.Name = path; editFile = myWorld.agi.read(path, "", 0, 0); if (editFile != null && editFile.getType() == fileTypes.Text) richTextBox1.Text = editFile.getData(); } }
public HomeFS() : base() { this.myroot = base.init(); this.sysHomePath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile); if (Directory.Exists(sysHomePath)) { string[] fileEntries = Directory.GetFiles(sysHomePath); foreach (string fileName in fileEntries) this.myroot.addChild(new FileNode(getFileNameFromPath(fileName), fileTypes.Text)); string[] subdirectoryEntries = Directory.GetDirectories(sysHomePath); foreach (string subdirectory in subdirectoryEntries) this.myroot.addChild(new FileNode(getFileNameFromPath(subdirectory), fileTypes.Directory)); } }
public void FileCount_TwoFoldersThreeFiles() { IFileBase rootFolder = Utils.MockFolder("root", "root"); IFileBase childFolder = Utils.MockFolder("folder", "folder"); IFileBase rootFile = Utils.MockFile("file", "file", "text/plain"); IFileBase childFile1 = Utils.MockFile("file1", "file1", "text/plain"); IFileBase childFile2 = Utils.MockFile("file2", "file2", "text/plain"); IFileNode fileNode = new FileNode(rootFolder, new List<IFileNode> { new FileNode(rootFile), new FileNode(childFolder, new List<IFileNode> { new FileNode(childFile1), new FileNode(childFile2) }) }); Assert.AreEqual(3, fileNode.FileCount()); }
public override FileNode read(string path, string flags, int offset, int length) { if(path == "") { return this.myroot; } else if (getWorkPathArray(path)[1] == "time") { FileNode timeNode = new FileNode(getNewfileName(path), fileTypes.Text); timeNode.putData(DateTime.Now.ToLongTimeString()); return timeNode; } else if (getWorkPathArray(path)[1] == "date") { FileNode dateNode = new FileNode(getNewfileName(path), fileTypes.Text); dateNode.putData(DateTime.Now.ToLongDateString()); return dateNode; } else return null; }
public override FileNode read(string path, string flags, int offset, int length) { Console.WriteLine("path = " + path); if (path == "") { return this.myroot; } else { string loadPath = sysHomePath + buildWindowsFilePath(path); if (Directory.Exists(loadPath)) { Console.WriteLine("loading Directory"); string[] fileEntries = Directory.GetFiles(loadPath); FileNode tempNode = new FileNode(path, fileTypes.Directory); foreach (string fileName in fileEntries) tempNode.addChild(new FileNode(getFileNameFromPath(fileName), fileTypes.Text)); string[] subdirectoryEntries = Directory.GetDirectories(loadPath); foreach (string subdirectory in subdirectoryEntries) tempNode.addChild(new FileNode(getFileNameFromPath(subdirectory), fileTypes.Directory)); return tempNode; } else if (File.Exists(loadPath)) { FileNode tempNode = new FileNode(getFileNameFromPath(path), fileTypes.Text); string filebuffer = File.ReadAllText(loadPath); tempNode.putData(filebuffer); return tempNode; } else return null; } }
public void LoadFileNode(FileNode fileNode) { Log.Debug("Loading file node '{0}'", fileNode); try { _dispatcherService.Invoke(() => { var fileRecords = _logReaderService.LoadRecordsFromFileAsync(fileNode).Result; var logRecords = fileNode.Records; using (logRecords.SuspendChangeNotifications()) { logRecords.ReplaceRange(fileRecords); } }, true); } catch (Exception ex) { Log.Warning(ex, "Failed to load file node '{0}'", fileNode); } }
public static Node Create(string path, Node parent) { var node = new Node(); if (IsDirectory(path)) { node.Name = GetDirectoryName(path); node.Path = GetDirectoryPath(path); node.Parent = parent; node.Type = Node.DirectoryTypeName; } else { node = new FileNode(); node.Parent = parent; node.Name = Path.GetFileName(path); node.Path = path; node.Type = Node.FileTypeName; } return node; }
public override void Run() { WebReferenceNode node = Owner as WebReferenceNode; if (node != null && node.Project != null && node.ProjectItem != null) { WebReferenceUrl url = (WebReferenceUrl)node.ProjectItem; try { // Discover web services at url. DiscoveryClientProtocol protocol = DiscoverWebServices(url.UpdateFromURL); if (protocol != null) { // Save web services. WebReference webReference = new WebReference(url.Project, url.UpdateFromURL, node.Text, url.Namespace, protocol); webReference.Save(); // Update project. WebReferenceChanges changes = webReference.GetChanges(url.Project); if (changes.Changed) { foreach (ProjectItem itemRemoved in changes.ItemsRemoved) { ProjectService.RemoveProjectItem(url.Project, itemRemoved); FileService.RemoveFile(itemRemoved.FileName, false); } foreach (ProjectItem newItem in changes.NewItems) { ProjectService.AddProjectItem(url.Project, newItem); FileNode fileNode = new FileNode(newItem.FileName, FileNodeStatus.InProject); fileNode.InsertSorted(node); } ProjectBrowserPad.Instance.ProjectBrowserControl.TreeView.Sort(); url.Project.Save(); } // Update code completion. SD.ParserService.ParseFileAsync(FileName.Create(webReference.WebProxyFileName), parentProject: url.Project).FireAndForget(); } } catch (WebException ex) { LoggingService.Debug(ex); MessageService.ShowError(GetRefreshWebReferenceErrorMessage(ex, url.UpdateFromURL)); } } }
public FileNode CreateFileNode(string fileName) { Argument.IsNotNullOrEmpty(() => fileName); //Log.Debug("Creating file node '{0}'", fileName); var fileNode = new FileNode(new FileInfo(fileName)); fileNode.Name = fileNode.FileInfo.Name; fileNode.IsUnifyNamed = _fileNameMask.IsMatch(fileNode.FileInfo.Name); if (!fileNode.IsUnifyNamed) { fileNode.Name = fileNode.FileInfo.Name; } else { fileNode.Name = fileNode.FileInfo.Name; var dateTimeString = Regex.Match(fileNode.FileInfo.Name, @"(\d{4}-\d{2}-\d{2})").Value; fileNode.DateTime = DateTime.ParseExact(dateTimeString, "yyyy-MM-dd", null, DateTimeStyles.None); } return fileNode; }
public override void Run() { WebReferenceNode node = Owner as WebReferenceNode; if (node != null && node.Project != null && node.ProjectItem != null) { WebReferenceUrl url = (WebReferenceUrl)node.ProjectItem; try { // Discover web services at url. DiscoveryClientProtocol protocol = DiscoverWebServices(url.UpdateFromURL); if (protocol != null) { // Save web services. WebReference webReference = new WebReference(url.Project, url.UpdateFromURL, node.Text, url.Namespace, protocol); webReference.Save(); // Update project. WebReferenceChanges changes = webReference.GetChanges(url.Project); if (changes.Changed) { foreach (ProjectItem itemRemoved in changes.ItemsRemoved) { ProjectService.RemoveProjectItem(url.Project, itemRemoved); FileService.RemoveFile(itemRemoved.FileName, false); } foreach (ProjectItem newItem in changes.NewItems) { ProjectService.AddProjectItem(url.Project, newItem); FileNode fileNode = new FileNode(newItem.FileName, FileNodeStatus.InProject); fileNode.InsertSorted(node); } ProjectBrowserPad.Instance.ProjectBrowserControl.TreeView.Sort(); url.Project.Save(); } // Update code completion. ParserService.ParseFile(webReference.WebProxyFileName); } } catch (WebException ex) { MessageService.ShowException(ex, String.Format(StringParser.Parse("${res:ICSharpCode.SharpDevelop.Commands.ProjectBrowser.RefreshWebReference.ReadServiceDescriptionError}"), url.UpdateFromURL)); } } }
public static void ExcludeFileNode(FileNode fileNode) { List<FileNode> dependentNodes = new List<FileNode>(); foreach (TreeNode subNode in fileNode.Nodes) { // exclude dependent files if (subNode is FileNode) dependentNodes.Add((FileNode)subNode); } dependentNodes.ForEach(ExcludeFileNode); bool isLink = fileNode.IsLink; if (fileNode.ProjectItem != null) { // don't try to exclude same node twice ProjectService.RemoveProjectItem(fileNode.Project, fileNode.ProjectItem); } if (isLink) { fileNode.Remove(); } else { fileNode.ProjectItem = null; fileNode.FileNodeStatus = FileNodeStatus.None; if (fileNode.Parent is ExtTreeNode) { ((ExtTreeNode)fileNode.Parent).UpdateVisibility(); } } }
public abstract object GetTransferObject(FileNode fileNode);
public RoslynUstCommonConverterVisitor(SyntaxNode root, FileNode fileNode) { Root = root; FileNode = fileNode; }
public RoslynUstCommonConverterVisitor(SyntaxTree syntaxTree, string filePath) { Root = syntaxTree.GetRoot(); FileNode = new FileNode(filePath, syntaxTree.GetText().ToString()); }
protected override void InternalDelete(FileNode path) { File.Delete(path.AbosolutePath); }
protected EntityDeclaration(IdToken name, TextSpan textSpan, FileNode fileNode) : base(textSpan, fileNode) { Name = name; }
public OAComposeStarFileItem(OAProject project, FileNode node) : base(project, node) { }
public ArgsNode(IEnumerable <Expression> args, TextSpan textSpan, FileNode fileNode) : base(args, textSpan, fileNode) { }
public Stream Open(ResourcePath path, FileMode fileMode, FileAccess access, FileShare share) { if (!path.IsRooted) { throw new ArgumentException("Path must be rooted", nameof(path)); } path = path.Clean(); var parentPath = path.Directory; if (!TryGetNodeAt(parentPath, out var parent) || !(parent is DirectoryNode parentDir)) { throw new ArgumentException("Parent directory does not exist."); } var fileName = path.Filename; if (parentDir.Children.TryGetValue(fileName, out var maybeFileNode) && maybeFileNode is DirectoryNode) { throw new ArgumentException("There is a directory at that location."); } var fileNode = (FileNode)maybeFileNode !; switch (fileMode) { case FileMode.Append: { if (fileNode == null) { fileNode = new FileNode(); parentDir.Children.Add(fileName, fileNode); } return(new VirtualFileStream(fileNode.Contents, false, true, fileNode.Contents.Length)); } case FileMode.Create: { if (fileNode == null) { fileNode = new FileNode(); parentDir.Children.Add(fileName, fileNode); } else { // Clear contents if it already exists. fileNode.Contents.SetLength(0); } return(new VirtualFileStream(fileNode.Contents, true, true, 0)); } case FileMode.CreateNew: { if (fileNode != null) { throw new IOException("File already exists."); } fileNode = new FileNode(); parentDir.Children.Add(fileName, fileNode); return(new VirtualFileStream(fileNode.Contents, true, true, 0)); } case FileMode.Open: { if (fileNode == null) { throw new FileNotFoundException(); } return(new VirtualFileStream(fileNode.Contents, true, true, 0)); } case FileMode.OpenOrCreate: { if (fileNode == null) { fileNode = new FileNode(); parentDir.Children.Add(fileName, fileNode); } return(new VirtualFileStream(fileNode.Contents, true, true, 0)); } case FileMode.Truncate: { if (fileNode == null) { throw new FileNotFoundException(); } fileNode.Contents.SetLength(0); return(new VirtualFileStream(fileNode.Contents, true, true, 0)); } default: throw new ArgumentOutOfRangeException(nameof(fileMode), fileMode, null); } }
internal XSharpEventBindingProvider(FileNode xsFile) { _xsFile = xsFile; _project = xsFile.ProjectMgr; }
internal OAFileItem(OAProject project, FileNode node) : base(project, node) { }
protected CollectionNode(IEnumerable <TUstNode> collection, TextSpan textSpan, FileNode fileNode) : base(textSpan, fileNode) { Collection = collection as List <TUstNode> ?? collection.ToList(); }
public ModifierLiteral(Modifier modifier, TextSpan textSpan, FileNode fileNode) : base(textSpan, fileNode) { Modifier = modifier; }
private void ServersTreeView_AfterLabelEdit(object sender, NodeLabelEditEventArgs e) { LabelEditAction EditAction = this.EditAction; this.EditAction = LabelEditAction.None; if (e.Label == null || e.Label == "") { if (EditAction == LabelEditAction.Rename) { if (OldLabelEditName != null) { e.Node.Text = OldLabelEditName; } } else if (EditAction == LabelEditAction.NewFile || EditAction == LabelEditAction.NewDirectory) { e.Node.Remove(); } e.CancelEdit = true; return; } if (EditAction == LabelEditAction.Rename) { #region ActionRename if (e.Node is FileNode) { FileNode node = (FileNode)e.Node; FileInfo file = node.GetFile(); string path = file.DirectoryName + Path.DirectorySeparatorChar + e.Label; if (File.Exists(path)) { Error.Show("ErrorFileExists"); e.CancelEdit = true; return; } try { file.MoveTo(path); } catch (IOException) { Error.Show("ErrorFileInvalidName"); e.CancelEdit = true; return; } } else if (e.Node is ServerNode) { ServerNode node = (ServerNode)e.Node; DirectoryInfo directory = node.GetDirectory(); string path = directory.Parent.FullName + Path.DirectorySeparatorChar + e.Label; if (Directory.Exists(path)) { Error.Show("ErrorServerExists"); } else { try { directory.MoveTo(path); node.GetServerData().name = e.Label; node.GetServerData().Save(); } catch (IOException) { Error.Show("ErrorServerInvalidName"); } } node.Text = node.GetServerData().ToString(); e.CancelEdit = true; } else if (e.Node is DirectoryNode) { DirectoryNode node = (DirectoryNode)e.Node; DirectoryInfo directory = node.GetDirectory(); string path = directory.Parent.FullName + Path.DirectorySeparatorChar + e.Label; if (Directory.Exists(path)) { Error.Show("ErrorDirectoryExists"); e.CancelEdit = true; return; } try { directory.MoveTo(path); } catch (IOException) { Error.Show("ErrorDirectoryInvalidName"); e.CancelEdit = true; return; } } else if (e.Node is RemoteServerNode) { RemoteServerNode node = (RemoteServerNode)e.Node; Data.RemoteServer data = new Data.RemoteServer(); data.name = e.Label; if (!Directory.Exists(data.GetDirectory())) { Directory.Move(node.GetServerData().GetDirectory(), data.GetDirectory()); node.GetServerData().name = e.Label; node.GetServerData().Save(); } node.Text = node.GetServerData().ToString(); e.CancelEdit = true; } else if (e.Node is RemoteDirectoryNode) { RemoteDirectoryNode node = (RemoteDirectoryNode)e.Node; Ftp.rename(node.data, node.directory, e.Label); ((RemoteDirectoryNode)e.Node.Parent).Refresh(); e.CancelEdit = true; } else if (e.Node is RemoteFileNode) { RemoteFileNode node = (RemoteFileNode)e.Node; Ftp.rename(node.data, node.GetFile(), e.Label); ((RemoteDirectoryNode)e.Node.Parent).Refresh(); e.CancelEdit = true; } #endregion } else if (EditAction == LabelEditAction.NewFile) { #region ActionNewFile if (e.Node.Parent is DirectoryNode) { DirectoryNode node = (DirectoryNode)e.Node.Parent; string path = node.GetDirectory().FullName + Path.DirectorySeparatorChar + e.Label; if (File.Exists(path)) { Error.Show("ErrorFileExists"); } else { try { File.Create(path).Close(); } catch (IOException) { Error.Show("ErrorFileInvalidName"); } } e.Node.Remove(); } else if (e.Node.Parent is RemoteDirectoryNode) { RemoteDirectoryNode node = (RemoteDirectoryNode)e.Node.Parent; File.Create(Main.TempDirectory + e.Label).Close(); Ftp.upload(node.data, node.directory + e.Label, Main.TempDirectory + e.Label); e.Node.Remove(); node.Refresh(); } #endregion ; } else if (EditAction == LabelEditAction.NewDirectory) { #region ActionNewDirectory if (e.Node.Parent is DirectoryNode) { DirectoryNode node = (DirectoryNode)e.Node.Parent; string path = node.GetDirectory().FullName + Path.DirectorySeparatorChar + e.Label; if (Directory.Exists(path)) { Error.Show("ErrorDirectoryExists"); } else { try { Directory.CreateDirectory(path); } catch (IOException) { Error.Show("ErrorDirectoryInvalidName"); } } e.Node.Remove(); } else if (e.Node.Parent is RemoteDirectoryNode) { RemoteDirectoryNode node = (RemoteDirectoryNode)e.Node.Parent; Ftp.createDirectory(node.data, node.directory + e.Label); e.Node.Remove(); node.Refresh(); } #endregion } }
public override PlatformData Create(string path, Game game, ProgressIndicator progress) { PlatformData data = new PlatformData(this, game); DirectoryNode dir = data.GetDirectoryStructure(path); data.Game = Platform.DetermineGame(data); try { FileNode qbpak = dir.Navigate("pak/qb.pak.ngc") as FileNode; if (qbpak == null) { throw new FormatException("Couldn't find qb.pak on Guitar Hero Wii disc."); } FileNode qspak = dir.Navigate("pak/qs.pak.ngc") as FileNode; if (qspak == null) { throw new FormatException("Couldn't find qs.pak on Guitar Hero Wii disc."); } Pak qs = new Pak(new EndianReader(qspak.Data, Endianness.BigEndian)); StringList strings = new StringList(); foreach (Pak.Node node in qs.Nodes) { strings.ParseFromStream(node.Data); } Pak qb = new Pak(new EndianReader(qbpak.Data, Endianness.BigEndian)); FileNode songlistfile = qb.FindFile(@"scripts\guitar\songlist.qb.ngc"); if (songlistfile == null) { songlistfile = qb.FindFile(@"scripts\guitar\songlist.qb"); } if (songlistfile == null) { throw new FormatException("Couldn't find the songlist on the Guitar Hero Wii disc pak."); } QbFile songlist = new QbFile(songlistfile.Data, PakFormat); data.Session["rootdir"] = dir; List <QbKey> listkeys = new List <QbKey>(); foreach (uint songlistkey in NeversoftMetadata.SonglistKeys) { QbKey key = QbKey.Create(songlistkey); QbItemStruct list = songlist.FindItem(key, true) as QbItemStruct; if (list != null && list.Items.Count > 0) { listkeys.Add(key); } } progress.NewTask(listkeys.Count); List <string> songsadded = new List <string>(); foreach (QbKey songlistkey in listkeys) { QbItemStruct list = songlist.FindItem(songlistkey, true) as QbItemStruct; progress.NewTask(list.Items.Count); foreach (QbItemArray item in list.Items.OfType <QbItemArray>()) { item.Items[0].ItemQbKey = item.ItemQbKey; SongData song = NeversoftMetadata.GetSongData(data, item.Items[0] as QbItemStruct, strings); progress.Progress(); if (songsadded.Contains(song.ID)) { continue; } try { if (AddSong(data, song, progress)) { songsadded.Add(song.ID); } } catch (Exception exception) { Exceptions.Warning(exception, "Unable to properly parse " + song.Name); } } progress.EndTask(); progress.Progress(); } progress.EndTask(); qbpak.Data.Close(); qspak.Data.Close(); } catch (Exception exception) { Exceptions.Error(exception, "An error occurred while parsing the Guitar Hero Wii disc."); } return(data); }
/// <summary> /// process the http request /// </summary> /// <param name="context">http context</param> public void ProcessRequest(HttpContext context) { HttpRequest request = context.Request; HttpResponse response = context.Response; response.StatusCode = (int)HttpStatusCode.BadRequest; try { // Make sure that there is a session. if (context.Session != null) { //HttpService service = Session[ serviceTag ]; response.Cache.SetCacheability(HttpCacheability.NoCache); string method = request.HttpMethod.ToLower(); log.Debug("Simias.HttpFile.Handler.ProcessRequest called"); log.Debug(" method: " + method); //SyncMethod method = (SyncMethod)Enum.Parse(typeof(SyncMethod), Request.Headers.Get(SyncHeaders.Method), true); if (method == "get") { // Must a query string which contains the domainid and the // filenodeid for the file caller is attempting to download. if (request.QueryString.Count > 0) { Collection collection; Domain domain; FileNode fileNode; Node node; Store store = Store.GetStore(); string domainID = request.QueryString["did"]; if (domainID == null) { domainID = store.DefaultDomain; } string fileID = request.QueryString["fid"]; if (fileID != null) { log.Debug(" domainID: " + domainID); log.Debug(" fileID: " + fileID); domain = Store.GetStore().GetDomain(domainID); node = domain.GetNodeByID(fileID); if (node != null) { Property cid = node.Properties.GetSingleProperty("CollectionId"); collection = store.GetCollectionByID(cid.Value as string); fileNode = new FileNode(node); string fullPath = fileNode.GetFullPath(collection); string fileName = fileNode.GetFileName(); log.Debug(" nodename: " + fileNode.Name); log.Debug(" filename: " + fileName); log.Debug(" fullpath: " + fullPath); response.StatusCode = (int)HttpStatusCode.OK; Property lastModified = node.Properties.GetSingleProperty("LastModified"); if (lastModified != null) { DateTime dt = (DateTime)lastModified.Value; response.AddHeader( "Last-Modified", Util.GetRfc822Date((DateTime)lastModified.Value)); } response.AddHeader( "Content-length", fileNode.Length.ToString()); response.ContentType = Simias.HttpFile.Response.GetMimeType(fileName).ToLower(); if (response.ContentType.Equals("text/plain")) { response.AddHeader( "Content-Disposition", "inline; filename=\"" + fileName + "\""); } else if (response.ContentType.Equals("text/xml")) { response.AddHeader( "Content-Disposition", "inline; filename=\"" + fileName + "\""); } else if (response.ContentType.StartsWith("image")) { response.AddHeader( "Content-Disposition", "inline; filename=\"" + fileName + "\""); } else { response.AddHeader( "Content-Disposition", "attachment; filename=\"" + fileName + "\""); } response.TransmitFile(fullPath); /* * response. * FileStream stream = * File.Open( * fullPath, * System.IO.FileMode.Open, * System.IO.FileAccess.Read, * System.IO.FileShare.Read ); */ } } } } } } catch (Exception ex) { log.Error(ex.Message); log.Error(ex.StackTrace); response.StatusCode = (int)HttpStatusCode.InternalServerError; } finally { response.End(); } }
void FileNode_OnFileNodeRefresh(FileNode node) { UpdateNodeStatus(node); }
protected override Stream InternalGetFileStream(FileNode node) { return(File.Open(node.AbosolutePath, FileMode.Open)); }
internal static AnalysisEntry GetAnalysisEntry(this FileNode node) { return(((PythonProjectNode)node.ProjectMgr).GetAnalyzer().GetAnalysisEntryFromPath(node.Url)); }
protected override void InternalMove(FileNode source, FileNode dist) { File.Move(source.AbosolutePath, dist.AbosolutePath); }
void AddFileNodeTo(TreeNode node) { var fileNode = new FileNode(newFileAddedToProject.FileName, FileNodeStatus.InProject); fileNode.InsertSorted(node); }
private static void AddChild(MenuItem parent, FileNode path) { var item = new FileButton(path); parent.AddChild(item); }
bool FileNodeMatchesNewFileAdded(FileNode fileNode) { return(FileUtility.IsEqualFileName(fileNode.FileName, newFileAddedToProject.FileName)); }
public RoslynUstCommonConverterVisitor(SyntaxTree syntaxTree, FileNode fileNode) { Root = syntaxTree.GetRoot(); FileNode = fileNode; }
public static async Task ReloadFileNodeAsync(this IFileNodeService fileNodeService, FileNode fileNode) { await Task.Factory.StartNew(() => fileNodeService.ReloadFileNode(fileNode)); }
protected override void RenameChildNodes(FileNode parentNode) { base.RenameChildNodes(parentNode); this.ProjectMgr.Analyzer.ReloadComplete(); }
/// <summary> /// Add new topics from all files in a selected folder /// </summary> /// <param name="sender">The sender of the event</param> /// <param name="e">The event arguments</param> private void cmdAddAllFromFolder_Executed(object sender, ExecutedRoutedEventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); FileNode thisNode = this.FileNode; TocEntryCollection parent, newTopics = new TocEntryCollection(null); TocEntry selectedTopic = base.UIControl.CurrentTopic; string projectPath = Path.GetDirectoryName(siteMapFile.Project.Filename); int idx; using (WinFormsFolderBrowserDialog dlg = new WinFormsFolderBrowserDialog()) { dlg.Description = "Select a folder to add all of its content"; dlg.SelectedPath = (selectedTopic != null && selectedTopic.SourceFile.Path.Length != 0) ? Path.GetDirectoryName(selectedTopic.SourceFile) : projectPath; if (dlg.ShowDialog() == WinFormsDialogResult.OK) { Utility.GetServiceFromPackage <IVsUIShell, SVsUIShell>(true).SetWaitCursor(); newTopics.AddTopicsFromFolder(dlg.SelectedPath, dlg.SelectedPath, siteMapFile.Project); if (thisNode != null) { thisNode.ProjectMgr.RefreshProject(); } } if (newTopics.Count != 0) { if (e.Parameter == null || selectedTopic == null) { // Insert as siblings if (selectedTopic == null) { parent = base.UIControl.Topics; idx = 0; } else { parent = selectedTopic.Parent; idx = parent.IndexOf(selectedTopic) + 1; } foreach (TocEntry t in newTopics) { parent.Insert(idx++, t); } } else { // Insert as children parent = selectedTopic.Children; foreach (TocEntry t in newTopics) { parent.Add(t); } selectedTopic.IsExpanded = true; } } } }
public void TestDirectoryWithSpecialCharNamedBlobs() { #if DNXCORE50 // TODO: There's a known issue that signature for URI with '[' or ']' doesn't work. string specialChars = "~`!@#$%()-_+={};?.^&"; #else string specialChars = "~`!@#$%()-_+={}[];?.^&"; #endif DMLibDataInfo sourceDataInfo = new DMLibDataInfo(string.Empty); var subDirWithDot = new DirNode(DMLibTestBase.FolderName + "." + DMLibTestBase.FolderName); for (int i = 0; i < specialChars.Length; ++i) { string fileName = DMLibTestBase.FileName + specialChars[i] + DMLibTestBase.FileName; if (random.Next(2) == 0) { if ((specialChars[i] != '.') && (random.Next(2) == 0)) { string folderName = DMLibTestBase.FolderName + specialChars[i] + DMLibTestBase.FolderName; var subDir = new DirNode(folderName); DMLibDataHelper.AddOneFileInBytes(subDir, fileName, 1024); FileNode fileNode1 = subDir.GetFileNode(fileName); fileNode1.SnapshotsCount = 1; sourceDataInfo.RootNode.AddDirNode(subDir); } else { DMLibDataHelper.AddOneFileInBytes(subDirWithDot, fileName, 1024); FileNode fileNode1 = subDirWithDot.GetFileNode(fileName); fileNode1.SnapshotsCount = 1; } } else { DMLibDataHelper.AddOneFileInBytes(sourceDataInfo.RootNode, fileName, 1024); FileNode fileNode1 = sourceDataInfo.RootNode.GetFileNode(fileName); fileNode1.SnapshotsCount = 1; } } sourceDataInfo.RootNode.AddDirNode(subDirWithDot); var options = new TestExecutionOptions <DMLibDataInfo>(); options.IsDirectoryTransfer = true; // transfer with IncludeSnapshots = true options.TransferItemModifier = (fileNode, transferItem) => { dynamic dirOptions = DefaultTransferDirectoryOptions; dirOptions.Recursive = true; dirOptions.IncludeSnapshots = true; transferItem.Options = dirOptions; }; var result = this.ExecuteTestCase(sourceDataInfo, options); // verify that snapshots are transferred Test.Assert(result.Exceptions.Count == 0, "Verify no exception is thrown."); Test.Assert(DMLibDataHelper.Equals(sourceDataInfo, result.DataInfo), "Verify transfer result."); }
private static void AddFolderForFile(Dictionary <FileNode, List <CommonFolderNode> > directoryPackages, FileNode rootFile, CommonFolderNode folderChild) { List <CommonFolderNode> folders; if (!directoryPackages.TryGetValue(rootFile, out folders)) { directoryPackages[rootFile] = folders = new List <CommonFolderNode>(); } folders.Add(folderChild); }
protected IEnumerable <FileProjectItem> AddExistingItems() { DirectoryNode node = ProjectBrowserPad.Instance.ProjectBrowserControl.SelectedDirectoryNode; if (node == null) { return(null); } node.Expanding(); node.Expand(); List <FileProjectItem> addedItems = new List <FileProjectItem>(); using (OpenFileDialog fdiag = new OpenFileDialog()) { fdiag.AddExtension = true; var fileFilters = ProjectService.GetFileFilters(); fdiag.InitialDirectory = node.Directory; fdiag.FilterIndex = GetFileFilterIndex(node.Project, fileFilters); fdiag.Filter = String.Join("|", fileFilters); fdiag.Multiselect = true; fdiag.CheckFileExists = true; fdiag.Title = StringParser.Parse("${res:ProjectComponent.ContextMenu.AddExistingFiles}"); if (fdiag.ShowDialog(SD.WinForms.MainWin32Window) == DialogResult.OK) { List <KeyValuePair <string, string> > fileNames = new List <KeyValuePair <string, string> >(fdiag.FileNames.Length); foreach (string fileName in fdiag.FileNames) { fileNames.Add(new KeyValuePair <string, string>(fileName, "")); } bool addedDependentFiles = false; foreach (string fileName in fdiag.FileNames) { foreach (string additionalFile in FindAdditionalFiles(fileName)) { if (!fileNames.Exists(delegate(KeyValuePair <string, string> pair) { return(FileUtility.IsEqualFileName(pair.Key, additionalFile)); })) { addedDependentFiles = true; fileNames.Add(new KeyValuePair <string, string>(additionalFile, Path.GetFileName(fileName))); } } } string copiedFileName = Path.Combine(node.Directory, Path.GetFileName(fileNames[0].Key)); if (!FileUtility.IsEqualFileName(fileNames[0].Key, copiedFileName)) { int res = MessageService.ShowCustomDialog( fdiag.Title, "${res:ProjectComponent.ContextMenu.AddExistingFiles.Question}", 0, 2, "${res:ProjectComponent.ContextMenu.AddExistingFiles.Copy}", "${res:ProjectComponent.ContextMenu.AddExistingFiles.Link}", "${res:Global.CancelButtonText}"); if (res == 1) { // Link foreach (KeyValuePair <string, string> pair in fileNames) { string fileName = pair.Key; string relFileName = FileUtility.GetRelativePath(node.Project.Directory, fileName); FileNode fileNode = new FileNode(fileName, FileNodeStatus.InProject); FileProjectItem fileProjectItem = new FileProjectItem(node.Project, node.Project.GetDefaultItemType(fileName), relFileName); fileProjectItem.SetEvaluatedMetadata("Link", Path.Combine(node.RelativePath, Path.GetFileName(fileName))); fileProjectItem.DependentUpon = pair.Value; addedItems.Add(fileProjectItem); fileNode.ProjectItem = fileProjectItem; fileNode.InsertSorted(node); ProjectService.AddProjectItem(node.Project, fileProjectItem); } node.Project.Save(); if (addedDependentFiles) { node.RecreateSubNodes(); } return(addedItems.AsReadOnly()); } if (res == 2) { // Cancel return(addedItems.AsReadOnly()); } // only continue for res==0 (Copy) } bool replaceAll = false; foreach (KeyValuePair <string, string> pair in fileNames) { copiedFileName = Path.Combine(node.Directory, Path.GetFileName(pair.Key)); if (!replaceAll && File.Exists(copiedFileName) && !FileUtility.IsEqualFileName(pair.Key, copiedFileName)) { ReplaceExistingFile res = ShowReplaceExistingFileDialog(fdiag.Title, Path.GetFileName(pair.Key), true); if (res == ReplaceExistingFile.YesToAll) { replaceAll = true; } else if (res == ReplaceExistingFile.No) { continue; } else if (res == ReplaceExistingFile.Cancel) { break; } } FileProjectItem item = CopyFile(pair.Key, node, true); if (item != null) { addedItems.Add(item); item.DependentUpon = pair.Value; } } node.Project.Save(); if (addedDependentFiles) { node.RecreateSubNodes(); } } } return(addedItems.AsReadOnly()); }
private void removeMenu_Click(object sender, EventArgs e) { if (base.SelectedNode is FileNode) { FileNode node = (FileNode)base.SelectedNode; FileInfo file = node.GetFile(); DialogResult result = MessageBox.Show( String.Format(Language.GetString("DialogFileRemove"), file.Name), Language.GetString("Warning"), MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation); if (result == DialogResult.Yes) { file.Delete(); node.Remove(); } } else if (base.SelectedNode is DirectoryNode) { DirectoryNode node = (DirectoryNode)base.SelectedNode; DirectoryInfo directory = node.GetDirectory(); string message; if (base.SelectedNode is ServerNode) { message = String.Format(Language.GetString("DialogDirectoryRemove"), directory.Name); } else { message = String.Format(Language.GetString("DialogServerRemove"), directory.Name); } DialogResult result = MessageBox.Show(message, Language.GetString("Warning"), MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation); if (result == DialogResult.Yes) { try { if (directory.Exists) { new Computer().FileSystem.DeleteDirectory(directory.FullName, UIOption.AllDialogs, RecycleOption.SendToRecycleBin); } if (base.SelectedNode is ServerNode && ((ServerNode)base.SelectedNode).GetServerData().isImported) { File.Delete(((ServerNode)base.SelectedNode).GetServerData().GetFile()); } node.Destroy(); } catch (OperationCanceledException) { } } } else if (base.SelectedNode is RemoteServerNode) { RemoteServerNode node = (RemoteServerNode)base.SelectedNode; DialogResult result = MessageBox.Show( String.Format(Language.GetString("DialogRemoteServerRemove"), node.GetServerData().name), Language.GetString("Warning"), MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation); if (result == DialogResult.Yes) { Directory.Delete(Main.RemoteDirectory + node.GetServerData().name, true); node.Destroy(); } } else if (base.SelectedNode is RemoteDirectoryNode) { RemoteDirectoryNode node = (RemoteDirectoryNode)base.SelectedNode; DialogResult dr = MessageBox.Show( String.Format(Language.GetString("DialogDirectoryRemove"), node.Text), Language.GetString("Warning"), MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation); if (dr == DialogResult.Yes) { Ftp.deleteDirectory(node.data, node.directory); node.Destroy(); } } else if (base.SelectedNode is RemoteFileNode) { RemoteFileNode node = (RemoteFileNode)base.SelectedNode; DialogResult dr = MessageBox.Show( String.Format(Language.GetString("DialogFileRemove"), node.Text), Language.GetString("Warning"), MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation); if (dr == DialogResult.Yes) { Ftp.deleteFile(node.data, node.GetFile()); node.Remove(); } } }