/// <summary>
/// Initializes a new instance of the
/// <see cref="Tasque.Core.BackendManager"/> class.
/// </summary>
/// <param name='preferences'>
/// Preferences.
/// </param>
/// <exception cref="T:System.ArgumentNullException">
/// thrown when preferences is <c>null</c>.
/// </exception>
public BackendManager(IPreferences preferences)
{
manager = new InternalBackendManager (preferences);
// setup backend manager for AllList
Tasque.Utils.AllList.SetBackendManager (this);
}
public RecentFilesProvider (IPreferences prefs)
{
NumRecentDocs = prefs.Get<int> ("NumRecentDocs", 7);
RefreshRecentDocs ();
Gtk.RecentManager.Default.Changed += delegate { RefreshRecentDocs (); };
}
/// <summary>
/// Initializes a new instance of the StringSequenceFeedSourceStore class.
/// </summary>
/// <param name="preferences">IStringSequenceStore instance.</param>
/// <param name="filterTag">Gallery filter tag for the feed sources.</param>
public StringSequenceFeedSourceStore(IPreferences preferences, string filterTag)
: base(preferences)
{
_filterTag = filterTag;
_stringSequenceStore = new StringSequenceStore(this.Preferences);
}
static NPR ()
{
prefs = DockServices.Preferences.Get <NPR> ();
Stations = new List<Station> ();
// create the null station
LookupStation (-1);
}
public ConnectionManager(IPreferences preferences, IPowerManager powerManager, IConnectionInfo connectionInfo, IBlackoutTime blackoutTime)
{
Preferences = preferences;
PowerManager = powerManager;
ConnectionInfo = connectionInfo;
BlackoutTime = blackoutTime;
}
public RenderPackageFactoryViewModel(IPreferences preferenceSettings)
{
this.factory = new HelixRenderPackageFactory()
{
TessellationParameters = { ShowEdges = preferenceSettings.ShowEdges }
};
}
public Connection (IPreferences preferences)
{
if (null == preferences) {
throw new ArgumentNullException ("preferences");
}
this.preferences = preferences;
this.cookies = new CookieCollection ();
}
/// <summary>
/// Enables starting Dynamo with a mock IUpdateManager
/// </summary>
/// <param name="updateManager"></param>
/// <param name="watchHandler"></param>
/// <param name="preferences"></param>
/// <param name="visualizationManager"></param>
protected void StartDynamo(IUpdateManager updateManager, ILogger logger, IWatchHandler watchHandler, IPreferences preferences, IVisualizationManager visualizationManager)
{
//create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager, logger, watchHandler, preferences);
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
DynamoController.IsTestMode = true;
Controller.VisualizationManager = new VisualizationManager();
}
public static void GetPreferences(this ModbusAdaptersViewModel modbusAdaptersViewModel, IPreferences preferences, string key)
{
var selectedPort = modbusAdaptersViewModel.SelectedPort;
if (selectedPort != null)
{
preferences[key] = selectedPort;
}
}
public Setting(string id, ISettings settings)
{
ID = id;
if (settings != null)
{
_preferences = settings.Preferences;
settings.AddSetting(id, this);
}
}
private void ScanAllPackageDirectories(IPreferences preferences)
{
foreach (var dir in
Directory.EnumerateDirectories(RootPackagesDirectory, "*", SearchOption.TopDirectoryOnly))
{
var pkg = ScanPackageDirectory(dir);
if (preferences.PackageDirectoriesToUninstall.Contains(dir)) pkg.MarkForUninstall(preferences);
}
}
public NuGetFeedSourceStore(IPreferences preferences)
: base(preferences)
{
_packageSourceProvider = new PackageSourceProvider(
// Do not load user settings or machine wide settings for WebMatrix 'nuget.org' feed
// In other words, pass all null to LoadDefaultSettings
Settings.LoadDefaultSettings(null, null, null),
defaultSources: new[] { new PackageSource("https://www.nuget.org/api/v2", Resources.NuGet_PackageSourceName) });
}
public void Load(IPreferences preferences, IPathManager pathManager)
{
// Load Packages
PackageLoader.DoCachedPackageUninstalls(preferences);
PackageLoader.LoadAll(new LoadPackageParams
{
Preferences = preferences,
PathManager = pathManager
});
}
public void Initialize (IPreferences preferences)
{
if (preferences == null)
throw new ArgumentNullException ("preferences");
this.preferences = preferences;
// *************************************
// AUTHENTICATION to Remember The Milk
// *************************************
string authToken = preferences.Get (PreferencesKeys.AuthTokenKey);
if (authToken != null) {
Logger.Debug ("Found AuthToken, checking credentials...");
try {
Rtm = new RtmNet.Rtm (ApiKey, SharedSecret, authToken);
rtmAuth = Rtm.AuthCheckToken (authToken);
Timeline = Rtm.TimelineCreate ();
Logger.Debug ("RTM Auth Token is valid!");
Logger.Debug ("Setting configured status to true");
IsConfigured = true;
} catch (RtmNet.RtmApiException e) {
preferences.Set (PreferencesKeys.AuthTokenKey, null);
preferences.Set (PreferencesKeys.UserIdKey, null);
preferences.Set (PreferencesKeys.UserNameKey, null);
Rtm = null;
rtmAuth = null;
Logger.Error ("Exception authenticating, reverting "
+ e.Message);
} catch (RtmNet.ResponseXmlException e) {
Rtm = null;
rtmAuth = null;
Logger.Error ("Cannot parse RTM response. " +
"Maybe the service is down. " + e.Message);
} catch (RtmNet.RtmWebException e) {
Rtm = null;
rtmAuth = null;
Logger.Error ("Not connected to RTM, maybe proxy: #{0}",
e.Message);
} catch (System.Net.WebException e) {
Rtm = null;
rtmAuth = null;
Logger.Error ("Problem connecting to internet: #{0}",
e.Message);
}
}
if (Rtm == null) {
Rtm = new RtmNet.Rtm (ApiKey, SharedSecret);
if (NeedsConfiguration != null)
NeedsConfiguration (this, EventArgs.Empty);
return;
}
FinishInitialization ();
}
/// <summary>
/// Initializes a new instance of the <see cref="StartupParams"/> class.
/// </summary>
/// <param name="provider"><see cref="IAuthProvider"/> for DynamoModel</param>
/// <param name="pathManager"><see cref="IPathManager"/> for DynamoModel</param>
/// <param name="libraryLoader"><see cref="ILibraryLoader"/> for DynamoModel</param>
/// <param name="customNodeManager"><see cref="ICustomNodeManager"/> for DynamoModel</param>
/// <param name="dynamoVersion"><see cref="Version"/> for DynamoModel</param>
/// <param name="preferences"><see cref="IPreferences"/> for DynamoModel</param>
public StartupParams(IAuthProvider provider, IPathManager pathManager,
ILibraryLoader libraryLoader, ICustomNodeManager customNodeManager,
Version dynamoVersion, IPreferences preferences)
{
this.authProvider = provider;
this.pathManager = pathManager;
this.libraryLoader = libraryLoader;
this.customNodeManager = customNodeManager;
this.dynamoVersion = dynamoVersion;
this.preferences = preferences;
}
public InternalBackendManager(IPreferences preferences)
{
if (preferences == null)
throw new ArgumentNullException ("preferences");
this.preferences = preferences;
availableBackendNodes = AddinManager
.GetExtensionNodes<BackendNode> (typeof(IBackend));
taskLists = new TaskListCollection ();
}
public static void ApplyPreferences(this ModbusAdaptersViewModel modbusAdaptersViewModel, IPreferences preferences, string key)
{
var displayName = preferences[key];
var item = modbusAdaptersViewModel.Ports.FirstOrDefault(a => string.Compare(a, displayName, true) == 0);
if (item != null)
{
modbusAdaptersViewModel.SelectedPort = item;
}
}
/// <summary>
/// Enables starting Dynamo with a mock IUpdateManager
/// </summary>
/// <param name="updateManager"></param>
/// <param name="watchHandler"></param>
/// <param name="preferences"></param>
/// <param name="visualizationManager"></param>
protected void StartDynamo(IUpdateManager updateManager, IWatchHandler watchHandler, IPreferences preferences, IVisualizationManager visualizationManager)
{
var corePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
DynamoPathManager.Instance.InitializeCore(corePath);
//create a new instance of the ViewModel
Controller = new DynamoController(Context.NONE, updateManager, watchHandler, preferences, corePath);
Controller.DynamoViewModel = new DynamoViewModel(Controller, null);
DynamoController.IsTestMode = true;
Controller.VisualizationManager = new VisualizationManager();
}
/// <summary>
/// Scan the PackagesDirectory for packages and attempt to load all of them. Beware! Fails silently for duplicates.
/// </summary>
public void LoadPackagesIntoDynamo( IPreferences preferences, LibraryServices libraryServices )
{
this.ScanAllPackageDirectories( preferences );
foreach (var pkg in LocalPackages)
{
DynamoPathManager.Instance.AddResolutionPath(pkg.BinaryDirectory);
}
foreach (var pkg in LocalPackages)
{
pkg.LoadIntoDynamo(loader, logger, libraryServices);
}
}
public PackagePathViewModel(IPreferences setting)
{
RootLocations = new ObservableCollection<string>(setting.CustomPackageFolders);
this.setting = setting;
AddPathCommand = new DelegateCommand(p => InsertPath());
DeletePathCommand = new DelegateCommand(p => RemovePathAt((int) p), CanDelete);
MovePathUpCommand = new DelegateCommand(p => SwapPath((int) p, ((int) p) - 1), CanMoveUp);
MovePathDownCommand = new DelegateCommand(p => SwapPath((int) p, ((int) p) + 1), CanMoveDown);
UpdatePathCommand = new DelegateCommand(p => UpdatePathAt((int) p));
SaveSettingCommand = new DelegateCommand(CommitChanges);
SelectedIndex = 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="Tasque.Client.BackendManager"/> class.
/// </summary>
/// <param name='preferences'>The preferences.</param>
/// <exception cref="System.ArgumentNullException">
/// <para>
/// Thrown, when <paramref name="backendInfos"/> is <c>null</c> -or-
/// </para>
/// <para>
/// when <paramref name="preferences"/> is <c>null</c>.
/// </para>
/// </exception>
/// <exception cref="System.ArgumentException">
/// Thrown, when <paramref name="backendInfos"/> is empty.
/// </exception>
public BackendManager(IEnumerable<BackendInfo> backendInfos, IPreferences preferences)
{
if (backendInfos == null)
throw new ArgumentNullException ("backendInfos");
if (!backendInfos.Any ())
throw new ArgumentException ("backendInfos must at least have one element");
if (preferences == null)
throw new ArgumentNullException ("preferences");
AvailableBackends = new ReadOnlyCollection<BackendInfo> (backendInfos.ToList ());
this.preferences = preferences;
taskLists = new TaskListCollection ();
TaskLists = new ReadOnlyObservableCollection<ITaskList> (taskLists);
}
void IBackend.Initialize (IPreferences preferences)
{
if (preferences == null)
throw new ArgumentNullException ("preferences");
database = new Database ();
database.Open ();
taskListRepo = new SqliteTaskListRepository (database);
taskRepo = new SqliteTaskRepository (database);
noteRepo = new SqliteNoteRepository (database);
IsInitialized = true;
if (Initialized != null)
Initialized (this, EventArgs.Empty);
}
private void ScanPackageDirectories(string root, IPreferences preferences)
{
if (!Directory.Exists(root))
{
this.Log(string.Format(Resources.InvalidPackageFolderWarning, root));
return;
}
foreach (var dir in
Directory.EnumerateDirectories(root, "*", SearchOption.TopDirectoryOnly))
{
var pkg = ScanPackageDirectory(dir);
if (pkg != null && preferences.PackageDirectoriesToUninstall.Contains(dir))
{
pkg.MarkForUninstall(preferences);
}
}
}
public void Initialize(TreeModel model, TaskView view, IPreferences preferences)
{
if (view == null)
{
throw new ArgumentNullException("view");
}
this.view = view;
if (preferences == null)
{
throw new ArgumentNullException("preferences");
}
this.preferences = preferences;
if (model == null)
{
throw new ArgumentNullException("model");
}
this.model = model;
}
public PullKeysTests()
{
DependencyInjectionConfig.Init();
string zipDirectory = ServiceLocator.Current.GetInstance <IFileSystem>().CacheDirectory;
if (!Directory.Exists(zipDirectory))
{
Directory.CreateDirectory(zipDirectory);
}
_helper = new ZipDownloaderHelper();
_preferences = ServiceLocator.Current.GetInstance <IPreferences>();
_logManager = ServiceLocator.Current.GetInstance <ILoggingManager>();
_developerTools = ServiceLocator.Current.GetInstance <IDeveloperToolsService>();
_preferences.Clear();
_logManager.DeleteAll();
_developerTools.ClearAllFields();
}
public ExtendedNotificationService(IAnalyticsService analyticsService,
DeepLinkingService deepLinkingService,
MobileSortingService sortingService,
AzureFunctionsApiService azureFunctionsApiService,
IPreferences preferences,
ISecureStorage secureStorage,
INotificationManager notificationManager,
INotificationService notificationService) :
base(analyticsService,
deepLinkingService,
sortingService,
azureFunctionsApiService,
preferences,
secureStorage,
notificationManager,
notificationService)
{
}
public BenchmarksModel(IPreferences preferences, IProteinService proteinService,
IProteinBenchmarkService benchmarkService, IEnumerable <BenchmarksReport> reports)
{
Preferences = preferences ?? new InMemoryPreferencesProvider();
ProteinService = proteinService ?? NullProteinService.Instance;
BenchmarkService = benchmarkService ?? NullProteinBenchmarkService.Instance;
Reports = reports ?? Array.Empty <BenchmarksReport>();
SlotIdentifiers = new BindingSource();
SlotIdentifiers.DataSource = new BindingList <ListItem> {
RaiseListChangedEvents = false
};
SlotProjects = new BindingSource();
SlotProjects.DataSource = new BindingList <ListItem> {
RaiseListChangedEvents = false
};
SelectedSlotProjectListItems = new BindingSourceListItemCollection(SlotProjects);
}
public PreferenceEditor(IPreferences pref)
{
InitializeComponent();
_boldFont = new Font(_listView.Font, _listView.Font.Style | FontStyle.Bold);
_preferences = pref;
_filterChangeTimer = new Timer();
_filterChangeTimer.Interval = 500;
_filterChangeTimer.Tick += new EventHandler(OnFilterChangeTimer);
StringResource sr = UsabilityPlugin.Strings;
_filterLabel.Text = sr.GetString("Form.PreferenceEditor._filterLabel");
_nameHeader.Text = sr.GetString("Form.PreferenceEditor._nameHeader");
_typeHeader.Text = sr.GetString("Form.PreferenceEditor._typeHeader");
_valueHeader.Text = sr.GetString("Form.PreferenceEditor._valueHeader");
_okButton.Text = sr.GetString("Common.OK");
_cancelButton.Text = sr.GetString("Common.Cancel");
_resetButton.Text = sr.GetString("Form.PreferenceEditor._resetButton");
this.Text = sr.GetString("Form.PreferenceEditor.Text");
//洗い出し
_folderTags = new List <FolderTag>();
_itemTags = new List <ItemTag>();
foreach (IPreferenceFolder folder in _preferences.GetAllFolders())
{
FolderTag ft = new FolderTag(folder);
_folderTags.Add(ft);
int count = ft.Work.ChildCount;
for (int i = 0; i < count; i++)
{
IPreferenceItem item = ft.Work.ChildAt(i).AsItem();
if (item != null)
{
ItemTag it = new ItemTag(item);
_itemTags.Add(it);
}
}
}
//ソート
_itemTags.Sort();
InitList();
}
// TODO: Simplify this constructor once IPreferences and IRenderPrecisionPreference have been consolidated in 3.0 (DYN-1699)
public RenderPackageFactoryViewModel(IPreferences preferenceSettings)
{
var ps = preferenceSettings as PreferenceSettings;
if (ps != null)
{
this.factory = new HelixRenderPackageFactory()
{
TessellationParameters = { ShowEdges = ps.ShowEdges, MaxTessellationDivisions = ps.RenderPrecision }
};
}
else
{
this.factory = new HelixRenderPackageFactory()
{
TessellationParameters = { ShowEdges = preferenceSettings.ShowEdges }
};
}
}
public ProxyDockItem (AbstractDockItemProvider provider, IPreferences prefs)
{
StripMnemonics = false;
Provider = provider;
Provider.ItemsChanged += HandleProviderItemsChanged;
this.prefs = prefs;
if (prefs == null) {
currentPos = 0;
} else {
currentPos = prefs.Get<int> ("CurrentIndex", 0);
if (CurrentPosition >= Provider.Items.Count ())
CurrentPosition = 0;
}
ItemChanged ();
}
/// <summary>
/// Creates a WebProxy object based on preference settings.
/// </summary>
public static WebProxy Create(IPreferences preferences)
{
if (preferences == null || !preferences.Get <bool>(Preference.UseProxy))
{
return(null);
}
var proxy = new WebProxy(
preferences.Get <string>(Preference.ProxyServer),
preferences.Get <int>(Preference.ProxyPort));
if (preferences.Get <bool>(Preference.UseProxyAuth))
{
proxy.Credentials = NetworkCredentialFactory.Create(
preferences.Get <string>(Preference.ProxyUser),
preferences.Get <string>(Preference.ProxyPass));
}
return(proxy);
}
/// <summary>
/// Helper function to load new custom nodes and packages.
/// </summary>
/// <param name="newPaths">New package paths to load custom nodes and packages from.</param>
/// <param name="preferences">Can be a temporary local preferences object.</param>
/// <param name="customNodeManager"></param>
private void LoadCustomNodesAndPackagesHelper(IEnumerable <string> newPaths, IPreferences preferences,
CustomNodeManager customNodeManager)
{
foreach (var path in preferences.CustomPackageFolders)
{
// Append the definitions subdirectory for custom nodes.
var dir = path == DynamoModel.BuiltInPackagesToken ? PathManager.BuiltinPackagesDirectory : path;
dir = TransformPath(dir, PathManager.DefinitionsDirectoryName);
customNodeManager.AddUninitializedCustomNodesInPath(dir, false, false);
}
foreach (var path in newPaths)
{
if (DynamoModel.IsDisabledPath(path, preferences))
{
Log(string.Format(Resources.PackagesDirectorySkipped, path));
continue;
}
else
{
ScanPackageDirectories(path, preferences);
}
}
if (pathManager != null)
{
foreach (var pkg in LocalPackages)
{
if (Directory.Exists(pkg.BinaryDirectory))
{
pathManager.AddResolutionPath(pkg.BinaryDirectory);
}
}
}
if (LocalPackages.Any())
{
// Load only those recently addeed local packages (that are located in any of the new paths)
var newPackages = LocalPackages.Where(x => newPaths.Any(y => x.RootDirectory.Contains(y)));
LoadPackages(newPackages);
}
}
protected static HttpState GetHttpState(out MockedFileSystem fileSystem,
out IPreferences preferences,
string baseAddress = "",
string header = "",
string path = "",
IDictionary <string, string> urlsWithResponse = null,
bool readFromFile = false,
string fileContents = "",
string contentType = "")
{
HttpResponseMessage responseMessage = new HttpResponseMessage();
responseMessage.Content = new MockHttpContent(string.Empty);
MockHttpMessageHandler messageHandler = new MockHttpMessageHandler(urlsWithResponse, header, readFromFile, fileContents, contentType);
HttpClient httpClient = new HttpClient(messageHandler);
fileSystem = new MockedFileSystem();
preferences = new NullPreferences();
HttpState httpState = new HttpState(fileSystem, preferences, httpClient);
if (!string.IsNullOrWhiteSpace(baseAddress))
{
httpState.BaseAddress = new Uri(baseAddress);
}
if (!string.IsNullOrWhiteSpace(path))
{
httpState.BaseAddress = new Uri(baseAddress);
if (path != null)
{
string[] pathParts = path.Split('/');
foreach (string pathPart in pathParts)
{
httpState.PathSections.Push(pathPart);
}
}
}
return(httpState);
}
public DockPreferences(string dockName)
{
prefs = DockServices.Preferences.Get <DockPreferences> ();
// ensures position actually gets set
position = (DockPosition)100;
this.Build();
// Manually set the tooltips <shakes fist at MD...>
window_manager_check.TooltipMarkup = Mono.Unix.Catalog.GetString(
"When set, windows which do not already have launchers on a dock will be added to this dock.");
icon_scale.Adjustment.SetBounds(24, 129, 1, 12, 1);
zoom_scale.Adjustment.SetBounds(1, 4.01, .01, .1, .01);
zoom_scale.FormatValue += delegate(object o, FormatValueArgs args) {
args.RetVal = string.Format("{0:#}%", args.Value * 100);
};
name = dockName;
BuildItemProviders();
BuildOptions();
Gdk.Screen.Default.CompositedChanged += HandleCompositedChanged;
icon_scale.ValueChanged += IconScaleValueChanged;
zoom_scale.ValueChanged += ZoomScaleValueChanged;
zoom_checkbutton.Toggled += ZoomCheckbuttonToggled;
autohide_box.Changed += AutohideBoxChanged;
fade_on_hide_check.Toggled += FadeOnHideToggled;
DefaultProvider.ItemsChanged += HandleDefaultProviderItemsChanged;
if (FirstRun)
{
FirstRun = false;
}
ShowAll();
}
public WebAssemblyVersionTracking(IPreferences preferences, IAppInfo appInfo)
{
_preferences = preferences;
_appInfo = appInfo;
IsFirstLaunchEver = !_preferences.ContainsKey(versionsKey, sharedName) || !_preferences.ContainsKey(buildsKey, sharedName);
if (IsFirstLaunchEver)
{
versionTrail = new Dictionary <string, List <string> >
{
{ versionsKey, new List <string>() },
{ buildsKey, new List <string>() }
};
}
else
{
versionTrail = new Dictionary <string, List <string> >
{
{ versionsKey, ReadHistory(versionsKey).ToList() },
{ buildsKey, ReadHistory(buildsKey).ToList() }
};
}
IsFirstLaunchForCurrentVersion = !versionTrail[versionsKey].Contains(CurrentVersion);
if (IsFirstLaunchForCurrentVersion)
{
versionTrail[versionsKey].Add(CurrentVersion);
}
IsFirstLaunchForCurrentBuild = !versionTrail[buildsKey].Contains(CurrentBuild);
if (IsFirstLaunchForCurrentBuild)
{
versionTrail[buildsKey].Add(CurrentBuild);
}
if (IsFirstLaunchForCurrentVersion || IsFirstLaunchForCurrentBuild)
{
WriteHistory(versionsKey, versionTrail[versionsKey]);
WriteHistory(buildsKey, versionTrail[buildsKey]);
}
}
protected Watch3DViewModelBase(Watch3DViewModelStartupParams parameters)
{
model = parameters.Model;
scheduler = parameters.Scheduler;
preferences = parameters.Preferences;
logger = parameters.Logger;
engineManager = parameters.EngineControllerManager;
renderPackageFactory = parameters.RenderPackageFactory;
viewModel = parameters.ViewModel;
renderPackageFactoryViewModel = parameters.RenderPackageFactoryViewModel;
Active = parameters.Preferences.IsBackgroundPreviewActive;
Name = parameters.Name;
logger = parameters.Logger;
RegisterEventHandlers();
TogglePanCommand = new DelegateCommand(TogglePan, CanTogglePan);
ToggleOrbitCommand = new DelegateCommand(ToggleOrbit, CanToggleOrbit);
ToggleCanNavigateBackgroundCommand = new DelegateCommand(ToggleCanNavigateBackground, CanToggleCanNavigateBackground);
}
/// <summary>
/// The DefaultWatch3DViewModel is used in contexts where a complete rendering environment
/// cannot be established. Typically, this is machines that do not have GPUs, or do not
/// support DirectX 10 feature levels. For most purposes, you will want to use a <see cref="HelixWatch3DViewModel"/>
/// </summary>
/// <param name="parameters">A Watch3DViewModelStartupParams object.</param>
public DefaultWatch3DViewModel(Watch3DViewModelStartupParams parameters)
{
model = parameters.Model;
scheduler = parameters.Scheduler;
preferences = parameters.Preferences;
logger = parameters.Logger;
engineManager = parameters.EngineControllerManager;
Name = Resources.BackgroundPreviewDefaultName;
isGridVisible = parameters.Preferences.IsBackgroundGridVisible;
active = parameters.Preferences.IsBackgroundPreviewActive;
logger = parameters.Logger;
RegisterEventHandlers();
TogglePanCommand = new DelegateCommand(TogglePan, CanTogglePan);
ToggleOrbitCommand = new DelegateCommand(ToggleOrbit, CanToggleOrbit);
ToggleCanNavigateBackgroundCommand = new DelegateCommand(ToggleCanNavigateBackground, CanToggleCanNavigateBackground);
ZoomToFitCommand = new DelegateCommand(ZoomToFit, CanZoomToFit);
CanBeActivated = true;
}
public ServerState(
IUser user,
IEnumerable <IClient> clients = null,
IEnumerable <IProject> projects = null,
IPreferences preferences = null,
IEnumerable <ITag> tags = null,
IEnumerable <ITask> tasks = null,
IEnumerable <ITimeEntry> timeEntries = null,
IEnumerable <IWorkspace> workspaces = null,
IDictionary <long, PricingPlans> pricingPlans = null)
{
User = user;
Clients = new HashSet <IClient>(clients ?? new IClient[0]);
Projects = new HashSet <IProject>(projects ?? new IProject[0]);
Preferences = preferences ?? new MockPreferences();
Tags = new HashSet <ITag>(tags ?? new ITag[0]);
Tasks = new HashSet <ITask>(tasks ?? new ITask[0]);
TimeEntries = new HashSet <ITimeEntry>(timeEntries ?? new ITimeEntry[0]);
Workspaces = new HashSet <IWorkspace>(workspaces ?? new IWorkspace[0]);
PricingPlans = pricingPlans ?? new Dictionary <long, PricingPlans>();
}
private static HttpClient GetHttpClientWithPreferences(IPreferences preferences)
{
bool useDefaultCredentials = preferences.GetBoolValue(WellKnownPreference.UseDefaultCredentials);
bool proxyUseDefaultCredentials = preferences.GetBoolValue(WellKnownPreference.ProxyUseDefaultCredentials);
if (useDefaultCredentials || proxyUseDefaultCredentials)
{
#pragma warning disable CA2000 // Dispose objects before losing scope
HttpClientHandler handler = new HttpClientHandler()
{
UseDefaultCredentials = useDefaultCredentials,
DefaultProxyCredentials = proxyUseDefaultCredentials ? CredentialCache.DefaultCredentials : null
};
return(new HttpClient(handler));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
return(new HttpClient());
}
/// <summary>
/// Initializes a new instance of the <see cref="T:NuGetViewModel"/> class.
/// </summary>
public NuGetViewModel(
INuGetGalleryDescriptor descriptor,
IWebMatrixHost host,
PackageSourcesViewModel packageSourcesViewModel,
Func <Uri, string, INuGetPackageManager> packageManagerCreator,
string destination,
TaskScheduler scheduler)
{
this.Descriptor = descriptor;
this.Host = host;
this.Scheduler = scheduler;
_packageManagerCreator = packageManagerCreator;
_destination = destination;
_preferences = this.Host.GetExtensionSpecificPreferences(this.Descriptor.PreferencesStore);
_selectedPrereleaseFilter = LoadPrereleaseFilter();
_includePrerelease = (_selectedPrereleaseFilter == Resources.Prerelease_Filter_IncludePrerelease);
PackagesToDisplayForUpdateAll = new List <PackageViewModel>();
this.ShowDetailsPageCommand = new RelayCommand(this.ShowDetailsPage, this.CanShowDetailsPage);
this.ShowLicensePageCommand = new RelayCommand(this.ShowLicensePage, this.CanShowLicensePage);
this.ShowUninstallPageCommand = new RelayCommand(this.ShowUninstallPage, this.CanShowUninstallPage);
this.ShowListCommand = new RelayCommand(this.ShowList, this.CanShowList);
this.InstallCommand = new RelayCommand(this.Install, this.CanInstall);
this.UpdateCommand = new RelayCommand(this.Update, this.CanUpdate);
this.UninstallCommand = new RelayCommand(this.Uninstall, this.CanUninstall);
this.UpdateAllCommand = new RelayCommand(this.UpdateAll, this.CanUpdateAll);
this.ShowLicensePageForAllCommand = new RelayCommand(this.ShowLicensePageForAll, this.CanShowLicensePageForAll);
this.DisableCommand = new RelayCommand(this.Disable, this.CanDisable);
this.EnableCommand = new RelayCommand(this.Enable, this.CanEnable);
this.DefaultActionCommand = new RelayCommand(this.DefaultAction, this.CanDefaultAction);
// Initialize the Package Sources
InitializePackageSources(packageSourcesViewModel);
}
protected virtual void StartDynamo(IPreferences settings = null)
{
var assemblyPath = Assembly.GetExecutingAssembly().Location;
preloader = new Preloader(Path.GetDirectoryName(assemblyPath));
preloader.Preload();
var preloadedLibraries = new List <string>();
GetLibrariesToPreload(preloadedLibraries);
if (preloadedLibraries.Any())
{
// Only when any library needs preloading will a path resolver be
// created, otherwise DynamoModel gets created without preloading
// any library.
//
var pathResolverParams = new TestPathResolverParams()
{
UserDataRootFolder = GetUserUserDataRootFolder(),
CommonDataRootFolder = GetCommonDataRootFolder()
};
pathResolver = new TestPathResolver(pathResolverParams);
foreach (var preloadedLibrary in preloadedLibraries.Distinct())
{
pathResolver.AddPreloadLibraryPath(preloadedLibrary);
}
}
this.CurrentDynamoModel = DynamoModel.Start(
new DynamoModel.DefaultStartConfiguration()
{
PathResolver = pathResolver,
StartInTestMode = true,
GeometryFactoryPath = preloader.GeometryFactoryPath,
Preferences = settings
});
}
/// <summary>
/// Initializes a new instance of the <see cref="T:NuGetViewModel"/> class.
/// </summary>
public NuGetViewModel(
INuGetGalleryDescriptor descriptor,
IWebMatrixHost host,
PackageSourcesViewModel packageSourcesViewModel,
Func<Uri, string, INuGetPackageManager> packageManagerCreator,
string destination,
TaskScheduler scheduler)
{
this.Descriptor = descriptor;
this.Host = host;
this.Scheduler = scheduler;
_packageManagerCreator = packageManagerCreator;
_destination = destination;
_preferences = this.Host.GetExtensionSpecificPreferences(this.Descriptor.PreferencesStore);
_selectedPrereleaseFilter = LoadPrereleaseFilter();
_includePrerelease = (_selectedPrereleaseFilter == Resources.Prerelease_Filter_IncludePrerelease);
PackagesToDisplayForUpdateAll = new List<PackageViewModel>();
this.ShowDetailsPageCommand = new RelayCommand(this.ShowDetailsPage, this.CanShowDetailsPage);
this.ShowLicensePageCommand = new RelayCommand(this.ShowLicensePage, this.CanShowLicensePage);
this.ShowUninstallPageCommand = new RelayCommand(this.ShowUninstallPage, this.CanShowUninstallPage);
this.ShowListCommand = new RelayCommand(this.ShowList, this.CanShowList);
this.InstallCommand = new RelayCommand(this.Install, this.CanInstall);
this.UpdateCommand = new RelayCommand(this.Update, this.CanUpdate);
this.UninstallCommand = new RelayCommand(this.Uninstall, this.CanUninstall);
this.UpdateAllCommand = new RelayCommand(this.UpdateAll, this.CanUpdateAll);
this.ShowLicensePageForAllCommand = new RelayCommand(this.ShowLicensePageForAll, this.CanShowLicensePageForAll);
this.DisableCommand = new RelayCommand(this.Disable, this.CanDisable);
this.EnableCommand = new RelayCommand(this.Enable, this.CanEnable);
this.DefaultActionCommand = new RelayCommand(this.DefaultAction, this.CanDefaultAction);
// Initialize the Package Sources
InitializePackageSources(packageSourcesViewModel);
}
public UserStatsDataModel(ISynchronizeInvoke synchronizeInvoke, IPreferences preferences, EocStatsScheduledTask scheduledTask)
{
_preferences = preferences;
_scheduledTask = scheduledTask;
_mapper = new MapperConfiguration(cfg => cfg.AddProfile <UserStatsDataModelProfile>()).CreateMapper();
_preferences.PreferenceChanged += (s, e) =>
{
switch (e.Preference)
{
case Preference.EnableUserStats:
ControlsVisible = _preferences.Get <bool>(Preference.EnableUserStats);
if (ControlsVisible)
{
RefreshFromData();
}
break;
case Preference.EocUserId:
Refresh();
break;
}
};
_scheduledTask.Changed += (s, e) =>
{
switch (e.Action)
{
case ScheduledTaskChangedAction.Finished:
// scheduled task completes on thread pool, but RefreshFromData will trigger UI control updates
// provide the ISynchronizeInvoke instance for posting the updates back to the UI thread
RefreshFromData(synchronizeInvoke);
break;
}
};
ControlsVisible = _preferences.Get <bool>(Preference.EnableUserStats);
RefreshFromData();
}
/// <summary>
/// Scan the PackagesDirectory for packages and attempt to load all of them. Beware! Fails silently for duplicates.
/// </summary>
public void LoadPackagesIntoDynamo(
IPreferences preferences, LibraryServices libraryServices, DynamoLoader loader, string context,
bool isTestMode, CustomNodeManager customNodeManager)
{
ScanAllPackageDirectories(preferences);
foreach (var pkg in LocalPackages)
{
DynamoPathManager.Instance.AddResolutionPath(pkg.BinaryDirectory);
}
foreach (var pkg in LocalPackages)
{
pkg.LoadIntoDynamo(
loader,
AsLogger(),
libraryServices,
context,
isTestMode,
customNodeManager);
}
}
private void InitItems()
{
_idToWorkPreference = new TypedHashtable <string, WorkPreference>();
IPreferences preferences = OptionDialogPlugin.Instance.RootPreferences;
int y = 8;
for (int i = 0; i < _entries.Length; i++)
{
IOptionPanelExtension e = _entries[i].Extension;
foreach (string pref_id in e.PreferenceFolderIDsToEdit)
{
WorkPreference wp = _idToWorkPreference[pref_id];
if (wp == null) //add entry
{
IPreferenceFolder folder = preferences.FindPreferenceFolder(pref_id);
if (folder == null)
{
throw new Exception(pref_id + " not found");
}
_idToWorkPreference.Add(pref_id, new WorkPreference(folder));
}
}
PanelItem item = new PanelItem(this, i, e.Icon, e.Caption);
item.Location = new Point(3, y);
_categoryItems.Controls.Add(item);
y += 52;
}
// 項目が増えた場合はパネルにスクロールを表示させてパネル幅/フォーム幅を変更する
// ※項目数が増えれば増えるほどフォーム自体が縦長になってしまい表示しきれない懸念がある
// ※今後プラグインでどれだけ項目数を増やしてもスクロールを表示することで対応
if (y > _categoryItems.ClientSize.Height)
{
_categoryItems.AutoScroll = true;
_categoryItems.Width += SystemInformation.VerticalScrollBarWidth;
this.Width += SystemInformation.VerticalScrollBarWidth;
}
}
/// <summary>
/// Constructs DynamoAnalyticsClient with given DynamoModel
/// </summary>
/// <param name="dynamoModel">DynamoModel</param>
public DynamoAnalyticsClient(DynamoModel dynamoModel)
{
//Set the preferences, so that we can get live value of analytics
//reporting approved status.
preferences = dynamoModel.PreferenceSettings;
if (Session == null)
{
Session = new DynamoAnalyticsSession();
}
//Setup Analytics service, StabilityCookie, Heartbeat and UsageLog.
Session.Start(dynamoModel);
//Dynamo app version.
var appversion = dynamoModel.AppVersion;
product = new ProductInfo()
{
Name = "Dynamo", VersionString = appversion, AppVersion = dynamoModel.Version
};
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public SlaveExplorerViewModel(IMessageBoxService messageBoxService, IPreferences preferences)
{
_messageBoxService = messageBoxService;
_preferences = preferences;
_registerViewerPreferences = new RegisterViewerPreferences(preferences);
ReadCommand = new RelayCommand(Read, CanRead);
WriteCommand = new RelayCommand(Write, CanWrite);
ExitCommand = new RelayCommand(Exit);
OpenCommand = new RelayCommand(Open, CanOpen);
SaveAsCommand = new RelayCommand(SaveAs, CanSaveAs);
ExportToCsvCommand = new RelayCommand(ExportToCsv, CanExportToCsv);
if (IsInDesignMode)
{
Registers = new ObservableCollection<SlaveExplorerRegisterViewModel>()
{
new SlaveExplorerRegisterViewModel(1000, 0, _descriptionStore) { IsZeroBased = IsZeroBased },
new SlaveExplorerRegisterViewModel(1001, 20, _descriptionStore) { IsZeroBased = IsZeroBased },
new SlaveExplorerRegisterViewModel(1002, 23, _descriptionStore) { IsZeroBased = IsZeroBased },
new SlaveExplorerRegisterViewModel(1003, 24, _descriptionStore) { IsZeroBased = IsZeroBased },
new SlaveExplorerRegisterViewModel(1004, 25, _descriptionStore) { IsZeroBased = IsZeroBased },
};
}
SlaveAddress = _registerViewerPreferences.SlaveAddress;
StartingRegisterNumber = _registerViewerPreferences.StartingRegister;
NumberOfRegisters = _registerViewerPreferences.NumberOfRegisters;
RegisterType = _registerTypes.FirstOrDefault(rt => rt.RegisterType == _registerViewerPreferences.RegisterType);
ModbusAdapters.ApplyPreferences(_preferences, RegisterViewerPreferences.Keys.ModbusAdapter);
IsZeroBased = _registerViewerPreferences.IsZeroBased;
_autoRefreshTimer.Elapsed += _autoRefreshTimer_Elapsed;
}
public EocStatsScheduledTask(IPreferences preferences, ILogger logger, IEocStatsService eocStatsService, EocStatsDataContainer dataContainer)
: base("EOC stats")
{
Preferences = preferences ?? new InMemoryPreferencesProvider();
Logger = logger ?? NullLogger.Instance;
StatsService = eocStatsService ?? throw new ArgumentNullException(nameof(eocStatsService));
DataContainer = dataContainer ?? throw new ArgumentNullException(nameof(dataContainer));
Interval = CalculateInterval(DataContainer.Data.LastUpdated);
Changed += TaskChanged;
Preferences.PreferenceChanged += (s, e) =>
{
if (e.Preference == Preference.EnableUserStats)
{
bool enableUserStats = Preferences.Get <bool>(Preference.EnableUserStats);
if (enableUserStats)
{
Start();
}
else
{
Stop();
}
}
};
if (Preferences.Get <bool>(Preference.EnableUserStats))
{
if (TimeForNextUpdate(DataContainer.Data.LastUpdated))
{
Run();
}
else
{
Start();
}
}
}
protected static HttpState GetHttpState(out MockedFileSystem fileSystem,
out IPreferences preferences,
string baseAddress = "",
string header = "",
string path = "",
IDictionary <string, string> urlsWithResponse = null,
bool readFromFile = false,
string fileContents = "",
string contentType = "")
{
fileSystem = new MockedFileSystem();
preferences = new NullPreferences();
return(GetHttpStateWithOptional(ref fileSystem,
ref preferences,
baseAddress,
header,
path,
urlsWithResponse,
readFromFile,
fileContents,
contentType));
}
internal void DoCachedPackageUninstalls(IPreferences preferences)
{
// this can only be run once per app run
if (hasAttemptedUninstall)
{
return;
}
hasAttemptedUninstall = true;
var pkgDirsRemoved = new HashSet <string>();
foreach (var pkgNameDirTup in preferences.PackageDirectoriesToUninstall)
{
if (pkgNameDirTup.StartsWith(PathManager.BuiltinPackagesDirectory))
{
// do not delete packages from the built in dir
continue;
}
try
{
Directory.Delete(pkgNameDirTup, true);
pkgDirsRemoved.Add(pkgNameDirTup);
Log(String.Format("Successfully uninstalled package from \"{0}\"", pkgNameDirTup));
}
catch
{
Log(
String.Format(
"Failed to delete package directory at \"{0}\", you may need to delete the directory manually.",
pkgNameDirTup),
WarningLevel.Moderate);
}
}
preferences.PackageDirectoriesToUninstall.RemoveAll(pkgDirsRemoved.Contains);
}
private void ScanPackageDirectories(string root, IPreferences preferences)
{
try
{
if (!Directory.Exists(root))
{
string extension = null;
if (root != null)
{
extension = Path.GetExtension(root);
}
// If the path has a .dll or .ds extension it is a locally imported library
// so do not output an error about the directory
if (extension == ".dll" || extension == ".ds")
{
return;
}
this.Log(string.Format(Resources.InvalidPackageFolderWarning, root));
return;
}
foreach (var dir in
Directory.EnumerateDirectories(root, "*", SearchOption.TopDirectoryOnly))
{
var pkg = ScanPackageDirectory(dir);
if (pkg != null && preferences.PackageDirectoriesToUninstall.Contains(dir))
{
pkg.MarkForUninstall(preferences);
}
}
}
catch (UnauthorizedAccessException ex) { }
catch (IOException ex) { }
catch (ArgumentException ex) { }
}
public NuGetService(
ICacheService cacheProvider,
IHttpHandlerService httpHandlerService,
IPreferences preferences,
IVersionTracking versionTracking,
IConnectivity connectivity,
IFileSystem fileSystem,
ILogger logger)
{
_cache = cacheProvider ?? throw new ArgumentNullException(nameof(cacheProvider));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_preferences = preferences;
_versionTracking = versionTracking;
_connectivity = connectivity;
_httpClient = new HttpClient(httpHandlerService.GetNativeHandler());
var dbPath = Path.Combine(fileSystem.AppDataDirectory, "nugets.db");
_db = new LiteDatabase($"Filename={dbPath};Upgrade=true;");
_db.Pragma("UTC_DATE", true);
_packageSourceRepo = new EntityRepository <PackageSource>(_db, TimeSpan.FromDays(7), _connectivity);
_favouriteRepo = new EntityRepository <FavouritePackage>(_db, TimeSpan.MaxValue, _connectivity);
_recentRepo = new EntityRepository <RecentPackage>(_db, TimeSpan.MaxValue, _connectivity);
_retryPolicy =
Policy.Handle <WebException>()
.Or <HttpRequestException>()
.WaitAndRetryAsync
(
retryCount: 2,
sleepDurationProvider: retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))
);
}
public ProxyDockItem(AbstractDockItemProvider provider, IPreferences prefs)
{
StripMnemonics = false;
Provider = provider;
Provider.ItemsChanged += HandleProviderItemsChanged;
this.prefs = prefs;
if (prefs == null)
{
currentPos = 0;
}
else
{
currentPos = prefs.Get <int> ("CurrentIndex", 0);
if (CurrentPosition >= Provider.Items.Count())
{
CurrentPosition = 0;
}
}
ItemChanged();
}
/// <summary>
/// Starts the client when DynamoModel is created. This method initializes
/// the Analytics service and application life cycle start is tracked.
/// </summary>
/// <param name="model"></param>
public void Start(DynamoModel dynamoModel)
{
//Set the preferences, so that we can get live value of analytics
//reporting approved status.
preferences = dynamoModel.PreferenceSettings;
if (Session == null)
{
Session = new DynamoAnalyticsSession();
}
//Setup Analytics service, StabilityCookie, Heartbeat and UsageLog.
Session.Start(dynamoModel);
//Dynamo app version.
var appversion = dynamoModel.AppVersion;
//If not ReportingAnalytics, then set the idle time as infinite so idle state is not recorded.
Service.StartUp(new ProductInfo()
{
Name = "Dynamo", VersionString = appversion
},
new UserInfo(Session.UserId), ReportingAnalytics ? TimeSpan.FromMinutes(30) : TimeSpan.MaxValue);
}
/// <summary>
/// Constructs DynamoAnalyticsClient with given DynamoModel
/// </summary>
/// <param name="dynamoModel">DynamoModel</param>
public DynamoAnalyticsClient(DynamoModel dynamoModel)
{
//Set the preferences, so that we can get live value of analytics
//reporting approved status.
preferences = dynamoModel.PreferenceSettings;
if (Session == null)
{
Session = new DynamoAnalyticsSession();
}
//Setup Analytics service, and StabilityCookie.
Session.Start(dynamoModel);
//Dynamo app version.
var appversion = dynamoModel.AppVersion;
var hostName = string.IsNullOrEmpty(dynamoModel.HostName) ? "Dynamo" : dynamoModel.HostName;
hostInfo = new HostContextInfo()
{
ParentId = dynamoModel.HostAnalyticsInfo.ParentId, SessionId = dynamoModel.HostAnalyticsInfo.SessionId
};
string buildId = String.Empty, releaseId = String.Empty;
if (Version.TryParse(dynamoModel.Version, out Version version))
{
buildId = $"{version.Major}.{version.Minor}.{version.Build}"; // BuildId has the following format major.minor.build, ex: 2.5.1
releaseId = $"{version.Major}.{version.Minor}.0"; // ReleaseId has the following format: major.minor.0; ex: 2.5.0
}
product = new ProductInfo()
{
Id = "DYN", Name = hostName, VersionString = appversion, AppVersion = appversion, BuildId = buildId, ReleaseId = releaseId
};
}
/// <summary>
/// The DefaultWatch3DViewModel is used in contexts where a complete rendering environment
/// cannot be established. Typically, this is machines that do not have GPUs, or do not
/// support DirectX 10 feature levels. For most purposes, you will want to use a <see cref="HelixWatch3DViewModel"/>
/// </summary>
/// <param name="parameters">A Watch3DViewModelStartupParams object.</param>
public DefaultWatch3DViewModel(Watch3DViewModelStartupParams parameters)
{
model = parameters.Model;
scheduler = parameters.Scheduler;
preferences = parameters.Preferences;
logger = parameters.Logger;
engineManager = parameters.EngineControllerManager;
Name = Resources.BackgroundPreviewDefaultName;
isGridVisible = parameters.Preferences.IsBackgroundGridVisible;
logger = parameters.Logger;
RegisterEventHandlers();
TogglePanCommand = new DelegateCommand(TogglePan, CanTogglePan);
ToggleOrbitCommand = new DelegateCommand(ToggleOrbit, CanToggleOrbit);
ToggleCanNavigateBackgroundCommand = new DelegateCommand(ToggleCanNavigateBackground, CanToggleCanNavigateBackground);
ZoomToFitCommand = new DelegateCommand(ZoomToFit, CanZoomToFit);
CanBeActivated = true;
}
private static void InitializePreferences(IPreferences preferences)
{
BaseUnit.NumberFormat = preferences.NumberFormat;
var settings = preferences as PreferenceSettings;
if (settings != null)
{
settings.InitializeNamespacesToExcludeFromLibrary();
}
}
private IPreferences CreateOrLoadPreferences(IPreferences preferences)
{
if (preferences != null) // If there is preference settings provided...
return preferences;
// Is order for test cases not to interfere with the regular preference
// settings xml file, a test case usually specify a temporary xml file
// path from where preference settings are to be loaded. If that value
// is not set, then fall back to the file path specified in PathManager.
//
var xmlFilePath = PreferenceSettings.DynamoTestPath;
if (string.IsNullOrEmpty(xmlFilePath))
xmlFilePath = pathManager.PreferenceFilePath;
if (File.Exists(xmlFilePath))
{
// If the specified xml file path exists, load it.
return PreferenceSettings.Load(xmlFilePath);
}
// Otherwise make a default preference settings object.
return new PreferenceSettings();
}
private void InitializeNodeLibrary(IPreferences preferences)
{
// Initialize all nodes inside of this assembly.
InitializeIncludedNodes();
List<TypeLoadData> modelTypes;
List<TypeLoadData> migrationTypes;
Loader.LoadNodeModelsAndMigrations(pathManager.NodeDirectories,
Context, out modelTypes, out migrationTypes);
// Load NodeModels
foreach (var type in modelTypes)
{
// Protect ourselves from exceptions thrown by malformed third party nodes.
try
{
NodeFactory.AddTypeFactoryAndLoader(type.Type);
NodeFactory.AddAlsoKnownAs(type.Type, type.AlsoKnownAs);
AddNodeTypeToSearch(type);
}
catch (Exception e)
{
Logger.Log(e);
}
}
// Load migrations
foreach (var type in migrationTypes)
MigrationManager.AddMigrationType(type);
// Import Zero Touch libs
var functionGroups = LibraryServices.GetAllFunctionGroups();
if (!IsTestMode)
AddZeroTouchNodesToSearch(functionGroups);
#if DEBUG_LIBRARY
DumpLibrarySnapshot(functionGroups);
#endif
// Load local custom nodes
foreach (var directory in pathManager.DefinitionDirectories)
CustomNodeManager.AddUninitializedCustomNodesInPath(directory, IsTestMode);
CustomNodeManager.AddUninitializedCustomNodesInPath(pathManager.CommonDefinitions, IsTestMode);
}
protected Watch3DViewModelBase(Watch3DViewModelStartupParams parameters)
{
model = parameters.Model;
scheduler = parameters.Scheduler;
preferences = parameters.Preferences;
logger = parameters.Logger;
engineManager = parameters.EngineControllerManager;
renderPackageFactory = parameters.RenderPackageFactory;
viewModel = parameters.ViewModel;
renderPackageFactoryViewModel = parameters.RenderPackageFactoryViewModel;
Active = parameters.Preferences.IsBackgroundPreviewActive;
Name = parameters.Name;
logger = parameters.Logger;
RegisterEventHandlers();
TogglePanCommand = new DelegateCommand(TogglePan, CanTogglePan);
ToggleOrbitCommand = new DelegateCommand(ToggleOrbit, CanToggleOrbit);
ToggleCanNavigateBackgroundCommand = new DelegateCommand(ToggleCanNavigateBackground, CanToggleCanNavigateBackground);
}
