//reads all the views from the current views directory with empty FigmaBundleViews (not implemented the read)
//public void RefreshViews ()
//{
// Views.Clear ();
// if (!Directory.Exists (ViewsDirectoryPath)) {
// return;
// }
// foreach (var viewFullPath in Directory.EnumerateFiles (ViewsDirectoryPath, $"*{FigmaBundleViewBase.PartialDesignerExtension}")) {
// var name = viewFullPath.Substring (0, viewFullPath.Length - FigmaBundleViewBase.PartialDesignerExtension.Length);
// //TODO: right not it's not possible to read the content of the current .cs file then we create a fake file
// var bundleView = NativeControlsContext.Current.GetBundleView (this, name, new FigmaNode ());
// Views.Add (bundleView);
// }
//}
//this happens when we call to FigmaBundle.FromDirectoryPath
public void Load(string bundleDirectoryPath)
{
if (!Directory.Exists(bundleDirectoryPath))
{
throw new DirectoryNotFoundException("directory doesn't exists");
}
var manifestFullPath = Path.Combine(bundleDirectoryPath, ManifestFileName);
if (!File.Exists(manifestFullPath))
{
throw new FileNotFoundException("manifest doesn't exists");
}
DirectoryPath = bundleDirectoryPath;
try {
Manifest = FigmaManifest.FromFilePath(manifestFullPath);
Namespace = Manifest.Namespace;
Version = new FigmaFileVersion()
{
id = Manifest.DocumentVersion
};
}
catch (Exception ex) {
throw new FileLoadException("error reading manifest file", ex);
}
//RefreshViews ();
}
void WindowController_VersionSelected(object sender, FigmaFileVersion version)
{
windowController.ToggleToolbarSpinner(toggle_on: true);
CurrentPageIndex = 0;
Reload(version: version);
}
public async Task UpdateVersionMenu(string link_id)
{
if (!UseAsVersionsMenu())
{
return;
}
versionsMainMenu.Activated += (s, e) => {
FigmaFileVersion version = menuManager.GetFileVersion(versionsMainMenu);
if (version != null)
{
VersionSelected?.Invoke(this, version);
}
};
var versions = await Task.Run(() =>
{
var query = new FigmaFileVersionQuery(link_id);
FigmaSharp.AppContext.Current.SetAccessToken(TokenStore.SharedTokenStore.GetToken());
return(FigmaSharp.AppContext.Api.GetFileVersions(query)
.versions.GroupByCreatedAt()
.ToArray());
});
menuManager.Clear();
foreach (var version in versions)
{
menuManager.AddItem(version);
}
UseAsVersionsMenu();
}
public void LoadDocument(string token, string documentId, FigmaFileVersion version = null)
{
Token = token;
DocumentID = documentId;
ToggleSpinner(toggle_on: true);
Load(version: version, pageIndex: CurrentPageIndex);
}
private async void FigmaUrlTextField_Changed(object sender, EventArgs e)
{
ShowLoading(true);
SelectedFileVersion = null;
//loads current versions
versionPopUp.RemoveAllItems();
RefreshStates();
if (WebApiHelper.TryParseFileUrl(FileId, out string fileId))
{
figmaUrlTextField.StringValue = fileId;
}
versions = await Task.Run(() => {
try {
var query = new FigmaFileVersionQuery(fileId);
var figmaFileVersions = FigmaSharp.AppContext.Api.GetFileVersions(query).versions;
var result = figmaFileVersions
.GroupByCreatedAt()
.ToArray();
return(result);
} catch (Exception ex) {
LoggingService.LogError("[FIGMA] Error", ex);
return(null);
}
});
ShowLoading(false);
versionMenu.Clear();
if (versions != null)
{
foreach (var item in versions)
{
versionMenu.AddItem(item);
}
versionMenu.Generate(versionPopUp.Menu);
versionPopUp.SelectItem(versionMenu.CurrentMenu);
SelectedFileVersion = versionMenu.CurrentVersion;
}
RefreshStates();
}
async Task GenerateBundle(string fileId, FigmaFileVersion version, string namesSpace, bool includeImages, bool translateLabels)
{
IdeApp.Workbench.StatusBar.AutoPulse = true;
IdeApp.Workbench.StatusBar.BeginProgress($"Adding package ‘{fileId}’…");
//we need to ask to figma server to get nodes as demmand
var fileProvider = new ControlRemoteNodeProvider();
await fileProvider.LoadAsync(fileId);
//bundle generation
var currentBundle = await Task.Run(() =>
{
var bundle = currentProject.CreateBundle(fileId, version, fileProvider, namesSpace);
bundle.SaveAll(includeImages, fileProvider);
return(bundle);
});
//now we need to add to Monodevelop all the stuff
await currentProject.IncludeBundleAsync(currentBundle, includeImages, savesInProject : false);
//to generate all layers we need a code renderer
var codeRendererService = new NativeViewCodeService(fileProvider)
{
TranslationService = new MonoDevelopTranslationService()
};
var mainFigmaNodes = fileProvider.GetMainGeneratedLayers();
foreach (var figmaNode in mainFigmaNodes)
{
if (!(figmaNode is FigmaFrame) || (figmaNode is FigmaGroup))
{
continue;
}
var figmaBundleView = currentBundle.GetFigmaFileView(figmaNode);
figmaBundleView.Generate(codeRendererService, writePublicClassIfExists: false, namesSpace: currentBundle.Namespace, translateLabels);
await currentProject.AddFigmaBundleViewAsync(figmaBundleView, savesInProject : false);
}
await IdeApp.ProjectOperations.SaveAsync(currentProject);
IdeApp.Workbench.StatusBar.EndProgress();
IdeApp.Workbench.StatusBar.AutoPulse = false;
}
internal void LoadLocalDocument()
{
//generate also Document.figma
Document = AppContext.Api.GetFile(new FigmaFileQuery(FileId, Version));
if (Manifest != null && Document != null)
{
Manifest.DocumentTitle = Document.name;
Manifest.DocumentVersion = Document.version;
}
if (Version == null)
{
Version = new FigmaFileVersion()
{
id = Manifest.DocumentVersion
};
}
Console.WriteLine($"[Done] Refreshed Figma Package from remote Figma API");
}
public async Task UpdateVersionMenu(string link_id)
{
if (!UseAsVersionsMenu())
{
return;
}
versionsMainMenu.Activated += (s, e) => {
FigmaFileVersion version = menuManager.GetFileVersion(versionsMainMenu);
if (version != null)
{
VersionSelected?.Invoke(this, version);
}
};
var versions = await Task.Run(() =>
{
try
{
var query = new FigmaFileVersionQuery(link_id);
return(FigmaSharp.AppContext.Api.GetFileVersions(query)
.versions.GroupByCreatedAt()
.ToArray());
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(new FigmaFileVersion[0]);
}
});
menuManager.Clear();
foreach (var version in versions)
{
menuManager.AddItem(version);
}
UseAsVersionsMenu();
}
internal void LoadLocalDocument()
{
//generate also Document.figma
Document = AppContext.Api.GetFile(new FigmaFileQuery(FileId, Version));
if (Manifest != null && Document != null)
{
Manifest.DocumentTitle = Document.name;
Manifest.DocumentVersion = Document.version;
Manifest.DocumentLastModified = Document.lastModified;
}
if (Version == null)
{
Version = new FigmaFileVersion()
{
id = Manifest.DocumentVersion
};
}
LoggingService.LogInfo($"[Done] Refreshed Figma Package from remote Figma API");
}
public static FigmaBundle Empty(string fileId, FigmaFileVersion version, string directoryPath, string nameSpace = null)
{
var bundle = new FigmaBundle()
{
DirectoryPath = directoryPath,
Version = version,
};
bundle.Manifest = new FigmaManifest()
{
ApiVersion = AppContext.Current.Version,
RemoteApiVersion = AppContext.Api.Version.ToString(),
Date = DateTime.Now,
FileId = fileId,
};
if (!string.IsNullOrEmpty(nameSpace))
{
bundle.Manifest.Namespace = bundle.Namespace = nameSpace;
}
return(bundle);
}
public void Reload(FigmaFileVersion version = null, int pageIndex = 0)
{
Load(version: version, pageIndex: pageIndex);
}
public static async Task UpdateFigmaFilesAsync(this Project sender, IEnumerable <ProjectFile> projectFiles, FigmaBundle figmaBundle, FigmaFileVersion version, bool translateStrings)
{
var includeImages = true;
var fileProvider = new FigmaRemoteFileProvider()
{
Version = version
};
await fileProvider.LoadAsync(figmaBundle.FileId);
Console.WriteLine($"[Done] Loaded Remote File provider for Version {version?.id ?? "Current"}");
var codeRendererService = new NativeViewCodeService(fileProvider);
await Task.Run(() => {
figmaBundle.Update(version, includeImages: includeImages);
});
await sender.IncludeBundleAsync(figmaBundle, includeImages : includeImages);
foreach (var designerFile in projectFiles)
{
if (designerFile.TryGetFigmaNode(fileProvider, out var figmaNode))
{
var fileView = figmaBundle.GetFigmaFileView(figmaNode);
fileView.GeneratePartialDesignerClass(codeRendererService,
designerFile.FilePath.ParentDirectory,
figmaBundle.Namespace,
translateStrings);
}
}
}
/// <summary>
/// Updates and Reloads a bundler to a specific version
/// </summary>
/// <param name="version"></param>
public void Update(FigmaFileVersion version, NodeProvider provider, bool includeImages = true)
{
Version = version;
Reload();
SaveAll(includeImages, provider);
}
public static async Task UpdateFigmaFilesAsync(this Project sender, ProgressMonitor monitor, IEnumerable <ProjectFile> projectFiles, FigmaBundle figmaBundle, FigmaFileVersion version, bool translateStrings)
{
var includeImages = true;
var fileProvider = new ControlRemoteNodeProvider()
{
Version = version
};
await fileProvider.LoadAsync(figmaBundle.FileId);
FigmaSharp.Services.LoggingService.LogInfo($"[Done] Loaded Remote File provider for Version {version?.id ?? "Current"}");
var codeRendererService = new NativeViewCodeService(fileProvider)
{
TranslationService = new Services.MonoDevelopTranslationService()
};
await Task.Run(() => {
figmaBundle.Update(version, fileProvider, includeImages: includeImages);
});
await sender.IncludeBundleAsync(monitor, figmaBundle, includeImages : includeImages);
foreach (var designerFile in projectFiles)
{
if (designerFile.TryGetFigmaNode(fileProvider, out var figmaNode))
{
try
{
var fileView = figmaBundle.GetFigmaFileView(figmaNode);
fileView.GeneratePartialDesignerClass(codeRendererService,
designerFile.FilePath.ParentDirectory,
figmaBundle.Namespace,
translateStrings);
await sender.FormatFileAsync(designerFile.FilePath);
}
catch (Exception ex)
{
FigmaSharp.Services.LoggingService.LogError($"Cannot update {designerFile.FilePath}' with '{figmaNode.name}' node.", ex);
}
}
}
}
async void Load(FigmaFileVersion version = null, int pageIndex = 0)
{
if (string.IsNullOrEmpty(DocumentID))
{
return;
}
windowController.EnableButtons(false);
if (response == null)
{
windowController.Title = string.Format("Opening “{0}”…", DocumentID);
}
FigmaSharp.AppContext.Current.SetAccessToken(Token);
if (response == null || version != null)
{
fileProvider = new FigmaRemoteFileProvider()
{
File = DocumentID, Version = version
};
fileProvider.ImageLinksProcessed += (sender, e) => {
InvokeOnMainThread(() => {
windowController.ToggleToolbarSpinner(toggle_on: false);
});
};
var embeddedSheetConverter = new EmbededSheetDialogConverter(fileProvider);
var embeddedWindowConverter = new EmbededWindowConverter(fileProvider);
rendererService = new NativeViewRenderingService(fileProvider);
rendererService.CustomConverters.Add(embeddedSheetConverter);
rendererService.CustomConverters.Add(embeddedWindowConverter);
embeddedWindowConverter.LivePreviewLoading += (s, e) => windowController.ToggleToolbarSpinner(true);
embeddedWindowConverter.LivePreviewLoaded += (s, e) => windowController.ToggleToolbarSpinner(false);
}
var scrollView = CreateScrollView();
await rendererService.StartAsync(DocumentID, scrollView.ContentView, new FigmaViewRendererServiceOptions()
{
StartPage = pageIndex
});
windowController.ToggleToolbarSpinner(toggle_on: true);
new StoryboardLayoutManager().Run(scrollView.ContentView, rendererService);
response = fileProvider.Response;
NativeScrollView.RemoveFromSuperview();
MainScrollView = scrollView;
NativeScrollView = (NSScrollView)scrollView.NativeObject;
View.AddSubview(NativeScrollView);
windowController.Window.Title = windowController.Title = response.name;
windowController.Window.BackgroundColor = NativeScrollView.BackgroundColor;
windowController.UpdatePagesPopupButton(response.document, pageIndex);
await windowController.UpdateVersionMenu(DocumentID);
windowController.EnableButtons(true);
RecentStore.SharedRecentStore.AddRecent(DocumentID, windowController.Window.Title);
ToggleSpinner(toggle_on: false);
}
/// <summary>
/// Updates and Reloads a bundler to a specific version
/// </summary>
/// <param name="version"></param>
public void Update(FigmaFileVersion version, bool includeImages = true)
{
Version = version;
Reload();
SaveAll(includeImages);
}
async void Load(FigmaFileVersion version = null, int pageIndex = 0)
{
if (string.IsNullOrEmpty(DocumentID))
{
return;
}
windowController.EnableButtons(false);
if (response == null)
{
windowController.Title = string.Format("Opening “{0}”…", DocumentID);
}
if (response == null || version != null)
{
fileProvider = new ControlRemoteNodeProvider()
{
File = DocumentID, Version = version
};
fileProvider.ImageLinksProcessed += (sender, e) => {
InvokeOnMainThread(() => {
windowController.ToggleToolbarSpinner(toggle_on: false);
});
};
var embeddedSheetConverter = new EmbededSheetDialogConverter(fileProvider);
var embeddedWindowConverter = new EmbededWindowConverter(fileProvider);
rendererService = new ControlViewRenderingService(fileProvider);
rendererService.CustomConverters.Add(embeddedSheetConverter);
rendererService.CustomConverters.Add(embeddedWindowConverter);
embeddedWindowConverter.LivePreviewLoading += (s, e) => windowController.ToggleToolbarSpinner(true);
embeddedWindowConverter.LivePreviewLoaded += (s, e) => windowController.ToggleToolbarSpinner(false);
}
var scrollView = CreateScrollView();
await rendererService.StartAsync(DocumentID, scrollView.ContentView, new ViewRenderServiceOptions()
{
StartPage = pageIndex
});
windowController.ToggleToolbarSpinner(toggle_on: true);
new StoryboardLayoutManager().Run(scrollView.ContentView, rendererService);
response = fileProvider.Response;
NativeScrollView.RemoveFromSuperview();
MainScrollView = scrollView;
NativeScrollView = (NSScrollView)scrollView.NativeObject;
View.AddSubview(NativeScrollView);
if (response != null)
{
windowController.Window.Title = windowController.Title = response.name;
// NOTE: Figma does not (yet) support color styles for the document background,
// so for now use UnderPageBackgroundColor to get a good contrast in all themes
//
// windowController.Window.BackgroundColor = NativeScrollView.BackgroundColor;
windowController.Window.BackgroundColor = NSColor.UnderPageBackgroundColor;
NativeScrollView.BackgroundColor = NSColor.UnderPageBackgroundColor;
windowController.UpdatePagesPopupButton(response.document, pageIndex);
await windowController.UpdateVersionMenu(DocumentID);
windowController.EnableButtons(true);
RecentStore.SharedRecentStore.AddRecent(DocumentID, windowController.Window.Title);
}
else
{
if (View.Window?.WindowController is DocumentWindowController controller)
{
controller.ShowError(DocumentID);
}
var windowController = this.Storyboard.InstantiateControllerWithIdentifier("OpenLocationWindow") as NSWindowController;
windowController.ShowWindow(null);
this.View.Window.Close();
}
ToggleSpinner(toggle_on: false);
}
