protected bool isContext(ISolutionEvent evt, SolutionEventType type)
{
var cfgContext = evt.BuildType;
// /LC: #799
if (type == SolutionEventType.SlnOpened)
{
if (cfgContext == BuildType.Common)
{
cfgContext = BuildType.Before; // consider it as default type
}
if (cfgContext != BuildType.Before &&
cfgContext != BuildType.After &&
cfgContext != BuildType.BeforeAndAfter)
{
return(false);
}
if (CurrentContext == BuildType.Common || // Before & After are not possible at all, e.g. Isolated env etc., thus consider it as any possible
cfgContext == BuildType.BeforeAndAfter)
{
return(true);
}
if (cfgContext == BuildType.Before || cfgContext == BuildType.After)
{
return(cfgContext == CurrentContext);
}
}
return(cfgContext == BuildType.Common || cfgContext == CurrentContext);
}
protected int bindSln(SBEEvent[] evt, SolutionEventType type)
{
if (isDisabledAll(evt))
{
return(Codes.Success);
}
if (!IsAllowActions)
{
return(_ignoredAction(type));
}
string typeString = SolutionEventType.SlnOpened.ToString();
foreach (SBEEvent item in evt)
{
try {
if (Cmd.exec(item, type))
{
Log.Info("[{0}] finished SBE: `{1}`", typeString, item.Caption);
}
Status._.add(type, StatusType.Success);
}
catch (Exception ex) {
Log.Error("[{0}] error: `{1}`", typeString, ex.Message);
Status._.add(type, StatusType.Fail);
}
}
return(Status._.contains(type, StatusType.Fail)? Codes.Failed : Codes.Success);
}
/// <summary>
/// Execution by user.
/// </summary>
public void execAction()
{
if (SBEItem == null)
{
Log.Info("No actions to execution. Add new, then try again.");
return;
}
Actions.ICommand cmd = new Actions.Command
(
Loader.Env,
Loader.Soba,
Loader.Soba.EvMSBuild
);
ISolutionEvent evt = SBEItem;
SolutionEventType type = SBE.type;
Log.Info("Action: execute action '{0}':'{1}' manually :: emulate '{2}' event", evt.Name, evt.Caption, type);
cmd.Env.BuildType = BuildType.Common; //TODO: IBuild.updateBuildType
try {
bool res = cmd.exec(evt, type);
Log.Info("Action: '{0}':'{1}' completed as - '{2}'", evt.Name, evt.Caption, res.ToString());
}
catch (Exception ex) {
Log.Error("Action: '{0}':'{1}' is failed. Error: '{2}'", evt.Name, evt.Caption, ex.Message);
}
}
/// <summary>
/// New status for Event type
/// </summary>
/// <param name="tevent">Event type</param>
/// <param name="tstatus">Execution status</param>
public void add(SolutionEventType tevent, StatusType tstatus)
{
if(!states.ContainsKey(tevent)) {
states[tevent] = new SynchronizedCollection<StatusType>();
}
states[tevent].Add(tstatus);
}
/// <summary>
/// New status for Event type
/// </summary>
/// <param name="tevent">Event type</param>
/// <param name="tstatus">Execution status</param>
public void add(SolutionEventType tevent, StatusType tstatus)
{
if (!states.ContainsKey(tevent))
{
states[tevent] = new SynchronizedCollection <StatusType>();
}
states[tevent].Add(tstatus);
}
/// <summary>
/// Changing the Enabled staus for all event-items
/// </summary>
/// <param name="type"></param>
/// <param name="status"></param>
public void enabled(SolutionEventType type, bool status)
{
ISolutionEvent[] evt = getEvent(type);
foreach (ISolutionEvent item in evt)
{
item.Enabled = status;
}
}
public void initQueue(SolutionEventType type)
{
if (queues.ContainsKey(type))
{
return;
}
queues[type] = new TQueue();
}
protected virtual ISolutionEvent[] getEvent(SolutionEventType type)
{
try {
return(Settings.Cfg.getEvent(type)); //TODO:
}
catch (NotFoundException) {
throw new NotSupportedOperationException($"The event type '{type}' is not supported yet.");
}
}
protected void enabled(SolutionEventType type, bool status)
{
try {
logic.enabled(type, status);
}
catch (Exception ex) {
Log.Warn("StatusToolControl: Failed - enabled() for type - '{0}' :: '{1}'", type, ex.Message);
}
}
protected virtual ISolutionEvent[] getEvent(SolutionEventType type)
{
try {
return Settings.Cfg.getEvent(type);
}
catch(Exception) {
throw new NotSupportedOperationException("getEvent: Not yet supported event type - '{0}'", type);
}
}
protected void restore(SolutionEventType type)
{
try {
logic.restore(type);
}
catch (Exception ex) {
Log.Warn("StatusToolControl: Failed - restore() for type - '{0}' :: '{1}'", type, ex.Message);
}
}
/// <summary>
/// Updating status for Event type
/// </summary>
/// <param name="tevent">Event type</param>
/// <param name="index">Position in list</param>
/// <param name="tstatus">new status</param>
public void update(SolutionEventType tevent, int index, StatusType tstatus)
{
try {
states[tevent][index] = tstatus;
}
catch (Exception ex) {
Log.Debug("Updating status: '{0}'", ex.Message);
}
}
/// <summary>
/// Checking existence of StatusType in the current statuses
/// </summary>
/// <param name="tevent">Event type</param>
/// <param name="type"></param>
/// <returns>true value if contains</returns>
public bool contains(SolutionEventType tevent, StatusType type)
{
Debug.Assert(states != null);
if (!states.ContainsKey(tevent))
{
return(false);
}
return(states[tevent].Contains(type));
}
/// <summary>
/// Captions for buttons
/// </summary>
/// <param name="type"></param>
/// <param name="selected"></param>
protected string caption(SolutionEventType type, bool selected)
{
try {
return(logic.caption(type, selected));
}
catch (Exception ex) {
Log.Warn("StatusToolControl: problem with caption '{0}'", ex.Message);
}
return(logic.caption(type));
}
protected bool isDisabledAll(SolutionEventType type)
{
try {
return(logic.isDisabledAll(type));
}
catch (Exception ex) {
Log.Warn("StatusToolControl: Failed checking the Enabled status for type - '{0}' :: '{1}'", type, ex.Message);
}
return(true);
}
private ISolutionEvent getEventByIndex(SolutionEventType type, int index)
{
ISolutionEvent[] evt = getEvent(type);
try {
return(evt[index - 1]); // starts with 1
}
catch (IndexOutOfRangeException) {
throw new NotFoundException("Incorrect index '{0}' for event type - `{1}` /{2}", index, type, evt.Length);
}
}
private ISolutionEvent getEventByIndex(SolutionEventType type, int index)
{
ISolutionEvent[] evt = getEvent(type);
try {
return(evt[index - 1]); // starts with 1
}
catch (IndexOutOfRangeException) {
throw new NotFoundException(type, $"For index '{index}' /{evt.Length}", index, evt.Length);
}
}
/// <summary>
/// Getting the Execution status by Event type and position in list
/// </summary>
/// <param name="tevent">Event type</param>
/// <param name="index">Position in list</param>
/// <returns>Executed status</returns>
public StatusType get(SolutionEventType tevent, int index)
{
Debug.Assert(states != null);
try {
return(states[tevent][index]);
}
catch (Exception) {
return(StatusType.NotFound);
}
}
protected void toggleRestored(SolutionEventType type, bool enabled)
{
if (enabled)
{
restore(type);
}
else
{
this.enabled(type, false);
}
Settings.CfgManager.Config.save();
}
/// <summary>
/// Getting event by type.
/// </summary>
/// <param name="type">Available event.</param>
/// <exception cref="NotFoundException"></exception>
public ISolutionEvent[] getEvent(SolutionEventType type)
{
switch(type)
{
case SolutionEventType.Common:
case SolutionEventType.CommandEvent:
case SolutionEventType.OWP: {
return Event;
}
}
throw new NotFoundException("getEvent: Not found event type - '{0}'", type);
}
/// <summary>
/// Provides captions by event type
/// </summary>
/// <param name="type"></param>
public string caption(SolutionEventType type)
{
switch(type) {
case SolutionEventType.OWP: {
return "Output";
}
case SolutionEventType.CommandEvent: {
return "DTE";
}
}
return type.ToString();
}
/// <summary>
/// The event by type.
/// </summary>
/// <param name="type">Available event.</param>
/// <exception cref="NotFoundException"></exception>
public ISolutionEvent[] getEvent(SolutionEventType type)
{
switch (type)
{
case SolutionEventType.Common:
case SolutionEventType.CommandEvent:
case SolutionEventType.OWP: {
return(Event);
}
}
throw new NotFoundException("getEvent: the event type '{0}' is not found.", type);
}
/// <summary>
/// Updating status for used event type
/// </summary>
/// <param name="btn"></param>
/// <param name="type"></param>
protected void update(ToggleButton btn, SolutionEventType type)
{
try {
logic.update(type);
Application.Current.Dispatcher.BeginInvoke(new Action(() => {
btn.Content = caption(type, false);
btn.IsChecked = !isDisabledAll(type);
}));
}
catch (Exception ex) {
Log.Warn("StatusToolControl: Failed update for type - '{0}' :: '{1}'", type, ex.Message);
}
}
/// <inheritdoc cref="ISolutionEvents.getEvent"/>
/// <exception cref="NotFoundException"></exception>
public ISolutionEvent[] getEvent(SolutionEventType type)
{
switch (type)
{
case SolutionEventType.Pre: {
return(PreBuild);
}
case SolutionEventType.Post: {
return(PostBuild);
}
case SolutionEventType.Cancel: {
return(CancelBuild);
}
case SolutionEventType.Warnings: {
return(WarningsBuild);
}
case SolutionEventType.Errors: {
return(ErrorsBuild);
}
case SolutionEventType.OWP: {
return(OWPBuild);
}
case SolutionEventType.Transmitter: {
return(Transmitter);
}
case SolutionEventType.CommandEvent: {
return(CommandEvent);
}
case SolutionEventType.Logging: {
return(Logging);
}
case SolutionEventType.SlnOpened: {
return(SlnOpened);
}
case SolutionEventType.SlnClosed: {
return(SlnClosed);
}
}
throw new NotFoundException(type);
}
/// <summary>
/// Provides captions by event type
/// </summary>
/// <param name="type"></param>
public string caption(SolutionEventType type)
{
switch (type)
{
case SolutionEventType.OWP: {
return("Output");
}
case SolutionEventType.CommandEvent: {
return("DTE");
}
}
return(type.ToString());
}
/// <summary>
/// Gets index from defined events
/// </summary>
/// <param name="type"></param>
/// <returns>current position in list of definition</returns>
public int getDefIndexByEventType(SolutionEventType type)
{
int idx = 0;
foreach (SBEWrap evt in events)
{
if (evt.type == type)
{
return(idx);
}
++idx;
}
return(-1);
}
public void restore(SolutionEventType type)
{
if (status.ContainsKey(type) && status[type] != null)
{
ISolutionEvent[] evt = getEvent(type);
for (int i = 0; i < evt.Length; ++i)
{
evt[i].Enabled = status[type][i];
}
}
if (isDisabledAll(type))
{
enabled(type, true);
}
}
/// <summary>
/// Provides captions by event type and selection mode
/// </summary>
/// <param name="type"></param>
/// <param name="selected"></param>
/// <exception cref="Exception"></exception>
public string caption(SolutionEventType type, bool selected)
{
ISolutionEvent[] evt = getEvent(type);
int enabled = (evt == null)? 0 : evt.Where(i => i.Enabled).Count();
if (selected)
{
return(String.Format("({0} /{1})", enabled, evt.Length));
}
if (enabled < 1)
{
return(caption(type));
}
return(String.Format("{0} ({1})", caption(type), enabled));
}
protected string stEventItem(SolutionEventType type, IPM pm)
{
ILevel level = pm.FirstLevel;
int index = -1;
ISolutionEvent evt;
if (level.Is(ArgumentType.StringDouble))
{
evt = getEventByName(type, (string)level.Args[0].data, out index);
}
else if (level.Is(ArgumentType.Integer))
{
index = (int)level.Args[0].data;
evt = getEventByIndex(type, index);
}
else
{
throw new PMLevelException(level, "`item( string name | integer index )`");
}
// .item(...).
if (pm.Is(1, LevelType.Property, "Enabled"))
{
return(pEnabled(evt, pm.PinTo(2)));
}
if (pm.Is(1, LevelType.Method, "run"))
{
return(mActionRun(type, evt, pm.PinTo(1)));
}
if (pm.Is(1, LevelType.Property, "Status"))
{
return(itemStatus(type, index, pm.PinTo(1)));
}
if (pm.Is(1, LevelType.Property, "stdout"))
{
return(pStdout(evt, pm.PinTo(2)));
}
if (pm.Is(1, LevelType.Property, "stderr"))
{
return(pStderr(evt, pm.PinTo(2)));
}
throw new IncorrectNodeException(pm, 1);
}
protected bool toggleEnabled(SolutionEventType type, bool enabled)
{
bool ret;
if (!enabled)
{
this.enabled(type, true);
ret = true;
}
else
{
this.enabled(type, false);
ret = false;
}
Settings.CfgManager.Config.save();
return(ret);
}
protected string itemStatus(SolutionEventType type, int index, IPM pm)
{
if (!pm.Is(LevelType.Property, "Status"))
{
throw new IncorrectNodeException(pm);
}
if (pm.FinalEmptyIs(1, LevelType.Property, "HasErrors"))
{
string status = Value.From(Status._.get(type, index) == StatusType.Fail);
#if DEBUG
Log.Trace($"pStatus: status - '{status}'");
#endif
return(status);
}
throw new IncorrectNodeException(pm, 1);
}
/// <param name="type"></param>
/// <param name="name"></param>
/// <param name="index">Index of selected type of event by name</param>
/// <returns></returns>
private ISolutionEvent getEventByName(SolutionEventType type, string name, out int index)
{
if (String.IsNullOrWhiteSpace(name))
{
throw new NotFoundException("The name of event type is null or empty.");
}
index = -1;
foreach (ISolutionEvent item in getEvent(type))
{
++index;
if (item.Name == name)
{
return(item);
}
}
throw new NotFoundException("The event type '{0}' with name '{1}' is not exists.", type, name);
}
/// <param name="type"></param>
/// <param name="name"></param>
/// <param name="index">Index of selected type of event by name</param>
/// <returns></returns>
private ISolutionEvent getEventByName(SolutionEventType type, string name, out int index)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name));
}
index = -1;
foreach (ISolutionEvent item in getEvent(type))
{
++index;
if (item.Name == name)
{
return(item);
}
}
throw new NotFoundException(name, $"Event type `{type}`.", type);
}
protected override ISolutionEvent[] getEvent(SolutionEventType type)
{
if (evt != null)
{
return(evt);
}
evt = new SBEEvent[3] {
new SBEEvent()
{
Name = "Name1",
SupportMSBuild = false,
SupportSBEScripts = false,
Mode = new ModeFile()
{
Command = ""
},
Enabled = true
},
new SBEEvent()
{
Name = "Name2",
Mode = new ModeFile()
{
Command = ""
},
Enabled = false
},
new SBEEvent()
{
Name = "Name3",
SupportMSBuild = false,
SupportSBEScripts = false,
BuildType = Bridge.BuildType.Rebuild,
Mode = new ModeFile()
{
Command = ""
},
Enabled = true
}
};
return(evt);
}
/// <summary>
/// Checking existence of StatusType in the current statuses
/// </summary>
/// <param name="tevent">Event type</param>
/// <param name="type"></param>
/// <returns>true value if contains</returns>
public bool contains(SolutionEventType tevent, StatusType type)
{
Debug.Assert(states != null);
if(!states.ContainsKey(tevent)) {
return false;
}
return states[tevent].Contains(type);
}
/// <param name="type">Event type</param>
/// <returns>true value if all event are disabled for present type</returns>
public bool isDisabledAll(SolutionEventType type)
{
return getEvent(type).All(x => !x.Enabled);
}
protected string pStatus(SolutionEventType type, int index, string data)
{
Match m = Regex.Match(data, @"\.\s*
([A-Za-z_0-9]+) #1 - property
\s*$",
RegexOptions.IgnorePatternWhitespace);
if(!m.Success) {
throw new OperandNotFoundException("Failed pStatus - '{0}'", data);
}
string property = m.Groups[1].Value;
if(property == "HasErrors")
{
string status = (Status._.get(type, index) == StatusType.Fail).ToString().ToLower();
Log.Debug("pStatus: status - '{0}'", status);
return status;
}
throw new SubtypeNotFoundException("pStatus: not found subtype - '{0}'", property);
}
protected string stEventItem(SolutionEventType type, string index, string name, string data)
{
Debug.Assert((index == null && name != null) || (index != null && name == null));
Match m = Regex.Match(data,
String.Format(@"\.\s*
([A-Za-z_0-9]+) #1 - property
(?:
\s*\(
{0} #2 - arg (optional)
\)\s*
)?
\s*(.*) #3 - operation
", RPattern.DoubleQuotesContent
), RegexOptions.IgnorePatternWhitespace);
if(!m.Success) {
throw new SyntaxIncorrectException("Failed stEventItem - '{0}'", data);
}
string property = m.Groups[1].Value;
string operation = m.Groups[3].Value.Trim();
Log.Debug("stEventItem: property - '{0}', operation - '{1}'", property, operation);
int sIndex = -1;
ISolutionEvent evt = (name != null)? getEventByName(type, name, out sIndex) : getEventByIndex(type, index, out sIndex);
switch(property)
{
case "Enabled": {
return pEnabled(evt, operation);
}
case "Status": {
return pStatus(type, sIndex, operation);
}
}
throw new SubtypeNotFoundException("stEventItem: not found subtype - '{0}'", property);
}
/// <summary>
/// Implements transport for new action by event type.
/// </summary>
/// <param name="type">The type of event.</param>
/// <param name="cfg">The event configuration for action.</param>
public void action(SolutionEventType type, ISolutionEvent cfg)
{
ISolutionEvent evt = addAction(-1);
if(evt == null || cfg == null) {
Log.Debug("UI.action for `{0}` - cfg or evt is null /skip", type);
return;
}
cfg.CloneByReflectionInto(evt, true);
refreshActions(true);
refreshSettings();
notice(true);
MessageBox.Show(String.Format("The new action `{0}`:\n`{1}` has been added.", evt.Name, evt.Caption), "New action");
}
/// <summary>
/// Updating status for used event type
/// </summary>
/// <param name="type"></param>
public void update(SolutionEventType type)
{
if(!isDisabledAll(type)) {
status[type] = getEvent(type).Select(i => i.Enabled).ToArray();
}
}
/// <summary>
/// Entry point for execution
/// </summary>
/// <param name="evt">Configured event</param>
/// <param name="type">Type of event</param>
/// <returns>true value if has been processed</returns>
public bool exec(ISolutionEvent evt, SolutionEventType type)
{
if(!evt.Enabled){
return false;
}
if(evt.BuildType != BuildType.Common && evt.BuildType != Env.BuildType) {
Log.Debug("Ignored context. Build type '{0}' should be '{1}'", Env.BuildType, evt.BuildType);
return false;
}
this.type = type;
if(!confirm(evt)) {
Log.Debug("Skipped action by user");
return false;
}
Log.Info("Launching action '{0}' :: Configuration - '{1}'", evt.Caption, (Env != null)? Env.SolutionActiveCfgString : "");
return actionBy(evt);
}
/// <summary>
/// Updating status for Event type
/// </summary>
/// <param name="tevent">Event type</param>
/// <param name="index">Position in list</param>
/// <param name="tstatus">new status</param>
public void update(SolutionEventType tevent, int index, StatusType tstatus)
{
try {
states[tevent][index] = tstatus;
}
catch(Exception ex) {
Log.Debug("Updating status: '{0}'", ex.Message);
}
}
/// <summary>
/// Flushing of all execution statuses by Event type
/// </summary>
/// <param name="tevent"></param>
public void flush(SolutionEventType tevent)
{
states[tevent] = new SynchronizedCollection<StatusType>();
}
/// <param name="type"></param>
public SBEWrap(SolutionEventType type)
{
this.type = type;
update();
}
/// <param name="sIndex">Binding index with the Execution status</param>
protected ISolutionEvent getEventByName(SolutionEventType type, string name, out int sIndex)
{
sIndex = -1;
if(String.IsNullOrEmpty(name)) {
throw new NotFoundException("getEventByName: name is null or empty");
}
ISolutionEvent[] evt = getEvent(type);
foreach(ISolutionEvent item in evt) {
++sIndex;
if(item.Name == name) {
return item;
}
}
throw new NotFoundException("getEvent: not found name - '{0}' with type - '{1}'", name, type);
}
/// <param name="sIndex">Binding index with the Execution status</param>
protected ISolutionEvent getEventByIndex(SolutionEventType type, string index, out int sIndex)
{
sIndex = -1;
ISolutionEvent[] evt = getEvent(type);
try {
sIndex = Int32.Parse(index) - 1; // >= 1
return evt[sIndex];
}
catch(Exception) {
throw new NotFoundException("getEvent: incorrect index - '{0}'({1}) with type - '{2}'", index, evt.Length, type);
}
}
private int _ignoredAction(SolutionEventType type)
{
Log.Trace("[{0}] Ignored action. It's already started in other processes of VS.", type);
return VSConstants.S_OK;
}
// --------------------------------------------------------------------------------------------
/// <summary>
/// Creates event argument for the specified event type.
/// </summary>
/// <param name="eventType">Type of solution event</param>
// --------------------------------------------------------------------------------------------
public ChangeProjectParentEventArgs(SolutionEventType eventType)
: base(eventType)
{
}
/// <summary>
/// Getting the Execution status by Event type and position in list
/// </summary>
/// <param name="tevent">Event type</param>
/// <param name="index">Position in list</param>
/// <returns>Executed status</returns>
public StatusType get(SolutionEventType tevent, int index)
{
Debug.Assert(states != null);
try {
return states[tevent][index];
}
catch(Exception) {
return StatusType.NotFound;
}
}
public DTEOperation(IEnvironment env, SolutionEventType type)
{
this.env = env;
this.type = type;
initQueue(type);
}
// --------------------------------------------------------------------------------------------
/// <summary>
/// Creates event argument for the specified event type.
/// </summary>
/// <param name="eventType">Type of solution event</param>
// --------------------------------------------------------------------------------------------
public CloseSolutionEventArgs(SolutionEventType eventType)
: base(eventType)
{
}
public void initQueue(SolutionEventType type)
{
if(queues.ContainsKey(type)) {
return;
}
queues[type] = new TQueue();
}
/// <summary>
/// Changing the Enabled staus for all event-items
/// </summary>
/// <param name="type"></param>
/// <param name="status"></param>
public void enabled(SolutionEventType type, bool status)
{
ISolutionEvent[] evt = getEvent(type);
foreach(ISolutionEvent item in evt) {
item.Enabled = status;
}
}
// --------------------------------------------------------------------------------------------
/// <summary>
/// Creates event argument for the specified event type.
/// </summary>
/// <param name="eventType">Type of solution event</param>
// --------------------------------------------------------------------------------------------
public LoadProjectEventArgs(SolutionEventType eventType)
: base(eventType)
{
}
public void restore(SolutionEventType type)
{
if(status.ContainsKey(type) && status[type] != null)
{
ISolutionEvent[] evt = getEvent(type);
for(int i = 0; i < evt.Length; ++i) {
evt[i].Enabled = status[type][i];
}
}
if(isDisabledAll(type)) {
enabled(type, true);
}
}
// --------------------------------------------------------------------------------------------
/// <summary>
/// Creates event argument for the specified event type.
/// </summary>
/// <param name="eventType">Type of solution event</param>
// --------------------------------------------------------------------------------------------
public OpenSolutionEventArgs(SolutionEventType eventType)
: base(eventType)
{
}
protected virtual ISolutionEvent[] getEvent(SolutionEventType type)
{
return Settings.Cfg.getEvent(type);
}
// --------------------------------------------------------------------------------------------
/// <summary>
/// Creates event argument for the specified event type.
/// </summary>
/// <param name="eventType">Type of solution event</param>
// --------------------------------------------------------------------------------------------
public SolutionEventArgs(SolutionEventType eventType)
{
EventType = eventType;
}
/// <summary>
/// Provides captions by event type and selection mode
/// </summary>
/// <param name="type"></param>
/// <param name="selected"></param>
/// <exception cref="*"></exception>
public string caption(SolutionEventType type, bool selected)
{
ISolutionEvent[] evt = getEvent(type);
int enabled = (evt == null)? 0 : evt.Where(i => i.Enabled).Count();
if(selected) {
return String.Format("({0} /{1})", enabled, evt.Length);
}
if(enabled < 1) {
return caption(type);
}
return String.Format("{0} ({1})", caption(type), enabled);
}
// --------------------------------------------------------------------------------------------
/// <summary>
/// Creates event argument for the specified event type.
/// </summary>
/// <param name="eventType">Type of solution event</param>
// --------------------------------------------------------------------------------------------
public SolutionNodeEventArgs(SolutionEventType eventType)
: base(eventType)
{
}
