ICreateDocumentTask IDocumentService.CreateCreateDocumentTask(Uri uri, Guid guid, string persistentInfo)
{
return(CreateDocumentTask.FromFactory(() =>
{
if (uri.Scheme == Uri.UriSchemeFile)
{
var path = uri.LocalPath;
if (path == null || !UnifiedFile.Exists(path))
{
return null;
}
var fileViewer = this.GetFileViewerService(UnifiedPath.GetExtension(path));
if (fileViewer == null)
{
return null;
}
return this.CreateDocument(guid, uri, fileViewer);
}
else if (uri.Scheme == StreamScheme)
{
var streamId = uri.Host + uri.PathAndQuery;
StreamInfo streamInfo;
if (!_registeredStreams.TryGetValue(streamId, out streamInfo))
{
this.LogWarning("no registered stream with ID '{0}' found", streamId);
return null;
}
_registeredStreams.Remove(streamId);
if (!streamInfo.StreamReference.IsAlive)
{
this.LogWarning("the registered stream with ID '{0}' is no more alive", streamId);
return null;
}
var fileViewer = this.GetFileViewerServiceOrNotifyMissing(streamInfo.FileType);
if (fileViewer == null)
{
return null;
}
IFeature[] features;
var viewer = fileViewer.CreateViewer(streamInfo.StreamReference.Target, out features);
var document = DocumentInfo.CreateTemporary(streamInfo.OwnerRepository.ID, streamInfo.Title, uri, viewer, features);
document.Description = streamInfo.Description;
return document;
}
else
{
throw new NotSupportedException();
}
}));
}
private void DownloadRecursive(IVersionedRepository repository, UnifiedPath source, string target, DateTime?upToDateTime = null)
{
var files = repository.GetFiles(source);
foreach (var file in files)
{
var history = repository.GetFileHistory(file.Path);
var revision = history
.Where(r => r.Created.HasValue && (upToDateTime == null || r.Created.Value <= upToDateTime.Value))
.OrderByDescending(r => r.Created.Value)
.FirstOrDefault();
if (revision != null)
{
Directory.CreateDirectory(target);
repository.EndTransfer(repository.BeginDownloadVersionTransfer(revision.RevisionPath, target, true, null));
// TODO: Investigate
//File.SetLastWriteTime(Path.Combine(target, file.Name), revision.Created.Value);
}
}
var folders = repository.GetFolders(source);
foreach (var folder in folders)
{
string targetFolder = Path.Combine(target, folder.Name);
DownloadRecursive(repository, folder.Path, targetFolder, upToDateTime);
}
}
public static ImageSource Load(string packagePath, string localPath, double dpi = 96)
{
return(s_packageImageCache.GetOrCreate(UnifiedPath.Combine(packagePath, localPath),
() =>
{
try
{
using (var stream = new PackageStream(packagePath, localPath))
{
BitmapSource image = BitmapImageEx.FromStream(stream);
if (image.DpiX != dpi || image.DpiY != dpi)
{
image = image.ChangeDPI(dpi);
}
image.Freeze();
return (ImageSource)image;
}
}
catch (Exception)
{
return null;
}
}));
}
public static ImageSource Load(string path, double dpi = 96)
{
string packagePath, localPath;
UnifiedPath.ParsePath(path, out packagePath, out localPath);
return(PackageImage.Load(packagePath, localPath, dpi));
}
public PackageFolderVM(ExplorerTreeNodeVM parent, string packageFile, string localPath)
: base(parent, UnifiedPath.Combine(packageFile, localPath), UnifiedPath.GetFileName(localPath))
{
this.LocalPath = localPath;
this.PackagePath = packageFile;
_childEntries = new List <ZipEntry>();
}
private List <ExtractFileInfo> BuildExtractFileListFromSpecifiedFileList()
{
_progressController.SetIndeterminate();
var distinctFileList = new Dictionary <string, ExtractFileInfo>();
foreach (var file in this.FileList)
{
var fileInfo = distinctFileList.GetOrCreate(file, () =>
{
var info = new ExtractFileInfo();
string packagePath, localPath;
UnifiedPath.ParsePath(file, out packagePath, out localPath);
info.PackagePath = packagePath;
info.DestinationRoot = this.GetDestinationRoot(localPath);
info.RelativePath = localPath;
return(info);
});
}
var packageGroups = distinctFileList.Values.Aggregate(new Dictionary <string, List <ExtractFileInfo> >(),
(dict, item) =>
{
var list = dict.GetOrCreate(item.PackagePath.ToLower(),
() => new List <ExtractFileInfo>());
list.Add(item);
return(dict);
});
var nonExistedFiles = new List <ExtractFileInfo>();
foreach (var item in packageGroups)
{
var zipFile = new ZipFile(File.OpenRead(item.Key));
foreach (var info in item.Value)
{
var entryIndex = zipFile.FindEntry(info.RelativePath, true);
if (entryIndex == -1)
{
nonExistedFiles.Add(info);
}
else
{
info.Entry = zipFile[entryIndex];
info.ZipFile = zipFile;
}
}
}
// todo: handle non exisiting files
return(packageGroups.Values.SelectMany(i => i).ToList());
}
private void PopulateTree(IRepository repo, UnifiedPath path, TreeNode rootNode)
{
FolderInfo[] folders = repo.GetFolders(path);
foreach (var folder in folders)
{
var newNode = new TreeNode(folder.Name)
{
Tag = folder.Path
};
PopulateTree(repo, folder.Path, newNode);
rootNode.Nodes.Add(newNode);
}
}
private DocumentInfo CreateDocument(Guid guid, Uri uri, IFileViewerService fileViewerService)
{
IFeature[] features;
var viewer = fileViewerService.CreateViewer(uri.LocalPath, out features);
var document = new DocumentInfo(guid: guid,
repositoryId: this.RepositoryManager.FindOwner(uri.LocalPath).ID,
uri: uri,
title: UnifiedPath.GetFileName(uri.LocalPath),
content: viewer,
features: features)
{
Description = uri.LocalPath,
IconSource = this.RepositoryManager.FindOwner(uri.LocalPath).GetMarker()
};
return(document);
}
public XmlViewerVM(XmlViewerService service, CommandBindingCollection commandBindings, string path)
: this(service, commandBindings, new BigworldXmlReader(path))
{
if (!UnifiedPath.IsInPackage(path))
{
this.SavePath = path;
_defaultSaveAsPath = path;
}
else
{
var gameClient = RepositoryManager.Instance.FindOwner(path);
if (gameClient != null)
{
_defaultSaveAsPath = gameClient.GetCorrespondedModPath(path);
}
}
}
public string GetCorrespondedModPath(string unifiedPath)
{
string packagePath, localPath;
UnifiedPath.ParsePath(unifiedPath, out packagePath, out localPath);
if (string.IsNullOrEmpty(packagePath))
{
throw new ArgumentException("this is not a package path", nameof(unifiedPath));
}
packagePath = PathEx.NormalizeDirectorySeparators(packagePath);
var pathDirectory = Path.GetDirectoryName(packagePath);
var resPackagePath = Path.Combine("res", "packages");
if (!pathDirectory.ToLower().EndsWith(resPackagePath))
{
throw new ArgumentException("package is located in an invalid localtion", nameof(unifiedPath));
}
return(Path.Combine(this.ModDirectory, localPath));
}
public string GetUnifiedPath(string filename)
{
return(UnifiedPath.Combine(this.GetPackagePath(filename), filename));
}
public static string Decode(string path, out EncodeType encodeType, bool wellFormatted = false)
{
var packedFileName = UnifiedPath.GetFileName(path).ToLower();
using (var stream = UnifiedFile.OpenRead(path))
{
using (BinaryReader reader = new BinaryReader(stream))
{
Int32 header = reader.ReadInt32();
if (header == PackedSection.PackedHeader)
{
reader.ReadSByte();
var document = new XmlDocument();
var packedSection = new PackedSection();
var dictionary = packedSection.readDictionary(reader);
var xmlroot = document.CreateNode(XmlNodeType.Element, packedFileName, "");
packedSection.readElement(reader, xmlroot, document, dictionary);
document.AppendChild(xmlroot);
encodeType = EncodeType.Packed;
if (wellFormatted)
{
return(XmlDecoder.FormatXml(document.OuterXml));
}
else
{
return(document.OuterXml);
}
}
else if (header == BinaryHeader)
{
stream.Seek(0, SeekOrigin.Begin);
var document = new XmlDocument();
var xmlPrimitives = document.CreateNode(XmlNodeType.Element, "primitives", "");
var primitiveReader = new PrimitiveReader();
primitiveReader.ReadPrimitives(reader, xmlPrimitives, document);
document.AppendChild(xmlPrimitives);
encodeType = EncodeType.Binary;
if (wellFormatted)
{
return(XmlDecoder.FormatXml(document.OuterXml));
}
else
{
return(document.OuterXml);
}
}
else
{
var extension = UnifiedPath.GetExtension(path);
if (extension == ".xml" || extension == ".def" || extension == ".visual" || extension == ".chunk" || extension == ".settings" || extension == ".model")
{
encodeType = EncodeType.Plain;
return(File.ReadAllText(path));
}
else
{
throw new NotSupportedException();
}
}
}
}
}
public PackageFileVM(ExplorerTreeNodeVM parent, string packageFile, string localPath, string name)
: base(parent, UnifiedPath.Combine(packageFile, localPath), name)
{
this.LocalPath = localPath;
this.PackagePath = packageFile;
}
public string GetNationalTechTreeLayoutFile(string nationKey)
{
return(UnifiedPath.Combine(this.GuiPackageFile, string.Format(@"{0}\{1}{2}", c_techTreeLayoutRelativePath, nationKey, c_techTreeLayoutFilePostfix)));
}
public FileVM(ExplorerTreeNodeVM parent, string path)
: this(parent, path, UnifiedPath.GetFileName(path))
{
}
private string GetRelativePath(IPathHelper pathHelper, UnifiedPath root, UnifiedPath path)
{
int rootParts = pathHelper.Split(root).Length;
return(string.Join(pathHelper.PathSeparator.ToString(), pathHelper.Split(path).Skip(rootParts)));
}
private IEnumerable <UnifiedPath> GetFilesRecursively(IRepository repository, UnifiedPath root)
{
foreach (var file in repository.GetFiles(root))
{
yield return(file.Path);
}
foreach (var folder in repository.GetFolders(root))
{
foreach (var path in GetFilesRecursively(repository, folder.Path))
{
yield return(path);
}
}
}
