protected void RecursivelyConfigureViews(ViewNode parentNode, ViewRenderServiceOptions options)
{
var children = NodesProcessed.Where(s => s.ParentView == parentNode);
foreach (var child in children)
{
if (child.View == null)
{
Console.WriteLine("Node {0} has no view to process... skipping", child.Node);
continue;
}
var converter = GetConverter(child.Node);
if (converter != null)
{
if (RendersAddChild(child, parentNode, this))
{
PropertySetter.Configure(PropertyNames.AddChild, child, parentNode, converter, this);
}
if (RendersSize(child, parentNode, this))
{
PropertySetter.Configure(PropertyNames.Frame, child, parentNode, converter, this);
}
if (RendersConstraints(child, parentNode, this))
{
PropertySetter.Configure(PropertyNames.Constraints, child, parentNode, converter, this);
}
}
RecursivelyConfigureViews(child, options);
}
}
public void Start(string figmaName, IView container, ViewRenderServiceOptions options = null)
{
if (options == null)
{
options = new ViewRenderServiceOptions();
}
Console.WriteLine("[FigmaViewRenderer] Starting process..");
Console.WriteLine($"Reading {figmaName} from resources..");
this.container = container;
try
{
if (options.LoadFileProvider)
{
nodeProvider.Load(figmaName ?? nodeProvider.File);
}
//we generate all the processed nodes
Refresh(options);
//we render only if there is a canvas and GenerateViews is enabled
var canvas = NodesProcessed.FirstOrDefault(s => s.Node is FigmaCanvas);
if (canvas != null && options.ConfigureViews)
{
RecursivelyConfigureViews(canvas, options);
}
}
catch (Exception ex)
{
Console.WriteLine($"Error reading resource");
Console.WriteLine(ex);
}
}
public async Task StartAsync(string figmaName, IView container, ViewRenderServiceOptions options = null)
{
if (options == null)
{
options = new ViewRenderServiceOptions();
}
LoggingService.LogInfo("[FigmaViewRenderer] Starting process..");
LoggingService.LogInfo($"Reading {figmaName} from resources..");
this.container = container;
try
{
if (options.LoadFileProvider)
{
await nodeProvider.LoadAsync(figmaName ?? nodeProvider.File);
}
//we generate all the processed nodes
Refresh(options);
//we render only if there is a canvas and GenerateViews is enabled
var canvas = NodesProcessed.FirstOrDefault(s => s.Node is FigmaCanvas);
if (canvas != null && options.ConfigureViews)
{
RecursivelyConfigureViews(canvas, options);
}
}
catch (Exception ex)
{
LoggingService.LogError("[FIGMA] Error reading resource", ex);
}
}
protected virtual bool SkipsNode(FigmaNode currentNode, ViewNode parent, ViewRenderServiceOptions options)
{
if (options != null && options.ToIgnore != null && options.ToIgnore.Contains(currentNode))
{
return(true);
}
return(false);
}
public T RenderByPath <T> (ViewRenderServiceOptions options, IView parent, params string[] path) where T : IView
{
FigmaNode node = nodeProvider.FindByPath(path);
if (node == null)
{
return(default(T));
}
return((T)RenderByNode(node, parent, options));
}
public T RenderByName <T> (string figmaName, IView parent, ViewRenderServiceOptions options = null) where T : IView
{
var node = FindNodeByName(figmaName);
if (node == null)
{
return(default(T));
}
return((T)RenderByNode(node, parent, options));
}
public void RenderInWindow(IWindow mainWindow, string nodeName, ViewRenderServiceOptions options = null)
{
var node = nodeProvider.Nodes
.FirstOrDefault(s => s.name == nodeName || (s.TryGetNodeCustomName(out string name) && name == nodeName));
if (node == null)
{
throw new Exception($"nodename {nodeName} not found");
}
RenderInWindow(mainWindow, node, options);
}
public void ProcessFromNode(FigmaNode figmaNode, IView View, ViewRenderServiceOptions options)
{
try
{
var processedParentView = new ViewNode(figmaNode, View);
NodesProcessed.Add(processedParentView);
//in canvas we want calculate the bounds size
if (figmaNode is FigmaCanvas canvas)
{
canvas.absoluteBoundingBox = canvas.GetCurrentBounds();
}
if (figmaNode is FigmaCanvas || !options.GenerateMainView)
{
if (figmaNode is IFigmaNodeContainer container)
{
foreach (var item in container.children)
{
GenerateViewsRecursively(item, processedParentView, options);
}
}
}
else
{
GenerateViewsRecursively(figmaNode, processedParentView, options);
}
//Images
if (options.AreImageProcessed)
{
foreach (var processedNode in NodesProcessed)
{
if (NodeProvider.RendersAsImage(processedNode.Node))
{
ImageVectors.Add(processedNode);
}
}
nodeProvider.ImageLinksProcessed += FileProvider_ImageLinksProcessed;
nodeProvider.OnStartImageLinkProcessing(ImageVectors);
}
Console.WriteLine("View generation finished.");
}
catch (Exception ex)
{
Console.WriteLine($"Error reading resource");
Console.WriteLine(ex);
}
}
public IView RenderByNode(FigmaNode node, IView parent, ViewRenderServiceOptions options = null)
{
if (options == null)
{
options = new ViewRenderServiceOptions();
}
firstNode = node;
ProcessFromNode(node, parent, options);
var processedNode = FindProcessedNodeById(node.id);
RecursivelyConfigureViews(processedNode, options);
firstNode = null;
return(processedNode.View);
}
public void RenderInWindow(IWindow mainWindow, ViewRenderServiceOptions options = null)
{
var allCanvas = nodeProvider.Nodes
.OfType <FigmaCanvas>()
.ToArray();
if (allCanvas.Length == 0)
{
return;
}
var startPage = options != null ? options.StartPage : 0;
var canvas = allCanvas[startPage];
if (canvas != null)
{
canvas.absoluteBoundingBox = canvas.GetCurrentBounds();
RenderInWindow(mainWindow, canvas, options);
}
}
public virtual void RenderInWindow(IWindow mainWindow, FigmaNode node, ViewRenderServiceOptions options = null)
{
if (node is IAbsoluteBoundingBox bounNode)
{
mainWindow.Size = new Size(bounNode.absoluteBoundingBox.Width, bounNode.absoluteBoundingBox.Height);
}
if (options == null)
{
options = new ViewRenderServiceOptions();
}
SetOptions(options);
ProcessFromNode(node, mainWindow.Content, options);
var processedNode = FindProcessedNodeById(node.id);
RecursivelyConfigureViews(processedNode, options);
}
public void Refresh(ViewRenderServiceOptions options)
{
//on refresh we want clear results
ImageVectors.Clear();
NodesProcessed.Clear();
SetOptions(options);
Console.WriteLine($"Reading successfull");
FigmaCanvas canvas;
if (options.StartPage >= 0 && options.StartPage <= nodeProvider.Response.document.children.Length)
{
canvas = nodeProvider.Response.document.children[options.StartPage];
}
else
{
canvas = nodeProvider.Response.document.children.FirstOrDefault();
}
ProcessFromNode(canvas, container, options);
}
public T RenderByNode <T>(FigmaNode node, IView parent, ViewRenderServiceOptions options = null) where T : IView
{
return((T)RenderByNode(node, parent, options));
}
protected virtual bool NodeScansChildren(FigmaNode currentNode, NodeConverter converter, ViewRenderServiceOptions options)
{
if (converter == null)
{
return(false);
}
if (!converter.ScanChildren(currentNode))
{
return(false);
}
if (!options.ScanChildrenFromFigmaInstances && (currentNode is FigmaInstance || currentNode is FigmaComponentEntity))
{
return(false);
}
return(true);
}
protected virtual IEnumerable <FigmaNode> GetCurrentChildren(FigmaNode currentNode, FigmaNode parentNode, NodeConverter converter, ViewRenderServiceOptions options)
{
if (currentNode is IFigmaNodeContainer nodeContainer)
{
return(nodeContainer.children);
}
return(Enumerable.Empty <FigmaNode>());
}
//TODO: This
protected void GenerateViewsRecursively(FigmaNode currentNode, ViewNode parent, ViewRenderServiceOptions options)
{
Console.WriteLine("[{0}.{1}] Processing {2}..", currentNode?.id, currentNode?.name, currentNode?.GetType());
//if (currentNode.name.StartsWith ("#") || currentNode.name.StartsWith ("//")) {
// Console.WriteLine ("[{0}.{1}] Detected skipped flag in name.. Skipping...", currentNode?.id, currentNode?.name, currentNode?.GetType ());
// return;
//}
if (SkipsNode(currentNode, parent, options))
{
return;
}
var converter = GetConverter(currentNode);
ViewNode currentProcessedNode = null;
if (converter != null)
{
var currentView = options.IsToViewProcessed ? converter.ConvertToView(currentNode, parent, this) : null;
currentProcessedNode = new ViewNode(currentNode, currentView, parent);
NodesProcessed.Add(currentProcessedNode);
}
else
{
Console.WriteLine("[{1}.{2}] There is no Converter for this type: {0}", currentNode.GetType(), currentNode.id, currentNode.name);
}
if (NodeScansChildren(currentNode, converter, options))
{
foreach (var item in GetCurrentChildren(currentNode, parent?.Node, converter, options))
{
GenerateViewsRecursively(item, currentProcessedNode ?? parent, options);
}
}
}
protected virtual bool NodeScansChildren(FigmaNode currentNode, NodeConverter converter, ViewRenderServiceOptions options)
{
if (converter == null)
{
return(false);
}
if (!converter.ScanChildren(currentNode))
{
return(false);
}
if (!options.ScanChildrenFromFigmaInstances && (currentNode is FigmaInstance || currentNode is FigmaComponentEntity))
{
return(false);
}
// This will not be used by the ViewRenderService when SkipsNode returns true. Added here
// in case something calls NodeScansChildren directly.
if (currentNode.IsRenderSkipped())
{
return(false);
}
return(true);
}
