public void SetUp()
{
XmlCompletionDataProvider completionDataProvider = new XmlCompletionDataProvider(new XmlSchemaCompletionDataCollection(), null, String.Empty);
treeViewContainerControl = new XmlTreeViewContainerControl();
treeView = treeViewContainerControl.TreeView;
treeViewContainerControl.LoadXml("<root><top>text</top><bottom><child>text</child></bottom></root>", completionDataProvider);
doc = treeViewContainerControl.Document;
ExtTreeNode rootNode = (ExtTreeNode)treeView.Nodes[0];
rootNode.Expanding();
topElementTreeNode = (XmlElementTreeNode)rootNode.Nodes[0];
topElementTreeNode.Expanding();
topTextTreeNode = (XmlTextTreeNode)topElementTreeNode.Nodes[0];
ExtTreeNode bottomNode = (ExtTreeNode)rootNode.Nodes[1];
bottomNode.Expanding();
childElementTreeNode = (XmlElementTreeNode)bottomNode.Nodes[0];
childElementTreeNode.Expanding();
}
public static void DoPaste(ISolutionFolderNode folderNode)
{
System.Windows.IDataObject dataObject = SD.Clipboard.GetDataObject();
if (!DoEnablePaste(folderNode.Folder, dataObject))
{
LoggingService.Warn("SolutionFolderNode.DoPaste: Pasting was not enabled.");
return;
}
ExtTreeNode folderTreeNode = (ExtTreeNode)folderNode;
if (dataObject.GetDataPresent(typeof(ISolutionItem).ToString()))
{
Guid guid = Guid.Parse(dataObject.GetData(typeof(ISolutionItem).ToString()).ToString());
ISolutionItem solutionItem = folderNode.Solution.GetItemByGuid(guid);
if (solutionItem != null)
{
MoveItem(solutionItem, folderNode.Folder);
ExtTreeView treeView = (ExtTreeView)folderTreeNode.TreeView;
foreach (ExtTreeNode node in treeView.CutNodes)
{
ExtTreeNode oldParent = node.Parent as ExtTreeNode;
node.Remove();
node.InsertSorted(folderTreeNode);
if (oldParent != null)
{
oldParent.Refresh();
}
}
ProjectService.SaveSolution();
}
}
folderTreeNode.Expand();
}
/// <summary>
/// Creates a new TestNamespaceTreeNode
/// </summary>
/// <remarks>
/// Note that the Namespace child nodes are added in
/// the constructor not whilst the node is expanding
/// via the Initialize method. This is so the icon for the
/// node can be updated even if the parent node is not
/// expanded. The alternative is to have each namespace node,
/// even if it does not have any class child nodes, to
/// store all the classes that are below it in the tree and
/// update the icon based on their results. The assumption
/// is that there are fewer namespace nodes than classes so
/// adding the namespace nodes here does not matter.
/// </remarks>
/// <param name="namespacePrefix">The first part of the
/// namespace (including any dot characters) before this
/// particular namespace.</param>
/// <param name="name">The name of the namespace without any
/// dot characters (e.g. the name at this particular
/// location in the tree).</param>
public TestNamespaceTreeNode(TestProject testProject, string namespacePrefix, string name)
: base(testProject, name)
{
ns = name;
this.namespacePrefix = namespacePrefix;
fullNamespace = GetFullNamespace(namespacePrefix, ns);
GetTestClasses();
testProject.TestClasses.TestClassAdded += TestClassAdded;
testProject.TestClasses.TestClassRemoved += TestClassRemoved;
// Add namespace nodes - do not add them on node expansion.
foreach (string namespaceName in TestProject.GetChildNamespaces(fullNamespace))
{
TestNamespaceTreeNode node = new TestNamespaceTreeNode(TestProject, fullNamespace, namespaceName);
node.AddTo(this);
namespaceChildNodes.Add(node);
node.ImageIndexChanged += TestNamespaceNodeImageIndexChanged;
}
// Add a dummy node if there are no namespaces since
// there might be class nodes which will be added
// lazily when the node is expanded.
if (namespaceChildNodes.Count == 0)
{
dummyNode = new ExtTreeNode();
Nodes.Add(dummyNode);
}
UpdateImageListIndex();
}
/// <summary>
/// Inserts a new comment node either before or after the
/// currently selected node.
/// </summary>
void InsertComment(XmlComment comment, InsertionMode insertionMode)
{
ExtTreeNode selectedNode = (ExtTreeNode)SelectedNode;
if (selectedNode != null)
{
ExtTreeNode parentNode = (ExtTreeNode)selectedNode.Parent;
XmlCommentTreeNode newNode = new XmlCommentTreeNode(comment);
int index = 0;
if (parentNode != null)
{
index = parentNode.Nodes.IndexOf(selectedNode);
}
else
{
index = Nodes.IndexOf(selectedNode);
}
if (insertionMode == InsertionMode.After)
{
index++;
}
if (parentNode != null)
{
newNode.Insert(index, parentNode);
}
else
{
newNode.Insert(index, this);
}
}
}
void TreeViewDragDrop(object sender, DragEventArgs e)
{
Point clientcoordinate = PointToClient(new Point(e.X, e.Y));
ExtTreeNode node = treeView.GetNodeAt(clientcoordinate) as ExtTreeNode;
if (node == null)
{
// did not drag onto any node
if (e.Data.GetDataPresent(DataFormats.FileDrop))
{
string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
foreach (string file in files)
{
try {
IProjectLoader loader = ProjectService.GetProjectLoader(file);
if (loader != null)
{
FileUtility.ObservedLoad(new NamedFileOperationDelegate(loader.Load), file);
}
else
{
FileService.OpenFile(file);
}
} catch (Exception ex) {
MessageService.ShowException(ex, "unable to open file " + file);
}
}
}
}
}
/// <summary>
/// Adds a new tree node containing the xml element to the specified
/// nodes collection.
/// </summary>
public static ExtTreeNode AddNode(ExtTreeNode parentNode, XmlElement element)
{
ExtTreeNode node = CreateNode(element);
node.AddTo(parentNode);
return(node);
}
public void AddNewClass()
{
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
MockClass mockClass = new MockClass(projectContent, "MyNewTestFixture");
mockClass.Attributes.Add(new MockAttribute("TestFixture"));
TestClass newTestClass = new TestClass(mockClass, testFrameworks);
projectNode.TestProject.TestClasses.Add(newTestClass);
ExtTreeNode newTestClassNode = null;
foreach (ExtTreeNode node in rootNode.Nodes)
{
if (node.Text == "MyNewTestFixture")
{
newTestClassNode = node;
break;
}
}
newTestClass.Result = TestResultType.Failure;
// New test class node should be added to the root node.
Assert.IsNotNull(newTestClassNode);
Assert.AreEqual(2, rootNode.Nodes.Count);
// Make sure the project node image index is affected by the
// new test class added.
Assert.AreEqual(TestTreeViewImageListIndex.TestFailed, (TestTreeViewImageListIndex)rootNode.SelectedImageIndex);
}
public static void DoPaste(ISolutionFolderNode folderNode)
{
if (!DoEnablePaste(folderNode))
{
LoggingService.Warn("SolutionFolderNode.DoPaste: Pasting was not enabled.");
return;
}
ExtTreeNode folderTreeNode = (ExtTreeNode)folderNode;
IDataObject dataObject = ClipboardWrapper.GetDataObject();
if (dataObject.GetDataPresent(typeof(ISolutionFolder).ToString()))
{
string guid = dataObject.GetData(typeof(ISolutionFolder).ToString()).ToString();
ISolutionFolder solutionFolder = folderNode.Solution.GetSolutionFolder(guid);
if (solutionFolder != null)
{
folderNode.Container.AddFolder(solutionFolder);
ExtTreeView treeView = (ExtTreeView)folderTreeNode.TreeView;
foreach (ExtTreeNode node in treeView.CutNodes)
{
ExtTreeNode oldParent = node.Parent as ExtTreeNode;
node.Remove();
node.AddTo(folderTreeNode);
if (oldParent != null)
{
oldParent.Refresh();
}
}
ProjectService.SaveSolution();
}
}
folderTreeNode.Expand();
}
public void GetChild(string id)
{
JavaScriptSerializer jss = new JavaScriptSerializer();
List <ExtTreeNode> nodes = new List <ExtTreeNode>();
TreeNode nodess = this.ListTreeView.FindNode(id);
try {
foreach (TreeNode row in nodess.ChildNodes)
{
ExtTreeNode node = new ExtTreeNode();
node.id = row.ValuePath;
node.IsRoot = false;
node.icon = row.ImageUrl.Replace("~", "..");
if (row.ChildNodes.Count == 0)
{
node.leaf = true;
node.PID = row.Parent.ImageToolTip;
}
node.draggable = true;
node.text = row.Text;
node.TypeID = row.Value;
node.TypeTitle = row.Text;
node.TypeEName = row.Text;
node.action = row.NavigateUrl;
nodes.Add(node);
}
res = jss.Serialize(nodes);
}
catch (Exception ee) {
string error = ee.Message;
}
Response.Write(res);
Response.End();
}
public void SetUp()
{
treeViewContainerControl = new DerivedXmlTreeViewContainerControl();
treeView = treeViewContainerControl.TreeView;
string xml = "<root><top>text</top><bottom><child>text</child></bottom></root>";
treeViewContainerControl.LoadXml(xml);
doc = treeViewContainerControl.Document;
ExtTreeNode rootNode = (ExtTreeNode)treeView.Nodes[0];
rootNode.Expanding();
topElementTreeNode = (XmlElementTreeNode)rootNode.Nodes[0];
topElementTreeNode.Expanding();
topTextTreeNode = (XmlTextTreeNode)topElementTreeNode.Nodes[0];
ExtTreeNode bottomNode = (ExtTreeNode)rootNode.Nodes[1];
bottomNode.Expanding();
childElementTreeNode = (XmlElementTreeNode)bottomNode.Nodes[0];
childElementTreeNode.Expanding();
}
public void RemoveClassFromNamespaceNodeWithNonClassNodeChildren()
{
ExtTreeNode projectNamespaceNode = ExpandProjectNamespaceNode();
ExtTreeNode testsNamespaceNode = ExpandTestsNamespaceNode();
// Add a dummy tree node to the tests namespace node to make
// sure the TestNamespaceTreeNode handles non-TestClassTreeNode
// children when removing a class.
testsNamespaceNode.Nodes.Insert(0, new ExtTreeNode());
// Locate the class we are going to remove.
TestClass testClass = testProject.TestClasses["Project.Tests.MyTestFixture"];
testProject.TestClasses.Remove(testClass);
ExtTreeNode testClassNode = null;
foreach (ExtTreeNode node in testsNamespaceNode.Nodes)
{
if (node.Text == "MyTestFixture")
{
testClassNode = node;
break;
}
}
Assert.IsNull(testClassNode);
Assert.AreEqual(1, testsNamespaceNode.Nodes.Count);
}
public void SetUpFixture()
{
doc = new XmlDocument();
doc.LoadXml("<root><firstChild><secondChild/></firstChild><textChild>some text</textChild></root>");
using (XmlTreeViewControl treeView = new XmlTreeViewControl()) {
treeView.Document = doc;
treeView.SelectedNode = treeView.Nodes[0];
rootNodeElement = treeView.SelectedElement;
isRootElementSelected = treeView.IsElementSelected;
rootNode = (ExtTreeNode)treeView.SelectedNode;
rootNodeHadChildrenBeforeExpansion = rootNode.Nodes.Count > 0;
rootNode.Expanding();
firstChildNode = (ExtTreeNode)rootNode.Nodes[0];
firstChildNodeHadChildrenBeforeExpansion = firstChildNode.Nodes.Count > 0;
firstChildNode.Expanding();
secondChildNode = (ExtTreeNode)firstChildNode.Nodes[0];
textChildNode = (ExtTreeNode)rootNode.Nodes[1];
textChildNode.Expanding();
textNode = (ExtTreeNode)textChildNode.Nodes[0];
isTextContentSelectedBeforeTextNodeSelected = treeView.IsTextNodeSelected;
textContentBefore = treeView.SelectedTextNode;
treeView.SelectedNode = textNode;
isTextContentSelectedAfterTextNodeSelected = treeView.IsTextNodeSelected;
textContentAfter = treeView.SelectedTextNode;
textNodeElement = treeView.SelectedElement;
}
}
void TreeViewDragDrop(object sender, DragEventArgs e)
{
Point clientcoordinate = PointToClient(new Point(e.X, e.Y));
ExtTreeNode node = treeView.GetNodeAt(clientcoordinate) as ExtTreeNode;
if (node == null)
{
// did not drag onto any node
if (e.Data.GetDataPresent(DataFormats.FileDrop))
{
string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
foreach (string file in files)
{
try {
var fileName = FileName.Create(file);
if (SD.ProjectService.IsSolutionOrProjectFile(fileName))
{
SD.ProjectService.OpenSolutionOrProject(fileName);
}
else
{
FileService.OpenFile(fileName);
}
} catch (Exception ex) {
MessageService.ShowException(ex, "unable to open file " + file);
}
}
}
}
}
public void RemoveNamespaceNode()
{
ExtTreeNode projectNamespaceNode = ExpandProjectNamespaceNode();
ExtTreeNode testsNamespaceNode = ExpandTestsNamespaceNode();
// Locate the class we are going to remove.
TestClass testClass = testProject.TestClasses["Project.Tests.MyTestFixture"];
testProject.TestClasses.Remove(testClass);
ExtTreeNode testClassNode = null;
foreach (ExtTreeNode node in testsNamespaceNode.Nodes)
{
if (node.Text == "MyTestFixture")
{
testClassNode = node;
break;
}
}
Assert.IsNull(testClassNode);
// Project namespace node should only have one child node.
Assert.AreEqual(1, projectNamespaceNode.Nodes.Count);
Assert.AreEqual("MyTestFixture", projectNamespaceNode.Nodes[0].Text);
}
public void NewMethodAdded()
{
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
TestClass testClass = projectNode.TestProject.TestClasses["RootNamespace.Tests.MyTestFixture"];
MockMethod method = new MockMethod(testClass.Class, "NewMethod");
method.Attributes.Add(new MockAttribute("Test"));
testClass.TestMembers.Add(new TestMember(method));
ExtTreeNode newMethodNode = null;
foreach (ExtTreeNode node in testFixtureNode.Nodes)
{
if (node.Text == "NewMethod")
{
newMethodNode = node;
break;
}
}
Assert.AreEqual(2, testFixtureNode.Nodes.Count);
Assert.IsNotNull(newMethodNode);
Assert.IsInstanceOf(typeof(TestMemberTreeNode), newMethodNode);
}
public void UnknownProjectHasNUnitReferenceAdded()
{
project = new MockCSharpProject();
project.Name = "NewProject";
nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
treeView.ProjectItemAdded(nunitFrameworkReferenceItem);
ExtTreeNode allProjectsNode = treeView.Nodes[0] as ExtTreeNode;
ExtTreeNode newProjectNode = null;
foreach (ExtTreeNode node in allProjectsNode.Nodes)
{
if (node.Text == "NewProject")
{
newProjectNode = node;
break;
}
}
Assert.AreEqual(1, treeView.Nodes.Count);
Assert.IsNotNull(newProjectNode);
}
DirectoryNode ExpandFirstChildDirectory(ExtTreeNode parentNode)
{
DirectoryNode directoryNode = GetFirstDirectoryChildNode(parentNode);
directoryNode.Expanding();
return(directoryNode);
}
ToolStripMenuItem MakeItem(string title, ExtTreeNode classBrowserTreeNode, ICompilationUnit cu, DomRegion region)
{
ToolStripMenuItem item = MakeItemInternal(classBrowserTreeNode.Text, classBrowserTreeNode.ImageIndex, cu, region);
MenuService.AddItemsToMenu(item.DropDown.Items, classBrowserTreeNode, classBrowserTreeNode.ContextmenuAddinTreePath);
return(item);
}
/// <summary>
/// Adds a new tree node to the tree view.
/// </summary>
public static ExtTreeNode AddNode(ExtTreeView treeView, XmlElement element)
{
ExtTreeNode node = CreateNode(element);
node.AddTo(treeView);
return(node);
}
public void RemoveChildElement()
{
ExtTreeNode rootNode = (ExtTreeNode)treeView.Nodes[0];
rootNode.Expanding();
treeView.RemoveElement((XmlElement)doc.DocumentElement.FirstChild);
Assert.AreEqual(0, treeView.Nodes[0].Nodes.Count);
}
public void NonCodeCoverageNodeNotInitialised()
{
DerivedCodeCoverageTreeView treeView = new DerivedCodeCoverageTreeView();
ExtTreeNode node = new ExtTreeNode();
treeView.CallOnAfterSelect(node);
Assert.IsFalse(node.IsInitialized);
}
/// <summary>
/// 设置ExTreeNode的IsExpand属性
/// </summary>
/// <param name="baseNode">ExTreeNode</param>
/// <param name="isExpand">isExpand</param>
private void SetExpand(ExtTreeNode baseNode, bool isExpand)
{
baseNode.IsExpanded = isExpand;
foreach (ExtTreeNode node in baseNode.Items)
{
node.IsExpanded = isExpand;
SetExpand(node, isExpand);
}
}
public void SelectAll()
{
ExtTreeNode node = ProjectBrowserControl.TreeView.SelectedNode as ExtTreeNode;
if (node != null)
{
node.SelectAll();
}
}
MenuItem MakeItem(ExtTreeNode classBrowserTreeNode, ICompilationUnit cu, DomRegion region)
{
MenuItem item = MakeItemWithGoToDefinition(classBrowserTreeNode.Text, ClassBrowserIconService.GetImageByIndex(classBrowserTreeNode.ImageIndex), cu, region);
foreach (object obj in MenuService.CreateMenuItems(null, classBrowserTreeNode, classBrowserTreeNode.ContextmenuAddinTreePath))
{
item.Items.Add(obj);
}
return(item);
}
public void Copy()
{
ProjectBrowserControl.TreeView.ClearCutNodes();
ExtTreeNode node = ProjectBrowserControl.TreeView.SelectedNode as ExtTreeNode;
if (node != null)
{
node.Copy();
}
}
public void Delete()
{
ExtTreeNode node = ProjectBrowserControl.TreeView.SelectedNode as ExtTreeNode;
if (node != null)
{
node.Delete();
}
ProjectBrowserControl.TreeView.ClearCutNodes();
}
public WixTreeNode(XmlElement element)
{
this.element = element;
sortOrder = 10;
if (element.HasChildNodes)
{
dummyChildNode = new ExtTreeNode();
dummyChildNode.AddTo(this);
}
}
/// <summary>
/// Adds all the elements.
/// </summary>
public static void AddNodes(ExtTreeNode parentNode, XmlNodeList nodes)
{
foreach (XmlNode childNode in nodes)
{
XmlElement childElement = childNode as XmlElement;
if (childElement != null)
{
AddNode(parentNode, childElement);
}
}
}
/// <summary>
/// Adds child nodes to this tree node.
/// </summary>
protected override void Initialize()
{
base.Initialize();
if (dummyChildNode != null)
{
Nodes.Remove(dummyChildNode);
dummyChildNode = null;
}
WixTreeNodeBuilder.AddNodes(this, element.ChildNodes);
}
public void ClassOccursBeforeNamespaceOnInitialLoad()
{
MockCSharpProject project = new MockCSharpProject();
project.Name = "TestProject";
ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
List <IProject> projects = new List <IProject>();
projects.Add(project);
// Add a test class with a TestFixture attributes.
TestClass testClass = CreateTestClass("MyTests.MyTestFixture");
projectContent.Classes.Add(testClass.Class);
// Add a second class with no namespace.
testClass = CreateTestClass("AppleTestFixture");
projectContent.Classes.Add(testClass.Class);
// Add another class that exists in a namespace inside
// MyTests.
testClass = CreateTestClass("MyTests.ZebraTests.AddZebra");
projectContent.Classes.Add(testClass.Class);
// Load the project into the tree.
treeView.Clear();
treeView.AddProject(project);
projectNode = (TestProjectTreeNode)treeView.Nodes[0];
projectNode.PerformInitialization();
ExtTreeNode treeNode = (ExtTreeNode)projectNode.LastNode;
treeNode.PerformInitialization();
// Get the class node without a root namespace and
// the my tests namespace node.
TestClassTreeNode appleTestFixtureNode = projectNode.FirstNode as TestClassTreeNode;
TestNamespaceTreeNode myTestsNamespaceNode = projectNode.LastNode as TestNamespaceTreeNode;
// Get the zebra namespace tree node.
TestNamespaceTreeNode zebraTestsNamespaceNode = treeNode.LastNode as TestNamespaceTreeNode;
Assert.IsNotNull(appleTestFixtureNode);
Assert.AreEqual(appleTestFixtureNode.Text, "AppleTestFixture");
Assert.IsNotNull(myTestsNamespaceNode);
Assert.AreEqual(myTestsNamespaceNode.Text, "MyTests");
Assert.IsNotNull(zebraTestsNamespaceNode);
Assert.AreEqual(zebraTestsNamespaceNode.Text, "ZebraTests");
}
private void AddImageNode(string name)
{
Action method = delegate {
ExtTreeNode node = new ExtTreeNode {
Text = name,
ToolTipText = "双击查看"
};
node.AddTo(this.tvImage);
this.tvImage.SelectedNode = node;
};
base.Invoke(method);
}
public void GetChild(string id)
{
JavaScriptSerializer jss = new JavaScriptSerializer();
List<ExtTreeNode> nodes = new List<ExtTreeNode>();
TreeNode nodess = this.ListTreeView.FindNode(id);
try {
foreach(TreeNode row in nodess.ChildNodes) {
ExtTreeNode node = new ExtTreeNode();
node.id = row.ValuePath;
node.IsRoot = false;
node.icon = row.ImageUrl.Replace("~", "..");
if(row.ChildNodes.Count == 0) {
node.leaf = true;
node.PID = row.Parent.ImageToolTip;
}
node.draggable = true;
node.text = row.Text;
node.TypeID = row.Value;
node.TypeTitle = row.Text;
node.TypeEName = row.Text;
node.action = row.NavigateUrl;
nodes.Add(node);
}
res = jss.Serialize(nodes);
}
catch(Exception ee) {
string error = ee.Message;
}
Response.Write(res);
Response.End();
}
public void StartSearch()
{
if (searchTerm.Length == 0) {
CancelSearch();
return;
}
if (!inSearchMode) {
foreach (TreeNode node in classBrowserTreeView.Nodes) {
oldNodes.Add(node);
}
inSearchMode = true;
previousNodes.Clear();
nextNodes.Clear();
UpdateToolbars();
}
classBrowserTreeView.BeginUpdate();
classBrowserTreeView.Nodes.Clear();
if (ProjectService.OpenSolution != null) {
foreach (IProject project in ProjectService.OpenSolution.Projects) {
IProjectContent projectContent = ParserService.GetProjectContent(project);
if (projectContent != null) {
foreach (IClass c in projectContent.Classes) {
if (c.Name.ToUpper().StartsWith(searchTerm)) {
ClassNodeBuilders.AddClassNode(classBrowserTreeView, project, c);
}
}
}
}
}
if (classBrowserTreeView.Nodes.Count == 0) {
ExtTreeNode notFoundMsg = new ExtTreeNode();
notFoundMsg.Text = ResourceService.GetString("MainWindow.Windows.ClassBrowser.NoResultsFound");
notFoundMsg.AddTo(classBrowserTreeView);
}
classBrowserTreeView.Sort();
classBrowserTreeView.EndUpdate();
}
public void IndexInfo(TreeNodeCollection nodeCollection)
{
JavaScriptSerializer jss = new JavaScriptSerializer();
List<ExtTreeNode> nodes = new List<ExtTreeNode>();
try {
foreach(TreeNode row in nodeCollection) {
ExtTreeNode node = new ExtTreeNode();
node.id = row.Value;
node.IsRoot = false;
node.icon = row.ImageUrl.Replace("~", "..");
node.iconCls = row.ImageToolTip;
if(row.Parent == null) {
node.leaf = false;
node.PID = "";
}
else {
node.leaf = true;
node.PID = row.Parent.ImageToolTip;
}
node.draggable = true;
node.text = row.Text;
node.TypeID = row.Value;
node.TypeTitle = row.Text;
node.TypeEName = row.Text;
node.action = row.NavigateUrl;
nodes.Add(node);
}
res = jss.Serialize(nodes);
}
catch(Exception ee) {
string error = ee.Message;
}
Response.Write(res);
Response.End();
}
private void LoadBillNodes(XmlNodeList xmlNodes, ExtTreeNode parentNode)
{
foreach (XmlNode node in xmlNodes)
{
if (!(node is XmlElement))
{
continue;
}
XmlElement element = node as XmlElement;
if ((element.ChildNodes.Count == 0) || (element.SelectNodes("Bill").Count == 0))
{
BillNode node2 = new BillNode();
node2.ImageIndex = 2;
node2.SelectedImageIndex = 2;
foreach (XmlAttribute attribute in element.Attributes)
{
switch (attribute.Name)
{
case "name":
{
node2.Text = attribute.Value;
continue;
}
case "logo":
{
node2.Logo = attribute.Value;
continue;
}
case "formname":
{
node2.FormName = attribute.Value;
continue;
}
case "SQL":
{
node2.SQL = attribute.Value;
continue;
}
case "reportoid":
{
node2.ReportOID = attribute.Value;
continue;
}
case "addressprefix":
{
node2.AddressPrefix = attribute.Value;
continue;
}
case "taxtypeoid":
{
node2.TaxTypeOID = attribute.Value;
continue;
}
}
}
parentNode.Nodes.Add(node2);
continue;
}
ExtTreeNode node3 = new ExtTreeNode();
node3.ImageIndex = 1;
node3.SelectedImageIndex = 1;
node3.Text = element.GetAttribute("name");
parentNode.Nodes.Add(node3);
this.LoadBillNodes(element.ChildNodes, node3);
}
}
private void LoadBills()
{
string filename = Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase) + Path.DirectorySeparatorChar + "Bills.xml";
XmlDocument document = new XmlDocument();
document.Load(filename);
XmlElement documentElement = document.DocumentElement;
if (documentElement != null)
{
ExtTreeNode parentNode = new ExtTreeNode();
parentNode.ImageIndex = 1;
parentNode.SelectedImageIndex = 1;
parentNode.Text = documentElement.GetAttribute("name");
this.LoadBillNodes(documentElement.ChildNodes, parentNode);
this.billBrowserTreeView.Nodes.Add(parentNode);
parentNode.Expand();
}
}
public override TreeNode GetNodeByPath(string directory, bool create)
{
directory = StripRootNamespace(directory);
string[] treepath = directory.Split(new char[] { '.' });
TreeNodeCollection curcollection = Nodes;
TreeNode curnode = this;
foreach (string path in treepath) {
if (path.Length == 0 || path[0] == '.') {
continue;
}
TreeNode node = GetNodeByName(curcollection, path);
if (node == null) {
if (create) {
ExtTreeNode newnode = new ExtTreeNode();
newnode.Tag = path;
newnode.Text = path;
newnode.ImageIndex = newnode.SelectedImageIndex = ClassBrowserIconService.Namespace.ImageIndex;
curcollection.Add(newnode);
curnode = newnode;
curcollection = curnode.Nodes;
continue;
} else {
return null;
}
}
curnode = node;
curcollection = curnode.Nodes;
}
return curnode;
}
public void StartLabelEdit(ExtTreeNode node)
{
if ((node != null) && node.CanLabelEdit)
{
node.EnsureVisible();
base.SelectedNode = node;
base.LabelEdit = true;
node.BeforeLabelEdit();
node.BeginEdit();
}
}
