/// <summary>
/// Setup of the base framework. Enough to manage and calculate canvases.
/// </summary>
private static void setupBaseFramework()
{
CheckEditorPath();
// Init Resource system. Can be called anywhere else, too, if it's needed before.
ResourceManager.SetDefaultResourcePath(editorPath + "Resources/");
// Run fetching algorithms searching the script assemblies for Custom Nodes / Connection Types / NodeCanvas Types
ConnectionPortStyles.FetchConnectionPortStyles();
NodeTypes.FetchNodeTypes();
NodeCanvasManager.FetchCanvasTypes();
ConnectionPortManager.FetchNodeConnectionDeclarations();
ImportExportManager.FetchIOFormats();
// Setup Callback system
NodeEditorCallbacks.SetupReceivers();
NodeEditorCallbacks.IssueOnEditorStartUp();
// Init input
NodeEditorInputSystem.SetupInput();
#if UNITY_EDITOR
UnityEditor.EditorApplication.update -= Update;
UnityEditor.EditorApplication.update += Update;
#endif
initiatedBase = true;
}
/// <summary>
/// Exports the environment variable.
/// </summary>
private void ExportEnvironmentVariable()
{
try
{
saveFileDialog.InitialDirectory
= Environment.SpecialFolder.MyDocuments.ToString();
if (saveFileDialog.ShowDialog() == DialogResult.OK)
{
EnvironmentVariable envVar = new EnvironmentVariable();
envVar.VarName = txtVariableName.Text;
envVar.VarValues
= this.EnvironmentVariableValue().ToString();
ImportExportManager importExportManager
= new ImportExportManager();
importExportManager.EnvVariable = envVar;
importExportManager.Save(saveFileDialog.FileName);
MessageBox.Show(
"'" + txtVariableName.Text
+ "' successfully exported to "
+ saveFileDialog.FileName + " file.",
"Export Success!",
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error!");
}
}
public ImportExportManagerTests()
{
_importDocumentsValidationService = A.Fake <IImportDocumentsValidationService>();
_importDocumentsService = A.Fake <IImportDocumentsService>();
_exportDocumentsService = A.Fake <IExportDocumentsService>();
_inMemoryRepository = new InMemoryRepository <Webpage>();
_importExportManager = new ImportExportManager(_importDocumentsValidationService, _importDocumentsService, _exportDocumentsService, _messageParser, _inMemoryRepository);
}
public ImportExportManagerTests()
{
_documentService = A.Fake <IDocumentService>();
_importDocumentsValidationService = A.Fake <IImportDocumentsValidationService>();
_importDocumentsService = A.Fake <IImportDocumentsService>();
_exportDocumentsService = A.Fake <IExportDocumentsService>();
_importExportManager = new ImportExportManager(_importDocumentsValidationService, _importDocumentsService, _exportDocumentsService, _documentService, _messageParser);
}
private async void ExportSettingsAction()
{
List <ImportExportManager.ImportExportOptions> exportOptions = new List <ImportExportManager.ImportExportOptions>();
if (ApplicationSettingsExists && (ExportEverything || ExportApplicationSettings))
{
exportOptions.Add(ImportExportManager.ImportExportOptions.ApplicationSettings);
}
if (NetworkInterfaceProfilesExists && (ExportEverything || ExportNetworkInterfaceProfiles))
{
exportOptions.Add(ImportExportManager.ImportExportOptions.NetworkInterfaceProfiles);
}
if (IPScannerProfilesExists && (ExportEverything || ExportIPScannerProfiles))
{
exportOptions.Add(ImportExportManager.ImportExportOptions.IPScannerProfiles);
}
if (WakeOnLANClientsExists && (ExportEverything || ExportWakeOnLANClients))
{
exportOptions.Add(ImportExportManager.ImportExportOptions.WakeOnLANClients);
}
if (PortScannerProfilesExists && (ExportEverything || ExportPortScannerProfiles))
{
exportOptions.Add(ImportExportManager.ImportExportOptions.PortScannerProfiles);
}
if (RemoteDesktopSessionsExists && (ExportEverything || ExportRemoteDesktopSessions))
{
exportOptions.Add(ImportExportManager.ImportExportOptions.RemoteDesktopSessions);
}
if (PuTTYSessionsExists && (ExportEverything || ExportPuTTYSessions))
{
exportOptions.Add(ImportExportManager.ImportExportOptions.PuTTYSessions);
}
System.Windows.Forms.SaveFileDialog saveFileDialog = new System.Windows.Forms.SaveFileDialog()
{
Filter = ImportExportFileExtensionFilter,
FileName = string.Format("{0}_{1}_{2}{3}", Application.Current.Resources["String_ProductName"] as string, Application.Current.Resources["String_Backup"] as string, TimestampHelper.GetTimestamp(), ImportExportManager.ImportExportFileExtension)
};
if (saveFileDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
ImportExportManager.Export(exportOptions, saveFileDialog.FileName);
MetroDialogSettings settings = AppearanceManager.MetroDialog;
settings.AffirmativeButtonText = Application.Current.Resources["String_Button_OK"] as string;
await dialogCoordinator.ShowMessageAsync(this, Application.Current.Resources["String_Header_Success"] as string, string.Format("{0}\n\n{1}: {2}", Application.Current.Resources["String_SettingsSuccessfullyExported"] as string, Application.Current.Resources["String_Path"] as string, saveFileDialog.FileName), MessageDialogStyle.Affirmative, settings);
}
}
public VarImportCommand(TextBox txtVarName, string currentVarValues,
string fileName, DgvHandler dgvHandler)
{
this.txtVarName = txtVarName;
this.currentVarValues = currentVarValues;
importExportManager = new ImportExportManager();
importExportManager.EnvVariable = new EnvironmentVariable();
importExportManager.Load(fileName);
this.dgvHandler = dgvHandler;
GetValuesToImport();
}
private void SaveCollection()
{
if (this.currentPackage == null)
{
MessageBox.Show("An unexpected error has occurred", "Error Detected!");
return;
}
ImportExportManager iem = null;
Stream myStream;
SaveFileDialog saveFileDialog1 = new SaveFileDialog();
saveFileDialog1.Filter = "MSFast .MSF File (*.msf)|*.msf|XML File (*.xml)|*.xml|HTTP Archive v1.1 .HAR File (*.har)|*.har";
saveFileDialog1.FilterIndex = 2;
saveFileDialog1.RestoreDirectory = true;
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
if ((myStream = saveFileDialog1.OpenFile()) != null)
{
if (saveFileDialog1.FileName.ToLower().EndsWith("xml"))
{
iem = new XMLImportExportManager();
}
else if (saveFileDialog1.FileName.ToLower().EndsWith("har"))
{
iem = new HARImportExportsManager();
}
else
{
iem = new MSFImportExportsManager();
}
try
{
iem.SaveProcessedDataPackage(myStream, this.currentPackage);
}
catch
{
MessageBox.Show("An unexpected error has occurred", "Error Detected!");
}
finally{
myStream.Flush();
myStream.Close();
myStream.Dispose();
}
}
}
}
private void ImportCanvasCallback(string formatID)
{
IOFormat = ImportExportManager.ParseFormat(formatID);
if (IOFormat.RequiresLocationGUI)
{
ImportLocationGUI = IOFormat.ImportLocationArgsGUI;
modalPanelContent = ImportCanvasGUI;
showModalPanel = true;
}
else if (IOFormat.ImportLocationArgsSelection(out IOLocationArgs))
{
canvasCache.SetCanvas(ImportExportManager.ImportCanvas(IOFormat, IOLocationArgs));
}
}
private void ExportCanvasCallback(string formatID)
{
IOFormat = ImportExportManager.ParseFormat(formatID);
if (IOFormat.RequiresLocationGUI)
{
ExportLocationGUI = IOFormat.ExportLocationArgsGUI;
modalPanelContent = ExportCanvasGUI;
showModalPanel = true;
}
else if (IOFormat.ExportLocationArgsSelection(canvasCache.nodeCanvas.saveName, out IOLocationArgs))
{
ImportExportManager.ExportCanvas(canvasCache.nodeCanvas, IOFormat, IOLocationArgs);
}
}
private async void ValidateImportSettingsAction()
{
try
{
List <ImportExportManager.ImportExportOptions> importOptions = ImportExportManager.ValidateImportFile(ImportFilePath);
ImportFileIsValid = true;
ImportSettingsExists = importOptions.Contains(ImportExportManager.ImportExportOptions.Settings);
ImportProfilesExists = importOptions.Contains(ImportExportManager.ImportExportOptions.Profiles);
}
catch (ImportFileNotValidException)
{
await dialogCoordinator.ShowMessageAsync(this, LocalizationManager.GetStringByKey("String_Header_ValidationFailed"), LocalizationManager.GetStringByKey("String_NoValidFileFoundToImport"), MessageDialogStyle.Affirmative, AppearanceManager.MetroDialog);
}
}
public void AutoSave()
{
if (autoSaveEnabled)
{
if (IOLocationArgs == null)
{
Debug.Log("[Auto Save] Null IO location args");
}
else
{
Debug.Log("[Auto Save] IO location args: " + IOLocationArgs[0]);
ImportExportManager.ExportCanvas(canvasCache.nodeCanvas, IOFormat, IOLocationArgs);
}
}
}
private async void ValidateImportSettingsAction()
{
try
{
List <ImportExportManager.ImportExportOptions> importOptions = ImportExportManager.ValidateImportFile(ImportLocationSelectedPath);
ImportFileIsValid = true;
ImportApplicationSettingsExists = importOptions.Contains(ImportExportManager.ImportExportOptions.ApplicationSettings);
ImportNetworkInterfaceProfilesExists = importOptions.Contains(ImportExportManager.ImportExportOptions.NetworkInterfaceProfiles);
ImportWakeOnLANClientsExists = importOptions.Contains(ImportExportManager.ImportExportOptions.WakeOnLANClients);
}
catch (ImportFileNotValidException)
{
await dialogCoordinator.ShowMessageAsync(this, Application.Current.Resources["String_Header_ValidationFailed"] as string, Application.Current.Resources["String_NoValidFileFoundToImport"] as string, MessageDialogStyle.Affirmative, AppearanceManager.MetroDialog);
}
}
public static void InitSystem()
{
_inst = AssetDatabase.LoadAssetAtPath <NodeSystemSetting>(ASSET_PATH);
bool hasExist = _inst != null;
if (!hasExist)
{
_inst = CreateInstance <NodeSystemSetting>();
AssetDatabase.CreateAsset(_inst, ASSET_PATH);
}
ConnectionPortStyles.InitSystem(out _inst.portStyles, out _inst.valueTypes);
NodeTypes.InitSystem(out _inst.nodeDatas);
NodeCanvasManager.InitSystem(out _inst.canvasDatas);
ConnectionPortManager.InitSystem(out _inst.nodePortDec);
ConnectionPortManager.InitSystem(out _inst.nodePortDec);
ImportExportManager.InitSystem(out _inst.ioFormats);
NodeEditorInputSystem.InitSystem(out _inst.eventHandlers, out _inst.hotkeyHandlers, out _inst.contextEntries, out _inst.contextFillers);
}
private async void ValidateImportSettingsAction()
{
try
{
List <ImportExportManager.ImportExportOptions> importOptions = ImportExportManager.ValidateImportFile(ImportLocationSelectedPath);
ImportFileIsValid = true;
ImportApplicationSettingsExists = importOptions.Contains(ImportExportManager.ImportExportOptions.ApplicationSettings);
ImportNetworkInterfaceProfilesExists = importOptions.Contains(ImportExportManager.ImportExportOptions.NetworkInterfaceProfiles);
ImportIPScannerProfilesExists = importOptions.Contains(ImportExportManager.ImportExportOptions.IPScannerProfiles);
ImportWakeOnLANClientsExists = importOptions.Contains(ImportExportManager.ImportExportOptions.WakeOnLANClients);
ImportPortScannerProfilesExists = importOptions.Contains(ImportExportManager.ImportExportOptions.PortScannerProfiles);
ImportRemoteDesktopSessionsExists = importOptions.Contains(ImportExportManager.ImportExportOptions.RemoteDesktopSessions);
ImportPuTTYSessionsExists = importOptions.Contains(ImportExportManager.ImportExportOptions.PuTTYSessions);
}
catch (ImportFileNotValidException)
{
await dialogCoordinator.ShowMessageAsync(this, LocalizationManager.GetStringByKey("String_Header_ValidationFailed"), LocalizationManager.GetStringByKey("String_NoValidFileFoundToImport"), MessageDialogStyle.Affirmative, AppearanceManager.MetroDialog);
}
}
public SalaryTableViewModel(
INavigationService navigationService,
IDialogService dialogService,
IWindowService windowService,
ImportExportManager importExportManager,
IValidator <ISalary> salaryValidator)
{
this.navigationService = navigationService;
this.dialogService = dialogService;
this.windowService = windowService;
this.importExportManager = importExportManager;
this.salaryValidator = salaryValidator;
showSalaryCommand = new RelayCommand(ShowSalary, CanShowSalary);
editSalaryCommand = new RelayCommand(EditSalary, CanEditSalary);
deleteSalaryCommand = new RelayCommand(DeleteSalary, CanDeleteSalary);
exportCommand = new RelayCommand <FileType>(Export, CanExport);
importCommand = new RelayCommand(Import);
Salary[] salaries = new[]
{
new Salary
{
FirstName = "Jan",
LastName = "Kowalski",
BirthDate = new DateTime(1979, 5, 3),
SalaryValue = 4300
},
new Salary
{
FirstName = "Adam",
LastName = "Nowak",
BirthDate = new DateTime(1972, 11, 4),
SalaryValue = 5200
}
};
LoadSalaries(salaries);
MessengerInstance.Register <SalaryAddedMessage>(this, OnSalaryAdded);
}
private void ExportCanvasGUI()
{
if (ExportLocationGUI != null)
{
bool?state = ExportLocationGUI(canvasCache.nodeCanvas.saveName, ref IOLocationArgs);
if (state == null)
{
return;
}
if (state == true)
{
ImportExportManager.ExportCanvas(canvasCache.nodeCanvas, IOFormat, IOLocationArgs);
}
ImportLocationGUI = null;
modalPanelContent = null;
showModalPanel = false;
}
else
{
showModalPanel = false;
}
}
private void ImportCanvasGUI()
{
if (ImportLocationGUI != null)
{
bool?state = ImportLocationGUI(ref IOLocationArgs);
if (state == null)
{
return;
}
if (state == true)
{
canvasCache.SetCanvas(ImportExportManager.ImportCanvas(IOFormat, IOLocationArgs));
}
ImportLocationGUI = null;
modalPanelContent = null;
showModalPanel = false;
}
else
{
showModalPanel = false;
}
}
private async void ImportSettingsAction()
{
MetroDialogSettings settings = AppearanceManager.MetroDialog;
settings.AffirmativeButtonText = LocalizationManager.GetStringByKey("String_Button_Continue");
settings.NegativeButtonText = LocalizationManager.GetStringByKey("String_Button_Cancel");
settings.DefaultButtonFocus = MessageDialogResult.Affirmative;
string message = LocalizationManager.GetStringByKey("String_SelectedSettingsAreOverwritten");
if (ImportSettingsExists && (ImportEverything || ImportSettings))
{
message += Environment.NewLine + Environment.NewLine + string.Format("* {0}", LocalizationManager.GetStringByKey("String_ApplicationIsRestartedAfterwards"));
}
if (await dialogCoordinator.ShowMessageAsync(this, LocalizationManager.GetStringByKey("String_Header_AreYouSure"), message, MessageDialogStyle.AffirmativeAndNegative, settings) == MessageDialogResult.Affirmative)
{
List <ImportExportManager.ImportExportOptions> importOptions = new List <ImportExportManager.ImportExportOptions>();
if (ImportSettingsExists && (ImportEverything || ImportSettings))
{
importOptions.Add(ImportExportManager.ImportExportOptions.Settings);
}
if (ImportProfilesExists && (ImportEverything || ImportProfiles))
{
importOptions.Add(ImportExportManager.ImportExportOptions.Profiles);
// Load network interface profile (option: add)
if (ProfileManager.Profiles == null)
{
ProfileManager.Load(!ImportOverrideProfiles);
}
}
// Import (copy) files from zip archive
ImportExportManager.Import(ImportFilePath, importOptions);
// Do the import (replace or add)
if (importOptions.Contains(ImportExportManager.ImportExportOptions.Profiles))
{
ProfileManager.Import(ImportEverything || ImportOverrideProfiles);
}
// Show the user a message what happened
if (!ImportExportManager.ForceRestart)
{
settings.AffirmativeButtonText = LocalizationManager.GetStringByKey("String_Button_OK");
message = LocalizationManager.GetStringByKey("String_SettingsSuccessfullyImported") + Environment.NewLine;
if (importOptions.Contains(ImportExportManager.ImportExportOptions.Profiles))
{
message += Environment.NewLine + string.Format("* {0}", LocalizationManager.GetStringByKey("String_ProfilesReloaded"));
}
await dialogCoordinator.ShowMessageAsync(this, LocalizationManager.GetStringByKey("String_Header_Success"), message, MessageDialogStyle.Affirmative, settings);
return;
}
// Close this view (this will restart the application)
CloseAction();
}
}
public void ExportData(string path)
{
IOFormat = ImportExportManager.ParseFormat("XML");
ImportExportManager.ExportCanvas(canvasCache.nodeCanvas, IOFormat, new string[] { path });
}
/// <summary>
/// Initializes a new instance of the <see cref="VarImportCommand"/> class.
/// </summary>
/// <param name="txtVarName">Name of the TXT variable.</param>
/// <param name="currentVarValues">The current variable values.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="dgvHandler">The DGV handler.</param>
public VarImportCommand(
TextBox txtVarName,
string currentVarValues,
string fileName,
DgvHandler dgvHandler)
{
this.txtVarName = txtVarName;
this.currentVarValues = currentVarValues;
this.importExportManager = new ImportExportManager();
this.importExportManager.EnvVariable = new EnvironmentVariable();
this.importExportManager.Load(fileName);
this.dgvHandler = dgvHandler;
this.GetValuesToImport();
}
public void DrawToolbarGUI(Rect rect)
{
rect.height = toolbarHeight;
rect.width = 280f;
if (!showModalPanel)
{
GUILayout.BeginArea(rect, NodeEditorGUI.toolbar);
GUILayout.BeginHorizontal();
//float curToolbarHeight = 0;
if (GUILayout.Button("New", NodeEditorGUI.toolbarButton, GUILayout.Width(50)))
{
AutoSave();
switch (NodeEditorGUI.state)
{
case NodeEditorGUI.NodeEditorState.Mission:
NewNodeCanvas(typeof(QuestCanvas));
break;
case NodeEditorGUI.NodeEditorState.Dialogue:
NewNodeCanvas(typeof(DialogueCanvas));
break;
case NodeEditorGUI.NodeEditorState.Sector:
NewNodeCanvas(typeof(SectorCanvas));
break;
}
IOLocationArgs = null;
}
if (GUILayout.Button("Import", NodeEditorGUI.toolbarButton, GUILayout.Width(50)))
{
IOFormat = ImportExportManager.ParseFormat("XML");
if (IOFormat.RequiresLocationGUI)
{
// Try to auto save
AutoSave();
ImportLocationGUI = IOFormat.ImportLocationArgsGUI;
modalPanelContent = ImportCanvasGUI;
showModalPanel = true;
}
else if (IOFormat.ImportLocationArgsSelection(out IOLocationArgs))
{
canvasCache.SetCanvas(ImportExportManager.ImportCanvas(IOFormat, IOLocationArgs));
}
}
if (GUILayout.Button("Export", NodeEditorGUI.toolbarButton, GUILayout.Width(50)))
{
IOFormat = ImportExportManager.ParseFormat("XML");
if (IOFormat.RequiresLocationGUI)
{
ExportLocationGUI = IOFormat.ExportLocationArgsGUI;
modalPanelContent = ExportCanvasGUI;
showModalPanel = true;
}
else if (IOFormat.ExportLocationArgsSelection(canvasCache.nodeCanvas.saveName, out IOLocationArgs))
{
ImportExportManager.ExportCanvas(canvasCache.nodeCanvas, IOFormat, IOLocationArgs);
}
}
string buttonText = "Mission";
switch (NodeEditorGUI.state)
{
case NodeEditorGUI.NodeEditorState.Mission:
buttonText = "Mission";
break;
case NodeEditorGUI.NodeEditorState.Dialogue:
buttonText = "Dialogue";
break;
case NodeEditorGUI.NodeEditorState.Sector:
buttonText = "Sector";
break;
default:
break;
}
if (GUILayout.Button(buttonText, NodeEditorGUI.toolbarButton, GUILayout.Width(50)))
{
NodeEditorGUI.state = (NodeEditorGUI.NodeEditorState)(((int)NodeEditorGUI.state + 1) % 3);
switch (NodeEditorGUI.state)
{
case NodeEditorGUI.NodeEditorState.Mission:
NewNodeCanvas(typeof(QuestCanvas));
break;
case NodeEditorGUI.NodeEditorState.Dialogue:
NewNodeCanvas(typeof(DialogueCanvas));
break;
case NodeEditorGUI.NodeEditorState.Sector:
NewNodeCanvas(typeof(SectorCanvas));
break;
default:
break;
}
NodeEditorGUI.Init();
}
bool autoSave = GUILayout.Toggle(autoSaveEnabled, "Auto Save");
if (autoSave != autoSaveEnabled)
{
autoSaveEnabled = autoSave;
PlayerPrefs.SetInt("NEAutoSave", autoSave ? 1 : 0);
PlayerPrefs.Save();
}
GUI.backgroundColor = Color.white;
GUILayout.EndHorizontal();
GUILayout.EndArea();
if (Event.current.type == EventType.Repaint)
{
toolbarHeight = 20;
}
}
}
public void DrawToolbarGUI()
{
GUILayout.BeginHorizontal(GUI.skin.GetStyle("toolbar"));
if (GUILayout.Button("File", GUI.skin.GetStyle("toolbarDropdown"), GUILayout.Width(50)))
{
GenericMenu menu = new GenericMenu(NodeEditorGUI.useUnityEditorToolbar && !Application.isPlaying);
// New Canvas filled with canvas types
NodeCanvasManager.FillCanvasTypeMenu(ref menu, NewNodeCanvas, "New Canvas/");
menu.AddSeparator("");
// Load / Save
#if UNITY_EDITOR
menu.AddItem(new GUIContent("Load Canvas"), false, LoadCanvas);
menu.AddItem(new GUIContent("Reload Canvas"), false, ReloadCanvas);
if (canvasCache.nodeCanvas.allowSceneSaveOnly)
{
menu.AddDisabledItem(new GUIContent("Save Canvas"));
menu.AddDisabledItem(new GUIContent("Save Canvas As"));
}
else
{
menu.AddItem(new GUIContent("Save Canvas"), false, SaveCanvas);
menu.AddItem(new GUIContent("Save Canvas As"), false, SaveCanvasAs);
}
menu.AddSeparator("");
// Scene Saving
string[] sceneSaves = NodeEditorSaveManager.GetSceneSaves();
if (sceneSaves.Length <= 0) // Display disabled item
{
menu.AddItem(new GUIContent("Load Canvas from Scene"), false, null);
}
else
{
foreach (string sceneSave in sceneSaves) // Display scene saves to load
{
menu.AddItem(new GUIContent("Load Canvas from Scene/" + sceneSave), false, LoadSceneCanvasCallback, sceneSave);
}
}
menu.AddItem(new GUIContent("Save Canvas to Scene"), false, SaveSceneCanvasCallback);
menu.Show(new Vector2(3, toolbarHeight + 3));
#endif
// Import / Export filled with import/export types
ImportExportManager.FillImportFormatMenu(ref menu, ImportCanvasCallback, "Import/");
if (canvasCache.nodeCanvas.allowSceneSaveOnly)
{
menu.AddDisabledItem(new GUIContent("Export"));
}
else
{
ImportExportManager.FillExportFormatMenu(ref menu, ExportCanvasCallback, "Export/");
}
menu.AddSeparator("");
// Show dropdown
menu.Show(new Vector2(3, toolbarHeight + 3));
}
GUILayout.Space(10);
GUILayout.FlexibleSpace();
GUILayout.Label(new GUIContent(canvasCache.nodeCanvas.saveName,
"Save Type: " + (canvasCache.nodeCanvas.livesInScene ? "Scene" : "Asset") + "\n" +
"Save Path: " + canvasCache.nodeCanvas.savePath), GUI.skin.GetStyle("toolbarLabel"));
GUILayout.Label(new GUIContent(canvasCache.typeData.DisplayString, "Canvas Type: " + canvasCache.typeData.DisplayString), GUI.skin.GetStyle("toolbarLabel"));
GUI.backgroundColor = new Color(1, 0.3f, 0.3f, 1);
/*if (GUILayout.Button("Reinit", GUI.skin.GetStyle("toolbarButton"), GUILayout.Width(100)))
* {
* NodeEditor.ReInit(true);
* NodeEditorGUI.CreateDefaultSkin();
* canvasCache.nodeCanvas.Validate();
* }*/
if (Application.isPlaying)
{
GUILayout.Space(5);
if (GUILayout.Button("Quit", GUI.skin.GetStyle("toolbarButton"), GUILayout.Width(100)))
{
Application.Quit();
}
}
GUI.backgroundColor = Color.white;
GUILayout.EndHorizontal();
if (Event.current.type == EventType.Repaint)
{
toolbarHeight = GUILayoutUtility.GetLastRect().yMax;
}
}
public ImportDummyCategories(ImportExportManager importExportManager, IDocumentService documentService, ISynchronousBatchRunExecution synchronousBatchRunExecution)
{
_importExportManager = importExportManager;
_documentService = documentService;
_synchronousBatchRunExecution = synchronousBatchRunExecution;
}
/// <summary>
/// Exports the environment variable.
/// </summary>
private void ExportEnvironmentVariable()
{
try
{
saveFileDialog.InitialDirectory
= Environment.SpecialFolder.MyDocuments.ToString();
if (saveFileDialog.ShowDialog() == DialogResult.OK)
{
EnvironmentVariable envVar = new EnvironmentVariable();
envVar.VarName = txtVariableName.Text;
envVar.VarValues
= this.EnvironmentVariableValue().ToString();
ImportExportManager importExportManager
= new ImportExportManager();
importExportManager.EnvVariable = envVar;
importExportManager.Save(saveFileDialog.FileName);
MessageBox.Show(
"'" + txtVariableName.Text
+ "' successfully exported to "
+ saveFileDialog.FileName + " file.",
"Export Success!",
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error!");
}
}
private async void ImportSettingsAction()
{
MetroDialogSettings settings = AppearanceManager.MetroDialog;
settings.AffirmativeButtonText = LocalizationManager.GetStringByKey("String_Button_Continue");
settings.NegativeButtonText = LocalizationManager.GetStringByKey("String_Button_Cancel");
settings.DefaultButtonFocus = MessageDialogResult.Affirmative;
string message = LocalizationManager.GetStringByKey("String_SelectedSettingsAreOverwritten");
if (ImportApplicationSettingsExists && (ImportEverything || ImportApplicationSettings))
{
message += Environment.NewLine + Environment.NewLine + string.Format("* {0}", LocalizationManager.GetStringByKey("String_ApplicationIsRestartedAfterwards"));
}
if (await dialogCoordinator.ShowMessageAsync(this, LocalizationManager.GetStringByKey("String_Header_AreYouSure"), message, MessageDialogStyle.AffirmativeAndNegative, settings) == MessageDialogResult.Affirmative)
{
List <ImportExportManager.ImportExportOptions> importOptions = new List <ImportExportManager.ImportExportOptions>();
if (ImportApplicationSettingsExists && (ImportEverything || ImportApplicationSettings))
{
importOptions.Add(ImportExportManager.ImportExportOptions.ApplicationSettings);
}
if (ImportNetworkInterfaceProfilesExists && (ImportEverything || ImportNetworkInterfaceProfiles))
{
importOptions.Add(ImportExportManager.ImportExportOptions.NetworkInterfaceProfiles);
// Load network interface profile (option: add)
if (NetworkInterfaceProfileManager.Profiles == null)
{
NetworkInterfaceProfileManager.Load(!ImportOverrideNetworkInterfaceProfiles);
}
}
if (ImportIPScannerProfilesExists && (ImportEverything || ImportIPScannerProfiles))
{
importOptions.Add(ImportExportManager.ImportExportOptions.IPScannerProfiles);
// Load ip scanner profiles (option: add)
if (IPScannerProfileManager.Profiles == null)
{
IPScannerProfileManager.Load(!ImportOverrideIPScannerProfiles);
}
}
if (ImportPingProfilesExists && (ImportEverything || ImportPingProfiles))
{
importOptions.Add(ImportExportManager.ImportExportOptions.PingProfiles);
// Load ping profiles (option: add)
if (PingProfileManager.Profiles == null)
{
PingProfileManager.Load(!ImportOverridePingProfiles);
}
}
if (ImportTracerouteProfilesExists && (ImportEverything || ImportTracerouteProfiles))
{
importOptions.Add(ImportExportManager.ImportExportOptions.TracerouteProfiles);
// Load traceroute profiles (option: add)
if (TracerouteProfileManager.Profiles == null)
{
TracerouteProfileManager.Load(!ImportOverrideTracerouteProfiles);
}
}
if (ImportPortScannerProfilesExists && (ImportEverything || ImportPortScannerProfiles))
{
importOptions.Add(ImportExportManager.ImportExportOptions.PortScannerProfiles);
// Load port scanner profiles (option: add)
if (PortScannerProfileManager.Profiles == null)
{
PortScannerProfileManager.Load(!ImportOverridePortScannerProfiles);
}
}
if (ImportRemoteDesktopSessionsExists && (ImportEverything || ImportRemoteDesktopSessions))
{
importOptions.Add(ImportExportManager.ImportExportOptions.RemoteDesktopSessions);
// Load remote desktop sessions (option: add)
if (RemoteDesktopSessionManager.Sessions == null)
{
RemoteDesktopSessionManager.Load(!ImportOverrideRemoteDesktopSessions);
}
}
if (ImportPuTTYSessionsExists && (ImportEverything || ImportPuTTYSessions))
{
importOptions.Add(ImportExportManager.ImportExportOptions.PuTTYSessions);
// Load remote desktop sessions (option: add)
if (PuTTYSessionManager.Sessions == null)
{
RemoteDesktopSessionManager.Load(!ImportOverridePuTTYSessions);
}
}
if (ImportWakeOnLANClientsExists && (ImportEverything || ImportWakeOnLANClients))
{
importOptions.Add(ImportExportManager.ImportExportOptions.WakeOnLANClients);
// Load WoL clients (option: add)
if (WakeOnLANClientManager.Clients == null)
{
WakeOnLANClientManager.Load(!ImportOverrideWakeOnLANClients);
}
}
// Import (copy) files from zip archive
ImportExportManager.Import(ImportFilePath, importOptions);
// Do the import (replace or add)
if (importOptions.Contains(ImportExportManager.ImportExportOptions.NetworkInterfaceProfiles))
{
NetworkInterfaceProfileManager.Import(ImportEverything || ImportOverrideNetworkInterfaceProfiles);
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.IPScannerProfiles))
{
IPScannerProfileManager.Import(ImportEverything || ImportOverrideIPScannerProfiles);
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.PortScannerProfiles))
{
PortScannerProfileManager.Import(ImportEverything || ImportOverridePortScannerProfiles);
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.PingProfiles))
{
PingProfileManager.Import(ImportEverything || ImportOverridePingProfiles);
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.TracerouteProfiles))
{
TracerouteProfileManager.Import(ImportEverything || ImportOverrideTracerouteProfiles);
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.RemoteDesktopSessions))
{
RemoteDesktopSessionManager.Import(ImportEverything || ImportOverrideRemoteDesktopSessions);
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.PuTTYSessions))
{
PuTTYSessionManager.Import(ImportEverything || ImportOverridePuTTYSessions);
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.WakeOnLANClients))
{
WakeOnLANClientManager.Import(ImportEverything || ImportOverrideWakeOnLANClients);
}
// Show the user a message what happened
if (!ImportExportManager.ForceRestart)
{
settings.AffirmativeButtonText = LocalizationManager.GetStringByKey("String_Button_OK");
message = LocalizationManager.GetStringByKey("String_SettingsSuccessfullyImported") + Environment.NewLine;
if (importOptions.Contains(ImportExportManager.ImportExportOptions.NetworkInterfaceProfiles))
{
message += Environment.NewLine + string.Format("* {0}", LocalizationManager.GetStringByKey("String_NetworkInterfaceProfilesReloaded"));
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.IPScannerProfiles))
{
message += Environment.NewLine + string.Format("* {0}", LocalizationManager.GetStringByKey("String_IPScannerProfilesReloaded"));
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.PortScannerProfiles))
{
message += Environment.NewLine + string.Format("* {0}", LocalizationManager.GetStringByKey("String_PortScannerProfilesReloaded"));
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.PingProfiles))
{
message += Environment.NewLine + string.Format("* {0}", LocalizationManager.GetStringByKey("String_PingProfilesReloaded"));
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.TracerouteProfiles))
{
message += Environment.NewLine + string.Format("* {0}", LocalizationManager.GetStringByKey("String_TracerouteProfilesReloaded"));
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.RemoteDesktopSessions))
{
message += Environment.NewLine + string.Format("* {0}", LocalizationManager.GetStringByKey("String_RemoteDesktopSessionsReloaded"));
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.PuTTYSessions))
{
message += Environment.NewLine + string.Format("* {0}", LocalizationManager.GetStringByKey("String_PuTTYSessionsReloaded"));
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.WakeOnLANClients))
{
message += Environment.NewLine + string.Format("* {0}", LocalizationManager.GetStringByKey("String_WakeOnLANClientsReloaded"));
}
await dialogCoordinator.ShowMessageAsync(this, LocalizationManager.GetStringByKey("String_Header_Success"), message, MessageDialogStyle.Affirmative, settings);
return;
}
// Close this view (this will restart the application)
CloseAction();
}
}
public void DrawToolbarGUI(Rect rect)
{
rect.height = toolbarHeight;
GUILayout.BeginArea(rect, NodeEditorGUI.toolbar);
GUILayout.BeginHorizontal();
float curToolbarHeight = 0;
if (GUILayout.Button("File", NodeEditorGUI.toolbarDropdown, GUILayout.Width(50)))
{
GenericMenu menu = new GenericMenu(!Application.isPlaying);
// New Canvas filled with canvas types
NodeCanvasManager.FillCanvasTypeMenu(ref menu, NewNodeCanvas, "New Canvas/");
menu.AddSeparator("");
// Load / Save
#if UNITY_EDITOR
menu.AddItem(new GUIContent("Load Canvas"), false, LoadCanvas);
menu.AddItem(new GUIContent("Reload Canvas"), false, ReloadCanvas);
menu.AddSeparator("");
if (canvasCache.nodeCanvas.allowSceneSaveOnly)
{
menu.AddDisabledItem(new GUIContent("Save Canvas"));
menu.AddDisabledItem(new GUIContent("Save Canvas As"));
}
else
{
menu.AddItem(new GUIContent("Save Canvas"), false, SaveCanvas);
menu.AddItem(new GUIContent("Save Canvas As"), false, SaveCanvasAs);
}
menu.AddSeparator("");
#endif
// Import / Export filled with import/export types
ImportExportManager.FillImportFormatMenu(ref menu, ImportCanvasCallback, "Import/");
if (canvasCache.nodeCanvas.allowSceneSaveOnly)
{
menu.AddDisabledItem(new GUIContent("Export"));
}
else
{
ImportExportManager.FillExportFormatMenu(ref menu, ExportCanvasCallback, "Export/");
}
menu.AddSeparator("");
// Scene Saving
string[] sceneSaves = NodeEditorSaveManager.GetSceneSaves();
if (sceneSaves.Length <= 0) // Display disabled item
{
menu.AddItem(new GUIContent("Load Canvas from Scene"), false, null);
}
else
{
foreach (string sceneSave in sceneSaves) // Display scene saves to load
{
menu.AddItem(new GUIContent("Load Canvas from Scene/" + sceneSave), false, LoadSceneCanvasCallback, sceneSave);
}
}
menu.AddItem(new GUIContent("Save Canvas to Scene"), false, SaveSceneCanvasCallback);
// Show dropdown
menu.Show(new Vector2(5, toolbarHeight));
}
curToolbarHeight = Mathf.Max(curToolbarHeight, GUILayoutUtility.GetLastRect().yMax);
GUILayout.Space(10);
GUILayout.FlexibleSpace();
GUILayout.Label(new GUIContent("" + canvasCache.nodeCanvas.saveName + " (" + (canvasCache.nodeCanvas.livesInScene ? "Scene Save" : "Asset Save") + ")",
"Opened Canvas path: " + canvasCache.nodeCanvas.savePath), NodeEditorGUI.toolbarLabel);
GUILayout.Label("Type: " + canvasCache.typeData.DisplayString, NodeEditorGUI.toolbarLabel);
curToolbarHeight = Mathf.Max(curToolbarHeight, GUILayoutUtility.GetLastRect().yMax);
GUI.backgroundColor = new Color(1, 0.3f, 0.3f, 1);
if (GUILayout.Button("Force Re-init", NodeEditorGUI.toolbarButton, GUILayout.Width(100)))
{
NodeEditor.ReInit(true);
canvasCache.nodeCanvas.Validate();
}
#if !UNITY_EDITOR
GUILayout.Space(5);
if (GUILayout.Button("Quit", NodeEditorGUI.toolbarButton, GUILayout.Width(100)))
{
Application.Quit();
}
#endif
curToolbarHeight = Mathf.Max(curToolbarHeight, GUILayoutUtility.GetLastRect().yMax);
GUI.backgroundColor = Color.white;
GUILayout.EndHorizontal();
GUILayout.EndArea();
if (Event.current.type == EventType.Repaint)
{
toolbarHeight = curToolbarHeight;
}
}
void Start()
{
ieManager = GetComponent<ImportExportManager>();
rManager = GetComponent<RouteManager>();
InvokeRepeating("StartCar",1,1);
}
private async void ImportSettingsAction()
{
MetroDialogSettings settings = AppearanceManager.MetroDialog;
settings.AffirmativeButtonText = Application.Current.Resources["String_Button_Continue"] as string;
settings.NegativeButtonText = Application.Current.Resources["String_Button_Cancel"] as string;
settings.DefaultButtonFocus = MessageDialogResult.Affirmative;
string message = Application.Current.Resources["String_SelectedSettingsAreOverwritten"] as string;
if (ImportApplicationSettingsExists && (ImportEverything || ImportApplicationSettings))
{
message += Environment.NewLine + Environment.NewLine + string.Format("* {0}", Application.Current.Resources["String_ApplicationIsRestartedAfterwards"] as string);
}
if (await dialogCoordinator.ShowMessageAsync(this, Application.Current.Resources["String_Header_AreYouSure"] as string, message, MessageDialogStyle.AffirmativeAndNegative, settings) == MessageDialogResult.Affirmative)
{
List <ImportExportManager.ImportExportOptions> importOptions = new List <ImportExportManager.ImportExportOptions>();
if (ImportApplicationSettingsExists && (ImportEverything || ImportApplicationSettings))
{
importOptions.Add(ImportExportManager.ImportExportOptions.ApplicationSettings);
}
if (ImportNetworkInterfaceProfilesExists && (ImportEverything || ImportNetworkInterfaceProfiles))
{
importOptions.Add(ImportExportManager.ImportExportOptions.NetworkInterfaceProfiles);
}
if (ImportWakeOnLANClientsExists && (ImportEverything || ImportWakeOnLANClients))
{
importOptions.Add(ImportExportManager.ImportExportOptions.WakeOnLANClients);
}
// Load network interface profile (option: add)
if (NetworkInterfaceProfileManager.Profiles == null)
{
NetworkInterfaceProfileManager.Load(!ImportOverrideNetworkInterfaceProfiles);
}
// Load WoL clients (option: add)
if (WakeOnLANClientManager.Clients == null)
{
WakeOnLANClientManager.Load(!ImportOverrideWakeOnLANClients);
}
// Import (copy) files from zip archive
ImportExportManager.Import(ImportLocationSelectedPath, importOptions);
// Do the import (replace or add)
if (importOptions.Contains(ImportExportManager.ImportExportOptions.NetworkInterfaceProfiles))
{
NetworkInterfaceProfileManager.Import(ImportEverything || ImportOverrideNetworkInterfaceProfiles);
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.WakeOnLANClients))
{
WakeOnLANClientManager.Import(ImportEverything || ImportOverrideWakeOnLANClients);
}
// Show the user a message what happened
if (!ImportExportManager.ForceRestart)
{
settings.AffirmativeButtonText = Application.Current.Resources["String_Button_OK"] as string;
message = Application.Current.Resources["String_SettingsSuccessfullyImported"] as string + Environment.NewLine;
if (importOptions.Contains(ImportExportManager.ImportExportOptions.NetworkInterfaceProfiles))
{
message += Environment.NewLine + string.Format("* {0}", Application.Current.Resources["String_NetworkInterfaceProfilesReloaded"] as string);
}
if (importOptions.Contains(ImportExportManager.ImportExportOptions.WakeOnLANClients))
{
message += Environment.NewLine + string.Format("* {0}", Application.Current.Resources["String_WakeOnLANClientsReloaded"] as string);
}
await dialogCoordinator.ShowMessageAsync(this, Application.Current.Resources["String_Header_Success"] as string, message, MessageDialogStyle.Affirmative, settings);
return;
}
// Close this view (this will restart the application)
CloseAction();
}
}
