public void Loaded(ViewLoadedParams p)
{
DisposeWindow = false;
var mainViewModel = new GitHubForDynamoWPF.ViewModels.MainViewModel(p, p.DynamoWindow, UniqueId, Name);
gitHubWindow = new GitHubForDynamoWPF.Views.MainView(mainViewModel)
{
Title = this.Name,
Owner = p.DynamoWindow,
DataContext = mainViewModel
};
// When closing, actually hide the window so it is kept on the background
gitHubWindow.Closing += (sender, args) =>
{
if (!DisposeWindow)
{
args.Cancel = true;
(sender as Window).Hide();
}
};
gitHubMenuItem = new MenuItem
{
Header = this.Name
};
gitHubMenuItem.Click += (sender, args) =>
{
gitHubWindow.Show();
};
p.AddSeparator(MenuBarType.Packages, new Separator());
p.AddMenuItem(MenuBarType.Packages, gitHubMenuItem);
}
public void DependencyRegenCrashingDynamoTest()
{
RaiseLoadedEvent(this.View);
var extensionManager = View.viewExtensionManager;
extensionManager.Add(viewExtension);
// Open a random dyf, as a result two Workspace Model will exist under DynamoModel
Open(@"pkgs\EvenOdd2\dyf\EvenOdd.dyf");
var loadedParams = new ViewLoadedParams(View, ViewModel);
viewExtension.pmExtension = this.Model.ExtensionManager.Extensions.OfType <PackageManagerExtension>().FirstOrDefault();
viewExtension.Loaded(loadedParams);
var homeWorkspaceModel = ViewModel.Model.Workspaces.OfType <HomeWorkspaceModel>().FirstOrDefault();
// This is equivalent to uninstall the package
var package = viewExtension.pmExtension.PackageLoader.LocalPackages.Where(x => x.Name == "Dynamo Samples").FirstOrDefault();
package.LoadState.SetScheduledForDeletion();
// Closing the dyf will trigger DependencyRegen of HomeWorkspaceModel.
// The HomeWorkspaceModel does not contain any dependency info since it's empty
// but DependencyRegen() call on it should not crash
Assert.DoesNotThrow(() => viewExtension.DependencyView.DependencyRegen(homeWorkspaceModel));
}
public void Loaded(ViewLoadedParams p)
{
viewLoadedParams = p;
controller = new LibraryViewController(p.DynamoWindow, p.CommandExecutive);
controller.AddLibraryView();
//controller.ShowDetailsView("583d8ad8fdef23aa6e000037");
}
public void Loaded(ViewLoadedParams p)
{
// Specify the text displayed on the menu item
viewportMenuItem = new MenuItem {
Header = "Launch Viewport"
};
// Define the behavior when menu item is clicked
viewportMenuItem.Click += (sender, args) =>
{
// Instantiate a viewModel and window
var viewModel = new ViewportWindowViewModel(p);
var window = new ViewportWindow(viewModel)
{
// Set the data context for the main grid in the window
// This refers to the main grid also seen in our xaml file
MainGrid = { DataContext = viewModel },
// Set the owner of the window to the Dynamo window.
Owner = p.DynamoWindow
};
// Show a modeless window.
window.Show();
};
// add the menu item to our loaded parameters
p.AddMenuItem(MenuBarType.View, viewportMenuItem);
}
public override void Loaded(ViewLoadedParams viewLoadedParams)
{
DependencyView = new WorkspaceDependencyView(this, viewLoadedParams);
// when a package is loaded update the DependencyView
// as we may have installed a missing package.
pmExtension.PackageLoader.PackgeLoaded += (package) =>
{
DependencyView.DependencyRegen(viewLoadedParams.CurrentWorkspaceModel as WorkspaceModel);
};
// Adding a button in view menu to refresh and show manually
workspaceReferencesMenuItem = new MenuItem {
Header = Resources.MenuItemString, IsCheckable = true, IsChecked = false
};
workspaceReferencesMenuItem.Click += (sender, args) =>
{
if (workspaceReferencesMenuItem.IsChecked)
{
// Refresh dependency data
DependencyView.DependencyRegen(viewLoadedParams.CurrentWorkspaceModel as WorkspaceModel);
viewLoadedParams.AddToExtensionsSideBar(this, DependencyView);
workspaceReferencesMenuItem.IsChecked = true;
}
else
{
viewLoadedParams.CloseExtensioninInSideBar(this);
workspaceReferencesMenuItem.IsChecked = false;
}
};
viewLoadedParams.AddExtensionMenuItem(workspaceReferencesMenuItem);
}
public void Loaded(ViewLoadedParams viewLoadedParams)
{
if (viewLoadedParams == null)
{
throw new ArgumentNullException(nameof(viewLoadedParams));
}
this.ViewModel.MessageLogged += OnViewModelMessageLogged;
this.viewLoadedParamsReference = viewLoadedParams;
// Add a button to Dynamo View menu to manually show the window
this.documentationBrowserMenuItem = new MenuItem {
Header = Resources.MenuItemText, IsCheckable = true
};
this.documentationBrowserMenuItem.Checked += MenuItemCheckHandler;
this.documentationBrowserMenuItem.Unchecked += MenuItemUnCheckedHandler;
this.viewLoadedParamsReference.AddMenuItem(MenuBarType.View, this.documentationBrowserMenuItem);
DynamoView.CloseExtension += OnCloseExtension;
// subscribe to the documentation open request event from Dynamo
this.viewLoadedParamsReference.RequestOpenDocumentationLink += HandleRequestOpenDocumentationLink;
// subscribe to property changes of DynamoViewModel so we can show/hide the browser on StartPage display
(viewLoadedParams.DynamoWindow.DataContext as DynamoViewModel).PropertyChanged += HandleStartPageVisibilityChange;
}
/// <summary>
/// The general data collecting method
/// </summary>
/// <param name="vlp">View Loaded Parameters from Dynamo</param>
public static void Collect(ViewLoadedParams vlp)
{
// @todo if user does not consent, don't store..
// @todo provide a visual clue to the user that we are in the process of gathering data/geolocating IP which is delaying startup..
// Dynamo StartupParams
Data.dynamoVersion = vlp.StartupParams.DynamoVersion.ToString();
// @todo Determine whether the script is run from DynamoPlayer..
// Store the local environment data
Data.user = Environment.UserName;
Data.computerName = Environment.MachineName;
// @todo Define the revitVersion, leave blank or null if opened from any other environment (Sandbox, Civil3D etc)
Data.revitVersion = "2019.0.2";
// Request the IP and geolocation from ipinfo.io
WebClient client = new WebClient();
client.Headers.Set("Accept", "application/json");
var json = client.DownloadString("https://ipinfo.io");
// @todo We need to check the request was actually sent successfully and gracefully deal with cases where the API is unavailable
// Parse the JSON
JObject ipinfo = JObject.Parse(json);
// Store geolocation data
Data.ip = (string)ipinfo["ip"];
Data.latlng = (string)ipinfo["loc"];
Data.city = (string)ipinfo["city"];
Data.country = (string)ipinfo["country"];
}
public void Loaded(ViewLoadedParams viewLoadedParams)
{
try
{
var dynamoViewModel = viewLoadedParams.DynamoWindow.DataContext as DynamoViewModel;
//var speckleWatchHandler = new SpeckleWatchHandler(dynamoViewModel.PreferenceSettings);
if (dynamoViewModel.Model is RevitDynamoModel rdm)
{
rdm.RevitDocumentChanged += Rdm_RevitDocumentChanged;
Globals.RevitDocument = DocumentManager.Instance.GetType().GetProperty("CurrentDBDocument").GetValue(DocumentManager.Instance);
}
//sets a read-only property using reflection WatchHandler
//typeof(DynamoViewModel).GetProperty("WatchHandler").SetValue(dynamoViewModel, speckleWatchHandler);
}
catch (Exception e)
{
}
//initialize telemetry and logging
if (Globals.RevitDocument != null)
{
Setup.Init(Applications.DynamoRevit);
}
else
{
Setup.Init(Applications.DynamoSandbox);
}
}
/// <summary>
/// Method that is called when Dynamo has finished loading and the UI is ready to be interacted with.
/// </summary>
/// <param name="vlp">
/// Parameters that provide references to Dynamo commands, settings, events and
/// Dynamo UI items like menus or the background preview. This object is supplied by Dynamo itself.
/// </param>
public void Loaded(ViewLoadedParams vlp)
{
// Display a MessageBox to the user
// @todo Use a view framework to improve the UI/UX
string message = "By pressing OK you agreeing to Binoculars 🔍 data collection.";
string title = "Terms of Use Agreement";
MessageBox.Show(message, title, MessageBoxButton.OK, MessageBoxImage.Exclamation);
// Collect the environment variables
Data.Collect(vlp);
// hold a reference to the Dynamo params to be used later
_viewLoadedParams = vlp;
var dynamoViewModel = vlp.DynamoWindow.DataContext as DynamoViewModel;
// we can register our own events that will be triggered when specific things happen in Dynamo
// a reference to the ReadyParams is needed to do this, so we pass it on
Events.Register(dynamoViewModel.Model);
// Add Revit data, if run from inside Revit
// 10x Brendan Cassidy https://knowledge.autodesk.com/community/screencast/2f26aab4-bbdb-4935-84e1-bdd0e012a1dc
if (dynamoViewModel.HostName.ToLower().Contains("revit"))
{
//Autodesk.Revit.DB.Document doc = RevitServices.Persistence.DocumentManager.Instance.CurrentDBDocument;
//Autodesk.Revit.UI.UIApplication uiapp = RevitServices.Persistence.DocumentManager.Instance.CurrentUIApplication;
//Autodesk.Revit.ApplicationServices.Application app = uiapp.Application;
Data.revit_build = Utils.GetRevitData();
}
// we can now add custom menu items to Dynamo's UI
BinocularsMenuItems();
}
public void Loaded(ViewLoadedParams p)
{
if (publishViewModel == null || inviteViewModel == null)
{
return;
}
publishViewModel.Workspaces = p.WorkspaceModels;
publishViewModel.CurrentWorkspaceModel = p.CurrentWorkspaceModel;
dynamoMenu = p.dynamoMenu;
extensionMenuItem = GenerateMenuItem();
p.AddMenuItem(MenuBarType.File, extensionMenuItem, 11);
manageCustomizersMenuItem = GenerateManageCustomizersMenuItem();
p.AddMenuItem(MenuBarType.File, manageCustomizersMenuItem, 12);
inviteMenuItem = GenerateInviteMenuItem();
p.AddMenuItem(MenuBarType.File, inviteMenuItem, 11);
p.AddSeparator(MenuBarType.File, separator, 14);
p.CurrentWorkspaceChanged += (ws) =>
{
publishViewModel.CurrentWorkspaceModel = ws;
var isEnabled = ws is HomeWorkspaceModel && publishModel.HasAuthProvider;
extensionMenuItem.IsEnabled = isEnabled;
};
}
public void Loaded(ViewLoadedParams p)
{
biltMenuItem = new MenuItem {
Header = "BILT EUR 2018"
};
var VM = p.DynamoWindow.DataContext as DynamoViewModel;
extensionMenuItem = new MenuItem {
Header = "designtech Sample Extension"
};
extensionMenuItem.Click += (sender, args) =>
{
var viewModel = new dtSampleWindowViewModel(p);
var window = new dtSampleWindow
{
// Set the data context for the main grid in the window.
MainGrid = { DataContext = viewModel },
// Set the owner of the window to the Dynamo window.
Owner = p.DynamoWindow
};
window.Left = window.Owner.Left + 400;
window.Top = window.Owner.Top + 200;
window.Show();
};
biltMenuItem.Items.Add(extensionMenuItem);
p.dynamoMenu.Items.Add(biltMenuItem);
}
//private SimpleSearch dependencyViewExtension;
public SimpleSearch(ViewLoadedParams p)
{
InitializeComponent();
this.DataContext = this;
currentWorkspace = p.CurrentWorkspaceModel as WorkspaceModel;
loadedParams = p;
//grid view to add the dynamo info to the list
GridView grid = new GridView();
//column to contain simple node names
GridViewColumn col0 = new GridViewColumn();
col0.Width = 20;
col0.DisplayMemberBinding = new System.Windows.Data.Binding("Weight");
grid.Columns.Add(col0);
GridViewColumn col1 = new GridViewColumn();
col1.Width = 200;
col1.Header = "Node Name";
col1.DisplayMemberBinding = new System.Windows.Data.Binding("Name");
grid.Columns.Add(col1);
//column to contain full node names
GridViewColumn col2 = new GridViewColumn();
col2.Width = 200;
col2.Header = "Node Full Name";
col2.DisplayMemberBinding = new System.Windows.Data.Binding("FullCategoryName");
grid.Columns.Add(col2);
//bind the list view to the grid
this.ResultsList.View = grid;
_searchTextBox = SearchTextBox;
}
public void Loaded(ViewLoadedParams p)
{
p.CurrentWorkspaceChanged += (ws) =>
{
Counter++;
};
}
public void Loaded(ViewLoadedParams p)
{
menuItem = new MenuItem {
Header = "Browse Warnings..."
};
menuItem.Click += (sender, args) =>
{
var dynViewModel = p.DynamoWindow.DataContext as DynamoViewModel;
var viewModel = new WarningsWindowViewModel(p, dynViewModel);
var window = new WarningsWindow
{
// Set the data context for the main grid in the window
MainGrid = { DataContext = viewModel },
// Set the owner of the window to the Dynamo window
Owner = p.DynamoWindow
};
window.Left = window.Owner.Left + 400;
window.Top = window.Owner.Top + 200;
// Show our modeless window
window.Show();
};
p.AddMenuItem(MenuBarType.View, menuItem);
}
public void Loaded(ViewLoadedParams parameters)
{
// Save a reference to your loaded parameters.
// You'll need these later when you want to use
// the supplied workspaces
vm = parameters.DynamoWindow.DataContext as DynamoViewModel;
pandamoMenuItem = new MenuItem {
Header = "Pandamo"
};
pandamoMenuItem.Click += (sender, args) =>
{
pandamoViewModel = new PandamoWindowViewModel(parameters);
var window = new PandamoWindow(pandamoViewModel)
{
DataContext = pandamoViewModel,
Owner = parameters.DynamoWindow
};
// Show a modeless window.
window.Show();
};
//parameters.AddSeparator(MenuBarType.View, new Separator());
//parameters.AddMenuItem(MenuBarType.View, pandamoMenuItem);
parameters.dynamoMenu.Items.Add(pandamoMenuItem);
pandamoViewModel.StartServer();
}
/// <summary>
/// Method that is called when Dynamo has finished loading and the UI is ready to be interacted with.
/// </summary>
/// <param name="vlp">
/// Parameters that provide references to Dynamo commands, settings, events and
/// Dynamo UI items like menus or the background preview. This object is supplied by Dynamo itself.
/// </param>
public void Loaded(ViewLoadedParams vlp)
{
// Hold a reference to the Dynamo params to be used later
viewLoadedParams = vlp;
// Add custom menu items to Dynamo's UI
MakeMenuItems();
}
public void Loaded(ViewLoadedParams p)
{
Clustering a = new Clustering();
// Save a reference to your loaded parameters.
// You'll need these later when you want to use
// the supplied workspaces
sampleMenuItem = new MenuItem {
Header = "Seurat Extension"
};
sampleMenuItem.Click += (sender, args) =>
{
var dynViewModel = p.DynamoWindow.DataContext as DynamoViewModel;
var viewModel = new SeuratExtensionWindowViewModel(p, dynViewModel);
var window = new SeuratExtensionWindow
{
// Set the data context for the main grid in the window.
MainGrid = { DataContext = viewModel },
// Set the owner of the window to the Dynamo window.
Owner = p.DynamoWindow
};
window.Left = window.Owner.Left + 400;
window.Top = window.Owner.Top + 200;
// Show a modeless window.
window.Show();
};
p.AddMenuItem(MenuBarType.View, sampleMenuItem);
}
public void Loaded(ViewLoadedParams p)
{
// Save a reference to your loaded parameters.
// You'll need these later when you want to use
// the supplied workspaces
sampleMenuItem = new MenuItem {
Header = "Show View Extension Sample Window"
};
sampleMenuItem.Click += (sender, args) =>
{
var viewModel = new SampleWindowViewModel(p);
var window = new SampleWindow
{
// Set the data context for the main grid in the window.
MainGrid = { DataContext = viewModel },
// Set the owner of the window to the Dynamo window.
Owner = p.DynamoWindow
};
window.Left = window.Owner.Left + 400;
window.Top = window.Owner.Top + 200;
// Show a modeless window.
window.Show();
};
p.AddMenuItem(MenuBarType.View, sampleMenuItem);
// JL
this.loadedParams = p;
p.DynamoWindow.LayoutUpdated += DynamoWindow_ContentRendered;
}
public void Loaded(ViewLoadedParams p)
{
// Specify the text displayed on the menu item
rechargeMenuItem = new MenuItem {
Header = "Show View Extension Recharge Window"
};
// Define the behavior when menu item is clicked
rechargeMenuItem.Click += (sender, args) =>
{
// Instantiate a viewModel and window
var viewModel = new RechargeWindowViewModel(p);
var window = new RechargeWindow
{
// Set the data context for the main grid in the window
// This refers to the main grid also seen in our xaml file
MainGrid = { DataContext = viewModel },
// Set the owner of the window to the Dynamo window.
Owner = p.DynamoWindow
};
// Set the window position
window.Left = window.Owner.Left + 400;
window.Top = window.Owner.Top + 200;
// Show a modeless window.
window.Show();
};
// add the menu item to our loaded parameters
p.AddMenuItem(MenuBarType.View, rechargeMenuItem);
}
public ViewportWindowViewModel(ViewLoadedParams p, string defaultPackagePath)
{
// Save a reference to our loaded parameters which
// is required in order to access the workspaces
readyParams = p;
// TODO: This API will be obsoleted in future Dynamo releases
// Turn off Dynamo background preview if it's enabled
(p.BackgroundPreviewViewModel as Dynamo.Wpf.ViewModels.Watch3D.HelixWatch3DViewModel).Active = false;
// Save a reference to the default packages directory
PackagePath = defaultPackagePath;
// Subscribe to NodeAdded and NodeRemoved events
p.CurrentWorkspaceModel.NodeAdded += CurrentWorkspaceModel_NodeAdded;
p.CurrentWorkspaceModel.NodeRemoved += CurrentWorkspaceModel_NodeRemoved;
// TODO: this could be dangerous if called in custom node ws
HomeWorkspaceModel currentWS = readyParams.CurrentWorkspaceModel as HomeWorkspaceModel;
// TODO: opening/changing WS needs more attention
// Register all nodes that currently exist in the WS
foreach (NodeModel node in currentWS.Nodes)
{
node.RenderPackagesUpdated += CurrentWorkspaceModel_UpdateViewportGeometry;
node.PropertyChanged += CurrentWorkspaceModel_nodePropertyChanged;
}
}
public void Loaded(ViewLoadedParams p)
{
viewLoadedParams = p;
dynamoWindow = p.DynamoWindow;
var viewModel = dynamoWindow.DataContext as DynamoViewModel;
logger = viewModel.Model.Logger;
Notifications = new ObservableCollection <Logging.NotificationMessage>();
notificationHandler = (notificationMessage) =>
{
Notifications.Add(notificationMessage);
AddNotifications();
};
p.NotificationRecieved += notificationHandler;
//add a new menuItem to the Dynamo mainMenu.
notificationsMenuItem = new NotificationsMenuItem(this);
//null out the content of the notificationsMenu to get rid of
//the parent of the menuItem we created
(notificationsMenuItem.MenuItem.Parent as ContentControl).Content = null;
//place the menu into the DynamoMenu
p.dynamoMenu.Items.Add(notificationsMenuItem.MenuItem);
}
public void Loaded(ViewLoadedParams p)
{
ViewModel = new TuneUpWindowViewModel(p);
TuneUpView = new TuneUpWindow(p, UniqueId)
{
// Set the data context for the main grid in the window.
NodeAnalysisTable = { DataContext = ViewModel },
MainGrid = { DataContext = ViewModel }
};
TuneUpMenuItem = new MenuItem {
Header = "Show TuneUp", IsCheckable = true, IsChecked = false
};
TuneUpMenuItem.Click += (sender, args) =>
{
if (TuneUpMenuItem.IsChecked)
{
p.AddToExtensionsSideBar(this, TuneUpView);
ViewModel.EnableProfiling();
}
else
{
p.CloseExtensioninInSideBar(this);
}
};
p.AddMenuItem(MenuBarType.View, TuneUpMenuItem);
}
public void Loaded(ViewLoadedParams p)
{
// Save a reference to your loaded parameters.
// You'll need these later when you want to use
// the supplied workspaces
view = p.DynamoWindow as DynamoView;
ksMenuItem = new MenuItem {
Header = "Keyboard Shortcuts"
};
#region Shortcuts
ksMenuItem.Click += (sender, args) =>
{
var viewModel = new NodeShortcutsViewModel(p);
var window = new NodeShortcutsWindow()
{
// Set the data context for the main grid in the window.
sp = { DataContext = viewModel },
// Set the owner of the window to the Dynamo window.
Owner = p.DynamoWindow
};
window.Left = window.Owner.Left + 400;
window.Top = window.Owner.Top + 200;
// Show a modeless window.
window.Show();
};
p.dynamoMenu.Items.Add(ksMenuItem);
#endregion
}
public void Loaded(ViewLoadedParams p)
{
ViewModel = new NodePropertyPaletteWindowViewModel(p);
NodePropertyPaletteView = new NodePropertyPaletteWindow(p, ViewModel)
{
// Set the data context for the main grid in the window.
NodesTable = { DataContext = ViewModel },
MainGrid = { DataContext = ViewModel },
Owner = p.DynamoWindow
};
NodePropertyPaletteMenuItem = new MenuItem {
Header = "Show NodePropertyPalette", IsCheckable = true, IsChecked = false
};
NodePropertyPaletteMenuItem.Click += (sender, args) =>
{
if (NodePropertyPaletteMenuItem.IsChecked)
{
p.AddToExtensionsSideBar(this, NodePropertyPaletteView);
}
else
{
p.CloseExtensioninInSideBar(this);
}
};
p.AddMenuItem(MenuBarType.View, NodePropertyPaletteMenuItem);
}
public void OnViewExtensionClosedTest()
{
RaiseLoadedEvent(this.View);
var extensionManager = View.viewExtensionManager;
WorkspaceDependencyViewExtension workspaceDependencyViewExtension = (WorkspaceDependencyViewExtension)extensionManager.ViewExtensions
.Where(ve => ve.Name.Equals("Workspace References")).FirstOrDefault();
// Open a graph which should bring up the Workspace References view extension window with one tab
Open(@"pkgs\Dynamo Samples\extra\CustomRenderExample.dyn");
Assert.AreEqual(1, View.ExtensionTabItems.Count);
var loadedParams = new ViewLoadedParams(View, ViewModel);
// Assert that the workspace references menu item is checked.
Assert.IsTrue(workspaceDependencyViewExtension.workspaceReferencesMenuItem.IsChecked);
// Closing the view extension side bar should trigger the Closed() on the workspace dependency view extension.
// This will un-check the workspace references menu item.
loadedParams.CloseExtensioninInSideBar(workspaceDependencyViewExtension);
Assert.AreEqual(0, View.ExtensionTabItems.Count);
// Assert that the workspace references menu item is un-checked.
Assert.IsFalse(workspaceDependencyViewExtension.workspaceReferencesMenuItem.IsChecked);
}
public void Loaded(ViewLoadedParams viewLoadedParams)
{
var window = viewLoadedParams.DynamoWindow;
_content = (Panel)window.Content;
Instance = this;
}
public void DownloadSpecifiedVersionOfPackageTest()
{
RaiseLoadedEvent(this.View);
var extensionManager = View.viewExtensionManager;
extensionManager.Add(viewExtension);
Open(@"pkgs\Dynamo Samples\extra\CustomRenderExample.dyn");
var loadedParams = new ViewLoadedParams(View, ViewModel);
viewExtension.pmExtension = this.Model.ExtensionManager.Extensions.OfType <PackageManagerExtension>().FirstOrDefault();
viewExtension.Loaded(loadedParams);
var CurrentWorkspace = ViewModel.Model.CurrentWorkspace;
// This is equivalent to uninstall the package
var package = viewExtension.pmExtension.PackageLoader.LocalPackages.Where(x => x.Name == "Dynamo Samples").FirstOrDefault();
package.LoadState.SetScheduledForDeletion();
// Once choosing to install the specified version, info.State should reflect RequireRestart
viewExtension.DependencyView.DependencyRegen(CurrentWorkspace);
// Restart banner should display immediately
Assert.AreEqual(Visibility.Visible, viewExtension.DependencyView.RestartBanner.Visibility);
Assert.AreEqual(1, viewExtension.DependencyView.PackageDependencyTable.Items.Count);
var newInfo = viewExtension.DependencyView.dataRows.FirstOrDefault().DependencyInfo;
// Local loaded version was 2.0.0, but now will be update to date with dyn
Assert.AreEqual("2.0.1", newInfo.Version.ToString());
Assert.AreEqual(1, newInfo.Nodes.Count);
Assert.AreEqual(newInfo.State, PackageDependencyState.RequiresRestart);
}
public void Loaded(ViewLoadedParams p)
{
p.CurrentWorkspaceChanged += (ws) =>
{
Counter++;
};
var window = new Window();
window.Content = new TextBlock()
{
Text = "Dummy"
};
window.Closed += (sender, args) =>
{
WindowClosed = true;
};
if (SetOwner)
{
window.Owner = p.DynamoWindow;
}
Content = window;
p.AddToExtensionsSideBar(this, window);
}
public void Loaded(ViewLoadedParams p)
{
menuItem = new MenuItem {
Header = "Capture Refinery Study..."
};
menuItem.Click += (sender, args) =>
{
var dynViewModel = p.DynamoWindow.DataContext as DynamoViewModel;
var viewModel = new CapturefineryWindowViewModel(p, dynViewModel);
var window = new CapturefineryWindow
{
// Set the data context for the main grid in the window
MainGrid = { DataContext = viewModel },
// Set the owner of the window to the Dynamo window
Owner = p.DynamoWindow
};
window.Left = window.Owner.Left + window.Owner.Width / 2 - window.Width / 2;
window.Top = window.Owner.Top + window.Owner.Height / 2 - window.Height / 2;
// Show our modeless window
window.Show();
};
p.AddMenuItem(MenuBarType.View, menuItem);
}
public GroupNavigationViewModel(ReadyParams p)
{
readyParams = p as ViewLoadedParams;
p.CurrentWorkspaceChanged += CurrentWorkspaceModel_WorkspaceChanged;
p.CurrentWorkspaceChanged += ReadyParams_CurrentWorkspaceChanged;
AddEventHandlers(p.CurrentWorkspaceModel);
}