/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
string[] processed = ProcessParameters(variables, Parameters);
using (Process process = new Process())
{
process.StartInfo.FileName = processed[0];
process.StartInfo.WorkingDirectory = processed[1];
process.StartInfo.Arguments = processed[2];
process.StartInfo.WindowStyle = (ProcessWindowStyle) Enum.Parse(typeof (ProcessWindowStyle), processed[3], true);
process.StartInfo.CreateNoWindow = bool.Parse(processed[4]);
process.StartInfo.UseShellExecute = bool.Parse(processed[5]);
//process.PriorityClass = ProcessPriorityClass.
bool waitForExit = bool.Parse(processed[6]);
bool forceFocus = bool.Parse(processed[7]);
process.Start();
// Give new process focus ...
if (forceFocus && !process.StartInfo.CreateNoWindow &&
process.StartInfo.WindowStyle != ProcessWindowStyle.Hidden)
{
//FocusForcer forcer = new FocusForcer(process.Id);
//forcer.Start();
//forcer.Force();
}
if (waitForExit)
process.WaitForExit();
}
}
/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
string[] processed = ProcessParameters(variables, Parameters);
string windowID = processed[0];
int window = (int) GUIWindow.Window.WINDOW_INVALID;
try
{
window = (int) Enum.Parse(typeof (GUIWindow.Window), "WINDOW_" + windowID, true);
}
catch (ArgumentException)
{
// Parsing the window id as a GUIWindow.Window failed, so parse it as an int
}
if (window == (int) GUIWindow.Window.WINDOW_INVALID)
int.TryParse(windowID, out window);
if (window == (int) GUIWindow.Window.WINDOW_INVALID)
throw new CommandStructureException(String.Format("Failed to parse Goto screen command window id \"{0}\"",
windowID));
GUIGraphicsContext.ResetLastActivity();
GUIWindowManager.SendThreadMessage(new GUIMessage(GUIMessage.MessageType.GUI_MSG_GOTO_WINDOW, 0, 0, 0, window, 0,
null));
}
protected ConstraintVar( Solver solver, Variable[] varList, VariableList[] varListList )
: base(solver)
{
m_VariableList = varList;
m_VariableListList = varListList;
OnSet();
}
/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
string[] processed = ProcessParameters(variables, Parameters);
int timeout = int.Parse(processed[2]);
PopupMessage popup = new PopupMessage(processed[0], processed[1], timeout);
popup.ShowDialog();
}
internal void DropEdge(GremlinVariable dropEdgeVariable)
{
var sourceProperty = dropEdgeVariable.GetVariableProperty(GremlinKeyword.EdgeSourceV);
var edgeProperty = dropEdgeVariable.GetVariableProperty(GremlinKeyword.EdgeID);
GremlinDropVariable dropVariable = new GremlinDropEdgeVariable(sourceProperty, edgeProperty);
VariableList.Add(dropVariable);
TableReferences.Add(dropVariable);
SetPivotVariable(dropVariable);
}
public HeroClass(HeroType type = null)
{
Type = new HeroType(HeroTypes.Class);
Variables = new VariableList();
if (type != null)
{
Type.Id = type.Id;
}
hasValue = false;
}
/// <summary>
/// Default ctor
/// </summary>
public MethodEntry(string name, string signature, string dexName, string dexSignature, int mapFileId)
{
this.name = name;
this.signature = signature;
this.dexName = dexName;
this.dexSignature = dexSignature;
this.mapFileId = mapFileId;
variables = new VariableList();
parameters = new ParameterList();
}
/// <summary>
/// XML ctor
/// </summary>
internal MethodEntry(XElement e)
{
name = e.GetAttribute("name");
signature = e.GetAttribute("signature");
dexName = e.GetAttribute("dname");
dexSignature = e.GetAttribute("dsignature");
mapFileId = int.Parse(e.GetAttribute("id") ?? "0");
variables = new VariableList(e);
parameters = new ParameterList(e);
}
internal void BothV(GremlinVariable lastVariable)
{
GremlinVariableProperty sourceProperty = lastVariable.GetVariableProperty(GremlinKeyword.EdgeSourceV);
GremlinVariableProperty sinkProperty = lastVariable.GetVariableProperty(GremlinKeyword.EdgeSinkV);
GremlinBoundVertexVariable bothVertex = new GremlinBoundVertexVariable(lastVariable.GetEdgeType(), sourceProperty, sinkProperty);
VariableList.Add(bothVertex);
TableReferences.Add(bothVertex);
SetPivotVariable(bothVertex);
}
public VariableList[] Copy( VariableList[] other )
{
VariableList[] copy = new VariableList[ other.Length ];
for( int idx = 0; idx < other.Length; ++idx )
{
copy[ idx ] = m_VarListList[ other[ idx ].Index ];
}
return copy;
}
public void ListVar_TestVariableUIType()
{
//Arrange
VariableList variableList = new VariableList();
//Act
string varType = variableList.VariableUIType;
//Assert
Assert.IsTrue(varType.Contains("List"), "List Variable UI Type");
}
public void ListVar_TestVariableType()
{
//Arrange
VariableList variableList = new VariableList();
//Act
string varType = variableList.VariableType;
//Assert
Assert.AreEqual("List", varType, "List Variable Type");
}
/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
string[] processed = ProcessParameters(variables, Parameters);
Action.ActionType type = (Action.ActionType) Enum.Parse(typeof (Action.ActionType), processed[0]);
float f1 = float.Parse(processed[1]);
float f2 = float.Parse(processed[2]);
Action action = new Action(type, f1, f2);
GUIGraphicsContext.OnAction(action);
}
public void SetListVariable(string name, VariableList val)
{
if (val == null)
{
return;
}
lock (listvariables)
{
listvariables[name] = val;
}
}
public void ListVar_TestFormulaNoList()
{
//Arrange
VariableList variableList = new VariableList();
//Act
string formulaResult = variableList.GetFormula();
//Assert
Assert.AreEqual(string.Empty, formulaResult, "List Formula");
}
/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
string[] processed = ProcessParameters(variables, Parameters);
Action.ActionType type = (Action.ActionType)Enum.Parse(typeof(Action.ActionType), processed[0]);
float f1 = float.Parse(processed[1]);
float f2 = float.Parse(processed[2]);
Action action = new Action(type, f1, f2);
GUIGraphicsContext.OnAction(action);
}
public string GetProjectPath()
{
string projectPath = string.Empty;
var projectPathVariable = VariableList.Where(v => v.VariableName == "ProjectPath").SingleOrDefault();
if (projectPathVariable != null)
{
projectPath = projectPathVariable.VariableValue.ToString();
}
return(projectPath);
}
/// <summary>
/// Handles the <see cref="ButtonBase.Click"/> event for the "Add Variable" <see
/// cref="Button"/>.</summary>
/// <param name="sender">
/// The <see cref="Object"/> where the event handler is attached.</param>
/// <param name="args">
/// A <see cref="RoutedEventArgs"/> object containing event data.</param>
/// <remarks><para>
/// <b>OnVariableAdd</b> displays a <see cref="Dialog.ChangeIdentifier"/> dialog, followed
/// by a <see cref="Dialog.ChangeVariable"/> dialog, allowing the user to define a new
/// variable. The new variable copies the properties of the first selected item in the
/// "Variable" list view, if any; otherwise, it is created with default properties.
/// </para><para>
/// If the user confirmed both dialogs, <b>OnVariableAdd</b> adds the new variable to the
/// "Variable" list view and to the <see cref="CurrentVariables"/> collection, and sets the
/// <see cref="SectionTabItem.DataChanged"/> flag.</para></remarks>
private void OnVariableAdd(object sender, RoutedEventArgs args)
{
args.Handled = true;
// ask user for new variable ID
var variables = CurrentVariables;
var dialog = new Dialog.ChangeIdentifier(CurrentDefaultId,
Global.Strings.TitleVariableIdEnter, variables.ContainsKey, false);
dialog.Owner = MainWindow.Instance;
if (dialog.ShowDialog() != true)
{
return;
}
// retrieve new variable ID
string id = String.Intern(dialog.Identifier);
// create new variable based on selected variable, if any
VariableClass variable, selection = VariableList.SelectedItem as VariableClass;
if (selection == null)
{
variable = VariableClass.Create(id, CurrentCategory);
}
else
{
variable = (VariableClass)selection.Clone();
variable.Id = id;
}
// let user make changes to new variable
var variableDialog = new Dialog.ChangeVariable(variable)
{
Owner = MainWindow.Instance
};
if (variableDialog.ShowDialog() != true)
{
return;
}
// add variable to section table
variables.Add(id, variable);
// update list view and select new item
VariableList.Items.Refresh();
VariableList.SelectAndShow(variable);
// broadcast data changes
EnableListButtons();
SectionTab.DataChanged = true;
}
public LocalVariable AddVariable(Symbol s)
{
if (pos.ContainsKey(s))
{
throw new SyntaxError(string.Format("Env: Redefined name {0}", s));
}
pos.Add(s, VariableList.Count);
var ret = new LocalVariable(s.Name, this);
VariableList.Add(ret);
return(ret);
}
// Lua's productions allways take lists on both sides of the '='
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
foreach (var parseTreeNode in treeNode.ChildNodes[0].ChildNodes)
VariableList.Add(AddChild(String.Empty, parseTreeNode) as LuaNode);
foreach (var parseTreeNode in treeNode.ChildNodes[2].ChildNodes)
ExpressionList.Add(AddChild(String.Empty, parseTreeNode) as LuaNode);
AsString = "(assignment)";
}
public void ListVar_TestResetIndexValueForEmptyList()
{
//Arrange
List <string> lstTemp = new List <string>();
VariableList variableList = new VariableList("TestList", lstTemp);
//Act
variableList.ResetValue();
//Assert
Assert.AreEqual(0, variableList.CurrentValueIndex, "On Reset Index Value repositioned to 0");
}
internal WMatchClause GetMatchClause()
{
var newMatchClause = new WMatchClause();
foreach (var path in PathList)
{
if (path.EdgeVariable is GremlinFreeEdgeTableVariable && VariableList.Contains(path.EdgeVariable))
{
newMatchClause.Paths.Add(path.ToMatchPath());
}
}
return(newMatchClause.Paths.Count == 0 ? null : newMatchClause);
}
public void ListVar_TestFormulaForEmptyList()
{
//Arrange
List <string> lstTemp = new List <string>();
VariableList variableList = new VariableList("TestList", lstTemp);
string formulaExpectedResult = String.Join(",", lstTemp.ToArray());
//Act
string formulaResult = variableList.GetFormula();
//Assert
Assert.AreEqual(formulaExpectedResult, formulaResult, "List Formula");
}
public string Visit(VariableList node)
{
var stringo = $"// Start {node.GetType()} \n";
stringo += "\t\t.locals init (\n";
for (int i = 0; i < node.children.Count; i++)
{
stringo += $"\t\t\t[{i}] int32 {node.children[i].AnchorToken.Lexeme}";
stringo += i == node.children.Count - 1 ? "\n" : ",\n";
}
stringo += "\t\t)\n\n";
return(stringo);
}
internal void Reset()
{
PivotVariable = null;
Predicates = null;
VariableList.Clear();
TableReferences.Clear();
PathList.Clear();
StepList.Clear();
IsPopulateGremlinPath = false;
CurrentContextPath = null;
ProjectVariablePropertiesList.Clear();
ProjectedProperties.Clear();
}
public void ListVar_TestImageType()
{
//Arrange
List <string> lstTemp = new List <string>();
lstTemp.Add("Jupiter");
VariableList variableList = new VariableList("TestList", lstTemp);
//Act
eImageType eImageType = variableList.Image;
//Assert
Assert.AreEqual(eImageType.VariableList, eImageType, "Image Type");
}
internal void OutE(GremlinVariable lastVariable, List <string> edgeLabels)
{
GremlinVariableProperty sourceProperty = lastVariable.GetVariableProperty(GremlinKeyword.NodeID);
GremlinVariableProperty adjEdge = lastVariable.GetVariableProperty(GremlinKeyword.EdgeAdj);
GremlinVariableProperty labelProperty = lastVariable.GetVariableProperty(GremlinKeyword.Label);
GremlinBoundEdgeTableVariable outEdgeTable = new GremlinBoundEdgeTableVariable(sourceProperty, adjEdge, labelProperty, WEdgeType.OutEdge);
VariableList.Add(outEdgeTable);
TableReferences.Add(outEdgeTable);
AddLabelPredicateForEdge(outEdgeTable, edgeLabels);
AddPath(new GremlinMatchPath(lastVariable, outEdgeTable, null));
SetPivotVariable(outEdgeTable);
}
protected ExpressionToBDD(ProbModel model)
{
this.allRowVars = model.allRowVars;
this.allColVars = model.allColVars;
this.allRowVarRanges = model.allRowVarRanges;
this.varIdentities = model.varIdentities;
this.varList = model.varList;
this.varEncodings = model.varEncodings;
this.trans = model.trans;
this.start = model.start;
this.stateRewards = model.stateRewards;
this.transRewards = model.transRewards;
}
public void ListVar_TestRandomGenerateAutoValueNotExists()
{
//Arrange
List <string> lstTemp = new List <string>();
VariableList variableList = new VariableList("TestList", lstTemp);
variableList.RandomOrder = true;
//Act
variableList.GenerateAutoValue();
//Assert
Assert.IsFalse(lstTemp.Contains("Dummy"), "Random GenerateAutoValue");
}
public ProbModel(CUDDNode trans, CUDDNode start, List <CUDDNode> stateRewards, List <CUDDNode> transRewards, CUDDVars allRowVars, CUDDVars allColVars,
VariableList varList, CUDDNode allRowVarRanges, List <CUDDNode> varIdentities, List <CUDDNode> varEncodings)
{
this.trans = trans;
this.start = start;
this.stateRewards = stateRewards;
this.transRewards = transRewards;
this.allRowVars = allRowVars;
this.allColVars = allColVars;
this.varList = varList;
this.allRowVarRanges = allRowVarRanges;
this.varIdentities = varIdentities;
this.varEncodings = varEncodings;
}
private void AddListVariable(VariableStore vs, DataGridView dgv)
{
VariableList v = new VariableList();
string varname = "";
v = (VariableList)OpenVariableEditor(v, ref varname, true);
if (v != null)
{
lock (vs.List)
{
vs.List[varname] = v;
}
RefreshListVariables(vs, dgv);
}
}
private void btnListAdd_Click(object sender, EventArgs e)
{
VariableList v = new VariableList();
string varname = "";
v = (VariableList)OpenVariableEditor(v, ref varname, true);
if (v != null)
{
lock (plug.listvariables)
{
plug.listvariables[varname] = v;
}
RefreshListVariables();
}
}
internal void PopulateGremlinPath()
{
if (IsPopulateGremlinPath)
{
return;
}
GremlinPathVariable newVariable = new GremlinPathVariable(GetCurrAndChildGremlinStepList());
VariableList.Add(newVariable);
TableReferences.Add(newVariable);
CurrentContextPath = newVariable;
IsPopulateGremlinPath = true;
}
internal void BothE(GremlinVariable lastVariable, List <string> edgeLabels)
{
GremlinVariableProperty sourceProperty = lastVariable.GetVariableProperty(GremlinKeyword.NodeID);
GremlinVariableProperty adjReverseEdge = lastVariable.GetVariableProperty(GremlinKeyword.ReverseEdgeAdj);
GremlinVariableProperty adjEdge = lastVariable.GetVariableProperty(GremlinKeyword.EdgeAdj);
GremlinVariableProperty labelProperty = lastVariable.GetVariableProperty(GremlinKeyword.Label);
GremlinBoundEdgeTableVariable bothEdgeTable = new GremlinBoundEdgeTableVariable(sourceProperty, adjEdge, adjReverseEdge, labelProperty,
WEdgeType.BothEdge);
VariableList.Add(bothEdgeTable);
TableReferences.Add(bothEdgeTable);
AddLabelPredicateForEdge(bothEdgeTable, edgeLabels);
SetPivotVariable(bothEdgeTable);
}
/// <summary>
/// Initializes a new instance of the <see cref="ShowGauges"/> class with the specified
/// initially selected <see cref="ResourceClass"/> and <see cref="GaugeDisplay"/> flags.
/// </summary>
/// <param name="resource"><para>
/// The identifier of the <see cref="ResourceClass"/> to select initially. Possible values
/// include the pseudo-resources <see cref="ResourceClass.StandardMorale"/> and <see
/// cref="ResourceClass.StandardStrength"/>.
/// </para><para>-or-</para><para>
/// A null reference to select the <see cref="ResourceClass.StandardStrength"/>
/// pseudo-resource.</para></param>
/// <param name="flags">
/// A <see cref="GaugeDisplay"/> value indicating which display flags to select initially.
/// </param>
public ShowGauges(string resource, GaugeDisplay flags)
{
InitializeComponent();
Resource = resource;
ResourceFlags = flags;
// read specified display flags into check boxes
NeverToggle.IsChecked = String.IsNullOrEmpty(resource);
AlwaysToggle.IsChecked = ((flags & GaugeDisplay.Always) != 0);
StackToggle.IsChecked = ((flags & GaugeDisplay.Stack) != 0);
// adjust column width of Resource list view
DependencyPropertyDescriptor.FromProperty(
ListView.ActualWidthProperty, typeof(ListView))
.AddValueChanged(VariableList, OnVariableWidthChanged);
// show standard unit resources
VariableList.Items.Add(ResourceClass.StandardStrength);
VariableList.Items.Add(ResourceClass.StandardMorale);
VariableList.AddSeparator();
// show all scenario resources
foreach (VariableClass variable in MasterSection.Instance.Variables.Resources.Values)
{
VariableList.Items.Add(variable);
}
// select specified resource, if any
if (resource != null)
{
foreach (object item in VariableList.Items)
{
VariableClass variable = item as VariableClass;
if (variable != null && variable.Id == resource)
{
VariableList.SelectAndShow(variable);
break;
}
}
}
// select standard strength by default
if (VariableList.SelectedItems.Count == 0)
{
VariableList.SelectAndShow(0);
}
}
/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
string[] processed = ProcessParameters(variables, Parameters);
GUIMessage.MessageType type = (GUIMessage.MessageType) Enum.Parse(typeof (GUIMessage.MessageType), processed[0]);
int windowId = int.Parse(processed[1]);
int senderId = int.Parse(processed[2]);
int controlId = int.Parse(processed[3]);
int param1 = int.Parse(processed[4]);
int param2 = int.Parse(processed[5]);
GUIMessage message = new GUIMessage(type, windowId, senderId, controlId, param1, param2, null);
GUIGraphicsContext.ResetLastActivity();
GUIWindowManager.SendThreadMessage(message);
}
public void ListVar_TestResetIndexValue()
{
//Arrange
List <string> lstTemp = new List <string>();
lstTemp.Add("Friend");
lstTemp.Add("Love");
VariableList variableList = new VariableList("TestList", lstTemp);
//Act
variableList.ResetValue();
//Assert
Assert.AreEqual(0, variableList.CurrentValueIndex, "On Reset Index Value repositioned to 0");
Assert.AreEqual(lstTemp[0], variableList.Value, "Reset Index Value");
}
/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
string[] processed = ProcessParameters(variables, Parameters);
GUIMessage.MessageType type = (GUIMessage.MessageType)Enum.Parse(typeof(GUIMessage.MessageType), processed[0]);
int windowId = int.Parse(processed[1]);
int senderId = int.Parse(processed[2]);
int controlId = int.Parse(processed[3]);
int param1 = int.Parse(processed[4]);
int param2 = int.Parse(processed[5]);
GUIMessage message = new GUIMessage(type, windowId, senderId, controlId, param1, param2, null);
GUIGraphicsContext.ResetLastActivity();
GUIWindowManager.SendThreadMessage(message);
}
public override void Deserialize(PackedStream_2 stream)
{
base.hasValue = true;
this.Variables = new VariableList();
DeserializeClass class2 = new DeserializeClass(stream, 1);
for (uint i = 0; i < class2.Count; i++)
{
ulong num2;
int num5;
HeroFieldDef definition;
HeroAnyValue value2;
uint num3 = 0;
int variableId = 0;
class2.ReadFieldData(out num2, ref num3, ref variableId, out num5);
if (num5 == 2)
{
continue;
}
HeroType type = new HeroType((HeroTypes)num3);
DefinitionId field = new DefinitionId(num2);
if (field.Definition != null)
{
definition = field.Definition as HeroFieldDef;
HeroTypes types = definition.FieldType.Type;
if (types != HeroTypes.Enum)
{
if (types == HeroTypes.LookupList)
{
goto Label_0096;
}
if (types != HeroTypes.ScriptRef)
{
goto Label_009F;
}
}
type.Id = definition.FieldType.Id;
}
goto Label_009F;
Label_0096:
type = definition.FieldType;
Label_009F:
value2 = HeroAnyValue.Create(type);
value2.Deserialize(stream);
this.Variables.Add(new Variable(field, variableId, value2));
}
}
/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
GUIDialogNotify dlgNotify =
(GUIDialogNotify) GUIWindowManager.GetWindow((int) GUIWindow.Window.WINDOW_DIALOG_NOTIFY);
if (dlgNotify == null)
throw new CommandExecutionException("Failed to create GUIDialogNotify");
string[] processed = ProcessParameters(variables, Parameters);
int timeout = int.Parse(processed[2]);
dlgNotify.Reset();
dlgNotify.ClearAll();
dlgNotify.SetHeading(processed[0]);
dlgNotify.SetText(processed[1]);
dlgNotify.TimeOut = timeout;
dlgNotify.DoModal(GUIWindowManager.ActiveWindow);
}
public override string go()
{
SyntaxError error = null;
string s = null;
Lexema l = getToken();
if (l.GetType().Name == "Var")
{
while ((l=getToken())!=null&&l.GetType().Name!="Endl")
{
string type=l.GetType().Name;
if (type == "Begin")
{
addError(new EndlMissedError(), 0);
break;
}
lexems.Add(l);
}
if (l==null)
{
addError(new EndlMissedError(), 0);
}
string result = "SEG1 SEGMENT\n";
s = new VariableList(this).go();
if (s == null)
{
error = new VariableListMissedError();
}
else
{
result += s+"\n";
result += "SEG1 ENDS\n";
s = result;
}
}
return s;
}
/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
bool mpBasicHome = false;
using (Settings xmlreader = new Settings(MPCommon.MPConfigFile))
mpBasicHome = xmlreader.GetValueAsBool("general", "startbasichome", false);
GUIGraphicsContext.ResetLastActivity();
// Stop all media before suspending
g_Player.Stop();
GUIMessage msg;
if (mpBasicHome)
msg = new GUIMessage(GUIMessage.MessageType.GUI_MSG_GOTO_WINDOW, 0, 0, 0,
(int) GUIWindow.Window.WINDOW_SECOND_HOME, 0, null);
else
msg = new GUIMessage(GUIMessage.MessageType.GUI_MSG_GOTO_WINDOW, 0, 0, 0, (int) GUIWindow.Window.WINDOW_HOME, 0,
null);
GUIWindowManager.SendThreadMessage(msg);
WindowsController.ExitWindows(RestartOptions.Suspend, false);
}
/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
string[] processed = ProcessParameters(variables, Parameters);
int port = int.Parse(processed[1]);
SendWOL(processed[0], port, processed[2]);
}
/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
if (!Application.SetSuspendState(PowerState.Hibernate, false, false))
throw new CommandExecutionException("Hibernate command refused");
}
private void AddVariables(VariableList variables, int indent)
{
foreach (Variable variable in variables)
{
string name;
if (variable.Field.Definition != null)
{
name = variable.Field.Definition.Name;
}
else
{
name = string.Format("0x{0:X}", variable.Field.Id);
}
ListViewItem item = this.listViewVariables.Items.Add(name);
item.IndentCount = indent;
item.SubItems.Add(variable.Value.Type.ToString());
this.SetValueText(variable.Value, indent, item);
item.Tag = variable;
}
}
/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
GUIGraphicsContext.OnAction(new Action(Action.ActionType.ACTION_EXIT, 0, 0));
}
/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
if (!Win32.WindowsExit(Win32.ExitWindows.LogOff, Win32.ShutdownReasons.FlagUserDefined))
throw new CommandExecutionException("LogOff command refused");
}
/// <summary>
/// Execute this command.
/// </summary>
/// <param name="variables">The variable list of the calling code.</param>
public override void Execute(VariableList variables)
{
string[] processed = ProcessParameters(variables, Parameters);
int timeout = int.Parse(processed[0]);
Thread.Sleep(timeout);
}
/// <summary>
/// Initializes a new instance of the <see cref="Processor"/> class.
/// </summary>
/// <param name="blastIrDelegate">The blast ir delegate.</param>
/// <param name="blastIrPorts">The blast ir ports.</param>
public Processor(BlastIrDelegate blastIrDelegate, string[] blastIrPorts)
{
_variables = new VariableList();
_blastIrDelegate = blastIrDelegate;
_blastIrPorts = blastIrPorts;
}
private static VariableList makeFromTable(DataTable tbl)
{
VariableList list = new VariableList();
foreach (DataRow r in tbl.Rows)
{
list.Add(new Variable(r));
}
return list;
}
/// <summary>
/// Execute this command.
/// </summary>
public override void Execute(VariableList variables)
{
variables.VariableClear();
}
