814 lines
28 KiB
C#
814 lines
28 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
|
|
namespace ImaginationOverflow.UniversalDeepLinking.Editor.Xcode
|
|
{
|
|
internal class DeviceTypeRequirement
|
|
{
|
|
public static readonly string Key = "idiom";
|
|
public static readonly string Any = "universal";
|
|
public static readonly string iPhone = "iphone";
|
|
public static readonly string iPad = "ipad";
|
|
public static readonly string Mac = "mac";
|
|
public static readonly string iWatch = "watch";
|
|
}
|
|
|
|
internal class MemoryRequirement
|
|
{
|
|
public static readonly string Key = "memory";
|
|
public static readonly string Any = "";
|
|
public static readonly string Mem1GB = "1GB";
|
|
public static readonly string Mem2GB = "2GB";
|
|
}
|
|
|
|
internal class GraphicsRequirement
|
|
{
|
|
public static readonly string Key = "graphics-feature-set";
|
|
public static readonly string Any = "";
|
|
public static readonly string Metal1v2 = "metal1v2";
|
|
public static readonly string Metal2v2 = "metal2v2";
|
|
}
|
|
|
|
// only used for image sets
|
|
internal class SizeClassRequirement
|
|
{
|
|
public static readonly string HeightKey = "height-class";
|
|
public static readonly string WidthKey = "width-class";
|
|
public static readonly string Any = "";
|
|
public static readonly string Compact = "compact";
|
|
public static readonly string Regular = "regular";
|
|
}
|
|
|
|
// only used for image sets
|
|
internal class ScaleRequirement
|
|
{
|
|
public static readonly string Key = "scale";
|
|
public static readonly string Any = ""; // vector image
|
|
public static readonly string X1 = "1x";
|
|
public static readonly string X2 = "2x";
|
|
public static readonly string X3 = "3x";
|
|
}
|
|
|
|
internal class DeviceRequirement
|
|
{
|
|
internal Dictionary<string, string> values = new Dictionary<string, string>();
|
|
|
|
public DeviceRequirement AddDevice(string device)
|
|
{
|
|
AddCustom(DeviceTypeRequirement.Key, device);
|
|
return this;
|
|
}
|
|
|
|
public DeviceRequirement AddMemory(string memory)
|
|
{
|
|
AddCustom(MemoryRequirement.Key, memory);
|
|
return this;
|
|
}
|
|
|
|
public DeviceRequirement AddGraphics(string graphics)
|
|
{
|
|
AddCustom(GraphicsRequirement.Key, graphics);
|
|
return this;
|
|
}
|
|
|
|
public DeviceRequirement AddWidthClass(string sizeClass)
|
|
{
|
|
AddCustom(SizeClassRequirement.WidthKey, sizeClass);
|
|
return this;
|
|
}
|
|
|
|
public DeviceRequirement AddHeightClass(string sizeClass)
|
|
{
|
|
AddCustom(SizeClassRequirement.HeightKey, sizeClass);
|
|
return this;
|
|
}
|
|
|
|
public DeviceRequirement AddScale(string scale)
|
|
{
|
|
AddCustom(ScaleRequirement.Key, scale);
|
|
return this;
|
|
}
|
|
|
|
public DeviceRequirement AddCustom(string key, string value)
|
|
{
|
|
if (values.ContainsKey(key))
|
|
values.Remove(key);
|
|
values.Add(key, value);
|
|
return this;
|
|
}
|
|
|
|
public DeviceRequirement()
|
|
{
|
|
values.Add("idiom", DeviceTypeRequirement.Any);
|
|
}
|
|
}
|
|
|
|
internal class AssetCatalog
|
|
{
|
|
AssetFolder m_Root;
|
|
|
|
public string path { get { return m_Root.path; } }
|
|
public AssetFolder root { get { return m_Root; } }
|
|
|
|
public AssetCatalog(string path, string authorId)
|
|
{
|
|
if (Path.GetExtension(path) != ".xcassets")
|
|
throw new Exception("Asset catalogs must have xcassets extension");
|
|
m_Root = new AssetFolder(path, null, authorId);
|
|
}
|
|
|
|
AssetFolder OpenFolderForResource(string relativePath)
|
|
{
|
|
var pathItems = PBXPath.Split(relativePath).ToList();
|
|
|
|
// remove path filename
|
|
pathItems.RemoveAt(pathItems.Count - 1);
|
|
|
|
AssetFolder folder = root;
|
|
foreach (var pathItem in pathItems)
|
|
folder = folder.OpenFolder(pathItem);
|
|
return folder;
|
|
}
|
|
|
|
// Checks if a dataset at the given path exists and returns it if it does.
|
|
// Otherwise, creates a new dataset. Parent folders are created if needed.
|
|
// Note: the path is filesystem path, not logical asset name formed
|
|
// only from names of the folders that have "provides namespace" attribute.
|
|
// If you want to put certain resources in folders with namespace, first
|
|
// manually create the folders and then set the providesNamespace attribute.
|
|
// OpenNamespacedFolder may help to do this.
|
|
public AssetDataSet OpenDataSet(string relativePath)
|
|
{
|
|
var folder = OpenFolderForResource(relativePath);
|
|
return folder.OpenDataSet(Path.GetFileName(relativePath));
|
|
}
|
|
|
|
public AssetImageSet OpenImageSet(string relativePath)
|
|
{
|
|
var folder = OpenFolderForResource(relativePath);
|
|
return folder.OpenImageSet(Path.GetFileName(relativePath));
|
|
}
|
|
|
|
public AssetImageStack OpenImageStack(string relativePath)
|
|
{
|
|
var folder = OpenFolderForResource(relativePath);
|
|
return folder.OpenImageStack(Path.GetFileName(relativePath));
|
|
}
|
|
|
|
public AssetBrandAssetGroup OpenBrandAssetGroup(string relativePath)
|
|
{
|
|
var folder = OpenFolderForResource(relativePath);
|
|
return folder.OpenBrandAssetGroup(Path.GetFileName(relativePath));
|
|
}
|
|
|
|
// Checks if a folder with given path exists and returns it if it does.
|
|
// Otherwise, creates a new folder. Parent folders are created if needed.
|
|
public AssetFolder OpenFolder(string relativePath)
|
|
{
|
|
if (relativePath == null)
|
|
return root;
|
|
var pathItems = PBXPath.Split(relativePath);
|
|
if (pathItems.Length == 0)
|
|
return root;
|
|
AssetFolder folder = root;
|
|
foreach (var pathItem in pathItems)
|
|
folder = folder.OpenFolder(pathItem);
|
|
return folder;
|
|
}
|
|
|
|
// Creates a directory structure with "provides namespace" attribute.
|
|
// First, retrieves or creates the directory at relativeBasePath, creating parent
|
|
// directories if needed. Effectively calls OpenFolder(relativeBasePath).
|
|
// Then, relative to this directory, creates namespacePath directories with "provides
|
|
// namespace" attribute set. Fails if the attribute can't be set.
|
|
public AssetFolder OpenNamespacedFolder(string relativeBasePath, string namespacePath)
|
|
{
|
|
var folder = OpenFolder(relativeBasePath);
|
|
var pathItems = PBXPath.Split(namespacePath);
|
|
foreach (var pathItem in pathItems)
|
|
{
|
|
folder = folder.OpenFolder(pathItem);
|
|
folder.providesNamespace = true;
|
|
}
|
|
return folder;
|
|
}
|
|
|
|
public void Write()
|
|
{
|
|
Write(null);
|
|
}
|
|
|
|
public void Write(List<string> warnings)
|
|
{
|
|
m_Root.Write(warnings);
|
|
}
|
|
}
|
|
|
|
internal abstract class AssetCatalogItem
|
|
{
|
|
public readonly string name;
|
|
public readonly string authorId;
|
|
public string path { get { return m_Path; } }
|
|
|
|
protected Dictionary<string, string> m_Properties = new Dictionary<string, string>();
|
|
|
|
protected string m_Path;
|
|
|
|
public AssetCatalogItem(string name, string authorId)
|
|
{
|
|
if (name != null && name.Contains("/"))
|
|
throw new Exception("Asset catalog item must not have slashes in name");
|
|
this.name = name;
|
|
this.authorId = authorId;
|
|
}
|
|
|
|
protected JsonElementDict WriteInfoToJson(JsonDocument doc)
|
|
{
|
|
var info = doc.root.CreateDict("info");
|
|
info.SetInteger("version", 1);
|
|
info.SetString("author", authorId);
|
|
return info;
|
|
}
|
|
|
|
public abstract void Write(List<string> warnings);
|
|
}
|
|
|
|
internal class AssetFolder : AssetCatalogItem
|
|
{
|
|
List<AssetCatalogItem> m_Items = new List<AssetCatalogItem>();
|
|
bool m_ProvidesNamespace = false;
|
|
|
|
public bool providesNamespace
|
|
{
|
|
get { return m_ProvidesNamespace; }
|
|
set {
|
|
if (m_Items.Count > 0 && value != m_ProvidesNamespace)
|
|
throw new Exception("Asset folder namespace providing status can't be "+
|
|
"changed after items have been added");
|
|
m_ProvidesNamespace = value;
|
|
}
|
|
}
|
|
|
|
internal AssetFolder(string parentPath, string name, string authorId) : base(name, authorId)
|
|
{
|
|
if (name != null)
|
|
m_Path = Path.Combine(parentPath, name);
|
|
else
|
|
m_Path = parentPath;
|
|
}
|
|
|
|
// Checks if a folder with given name exists and returns it if it does.
|
|
// Otherwise, creates a new folder.
|
|
public AssetFolder OpenFolder(string name)
|
|
{
|
|
var item = GetChild(name);
|
|
if (item != null)
|
|
{
|
|
if (item is AssetFolder)
|
|
return item as AssetFolder;
|
|
throw new Exception("The given path is already occupied with an asset");
|
|
}
|
|
|
|
var folder = new AssetFolder(m_Path, name, authorId);
|
|
m_Items.Add(folder);
|
|
return folder;
|
|
}
|
|
|
|
T GetExistingItemWithType<T>(string name) where T : class
|
|
{
|
|
var item = GetChild(name);
|
|
if (item != null)
|
|
{
|
|
if (item is T)
|
|
return item as T;
|
|
throw new Exception("The given path is already occupied with an asset");
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Checks if a dataset with given name exists and returns it if it does.
|
|
// Otherwise, creates a new data set.
|
|
public AssetDataSet OpenDataSet(string name)
|
|
{
|
|
var item = GetExistingItemWithType<AssetDataSet>(name);
|
|
if (item != null)
|
|
return item;
|
|
|
|
var dataset = new AssetDataSet(m_Path, name, authorId);
|
|
m_Items.Add(dataset);
|
|
return dataset;
|
|
}
|
|
|
|
// Checks if an imageset with given name exists and returns it if it does.
|
|
// Otherwise, creates a new image set.
|
|
public AssetImageSet OpenImageSet(string name)
|
|
{
|
|
var item = GetExistingItemWithType<AssetImageSet>(name);
|
|
if (item != null)
|
|
return item;
|
|
|
|
var imageset = new AssetImageSet(m_Path, name, authorId);
|
|
m_Items.Add(imageset);
|
|
return imageset;
|
|
}
|
|
|
|
// Checks if a image stack with given name exists and returns it if it does.
|
|
// Otherwise, creates a new image stack.
|
|
public AssetImageStack OpenImageStack(string name)
|
|
{
|
|
var item = GetExistingItemWithType<AssetImageStack>(name);
|
|
if (item != null)
|
|
return item;
|
|
|
|
var imageStack = new AssetImageStack(m_Path, name, authorId);
|
|
m_Items.Add(imageStack);
|
|
return imageStack;
|
|
}
|
|
|
|
// Checks if a brand asset with given name exists and returns it if it does.
|
|
// Otherwise, creates a new brand asset.
|
|
public AssetBrandAssetGroup OpenBrandAssetGroup(string name)
|
|
{
|
|
var item = GetExistingItemWithType<AssetBrandAssetGroup>(name);
|
|
if (item != null)
|
|
return item;
|
|
|
|
var brandAsset = new AssetBrandAssetGroup(m_Path, name, authorId);
|
|
m_Items.Add(brandAsset);
|
|
return brandAsset;
|
|
}
|
|
|
|
// Returns the requested item or null if not found
|
|
public AssetCatalogItem GetChild(string name)
|
|
{
|
|
foreach (var item in m_Items)
|
|
{
|
|
if (item.name == name)
|
|
return item;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
void WriteJson()
|
|
{
|
|
if (!providesNamespace)
|
|
return; // json is optional when namespace is not provided
|
|
|
|
var doc = new JsonDocument();
|
|
|
|
WriteInfoToJson(doc);
|
|
|
|
var props = doc.root.CreateDict("properties");
|
|
props.SetBoolean("provides-namespace", providesNamespace);
|
|
doc.WriteToFile(Path.Combine(m_Path, "Contents.json"));
|
|
}
|
|
|
|
public override void Write(List<string> warnings)
|
|
{
|
|
if (Directory.Exists(m_Path))
|
|
Directory.Delete(m_Path, true); // ensure we start from clean state
|
|
Directory.CreateDirectory(m_Path);
|
|
WriteJson();
|
|
|
|
foreach (var item in m_Items)
|
|
item.Write(warnings);
|
|
}
|
|
}
|
|
|
|
abstract class AssetCatalogItemWithVariants : AssetCatalogItem
|
|
{
|
|
protected List<VariantData> m_Variants = new List<VariantData>();
|
|
protected List<string> m_ODRTags = new List<string>();
|
|
|
|
protected AssetCatalogItemWithVariants(string name, string authorId) :
|
|
base(name, authorId)
|
|
{
|
|
}
|
|
|
|
protected class VariantData
|
|
{
|
|
public DeviceRequirement requirement;
|
|
public string path;
|
|
|
|
public VariantData(DeviceRequirement requirement, string path)
|
|
{
|
|
this.requirement = requirement;
|
|
this.path = path;
|
|
}
|
|
}
|
|
|
|
public bool HasVariant(DeviceRequirement requirement)
|
|
{
|
|
foreach (var item in m_Variants)
|
|
{
|
|
if (item.requirement.values == requirement.values)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void AddOnDemandResourceTag(string tag)
|
|
{
|
|
if (!m_ODRTags.Contains(tag))
|
|
m_ODRTags.Add(tag);
|
|
}
|
|
|
|
protected void AddVariant(VariantData newItem)
|
|
{
|
|
foreach (var item in m_Variants)
|
|
{
|
|
if (item.requirement.values == newItem.requirement.values)
|
|
throw new Exception("The given requirement has been already added");
|
|
if (Path.GetFileName(item.path) == Path.GetFileName(path))
|
|
throw new Exception("Two items within the same set must not have the same file name");
|
|
}
|
|
if (Path.GetFileName(newItem.path) == "Contents.json")
|
|
throw new Exception("The file name must not be equal to Contents.json");
|
|
m_Variants.Add(newItem);
|
|
}
|
|
|
|
protected void WriteODRTagsToJson(JsonElementDict info)
|
|
{
|
|
if (m_ODRTags.Count > 0)
|
|
{
|
|
var tags = info.CreateArray("on-demand-resource-tags");
|
|
foreach (var tag in m_ODRTags)
|
|
tags.AddString(tag);
|
|
}
|
|
}
|
|
|
|
protected void WriteRequirementsToJson(JsonElementDict item, DeviceRequirement req)
|
|
{
|
|
foreach (var kv in req.values)
|
|
{
|
|
if (kv.Value != null && kv.Value != "")
|
|
item.SetString(kv.Key, kv.Value);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class AssetDataSet : AssetCatalogItemWithVariants
|
|
{
|
|
class DataSetVariant : VariantData
|
|
{
|
|
public string id;
|
|
|
|
public DataSetVariant(DeviceRequirement requirement, string path, string id) : base(requirement, path)
|
|
{
|
|
this.id = id;
|
|
}
|
|
}
|
|
|
|
internal AssetDataSet(string parentPath, string name, string authorId) : base(name, authorId)
|
|
{
|
|
m_Path = Path.Combine(parentPath, name + ".dataset");
|
|
}
|
|
|
|
// an exception is thrown is two equivalent requirements are added.
|
|
// The same asset dataset must not have paths with equivalent filenames.
|
|
// The identifier allows to identify which data variant is actually loaded (use
|
|
// the typeIdentifer property of the NSDataAsset that was created from the data set)
|
|
public void AddVariant(DeviceRequirement requirement, string path, string typeIdentifier)
|
|
{
|
|
foreach (DataSetVariant item in m_Variants)
|
|
{
|
|
if (item.id != null && typeIdentifier != null && item.id == typeIdentifier)
|
|
throw new Exception("Two items within the same dataset must not have the same id");
|
|
}
|
|
AddVariant(new DataSetVariant(requirement, path, typeIdentifier));
|
|
}
|
|
|
|
public override void Write(List<string> warnings)
|
|
{
|
|
Directory.CreateDirectory(m_Path);
|
|
|
|
var doc = new JsonDocument();
|
|
|
|
var info = WriteInfoToJson(doc);
|
|
WriteODRTagsToJson(info);
|
|
|
|
var data = doc.root.CreateArray("data");
|
|
|
|
foreach (DataSetVariant item in m_Variants)
|
|
{
|
|
var filename = Path.GetFileName(item.path);
|
|
if (!File.Exists(item.path))
|
|
{
|
|
if (warnings != null)
|
|
warnings.Add("File not found: " + item.path);
|
|
}
|
|
else
|
|
File.Copy(item.path, Path.Combine(m_Path, filename));
|
|
|
|
var docItem = data.AddDict();
|
|
docItem.SetString("filename", filename);
|
|
WriteRequirementsToJson(docItem, item.requirement);
|
|
if (item.id != null)
|
|
docItem.SetString("universal-type-identifier", item.id);
|
|
}
|
|
doc.WriteToFile(Path.Combine(m_Path, "Contents.json"));
|
|
}
|
|
}
|
|
|
|
internal class ImageAlignment
|
|
{
|
|
public int left = 0, right = 0, top = 0, bottom = 0;
|
|
}
|
|
|
|
internal class ImageResizing
|
|
{
|
|
public enum SlicingType
|
|
{
|
|
Horizontal,
|
|
Vertical,
|
|
HorizontalAndVertical
|
|
}
|
|
|
|
public enum ResizeMode
|
|
{
|
|
Stretch,
|
|
Tile
|
|
}
|
|
|
|
public SlicingType type = SlicingType.HorizontalAndVertical;
|
|
public int left = 0; // only valid for horizontal slicing
|
|
public int right = 0; // only valid for horizontal slicing
|
|
public int top = 0; // only valid for vertical slicing
|
|
public int bottom = 0; // only valid for vertical slicing
|
|
public ResizeMode centerResizeMode = ResizeMode.Stretch;
|
|
public int centerWidth = 0; // only valid for vertical slicing
|
|
public int centerHeight = 0; // only valid for horizontal slicing
|
|
}
|
|
|
|
// TODO: rendering intent property
|
|
internal class AssetImageSet : AssetCatalogItemWithVariants
|
|
{
|
|
internal AssetImageSet(string assetCatalogPath, string name, string authorId) : base(name, authorId)
|
|
{
|
|
m_Path = Path.Combine(assetCatalogPath, name + ".imageset");
|
|
}
|
|
|
|
class ImageSetVariant : VariantData
|
|
{
|
|
public ImageAlignment alignment = null;
|
|
public ImageResizing resizing = null;
|
|
|
|
public ImageSetVariant(DeviceRequirement requirement, string path) : base(requirement, path)
|
|
{
|
|
}
|
|
}
|
|
|
|
public void AddVariant(DeviceRequirement requirement, string path)
|
|
{
|
|
AddVariant(new ImageSetVariant(requirement, path));
|
|
}
|
|
|
|
public void AddVariant(DeviceRequirement requirement, string path, ImageAlignment alignment, ImageResizing resizing)
|
|
{
|
|
var imageset = new ImageSetVariant(requirement, path);
|
|
imageset.alignment = alignment;
|
|
imageset.resizing = resizing;
|
|
AddVariant(imageset);
|
|
}
|
|
|
|
void WriteAlignmentToJson(JsonElementDict item, ImageAlignment alignment)
|
|
{
|
|
var docAlignment = item.CreateDict("alignment-insets");
|
|
docAlignment.SetInteger("top", alignment.top);
|
|
docAlignment.SetInteger("bottom", alignment.bottom);
|
|
docAlignment.SetInteger("left", alignment.left);
|
|
docAlignment.SetInteger("right", alignment.right);
|
|
}
|
|
|
|
static string GetSlicingMode(ImageResizing.SlicingType mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case ImageResizing.SlicingType.Horizontal: return "3-part-horizontal";
|
|
case ImageResizing.SlicingType.Vertical: return "3-part-vertical";
|
|
case ImageResizing.SlicingType.HorizontalAndVertical: return "9-part";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
static string GetCenterResizeMode(ImageResizing.ResizeMode mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case ImageResizing.ResizeMode.Stretch: return "stretch";
|
|
case ImageResizing.ResizeMode.Tile: return "tile";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
void WriteResizingToJson(JsonElementDict item, ImageResizing resizing)
|
|
{
|
|
var docResizing = item.CreateDict("resizing");
|
|
docResizing.SetString("mode", GetSlicingMode(resizing.type));
|
|
|
|
var docCenter = docResizing.CreateDict("center");
|
|
docCenter.SetString("mode", GetCenterResizeMode(resizing.centerResizeMode));
|
|
docCenter.SetInteger("width", resizing.centerWidth);
|
|
docCenter.SetInteger("height", resizing.centerHeight);
|
|
|
|
var docInsets = docResizing.CreateDict("cap-insets");
|
|
docInsets.SetInteger("top", resizing.top);
|
|
docInsets.SetInteger("bottom", resizing.bottom);
|
|
docInsets.SetInteger("left", resizing.left);
|
|
docInsets.SetInteger("right", resizing.right);
|
|
}
|
|
|
|
public override void Write(List<string> warnings)
|
|
{
|
|
Directory.CreateDirectory(m_Path);
|
|
var doc = new JsonDocument();
|
|
var info = WriteInfoToJson(doc);
|
|
WriteODRTagsToJson(info);
|
|
|
|
var images = doc.root.CreateArray("images");
|
|
|
|
foreach (ImageSetVariant item in m_Variants)
|
|
{
|
|
var filename = Path.GetFileName(item.path);
|
|
if (!File.Exists(item.path))
|
|
{
|
|
if (warnings != null)
|
|
warnings.Add("File not found: " + item.path);
|
|
}
|
|
else
|
|
File.Copy(item.path, Path.Combine(m_Path, filename));
|
|
|
|
var docItem = images.AddDict();
|
|
docItem.SetString("filename", filename);
|
|
WriteRequirementsToJson(docItem, item.requirement);
|
|
if (item.alignment != null)
|
|
WriteAlignmentToJson(docItem, item.alignment);
|
|
if (item.resizing != null)
|
|
WriteResizingToJson(docItem, item.resizing);
|
|
}
|
|
doc.WriteToFile(Path.Combine(m_Path, "Contents.json"));
|
|
}
|
|
}
|
|
|
|
/* A stack layer may either contain an image set or reference another imageset
|
|
*/
|
|
class AssetImageStackLayer : AssetCatalogItem
|
|
{
|
|
internal AssetImageStackLayer(string assetCatalogPath, string name, string authorId) : base(name, authorId)
|
|
{
|
|
m_Path = Path.Combine(assetCatalogPath, name + ".imagestacklayer");
|
|
m_Imageset = new AssetImageSet(m_Path, "Content", authorId);
|
|
}
|
|
|
|
AssetImageSet m_Imageset = null;
|
|
string m_ReferencedName = null;
|
|
|
|
public void SetReference(string name)
|
|
{
|
|
m_Imageset = null;
|
|
m_ReferencedName = name;
|
|
}
|
|
|
|
public string ReferencedName()
|
|
{
|
|
return m_ReferencedName;
|
|
}
|
|
|
|
public AssetImageSet GetImageSet()
|
|
{
|
|
return m_Imageset;
|
|
}
|
|
|
|
public override void Write(List<string> warnings)
|
|
{
|
|
Directory.CreateDirectory(m_Path);
|
|
var doc = new JsonDocument();
|
|
WriteInfoToJson(doc);
|
|
|
|
if (m_ReferencedName != null)
|
|
{
|
|
var props = doc.root.CreateDict("properties");
|
|
var reference = props.CreateDict("content-reference");
|
|
reference.SetString("type", "image-set");
|
|
reference.SetString("name", m_ReferencedName);
|
|
reference.SetString("matching-style", "fully-qualified-name");
|
|
}
|
|
if (m_Imageset != null)
|
|
m_Imageset.Write(warnings);
|
|
|
|
doc.WriteToFile(Path.Combine(m_Path, "Contents.json"));
|
|
}
|
|
}
|
|
|
|
class AssetImageStack : AssetCatalogItem
|
|
{
|
|
List<AssetImageStackLayer> m_Layers = new List<AssetImageStackLayer>();
|
|
|
|
internal AssetImageStack(string assetCatalogPath, string name, string authorId) : base(name, authorId)
|
|
{
|
|
m_Path = Path.Combine(assetCatalogPath, name + ".imagestack");
|
|
}
|
|
|
|
public AssetImageStackLayer AddLayer(string name)
|
|
{
|
|
foreach (var layer in m_Layers)
|
|
{
|
|
if (layer.name == name)
|
|
throw new Exception("A layer with given name already exists");
|
|
}
|
|
var newLayer = new AssetImageStackLayer(m_Path, name, authorId);
|
|
m_Layers.Add(newLayer);
|
|
return newLayer;
|
|
}
|
|
|
|
public override void Write(List<string> warnings)
|
|
{
|
|
Directory.CreateDirectory(m_Path);
|
|
var doc = new JsonDocument();
|
|
WriteInfoToJson(doc);
|
|
|
|
var docLayers = doc.root.CreateArray("layers");
|
|
foreach (var layer in m_Layers)
|
|
{
|
|
layer.Write(warnings);
|
|
|
|
var docLayer = docLayers.AddDict();
|
|
docLayer.SetString("filename", Path.GetFileName(layer.path));
|
|
}
|
|
doc.WriteToFile(Path.Combine(m_Path, "Contents.json"));
|
|
}
|
|
}
|
|
|
|
class AssetBrandAssetGroup : AssetCatalogItem
|
|
{
|
|
class AssetBrandAssetItem
|
|
{
|
|
internal string idiom = null;
|
|
internal string role = null;
|
|
internal int width, height;
|
|
internal AssetCatalogItem item = null;
|
|
|
|
}
|
|
|
|
List<AssetBrandAssetItem> m_Items = new List<AssetBrandAssetItem>();
|
|
|
|
internal AssetBrandAssetGroup(string assetCatalogPath, string name, string authorId) : base(name, authorId)
|
|
{
|
|
m_Path = Path.Combine(assetCatalogPath, name + ".brandassets");
|
|
}
|
|
|
|
void AddItem(AssetCatalogItem item, string idiom, string role, int width, int height)
|
|
{
|
|
foreach (var it in m_Items)
|
|
{
|
|
if (it.item.name == item.name)
|
|
throw new Exception("An item with given name already exists");
|
|
}
|
|
var newItem = new AssetBrandAssetItem();
|
|
newItem.item = item;
|
|
newItem.idiom = idiom;
|
|
newItem.role = role;
|
|
newItem.width = width;
|
|
newItem.height = height;
|
|
m_Items.Add(newItem);
|
|
}
|
|
|
|
public AssetImageSet OpenImageSet(string name, string idiom, string role, int width, int height)
|
|
{
|
|
var newItem = new AssetImageSet(m_Path, name, authorId);
|
|
AddItem(newItem, idiom, role, width, height);
|
|
return newItem;
|
|
}
|
|
|
|
public AssetImageStack OpenImageStack(string name, string idiom, string role, int width, int height)
|
|
{
|
|
var newItem = new AssetImageStack(m_Path, name, authorId);
|
|
AddItem(newItem, idiom, role, width, height);
|
|
return newItem;
|
|
}
|
|
|
|
public override void Write(List<string> warnings)
|
|
{
|
|
Directory.CreateDirectory(m_Path);
|
|
var doc = new JsonDocument();
|
|
WriteInfoToJson(doc);
|
|
|
|
var docAssets = doc.root.CreateArray("assets");
|
|
foreach (var item in m_Items)
|
|
{
|
|
var docAsset = docAssets.AddDict();
|
|
docAsset.SetString("size", String.Format("{0}x{1}", item.width, item.height));
|
|
docAsset.SetString("idiom", item.idiom);
|
|
docAsset.SetString("role", item.role);
|
|
docAsset.SetString("filename", Path.GetFileName(item.item.path));
|
|
|
|
item.item.Write(warnings);
|
|
}
|
|
doc.WriteToFile(Path.Combine(m_Path, "Contents.json"));
|
|
}
|
|
}
|
|
|
|
} // namespace UnityModule.iOS.Xcode
|