private void cmdOK_Click(object sender, EventArgs e)
{
try
{
if (SelectedEntry == null)
{
SelectedEntry = new NotifierEntry();
}
SelectedEntry.Name = txtName.Text;
SelectedEntry.Enabled = chkEnabled.Checked;
SelectedEntry.AlertLevel = (AlertLevel)cboAlertLevel.SelectedIndex;
SelectedEntry.DetailLevel = (DetailLevel)cboDetailLevel.SelectedIndex;
SelectedEntry.NotifierRegistrationName = editingNotifierEntry.NotifierRegistrationName;
SelectedEntry.InitialConfiguration = editingNotifierEntry.InitialConfiguration;
SelectedEntry.AlertForCollectors.Clear();
if (editingNotifierEntry.AlertForCollectors != null && editingNotifierEntry.AlertForCollectors.Count > 0)
{
SelectedEntry.AlertForCollectors.AddRange(editingNotifierEntry.AlertForCollectors.ToArray());
}
SelectedEntry.AttendedOptionOverride = (AttendedOption)cboAttendedOptionOverride.SelectedIndex;
SelectedEntry.ServiceWindows.CreateFromConfig(editingNotifierEntry.ServiceWindows.ToConfig());
SelectedEntry.ConfigVariables = new List <ConfigVariable>();
SelectedEntry.ConfigVariables.AddRange((from ConfigVariable cv in editingNotifierEntry.ConfigVariables
select cv.Clone()).ToArray());
SelectedEntry.CreateAndConfigureEntry(SelectedEntry.NotifierRegistrationName);
DialogResult = System.Windows.Forms.DialogResult.OK;
Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
internal void FaceButtonPress(Gamepad gamePad)
{
if (gamePad.Buttons == 0)
{
return;
}
if (gamePad.Buttons == LaunchButton && !_cemuRunning())
{
SelectedEntry.PlayTitle();
}
if (!gamePad.Buttons.HasFlag(GamepadButtonFlags.Start) ||
!gamePad.Buttons.HasFlag(GamepadButtonFlags.Back) ||
!_cemuRunning())
{
return;
}
var cemuPath = Path.Combine(Settings.CemuDirectory, "cemu.exe");
var fileName = Path.GetFileName(cemuPath).Replace(".exe", "");
foreach (var cemuProcess in Process.GetProcessesByName(fileName))
{
cemuProcess.Kill();
}
}
private void AddWordMethod()
{
if (SelectedEntry != null)
{
DictWordModel.DictWords.Add(new string(SelectedEntry.ToCharArray()));
}
}
private void OnExport()
{
Skeleton skele;
ModelDefinition model;
ImcVariant variant;
int m, b;
if (!TryGetModel(out skele, out model, out variant, out m, out b))
{
return;
}
List <PapFile> paps = SearchPaps(model.File.Path, m);
VistaFolderBrowserDialog dialog = new VistaFolderBrowserDialog
{
Description = "Select folder to export to",
UseDescriptionForTitle = true
};
bool?result = dialog.ShowDialog();
if (result.HasValue && result.Value && !string.IsNullOrEmpty(dialog.SelectedPath))
{
Task.Run(() =>
{
string identifier = SelectedEntry.ToString().Replace(" / ", "_");
string folderName = Path.Combine(dialog.SelectedPath, identifier);
Directory.CreateDirectory(folderName);
string fileName = Path.Combine(folderName, identifier + ".fbx");
// Set IsExporting for feedback
IsExporting = true;
int exportResult = FbxExport.ExportFbx(fileName, model.GetModel(0).Meshes, skele, paps);
FbxExport.ExportMonsterMaterials(Parent.Realm, folderName, model.GetModel(0).Definition.Materials, variant);
IsExporting = false;
if (exportResult == 0)
{
System.Windows.MessageBox.Show("The export of " + Path.GetFileName(fileName) + " has completed.",
"Export Complete",
MessageBoxButton.OK,
MessageBoxImage.Information,
MessageBoxResult.OK,
System.Windows.MessageBoxOptions.DefaultDesktopOnly);
}
else
{
System.Windows.MessageBox.Show("The export of " + Path.GetFileName(fileName) + " has failed.",
"Export Failed",
MessageBoxButton.OK,
MessageBoxImage.Error,
MessageBoxResult.OK,
System.Windows.MessageBoxOptions.DefaultDesktopOnly);
}
});
}
}
public void CheckInput(InputState input)
{
//Check all the input
if (input.IsMenuUp(ControllingPlayer))
{
// Move to the previous menu entry
MenuUp();
}
else if (input.IsMenuDown(ControllingPlayer))
{
// Move to the next menu entry
MenuDown();
}
//checkl the left/right messages
if (input.IsMenuLeft(ControllingPlayer))
{
//send a left message to the current menu entry
MenuLeft();
}
else if (input.IsMenuRight(ControllingPlayer))
{
//send a right message to the current menu entry
MenuRight();
}
// Accept or cancel the menu? We pass in our ControllingPlayer, which may
// either be null (to accept input from any player) or a specific index.
// If we pass a null controlling player, the InputState helper returns to
// us which player actually provided the input. We pass that through to
// OnSelectEntry and OnCancel, so they can tell which player triggered them.
PlayerIndex playerIndex;
if (input.IsMenuSelect(ControllingPlayer, out playerIndex))
{
if (null != SelectedEntry)
{
SelectedEntry.Clicked(this, new ClickEventArgs
{
PlayerIndex = playerIndex
});
}
}
else if (input.IsMenuCancel(ControllingPlayer, out playerIndex))
{
Cancelled(this, new ClickEventArgs
{
PlayerIndex = playerIndex
});
}
if (null != SelectedEntry)
{
SelectedEntry.IsHighlighted = IsActive;
}
}
public DialogResult ShowDialog(MonitorPack monitorPack)
{
this.monitorPack = monitorPack;
editingCollectorEntry = CollectorEntry.FromConfig(SelectedEntry.ToConfig());
if (SelectedEntry.Collector != null)
{
monitorPack.ApplyCollectorConfig(editingCollectorEntry);
}
return(ShowDialog());
}
private void OnAdd()
{
Skeleton skele;
ModelDefinition model;
ImcVariant variant;
int m, b;
if (TryGetModel(out skele, out model, out variant, out m, out b))
{
Parent.EngineHelper.AddToLast(SelectedEntry.ToString(), (e) => CreateModel(e, skele, model, variant, m, b));
}
}
protected void BuildHistoryControl(int loadAhead, List <GitLogEntry> gitLogEntries)
{
if (HistoryControl == null)
{
HistoryControl = new HistoryControl();
}
HistoryControl.Load(loadAhead, gitLogEntries);
if (!SelectedEntry.Equals(GitLogEntry.Default) &&
SelectedEntry.CommitID != HistoryControl.SelectedGitLogEntry.CommitID)
{
SelectedEntry = GitLogEntry.Default;
}
}
private void addCollectorConfigEntryToolStripButton_Click(object sender, EventArgs e)
{
if (currentEditingEntry.Collector != null && currentEditingEntry.Collector.AgentConfig != null)
{
ICollectorConfig currentConfig = (ICollectorConfig)currentEditingEntry.Collector.AgentConfig;
ICollectorConfigEntry entry = null;
if (SelectedEntry.ShowEditConfigEntry(ref entry))
{
if (entry != null)
{
currentConfig.Entries.Add(entry);
}
currentEditingEntry.InitialConfiguration = currentEditingEntry.Collector.AgentConfig.ToConfig();
ApplyConfigToControls();
}
}
}
private void EditEntry(object param)
{
AddEntryModel entryModel = Controller.EditEntryByUser(SelectedEntry.Clone());
if (entryModel == null || entryModel.DialogResult != true)
{
return;
}
Entry entry = entryModel.Entry;
//Replace selectedEntry with new entry
_storage.EditEntry(SelectedCategory, SelectedEntry, entry);
//Replace old entry with new entry in the entries
SelectedCategory.Entries[SelectedCategory.Entries.IndexOf(SelectedEntry)] = entry;
SelectedEntry = entry;
}
private void customTreeViewEx_AfterSelect(object sender, TreeViewEventArgs e)
{
SelectedEntry = e.Node.Tag as PwEntry;
// Set constraint flag from selected item
mConfirmConstraintControl.Checked =
SelectedEntry.GetKeeAgentSettings().UseConfirmConstraintWhenAdding;
// Set lifetime flag from selected item; also, if item does have a
// lifetime, set the lifetime duration
mLifetimeConstraintControl.Checked =
SelectedEntry.GetKeeAgentSettings().UseLifetimeConstraintWhenAdding;
if (mLifetimeConstraintControl.Checked)
{
mLifetimeConstraintControl.Lifetime =
SelectedEntry.GetKeeAgentSettings().LifetimeConstraintDuration;
}
}
/// <summary>
/// </summary>
private void DeleteEntry()
{
// Ask for confirmation.
var result = MessageBox.Show("Weet je zeker dat je deze post wilt verwijderen?", "Bookkeeping", MessageBoxButton.YesNoCancel);
if (result == MessageBoxResult.Yes)
{
// Delete entry
var rootInList = GetRootEntryOf(SelectedEntry);
mEntryDataService.Delete(SelectedEntry.ToEntity());
if (rootInList != null)
{
rootInList.DeleteChild(SelectedEntry);
}
mEntriesHaveChanged = true;
}
}
/// <summary> Constructor with name, bounds and optional text </summary>
public GLTextBoxAutoComplete(string name, Rectangle pos, string text = "") : base(name, pos, text)
{
MultiLineMode = false;
waitforautotimer.Tick += InitialDelayOver;
autocompleteinuitimer.Tick += AutoCompleteInUI;
triggercomplete.Tick += AutoCompleteFinished;
ListBox.AutoSize = true;
ListBox.SelectedIndexChanged += (c0, i) => {
Text = ListBox.SelectedItem;
CancelAutoComplete();
SelectedEntry?.Invoke(this);
};
ListBox.OtherKeyPressed += (c1, e) => { if (e.KeyCode == System.Windows.Forms.Keys.Delete)
{
CancelAutoComplete();
}
};
ListBox.Name = name + "_LB";
ListBox.TopMost = true;
ListBox.ShowFocusHighlight = true;
}
/// <inheritdoc cref="GLOFC.GL4.Controls.GLBaseControl.OnKeyDown(GLKeyEventArgs)"/>
protected override void OnKeyDown(GLKeyEventArgs e)
{
base.OnKeyDown(e);
if (!e.Handled)
{
if (ListBox.Visible)
{
if (e.KeyCode == System.Windows.Forms.Keys.Up)
{
ListBox.FocusUp();
}
else if (e.KeyCode == System.Windows.Forms.Keys.Down)
{
ListBox.FocusDown();
}
else if (e.KeyCode == System.Windows.Forms.Keys.PageUp)
{
ListBox.FocusUp(ListBox?.DisplayableItems ?? 0);
}
else if (e.KeyCode == System.Windows.Forms.Keys.PageDown)
{
ListBox.FocusDown(ListBox?.DisplayableItems ?? 0);
}
}
if (e.KeyCode == System.Windows.Forms.Keys.Enter || e.KeyCode == System.Windows.Forms.Keys.Return)
{
if (ListBox.Visible && ListBox.FocusIndex >= 0) // if we are showing list and there is a focus, we use that
{
ListBox.SelectCurrentFocus();
}
else
{
CancelAutoComplete(); // close any list box, and select this text, may be empty
SelectedEntry?.Invoke(this);
}
}
}
}
public DialogResult ShowDialog(MonitorPack monitorPack)
{
if (SelectedEntry == null)
{
return(System.Windows.Forms.DialogResult.Cancel);
}
else
{
this.monitorPack = monitorPack;
editingNotifierEntry = NotifierEntry.FromConfig(SelectedEntry.ToConfig());
try
{
//Create Notifier instance but do not apply Config Variables!
editingNotifierEntry.CreateAndConfigureEntry(editingNotifierEntry.NotifierRegistrationName, "", false);
return(ShowDialog());
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Loading", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(System.Windows.Forms.DialogResult.Cancel);
}
}
}
public DialogResult ShowDialog(MonitorPack monitorPack)
{
if (KnownRemoteHosts == null)
{
KnownRemoteHosts = new List <string>();
}
if (SelectedEntry == null)
{
return(System.Windows.Forms.DialogResult.Cancel);
}
else
{
this.monitorPack = monitorPack;
currentEditingEntry = CollectorEntry.FromConfig(SelectedEntry.ToConfig());
try
{
//Create Collector instance but do not apply Config Variables!
currentEditingEntry.CreateAndConfigureEntry(currentEditingEntry.CollectorRegistrationName, "", false, false);
ApplyConfigToControls();
txtName.Text = currentEditingEntry.Name;
chkEnabled.Checked = currentEditingEntry.Enabled;
chkExpandOnStart.Checked = currentEditingEntry.ExpandOnStart;
lblId.Text = currentEditingEntry.UniqueId;
llblCollectorType.Text = currentEditingEntry.CollectorRegistrationDisplayName;
chkRemoteAgentEnabled.Checked = currentEditingEntry.EnableRemoteExecute;
chkForceRemoteExcuteOnChildCollectors.Checked = currentEditingEntry.ForceRemoteExcuteOnChildCollectors;
txtRemoteAgentServer.Text = currentEditingEntry.RemoteAgentHostAddress;
remoteportNumericUpDown.SaveValueSet(currentEditingEntry.RemoteAgentHostPort);
chkBlockParentRHOverride.Checked = currentEditingEntry.BlockParentOverrideRemoteAgentHostSettings;
chkRunLocalOnRemoteHostConnectionFailure.Checked = currentEditingEntry.RunLocalOnRemoteHostConnectionFailure;
try
{
chkEnablePollingOverride.Checked = currentEditingEntry.EnabledPollingOverride;
onlyAllowUpdateOncePerXSecNumericUpDown.SaveValueSet(currentEditingEntry.OnlyAllowUpdateOncePerXSec);
chkEnablePollingFrequencySliding.Checked = currentEditingEntry.EnablePollFrequencySliding;
pollSlideFrequencyAfterThirdRepeatSecNumericUpDown.SaveValueSet(currentEditingEntry.PollSlideFrequencyAfterThirdRepeatSec);
pollSlideFrequencyAfterSecondRepeatSecNumericUpDown.SaveValueSet(currentEditingEntry.PollSlideFrequencyAfterSecondRepeatSec);
pollSlideFrequencyAfterFirstRepeatSecNumericUpDown.SaveValueSet(currentEditingEntry.PollSlideFrequencyAfterFirstRepeatSec);
}
catch { }
PollingOverrideControlsEnable();
numericUpDownRepeatAlertInXMin.SaveValueSet(currentEditingEntry.RepeatAlertInXMin);
numericUpDownRepeatAlertInXPolls.SaveValueSet(currentEditingEntry.RepeatAlertInXPolls);
AlertOnceInXMinNumericUpDown.SaveValueSet(currentEditingEntry.AlertOnceInXMin);
AlertOnceInXPollsNumericUpDown.SaveValueSet(currentEditingEntry.AlertOnceInXPolls);
delayAlertSecNumericUpDown.SaveValueSet(currentEditingEntry.DelayErrWarnAlertForXSec);
delayAlertPollsNumericUpDown.SaveValueSet(currentEditingEntry.DelayErrWarnAlertForXPolls);
chkCollectOnParentWarning.Checked = currentEditingEntry.CollectOnParentWarning;
chkAlertsPaused.Checked = currentEditingEntry.AlertsPaused;
chkCorrectiveScriptDisabled.Checked = currentEditingEntry.CorrectiveScriptDisabled;
txtCorrectiveScriptOnWarning.Text = currentEditingEntry.CorrectiveScriptOnWarningPath;
txtCorrectiveScriptOnError.Text = currentEditingEntry.CorrectiveScriptOnErrorPath;
txtRestorationScript.Text = currentEditingEntry.RestorationScriptPath;
chkOnlyRunCorrectiveScriptsOnStateChange.Checked = currentEditingEntry.CorrectiveScriptsOnlyOnStateChange;
linkLabelServiceWindows.Text = currentEditingEntry.ServiceWindows.ToString();
LoadParentCollectorList();
CheckOkEnabled();
return(ShowDialog());
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Loading", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(System.Windows.Forms.DialogResult.Cancel);
}
}
}
protected void DoHistoryGui(Rect rect, Action <GitLogEntry> historyControlRightClick = null,
Action <ChangesTreeNode> changesTreeRightClick = null)
{
if (HistoryControl != null)
{
var historyControlRect = new Rect(0f, 0f, Position.width, Position.height - rect.height);
var requiresRepaint = HistoryControl.Render(historyControlRect,
singleClick: entry => {
SelectedEntry = entry;
BuildTreeChanges();
},
doubleClick: entry => {
},
rightClick: historyControlRightClick);
if (requiresRepaint)
{
Redraw();
}
}
DoProgressGUI();
if (!SelectedEntry.Equals(GitLogEntry.Default))
{
// Top bar for scrolling to selection or clearing it
GUILayout.BeginHorizontal(EditorStyles.toolbar);
{
if (GUILayout.Button(CommitDetailsTitle, Styles.ToolbarButtonStyle))
{
HistoryControl.ScrollTo(HistoryControl.SelectedIndex);
}
if (GUILayout.Button(ClearSelectionButton, Styles.ToolbarButtonStyle, GUILayout.ExpandWidth(false)))
{
SelectedEntry = GitLogEntry.Default;
HistoryControl.SelectedIndex = -1;
}
}
GUILayout.EndHorizontal();
// Log entry details - including changeset tree (if any changes are found)
DetailsScroll = GUILayout.BeginScrollView(DetailsScroll, GUILayout.Height(250));
{
HistoryDetailsEntry(SelectedEntry);
GUILayout.Space(EditorGUIUtility.standardVerticalSpacing);
GUILayout.Label("Files changed", EditorStyles.boldLabel);
GUILayout.Space(-5);
rect = GUILayoutUtility.GetLastRect();
GUILayout.BeginHorizontal(Styles.HistoryFileTreeBoxStyle);
GUILayout.BeginVertical();
{
var borderLeft = Styles.Label.margin.left;
var treeControlRect = new Rect(rect.x + borderLeft, rect.y, Position.width - borderLeft * 2,
Position.height - rect.height + Styles.CommitAreaPadding);
var treeRect = new Rect(0f, 0f, 0f, 0f);
if (TreeChanges != null)
{
TreeChanges.FolderStyle = Styles.Foldout;
TreeChanges.TreeNodeStyle = Styles.TreeNode;
TreeChanges.ActiveTreeNodeStyle = Styles.ActiveTreeNode;
TreeChanges.FocusedTreeNodeStyle = Styles.FocusedTreeNode;
TreeChanges.FocusedActiveTreeNodeStyle = Styles.FocusedActiveTreeNode;
treeRect = TreeChanges.Render(treeControlRect, DetailsScroll,
singleClick: node => { },
doubleClick: node => { },
rightClick: changesTreeRightClick);
if (TreeChanges.RequiresRepaint)
{
Redraw();
}
}
GUILayout.Space(treeRect.y - treeControlRect.y);
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.Space(EditorGUIUtility.standardVerticalSpacing);
}
GUILayout.EndScrollView();
}
}
private void cmdOK_Click(object sender, EventArgs e)
{
if (SelectedEntry == null)
{
SelectedEntry = new CollectorEntry();
}
SelectedEntry.Name = txtName.Text;
SelectedEntry.Enabled = chkEnabled.Checked;
SelectedEntry.ExpandOnStart = chkExpandOnStart.Checked;
SelectedEntry.IsFolder = currentEditingEntry.IsFolder;
if (cboParentCollector.SelectedIndex > 0)
{
CollectorEntryDisplay ced = (CollectorEntryDisplay)cboParentCollector.SelectedItem;
SelectedEntry.ParentCollectorId = ced.CE.UniqueId;
}
else
{
SelectedEntry.ParentCollectorId = "";
}
SelectedEntry.CollectOnParentWarning = chkCollectOnParentWarning.Checked && !SelectedEntry.IsFolder;
//Collector type
SelectedEntry.CollectorRegistrationName = currentEditingEntry.CollectorRegistrationName;
SelectedEntry.CollectorRegistrationDisplayName = currentEditingEntry.CollectorRegistrationDisplayName;
//Remote agents
SelectedEntry.EnableRemoteExecute = chkRemoteAgentEnabled.Checked;
SelectedEntry.ForceRemoteExcuteOnChildCollectors = chkForceRemoteExcuteOnChildCollectors.Checked;
SelectedEntry.RemoteAgentHostAddress = txtRemoteAgentServer.Text;
SelectedEntry.RemoteAgentHostPort = (int)remoteportNumericUpDown.Value;
SelectedEntry.BlockParentOverrideRemoteAgentHostSettings = chkBlockParentRHOverride.Checked && !chkRemoteAgentEnabled.Checked;
SelectedEntry.RunLocalOnRemoteHostConnectionFailure = chkRunLocalOnRemoteHostConnectionFailure.Checked;
if (chkRemoteAgentEnabled.Checked && SelectedEntry.RemoteAgentHostAddress.Length > 0)
{
if (KnownRemoteHosts == null)
{
KnownRemoteHosts = new List <string>();
}
if ((from string rh in KnownRemoteHosts
where rh.ToLower() == SelectedEntry.RemoteAgentHostAddress.ToLower() + ":" + SelectedEntry.RemoteAgentHostPort.ToString()
select rh).Count() == 0
)
{
KnownRemoteHosts.Add(SelectedEntry.RemoteAgentHostAddress + ":" + SelectedEntry.RemoteAgentHostPort.ToString());
}
}
//Polling overrides
if (onlyAllowUpdateOncePerXSecNumericUpDown.Value >= pollSlideFrequencyAfterFirstRepeatSecNumericUpDown.Value)
{
pollSlideFrequencyAfterFirstRepeatSecNumericUpDown.Value = onlyAllowUpdateOncePerXSecNumericUpDown.Value + 1;
}
if (pollSlideFrequencyAfterFirstRepeatSecNumericUpDown.Value >= pollSlideFrequencyAfterSecondRepeatSecNumericUpDown.Value)
{
pollSlideFrequencyAfterSecondRepeatSecNumericUpDown.Value = pollSlideFrequencyAfterFirstRepeatSecNumericUpDown.Value + 1;
}
if (pollSlideFrequencyAfterSecondRepeatSecNumericUpDown.Value >= pollSlideFrequencyAfterThirdRepeatSecNumericUpDown.Value)
{
pollSlideFrequencyAfterThirdRepeatSecNumericUpDown.Value = pollSlideFrequencyAfterSecondRepeatSecNumericUpDown.Value + 1;
}
SelectedEntry.EnabledPollingOverride = chkEnablePollingOverride.Checked;
SelectedEntry.OnlyAllowUpdateOncePerXSec = (int)onlyAllowUpdateOncePerXSecNumericUpDown.Value;
SelectedEntry.EnablePollFrequencySliding = chkEnablePollingFrequencySliding.Checked;
SelectedEntry.PollSlideFrequencyAfterFirstRepeatSec = (int)pollSlideFrequencyAfterFirstRepeatSecNumericUpDown.Value;
SelectedEntry.PollSlideFrequencyAfterSecondRepeatSec = (int)pollSlideFrequencyAfterSecondRepeatSecNumericUpDown.Value;
SelectedEntry.PollSlideFrequencyAfterThirdRepeatSec = (int)pollSlideFrequencyAfterThirdRepeatSecNumericUpDown.Value;
//Alert suppresion
SelectedEntry.AlertsPaused = chkAlertsPaused.Checked;
SelectedEntry.RepeatAlertInXMin = (int)numericUpDownRepeatAlertInXMin.Value;
SelectedEntry.RepeatAlertInXPolls = (int)numericUpDownRepeatAlertInXPolls.Value;
SelectedEntry.AlertOnceInXMin = (int)AlertOnceInXMinNumericUpDown.Value;
SelectedEntry.AlertOnceInXPolls = (int)AlertOnceInXPollsNumericUpDown.Value;
SelectedEntry.DelayErrWarnAlertForXSec = (int)delayAlertSecNumericUpDown.Value;
SelectedEntry.DelayErrWarnAlertForXPolls = (int)delayAlertPollsNumericUpDown.Value;
//Corrective scripts
SelectedEntry.CorrectiveScriptDisabled = chkCorrectiveScriptDisabled.Checked;
SelectedEntry.CorrectiveScriptOnWarningPath = txtCorrectiveScriptOnWarning.Text;
SelectedEntry.CorrectiveScriptOnErrorPath = txtCorrectiveScriptOnError.Text;
SelectedEntry.RestorationScriptPath = txtRestorationScript.Text;
SelectedEntry.CorrectiveScriptsOnlyOnStateChange = chkOnlyRunCorrectiveScriptsOnStateChange.Checked;
//Service windows
SelectedEntry.ServiceWindows.CreateFromConfig(currentEditingEntry.ServiceWindows.ToConfig());
SelectedEntry.ConfigVariables = new List <ConfigVariable>();
SelectedEntry.ConfigVariables.AddRange((from ConfigVariable cv in currentEditingEntry.ConfigVariables
select cv.Clone()).ToArray());
if (SelectedEntry.IsFolder)
{
SelectedEntry.Collector = null;
}
else
{
SelectedEntry.InitialConfiguration = currentEditingEntry.InitialConfiguration;
RegisteredAgent currentRA = null;
currentRA = RegisteredAgentCache.GetRegisteredAgentByClassName("." + SelectedEntry.CollectorRegistrationName);
if (currentRA != null)
{
try
{
SelectedEntry.CreateAndConfigureEntry(currentRA, monitorPack.ConfigVariables);
}
catch (Exception ex)
{
SelectedEntry.LastMonitorState.State = CollectorState.ConfigurationError;
SelectedEntry.Enabled = false;
SelectedEntry.LastMonitorState.RawDetails = ex.Message;
}
}
else
{
SelectedEntry.LastMonitorState.State = CollectorState.ConfigurationError;
SelectedEntry.Enabled = false;
SelectedEntry.LastMonitorState.RawDetails = string.Format("Collector '{0}' cannot be loaded as the type '{1}' is not registered!", SelectedEntry.Name, SelectedEntry.CollectorRegistrationName);
}
}
DialogResult = System.Windows.Forms.DialogResult.OK;
Close();
}
private void OnExport()
{
Skeleton skele;
ModelDefinition model;
ImcVariant variant;
int m, b;
if (!TryGetModel(out skele, out model, out variant, out m, out b))
{
return;
}
var papPath = string.Format(PapPathFormat, m, b);
PapFile pap = null;
// We have animation
if (Parent.Realm.Packs.TryGetFile(papPath, out var papFileBase))
{
pap = new PapFile(papFileBase);
}
VistaSaveFileDialog dialog = new VistaSaveFileDialog {
OverwritePrompt = true,
Title = "Export FBX to...",
FileName = SelectedEntry.ToString().Replace(" / ", "_"),
DefaultExt = ".fbx",
Filter = "Autodesk FBX Files|*.fbx"
};
bool?result = dialog.ShowDialog();
if (result.HasValue && result.Value && !string.IsNullOrEmpty(dialog.FileName))
{
Task.Run(() =>
{
// Set IsExporting for feedback
IsExporting = true;
int exportResult = FbxExport.ExportFbx(dialog.FileName, model.GetModel(0).Meshes, skele, pap);
IsExporting = false;
if (exportResult == 0)
{
System.Windows.MessageBox.Show("The export of " + Path.GetFileName(dialog.FileName) + " has completed.",
"Export Complete",
MessageBoxButton.OK,
MessageBoxImage.Information,
MessageBoxResult.OK,
System.Windows.MessageBoxOptions.DefaultDesktopOnly);
}
else
{
System.Windows.MessageBox.Show("The export of " + Path.GetFileName(dialog.FileName) + " has failed.",
"Export Failed",
MessageBoxButton.OK,
MessageBoxImage.Error,
MessageBoxResult.OK,
System.Windows.MessageBoxOptions.DefaultDesktopOnly);
}
});
}
}
private void DemoBitmapMenuItem_Click(object sender, System.EventArgs e)
{
MessageBox.Show(SelectedEntry.ToString());
}
