private async Task HandleEditNodeBlockSegmentAsync(BlockSegmentVm segment)
{
using (MessengerDbContext _context = CreateContext())
{
using (var transaction = await _context.Database.BeginTransactionAsync().ConfigureAwait(false))
{
try
{
EditNodeBlockData blockData = (EditNodeBlockData)segment.PublicData;
var editedNode = NodeConverter.GetNode(blockData.Node);
if (await _context.Nodes.AnyAsync(node => node.Id == editedNode.Id).ConfigureAwait(false))
{
_context.Nodes.Attach(editedNode);
_context.Nodes.Update(editedNode);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
}
catch (Exception ex)
{
AddErrorMessage(nameof(HandleEditNodeBlockSegmentAsync), ex.ToString());
transaction.Rollback();
}
}
}
}
public async Task NewOrEditNodeAsync(NodeVm targetNode)
{
try
{
using (MessengerDbContext context = contextFactory.Create())
{
var node = await context.Nodes.FindAsync(targetNode.Id).ConfigureAwait(false);
if (node == null)
{
node = NodeConverter.GetNode(targetNode);
await context.AddAsync(node).ConfigureAwait(false);
}
else
{
node = NodeConverter.GetNode(targetNode);
context.Update(node);
}
await context.SaveChangesAsync().ConfigureAwait(false);
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
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);
}
public async void CreateOrUpdateNodeInformationAsync(NodeVm nodeInfo)
{
try
{
using (MessengerDbContext context = contextFactory.Create())
{
Node node = await context.Nodes
.Include(opt => opt.DomainNodes)
.Include(opt => opt.Ipnodes)
.FirstOrDefaultAsync(opt => opt.Id == nodeInfo.Id)
.ConfigureAwait(false);
if (node == null)
{
node = NodeConverter.GetNode(nodeInfo);
await context.Nodes.AddAsync(node).ConfigureAwait(false);
}
else
{
node = NodeConverter.GetNode(node, nodeInfo);
context.Nodes.Update(node);
}
await context.SaveChangesAsync().ConfigureAwait(false);
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
protected override bool NodeScansChildren(FigmaNode currentNode, NodeConverter converter, ViewRenderServiceOptions options)
{
if (nodeProvider.RendersAsImage(currentNode))
{
return(false);
}
return(base.NodeScansChildren(currentNode, converter, options));
}
public async Task <List <NodeVm> > GetAllNodesInfoAsync()
{
using (MessengerDbContext context = contextFactory.Create())
{
return(NodeConverter.GetNodesVm(await context.Nodes
.AsNoTracking()
.Include(opt => opt.NodeKeys)
.Include(opt => opt.DomainNodes)
.Include(opt => opt.Ipnodes)
.ToListAsync()
.ConfigureAwait(false)));
}
}
public async Task <NodeVm> GetAllNodeInfoAsync(long nodeId)
{
using (MessengerDbContext context = contextFactory.Create())
{
return(NodeConverter.GetNodeVm(
await context.Nodes
.Include(opt => opt.DomainNodes)
.Include(opt => opt.Ipnodes)
.Include(opt => opt.NodeKeys)
.FirstOrDefaultAsync(opt => opt.Id == nodeId)
.ConfigureAwait(false)));
}
}
internal virtual bool HasConstraints(FigmaNode currentNode, NodeConverter converter)
{
if (currentNode.TryGetAttributeValue(HasConstraintsParameter, out var value))
{
if (value == "true")
{
return(true);
}
if (value == "false")
{
return(false);
}
}
return(true);
}
internal override bool IsFlexibleVertical(ContainerNode currentNode, NodeConverter converter)
{
if (currentNode.Node.TryGetAttributeValue(IsFlexibleVerticalParameter, out var value))
{
if (value == "true")
{
return(true);
}
if (value == "false")
{
return(false);
}
}
return(base.IsFlexibleVertical(currentNode, converter));
}
internal override bool HasWidthConstraint(FigmaNode currentNode, NodeConverter converter)
{
if (currentNode.TryGetAttributeValue(HasWidthConstraintParameter, out var value))
{
if (value == "true")
{
return(true);
}
if (value == "false")
{
return(false);
}
}
return(base.HasWidthConstraint(currentNode, converter));
}
public async Task <List <NodeVm> > GetNodesAsync(List <long> nodesId)
{
var nodesCondition = PredicateBuilder.New <Node>();
nodesCondition = nodesId.Aggregate(nodesCondition,
(current, value) => current.Or(opt => opt.Id == value).Expand());
using (MessengerDbContext context = contextFactory.Create())
{
var nodes = await context.Nodes
.Include(opt => opt.NodeKeys)
.Include(opt => opt.DomainNodes)
.Where(nodesCondition)
.ToListAsync()
.ConfigureAwait(false);
return(NodeConverter.GetNodesVm(nodes));
}
}
private void OpenFile()
{
try
{
var jsonText = File.ReadAllText(fileName);
var rootObject = JObject.Parse(jsonText);
var jsonName = Path.GetFileNameWithoutExtension(fileName);
rootNode = NodeConverter.ConvertFromJObject(rootObject, jsonName);
InitialViews();
Text = $"Json Viewer - {jsonName} ({Path.GetDirectoryName(fileName)})";
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
InitialViews();
}
}
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 override IEnumerable <FigmaNode> GetCurrentChildren(FigmaNode currentNode, FigmaNode parentNode, NodeConverter converter, ViewRenderServiceOptions options)
{
var windowContent = currentNode.GetWindowContent();
if (windowContent != null && windowContent is IFigmaNodeContainer nodeContainer)
{
return(nodeContainer.children);
}
return(base.GetCurrentChildren(currentNode, parentNode, converter, options));
}
internal virtual bool HasHeightConstraint(FigmaNode currentNode, NodeConverter converter)
{
return(converter.HasHeightConstraint());
}
internal virtual bool IsFlexibleHorizontal(ContainerNode currentNode, NodeConverter converter)
{
return(converter.IsFlexibleHorizontal(currentNode.Node));
}
public abstract string ConvertToCode(string propertyName, CodeNode currentNode, CodeNode parentNode, NodeConverter converter, CodeRenderService rendererService);
public override void Configure(string propertyName, ViewNode currentViewNode, ViewNode parentViewNode, NodeConverter converter, ViewRenderService rendererService)
{
var currentNode = currentViewNode.Node;
var parentNode = parentViewNode?.Node;
if (propertyName == PropertyNames.AddChild)
{
if (parentViewNode?.View != null)
{
if (parentNode.IsStackView() && parentViewNode.View.NativeObject is AppKit.NSStackView stackView)
{
stackView.AddArrangedSubview(currentViewNode.View.NativeObject as NSView);
}
else
{
parentViewNode.View.AddChild(currentViewNode.View);
}
}
return;
}
if (propertyName == PropertyNames.Constraints)
{
if (!rendererService.HasConstraints(currentNode, converter))
{
return;
}
if (currentNode is IConstraints constrainedNode && currentViewNode?.View?.NativeObject is AppKit.NSView nativeView && parentViewNode?.View?.NativeObject is AppKit.NSView parentNativeView)
{
var constraints = constrainedNode.constraints;
var absoluteBoundingBox = ((IAbsoluteBoundingBox)currentNode)
.absoluteBoundingBox;
var absoluteBoundBoxParent = ((IAbsoluteBoundingBox)parentNode)
.absoluteBoundingBox;
if (constraints.horizontal.Contains("RIGHT") || constraints.horizontal == "SCALE")
{
var endPosition1 = absoluteBoundingBox.X + absoluteBoundingBox.Width;
var endPosition2 = absoluteBoundBoxParent.X + absoluteBoundBoxParent.Width;
var value = Math.Max(endPosition1, endPosition2) - Math.Min(endPosition1, endPosition2);
var rightConstraint = nativeView.RightAnchor.ConstraintEqualToAnchor(parentNativeView.RightAnchor, -value);
rightConstraint.Active = true;
}
if (constraints.horizontal.Contains("LEFT"))
{
var value2 = absoluteBoundingBox.X - absoluteBoundBoxParent.X;
nativeView.LeftAnchor.ConstraintEqualToAnchor(parentNativeView.LeftAnchor, value2)
.Active = true;
}
if (constraints.vertical.Contains("BOTTOM") || constraints.horizontal == "SCALE")
{
var endPosition1 = absoluteBoundingBox.Y + absoluteBoundingBox.Height;
var endPosition2 = absoluteBoundBoxParent.Y + absoluteBoundBoxParent.Height;
var value2 = Math.Max(endPosition1, endPosition2) - Math.Min(endPosition1, endPosition2);
var bottomConstraint = nativeView.BottomAnchor.ConstraintEqualToAnchor(parentNativeView.BottomAnchor, -value2);
bottomConstraint.Active = true;
}
if (constraints.vertical.Contains("TOP"))
{
var value = absoluteBoundingBox.Y - absoluteBoundBoxParent.Y;
nativeView.TopAnchor.ConstraintEqualToAnchor(parentNativeView.TopAnchor, value)
.Active = true;
}
if (constraints.horizontal == "CENTER" || constraints.horizontal == "SCALE")
{
var delta = absoluteBoundingBox.X - absoluteBoundBoxParent.X - absoluteBoundBoxParent.Center.X;
nativeView.LeftAnchor.ConstraintEqualToAnchor(parentNativeView.CenterXAnchor, delta)
.Active = true;
}
if (constraints.vertical == "CENTER" || constraints.vertical == "SCALE")
{
var delta = absoluteBoundingBox.Y - absoluteBoundBoxParent.Y - absoluteBoundBoxParent.Center.Y;
//var delta = absoluteBoundBoxParent.Center.Substract(absoluteBoundingBox.Origin).Y;
var test = nativeView.TopAnchor.ConstraintEqualToAnchor(parentNativeView.CenterYAnchor, delta);
test.Active = true;
}
}
return;
}
if (propertyName == PropertyNames.Frame)
{
if (currentNode is IAbsoluteBoundingBox absoluteBounding)
{
if (!rendererService.HasConstraints(currentNode, converter))
{
return;
}
var nativeView = currentViewNode?.View?.NativeObject as AppKit.NSView;
if (rendererService.HasWidthConstraint(currentNode, converter))
{
var widthConstraint = nativeView.WidthAnchor.ConstraintEqualToConstant(Math.Max(absoluteBounding.absoluteBoundingBox.Width, 1));
if (rendererService.IsFlexibleHorizontal(currentViewNode, converter))
{
widthConstraint.Priority = (float)NSLayoutPriority.DefaultLow;
}
widthConstraint.Active = true;
}
if (rendererService.HasHeightConstraint(currentNode, converter))
{
var heightConstraint = nativeView.HeightAnchor.ConstraintEqualToConstant(Math.Max(absoluteBounding.absoluteBoundingBox.Height, 1));
if (rendererService.IsFlexibleVertical(currentViewNode, converter))
{
heightConstraint.Priority = (float)NSLayoutPriority.DefaultLow;
}
heightConstraint.Active = true;
}
}
return;
}
}
public PlatformCustomViewConverter(string platform, NodeConverter converter)
{
Platform = platform;
Converter = converter;
}
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>());
}
public override string ConvertToCode(string propertyName, CodeNode currentNode, CodeNode parentNode, NodeConverter converter, CodeRenderService rendererService)
{
if (propertyName == PropertyNames.Frame)
{
if (!rendererService.HasConstraints(currentNode.Node, converter))
{
return(string.Empty);
}
System.Text.StringBuilder builder = new System.Text.StringBuilder();
if (currentNode.Node is IAbsoluteBoundingBox absoluteBounding)
{
var name = currentNode.Name;
if (rendererService.HasWidthConstraint(currentNode.Node, converter))
{
//width
var widthConstraintName = $"{name}WidthConstraint";
var widthMaxStringValue = Math.Max(absoluteBounding.absoluteBoundingBox.Width, 1).ToDesignerString();
var widthConstraintStringValue = CodeGenerationHelpers.GetWidthConstraintEqualToConstant(name, widthMaxStringValue);
builder.AppendLine($"var {widthConstraintName} = {widthConstraintStringValue};");
if (rendererService.IsFlexibleHorizontal(currentNode, converter))
{
builder.WritePropertyEquality(widthConstraintName, nameof(AppKit.NSLayoutConstraint.Priority), $"({typeof(int).FullName}){typeof(NSLayoutPriority)}.{nameof(NSLayoutPriority.DefaultLow)}");
}
builder.WritePropertyEquality(widthConstraintName, nameof(AppKit.NSLayoutConstraint.Active), true);
}
if (rendererService.HasHeightConstraint(currentNode.Node, converter))
{
//height
var heightConstraintName = $"{name}HeightConstraint";
var heightStringValue = Math.Max(absoluteBounding.absoluteBoundingBox.Height, 1).ToDesignerString();
var heightConstraintStringValue = CodeGenerationHelpers.GetHeightConstraintEqualToConstant(name, heightStringValue);
builder.AppendLine($"var {heightConstraintName} = {heightConstraintStringValue};");
if (rendererService.IsFlexibleVertical(currentNode, converter))
{
builder.WritePropertyEquality(heightConstraintName, nameof(AppKit.NSLayoutConstraint.Priority), $"({typeof(int).FullName}){typeof(NSLayoutPriority)}.{nameof(NSLayoutPriority.DefaultLow)}");
}
builder.WritePropertyEquality(heightConstraintName, nameof(AppKit.NSLayoutConstraint.Active), true);
}
return(builder.ToString());
}
return(string.Empty);
}
if (propertyName == PropertyNames.AddChild)
{
if (currentNode.Node.Parent?.IsStackView() ?? false)
{
return(parentNode?.GetMethod(nameof(NSStackView.AddArrangedSubview), currentNode.Name));
}
else
{
return(parentNode?.GetMethod(nameof(NSView.AddSubview), currentNode.Name));
}
}
if (propertyName == PropertyNames.Size)
{
if (currentNode.Node is IAbsoluteBoundingBox container)
{
if (currentNode.Node is FigmaLine line)
{
var width = container.absoluteBoundingBox.Width == 0 ? 1 : container.absoluteBoundingBox.Width;
var height = container.absoluteBoundingBox.Height == 0 ? 1 : container.absoluteBoundingBox.Height;
var size = typeof(CoreGraphics.CGSize).GetConstructor(new string[] { width.ToDesignerString(), height.ToDesignerString() });
return(currentNode.GetMethod(nameof(NSView.SetFrameSize), size));
}
var sizeConstructor = typeof(CoreGraphics.CGSize).GetConstructor(
container.absoluteBoundingBox.Width.ToDesignerString(),
container.absoluteBoundingBox.Height.ToDesignerString());
return(currentNode.GetMethod(nameof(NSView.SetFrameSize), sizeConstructor));
}
return(string.Empty);
}
if (propertyName == PropertyNames.Position)
{
//first level has an special behaviour on positioning
if (currentNode.Node.Parent is FigmaCanvas)
{
return(string.Empty);
}
if (currentNode.Node is IAbsoluteBoundingBox absoluteBounding && currentNode.Node.Parent is IAbsoluteBoundingBox parentAbsoluteBoundingBox)
{
var x = absoluteBounding.absoluteBoundingBox.X - parentAbsoluteBoundingBox.absoluteBoundingBox.X;
var parentY = parentAbsoluteBoundingBox.absoluteBoundingBox.Y + parentAbsoluteBoundingBox.absoluteBoundingBox.Height;
var actualY = absoluteBounding.absoluteBoundingBox.Y + absoluteBounding.absoluteBoundingBox.Height;
var y = parentY - actualY;
if (x != default || y != default)
{
var pointConstructor = typeof(CoreGraphics.CGPoint)
.GetConstructor(x.ToDesignerString(), y.ToDesignerString()
);
return(currentNode.GetMethod(nameof(AppKit.NSView.SetFrameOrigin), pointConstructor));
}
}
return(string.Empty);
}
if (propertyName == PropertyNames.Constraints)
{
if (!rendererService.HasConstraints(currentNode.Node, converter))
{
return(string.Empty);
}
if (currentNode.Node is IConstraints constrainedNode && currentNode.Node.Parent != null)
{
var parentNodeName = parentNode == null?
GetDefaultParentName(currentNode.Node, currentNode.Node.Parent, rendererService) :
parentNode.Name;
var builder = new System.Text.StringBuilder();
var constraints = constrainedNode.constraints;
var absoluteBoundingBox = ((IAbsoluteBoundingBox)currentNode.Node)
.absoluteBoundingBox;
var absoluteBoundBoxParent = ((IAbsoluteBoundingBox)(parentNode == null ? currentNode.Node.Parent : currentNode.Node.Parent))
.absoluteBoundingBox;
if (constraints.horizontal.Contains("RIGHT") || constraints.horizontal == "SCALE")
{
var endPosition1 = absoluteBoundingBox.X + absoluteBoundingBox.Width;
var endPosition2 = absoluteBoundBoxParent.X + absoluteBoundBoxParent.Width;
var value = Math.Max(endPosition1, endPosition2) - Math.Min(endPosition1, endPosition2);
var rightConstraintStringValue = CodeGenerationHelpers.GetRightConstraintEqualToAnchor(
currentNode.Name, -value, parentNodeName);
builder.WritePropertyEquality(rightConstraintStringValue, nameof(NSLayoutConstraint.Active), true);
}
if (constraints.horizontal.Contains("LEFT"))
{
var value2 = absoluteBoundingBox.X - absoluteBoundBoxParent.X;
var rightConstraintStringValue = CodeGenerationHelpers.GetLeftConstraintEqualToAnchor(
currentNode.Name, value2, parentNodeName);
builder.WritePropertyEquality(rightConstraintStringValue, nameof(NSLayoutConstraint.Active), true);
}
if (constraints.vertical.Contains("BOTTOM") || constraints.horizontal == "SCALE")
{
var endPosition1 = absoluteBoundingBox.Y + absoluteBoundingBox.Height;
var endPosition2 = absoluteBoundBoxParent.Y + absoluteBoundBoxParent.Height;
var value2 = Math.Max(endPosition1, endPosition2) - Math.Min(endPosition1, endPosition2);
var rightConstraintStringValue = CodeGenerationHelpers.GetBottomConstraintEqualToAnchor(
currentNode.Name, -value2, parentNodeName);
builder.WritePropertyEquality(rightConstraintStringValue, nameof(NSLayoutConstraint.Active), true);
}
if (constraints.vertical.Contains("TOP"))
{
var value = absoluteBoundingBox.Y - absoluteBoundBoxParent.Y;
var rightConstraintStringValue = CodeGenerationHelpers.GetTopConstraintEqualToAnchor(
currentNode.Name, value, parentNodeName);
builder.WritePropertyEquality(rightConstraintStringValue, nameof(NSLayoutConstraint.Active), true);
}
if (constraints.horizontal == "CENTER" || constraints.horizontal == "SCALE")
{
var delta = absoluteBoundingBox.X - absoluteBoundBoxParent.X - absoluteBoundBoxParent.Center.X;
var rightConstraintStringValue = CodeGenerationHelpers.GetConstraintEqualToAnchor(
currentNode.Name, nameof(NSView.LeftAnchor), delta, parentNodeName, nameof(NSView.CenterXAnchor));
builder.WritePropertyEquality(rightConstraintStringValue, nameof(NSLayoutConstraint.Active), true);
}
if (constraints.vertical == "CENTER" || constraints.vertical == "SCALE")
{
var delta = absoluteBoundingBox.Y - absoluteBoundBoxParent.Y - absoluteBoundBoxParent.Center.Y;
var rightConstraintStringValue = CodeGenerationHelpers.GetConstraintEqualToAnchor(
currentNode.Name, nameof(NSView.TopAnchor), delta, parentNodeName, nameof(NSView.CenterYAnchor));
builder.WritePropertyEquality(rightConstraintStringValue, nameof(NSLayoutConstraint.Active), true);
}
return(builder.ToString());
}
return(string.Empty);
}
throw new System.NotImplementedException(propertyName);
}
public abstract void Configure(string propertyName, ViewNode currentNode, ViewNode parentNode, NodeConverter converter, ViewRenderService rendererService);
public override string ConvertToCode(string propertyName, CodeNode currentNode, CodeNode parentNode, NodeConverter converter, CodeRenderService rendererService)
{
if (currentNode.Node.Parent != null && propertyName == PropertyNames.AddChild)
{
var defaultParentName = GetDefaultParentName(currentNode.Node, currentNode.Node.Parent, rendererService);
if (!string.IsNullOrEmpty(defaultParentName))
{
return(CodeGenerationHelpers.GetMethod(defaultParentName, nameof(NSView.AddSubview), currentNode.Name));
}
}
return(base.ConvertToCode(propertyName, currentNode, parentNode, converter, rendererService));
}
