internal void AfterTypeDragEnded(object sender, NodeDraggedEventArgs e)
{
QAliberTreeNode node = e.SourceNode.CompleteClone() as QAliberTreeNode;
TreeClipboard.Default.StoreInClipboard(new QAliberTreeNode[] { node }, false);
if (node != null)
{
if (node.Testcase != null)
{
string tcTypeName = node.Testcase.GetType().FullName;
node.Checked = node.Testcase.MarkedForExecution;
if (!testcaseIconsList.Images.ContainsKey(tcTypeName))
{
if (node.Testcase.Icon != null)
{
testcaseIconsList.Images.Add(tcTypeName, node.Testcase.Icon);
}
}
if (testcaseIconsList.Images.ContainsKey(tcTypeName))
{
node.ImageKey = node.SelectedImageKey = tcTypeName;
}
node.ContextMenuStrip = testCasesMenu;
ICommand command = new PasteCommand(e.TargetNode, true);
commandsHistory.Do(command);
OnScenarioChanged();
}
}
}
private void SetIconToNode(QAliberTreeNode node, ExecutionState state)
{
if (node != null)
{
if (node.Testcase != null)
{
switch (state)
{
case ExecutionState.NotExecuted:
break;
case ExecutionState.Paused:
node.SelectedImageKey = node.ImageKey = "InBreakpoint";
break;
case ExecutionState.InProgress:
node.SelectedImageKey = node.ImageKey = "InProgress";
break;
case ExecutionState.Executed:
break;
default:
break;
}
}
}
}
protected virtual void OnTestCaseDragged(QAliberTreeNode typeNode, QAliberTreeNode targetNode)
{
if (TestCaseDragged != null)
{
TestCaseDragged(this, new NodeDraggedEventArgs(typeNode, targetNode));
}
}
protected virtual void OnNodeDragged(QAliberTreeNode targetNode)
{
if (NodeDragged != null)
{
NodeDragged(this, new NodeDraggedEventArgs(nodeToBeDragged, targetNode));
}
}
private QAliberTreeNode AddNode(QAliberTreeNode node, TestCase testCase)
{
QAliberTreeNode child = node.LinkChild(testCase);
SetIconToNode(child, TestCaseResult.None);
child.ContextMenuStrip = testCasesMenu;
return(child);
}
protected override void OnDragDrop(DragEventArgs drgevent)
{
QAliberTreeNode targetNode = GetNodeAt(PointToClient(new Point(drgevent.X, drgevent.Y))) as QAliberTreeNode;
if (lastOverNode != null)
{
UnMarkNode(lastOverNode);
}
string data = drgevent.Data.GetData(typeof(string)) as string;
if (data != null)
{
if (targetNode != null &&
!IsAncestor(nodeToBeDragged, targetNode) &&
targetNode != nodeToBeDragged &&
targetNode != nodeToBeDragged.Parent)
{
OnNodeDragged(targetNode);
}
}
else
{
TreeNode typeNode = drgevent.Data.GetData(typeof(TreeNode)) as TreeNode;
if (typeNode != null)
{
if (targetNode != null && targetNode.Testcase != null && typeNode.Tag != null)
{
TestCase selectedTest = typeNode.Tag as TestCase;
if (selectedTest != null)
{
QAliberTreeNode QAliberNode = new QAliberTreeNode(selectedTest);
OnTestCaseDragged(QAliberNode, targetNode);
}
else
{
string file = typeNode.Tag as string;
if (file != null)
{
foreach (Type type in TestController.Default.SupportedTypes)
{
if (type.Name == "PlayMacroTestCase")
{
selectedTest = Activator.CreateInstance(type) as TestCase;
type.GetProperty("Filename").SetValue(selectedTest, file, null);
selectedTest.Name = System.IO.Path.GetFileNameWithoutExtension(file);
QAliberTreeNode QAliberNode = new QAliberTreeNode(selectedTest);
OnTestCaseDragged(QAliberNode, targetNode);
break;
}
}
}
}
}
}
}
base.OnDragDrop(drgevent);
}
private void UnMarkNode(TreeNode node)
{
QAliberTreeNode qnode = node as QAliberTreeNode;
if (qnode != null)
{
qnode.BackColor = qnode.NonHighlightBackColor;
qnode.ForeColor = qnode.NonHighlightForeColor;
}
}
public object CompleteClone()
{
QAliberTreeNode newNode = Clone() as QAliberTreeNode;
newNode.Testcase = Testcase.Clone() as TestCase;
UpdateTags(newNode, newNode.Testcase);
newNode.NonHighlightForeColor = newNode.ForeColor = newNode.Testcase.Color;
newNode.NonHighlightBackColor = newNode.BackColor = Color.White;
return(newNode);
}
public void FillTree(TestScenario scenario)
{
QAliberTreeNode node = new QAliberTreeNode(scenario.RootTestCase);
SetIconToNode(node, TestCaseResult.None);
node.ContextMenuStrip = testCasesMenu;
scenarioTreeView.Nodes.Add(node);
FillTreeRecursively(node);
testScenario = scenario;
node.Expand();
}
private void CheckNodeByColorRecursively(QAliberTreeNode node, Color color, bool check)
{
foreach (QAliberTreeNode child in node.Nodes)
{
if (child.Testcase.Color == color)
{
child.Checked = check;
}
CheckNodeByColorRecursively(child, color, check);
}
}
public void RemoveChild(QAliberTreeNode node)
{
FolderTestCase folderCase = this.testcase as FolderTestCase;
TestCase caseToBeRemoved = node.Testcase;
if (folderCase != null && caseToBeRemoved != null)
{
Nodes.Remove(node);
folderCase.Children.Remove(caseToBeRemoved);
}
}
public void AddChild(QAliberTreeNode child)
{
FolderTestCase folderCase = this.testcase as FolderTestCase;
if (folderCase != null)
{
Nodes.Add(child);
folderCase.Children.Add(child.Testcase);
child.Testcase.Scenario = folderCase.Scenario;
child.Testcase.Parent = folderCase;
}
}
public void InsertChild(int index, QAliberTreeNode node)
{
FolderTestCase folderCase = this.testcase as FolderTestCase;
if (folderCase != null)
{
Nodes.Insert(index, node);
folderCase.Children.Insert(index, node.Testcase);
node.Testcase.Scenario = folderCase.Scenario;
node.Testcase.Parent = folderCase;
}
}
private void FillTreeRecursively(QAliberTreeNode node)
{
FolderTestCase folderCase = node.Testcase as FolderTestCase;
if (folderCase != null)
{
foreach (TestCase child in folderCase.Children)
{
QAliberTreeNode childNode = AddNode(node, child);
FillTreeRecursively(childNode);
}
}
}
protected override void OnMouseDown(MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
QAliberTreeNode targetNode = GetNodeAt(new Point(e.X, e.Y)) as QAliberTreeNode;
if (targetNode != null)
{
SelectedNode = targetNode;
SelectedNodes = new QAliberTreeNode[] { targetNode };
}
}
base.OnMouseDown(e);
}
public void AddChild(TestCase testCase)
{
FolderTestCase folderCase = this.testcase as FolderTestCase;
if (testCase != null)
{
QAliberTreeNode node = new QAliberTreeNode(testCase);
Nodes.Add(node);
folderCase.Children.Add(testCase);
testCase.Scenario = folderCase.Scenario;
testCase.Parent = folderCase;
}
}
public void InsertChild(int index, TestCase testCase)
{
FolderTestCase folderCase = this.testcase as FolderTestCase;
if (testCase != null)
{
QAliberTreeNode node = new QAliberTreeNode(testCase);
Nodes.Insert(index, node);
folderCase.Children.Insert(index, testCase);
testCase.Scenario = folderCase.Scenario;
testCase.Parent = folderCase;
}
}
public QAliberTreeNode LinkChild(TestCase testCase)
{
FolderTestCase folderCase = this.testcase as FolderTestCase;
if (testCase != null)
{
QAliberTreeNode node = new QAliberTreeNode(testCase);
Nodes.Add(node);
testCase.Scenario = folderCase.Scenario;
testCase.Parent = folderCase;
return(node);
}
return(null);
}
private void UpdateTags(QAliberTreeNode node, TestCase testcase)
{
node.Testcase = testcase;
FolderTestCase folder = testcase as FolderTestCase;
if (folder != null)
{
if (node.Nodes.Count == folder.Children.Count)
{
for (int i = 0; i < folder.Children.Count; i++)
{
UpdateTags((QAliberTreeNode)node.Nodes[i], folder.Children[i]);
}
}
}
}
internal void MenuAddTestCaseClicked(object sender, EventArgs e)
{
// BJC: As above
if (scenarioTreeView.SelectedNode != null)
{
QAliberTreeNode node = new QAliberTreeNode(new ActualTestCase()
{
MarkedForExecution = true
});
SetIconToNode(node, TestCaseResult.None);
UpdateContextMenusAndIconsRec(node);
ICommand command = new InsertCommand((QAliberTreeNode)scenarioTreeView.SelectedNode,
new QAliberTreeNode[] { node });
commandsHistory.Do(command);
}
}
internal void MenuAddFolderClicked(object sender, EventArgs e)
{
// BJC: I object to this way of structuring menu handlers,
// but when in Rome...
if (scenarioTreeView.SelectedNode != null)
{
QAliberTreeNode node = new QAliberTreeNode(new FolderTestCase()
{
MarkedForExecution = true
});
SetIconToNode(node, TestCaseResult.None);
UpdateContextMenusAndIconsRec(node);
ICommand command = new InsertCommand((QAliberTreeNode)scenarioTreeView.SelectedNode,
new QAliberTreeNode[] { node });
commandsHistory.Do(command);
}
}
private void UpdateContextMenusAndIconsRec(QAliberTreeNode node)
{
string tcTypeName = node.Testcase.GetType().FullName;
if (!testcaseIconsList.Images.ContainsKey(tcTypeName))
{
if (node.Testcase.Icon != null)
{
testcaseIconsList.Images.Add(tcTypeName, node.Testcase.Icon);
}
}
if (testcaseIconsList.Images.ContainsKey(tcTypeName))
{
node.ImageKey = node.SelectedImageKey = tcTypeName;
}
node.ContextMenuStrip = testCasesMenu;
foreach (TreeNode child in node.Nodes)
{
UpdateContextMenusAndIconsRec((QAliberTreeNode)child);
}
}
internal void FindPrevPropertyValuePair(string property, string val, bool exactMatch)
{
QAliberTreeNode currentNode = scenarioTreeView.SelectedNode != null ? (QAliberTreeNode)scenarioTreeView.SelectedNode : (QAliberTreeNode)scenarioTreeView.Nodes[0];
currentNode = currentNode.GetPrevNode() as QAliberTreeNode;
while (currentNode != null)
{
TestCase testcase = currentNode.Testcase;
foreach (PropertyDescriptor prop in TypeDescriptor.GetProperties(testcase))
{
if (string.Compare(prop.DisplayName, property, true) == 0)
{
if ((exactMatch && string.Compare(prop.GetValue(testcase).ToString(), val) == 0) ||
(!exactMatch && prop.GetValue(testcase).ToString().ToLower().Contains(val.ToLower())))
{
scenarioTreeView.SelectedNode = currentNode;
currentNode.EnsureVisible();
return;
}
}
}
currentNode = currentNode.GetPrevNode() as QAliberTreeNode;
}
}
private TreeNode GetNodeByID(QAliberTreeNode node, int id)
{
TestCase testcase = node.Testcase as TestCase;
if (testcase != null)
{
if (testcase.ID == id)
{
return(node);
}
else
{
foreach (QAliberTreeNode child in node.Nodes)
{
TreeNode res = GetNodeByID(child, id);
if (res != null)
{
return(res);
}
}
}
}
return(null);
}
public NodeDraggedEventArgs(QAliberTreeNode src, QAliberTreeNode target)
{
this.src = src;
this.target = target;
}
private void SetIconToNode(QAliberTreeNode node, TestCaseResult result)
{
if (node != null)
{
if (node.Testcase != null)
{
string type = node.Testcase.GetType().FullName;
switch (result)
{
case TestCaseResult.None:
if (testcaseIconsList.Images.ContainsKey(type))
{
node.SelectedImageKey = node.ImageKey = type;
}
else
{
if (node.Testcase.Icon == null)
{
node.SelectedImageKey = node.ImageKey = "Generic";
}
else
{
testcaseIconsList.Images.Add(type, node.Testcase.Icon);
node.SelectedImageKey = node.ImageKey = type;
}
}
return;
case TestCaseResult.Passed:
case TestCaseResult.Failed:
string pfType = type + "---" + result.ToString();
if (!testcaseIconsList.Images.ContainsKey(pfType))
{
Bitmap bitmap = new Bitmap(16, 16);
using (Graphics graphics = Graphics.FromImage(bitmap))
{
if (!testcaseIconsList.Images.ContainsKey(type))
{
type = "Generic";
}
graphics.DrawImage(testcaseIconsList.Images[type], 0, 0);
if (result == TestCaseResult.Failed)
{
graphics.DrawImage(Properties.Resources.Error, 7, 0);
}
else
{
graphics.DrawImage(Properties.Resources.Pass, 7, 0);
}
testcaseIconsList.Images.Add(pfType, bitmap);
}
}
node.SelectedImageKey = node.ImageKey = pfType;
break;
default:
break;
}
}
}
}
