public CompressPrxVirtualFileSystem(IVirtualFileSystem vfs) : base(vfs)
{
if (prxModAttribute == null)
{
initPrxMappings();
}
}
public FileSystem(IVirtualFileSystem vfs)
{
this.vfs = vfs;
var localDataPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
vfs.MountDirectory("~", Path.Join(localDataPath, APPLICATION_FOLDER, TryGetProfile()));
}
public ConfigExportForm(IVirtualFileSystem fs)
{
InitializeComponent();
m_fs = fs;
configSelectionFrame1.FileSystem = m_fs;
addonSelectFrame1.Reload(false);
}
public ConfigSendForm(IVirtualFileSystem fs)
{
InitializeComponent();
m_fs = fs;
configSelectionFrame1.FileSystem = m_fs;
}
public virtual IVirtualFileSystem getVirtualFileSystem(string absoluteFileName, StringBuilder localFileName)
{
int colon = absoluteFileName.IndexOf(':');
if (colon < 0)
{
return(null);
}
string name = absoluteFileName.Substring(0, colon);
name = name.ToLower();
if (localFileName != null)
{
localFileName.Length = 0;
localFileName.Append(absoluteFileName.Substring(colon + 1));
normalizeLocalFileName(localFileName);
if ("ms0".Equals(name) && localFileName.ToString().StartsWith(PSP_GAME, StringComparison.Ordinal))
{
if (xmbVfs == null)
{
xmbVfs = new XmbVirtualFileSystem(new LocalVirtualFileSystem(Settings.Instance.getDirectoryMapping("ms0"), true));
}
return(xmbVfs);
}
}
return(virtualFileSystems[name]);
}
public static ConfigNode LoadConfig(IVirtualFileSystem fs)
{
var root = new ConfigRootTreeNode(fs.Root);
LoadItems(fs.Root, root);
return(root);
}
public static bool Run(IVirtualFileSystem fs)
{
using (var win = new ConfigImportForm(fs))
{
return(win.ShowDialogEx() == DialogResult.OK);
}
}
public Fat12VirtualFile(string deviceName, IVirtualFileSystem vfs, int totalSectors) : base(deviceName, vfs, totalSectors)
{
// FAT12 has no FS Info sector
FsInfoSectorNumber = -1;
// The FAT is directly after the boot sector, no reserved sectors present
// setFatSectorNumber(FatBuilder.bootSectorNumber + 1);
}
public VirtualFileSystemTemplateRenderer(IVirtualFileSystem FileSystem, bool OutputGeneratedCode)
{
this.TemplateFactory = new TemplateFactory(
new TemplateProviderVirtualFileSystem(FileSystem),
Encoding: Encoding.UTF8,
OutputGeneratedCode: OutputGeneratedCode
);
}
public SftpHandle(ISftpSubsystem sftp, string name, IVirtualFileSystem fileSystem, ILogger logger)
{
this.sftp = sftp;
this.fileSystem = fileSystem;
this.logger = logger;
Name = name;
}
public EntityViewModel(IWindowsManager windowsManager, IVirtualFileSystem fs, VirtualDirectory directory, bool isParentDirectory)
: base(windowsManager)
{
_entityInfo = isParentDirectory
? new ParentDirectoryInfo(directory, fs)
: new VirtualDirectoryInfo(directory, fs);
EditableName = Name;
}
public ContactPage(IBundleService bundleService
, IIconResourceService iconResourceService
, IPageService pageService
, IVirtualFileSystem virtualFileSystem
, IDbSessionFactory sessionFactory)
: base(bundleService, iconResourceService, pageService, virtualFileSystem)
{
m_sessionFactory = sessionFactory;
}
public Task StartLongOperation(IVirtualFileSystem fileSystem, Func <ILongOperationViewModel, Task> callback)
{
var retv = _longOperationsViewModelFactory.Create(fileSystem, callback);
retv.Initialize();
_longOperations.Add(retv);
HasOperationsChanged?.Invoke(this, EventArgs.Empty);
return(retv.Task);
}
public virtual IVirtualFile getVirtualFile(IVirtualFileSystem vfs)
{
if (!vFileOpen)
{
vFile = vfs.ioOpen(FullFileName, PSP_O_RDWR, 0);
vFileOpen = true;
}
return(vFile);
}
protected override void CopyContentTo(IVirtualFileSystem dstfs, bool isroot, List <Tuple <string, string> > repls)
{
base.CopyContentTo(dstfs, isroot, repls);
foreach (var sub in SubVirtFiles)
{
string path = GetNewName(sub, repls);
sub.CopyPathTo(dstfs, path);
}
}
public ConfigImportForm(IVirtualFileSystem fs)
{
InitializeComponent();
m_srcFs = fs;
m_dstFs = AppDataDiskFileSystem.Instance;
configSelectionFrame1.FileSystem = fs;
DetectConflicts(configSelectionFrame1.Root);
RenameAll();
configSelectionFrame1.CheckAll();
}
public MailPage(IBundleService bundleService
, IIconResourceService iconResourceService
, IPageService pageService
, IVirtualFileSystem virtualFileSystem
, IDbSessionFactory sessionFactory)
: base(bundleService, iconResourceService, pageService, virtualFileSystem)
{
m_sessionFactory = sessionFactory;
Initialize();
}
/// <summary>
/// Check if a file exists
/// </summary>
public static bool FileExists(this IVirtualFileSystem vfs, String fileName)
{
try
{
return(vfs.GetFileInfo(fileName).Exists);
}
catch
{
return(false);
}
}
/// <summary>
/// Check if a directory exists
/// </summary>
public static bool DirectoryExists(this IVirtualFileSystem vfs, String directoryName)
{
try
{
return(vfs.GetDirectoryInfo(directoryName).Exists);
}
catch
{
return(false);
}
}
public TreePage(IBundleService bundleService
, IIconResourceService iconResourceService
, IPageService pageService
, IVirtualFileSystem virtualFileSystem)
{
m_BundleService = bundleService;
m_IconResourceService = iconResourceService;
m_ToolStripFactory = pageService.PageLayoutProvider.ToolbarFactory;
m_VirtualFileSystem = virtualFileSystem;
}
public static IVirtualPath GetPath(this IVirtualFileSystem fs, IVirtualPath path)
{
if (path is IVirtualFile)
{
return(fs.GetFile(path.FullPath));
}
if (path is IVirtualFolder)
{
return(fs.GetFolder(path.FullPath));
}
return(null);
}
public NewFolderCommand(ISelectionService selectionService
, IDbSessionFactory sessionFactory
, IExtensionRegistry extensionRegistry
, IHierarchyDecoratorService contentService
, IIconResourceService iconResourceService
, IVirtualFileSystem virtualFs)
: base(selectionService, sessionFactory, "InsertFolder")
{
_extensionRegistry = extensionRegistry;
_contentService = contentService;
_iconResourceService = iconResourceService;
_virtualFs = virtualFs;
}
public SftpSubsystem(Channel channel, IVirtualFileSystemFactory fileSystemFactory, ILogger logger)
{
this.channel = channel;
this.logger = logger;
packetTypes.Add(SftpPacketType.SSH_FXP_INIT, typeof(InitPacket));
packetTypes.Add(SftpPacketType.SSH_FXP_REALPATH, typeof(RealPathPacket));
packetTypes.Add(SftpPacketType.SSH_FXP_OPENDIR, typeof(OpenDirPacket));
packetTypes.Add(SftpPacketType.SSH_FXP_READDIR, typeof(ReadDirPacket));
packetTypes.Add(SftpPacketType.SSH_FXP_CLOSE, typeof(ClosePacket));
fileSystem = fileSystemFactory.Create();
}
public MessageExplorer(IBundleService bundleService
, IIconResourceService iconResourceService
, IDbSessionFactory sessionFactory
, IPartRegistry partRegistry
, IPageService pageService
, IVirtualFileSystem virtualFileSystem)
{
m_BundleService = bundleService;
m_IconResourceService = iconResourceService;
m_sessionFactory = sessionFactory;
m_PartRegistry = partRegistry;
m_PageService = pageService;
m_ToolStripFactory = pageService.PageLayoutProvider.ToolbarFactory;
m_VirtualFileSystem = virtualFileSystem;
}
public static void CopyPathTo(this IVirtualPath path, IVirtualFileSystem dstfs, string newname)
{
if (path is IVirtualFile)
{
var dstf = dstfs.GetFile(newname);
((IVirtualFile)path).CopyFileTo(dstf, CopyFileMode.Copy);
}
else
{
var dstf = dstfs.GetFolder(newname);
if (!dstf.Exists())
{
dstf.Create();
}
}
}
public static string GetPath(string path, IVirtualFileSystem virtualFs)
{
if (System.IO.Path.IsPathRooted(path))
{
return(System.IO.File.Exists(path) ? path : null);
}
path = virtualFs.GetBinPath(path);
if (System.IO.File.Exists(path))
{
return(System.IO.Path.GetFullPath(path));
}
return(null);
}
public void CopyCheckedTo(IVirtualFileSystem dstfs, bool isroot, List <Tuple <string, string> > repls)
{
if (!m_selected)
{
return;
}
if (!isroot)
{
string path = GetNewName(VirtualPath, repls);
VirtualPath.CopyPathTo(dstfs, path);
}
foreach (var child in Children)
{
child.CopyCheckedTo(dstfs, false, repls);
}
CopyContentTo(dstfs, isroot, repls);
}
public XmbVirtualFileSystem(IVirtualFileSystem vfs)
{
this.vfs = vfs;
umdPaths = getUmdPaths(true);
File isoDir = new File(ISO_DIR);
if (isoDir.Directory)
{
umdPaths = add(umdPaths, isoDir);
}
umdVfs = new Dictionary <string, IVirtualFileSystem>();
for (int i = 0; i < umdPaths.Length; i++)
{
IVirtualFileSystem localVfs = new LocalVirtualFileSystem(umdPaths[i].AbsolutePath + "/", false);
umdVfs[umdPaths[i].AbsolutePath] = localVfs;
}
umdFiles = new LinkedList <XmbVirtualFileSystem.VirtualPBP>();
}
public override IVirtualFile ioOpen(string fileName, int flags, int mode)
{
StringBuilder restFileName = new StringBuilder();
VirtualPBP virtualPBP = getVirtualPBP(fileName, restFileName);
if (virtualPBP != null && isVirtualFile(restFileName.ToString()))
{
string umdFileName = virtualPBP.umdFile;
File umdFile = new File(umdFileName);
// Is it a directory containing an EBOOT.PBP file?
if (umdFile.Directory)
{
StringBuilder localFileName = new StringBuilder();
IVirtualFileSystem vfs = getUmdVfs(umdFileName, localFileName);
if (vfs != null)
{
// Open the EBOOT.PBP file inside the directory
return(vfs.ioOpen(localFileName.ToString() + "/" + restFileName.ToString(), flags, mode));
}
}
// Map the ISO/CSO file into a virtual PBP file
if (virtualPBP.vFile == null)
{
virtualPBP.vFile = new XmbIsoVirtualFile(umdFileName);
}
if (virtualPBP.vFile.Length() > 0)
{
return(virtualPBP.vFile);
}
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("XmbVirtualFileSystem.ioOpen could not open UMD file '{0}'", umdFileName));
}
}
return(vfs.ioOpen(fileName, flags, mode));
}
public static string FindArtworkUri(DirectoryInfo aInfo, IVirtualFileSystem aVirtualFileSystem)
{
string[] kImageSearchExt = { ".jpg", ".png" };
string[] kImageSearchName = { "folder", "cover" };
try
{
foreach (string s in kImageSearchExt)
{
foreach (string n in kImageSearchName)
{
string filename = Path.Combine(aInfo.FullName, string.Format("{0}{1}", n, s));
if (System.IO.File.Exists(filename))
{
return(aVirtualFileSystem.Uri(filename));
}
}
}
}
catch { } //ignore path errors
return(null);
}
public ContainerFolder(container aContainer, IVirtualFileSystem aVirtualFileSystem)
{
iVirtualFileSystem = aVirtualFileSystem;
iMetadata = aContainer;
iFileSystemWatcher = new FileSystemWatcher();
iFileSystemWatcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName;
iFileSystemWatcher.Filter = "*.*";
iFileSystemWatcher.Changed += Changed;
iFileSystemWatcher.Created += Changed;
iFileSystemWatcher.Deleted += Changed;
iFileSystemWatcher.Renamed += Renamed;
iFileSystemWatcher.Error += Error;
iPath = new DirectoryInfo(iMetadata.Id);
try
{
iFileSystemWatcher.Path = iPath.FullName;
iFileSystemWatcher.EnableRaisingEvents = true;
}
catch (Exception) { }
}
public TemplateProviderVirtualFileSystem(IVirtualFileSystem VirtualFileSystem)
{
this.VirtualFileSystem = VirtualFileSystem;
}
async static public Task<VirtualFileSystemTemplateRenderer> CreateFromVirtualFileSystemAsync(IVirtualFileSystem FileSystem, bool OutputGeneratedCode = false)
{
await Task.Yield();
return new VirtualFileSystemTemplateRenderer(FileSystem, OutputGeneratedCode);
}
public HttpStaticFileServer(IVirtualFileSystem VirtualFileSystem, bool Cache = true)
{
this.VirtualFileSystem = VirtualFileSystem;
this.Cache.Enabled = Cache;
this.VirtualFileSystem.OnEvent += VirtualFileSystem_OnEvent;
}
/// <summary>
/// Define the current VFS
/// </summary>
public static void SetCurrent(IVirtualFileSystem vfs)
{
_Current = vfs;
}
