/// <summary>Initializes a new instance of the <see cref="JackrabbitLibrary" /> class.</summary> /// <param name="fileType">The type of file</param> /// <param name="libraryName">The name of the library.</param> /// <param name="version">The version.</param> /// <param name="specificity">The version specificity.</param> public JackrabbitLibrary(FileType fileType, string libraryName, Version version, SpecificVersion specificity) { this.FileType = fileType; this.LibraryName = libraryName; this.Version = version; this.Specificity = specificity; }
private void FsCtl_Get_Compression_IsCompressionSupported(FileType fileType) { BaseTestSite.Log.Add(LogEntryKind.TestStep, "Test case steps:"); MessageStatus status; //Step 1: Create file BaseTestSite.Log.Add(LogEntryKind.TestStep, "1. Create " + fileType.ToString()); status = this.fsaAdapter.CreateFile(fileType); //Step 2: FSCTL request with FSCTL_GET_COMPRESSION FSCTL_GET_COMPRESSION_Reply compressionReply = new FSCTL_GET_COMPRESSION_Reply(); uint outputBufferSize = (uint)TypeMarshal.ToBytes<FSCTL_GET_COMPRESSION_Reply>(compressionReply).Length; long bytesReturned; byte[] outputBuffer = new byte[0]; BaseTestSite.Log.Add(LogEntryKind.TestStep, "2. FSCTL request with FSCTL_GET_COMPRESSION"); status = this.fsaAdapter.FsCtlGetCompression(outputBufferSize, out bytesReturned, out outputBuffer); //Step 3: Verify test result BaseTestSite.Log.Add(LogEntryKind.TestStep, "3. Verify returned NTSTATUS code."); // 2.1.5.9.7 FSCTL_GET_COMPRESSION // <64> Section 2.1.5.9.7: This is only implemented by the NTFS and ReFS file systems. if (this.fsaAdapter.FileSystem == FileSystem.NTFS || this.fsaAdapter.FileSystem == FileSystem.REFS) { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.SUCCESS, status, "FSCTL_GET_COMPRESSION is supported, status set to STATUS_SUCCESS."); } else { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.INVALID_DEVICE_REQUEST, status, "If the object store does not implement this functionality, the operation MUST be failed with STATUS_INVALID_DEVICE_REQUEST."); } }
public bool IsFileType(FileType type, [NotNull] string extensionName) { if (extensionName == null) throw new ArgumentNullException(nameof(extensionName)); Dictionary<string, ExtensionName> map; if (!this.mapedType.TryGetValue((int)type, out map)) return false; return map.ContainsKey(extensionName.TrimStart('.').ToLower()); }
private void AlternateDataStream_FsCtl_Set_ZeroData(FileType fileType) { //Prerequisites: Create streams on a newly created file //Step 1: FSCTL request with FSCTL_SET_ZERO_DATA FSCTL_SET_ZERO_DATA_Request setZeroDataRequest = new FSCTL_SET_ZERO_DATA_Request(); setZeroDataRequest.FileOffset = 0; setZeroDataRequest.BeyondFinalZero = 0; uint inputBufferSize = (uint)TypeMarshal.ToBytes<FSCTL_SET_ZERO_DATA_Request>(setZeroDataRequest).Length; BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. FSCTL request with FSCTL_SET_ZERO_DATA", ++testStep); status = this.fsaAdapter.FsCtlSetZeroData(setZeroDataRequest, inputBufferSize); //Step 2: Verify test result BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. Verify returned NTSTATUS code.", ++testStep); if (this.fsaAdapter.IsSetZeroDataSupported == false) { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.INVALID_DEVICE_REQUEST, status, "If the object store does not implement this functionality, the operation MUST be failed with STATUS_INVALID_DEVICE_REQUEST."); } else { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.SUCCESS, status, "FSCTL_SET_ZERO_DATA is supported, status set to STATUS_SUCCESS."); } }
static private FileType MakeFile(JadeData.Project.File file) { FileType result = new FileType(); result.Name = file.Name; result.Path = file.Path; return result; }
public string UserComment; // xml format #endregion Fields #region Constructors public G2File(String name, String hash, byte[] hashByte, TypeHash typeHash , long size, FileType fileType, String codecInfo , FileLocationFound filelocation, int lenghtMedia , String protocolName, String linkFile) : base(name,hash,hashByte,typeHash,size,fileType,codecInfo,filelocation,lenghtMedia,protocolName,linkFile) { }
private void AlternateDataStream_FsCtl_Get_IntegrityInformation(FileType fileType) { //Prerequisites: Create streams on a newly created file //Step 1: FSCTL Request with FSCTL_GET_INTEGRITY_INFORMATION FSCTL_GET_INTEGRITY_INFORMATION_BUFFER integrityInfo = new FSCTL_GET_INTEGRITY_INFORMATION_BUFFER(); uint outputBufferSize = (uint)TypeMarshal.ToBytes<FSCTL_GET_INTEGRITY_INFORMATION_BUFFER>(integrityInfo).Length; long bytesReturned; byte[] outputBuffer = new byte[0]; BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. FSCTL Request with FSCTL_GET_INTEGRITY_INFORMATION.", ++testStep); status = this.fsaAdapter.FsCtlGetIntegrityInfo(outputBufferSize, out bytesReturned, out outputBuffer); //Step 2: Verify test result BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. Verify returned NTStatus code.", ++testStep); if (this.fsaAdapter.Transport == Transport.SMB) { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.NOT_SUPPORTED, status, "This operation is not supported for SMB transport."); } else { if (this.fsaAdapter.IsIntegritySupported == false) { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.INVALID_DEVICE_REQUEST, status, "If the object store does not implement this functionality, the operation MUST be failed with STATUS_INVALID_DEVICE_REQUEST."); } else { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.SUCCESS, status, "Integrity is supported, status set to STATUS_SUCCESS."); } } }
public static string ContainingFolder(int sym, FileType type) { if (sym < 0) throw new ArgumentOutOfRangeException("sym"); return ContainingFolder(sym.ToString(), type); }
/// <summary> /// Gets search results for full text map search /// </summary> /// <param name="name">Name to search for</param> /// <returns>Search results</returns> public string GetResults(string name, FileType type) { return "Use CaDownloader to get maps and mods automatically: http://caspring.org/wiki/CaUpdater"; if (cachedResults.ContainsKey(name)) return cachedResults[name]; WebClient wc = new WebClient(); string result = ""; if (String.IsNullOrEmpty(name)) return "you must type name of map, e.g. !maplink altored"; try { result = wc.DownloadString("http://spring.unknown-files.net/page/search/1/" + (int)type + "/" + name); } catch { return "link search failed, unknown files down :("; } if (result == "" || !result.Contains("http://spring.unknown-files.net/file/")) return "link search failed, contact Licho"; int start = result.IndexOf("<b>Search Results</b>"); int end = result.IndexOf("<b>Quick Search</b>"); if (start == -1 || end == -1) return "no link found"; result = result.Substring(start, end - start); // pickup just result lines + something MatchCollection c = Regex.Matches(result, "<a href='(http://spring.unknown-files.net/file/[0-9]*)[^>]*>([^<]+)"); string response = ""; foreach (Match m in c) response += m.Groups[2].Value + " ---> " + m.Groups[1].Value + "\n"; if (response == "") response = "no such map found"; cachedResults[name] = response; return response; }
public IEnumerable<IMediaFile> GetMediaForProjectByType(int projectId, FileType type) { var wikiFiles = WikiFile.CurrentFiles(projectId); var mediaFiles = new List<MediaFile>(); foreach (var wikiFile in wikiFiles) { var mediaFile = new MediaFile { Current = wikiFile.Current, Archived = wikiFile.Archived, CreateDate = wikiFile.CreateDate, Name = wikiFile.Name, Id = wikiFile.Id, CreatedBy = wikiFile.CreatedBy, DotNetVersion = wikiFile.DotNetVersion, Downloads = wikiFile.Downloads, FileType = (FileType)Enum.Parse(typeof(FileType), wikiFile.FileType), FileVersion = wikiFile.NodeVersion, Path = wikiFile.Path, RemovedBy = wikiFile.RemovedBy, SupportsMediumTrust = false, UmbVersion = wikiFile.Versions, Verified = wikiFile.Verified }; if (mediaFiles.Contains(mediaFile) == false) mediaFiles.Add(mediaFile); } return mediaFiles; }
internal static char GetDelimiter(FileType fileType) { char delimiter; switch (fileType) { case FileType.CSV: { delimiter = ','; break; } case FileType.TXT: { delimiter = '\t'; break; } default: { Debug.Assert(false, "Un supported FileType"); delimiter = ','; break; } } return delimiter; }
private void configure(FileType type, P3DOperation operation, String addonPath) { // Prepare the process to run ProcessStartInfo start = new ProcessStartInfo(); // Enter in the command line arguments, everything you would enter after the executable name itself start.Arguments = "-Configure: File=" + type + ", Operation=" + operation + ", Path=" + addonPath; // Enter the executable to run, including the complete path start.FileName = @"C:\Prepar3D v3\Prepar3D.exe"; // Do you want to show a console window? start.WindowStyle = ProcessWindowStyle.Hidden; start.CreateNoWindow = true; int exitCode; logger.Info("Calling Prepar3D.exe with arguments {0}", start.Arguments); // Run the external process & wait for it to finish using (Process proc = Process.Start(start)) { proc.WaitForExit(); // Retrieve the app's exit code exitCode = proc.ExitCode; } }
private void FsCtl_Set_Sparse_IsSparseFileSupported(FileType fileType) { BaseTestSite.Log.Add(LogEntryKind.TestStep, "Test case steps:"); MessageStatus status; //Step 1: Create file BaseTestSite.Log.Add(LogEntryKind.TestStep, "1. Create " + fileType.ToString()); status = this.fsaAdapter.CreateFile(fileType); //Step 2: Write data to file if (fileType == FileType.DataFile) { long bytesToWrite = 1024; long bytesWritten = 0; BaseTestSite.Log.Add(LogEntryKind.TestStep, "2. Write the file with " + bytesToWrite + " bytes."); status = this.fsaAdapter.WriteFile(0, bytesToWrite, out bytesWritten); } else { BaseTestSite.Log.Add(LogEntryKind.TestStep, "2. Do not write data to directory file."); } //Step 3: FSCTL request with FSCTL_SET_SPARSE BaseTestSite.Log.Add(LogEntryKind.TestStep, "3. FSCTL request with FSCTL_SET_SPARSE"); status = this.fsaAdapter.FsCtlSetSparse(true); //Step 4: Verify test result BaseTestSite.Log.Add(LogEntryKind.TestStep, "4. Verify returned NTSTATUS code."); if (this.fsaAdapter.FileSystem == FileSystem.FAT32) { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.INVALID_DEVICE_REQUEST, status, "If the object store does not implement this functionality, the operation MUST be failed with STATUS_INVALID_DEVIeCE_REQUEST."); return; } if (fileType == FileType.DirectoryFile) { if (this.fsaAdapter.FileSystem == FileSystem.CSVFS) { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.STATUS_NOT_IMPLEMENTED, status, "If the Open is a directory on a Cluster Shared Volume File System (CSVFS), the operation MUST be failed with STATUS_NOT_IMPLEMENTED."); } else { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.INVALID_PARAMETER, status, "If the file is not a Data file, the operation MUST be failed with STATUS_INVALID_PARAMETER."); } return; } if (this.fsaAdapter.IsSparseFileSupported == false) { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.INVALID_DEVICE_REQUEST, status, "If the object store does not implement this functionality, the operation MUST be failed with STATUS_INVALID_DEVICE_REQUEST."); } else { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.SUCCESS, status, "FSCTL_SET_SPARSE is supported, status set to STATUS_SUCCESS."); } }
private static FileDialogResult ShowFileDialog(object owner, FileDialog dialog, IEnumerable<FileType> fileTypes, FileType defaultFileType, string defaultFileName) { int filterIndex = fileTypes.ToList().IndexOf(defaultFileType); if (filterIndex >= 0) { dialog.FilterIndex = filterIndex + 1; } if (!string.IsNullOrEmpty(defaultFileName)) { dialog.FileName = Path.GetFileName(defaultFileName); string directory = Path.GetDirectoryName(defaultFileName); if (!string.IsNullOrEmpty(directory)) { dialog.InitialDirectory = directory; } } dialog.Filter = CreateFilter(fileTypes); if (dialog.ShowDialog(owner as Window) == true) { filterIndex = dialog.FilterIndex - 1; if (filterIndex >= 0 && filterIndex < fileTypes.Count()) { defaultFileType = fileTypes.ElementAt(filterIndex); } else { defaultFileType = null; } return new FileDialogResult(dialog.FileName, defaultFileType); } else { return new FileDialogResult(); } }
public Document(string filePath, bool needSaveAs) { this.needSaveAs = needSaveAs; if (!File.Exists(filePath)) throw new FileNotFoundException("\"{0}\" does not exist.".F(filePath), filePath); try { foreach (string line in GetFileContent(filePath)) lines.Add(new Line(line, LineModification.Clean, this)); } catch { throw new FileNotFoundException("\"{0}\" could not be opened.".F(filePath), filePath); } point = new Caret(this); mark = new Caret(this); this.filePath = filePath; this.fileType = Config.ChooseFileType(filePath); if (lines.Count == 0) lines.Add(new Line("", LineModification.Clean, this)); lastModified = File.GetLastWriteTime(filePath); }
private bool BothHaveTextAndData(FileType addedTypes) { return (FileType.HasFlag(FileType.Data) && addedTypes.HasFlag(FileType.Text)) || (FileType.HasFlag(FileType.Text) && addedTypes.HasFlag(FileType.Data)); }
private bool BothHaveRarAndGZip(FileType addedTypes) { return (FileType.HasFlag(FileType.Rar) && addedTypes.HasFlag(FileType.GZip)) || (FileType.HasFlag(FileType.GZip) && addedTypes.HasFlag(FileType.Rar)); }
public void Remove(FileType fileTypes) { if (FileType.HasFlag(fileTypes)) { FileType &= ~fileTypes; } }
private void AlternateDataStream_Query_FileNetworkOpenInformation(FileType fileType) { //Prerequisites: Create streams on a newly created file //Step 1: Query FILE_NETWORKOPEN_INFORMATION long byteCount; byte[] outputBuffer; FileNetworkOpenInformation fileNetworkOpenInfo = new FileNetworkOpenInformation(); uint outputBufferSize = (uint)TypeMarshal.ToBytes<FileNetworkOpenInformation>(fileNetworkOpenInfo).Length; BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. QueryFileInformation with FileInfoClass.FILE_NETWORKOPEN_INFORMATION", ++testStep); status = this.fsaAdapter.QueryFileInformation(FileInfoClass.FILE_NETWORKOPEN_INFORMATION, outputBufferSize, out byteCount, out outputBuffer); // Step 2: Verify FILE_NETWORKOPEN_INFORMATION fileNetworkOpenInfo = TypeMarshal.ToStruct<FileNetworkOpenInformation>(outputBuffer); bool isIntegrityStreamSet = (fileNetworkOpenInfo.FileAttributes & (uint)FileAttribute.INTEGRITY_STREAM) == (uint)FileAttribute.INTEGRITY_STREAM; BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. Verify outputBuffer.FileAttributes.FILE_ATTRIBUTE_INTEGRITY_STREAM", ++testStep); if (this.fsaAdapter.IsIntegritySupported == true) { this.fsaAdapter.AssertAreEqual(this.Manager, true, isIntegrityStreamSet, "If integrity is supported, the object store MUST set FILE_ATTRIBUTE_INTEGRITY_STREAM in OutputBuffer.FileAttributes."); } else { this.fsaAdapter.AssertAreEqual(this.Manager, false, isIntegrityStreamSet, "Integrity is not supported, FILE_ATTRIBUTE_INTEGRITY_STREAM MUST NOT set."); } }
static private FileType MakeFile(JadeCore.Project.FileItem file, string projectDir) { FileType result = new FileType(); //Convert to relative path for storage in workspace result.Path = JadeUtils.IO.PathUtils.CalculateRelativePath(projectDir + @"\", file.Path.Str); return result; }
private void FsInfo_Query_FileFsSizeInformation_SectorsPerAllocationUnit(FileType fileType) { BaseTestSite.Log.Add(LogEntryKind.TestStep, "Test case steps:"); MessageStatus status; //Step 1: Create file BaseTestSite.Log.Add(LogEntryKind.TestStep, "1. Create " + fileType.ToString()); status = this.fsaAdapter.CreateFile(fileType); //Step 2: Query FileFsSizeInformation long byteCount; byte[] outputBuffer = new byte[0]; FileFsSizeInformation fsSizeInfo = new FileFsSizeInformation(); uint outputBufferSize = (uint)TypeMarshal.ToBytes<FileFsSizeInformation>(fsSizeInfo).Length; BaseTestSite.Log.Add(LogEntryKind.TestStep, "2. Query FileFsSizeInformation"); status = this.fsaAdapter.QueryFileSystemInformation(FileSystemInfoClass.File_FsSizeInformation, outputBufferSize, out byteCount, out outputBuffer); //Step 3: Verify test result BaseTestSite.Log.Add(LogEntryKind.TestStep, "3. Verify OutputBuffer.SectorsPerAllocationUnit"); fsSizeInfo = TypeMarshal.ToStruct<FileFsSizeInformation>(outputBuffer); uint expectedSectorsPerAllocationUnit = this.fsaAdapter.ClusterSizeInKB * 1024 / fsSizeInfo.BytesPerSector; uint actualSectorsPerAllocationUnit = fsSizeInfo.SectorsPerAllocationUnit; BaseTestSite.Log.Add(LogEntryKind.Debug, "ClusterSize is " + this.fsaAdapter.ClusterSizeInKB + " KB."); BaseTestSite.Log.Add(LogEntryKind.Debug, "BytesPerSector is " + fsSizeInfo.BytesPerSector + " bytes."); this.fsaAdapter.AssertAreEqual(this.Manager, expectedSectorsPerAllocationUnit, actualSectorsPerAllocationUnit, "OutputBuffer.SectorsPerAllocationUnit set to Open.File.Volume.ClusterSize / Open.File.Volume.LogicalBytesPerSector."); }
public MessageEventArgs_402(int messageId, string messageName, string path, FileType fileType, int size, DateTime created, DateTime modified, string checksum, string comment) : base(messageId, messageName, path, fileType, size, created, modified) { this.checksum = checksum; this.comment = comment; }
/// <summary> /// Returns an extension based on the given file type. /// </summary> /// <param name="fileType"></param> /// <returns></returns> public static string FileTypeToExtension(FileType fileType) { string extension = null; switch (fileType) { case FileType.CSS: extension = ".css"; break; case FileType.JavaScript: extension = ".js"; break; case FileType.Gif: extension = ".gif"; break; case FileType.Jpeg: extension = ".jpg"; break; case FileType.Png: extension = ".png"; break; default: throw new Exception("FileTypeToExtension - unknown file type: " + fileType.ToString()); } return extension; }
private void AlternateDataStream_FsCtl_Query_AllocatedRanges(FileType fileType) { //Prerequisites: Create streams on a newly created file //Step 1: FSCTL request with FSCTL_QUERY_ALLOCATED_RANGES long byteCount; byte[] outputBuffer; FSCTL_QUERY_ALLOCATED_RANGES_Request queryAllocatedRangesRequest = new FSCTL_QUERY_ALLOCATED_RANGES_Request(); queryAllocatedRangesRequest.FileOffset = 0; queryAllocatedRangesRequest.Length = dataStreamList[":" + dataStreamName1 + ":$DATA"]; uint outputBufferSize = (uint)TypeMarshal.ToBytes<FSCTL_QUERY_ALLOCATED_RANGES_Request>(queryAllocatedRangesRequest).Length; BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. FSCTL request with FSCTL_QUERY_ALLOCATED_RANGES", ++testStep); status = this.fsaAdapter.FsCtlQueryAllocatedRanges(queryAllocatedRangesRequest, outputBufferSize, out byteCount, out outputBuffer); //Step 2: Verify test result BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. Verify returned NTStatus code.", ++testStep); if (this.fsaAdapter.IsQueryAllocatedRangesSupported == false) { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.INVALID_DEVICE_REQUEST, status, "If the object store does not implement this functionality, the operation MUST be failed with STATUS_INVALID_DEVICE_REQUEST."); } else { FSCTL_QUERY_ALLOCATED_RANGES_Reply queryAllocatedRangesReply = TypeMarshal.ToStruct<FSCTL_QUERY_ALLOCATED_RANGES_Reply>(outputBuffer); this.fsaAdapter.AssertAreEqual(this.Manager, dataStreamList[":" + dataStreamName1 + ":$DATA"], queryAllocatedRangesReply.Length, "AllocatedRanges.Length is expected to same as the length of written data."); this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.SUCCESS, status, "FSCTL_QUERY_ALLOCATED_RANGES is supported, status set to STATUS_SUCCESS."); } }
private void AlternateDataStream_Set_FileShortNameInformation(FileType fileType) { //Prerequisites: Create streams on a newly created file //Step 1: Set FILE_SHORTNAME_INFORMATION FileShortNameInformation shortNameInfo = new FileShortNameInformation(); string shortName = this.fsaAdapter.ComposeRandomFileName(8); shortNameInfo.FileName = Encoding.Unicode.GetBytes(shortName); shortNameInfo.FileNameLength = (uint)shortNameInfo.FileName.Length; byte[] inputBuffer = TypeMarshal.ToBytes<FileShortNameInformation>(shortNameInfo); BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. SetFileInformation with FileInfoClass.FILE_SHORTNAME_INFORMATION.", ++testStep); status = this.fsaAdapter.SetFileInformation(FileInfoClass.FILE_SHORTNAME_INFORMATION, inputBuffer); if (this.fsaAdapter.IsShortNameSupported == false) { BaseTestSite.Log.Add(LogEntryKind.Debug, "FileShortNameInformation is not supported."); this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.INVALID_PARAMETER, status, "If a file system does not support a specific File Information Class, STATUS_INVALID_PARAMETER MUST be returned."); } else { if (status == MessageStatus.SHORT_NAMES_NOT_ENABLED_ON_VOLUME) { BaseTestSite.Log.Add(LogEntryKind.Debug, "If Open.File.Volume.GenerateShortNames is FALSE, the operation MUST be failed with STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME."); BaseTestSite.Log.Add(LogEntryKind.Debug, "To enable short name in specific volume, such as volume with driver letter N:, use command: fsutil 8dot3name set N: 0."); } else { this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.INVALID_PARAMETER, status, "If Open.Stream.StreamType is DataStream and Open.Stream.Name is not empty. The operation MUST be failed with STATUS_INVALID_PARAMETER."); } } }
private static bool IsHeaderLinkOrScriptControlAdded(Page page, string ResolvedUrl, FileType fType) { switch (fType) { case FileType.Css: foreach (Control c in page.Header.Controls) { var linkControl = c as HtmlLink; if (linkControl == null) continue; if (linkControl.Attributes["href"] == ResolvedUrl) return true; } break; case FileType.Javascript: foreach (Control c in page.Header.Controls) { var genericControl = c as HtmlGenericControl; if (genericControl == null) continue; if (genericControl.Attributes["src"] == ResolvedUrl) return true; } break; } return false; }
/// <summary> /// Create one alternate data stream on the newly created file /// </summary> /// <param name="fileType">The newly created file type: DataFile, DirectoryFile</param> private void AlternateDataStream_CreateStream(FileType fileType) { dataStreamList = new Dictionary<string, long>(); long bytesToWrite = 0; long bytesWritten = 0; //Step 1: Create a new File, it could be a DataFile or a DirectoryFile fileName = this.fsaAdapter.ComposeRandomFileName(8); createFileType = (fileType == FileType.DataFile ? CreateOptions.NON_DIRECTORY_FILE : CreateOptions.DIRECTORY_FILE); BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. Create a file with type: " + fileType.ToString() + " and name: " + fileName, ++testStep); status = this.fsaAdapter.CreateFile( fileName, FileAttribute.NORMAL, createFileType, FileAccess.GENERIC_ALL, ShareAccess.FILE_SHARE_READ | ShareAccess.FILE_SHARE_WRITE | ShareAccess.FILE_SHARE_DELETE, CreateDisposition.OPEN_IF); this.fsaAdapter.AssertIfNotSuccess(status, "Create file operation failed"); //Step 2: Write some bytes into the Unnamed Data Stream in the newly created file if (fileType == FileType.DataFile) { //Write some bytes into the DataFile. bytesToWrite = 1024; bytesWritten = 0; dataStreamList.Add("::$DATA", bytesToWrite); BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. Write the file with " + bytesToWrite + " bytes data.", ++testStep); status = this.fsaAdapter.WriteFile(0, bytesToWrite, out bytesWritten); this.fsaAdapter.AssertIfNotSuccess(status, "Write data to file operation failed."); } else { //Do not write data into DirectoryFile. bytesToWrite = 0; BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. Do not write data into DirectoryFile.", ++testStep); } //Step 3: Create an Alternate Data Stream <Stream1> in the newly created file dataStreamName1 = this.fsaAdapter.ComposeRandomFileName(8); BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. Create an Alternate Data Stream with name: " + dataStreamName1 + " on this file.", ++testStep); status = this.fsaAdapter.CreateFile( fileName + ":" + dataStreamName1 + ":$DATA", FileAttribute.NORMAL | FileAttribute.INTEGRITY_STREAM, // Set Integrity field CreateOptions.NON_DIRECTORY_FILE, FileAccess.GENERIC_ALL, ShareAccess.FILE_SHARE_READ | ShareAccess.FILE_SHARE_WRITE | ShareAccess.FILE_SHARE_DELETE, CreateDisposition.OPEN_IF); this.fsaAdapter.AssertIfNotSuccess(status, "Create Alternate Data Stream operation failed"); //Step 4: Write some bytes into the Alternate Data Stream <Stream1> in the file bytesToWrite = 2048; bytesWritten = 0; dataStreamList.Add(":" + dataStreamName1 + ":$DATA", bytesToWrite); BaseTestSite.Log.Add(LogEntryKind.TestStep, "{0}. Write the stream with " + bytesToWrite + " bytes data.", ++testStep); status = this.fsaAdapter.WriteFile(0, bytesToWrite, out bytesWritten); this.fsaAdapter.AssertIfNotSuccess(status, "Write data to stream operation failed."); }
/// <summary> /// Determines whether [is valid file type] [the specified file type]. /// </summary> /// <param name="control">The control.</param> /// <param name="fileType">Type of the file.</param> /// <returns></returns> /// <createdOn>1/26/2016 12:27 PM</createdOn> public static bool IsValidFileType(this FileUpload control, FileType fileType = FileType.Image) { if (!control.HasFile || !control.HasFiles) throw new Exception("No file exsit in the file upload"); var isAllowedExtension = false; if (control.AllowMultiple) { foreach (var file in control.PostedFiles) { isAllowedExtension = FileTypeSetting.IsAllowedExtension(file.FileName.GetSimpleFileExtension(), fileType); if (!isAllowedExtension) return false; } } else { isAllowedExtension = FileTypeSetting.IsAllowedExtension(control.PostedFile.FileName.GetSimpleFileExtension(), fileType); } return isAllowedExtension; }
public void FindLinks(string[] words, FileType type, TasClient tas, TasSayEventArgs e) { if (words.Length == 0) { Battle b = tas.MyBattle; if (b == null) return; ah.Respond(e, string.Format("Getting Zero-K mirrors for currently hosted {0}", type)); if (type == FileType.Map) GetLinksAsync(b.MapName, e); else GetLinksAsync(b.ModName, e); } else { int[] resultIndexes; string[] resultVals; int cnt; if (type == FileType.Map) cnt = ah.FilterMaps(words, out resultVals, out resultIndexes); else cnt = ah.FilterMods(words, out resultVals, out resultIndexes); if (cnt == 0) ah.Respond(e, string.Format("No such {0} found", type)); else { ah.Respond(e, string.Format("Getting Zero-K mirrors for {0}, please wait", resultVals[0])); GetLinksAsync(resultVals[0], e); } } }
internal static FileType GetInternalFileType(FileType fileType) { switch (fileType) { case FileType.WordDocument: case FileType.WordDocumentX: case FileType.WordDocumentMacroX: case FileType.WordDocumentTemplateX: case FileType.WordDocumentMacroTemplateX: case FileType.RTFDocument: return FileType.WordDocument; case FileType.ExcelSheet: case FileType.ExcelSheetX: case FileType.ExcelSheetMacroX: case FileType.ExcelSheetTemplateX: case FileType.ExcelSheetMacroTemplateX: return FileType.ExcelSheet; case FileType.PowerPoint: case FileType.PowerPointX: case FileType.PowerPointMacroX: case FileType.PowerPointTemplateX: case FileType.PowerPointMacroTemplateX: case FileType.PowerPointShowX: case FileType.PowerPointMacroShowX: return FileType.PowerPoint; default: return fileType; } }
public static void HandleContainer(Container container) { // Get the FileType FileType fileType = FileTypeExtensions.GetTypeFromContainer(container); // Format the destination S3 path string s3Path = $"/smash/{FileTypeExtensions.GetNamePrefixFromType(fileType)}/{container.Id}"; // Convert the Container into a JSON string byte[] json = Encoding.UTF8.GetBytes(WebFileHandler.ToJson(container)); // Write the data to S3 S3Api.TransferFile(json, s3Path, "data.json", "application/json"); // Check if this has an image if (fileType == FileType.Event || fileType == FileType.PopUpNews || fileType == FileType.Present) { // Get the image byte[] image = (byte[])container.GetType().GetProperty("Image").GetValue(container); // Write the image to S3 S3Api.TransferFile(image, s3Path, "image.jpg", "image/jpeg"); // Create a new MagickImage using (MagickImage magickImage = new MagickImage(image)) { // Set the output format to WebP magickImage.Format = MagickFormat.WebP; // Create the raw WebP byte[] webpImage = magickImage.ToByteArray(); // Upload to S3 S3Api.TransferFile(webpImage, s3Path, "image.webp", "image/webp"); } } lock (WebFileHandler.Lock) { // Connect to the remote server if needed WebFileHandler.Connect(((SsbuBotConfiguration)Configuration.LoadedConfiguration).WebConfig); // Convert the Container to a StrippedContainer StrippedContainer strippedContainer = StrippedContainer.ConvertToStrippedContainer(container); // Declare a variable to hold the container list List <StrippedContainer> containerList; // Format the container list path string indexPath = string.Format(((SsbuBotConfiguration)Configuration.LoadedConfiguration).WebConfig.ContainerListPath, FileTypeExtensions.GetNamePrefixFromType(fileType)); // Check if the file exists if (WebFileHandler.Exists(indexPath)) { // Deserialize the List containerList = WebFileHandler.ReadAllText <List <StrippedContainer> >(indexPath); } else { // Create a new List containerList = new List <StrippedContainer>(); } // Check if the Container already exists in the list int index = containerList.FindIndex(x => x.Id == container.Id); // Check the index if (index == -1) { // Add the StrippedContainer to the List containerList.Insert(0, strippedContainer); } else { // Replace the item at the index containerList[index] = strippedContainer; } // Serialize and write the container list WebFileHandler.WriteAllText(indexPath, WebFileHandler.ToJson(containerList)); // Declare a variable to hold the ContainerIndex ContainerIndex containerIndex; // Check if the ContainerIndex exists if (!WebFileHandler.Exists(((SsbuBotConfiguration)Configuration.LoadedConfiguration).WebConfig.ContainerIndexPath)) { // Create a dummy StrippedContainer StrippedContainer dummyStrippedContainer = new StrippedContainer(); dummyStrippedContainer.Id = "-1"; dummyStrippedContainer.Text = new Dictionary <Nintendo.Bcat.Language, string>(); // Create a dummy ContainerIndex containerIndex = new ContainerIndex(); containerIndex.Event = dummyStrippedContainer; containerIndex.LineNews = dummyStrippedContainer; containerIndex.PopUpNews = dummyStrippedContainer; containerIndex.Present = dummyStrippedContainer; } else { // Read the file containerIndex = WebFileHandler.ReadAllText <ContainerIndex>(((SsbuBotConfiguration)Configuration.LoadedConfiguration).WebConfig.ContainerIndexPath); } // Get the correct property PropertyInfo propertyInfo = containerIndex.GetType().GetProperty(container.GetType().Name); // Set the value propertyInfo.SetValue(containerIndex, strippedContainer); // Write out the ContainerIndex WebFileHandler.WriteAllText(((SsbuBotConfiguration)Configuration.LoadedConfiguration).WebConfig.ContainerIndexPath, WebFileHandler.ToJson(containerIndex)); // Disconnect from the remote server WebFileHandler.Disconnect(); } }
//nothing to do here, just pass data to generic constructor public ItemTRSData(string _path, FileType _type) : base(_path, _type) { }
public FileHeader(FileType type, string extension, string header) { this.Type = type; this.Extension = extension; this.Header = parsePattern(header); }
private static extern bool RENDERDOC_GetThumbnail(IntPtr filename, FileType type, UInt32 maxsize, IntPtr outmem);
public AudioFile(string filename, FileType filetype) { m_Filename = filename; m_Filetype = filetype; }
public FileHandle getFileHandle(string path, FileType type) { return(new GLFWFileHandle(path, type)); }
public void SendKno2Message(MessageDTO message) { try { //config DTO Kno2ConfigurationDTO configDTO = this.GetKno2Configuration(); //Get the httpClient that will be used for the transmissions HttpClient httpClient = this.GetHttpClient(configDTO); //Validate the addresses (probably optional) Dictionary <string, bool> addressValidationResults = ApiHelper.ValidateAddresses(httpClient: httpClient, directoryValidateUri: this.DirectoryValidate(), addresses: new[] { message.ToAddress, configDTO.FromAddress }); // Request the available document types (cacheable) IEnumerable <string> documentTypes = ApiHelper.RequestDocumentTypes(httpClient: httpClient, documentTypesUri: this.DocumentTypesUri()); // Request a message draft id var outboundMessage = ApiHelper.RequestMessageDraft(httpClient: httpClient, messageUri: this.MessagesUri() ); var attachmentIds = new List <string>(); FileType fileType = message.FileType; //get a new file name string fileName = FileHelpers.GenerateAttachmentName(fileType); //upload the attachment var attachment = ApiHelper.UploadAttachment(httpClient: httpClient, attachmentsUri: this.AttachmentsUri(outboundMessage.Id), fileName: fileName, attachment: new AttachmentResource { NativeFileName = fileName, NativeFileBytes = message.FileBytes, DocumentType = documentTypes.First(), AttachmentMeta = new AttachmentMetaResource { DocumentTitle = message.DocumentTitle, DocumentType = documentTypes.First(), DocumentDate = DateTime.UtcNow, DocumentDescription = message.DocumentDescription, Confidentiality = Confidentiality.Normal } } ); // Request the attachment meta data var attachments = new List <AttachmentResource>(); string id = attachment.Id; var metadata = ApiHelper.RequestAttachmentMetadata(httpClient: httpClient, attachmentsUri: this.AttachmentsUri(messageId: outboundMessage.Id, attachmentId: id) ); attachments.Add(metadata); // Send the message (draft) outboundMessage.Attachments = attachments; outboundMessage.Subject = configDTO.Subject; outboundMessage.ToAddress = message.ToAddress; outboundMessage.FromAddress = configDTO.FromAddress; outboundMessage.Comments = message.Comments; outboundMessage.Body = message.Body; outboundMessage.Patient = new Patient { BirthDate = message.BirthDate, FirstName = message.FirstName, Gender = message.Gender, LastName = message.LastName, MiddleName = message.MiddleName, PatientId = message.PatientId, }; ApiHelper.SendDraft(httpClient: httpClient, messageUri: this.MessagesUri(outboundMessage.Id), messageResource: outboundMessage); ApiHelper.SendRelease(httpClient: httpClient, messageSendUri: this.MessageSendUri(outboundMessage.Id), messageResource: outboundMessage ); } catch (AggregateException ex) { StringBuilder sb = new StringBuilder(); foreach (var innerException in ex.InnerExceptions) { sb.AppendLine(innerException.Message); sb.AppendLine(innerException.StackTrace); innerException.Message.ToConsole(); if (innerException.InnerException != null) { sb.AppendLine(innerException.InnerException.Message); sb.AppendLine(innerException.InnerException.StackTrace); } } throw new Exception(sb.ToString()); } catch (Exception ex) { throw ex; } }
public Document(string title, string message, FileType fileType, byte[] documentBytes) : base(title, message, fileType, documentBytes) { }
public Document(string title, string message, FileType fileType, string documentPath) : base(title, message, fileType, documentPath) { }
private static FileInfo GetFileInfo(Context context, XmlNode node) { string displayName = node.SelectSingleNode("DisplayName").InnerText; Guid guid = new Guid(node.SelectSingleNode("Guid").InnerText); int size = Int32.Parse(node.SelectSingleNode("Size").InnerText); FileType filetype = (FileType)Enum.Parse(typeof(FileType), node.Name); int sectionCount = Int32.Parse(node.SelectSingleNode("Sections/@count").InnerText); int[] sectionLengths = new int[sectionCount]; bool[] dteAllowed = new bool[sectionCount]; bool[] compressionAllowed = new bool[sectionCount]; bool[] hidden = new bool[sectionCount]; for (int i = 0; i < sectionCount; i++) { XmlNode sectionNode = node.SelectSingleNode(string.Format("Sections/Section[@value='{0}']", i)); XmlAttribute hideAttribute = sectionNode.Attributes["hide"]; if (hideAttribute != null) { hidden[i] = Boolean.Parse(hideAttribute.InnerText); } sectionLengths[i] = Int32.Parse(sectionNode.Attributes["entries"].InnerText); dteAllowed[i] = Boolean.Parse(sectionNode.Attributes["dte"].InnerText); if (filetype == FileType.CompressedFile) { compressionAllowed[i] = Boolean.Parse(sectionNode.Attributes["compressible"].InnerText); } } XmlNodeList sectors = node.SelectNodes("Sectors/*"); Dictionary <SectorType, IList <KeyValuePair <Enum, int> > > dict = new Dictionary <SectorType, IList <KeyValuePair <Enum, int> > >(3); bool first = true; KeyValuePair <Enum, int> primaryFile = new KeyValuePair <Enum, int>(); foreach (XmlNode sectorNode in sectors) { SectorType sectorType = (SectorType)Enum.Parse(typeof(SectorType), sectorNode.Name); if (!dict.ContainsKey(sectorType)) { dict.Add(sectorType, new List <KeyValuePair <Enum, int> >()); } int offset = Int32.Parse(sectorNode.Attributes["offset"].InnerText); Enum fileEnum = null; switch (sectorType) { case SectorType.BootBin: dict[sectorType].Add(new KeyValuePair <Enum, int>(PatcherLib.Iso.PspIso.Sectors.PSP_GAME_SYSDIR_BOOT_BIN, offset)); dict[sectorType].Add(new KeyValuePair <Enum, int>(PatcherLib.Iso.PspIso.Sectors.PSP_GAME_SYSDIR_EBOOT_BIN, offset)); fileEnum = PatcherLib.Iso.PspIso.Sectors.PSP_GAME_SYSDIR_BOOT_BIN; break; case SectorType.FFTPack: FFTPack.Files fftPackFile = (FFTPack.Files)Enum.Parse(typeof(FFTPack.Files), sectorNode.SelectSingleNode("@index").InnerText); dict[sectorType].Add(new KeyValuePair <Enum, int>(fftPackFile, offset)); fileEnum = fftPackFile; break; case SectorType.Sector: PatcherLib.Iso.PsxIso.Sectors file = (PatcherLib.Iso.PsxIso.Sectors)Enum.Parse(typeof(PatcherLib.Iso.PsxIso.Sectors), sectorNode.SelectSingleNode("@filename").InnerText); dict[sectorType].Add(new KeyValuePair <Enum, int>(file, offset)); fileEnum = file; break; } if (first) { //bytes = reader( iso, fileEnum, offset, size ); primaryFile = new KeyValuePair <Enum, int>(fileEnum, offset); first = false; } } IList <IList <string> > entryNames = GetEntryNames(node.SelectSingleNode("Sections"), node.SelectSingleNode("//Templates")); IList <string> sectionNames = GetSectionNames(node.SelectSingleNode("Sections")); IList <IList <int> > disallowedEntries; IList <IDictionary <int, string> > staticEntries; GetDisallowedEntries(node, sectionLengths.Length, out disallowedEntries, out staticEntries); Set <byte> terminators = new Set <byte>(new byte[] { 0xFE }); XmlNode terminatorNode = node.SelectSingleNode("Terminators"); if (terminatorNode != null) { foreach (XmlNode nnn in terminatorNode.SelectNodes("Terminator")) { terminators.Add( byte.Parse(nnn.InnerText, System.Globalization.NumberStyles.HexNumber)); } } FileInfo fi = new FileInfo { Context = context, DisplayName = displayName, DisallowedEntries = disallowedEntries.AsReadOnly(), StaticEntries = staticEntries.AsReadOnly(), EntryNames = entryNames.AsReadOnly(), FileType = filetype, Guid = guid, Hidden = hidden.AsReadOnly(), SectionLengths = sectionLengths.AsReadOnly(), Sectors = new ReadOnlyDictionary <SectorType, IList <KeyValuePair <Enum, int> > >(dict), SectionNames = sectionNames, AllowedTerminators = terminators.AsReadOnly(), Size = size, PrimaryFile = primaryFile, CompressionAllowed = compressionAllowed, DteAllowed = dteAllowed }; return(fi); }
public DatasourceDetail(FileType fileType, FileNameList filesName) { FileType = fileType; FilesName = filesName; }
/// <summary> /// Calls on the private Add method to add an element to the Tree! /// </summary> /// <param name="filepath"> Location of the node we are removing </param> /// <param name="data"> Data of node we are adding </param> /// <param name="type"> Type of file we are adding </param> public void Add(Queue <string> filepath, string data, FileType type) { _elements = Add(filepath, _elements, type, data); }
public OpenCommand(IconFitterVM viewModel, FileType fileType) : base(viewModel) { FileType = fileType; }
public static string GetTemplate(this FileType ftype) { //ToDo: make templates customizable return(ftype.FileTemplate); }
public static RvFile FromADir(RvFile dbDir, EScanLevel eScanLevel, ThreadWorker bgw, ref bool fileErrorAbort) { string fullDir = dbDir.FullName; DatStatus datStatus = dbDir.IsInToSort ? DatStatus.InToSort : DatStatus.NotInDat; RvFile fileDir = new RvFile(FileType.Dir); DirectoryInfo oDir = new DirectoryInfo(fullDir); DirectoryInfo[] oDirs = oDir.GetDirectories(); FileInfo[] oFiles = oDir.GetFiles(); // add all the subdirectories into scanDir foreach (DirectoryInfo dir in oDirs) { RvFile tDir = new RvFile(FileType.Dir) { Name = dir.Name, FileModTimeStamp = dir.LastWriteTime }; tDir.SetStatus(datStatus, GotStatus.Got); fileDir.ChildAdd(tDir); } // add all the files into scanDir foreach (FileInfo oFile in oFiles) { string fName = oFile.Name; if (fName == "__RomVault.tmp") { File.Delete(oFile.FullName); continue; } string fExt = Path.GetExtension(oFile.Name); FileType ft = DBTypeGet.fromExtention(fExt); if (Settings.rvSettings.FilesOnly) { ft = FileType.File; } RvFile tFile = new RvFile(ft) { Name = oFile.Name, Size = (ulong)oFile.Length, FileModTimeStamp = oFile.LastWriteTime }; tFile.FileStatusSet(FileStatus.SizeVerified); tFile.SetStatus(datStatus, GotStatus.Got); if (eScanLevel == EScanLevel.Level3 && tFile.FileType == FileType.File) { FromAFile(tFile, fullDir, eScanLevel, bgw, ref fileErrorAbort); } fileDir.ChildAdd(tFile); } return(fileDir); }
public string?GetFileUrl(string name, FileType fileType) => fileType switch {
private void TextureSaveDialog_Shown(object sender, EventArgs e) { jpegCompression.Value = saveData.jpegQuality; blackPoint.Text = Formatter.Format(saveData.comp.blackPoint); whitePoint.Text = Formatter.Format(saveData.comp.whitePoint); mipSelect.Items.Clear(); for (int i = 0; i < tex.mips; i++) { mipSelect.Items.Add(i + " - " + Math.Max(1, tex.width >> i) + "x" + Math.Max(1, tex.height >> i)); } mipSelect.SelectedIndex = (saveData.mip >= 0 ? saveData.mip : 0); sampleSelect.Items.Clear(); for (int i = 0; i < tex.msSamp; i++) { sampleSelect.Items.Add(String.Format("Sample {0}", i)); } sampleSelect.SelectedIndex = Math.Min((int)tex.msSamp, (saveData.sample.sampleIndex == ~0U ? 0 : (int)saveData.sample.sampleIndex)); resolveSamples.Enabled = true; if (tex.format.compType == FormatComponentType.UInt || tex.format.compType == FormatComponentType.SInt || tex.format.compType == FormatComponentType.Depth || (tex.creationFlags & TextureCreationFlags.DSV) != 0) { resolveSamples.Enabled = false; } if (saveData.sample.sampleIndex == ~0U && resolveSamples.Enabled) { resolveSamples.Checked = true; } else { oneSample.Checked = true; } String[] cubeFaces = { "X+", "X-", "Y+", "Y-", "Z+", "Z-" }; UInt32 numSlices = Math.Max(tex.arraysize, tex.depth); sliceSelect.Items.Clear(); for (UInt32 i = 0; i < numSlices; i++) { if (tex.cubemap) { String name = cubeFaces[i % 6]; if (numSlices > 6) { name = string.Format("[{0}] {1}", (i / 6), cubeFaces[i % 6]); // Front 1, Back 2, 3, 4 etc for cube arrays } sliceSelect.Items.Add(name); } else { sliceSelect.Items.Add("Slice " + i); } } sliceSelect.SelectedIndex = (saveData.slice.sliceIndex >= 0 ? saveData.slice.sliceIndex : 0); gridWidth.Maximum = tex.depth * tex.arraysize * tex.msSamp; mipGroup.Visible = (tex.mips > 1); sampleGroup.Visible = (tex.msSamp > 1); sliceGroup.Visible = (tex.depth > 1 || tex.arraysize > 1 || tex.msSamp > 1); if (saveData.destType != FileType.DDS) { cubeCruciform.Enabled = (tex.cubemap && tex.arraysize == 6); if (!oneSlice.Checked && !cubeCruciform.Enabled) { mapSlicesToGrid.Checked = true; } } FileType selectedType = saveData.destType; fileFormat.SelectedIndex = 0; fileFormat.SelectedIndex = 1; fileFormat.SelectedIndex = (int)selectedType; if (saveData.alpha == AlphaMapping.Discard) { alphaMap.SelectedIndex = 0; } else { alphaMap.SelectedIndex = alphaMap.Items.Count - 1; } }
/// <summary> /// Creates a new file object with a provided UUID /// </summary> /// <param name="uuid">The UUID of the file object</param> /// <param name="videoUrl">The url of the video</param> /// <param name="audioUrl">The url of the audio</param> /// <param name="title">The the title of the file</param> /// <param name="sha1">The sha1 hash of the file</param> /// <param name="subtitles">The subtitles of this file</param> /// <param name="duration">The duration of the file</param> /// <param name="isFileAvailable">Whether the file is available</param> /// <param name="type">Whether it's stored offline or it's downloaded</param> public ServerFile(int uuid, string videoUrl, string audioUrl, string title, string sha1, SubtitleInfo[] subtitles, double duration, bool isFileAvailable, FileType type) : base(videoUrl, audioUrl, title, sha1, subtitles, duration, isFileAvailable, type) { UUID = uuid; }
private void HandleFile(string file) { // TODO: Add support for dropping folders // Analyze file and find out what type it is FileType type = AnalyzeFile(file); if (type == FileType.Uknown) { lblResult.Text = "I don't know what type this file is :("; return; } lblResult.Text = "The file is a " + type.ToString() + " file!" + "\r\n"; // Add the extension if it is missing string ext = GetExtension(type); FileInfo info = new FileInfo(file); if (info.Extension != ext) { string newFile = file + ext; File.Move(file, newFile); file = newFile; lblResult.Text += "Added proper extension to the file"; } // If raw Steam Workshop file (7z), extract GMA file switch (type) { case FileType.LZMA: // Extract the GMA file lblResult.Text = "Please extract this file with 7-zip and drop the extracted file here"; break; case FileType.GMAD: // Extract the addon folder lblResult.Text = "Extracting GMAD file..."; try { GMADTool.Extract(file, Path.GetDirectoryName(file)); } catch (Exception ex) { MessageBox.Show(ex.ToString(), "Error!"); lblResult.Text = "Failed to extract addon folder!"; break; } lblResult.Text = "Successfully extracted addon folder!"; break; default: // Nothing more to do with the rest of the types lblResult.Text += "Now just put this file in the correct directory in GMOD!"; break; } }
public SearchFile(string path, string fileName, FileType type) : this(new List <string>(), new FileInfo(FileUtil.JoinPath(path, fileName)), type) { }
public SearchFile(IList <string> containers, FileInfo file, FileType type) { Containers = containers; File = file; Type = type; }
public AffectedFile(string path, FileType fileType, string project) { Path = path; FileType = fileType; Project = project; }
unsafe void convert_filename(byte *srcname, byte *destname, ref FileAccessMode filemode, ref FileType filetype, ref bool wildflag) { byte *p, q; // Search for ':', p points to first character after ':' if ((p = CharFunctions.strchr(srcname, ':')) != null) { p++; } else { p = srcname; } // Convert char set of the remaining string -> destname q = destname; for (int i = 0; i < IEC.NAMEBUF_LENGTH && (*q++ = conv_from_64(*p++, true)) != 0; i++) { ; } // Look for mode parameters seperated by ',' p = destname; while ((p = CharFunctions.strchr(p, ',')) != null) { // Cut string after the first ',' *p++ = 0; switch ((Char)(*p)) { case 'p': filetype = FileType.FTYPE_PRG; break; case 's': filetype = FileType.FTYPE_SEQ; break; case 'r': filemode = FileAccessMode.FMODE_READ; break; case 'w': filemode = FileAccessMode.FMODE_WRITE; break; case 'a': filemode = FileAccessMode.FMODE_APPEND; break; } } // Search for wildcards wildflag = CharFunctions.strchr(destname, '?') != null || CharFunctions.strchr(destname, '*') != null; }
byte open_file(int channel, BytePtr filename) { using (BytePtr plainname = new BytePtr(256)) { FileAccessMode filemode = FileAccessMode.FMODE_READ; FileType filetype = FileType.FTYPE_PRG; bool wildflag = false; FileMode fmode = FileMode.Open; FileAccess faccess = FileAccess.Read; unsafe { convert_filename(filename, plainname, ref filemode, ref filetype, ref wildflag); } // Channel 0 is READ PRG, channel 1 is WRITE PRG if (channel == 0) { filemode = FileAccessMode.FMODE_READ; filetype = FileType.FTYPE_PRG; } else if (channel == 1) { filemode = FileAccessMode.FMODE_WRITE; filetype = FileType.FTYPE_PRG; } // Wildcards are only allowed on reading if (wildflag) { if (filemode != FileAccessMode.FMODE_READ) { set_error(ErrorCode1541.ERR_SYNTAX33); return((byte)C64StatusCode.ST_OK); } find_first_file(plainname); } // Select fopen() mode according to file mode switch (filemode) { case FileAccessMode.FMODE_READ: fmode = FileMode.Open; faccess = FileAccess.Read; break; case FileAccessMode.FMODE_WRITE: fmode = FileMode.OpenOrCreate; faccess = FileAccess.ReadWrite; break; case FileAccessMode.FMODE_APPEND: fmode = FileMode.Append; faccess = FileAccess.ReadWrite; break; } try { string fullpath = Path.Combine(dir_path, plainname.ToString()); file[channel] = new FileStream(fullpath, fmode, faccess); if (filemode == FileAccessMode.FMODE_READ) // Read and buffer first byte { read_char[channel] = (byte)file[channel].ReadByte(); } else { Environment.CurrentDirectory = Assembly.GetExecutingAssembly().Location; } } catch (DirectoryNotFoundException) { set_error(ErrorCode1541.ERR_NOTREADY); } catch (FileNotFoundException) { set_error(ErrorCode1541.ERR_FILENOTFOUND); } } return((byte)C64StatusCode.ST_OK); }
unsafe byte open_directory(int channel, byte *filename) { using (BytePtr buf = new BytePtr(Encoding.ASCII.GetBytes("\u0001\u0004\u0001\u0001\u0000\u0000\u0012\u0022 \u0022 00 2A\0")), pattern = new BytePtr(IEC.NAMEBUF_LENGTH)) { //char str[NAMEBUF_LENGTH]; byte * p, q; int i; FileAccessMode filemode = FileAccessMode.FMODE_READ; FileType filetype = FileType.FTYPE_PRG; bool wildflag = false; string str; // Special treatment for "$0" if (filename[0] == '0' && filename[1] == 0) { filename += 1; } // Convert filename ('$' already stripped), filemode/type are ignored convert_filename(filename, pattern, ref filemode, ref filetype, ref wildflag); DirectoryInfo dir = new DirectoryInfo(dir_path); if (!dir.Exists) { set_error(ErrorCode1541.ERR_NOTREADY); return((byte)C64StatusCode.ST_OK); } FileSystemInfo[] files = dir.GetFileSystemInfos(); file[channel] = new FileStream(Path.GetTempFileName(), FileMode.OpenOrCreate, FileAccess.ReadWrite); p = (byte *)buf.Pointer + 8; for (i = 0; i < 16 & i < dir_title.Length; i++) { *p++ = conv_to_64((byte)dir_title[i], false); } file[channel].Write(buf, 0, 32); IEnumerator fenum = files.GetEnumerator(); while (fenum.MoveNext() && (((FileSystemInfo)fenum.Current).Name == "." || ((FileSystemInfo)fenum.Current).Name == "..")) { ; } do { FileSystemInfo fsi = (FileSystemInfo)fenum.Current; if (match(pattern.ToString(), fsi.Name)) { // Clear line with spaces and terminate with null byte for (i = 0; i < buf.Length; i++) { buf[i] = (byte)' '; } buf[31] = 0; p = buf; *p++ = 0x01; // Dummy line link *p++ = 0x01; if (fsi is FileInfo) { FileInfo fi = (FileInfo)fsi; // Calculate size in blocks (254 bytes each) i = (int)((fi.Length + 254) / 254); *p++ = (byte)(i & 0xff); *p++ = (byte)((i >> 8) & 0xff); p++; if (i < 10) { p++; // Less than 10: add one space } if (i < 100) { p++; // Less than 100: add another space } str = fi.Name; // Convert and insert file name *p++ = (byte)'\"'; q = p; for (i = 0; i < 16 && i < str.Length; i++) { *q++ = conv_to_64((byte)str[i], true); } *q++ = (byte)'\"'; p += 18; } // File type if (fsi is DirectoryInfo) { *p++ = (byte)'D'; *p++ = (byte)'I'; *p++ = (byte)'R'; } else { *p++ = (byte)'P'; *p++ = (byte)'R'; *p++ = (byte)'G'; } // Write line file[channel].Write(buf, 0, 32); } } while (fenum.MoveNext()); } // Final line file[channel].Write(Encoding.ASCII.GetBytes("\u0001\u0001\0\0BLOCKS FREE. \0\0\0"), 0, 32); file[channel].Position = 0; read_char[channel] = (byte)file[channel].ReadByte(); return((byte)C64StatusCode.ST_OK); }
public SearchFile(FileInfo fileInfo, FileType type) : this(new List <string>(), fileInfo, type) { }
public GetFilteredDataQuery(string username, FileType fileType, DateTime startingFrom) { Username = username; FileType = fileType; StartingFrom = startingFrom; }
public static RvFile FromADir(RvFile dbDir, EScanLevel eScanLevel, ThreadWorker bgw, ref bool fileErrorAbort) { string fullDir = dbDir.FullName; DatStatus datStatus = dbDir.IsInToSort ? DatStatus.InToSort : DatStatus.NotInDat; RvFile fileDir = new RvFile(FileType.Dir); DirectoryInfo oDir = new DirectoryInfo(fullDir); DirectoryInfo[] oDirs = oDir.GetDirectories(); FileInfo[] oFiles = oDir.GetFiles(); // add all the subdirectories into scanDir foreach (DirectoryInfo dir in oDirs) { RvFile tDir = new RvFile(FileType.Dir) { Name = dir.Name, TimeStamp = dir.LastWriteTime }; tDir.SetStatus(datStatus, GotStatus.Got); fileDir.ChildAdd(tDir); } // add all the files into scanDir foreach (FileInfo oFile in oFiles) { string fName = oFile.Name; if (fName == "__RomVault.tmp") { File.Delete(oFile.FullName); continue; } string fExt = Path.GetExtension(oFile.Name); FileType ft = DBTypeGet.fromExtention(fExt); if (Settings.rvSettings.FilesOnly) { ft = FileType.File; } RvFile tFile = new RvFile(ft) { Name = oFile.Name, Size = (ulong)oFile.Length, TimeStamp = oFile.LastWriteTime }; tFile.FileStatusSet(FileStatus.SizeVerified); tFile.SetStatus(datStatus, GotStatus.Got); if (eScanLevel == EScanLevel.Level3) { FromAFile(tFile, fullDir, eScanLevel, bgw, ref fileErrorAbort); } fileDir.ChildAdd(tFile); /* * // if we find a zip file add it as zip files. * // else * if (ft == FileType.File) * { * // Scanning a file * // * // Level1 & 2 : (are the same for files) Fully checksum changed only files * // Here we are just getting the TimeStamp of the File, and later * // if the TimeStamp was not matched we will have to read the files CRC, MD5 & SHA1 * // * // Level3: Fully checksum everything * // Get everything about the file right here so * // read CRC, MD5 & SHA1 * * errorCode = CHD.CheckFile(oFile, out tFile.AltSHA1, out tFile.AltMD5, out tFile.CHDVersion); * * if (errorCode == 0) * { * if (tFile.AltSHA1 != null) * { * tFile.FileStatusSet(FileStatus.AltSHA1FromHeader); * } * if (tFile.AltMD5 != null) * { * tFile.FileStatusSet(FileStatus.AltMD5FromHeader); * } * * // if we are scanning at Level3 then we get all the info here * if (EScanLevel == EScanLevel.Level3) * { * FileResults(fullDir, tFile); * ChdManCheck(fullDir, tFile); * } * } * else if (errorCode == 32) * { * tFile.GotStatus = GotStatus.FileLocked; * _bgw.Report(new bgwShowError(fullDir, "File Locked")); * } * else * { * string filename = Path.Combine(fullDir, tFile.Name); * ReportError.Show("File: " + filename + " Error: " + new Win32Exception(errorCode).Message + ". Scan Aborted."); * _fileErrorAbort = true; * return fileDir; * } * } */ } return(fileDir); }
public GLFWFileHandle(string fileName, FileType type) : base(fileName, type) { }
public AllFileSelector(FileType filterType) { FilterType = filterType; }