public override async Task OnClick(BaseTreeNode node_, Symmetry.Carbon.Client.ICarbonClient cc_)
{
var frm = new UserBbgListEditor();
try
{
frm.Create(
listName_: node_.Text,
currentTickers_: UserBbgLists.Instance.GetCurrentTickersForList(node_.Text));
var result = frm.DisplayInShowFormDialog(string.Format("Edit bbg list '{0}'", node_.Text), null);
if (result == System.Windows.Forms.DialogResult.Cancel) return;
var listname = frm.ListName;
var tickers = frm.Tickers;
await UserBbgLists.Instance.UpdateList(
listName_: frm.ListName,
tickersAndFields_: frm.Tickers.Select(ticker => Tuple.Create(ticker, "LAST_PRICE")),
cc_: cc_);
}
finally
{
frm.Dispose();
}
}
/// <summary>
/// Accepts drop of a tree node, in a drag & drop operation
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
if (sourceNode is StructureElementTreeNode)
{
StructureElementTreeNode structureElementTreeNode = sourceNode as StructureElementTreeNode;
StructureElement element = structureElementTreeNode.Item;
structureElementTreeNode.Delete();
Item.appendElements(element);
}
else if (sourceNode is ParagraphTreeNode)
{
ParagraphTreeNode node = sourceNode as ParagraphTreeNode;
Paragraph paragaph = node.Item;
StructureElement element = (StructureElement) acceptor.getFactory().createStructureElement();
element.Name = paragaph.Name;
ReqRef reqRef = (ReqRef) acceptor.getFactory().createReqRef();
reqRef.Name = paragaph.FullId;
element.appendRequirements(reqRef);
Item.appendElements(element);
}
}
/// <summary>
/// Accepts drop of a tree node, in a drag & drop operation
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
base.AcceptDrop(SourceNode);
if (SourceNode is StructureElementTreeNode)
{
StructureElementTreeNode structureElementTreeNode = SourceNode as StructureElementTreeNode;
DataDictionary.Types.StructureElement element = structureElementTreeNode.Item;
structureElementTreeNode.Delete();
AddElement(element);
}
else if (SourceNode is SpecificationView.ParagraphTreeNode)
{
SpecificationView.ParagraphTreeNode node = SourceNode as SpecificationView.ParagraphTreeNode;
DataDictionary.Specification.Paragraph paragaph = node.Item;
DataDictionary.Types.StructureElement element = (DataDictionary.Types.StructureElement)DataDictionary.Generated.acceptor.getFactory().createStructureElement();
element.Name = paragaph.Name;
DataDictionary.ReqRef reqRef = (DataDictionary.ReqRef)DataDictionary.Generated.acceptor.getFactory().createReqRef();
reqRef.Name = paragaph.FullId;
element.appendRequirements(reqRef);
AddElement(element);
}
}
public ContextMenuItem(IContextMenuDefinition def_, BaseTreeNode node_, ICarbonClient cc_)
{
Text = def_.ItemText(node_);
if(def_.ItemImage!=null) Image = def_.ItemImage(node_);
m_node = node_;
m_definition = def_;
m_cc = cc_;
Click += handleClick;
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
base.AcceptDrop(SourceNode);
if (SourceNode is RuleTreeNode)
{
RuleTreeNode node = SourceNode as RuleTreeNode;
DataDictionary.Rules.Rule rule = node.Item;
node.Delete();
AddRule(rule);
}
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
if (sourceNode is RuleTreeNode)
{
RuleTreeNode node = sourceNode as RuleTreeNode;
Rule rule = node.Item;
node.Delete();
Item.appendRules(rule);
}
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
base.AcceptDrop(SourceNode);
if (SourceNode is ParameterTreeNode)
{
ParameterTreeNode node = SourceNode as ParameterTreeNode;
DataDictionary.Parameter parameter = node.Item;
node.Delete();
AddParameter(parameter);
}
}
public void AddParent(BaseTreeNode parent)
{
if (parent != null)
{
if (parent.childNodes == null)
{
parent.childNodes = new List <BaseTreeNode>();
}
parent.childNodes.Add(this);
}
this.parentNode = parent;
}
/// <summary>
/// Returns all children of BaseTreeNode, including node itself.
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
private IEnumerable <BaseTreeNode> GetAllChildren(BaseTreeNode node)
{
yield return(node);
foreach (BaseTreeNode child in node.Children)
{
foreach (BaseTreeNode childChild in GetAllChildren(child))
{
yield return(childChild);
}
}
}
private void TvConnectionsLeftClick(BaseTreeNode baseTreeNode)
{
if (baseTreeNode.NodeType == NodeType.Connection)
{
var connectionNode = (ConnectionNode)baseTreeNode;
if (!connectionNode.HasConnected)
{
AttemptConnection(connectionNode);
}
}
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
if (sourceNode is ParameterTreeNode)
{
ParameterTreeNode node = sourceNode as ParameterTreeNode;
Parameter parameter = node.Item;
node.Delete();
Item.appendParameters(parameter);
}
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
if (sourceNode is CaseTreeNode)
{
CaseTreeNode node = sourceNode as CaseTreeNode;
Case aCase = node.Item;
node.Delete();
Item.appendCases(aCase);
}
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
base.AcceptDrop(SourceNode);
if (SourceNode is ParameterTreeNode)
{
ParameterTreeNode node = SourceNode as ParameterTreeNode;
DataDictionary.Parameter parameter = node.Item;
node.Delete();
AddParameter(parameter);
}
}
private void treeView_AfterSelect(object sender, TreeViewEventArgs e)
{
this.treeViewDefinition.BeginUpdate();
this.treeViewDefinition.Nodes.Clear();
BaseTreeNode node = e.Node as BaseTreeNode;
if (node != null)
{
node.OnPopulateDefinitionTree(this.treeViewDefinition.Nodes);
this.treeViewDefinition.EndUpdate();
}
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
if (sourceNode is CaseTreeNode)
{
CaseTreeNode node = sourceNode as CaseTreeNode;
Case aCase = node.Item;
node.Delete();
Item.appendCases(aCase);
}
}
/// <summary>
/// Handles a mouse up event
/// </summary>
/// <param name="sender"></param>
/// <param name="mouseEventArgs"></param>
private void HandleMouseUp(object sender, MouseEventArgs mouseEventArgs)
{
GraphicElement element = ElementForLocation(mouseEventArgs.Location, _movingBox);
if (element != null)
{
element.HandleMouseUp(sender, mouseEventArgs);
}
if (_changingArrow != null)
{
_changingArrow = null;
_chaningArrowAction = ChangeAction.None;
RefreshControl();
}
if (_movingBox != null)
{
if (_movingBoxHasMoved)
{
if (element != null)
{
BaseTreeNode targetNode = CorrespondingNode(element.Model as IModelElement);
BaseTreeNode sourceNode = CorrespondingNode(_movingBox.Model as IModelElement);
if (targetNode != null && sourceNode != null && sourceNode != targetNode)
{
targetNode.AcceptDrop(sourceNode);
_movingBox.Location = new Point(0, 0);
if (Settings.Default.AllowRefactor)
{
RefactorAndRelocateOperation refactorAndRelocate =
new RefactorAndRelocateOperation(sourceNode.Model as ModelElement);
refactorAndRelocate.ExecuteUsingProgressDialog(GuiUtils.MdiWindow, "Refactoring", false);
}
}
}
// Register the fact that the element has moved
// because
if (_movingBox.TypedModel.X != _positionBeforeMove.X ||
_movingBox.TypedModel.Y != _positionBeforeMove.Y)
{
EfsSystem.Instance.Context.HandleChangeEvent(_movingBox.Model as BaseModelElement,
Context.ChangeKind.ModelChange);
}
}
_movingBox = null;
_movingBoxHasMoved = false;
}
}
// The main work is done here.
// Find out if smart folder mode is being used
// If false, return active image based on aspectValue.
// If true, calculate correct icon to show depending on aspectValue and all parent values.
// If a parent is true, the icon will be active and based on aspectValue.
// If a parent is false, the icon will be inactive and based on aspectValue.
public override void Render(Graphics g, Rectangle r)
{
this.DrawBackground(g, r);
r = this.ApplyCellPadding(r);
Image image = null;
bool? aspectValue = this.Aspect as bool?;
// Is the listItem enabled? If so, we need to calculate the correct active/inactive icon.
if (ListItem.Enabled)
{
NlmTreeListView ListView = this.ListView as NlmTreeListView;
if (ListView.SmartFolderMode)
{
BaseTreeNode baseTreeNode = this.RowObject as BaseTreeNode;
bool parentValue = true;
while (baseTreeNode.Parent != null)
{
INLMColumn nlmColumn = this.Column as INLMColumn;
if ((Boolean?)nlmColumn.AspectEngine.GetAspect(baseTreeNode.Parent) == false)
{
parentValue = false;
break;
}
baseTreeNode = baseTreeNode.Parent;
}
if (parentValue)
{
image = GetActiveImage(aspectValue);
}
else
{
image = GetInactiveImage(aspectValue);
}
}
// Dumb folder mode is a lot simpler :)
else
{
image = GetActiveImage(aspectValue);
}
}
// If the item is disabled we want it to have 50% opacity, so we always use the inactive image.
else
{
image = GetInactiveImage(aspectValue);
}
// Finally, after all that work, let's draw the image.
if (image != null)
{
this.DrawAlignedImage(g, r, image);
}
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
base.AcceptDrop(SourceNode);
if (SourceNode is CaseTreeNode)
{
CaseTreeNode node = SourceNode as CaseTreeNode;
DataDictionary.Functions.Case aCase = node.Item;
node.Delete();
AddCase(aCase);
}
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
if (sourceNode is ParameterTreeNode)
{
ParameterTreeNode node = sourceNode as ParameterTreeNode;
Parameter parameter = node.Item;
node.Delete();
Item.appendParameters(parameter);
}
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
base.AcceptDrop(SourceNode);
if (SourceNode is CaseTreeNode)
{
CaseTreeNode node = SourceNode as CaseTreeNode;
DataDictionary.Functions.Case aCase = node.Item;
node.Delete();
AddCase(aCase);
}
}
/// <summary>
/// Accepts drop of a tree node, in a drag & drop operation
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
base.AcceptDrop(SourceNode);
if (SourceNode is NameSpaceTreeNode)
{
NameSpaceTreeNode nameSpaceTreeNode = SourceNode as NameSpaceTreeNode;
DataDictionary.Types.NameSpace nameSpace = nameSpaceTreeNode.Item;
nameSpaceTreeNode.Delete();
AddNameSpace(nameSpace);
}
}
public void AddChild(BaseTreeNode child)
{
if (child == null)
{
return;
}
if (childNodes == null)
{
childNodes = new List <BaseTreeNode>();
}
childNodes.Add(child);
child.parentNode = this;
}
/// <summary>
/// Accepts drop of a tree node, in a drag & drop operation
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
if (sourceNode is InterfaceTreeNode)
{
InterfaceTreeNode interfaceTreeNode = sourceNode as InterfaceTreeNode;
Structure structure = interfaceTreeNode.Item;
interfaceTreeNode.Delete();
Item.appendStructures(structure);
}
}
/// <summary>
/// Provides the base tree node associated to a model element
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
protected override BaseTreeNode CorrespondingNode(IModelElement model)
{
BaseTreeNode retVal = base.CorrespondingNode(model);
StateMachine stateMachine = model as StateMachine;
if (retVal == null && stateMachine != null && stateMachine.EnclosingState != null)
{
retVal = base.CorrespondingNode(stateMachine.EnclosingState);
}
return(retVal);
}
/// <summary>
/// Provides the base tree node associated to a model element
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
protected virtual BaseTreeNode CorrespondingNode(IModelElement model)
{
BaseTreeNode retVal = null;
IBaseForm baseForm = GuiUtils.EnclosingFinder <IBaseForm> .Find(this);
if (baseForm != null && baseForm.TreeView != null)
{
retVal = baseForm.TreeView.FindNode(model, true);
}
return(retVal);
}
// Find out if any parent nodes are NOT active, and if they are not return FALSE.
private Object getTreeNodeCellActive(BaseTreeNode treeNode, Boolean value)
{
while (treeNode.Parent != null)
{
if ((bool?)Column.GetValue(treeNode.Parent) == false)
{
value = false;
break;
}
treeNode = treeNode.Parent;
}
return(value);
}
/// <summary>
/// Accepts drop of a tree node, in a drag & drop operation
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
if (sourceNode is NameSpaceTreeNode)
{
NameSpaceTreeNode nameSpaceTreeNode = sourceNode as NameSpaceTreeNode;
NameSpace nameSpace = nameSpaceTreeNode.Item;
nameSpaceTreeNode.Delete();
Item.appendNameSpaces(nameSpace);
}
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
if (SourceNode is DataDictionaryView.PreConditionTreeNode)
{
if (MessageBox.Show("Are you sure you want to move the corresponding pre-condition ?", "Move pre-condition", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
DataDictionaryView.PreConditionTreeNode preConditionTreeNode = (DataDictionaryView.PreConditionTreeNode)SourceNode;
DataDictionary.Rules.PreCondition preCondition = preConditionTreeNode.Item;
preConditionTreeNode.Delete();
AddPreCondition(preCondition);
}
}
}
private void TvConnectionsRightClick(BaseTreeNode treeNode)
{
tvConnections.ContextMenuStrip = null;
SelectedNode = treeNode;
if (treeNode.NodeType == NodeType.NewConnection)
{
}
else if (treeNode.NodeType == NodeType.Connection)
{
var connectionNode = (ConnectionNode)(treeNode);
if (BlockStudioProjectService.BlockStudioProject.Connection.ConnectionType == ConnectionType.Instance)
{
ConnectionNodeContextMenu.Items[0].Text = connectionNode.HasConnected ? "&Refresh" : "&Connect";
ConnectionNodeContextMenu.Items[3].Enabled = true;
}
else
{
ConnectionNodeContextMenu.Items[3].Enabled = false;
}
tvConnections.ContextMenuStrip = ConnectionNodeContextMenu;
}
else if (treeNode.NodeType == NodeType.AccountParent)
{
tvConnections.ContextMenuStrip = AccountParentContextMenuStrip;
}
else if (treeNode.NodeType == NodeType.Account)
{
var accountNode = (AccountNode)treeNode;
if (accountNode.Account.LockState == LockedState.Unlocked)
{
AccountContextMenuStrip.Items[0].Enabled = false;
AccountContextMenuStrip.Items[1].Enabled = true;
}
else
{
AccountContextMenuStrip.Items[0].Enabled = true;
AccountContextMenuStrip.Items[1].Enabled = false;
}
tvConnections.ContextMenuStrip = AccountContextMenuStrip;
}
else if (treeNode.NodeType == NodeType.Address)
{
tvConnections.ContextMenuStrip = addressMenuStrip;
}
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
if (SourceNode is DataDictionaryView.PreConditionTreeNode)
{
if (MessageBox.Show("Are you sure you want to move the corresponding pre-condition ?", "Move pre-condition", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
DataDictionaryView.PreConditionTreeNode preConditionTreeNode = (DataDictionaryView.PreConditionTreeNode)SourceNode;
DataDictionary.Rules.PreCondition preCondition = preConditionTreeNode.Item;
preConditionTreeNode.Delete();
AddPreCondition(preCondition);
}
}
}
/// <summary>
/// Returns True if an ancestor is Selected. Returns False if an ancestor is not selected.
/// </summary>
public Boolean IsAncestorSelected(BaseTreeNode treeNode)
{
BaseTreeNode parent = treeNode.Parent;
while (parent != null)
{
if (ListView.IsSelected(parent))
{
return(true);
}
parent = parent.Parent;
}
return(false);
}
/// <summary>
/// Handles drop event
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
SourceTextTreeNode sourceTextTreeNode = Parent as SourceTextTreeNode;
SourceTextCommentTreeNode comment = sourceNode as SourceTextCommentTreeNode;
if (comment != null && sourceTextTreeNode != null)
{
SourceTextComment otherText = (SourceTextComment)comment.Item.Duplicate();
sourceTextTreeNode.Item.appendComments(otherText);
comment.Delete();
}
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
if (SourceNode is RuleTreeNode)
{
if (MessageBox.Show("Are you sure you want to move the corresponding rule ?", "Move rule", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
RuleTreeNode ruleTreeNode = (RuleTreeNode)SourceNode;
DataDictionary.Rules.Rule rule = ruleTreeNode.Item;
ruleTreeNode.Delete();
AddRule(rule);
}
}
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
if (SourceNode is ParagraphTreeNode)
{
if (MessageBox.Show("Are you sure you want to move the corresponding paragraph?", "Move paragraph", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
ParagraphTreeNode paragraphTreeNode = (ParagraphTreeNode)SourceNode;
DataDictionary.Specification.Paragraph paragraph = paragraphTreeNode.Item;
paragraphTreeNode.Delete();
AddParagraph(paragraph);
}
}
}
private void ApplyFilterToEventTree(HashSet <Object> filter, FilterMode mode)
{
if (FocusCallStack.IsChecked ?? true)
{
mode.HideNotRelative = true;
}
if (FilterByTime.IsChecked ?? true)
{
double limit = 0.0;
if (Double.TryParse(TimeLimit.Text.Replace(',', '.'), NumberStyles.Any, CultureInfo.InvariantCulture, out limit))
{
mode.TimeLimit = limit;
}
}
HashSet <Object> roof = null;
if (filter != null && filter.Count > 0)
{
roof = new HashSet <Object>();
foreach (Object node in filter)
{
BaseTreeNode current = (node as BaseTreeNode).Parent;
while (current != null)
{
if (!roof.Add(current))
{
break;
}
current = current.Parent;
}
}
}
foreach (var node in EventTreeView.ItemsSource)
{
if (node is BaseTreeNode)
{
BaseTreeNode eventNode = node as BaseTreeNode;
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
eventNode.ApplyFilter(roof, filter, mode);
}), DispatcherPriority.Loaded);
}
}
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
if (SourceNode is RuleTreeNode)
{
if (MessageBox.Show("Are you sure you want to move the corresponding rule ?", "Move rule", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
RuleTreeNode ruleTreeNode = (RuleTreeNode)SourceNode;
DataDictionary.Rules.Rule rule = ruleTreeNode.Item;
ruleTreeNode.Delete();
AddRule(rule);
}
}
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
if (SourceNode is ActionTreeNode)
{
if (MessageBox.Show("Are you sure you want to move the corresponding action ?", "Move action", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
ActionTreeNode actionTreeNode = (ActionTreeNode)SourceNode;
DataDictionary.Rules.Action action = actionTreeNode.Item;
actionTreeNode.Delete();
AddAction(action);
}
}
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
if (SourceNode is ActionTreeNode)
{
if (MessageBox.Show("Are you sure you want to move the corresponding action ?", "Move action", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
ActionTreeNode actionTreeNode = (ActionTreeNode)SourceNode;
DataDictionary.Rules.Action action = actionTreeNode.Item;
actionTreeNode.Delete();
AddAction(action);
}
}
}
// If folder value changes in hierarchy mode, recursively change all child layer node values to match.
private void SetFolderCheckState(BaseTreeNode treeNode, Boolean value)
{
for (int i = 0; i < treeNode.Children.Count; i++)
{
BaseTreeNode child = treeNode.Children[i];
if (child is LayerTreeNode)
{
Column.PutValue(child, value);
}
if (child is FolderTreeNode && child.Children.Count > 0)
{
SetFolderCheckState(child, value);
}
}
}
public override async Task OnClick(BaseTreeNode node_, Symmetry.Carbon.Client.ICarbonClient cc_)
{
var leaf = node_ as TreeNode_Leaf;
var series = await SeriesList.Instance.Retrieve(leaf.Config, cc_);
if (series != null && series.Series != null)
{
var chart = new PeriodLineChart.PeriodLineChart();
chart.Create();
chart.SetValues(series, PeriodLineChart.TimePeriod.YearOne);
chart.DisplayInShowForm(node_.Text);
}
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
base.AcceptDrop(SourceNode);
if (SourceNode is PreConditionTreeNode)
{
if (MessageBox.Show("Are you sure you want to move the corresponding function ?", "Move action", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
PreConditionTreeNode node = SourceNode as PreConditionTreeNode;
DataDictionary.Rules.PreCondition preCondition = node.Item;
node.Delete();
AddPreCondition(preCondition);
}
}
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="SourceNode"></param>
public override void AcceptDrop(BaseTreeNode SourceNode)
{
base.AcceptDrop(SourceNode);
if (SourceNode is PreConditionTreeNode)
{
if (MessageBox.Show("Are you sure you want to move the corresponding function ?", "Move action", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
PreConditionTreeNode node = SourceNode as PreConditionTreeNode;
DataDictionary.Rules.PreCondition preCondition = node.Item;
node.Delete();
AddPreCondition(preCondition);
}
}
}
/// <summary>
/// Create structure based on the subsystem structure
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
PreConditionTreeNode preConditionTreeNode = sourceNode as PreConditionTreeNode;
if (preConditionTreeNode != null)
{
if (
MessageBox.Show("Are you sure you want to move the corresponding function ?", "Move action",
MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
preConditionTreeNode.Delete();
Item.appendPreConditions(preConditionTreeNode.Item);
}
}
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
ActionTreeNode actionTreeNode = sourceNode as ActionTreeNode;
if (actionTreeNode != null)
{
if (
MessageBox.Show("Are you sure you want to move the corresponding action ?", "Move action",
MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
Action action = actionTreeNode.Item;
actionTreeNode.Delete();
Item.appendActions(action);
Item.setVerified(false);
}
}
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
RuleTreeNode ruleTreeNode = sourceNode as RuleTreeNode;
if (ruleTreeNode != null)
{
if (
MessageBox.Show("Are you sure you want to move the corresponding rule ?", "Move rule",
MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
Rule rule = ruleTreeNode.Item;
ruleTreeNode.Delete();
Item.appendSubRules(rule);
Item.setVerified(false);
}
}
}
private void explainTreeView_DragDrop(object sender, DragEventArgs e)
{
if (e.Data.GetDataPresent("WindowsForms10PersistentObject", false))
{
object data = e.Data.GetData("WindowsForms10PersistentObject");
BaseTreeNode sourceNode = data as BaseTreeNode;
if (sourceNode != null)
{
VariableTreeNode variableTreeNode = sourceNode as VariableTreeNode;
if (variableTreeNode != null)
{
ExpandAndShowVariable(new VariableSelector(variableTreeNode.Item));
}
}
}
}
/// <summary>
/// Accepts drop of a tree node, in a drag & drop operation
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
if (sourceNode is StructureElementTreeNode)
{
StructureElementTreeNode structureElementTreeNode = sourceNode as StructureElementTreeNode;
StructureElement element = structureElementTreeNode.Item;
structureElementTreeNode.Delete();
Item.appendElements(element);
}
else if (sourceNode is ParagraphTreeNode)
{
ParagraphTreeNode node = sourceNode as ParagraphTreeNode;
Paragraph paragraph = node.Item;
StructureElement element = StructureElement.CreateDefault(Item.Elements);
Item.appendElements(element);
element.FindOrCreateReqRef(paragraph);
}
}
public new void Dispose()
{
m_definition = null;
m_node = null;
m_cc = null;
}
public override async Task OnClick(BaseTreeNode node_, Symmetry.Carbon.Client.ICarbonClient cc_)
{
SeriesList.Instance.ClearCache();
await SeriesList.Instance.GetConfigList(cc_,forceRefresh_:true);
}
void FrameInfo_OnSelectedTreeNodeChanged(Data.Frame frame, BaseTreeNode node)
{
if (node is EventNode && frame is EventFrame)
{
ThreadView.FocusOn(frame as EventFrame, node as EventNode);
}
}
