/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
ParagraphTreeNode paragraphTreeNode = sourceNode as ParagraphTreeNode;
if (paragraphTreeNode != null)
{
Item.FindOrCreateReqRef(paragraphTreeNode.Item);
}
}
/// <summary>
/// Accepts a drop event
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
if (sourceNode is ParagraphTreeNode)
{
ParagraphTreeNode paragraph = sourceNode as ParagraphTreeNode;
Item.Name = paragraph.Item.FullId;
RefreshNode();
}
}
/// <summary>
/// Handles a drop event
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
ParagraphTreeNode paragraphTreeNode = sourceNode as ParagraphTreeNode;
if (paragraphTreeNode != null)
{
Item.FindOrCreateReqRef(paragraphTreeNode.Item);
}
else
{
ReqRefTreeNode reqRefTreeNode = sourceNode as ReqRefTreeNode;
if (reqRefTreeNode != null)
{
Item.FindOrCreateReqRef(reqRefTreeNode.Item.Paragraph);
}
}
}
/// <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 FunctionTreeNode)
{
FunctionTreeNode node = sourceNode as FunctionTreeNode;
Function function = node.Item;
Function duplFunction = OverallFunctionFinder.INSTANCE.findByName(function.Dictionary, function.Name);
if (duplFunction != null) // If there is a function with the same name, we must delete it
{
if (
MessageBox.Show("Are you sure you want to move the corresponding function?", "Move action",
MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
for (int i = 0; i < Nodes.Count; i++)
{
FunctionTreeNode temp = Nodes[i] as FunctionTreeNode;
if (temp != null && temp.Item.Name == function.Name)
{
temp.Delete();
}
}
node.Delete();
Item.appendFunctions(function);
}
}
else
{
node.Delete();
Item.appendFunctions(function);
}
}
else if (sourceNode is ParagraphTreeNode)
{
ParagraphTreeNode node = sourceNode as ParagraphTreeNode;
Paragraph paragraph = node.Item;
Function function = Function.CreateDefault(Item.Functions);
Item.appendFunctions(function);
function.FindOrCreateReqRef(paragraph);
}
}
/// <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 RuleConditionTreeNode)
{
RuleConditionTreeNode node = sourceNode as RuleConditionTreeNode;
RuleCondition ruleCondition = node.Item;
node.Delete();
Item.appendConditions(ruleCondition);
}
else if (sourceNode is ParagraphTreeNode)
{
ParagraphTreeNode node = sourceNode as ParagraphTreeNode;
Paragraph paragraph = node.Item;
RuleCondition ruleCondition = RuleCondition.CreateDefault(Item.RuleConditions);
Item.appendConditions(ruleCondition);
ruleCondition.FindOrCreateReqRef(paragraph);
}
}
/// <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 RangeTreeNode)
{
RangeTreeNode rangeTreeNode = sourceNode as RangeTreeNode;
Range range = rangeTreeNode.Item;
rangeTreeNode.Delete();
Item.appendRanges(range);
}
else if (sourceNode is ParagraphTreeNode)
{
ParagraphTreeNode node = sourceNode as ParagraphTreeNode;
Paragraph paragaph = node.Item;
Range range = Range.CreateDefault(Item.Ranges);
Item.appendRanges(range);
range.FindOrCreateReqRef(paragaph);
}
}
/// <summary>
/// Accepts a new procedure
/// </summary>
/// <param name="sourceNode"></param>
public override void AcceptDrop(BaseTreeNode sourceNode)
{
base.AcceptDrop(sourceNode);
if (sourceNode is ProcedureTreeNode)
{
ProcedureTreeNode procedureTreeNode = sourceNode as ProcedureTreeNode;
Procedure procedure = procedureTreeNode.Item;
procedureTreeNode.Delete();
Item.appendProcedures(procedure);
}
else if (sourceNode is ParagraphTreeNode)
{
ParagraphTreeNode node = sourceNode as ParagraphTreeNode;
Paragraph paragraph = node.Item;
Procedure procedure = Procedure.CreateDefault(Item.Procedures);
Item.appendProcedures(procedure);
procedure.FindOrCreateReqRef(paragraph);
}
}
/// <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 StateMachineTreeNode)
{
StateMachineTreeNode stateMachineTreeNode = sourceNode as StateMachineTreeNode;
StateMachine stateMachine = stateMachineTreeNode.Item;
stateMachineTreeNode.Delete();
Item.appendStateMachines(stateMachine);
}
else if (sourceNode is ParagraphTreeNode)
{
ParagraphTreeNode node = sourceNode as ParagraphTreeNode;
Paragraph paragraph = node.Item;
StateMachine stateMachine = StateMachine.CreateDefault(Item.StateMachines);
Item.appendStateMachines(stateMachine);
stateMachine.FindOrCreateReqRef(paragraph);
}
}
/// <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 EnumerationTreeNode)
{
EnumerationTreeNode enumerationTreeNode = sourceNode as EnumerationTreeNode;
Enum enumeration = enumerationTreeNode.Item;
enumerationTreeNode.Delete();
Item.appendEnumerations(enumeration);
}
else if (sourceNode is ParagraphTreeNode)
{
ParagraphTreeNode node = sourceNode as ParagraphTreeNode;
Paragraph paragraph = node.Item;
Enum enumeration = Enum.CreateDefault(Item.Enumerations);
Item.appendEnumerations(enumeration);
enumeration.FindOrCreateReqRef(paragraph);
}
}
/// <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 CollectionTreeNode)
{
CollectionTreeNode collectionTreeNode = sourceNode as CollectionTreeNode;
Collection collection = collectionTreeNode.Item;
collectionTreeNode.Delete();
Item.appendCollections(collection);
}
else if (sourceNode is ParagraphTreeNode)
{
ParagraphTreeNode node = sourceNode as ParagraphTreeNode;
Paragraph paragraph = node.Item;
Collection collection = Collection.CreateDefault(Item.Collections);
Item.appendCollections(collection);
collection.FindOrCreateReqRef(paragraph);
}
}
/// <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 VariableTreeNode)
{
VariableTreeNode variableTreeNode = sourceNode as VariableTreeNode;
Variable variable = variableTreeNode.Item;
variableTreeNode.Delete();
Item.appendVariables(variable);
}
else if (sourceNode is ParagraphTreeNode)
{
ParagraphTreeNode node = sourceNode as ParagraphTreeNode;
Paragraph paragraph = node.Item;
Variable variable = Variable.CreateDefault(Item.Variables);
Item.appendVariables(variable);
variable.FindOrCreateReqRef(paragraph);
}
}
/// <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);
}
}
