开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
XmlTreeView.cs
资源名称：xmlnotepad.rar　[点击查看]
上传用户：hbhltzc
上传日期：2022-06-04
资源大小：1925k
文件大小：73k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

XmlTreeView.cs：源码内容
  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Drawing;
  5. using System.Windows.Forms;
  6. using System.Xml;
  7. using System.Xml.XPath;
  8. using System.Xml.Schema;
  9. using System.Diagnostics;
  10. using System.Drawing.Drawing2D;
  11. using System.Text;
  13. namespace XmlNotepad {
  15.     public class XmlTreeView : System.Windows.Forms.UserControl {
  16.         XmlCache model;
  17.         Settings settings;
  18.         bool disposed;
  19.         const int HScrollIncrement = 5;
  21.         public event EventHandler<NodeChangeEventArgs> NodeChanged;
  22.         public event EventHandler<NodeChangeEventArgs> NodeInserted;
  23.         public event EventHandler SelectionChanged;
  24.         public event EventHandler ClipboardChanged;
  26.         XmlTreeNode dragged;
  27.         XmlTreeViewDropFeedback feedback;
  28.         IntelliTip tip;
  29.         private NodeTextView nodeTextView;
  30.         private TreeView myTreeView;
  31.         private System.Windows.Forms.ImageList imageList1;
  32.         private System.ComponentModel.IContainer components;
  33.         private PaneResizer resizer;
  34.         private System.Windows.Forms.VScrollBar vScrollBar1;
  35.         private System.Windows.Forms.HScrollBar hScrollBar1;
  37.         public XmlTreeView() {
  39.             this.SetStyle(ControlStyles.ContainerControl, true);
  40.             this.SetStyle(ControlStyles.ResizeRedraw, true);
  41.             this.SetStyle(ControlStyles.UserPaint, true);
  42.             this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
  43.             this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
  45.             // This call is required by the Windows.Forms Form Designer.
  46.             InitializeComponent();
  48.             myTreeView.AfterLabelEdit += new EventHandler<NodeLabelEditEventArgs>(myTreeView_AfterLabelEdit);            
  49.             myTreeView.AfterCollapse += new EventHandler<TreeViewEventArgs>(myTreeView_AfterCollapse);
  50.             myTreeView.AfterExpand += new EventHandler<TreeViewEventArgs>(myTreeView_AfterExpand);
  51.             myTreeView.AfterSelect += new EventHandler<TreeViewEventArgs>(myTreeView_AfterSelect);
  52.             myTreeView.MouseWheel += new MouseEventHandler(HandleMouseWheel);
  53.             myTreeView.KeyDown += new KeyEventHandler(myTreeView_KeyDown);
  55.             this.myTreeView.DragDrop += new DragEventHandler(treeViewFeedback_DragDrop);
  56.             this.myTreeView.DragEnter += new DragEventHandler(treeViewFeedback_DragEnter);
  57.             this.myTreeView.DragLeave += new EventHandler(treeViewFeedback_DragLeave);
  58.             this.myTreeView.DragOver += new DragEventHandler(treeViewFeedback_DragOver);
  59.             this.myTreeView.AllowDrop = true;
  60.             this.myTreeView.GiveFeedback += new GiveFeedbackEventHandler(myTreeView_GiveFeedback);
  61.             this.myTreeView.ItemDrag += new ItemDragEventHandler(myTreeView_ItemDrag);
  62.             this.myTreeView.AfterBatchUpdate += new EventHandler(myTreeView_AfterBatchUpdate);
  64.             this.nodeTextView.KeyDown += new KeyEventHandler(nodeTextView_KeyDown);
  65.             this.nodeTextView.MouseWheel += new MouseEventHandler(HandleMouseWheel);
  66.             this.nodeTextView.AfterSelect += new EventHandler<TreeViewEventArgs>(nodeTextView_AfterSelect);
  67.             this.nodeTextView.AccessibleRole=System.Windows.Forms.AccessibleRole.List;            
  69.             this.Disposed += new EventHandler(OnDisposed);
  71.             tip = new IntelliTip(this);
  72.             tip.AddWatch(this.nodeTextView);
  73.             tip.AddWatch(this.myTreeView);
  74.             tip.ShowToolTip += new IntelliTipEventHandler(OnShowToolTip);
  75.         }
  77.         void OnDisposed(object sender, EventArgs e) {
  78.             this.disposed = true;
  79.         }
  81.         public void Close() {
  82.             this.myTreeView.Close();
  83.             this.nodeTextView.Close();
  84.         }
  86.         [Browsable(false)]
  87.         public XmlTreeNode SelectedNode {
  88.             get {
  89.                 return this.myTreeView.SelectedNode as XmlTreeNode;
  90.             }
  91.             set {
  92.                 this.myTreeView.SelectedNode = value;
  93.             }
  94.         }
  96.         void OnShowToolTip(object sender, IntelliTipEventArgs args) {
  97.             Point pt = this.myTreeView.ApplyScrollOffset(args.Location);            
  98.             XmlTreeNode tn = this.TreeView.FindNodeAt(20, pt.Y) as XmlTreeNode;
  99.             if (tn != null) {
  100.                 args.ToolTip = tn.GetToolTip();
  101.             }
  102.         }
  104.         public void ExpandAll() {
  105.             this.SuspendLayout();
  106.             this.myTreeView.ExpandAll();
  107.             this.ResumeLayout();
  108.         }
  110.         public void CollapseAll() {
  111.             this.SuspendLayout();
  112.             this.myTreeView.CollapseAll();
  113.             this.ResumeLayout();
  114.         }
  116.         public void SetSite(ISite site) {
  117.             base.Site = site;
  118.             this.nodeTextView.SetSite(site);
  119.             this.myTreeView.SetSite(site);
  120.             this.model = (XmlCache)this.Site.GetService(typeof(XmlCache));
  121.             if (this.model != null) {
  122.                 this.model.FileChanged += new EventHandler(OnFileChanged);
  123.                 this.model.ModelChanged += new EventHandler<ModelChangedEventArgs>(OnModelChanged);
  124.             }
  125.             this.settings = (Settings)this.Site.GetService(typeof(Settings));
  126.             if (this.settings != null) {
  127.                 this.settings.Changed += new SettingsEventHandler(settings_Changed);
  128.             }            
  129.             if (this.model != null) BindTree();
  130.         }
  132.         [Browsable(false)]
  133.         public XmlCache Model {
  134.             get {
  135.                 if (this.Site == null) {
  136.                     throw new ApplicationException("ISite has not been provided, so model cannot be found");
  137.                 }
  138.                 return this.model; 
  139.             }
  140.         }
  142.         [Browsable(false)]
  143.         public Settings Settings {
  144.             get {
  145.                 if (this.Site == null) {
  146.                     throw new ApplicationException("ISite has not been provided, so settings cannot be found");
  147.                 }
  148.                 return this.settings; 
  149.             }
  150.         }
  152.         public NodeTextView NodeTextView {
  153.             get { return nodeTextView; }
  154.             set { nodeTextView = value; }
  155.         }
  157.         public void CancelEdit() {
  158.             TreeNode n = myTreeView.SelectedNode;
  159.             if (n != null && n.IsEditing) {
  160.                 n.EndEdit(true);
  161.             }
  162.             this.nodeTextView.EndEdit(true);
  163.         }
  166.         public virtual XmlTreeNode CreateTreeNode() {
  167.             return new XmlTreeNode(this);
  168.         }
  170.         public virtual XmlTreeNode CreateTreeNode(XmlNode node) {
  171.             return new XmlTreeNode(this, node);
  172.         }
  174.         public virtual XmlTreeNode CreateTreeNode(XmlTreeNode parent, XmlNode node) {
  175.             return new XmlTreeNode(this, parent, node);
  176.         }
  178.         public XmlTreeNode FindNode(XmlNode node) {
  179.             return FindNode(this.myTreeView.Nodes, node);
  180.         }
  182.         XmlTreeNode FindNode(TreeNodeCollection nodes, XmlNode node) {
  183.             foreach (XmlTreeNode xn in nodes) {
  184.                 if (xn.Node == node) return xn;
  185.                 if (xn.Nodes != null) {
  186.                     XmlTreeNode child = FindNode(xn.Nodes, node);
  187.                     if (child != null) return child;
  188.                 }
  189.             }
  190.             return null;
  191.         }
  192.         
  193.         public bool Commit() {
  194.             this.nodeTextView.EndEdit(false);
  195.             TreeNode n = myTreeView.SelectedNode;
  196.             if (n != null && n.IsEditing) {
  197.                 return n.EndEdit(false);
  198.             }
  199.             return true;
  200.         }
  202.         [Browsable(false)]
  203.         public UndoManager UndoManager {
  204.             get { return (UndoManager)this.Site.GetService(typeof(UndoManager)); }
  205.         }
  207.         [System.ComponentModel.Browsable(false)]
  208.         public IIntellisenseProvider IntellisenseProvider {
  209.             get { return (IIntellisenseProvider)this.Site.GetService(typeof(IIntellisenseProvider)); }
  210.         }
  212.         [Browsable(false)]
  213.         public TreeView TreeView {
  214.             get { return this.myTreeView; }
  215.         }
  217.         private void myTreeView_AfterLabelEdit(object sender, NodeLabelEditEventArgs e) {
  218.             try {
  219.                 XmlTreeNode xn = (XmlTreeNode)e.Node;
  220.                 XmlNode n = xn.Node;
  221.                 if (e.CancelEdit) return; // it's being cancelled.
  223.                 if (e.Label == null || StringHelper.IsNullOrEmpty(e.Label.Trim())) {
  224.                     
  225.                     string arg = null;
  226.                     if (xn.NodeImage == NodeImage.Attribute) 
  227.                         arg = "attributes";
  228.                     else if (xn.NodeImage == NodeImage.Element || xn.NodeImage == NodeImage.OpenElement || xn.NodeImage == NodeImage.Leaf) 
  229.                         arg = "elements";
  231.                     if (arg != null && n == null && MessageBox.Show(this,
  232.                         SR.XmlNameEmptyPrompt, SR.XmlNameErrorCaption,
  233.                         MessageBoxButtons.YesNo, MessageBoxIcon.Error) == DialogResult.No) {
  234.                         e.Node.BeginEdit();
  235.                         e.CancelEdit = true;
  236.                     }                     
  237.                     return; 
  238.                 }
  239.                 Command cmd = null;
  240.                 if (n == null) {
  241.                     TreeNode parent = e.Node.Parent;
  242.                     XmlNode context = (parent == null) ? this.model.Document : ((XmlTreeNode)parent).Node;
  243.                     cmd = this.UndoManager.Peek();
  244.                     try {
  245.                         InsertNode inode = cmd as InsertNode;
  246.                         if (inode != null) {
  247.                             if (inode.RequiresName) {
  248.                                 inode.XmlNode = inode.CreateNode(context, e.Label); 
  249.                                 // Cause selection event to be triggered so that menu state
  250.                                 // is recalculated.
  251.                                 this.myTreeView.SelectedNode = null;
  252.                                 this.OnNodeInserted(inode.NewNode);
  253.                             }
  254.                         }
  255.                     } 
  256.                     catch (Exception ex) {
  257.                         MessageBox.Show(this, ex.Message,
  258.                             SR.XmlNameErrorCaption, MessageBoxButtons.OK, MessageBoxIcon.Error);
  259.                         this.myTreeView.SelectedNode = e.Node;
  260.                         e.CancelEdit = true;
  261.                         xn.Label = e.Label.Trim();
  262.                         e.Node.BeginEdit();
  263.                         return;
  264.                     }
  265.                     e.Node.Label = e.Label;
  266.                     this.myTreeView.SelectedNode = e.Node;
  267.                     this.nodeTextView.Invalidate(e.Node);
  268.                     this.nodeTextView.FocusBeginEdit(null);
  269.                     return; // one undoable unit.
  270.                 }
  271.                 switch (n != null ? n.NodeType : XmlNodeType.None) {
  272.                     case XmlNodeType.Comment:
  273.                     case XmlNodeType.Text:
  274.                     case XmlNodeType.CDATA:
  275.                         e.CancelEdit = true;
  276.                         // actually it would be cool to change the node type at this point.
  277.                         break;
  278.                     case XmlNodeType.Attribute:
  279.                         cmd = new EditAttributeName(n as XmlAttribute, e);
  280.                         break;
  281.                     case XmlNodeType.Element:
  282.                         cmd =  new EditElementName(n as XmlElement, e);
  283.                         break;
  284.                     case XmlNodeType.ProcessingInstruction:
  285.                         cmd = new EditProcessingInstructionName(n as XmlProcessingInstruction, e);
  286.                         break;
  287.                 }
  288.                 if (cmd != null) {
  289.                     this.UndoManager.Push(cmd);
  290.                 }
  291.             } 
  292.             catch (Exception ex) {
  293.                 e.CancelEdit = true;
  294.                 MessageBox.Show(this, ex.Message, SR.EditErrorCaption, MessageBoxButtons.OK, MessageBoxIcon.Error);
  295.             }
  296.         }        
  298.         private void myTreeView_AfterCollapse(object sender, TreeViewEventArgs e) {
  299.             if (!this.myTreeView.InBatchUpdate) {
  300.                 PerformLayout();
  301.                 Invalidate();
  302.             }
  303.         }
  305.         private void myTreeView_AfterExpand(object sender, TreeViewEventArgs e) {
  306.             if (!this.myTreeView.InBatchUpdate) {
  307.                 PerformLayout();
  308.                 Invalidate();
  309.             }
  310.         }
  312.         private void myTreeView_AfterSelect(object sender, TreeViewEventArgs e) {
  313.             TreeNode n = e.Node;
  314.             if (this.TreeView.InBatchUpdate) {
  315.                 this.nodeTextView.InternalSelect(n);
  316.             } else {
  317.                 this.nodeTextView.SelectedNode = n;
  318.                 if (n != null) {
  319.                     ScrollIntoView(n);
  320.                 }
  321.                 if (SelectionChanged != null) SelectionChanged(this, EventArgs.Empty); 
  322.             }
  323.         }
  325.         void myTreeView_AfterBatchUpdate(object sender, EventArgs e) {
  326.             if (this.SelectedNode != null) {
  327.                 ScrollIntoView(this.SelectedNode);
  328.             }
  329.         }
  331.         void nodeTextView_AfterSelect(object sender, TreeViewEventArgs e) {
  332.             if (this.myTreeView != null) {
  333.                 this.myTreeView.SelectedNode = e.Node;
  334.             }
  335.         }
  337.         public Point ScrollPosition {
  338.             get { return myTreeView.ScrollPosition; }
  339.         }
  341.         public virtual void ScrollIntoView(TreeNode n) {
  342.             // Scroll the newly selected node into view vertically.
  343.             Rectangle r = n.LabelBounds;
  344.             int delta = myTreeView.TreeIndent + imageList1.ImageSize.Width + TreeNode.GetGap(myTreeView.TreeIndent);
  345.             r = new Rectangle(r.Left - delta, r.Top, r.Width + delta, r.Height);
  346.             int y = r.Top + myTreeView.ScrollPosition.Y;
  347.             if (y > myTreeView.Height - myTreeView.ItemHeight) {
  348.                 y = y - myTreeView.Height + myTreeView.ItemHeight;
  349.             } 
  350.             else if (y > 0) {
  351.                 y = 0;
  352.             }
  353.             if (y != 0) {
  354.                 int newy = myTreeView.ScrollPosition.Y - y;
  355.                 myTreeView.ScrollPosition = new Point(myTreeView.ScrollPosition.X, newy);
  356.                 nodeTextView.ScrollPosition = new Point(0, newy);
  357.                 this.nodeTextView.Invalidate();
  358.                 this.vScrollBar1.Value = Math.Max(0,Math.Min(this.vScrollBar1.Maximum, this.vScrollBar1.Value + (y / myTreeView.ItemHeight)));
  359.             }
  361.             // Tweak horizontal to make the newly selected label visible.
  362.             int x = this.myTreeView.ScrollPosition.X;
  363.             if (r.Left + this.myTreeView.ScrollPosition.X < 0) {
  364.                 // Label is off the left hand side.
  365.                 x = -r.Left;
  366.             } else if (r.Right + this.myTreeView.ScrollPosition.X > this.resizer.Left) {
  367.                 // Label is off the right hand side
  368.                 x = this.resizer.Left - r.Right - 10;
  369.                 if (r.Left + x < 0) {
  370.                     // Label is too long to fit, now it hangs off the left side, so
  371.                     // let's just leave it where it was
  372.                     x = this.myTreeView.ScrollPosition.X;
  373.                 }
  374.             }
  375.             if (x != this.myTreeView.ScrollPosition.X) {
  376.                 int pos = Math.Max(0, Math.Min(this.hScrollBar1.Maximum * HScrollIncrement, -x));
  377.                 myTreeView.ScrollPosition = new Point(-pos, myTreeView.ScrollPosition.Y);
  378.                 this.hScrollBar1.Value = pos / HScrollIncrement;
  379.             }            
  380.         }
  382.         internal void OnNodeChanged(XmlTreeNode node) {
  383.             if (NodeChanged != null) NodeChanged(this, new NodeChangeEventArgs(node));
  384.         }
  386.         public virtual void OnNodeInserted(XmlTreeNode node) {
  387.             if (NodeInserted != null) NodeInserted(this, new NodeChangeEventArgs(node));
  388.             // Populate default value.
  389.             if (node.Node != null && !node.Node.HasChildNodes &&
  390.                 (node.NodeType == XmlNodeType.Attribute || node.NodeType == XmlNodeType.Element)) {
  391.                 SetDefaultValue(node);
  392.             }
  393.         }
  395.         protected virtual void SetDefaultValue(XmlTreeNode node) {
  396.             IIntellisenseProvider provider = this.IntellisenseProvider;
  397.             if (provider != null) {
  398.                 provider.SetContextNode(node);
  399.                 string defaultValue = provider.GetDefaultValue();
  400.                 if (!string.IsNullOrEmpty(defaultValue)) {
  401.                     EditNodeValue cmd = new EditNodeValue(this, node, defaultValue);
  402.                     this.UndoManager.Push(cmd);                    
  403.                 }
  404.             }
  405.         }
  407.         private void OnModelChanged(object sender, ModelChangedEventArgs e) {
  408.             if (disposed) return;
  409.             ModelChangeType t = e.ModelChangeType;            
  410.             switch (t) {
  411.                 case ModelChangeType.Reloaded:
  412.                     BindTree();
  413.                     break;
  414.                 case ModelChangeType.NamespaceChanged:
  415.                     RecalculateNamespaces(e.Node);
  416.                     break;
  417.             }
  418.             nodeTextView.Invalidate();
  419.         }
  420.         
  421.         public bool IsEditing {
  422.             get { return this.myTreeView.IsEditing || this.nodeTextView.IsEditing;  }
  423.         }
  425.         private void OnFileChanged(object sender, EventArgs e) {
  426.             BindTree();
  427.         }
  429.         void BindTree() {
  430.             this.myTreeView.ScrollPosition = new Point(0,0);
  431.             this.vScrollBar1.Maximum = 0;
  432.             this.vScrollBar1.Value = 0;
  433.             this.hScrollBar1.Maximum = 0;
  434.             this.hScrollBar1.Value = 0;
  435.             this.nodeTextView.Top = 0;
  436.             this.nodeTextView.ScrollPosition = new Point(0, 0);
  438.             this.SuspendLayout();
  439.             this.myTreeView.BeginUpdate();
  440.             try {
  441.                 XmlTreeNodeCollection nodes = new XmlTreeNodeCollection(this, this.model.Document);
  442.                 this.myTreeView.Nodes = this.nodeTextView.Nodes = nodes;
  444.                 foreach (XmlTreeNode tn in this.myTreeView.Nodes) {
  445.                     tn.Expand();
  446.                 }
  447.                 this.nodeTextView.Reset();
  448.             } 
  449.             finally {
  450.                 this.myTreeView.EndUpdate();
  451.             }
  452.             this.ResumeLayout();
  453.             this.myTreeView.Invalidate();
  454.             this.myTreeView.Focus();
  455.             if (this.myTreeView.Nodes.Count > 0) {
  456.                 this.SelectedNode = (XmlTreeNode)this.myTreeView.Nodes[0];
  457.             }
  458.         }
  461.         int CountVisibleNodes(TreeNodeCollection tc) {
  462.             if (tc == null) return 0;
  463.             int count = 0;
  464.             foreach (TreeNode tn in tc) {
  465.                 count++;
  466.                 if (tn.IsExpanded) {
  467.                     count += CountVisibleNodes(tn.Nodes);
  468.                 }
  469.             }
  470.             return count;
  471.         }
  473.         internal void SyncScrollbars() {
  475.             if (this.hScrollBar1.Visible) {
  476.                 int x = this.resizer.Left;
  477.                 int w = this.myTreeView.VirtualWidth + 10;
  478.                 this.myTreeView.Height = this.Height - this.hScrollBar1.Height;
  479.                 int hScrollMax = 10 + ((w - x) / HScrollIncrement);
  480.                 this.hScrollBar1.Minimum = 0;
  481.                 this.hScrollBar1.Maximum = hScrollMax;
  482.                 this.hScrollBar1.Value = Math.Min(this.hScrollBar1.Value, hScrollMax);
  483.             } else {
  484.                 this.hScrollBar1.Visible = false;
  485.                 this.hScrollBar1.Value = 0;
  486.             }
  487.             int itemHeight = this.myTreeView.ItemHeight;
  488.             int visibleNodes = this.myTreeView.VirtualHeight / itemHeight;
  489.             int vScrollMax = Math.Max(0, visibleNodes - 1);
  490.             this.vScrollBar1.Maximum = vScrollMax;
  491.             this.vScrollBar1.SmallChange = 1;
  492.             this.vScrollBar1.LargeChange = this.myTreeView.VisibleRows;
  493.             this.vScrollBar1.Minimum = 0;
  494.             if (this.myTreeView.VirtualHeight < this.Height) {
  495.                 this.vScrollBar1.Value = 0;
  496.             } else {
  497.                 this.vScrollBar1.Value = Math.Min(this.vScrollBar1.Value, vScrollMax);
  498.             }
  499.         }
  501.         public int ResizerPosition {
  502.             get { return this.resizer.Left; }
  503.             set { this.resizer.Left = value; this.PerformLayout();  }
  504.         }
  505.         
  506.         protected override void OnLayout(LayoutEventArgs levent) {
  507.             
  508.             int x = this.resizer.Left;
  509.             this.myTreeView.Width = x;
  511.             int count = CountVisibleNodes(this.myTreeView.Nodes);
  512.             int h = Math.Max(this.Height, this.myTreeView.ItemHeight * count);
  513.             this.vScrollBar1.Left = this.Right - this.vScrollBar1.Width;
  514.             this.vScrollBar1.Height = this.Height;
  515.             this.hScrollBar1.Top = this.Height - this.hScrollBar1.Height;
  517.             this.hScrollBar1.Width = x;
  518.             this.myTreeView.Size = new Size(x, this.Height);
  519.             this.nodeTextView.Size = new Size(this.vScrollBar1.Left - this.resizer.Right, this.Height);
  520.             this.nodeTextView.Left = this.resizer.Right;
  522.             int w = this.myTreeView.VirtualWidth + 10;            
  523.             this.myTreeView.Width = Math.Max(w, x);
  524.             if (w > x) {
  525.                 this.myTreeView.Height = this.Height - this.hScrollBar1.Height;
  526.                 this.hScrollBar1.Visible = true;
  527.             } else {
  528.                 this.hScrollBar1.Visible = false;
  529.             }
  531.             SyncScrollbars();
  533.             int y = -this.vScrollBar1.Value * this.myTreeView.ItemHeight;
  534.             this.myTreeView.ScrollPosition = new Point(-this.hScrollBar1.Value * HScrollIncrement, y);
  536.             this.resizer.Height = this.Height;            
  537.             Invalidate();
  538.             this.nodeTextView.Invalidate();
  539.         }
  542.         public void Cut() {
  543.             this.Commit();
  544.             XmlTreeNode selection = (XmlTreeNode)this.myTreeView.SelectedNode;
  545.             if (selection != null) {
  546.                 this.UndoManager.Push(new CutCommand(this, selection));
  547.                 if (ClipboardChanged != null) ClipboardChanged(this, EventArgs.Empty);
  548.             }
  549.         }
  551.         public void Copy() {
  552.             this.Commit();
  553.             XmlTreeNode selection = (XmlTreeNode)this.myTreeView.SelectedNode;
  554.             if (selection != null) {
  555.                 TreeData.SetData(selection);
  556.                 if (ClipboardChanged != null) ClipboardChanged(this, EventArgs.Empty);
  557.             }
  558.         }
  560.         public void Paste(InsertPosition position) {
  561.             this.Commit();
  562.             try {
  563.                 this.UndoManager.Push(new PasteCommand(this.model.Document, this, position, TreeData.GetData()));
  564.             } 
  565.             catch (Exception ex) {
  566.                 MessageBox.Show(this, ex.Message, SR.PasteErrorCaption, MessageBoxButtons.OK, MessageBoxIcon.Error);
  567.             }
  568.         }
  570.         public void PasteXml(InsertPosition position, string xml ) {
  571.             this.Commit();
  572.             try {
  573.                 this.UndoManager.Push(new PasteCommand(this.model.Document, this, position, new TreeData(xml)));
  574.             } catch (Exception ex) {
  575.                 MessageBox.Show(this, ex.Message, SR.PasteErrorCaption, MessageBoxButtons.OK, MessageBoxIcon.Error);
  576.             }
  577.         }
  579.         public virtual bool CanInsertNode(InsertPosition position, XmlNodeType type) {
  580.             XmlTreeNode n = (XmlTreeNode)this.myTreeView.SelectedNode;
  581.             if (n!= null && n.Node == null) {
  582.                 // We are still editing this tree node and haven't created XmlNode
  583.                 // for it yet - so bail!
  584.                 return false;
  585.             }
  586.             InsertNode inode = new InsertNode(this);
  587.             return inode.Initialize(n, position, type);
  588.         }
  590.         public void ChangeTo(XmlNodeType nt) {
  591.             try {
  592.                 if (this.Commit()) {
  593.                     XmlTreeNode n = (XmlTreeNode)this.myTreeView.SelectedNode;
  594.                     if (n == null) return;
  595.                     ChangeNode cmd = new ChangeNode(this, n, nt);
  596.                     this.UndoManager.Push(cmd);
  597.                     this.nodeTextView.Invalidate();
  598.                     this.myTreeView.SelectedNode = cmd.NewNode;                    
  599.                 }
  600.             } catch (Exception ex) {
  601.                 MessageBox.Show(this, ex.Message, SR.ChangeErrorCaption, MessageBoxButtons.OK, MessageBoxIcon.Error);
  602.             }
  603.         }
  605.         public void InsertNode(InsertPosition position, XmlNodeType type) {
  606.             try {
  607.                 XmlTreeNode n = (XmlTreeNode)this.myTreeView.SelectedNode;
  608.                 InsertNode inode = new InsertNode(this);
  609.                 inode.Initialize(n, position, type);
  610.                 this.UndoManager.Push(inode);
  611.                 this.nodeTextView.Invalidate();
  612.                 this.myTreeView.SelectedNode = inode.NewNode;
  613.                 if (inode.RequiresName) {
  614.                     this.myTreeView.Focus();
  615.                     inode.NewNode.BeginEdit();
  616.                 } else {
  617.                     this.nodeTextView.FocusBeginEdit(null);
  618.                 }
  619.             } catch (Exception ex) {
  620.                 MessageBox.Show(this, ex.Message, SR.InsertErrorCaption, MessageBoxButtons.OK, MessageBoxIcon.Error);
  621.             }
  622.         }
  623.         
  624.         public bool Delete() {
  625.             if (this.myTreeView.SelectedNode != null) {
  626.                 XmlTreeNode t = (XmlTreeNode)this.myTreeView.SelectedNode;                 
  627.                 this.UndoManager.Push(new DeleteNode(this.model.Document, t));
  628.                 this.nodeTextView.Invalidate();
  629.                 return true;
  630.             }
  631.             return false;
  632.         }
  634.         public bool Insert() {
  635.             // Insert empty node of same type as current node right after current node.
  636.             if (this.myTreeView.SelectedNode != null) {
  637.                 XmlTreeNode n = (XmlTreeNode)this.myTreeView.SelectedNode;
  638.                 InsertNode(InsertPosition.After, n.Node.NodeType);
  639.                 return true;
  640.             }
  641.             return false;
  642.         }
  644.         public bool Duplicate() {
  645.             if (this.myTreeView.SelectedNode != null) {
  646.                 XmlTreeNode t = (XmlTreeNode)this.myTreeView.SelectedNode;
  647.                 this.UndoManager.Push(new MoveNode(this, t, t, InsertPosition.After, true));
  648.                 this.nodeTextView.Invalidate();
  649.                 return true;
  650.             }
  651.             return false;
  653.         }
  655.         private void HandleMouseWheel(object sender, MouseEventArgs e) {            
  656.             int y = SystemInformation.MouseWheelScrollLines * (e.Delta/120);
  657.             int v = Math.Max(0, Math.Min(this.vScrollBar1.Value - y, this.vScrollBar1.Maximum + 1 - this.vScrollBar1.LargeChange));
  658.             this.vScrollBar1.Value = v;
  659.             vScrollBar1_Scroll(this, new ScrollEventArgs(ScrollEventType.ThumbTrack, v));
  660.         }
  662.         private void hScrollBar1_Scroll(object sender, System.Windows.Forms.ScrollEventArgs e) {
  663.             if (this.TreeView.IsEditing) {
  664.                 this.TreeView.EndEdit(true);
  665.             }
  666.             if (this.nodeTextView.IsEditing) {
  667.                 this.nodeTextView.EndEdit(true);
  668.             }
  669.             this.myTreeView.ScrollPosition = new Point(-e.NewValue * HScrollIncrement, this.myTreeView.ScrollPosition.Y);            
  670.         }
  671.         
  672.         private void vScrollBar1_Scroll(object sender, System.Windows.Forms.ScrollEventArgs e) {
  673.             if (this.TreeView.IsEditing) {
  674.                 this.TreeView.EndEdit(true);
  675.             }
  676.             if (this.nodeTextView.IsEditing) {
  677.                 this.nodeTextView.EndEdit(true);
  678.             }
  679.             int y = -e.NewValue * this.myTreeView.ItemHeight;
  680.             this.myTreeView.ScrollPosition = new Point(this.myTreeView.ScrollPosition.X, y);
  681.             this.nodeTextView.ScrollPosition = new Point(0, y);
  682.             this.nodeTextView.Invalidate();
  683.         }        
  684.         
  685.         protected override bool ProcessDialogKey(Keys keyData) {
  686.             CurrentEvent.Event = new KeyEventArgs(keyData);
  687.             Keys modifiers = (keyData & Keys.Modifiers);
  688.             Keys key = keyData & ~modifiers;
  689.             switch (key) {
  690.                 case Keys.Tab:
  691.                     if (modifiers == Keys.Shift) {
  692.                         bool editing = this.nodeTextView.IsEditing;
  693.                         if (this.nodeTextView.Focused || editing) {
  694.                             if (this.nodeTextView.EndEdit(false)) {
  695.                                 this.myTreeView.Focus();
  696.                             }
  697.                         } else {
  698.                             if (this.myTreeView.SelectedNode != null) {
  699.                                 TreeNode previous = this.myTreeView.SelectedNode.PrevVisibleNode;
  700.                                 if (previous != null) this.myTreeView.SelectedNode = previous;
  701.                             }
  702.                             this.nodeTextView.Focus();
  703.                         }
  704.                     } else {
  705.                         bool editing = this.myTreeView.IsEditing;
  706.                         if (this.myTreeView.Focused || editing) {
  707.                             if (this.myTreeView.EndEdit(false)) {
  708.                                 this.nodeTextView.Focus();
  709.                                 if (editing) {
  710.                                     this.nodeTextView.FocusBeginEdit(null);
  711.                                 }
  712.                             }
  713.                         } else {
  714.                             if (this.myTreeView.SelectedNode != null) {
  715.                                 TreeNode next = this.myTreeView.SelectedNode.NextVisibleNode;
  716.                                 if (next != null) this.myTreeView.SelectedNode = next;
  717.                             }
  718.                             this.myTreeView.Focus();
  719.                         }
  720.                     }
  721.                     return true;
  722.             }
  723.             return false;
  724.         }
  726.         public void StartIncrementalSearch() {
  727.             if (this.TreeView.ContainsFocus) {
  728.                 this.TreeView.StartIncrementalSearch();
  729.             } else if (this.nodeTextView.ContainsFocus) {
  730.                 this.nodeTextView.StartIncrementalSearch();
  731.             }
  732.         }
  734.         private void myTreeView_KeyDown(object sender, KeyEventArgs e) {
  735.             CurrentEvent.Event = e;
  736.             if (!this.IsEditing) {
  738.                 bool ctrlMods = e.Modifiers == Keys.Control || e.Modifiers == (Keys.Control | Keys.Shift);
  739.                 bool nudgeMods = e.Modifiers == (Keys.Control | Keys.Shift);
  740.                 XmlTreeNode xn = this.SelectedNode;
  741.                 TreeNode n = this.myTreeView.SelectedNode;
  742.                 switch (e.KeyCode) {
  743.                     case Keys.Escape:
  744.                         this.Commit();
  745.                         if (!e.Handled) {
  746.                             this.myTreeView.SelectedNode = null;
  747.                             if (this.SelectionChanged != null)
  748.                                 SelectionChanged(this, EventArgs.Empty);
  749.                         }
  750.                         break;
  751.                     case Keys.X:
  752.                         if (ctrlMods) {
  753.                             this.Cut();
  754.                             e.Handled = true;
  755.                         }
  756.                         break;
  757.                     case Keys.C:
  758.                         if (ctrlMods) {
  759.                             this.Copy();
  760.                             e.Handled = true;
  761.                         }
  762.                         break;
  763.                     case Keys.V:
  764.                         if (ctrlMods) {
  765.                             this.Paste(InsertPosition.Child);
  766.                             e.Handled = true;
  767.                         }
  768.                         break;
  769.                     case Keys.Right:
  770.                         if (nudgeMods && CanNudgeNode(xn, NudgeDirection.Right)) {
  771.                             this.NudgeNode(xn, NudgeDirection.Right);
  772.                             e.Handled = true;
  773.                         } else if (!this.IsEditing && n != null && n.Nodes.Count == 0) {
  774.                             this.nodeTextView.Focus();
  775.                             e.Handled = true;
  776.                         }
  777.                         break;
  778.                     case Keys.Delete:
  779.                         this.Delete();
  780.                         break;
  781.                     case Keys.F2:
  782.                     case Keys.Enter:
  783.                         BeginEditNodeName();
  784.                         e.Handled = true;
  785.                         break;
  786.                     case Keys.Up:
  787.                         if (nudgeMods && CanNudgeNode(xn, NudgeDirection.Up)) {
  788.                             this.NudgeNode(xn, NudgeDirection.Up);
  789.                             e.Handled = true;
  790.                         }
  791.                         break;
  792.                     case Keys.Down:
  793.                         if (nudgeMods && CanNudgeNode(xn, NudgeDirection.Down)) {
  794.                             this.NudgeNode(xn, NudgeDirection.Down);
  795.                             e.Handled = true;
  796.                         }
  797.                         break;
  798.                     case Keys.Left:
  799.                         if (nudgeMods && CanNudgeNode(xn, NudgeDirection.Left)) {
  800.                             this.NudgeNode(xn, NudgeDirection.Left);
  801.                             e.Handled = true;
  802.                         }
  803.                         break;
  804.                     default:
  805.                         if (!e.Handled) {
  806.                             nodeTextView_KeyDown(sender, e);
  807.                         }
  808.                         break;
  809.                 }
  810.             } else if (!e.Handled) {
  811.                 base.OnKeyDown(e);
  812.             }
  814.         }
  816.         public void BeginEditNodeName() {
  817.             TreeNode n = this.myTreeView.SelectedNode;                
  818.             if (!this.IsEditing && n != null && n.IsLabelEditable) {
  819.                 n.BeginEdit();
  820.             }
  821.         }
  823.         private void nodeTextView_KeyDown(object sender, KeyEventArgs e) {
  824.             tip.Hide();
  825.             CurrentEvent.Event = e;
  826.             if (!this.IsEditing) {
  827.                 bool ctrlMods = e.Modifiers == Keys.Control || e.Modifiers == (Keys.Control | Keys.Shift);
  828.                 Keys key = (e.KeyData & ~Keys.Modifiers);
  829.                 switch (key) {
  830.                     case Keys.Left:
  831.                         if (nodeTextView.Focused) {
  832.                             this.myTreeView.Focus();
  833.                             e.Handled = true;
  834.                         }
  835.                         break;
  836.                     case Keys.Delete:
  837.                         this.Delete();
  838.                         e.Handled = true;
  839.                         return;
  840.                     case Keys.X:
  841.                         if (ctrlMods) {
  842.                             this.Cut();
  843.                             e.Handled = true;
  844.                         }
  845.                         break;
  846.                     case Keys.C:
  847.                         if (ctrlMods) {
  848.                             this.Copy();
  849.                             e.Handled = true;
  850.                         }
  851.                         break;
  852.                     case Keys.V:
  853.                         if (ctrlMods) {
  854.                             this.Paste(InsertPosition.Child);
  855.                             e.Handled = true;
  856.                         }
  857.                         break;
  858.                     default:
  859.                         if (!e.Handled) {
  860.                             this.myTreeView.HandleKeyDown(e);
  861.                         }
  862.                         break;
  863.                 }
  864.             }
  865.             if (!e.Handled) {
  866.                 base.OnKeyDown(e);
  867.             }
  868.         }
  870.         private void settings_Changed(object sender, string name) {
  871.             ISynchronizeInvoke si = (ISynchronizeInvoke)this;
  872.             if (si.InvokeRequired){
  873.                 this.Invoke(new SettingsEventHandler(OnSettingsChanged), new object[] { sender, name });
  874.             } else {
  875.                 OnSettingsChanged(sender, name);
  876.             }
  877.         }
  879.         private void OnSettingsChanged(object sender, string name) {
  881.             // change the node colors.
  882.             System.Collections.Hashtable colors = (System.Collections.Hashtable)this.settings["Colors"];
  883.             Color backColor = (Color)colors["Background"];
  884.             this.BackColor = backColor;
  885.             this.myTreeView.BackColor = backColor;
  886.             this.nodeTextView.BackColor = backColor;
  888.             this.Font = (Font)this.settings["Font"];
  890.             this.myTreeView.BeginUpdate();
  891.             InvalidateNodes(this.myTreeView.Nodes); // force nodes to pick up new colors.
  892.             this.myTreeView.EndUpdate();
  893.         }
  895.         void InvalidateNodes(TreeNodeCollection nodes) {
  896.             if (nodes == null) return;
  897.             foreach (XmlTreeNode xn in nodes) {
  898.                 if (xn.IsVisible) {
  899.                     xn.Invalidate();
  900.                     if (xn.IsExpanded) {
  901.                         InvalidateNodes(xn.Nodes);
  902.                     }
  903.                 }
  904.             }
  905.         }
  907.         enum DragKeyState {
  908.             LeftButton = 1,
  909.             RightButton = 2,
  910.             Shift = 4,
  911.             Control = 8,
  912.             MiddleButton = 16,
  913.             Alt = 32
  914.         }
  916.         static TreeData CheckDragEvent(DragEventArgs e) {
  917.             TreeData data = null;
  918.             string name = DataFormats.GetFormat(typeof(TreeData).FullName).Name;
  919.             try {
  920.                 if (e.Data.GetDataPresent(name, false)) {
  921.                     data = (TreeData)e.Data.GetData(name);
  922.                 }
  923.             } 
  924.             catch (Exception ex) {
  925.                 Trace.WriteLine("Exception:" + ex.ToString());
  926.             }
  927.             if (data == null && e.Data.GetDataPresent(DataFormats.Text)) {
  928.                 string xml = (string)e.Data.GetData(DataFormats.Text);
  929.                 data = new TreeData(xml);
  930.             }
  931.             if (data != null) {
  932.                 DragKeyState ks = (DragKeyState)e.KeyState;
  933.                 // Copy when the control key is down.
  934.                 e.Effect = ((ks & DragKeyState.Control) != DragKeyState.Control) ?
  935.                     DragDropEffects.Move : DragDropEffects.Copy;
  936.             } 
  937.             else {
  938.                 e.Effect = DragDropEffects.None;
  939.             }
  940.             return data;
  941.         }
  943.         private void treeViewFeedback_DragDrop(object sender, DragEventArgs e) {
  944.             TreeData data = CheckDragEvent(e);
  945.             FinishDragDrop(data, e.Effect);
  946.         }
  948.         private void treeViewFeedback_DragEnter(object sender, DragEventArgs e) {
  949.             TreeData data = CheckDragEvent(e);
  950.             if (data != null && this.feedback == null) {
  951.                 this.feedback = new XmlTreeViewDropFeedback();
  952.                 if (this.dragged == null) {
  953.                     // dragging from another app, so we have to import the node at this point.
  954.                     XmlTreeNode target = (XmlTreeNode)this.myTreeView.FindNodeAt(e.X, e.Y);
  955.                     this.dragged = data.GetTreeNode(this.Model.Document, target, this);
  956.                 }
  957.                 this.feedback.Item = this.dragged;
  958.                 this.feedback.TreeView = this.myTreeView;
  959.             }            
  960.             if (this.feedback != null) {
  961.                 this.feedback.Position = new Point(e.X, e.Y);
  962.             }
  963.         }
  965.         private void treeViewFeedback_DragLeave(object sender, EventArgs e) {
  966.             RemoveFeedback();
  967.         }
  969.         private void treeViewFeedback_DragOver(object sender, DragEventArgs e) {
  970.             // find the node under the X,Y position and draw feedback as to where the new node will
  971.             // be dropped. 
  972.             if (this.feedback != null) {
  973.                 CheckDragEvent(e);                
  974.                 this.feedback.Position = new Point(e.X, e.Y);
  975.             }
  976.         }
  978.         private void myTreeView_GiveFeedback(object sender, GiveFeedbackEventArgs e) {
  979.             e.UseDefaultCursors = true;
  980.         }
  982.         private void myTreeView_ItemDrag(object sender, ItemDragEventArgs e) {
  983.             if (e.Button == MouseButtons.Left) {
  984.                 this.dragged = (XmlTreeNode)e.Item;
  985.                 this.myTreeView.SelectedNode = this.dragged;
  986.                 TreeData data = new TreeData(this.dragged);
  987.                 DragDropEffects effect = this.DoDragDrop(data, DragDropEffects.All);
  988.                 if (this.dragged != null && effect != DragDropEffects.None) {
  989.                     FinishDragDrop(data, effect);
  990.                 }
  991.                 RemoveFeedback();
  993.             }
  994.         }
  995.         void RemoveFeedback() {
  996.             if (this.feedback != null) {
  997.                 this.feedback.Finish(this.dragged != null);
  998.                 this.feedback.Dispose();
  999.                 this.feedback = null;
  1000.             }
  1001.         }
  1003.         protected void FinishDragDrop(TreeData data, DragDropEffects effect) {
  1004.             if (data != null && effect != DragDropEffects.None && this.dragged != null) {
  1005.                 bool copy = (effect == DragDropEffects.Copy);
  1006.                 if (this.feedback != null) {
  1007.                     // Then we are also the drop site
  1008.                     MoveNode cmd = null;
  1009.                     if (this.feedback.Before != null) {
  1010.                         cmd = MoveNode(this.dragged, (XmlTreeNode)this.feedback.Before, InsertPosition.Before, copy);
  1011.                     } 
  1012.                     else if (this.feedback.After != null) {
  1013.                         cmd = MoveNode(this.dragged, (XmlTreeNode)this.feedback.After, InsertPosition.After, copy);
  1014.                     }
  1015.                     // Now we can expand it because it is now in the tree
  1016.                     if (cmd != null && cmd.Source.Nodes.Count > 1) {
  1017.                         cmd.Source.Expand();
  1018.                     }
  1019.                 } 
  1020.                 else if (!copy) {
  1021.                     // Then this was a move to another process, so now we have to remove it
  1022.                     // from this process.
  1023.                     Debug.Assert(this.myTreeView.SelectedNode == this.dragged);
  1024.                     this.Delete();
  1025.                 }
  1026.             }
  1027.             this.dragged = null;
  1028.             RemoveFeedback();
  1029.         }
  1031.         private MoveNode MoveNode(XmlTreeNode source, XmlTreeNode dest, InsertPosition where, bool copy) {
  1032.             try {
  1033.                 MoveNode cmd = new MoveNode(this, source, dest, where, copy);
  1034.                 this.UndoManager.Push(cmd);
  1035.                 return cmd;
  1036.             } 
  1037.             catch (Exception ex) {
  1038.                 MessageBox.Show(this, ex.Message, SR.MoveErrorCaption, MessageBoxButtons.OK, MessageBoxIcon.Error);
  1039.             }
  1040.             return null;
  1041.         }
  1043.         public bool CanNudgeNode(XmlTreeNode node, NudgeDirection dir) {
  1044.             if (node == null) return false;
  1045.             NudgeNode n = new NudgeNode(this, node, dir);
  1046.             return n.IsEnabled;
  1047.         }
  1049.         public void NudgeNode(XmlTreeNode node, NudgeDirection dir) {
  1050.             try {
  1051.                 NudgeNode cmd = new NudgeNode(this, node, dir);
  1052.                 this.UndoManager.Push(cmd);
  1053.             } 
  1054.             catch (Exception ex) {
  1055.                 MessageBox.Show(this, ex.Message, SR.NudgeErrorCaption, MessageBoxButtons.OK, MessageBoxIcon.Error);
  1056.             }
  1057.         }
  1059.         bool reentrantLock = false;
  1061.         public void RecalculateNamespaces(XmlNode node) {
  1062.             if (node is XmlText) node = node.ParentNode;
  1063.             if (node.NodeType != XmlNodeType.Element && node.NodeType != XmlNodeType.Attribute) {
  1064.                 return;
  1065.             }
  1066.             if (reentrantLock) return;
  1068.             Command exec = this.UndoManager.Executing;
  1069.             if (exec != null && exec.Name == "Edit Namespace")
  1070.                 return; // don't "redo" this during Commnad.Redo()! 
  1072.             this.SuspendLayout();
  1073.             this.myTreeView.BeginUpdate();
  1074.             this.model.BeginUpdate();
  1075.             
  1076.             Cursor.Current = Cursors.WaitCursor;
  1077.             
  1078.             // Do not re-enter this when we are processing the recalcNamespaces compound command!
  1079.             reentrantLock = true;
  1080.             try {
  1081.                 // This xmlns attribute has changed, so we need to recalculate the NamespaceURI
  1082.                 // property on the scoped element and it's children so that validation works
  1083.                 // as expected.  
  1084.                 XmlElement scope;
  1085.                 if (node is XmlAttribute) {
  1086.                     scope = ((XmlAttribute)node).OwnerElement;
  1087.                 } else {
  1088.                     scope = (XmlElement)node;
  1089.                 }
  1090.                 if (scope == null) return;
  1091.                 XmlTreeNode tnode = FindNode(scope);
  1092.                 if (tnode == null) return;
  1093.                 if (tnode.Node == null) return;
  1095.                 XmlNamespaceManager nsmgr = XmlHelpers.GetNamespaceScope(scope);
  1096.                 CompoundCommand cmd = new CompoundCommand("Edit Namespace");
  1097.                 tnode.RecalculateNamespaces(nsmgr, cmd);
  1098.                 if (cmd.Count > 0) {
  1099.                     this.UndoManager.Merge(cmd);
  1100.                 }
  1101.             } finally {
  1102.                 reentrantLock = false;
  1103.                 this.myTreeView.EndUpdate();
  1104.                 this.ResumeLayout();
  1105.                 this.myTreeView.Invalidate();
  1106.                 this.model.EndUpdate();
  1107.                 Cursor.Current = Cursors.Arrow;
  1108.             }
  1109.         }
  1111.         //=======================================================================================
  1112.         // DO NOT EDIT BELOW THIS LINE
  1113.         //=======================================================================================
  1115.         /// <summary> 
  1116.         /// Clean up any resources being used.
  1117.         /// </summary>
  1118.         protected override void Dispose(bool disposing) {
  1119.             if (disposing) {
  1120.                 if (components != null) {
  1121.                     components.Dispose();
  1122.                 }
  1123.             }
  1124.             base.Dispose(disposing);
  1125.         }
  1127.         #region Component Designer generated code
  1128.         /// <summary> 
  1129.         /// Required method for Designer support - do not modify 
  1130.         /// the contents of this method with the code editor.
  1131.         /// </summary>
  1132.         private void InitializeComponent() {
  1133.             this.components = new System.ComponentModel.Container();
  1134.             System.Resources.ResourceManager resources = new System.Resources.ResourceManager(typeof(XmlTreeView));
  1135.             this.myTreeView = new TreeView();
  1136.             this.imageList1 = new System.Windows.Forms.ImageList(this.components);
  1137.             this.nodeTextView = new XmlNotepad.NodeTextView();
  1138.             this.resizer = new XmlNotepad.PaneResizer();
  1139.             this.vScrollBar1 = new System.Windows.Forms.VScrollBar();
  1140.             this.hScrollBar1 = new HScrollBar();
  1141.             this.SuspendLayout();
  1142.             // 
  1143.             // myTreeView
  1144.             // 
  1145.             this.myTreeView.BorderStyle = System.Windows.Forms.BorderStyle.None;
  1146.             this.myTreeView.ImageList = this.imageList1;
  1147.             this.myTreeView.LabelEdit = true;
  1148.             this.myTreeView.Location = new System.Drawing.Point(0, 0);
  1149.             this.myTreeView.Name = "TreeView";
  1150.             this.myTreeView.AccessibleName = "TreeView";
  1151.             //this.myTreeView.Scrollable = false;
  1152.             this.myTreeView.Size = new System.Drawing.Size(216, 224);
  1153.             this.myTreeView.TabIndex = 1;
  1154.             // 
  1155.             // imageList1
  1156.             // 
  1157.             this.imageList1.ColorDepth = System.Windows.Forms.ColorDepth.Depth24Bit;
  1158.             this.imageList1.ImageSize = new System.Drawing.Size(16, 16);
  1159.             object imgStream = resources.GetObject("imageList1.ImageStream");
  1160.             this.imageList1.ImageStream = (System.Windows.Forms.ImageListStreamer)imgStream;
  1161.             this.imageList1.TransparentColor = System.Drawing.Color.Transparent;
  1162.             // 
  1163.             // nodeTextView
  1164.             // 
  1165.             this.nodeTextView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
  1166.                 | System.Windows.Forms.AnchorStyles.Left)
  1167.                 | System.Windows.Forms.AnchorStyles.Right)));
  1168.             this.nodeTextView.BackColor = System.Drawing.Color.White;
  1169.             this.nodeTextView.Location = new System.Drawing.Point(301, 0);
  1170.             this.nodeTextView.Name = "nodeTextView";
  1171.             this.nodeTextView.SelectedNode = null;
  1172.             this.nodeTextView.Size = new System.Drawing.Size(179, 224);
  1173.             this.nodeTextView.TabIndex = 4;
  1174.             // 
  1175.             // resizer
  1176.             // 
  1177.             this.resizer.Border3DStyle = System.Windows.Forms.Border3DStyle.Raised;
  1178.             this.resizer.Location = new System.Drawing.Point(200, 0);
  1179.             this.resizer.Name = "XmlTreeResizer";
  1180.             this.resizer.AccessibleName = "XmlTreeResizer";
  1181.             this.resizer.Pane1 = this.myTreeView;
  1182.             this.resizer.Pane2 = this.nodeTextView;
  1183.             this.resizer.PaneWidth = 5;
  1184.             this.resizer.Size = new System.Drawing.Size(5, 408);
  1185.             this.resizer.TabIndex = 3;
  1186.             this.resizer.Vertical = true;
  1187.             //
  1188.             // hScrollBar1
  1189.             //
  1190.             this.hScrollBar1.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
  1191.                 | System.Windows.Forms.AnchorStyles.Right)));
  1192.             this.hScrollBar1.Location = new System.Drawing.Point(0, 207);
  1193.             this.hScrollBar1.Name = "HScrollBar";
  1194.             this.hScrollBar1.AccessibleName = "HScrollBar";
  1195.             this.hScrollBar1.Size = new System.Drawing.Size(179, 17);
  1196.             this.hScrollBar1.TabIndex = 2;
  1197.             this.hScrollBar1.Scroll += new System.Windows.Forms.ScrollEventHandler(this.hScrollBar1_Scroll);
  1198.             
  1199.             // 
  1200.             // vScrollBar1
  1201.             // 
  1202.             this.vScrollBar1.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
  1203.                 | System.Windows.Forms.AnchorStyles.Right)));
  1204.             this.vScrollBar1.Location = new System.Drawing.Point(480, 0);
  1205.             this.vScrollBar1.Name = "VScrollBar";
  1206.             this.vScrollBar1.AccessibleName = "VScrollBar";
  1207.             this.vScrollBar1.Size = new System.Drawing.Size(17, 224);
  1208.             this.vScrollBar1.TabIndex = 0;
  1209.             this.vScrollBar1.Scroll += new System.Windows.Forms.ScrollEventHandler(this.vScrollBar1_Scroll);
  1210.             // 
  1211.             // XmlTreeView
  1212.             // 
  1213.             this.BackColor = System.Drawing.SystemColors.Window;
  1214.             this.Controls.Add(this.vScrollBar1);
  1215.             this.Controls.Add(this.hScrollBar1);
  1216.             this.Controls.Add(this.resizer);
  1217.             this.Controls.Add(this.nodeTextView);
  1218.             this.Controls.Add(this.myTreeView);
  1219.             this.Size = new System.Drawing.Size(496, 224);
  1220.             this.ResumeLayout(false);
  1222.         }
  1223.         #endregion
  1224.     }
  1226.     public enum NodeImage {
  1227.         None,
  1228.         Element,
  1229.         Attribute,
  1230.         Leaf,
  1231.         Text,
  1232.         Comment,
  1233.         PI,
  1234.         OpenElement,
  1235.         CData,
  1236.     }
  1238.     public class XmlTreeNode : TreeNode {
  1239.         Settings settings;
  1240.         NodeImage img;
  1241.         Color foreColor;
  1242.         internal List<XmlTreeNode> children;
  1243.         XmlTreeView view;
  1244.         XmlNode node;
  1245.         XmlSchemaType type;
  1246.         XmlNodeType nodeType;
  1247.         string editLabel;
  1249.         public XmlTreeNode(XmlTreeView view) {
  1250.             this.view = view;
  1251.         }
  1253.         public XmlTreeNode(XmlTreeView view, XmlNode node) {
  1254.             this.view = view;
  1255.             this.node = node;
  1256.             Init();
  1257.         }
  1259.         public XmlTreeNode(XmlTreeView view, XmlTreeNode parent, XmlNode node)
  1260.             : base(parent) {
  1261.             this.view = view;
  1262.             this.node = node;
  1263.             Init();
  1264.         }
  1266.         [Browsable(false)]
  1267.         public XmlNodeType NodeType {
  1268.             get { return (this.node != null) ? this.node.NodeType : this.nodeType; }
  1269.             set { this.nodeType = value; }
  1270.         }
  1272.         [Browsable(false)]
  1273.         public XmlTreeView XmlTreeView {
  1274.             get { return this.view; }
  1275.             set {
  1276.                 this.view = value;
  1277.                 this.TreeView = value == null ? null : value.TreeView;
  1278.                 PropagateView(value, children);
  1279.                 Init();
  1280.             }
  1281.         }
  1283.         public override void Remove() {
  1284.             base.Remove();
  1285.             XmlTreeNode xp = this.Parent as XmlTreeNode;
  1286.             if (xp != null) {
  1287.                 xp.OnChildRemoved();
  1288.             }
  1289.         }
  1291.         void OnChildRemoved() {
  1292.             if (this.img == NodeImage.Element && this.Nodes.Count == 0) {
  1293.                 MakeLeaf();
  1294.             }
  1295.         }
  1297.         void MakeLeaf() {
  1298.             this.Collapse();
  1299.             this.img = NodeImage.Leaf;
  1300.             this.Invalidate();
  1301.         }
  1303.         [Browsable(false)]
  1304.         public XmlSchemaType SchemaType {
  1305.             get { return this.type; }
  1306.             set { this.type = value; }
  1307.         }
  1309.         void PropagateView(XmlTreeView view, List<XmlTreeNode> children) {
  1310.             if (children != null) {
  1311.                 foreach (XmlTreeNode child in children) {
  1312.                     child.XmlTreeView = view;
  1313.                     PropagateView(view, child.children);
  1314.                 }
  1315.             }
  1316.         }
  1318.         void Init() {
  1319.             if (this.view != null) {
  1320.                 this.settings = view.Settings;
  1321.                 this.img = CalculateNodeImage(this.Node);
  1322.                 this.foreColor = this.GetForeColor(this.img);
  1323.             }
  1324.         }
  1327.         public override void Invalidate() {
  1328.             base.Invalidate();
  1329.             Init();
  1330.             this.XmlTreeView.SyncScrollbars();
  1331.         }
  1333.         public Settings Settings { get { return this.settings; } }
  1335.         public XmlNode Node {
  1336.             get { return this.node; }
  1337.             set {
  1338.                 this.node = value;
  1339.                 int count = this.Nodes.Count;
  1340.                 Init();
  1341.                 this.Invalidate();
  1342.                 if (this.TreeView != null) {
  1343.                     this.TreeView.InvalidateLayout(); // LabelBounds needs recalculating.                
  1344.                     this.TreeView.InvalidateNode(this);
  1345.                 }
  1346.             }
  1347.         }
  1348.         public override string Label {
  1349.             get {
  1350.                 return this.Node == null ? editLabel : this.Node.Name;
  1351.             }
  1352.             set {
  1353.                 editLabel = value;
  1354.                 this.Invalidate();
  1355.             }
  1356.         }
  1357.         public override bool IsLabelEditable {
  1358.             get {
  1359.                 return (this.node == null || this.node is XmlProcessingInstruction ||
  1360.                     ((this.node is XmlAttribute || this.node is XmlElement)));
  1361.             }
  1362.         }
  1363.         public override string Text {
  1364.             get {
  1365.                 XmlNode n = this.Node;
  1366.                 string text = null;
  1367.                 if (n is XmlElement) {
  1368.                     NodeImage i = this.NodeImage;
  1369.                     if (NodeImage.Element != i && NodeImage.OpenElement != i) {
  1370.                         text = n.InnerText;
  1371.                     }
  1372.                 } else if (n is XmlProcessingInstruction) {
  1373.                     text = ((XmlProcessingInstruction)n).Data;
  1374.                 } else if (n != null) {
  1375.                     text = n.Value;
  1376.                 }
  1377.                 return text;
  1378.             }
  1379.             set {
  1380.                 EditNodeValue ev = new EditNodeValue(this.XmlTreeView, this, value);
  1381.                 UndoManager undo = this.XmlTreeView.UndoManager;
  1382.                 undo.Push(ev);
  1383.             }
  1384.         }
  1386.         public override Color ForeColor {
  1387.             get {
  1388.                 return this.foreColor;
  1389.             }
  1390.         }
  1392.         public override TreeNodeCollection Nodes {
  1393.             get {
  1394.                 return new XmlTreeNodeCollection(this);
  1395.             }
  1396.         }
  1398.         public NodeImage NodeImage {
  1399.             get {
  1400.                 if (this.IsExpanded) {
  1401.                     return NodeImage.OpenElement;
  1402.                 }
  1403.                 return this.img;
  1404.             }
  1405.         }
  1407.         public override int ImageIndex {
  1408.             get {
  1409.                 return (int)this.NodeImage - 1;
  1410.             }
  1411.         }
  1413.         public Color GetForeColor(NodeImage img) {
  1414.             System.Collections.Hashtable colors = (System.Collections.Hashtable)this.settings["Colors"];
  1415.             switch (img) {
  1416.                 case NodeImage.Element:
  1417.                 case NodeImage.OpenElement:
  1418.                 case NodeImage.Leaf:
  1419.                     return (Color)colors["Element"];
  1420.                 case NodeImage.Attribute:
  1421.                     return (Color)colors["Attribute"];
  1422.                 case NodeImage.PI:
  1423.                     return (Color)colors["PI"];
  1424.                 case NodeImage.CData:
  1425.                     return (Color)colors["CDATA"];
  1426.                 case NodeImage.Comment:
  1427.                     return (Color)colors["Comment"];
  1428.                 default:
  1429.                     return (Color)colors["Text"];
  1430.             }
  1431.         }
  1433.         NodeImage CalculateNodeImage(XmlNode n) {
  1434.             XmlNodeType nt = (n == null) ? this.nodeType : n.NodeType;
  1435.             switch (nt) {
  1436.                 case XmlNodeType.Attribute:
  1437.                     return NodeImage.Attribute;
  1438.                 case XmlNodeType.Comment:
  1439.                     return NodeImage.Comment;
  1440.                 case XmlNodeType.ProcessingInstruction:
  1441.                 case XmlNodeType.XmlDeclaration:
  1442.                     return NodeImage.PI;
  1443.                 case XmlNodeType.Text:
  1444.                 case XmlNodeType.Whitespace:
  1445.                 case XmlNodeType.SignificantWhitespace:
  1446.                     return NodeImage.Text;
  1447.                 case XmlNodeType.CDATA:
  1448.                     return NodeImage.CData;
  1449.                 case XmlNodeType.Element:
  1450.                     XmlElement e = (XmlElement)n;
  1451.                     if (e != null && IsContainer(e)) {
  1452.                         return NodeImage.Element;
  1453.                     }
  1454.                     return NodeImage.Leaf;
  1455.                 default:
  1456.                     return NodeImage.PI;
  1457.             }
  1458.         }
  1460.         static bool IsContainer(XmlElement e) {
  1461.             if (e.HasChildNodes) {
  1462.                 int count = 0;
  1463.                 foreach (XmlNode c in e.ChildNodes) {
  1464.                     if (c is XmlComment || c is XmlProcessingInstruction || c is XmlElement)
  1465.                         return true;
  1466.                     if (c is XmlText || c is XmlCDataSection) {
  1467.                         count++;
  1468.                         if (count > 1) return true;
  1469.                     }
  1470.                 }
  1471.             }
  1472.             return HasSpecifiedAttributes(e);
  1473.         }
  1475.         static bool HasSpecifiedAttributes(XmlElement e) {
  1476.             if (e.HasAttributes) {
  1477.                 foreach (XmlAttribute a in e.Attributes) {
  1478.                     if (a.Specified) return true;
  1479.                 }
  1480.             }
  1481.             return false;
  1482.         }
  1484.         public void RecalculateNamespaces(XmlNamespaceManager nsmgr, CompoundCommand cmd) {
  1485.             Debug.Assert(this.NodeType == XmlNodeType.Element || this.NodeType == XmlNodeType.Attribute);
  1486.             XmlNode e = this.Node;
  1487.             if (e == null) return; // user is still editing this tree node!
  1488.             bool hasXmlNs = false;
  1489.             if (e.Attributes != null) {
  1490.                 XmlAttributeCollection acol = e.Attributes;
  1491.                 for (int i = 0, n = acol.Count; i < n; i++) {
  1492.                     XmlAttribute a = acol[i];
  1493.                     string value = a.Value;
  1494.                     if (a.NamespaceURI == XmlHelpers.XmlnsUri) {
  1495.                         if (!hasXmlNs) {
  1496.                             nsmgr.PushScope();
  1497.                             hasXmlNs = true;
  1498.                         }
  1499.                         XmlNameTable nt = nsmgr.NameTable;
  1500.                         string prefix = nt.Add(a.LocalName);
  1501.                         if (prefix == "xmlns") prefix = "";
  1502.                         if (!nsmgr.HasNamespace(prefix)) {
  1503.                             try {
  1504.                                 nsmgr.AddNamespace(prefix, nt.Add(value));
  1505.                             } catch (Exception ex) {
  1506.                                 // illegal namespace declaration, perhaps user has not finished editing it yet.
  1507.                                 Trace.WriteLine(ex.Message);
  1508.                             }
  1509.                         }
  1510.                     }
  1511.                 }
  1512.             }
  1514.             XmlName name = XmlHelpers.ParseName(nsmgr, e.Name, this.NodeType);
  1515.             if (name.NamespaceUri != e.NamespaceURI &&
  1516.                 (string.IsNullOrEmpty(name.Prefix) || !string.IsNullOrEmpty(name.NamespaceUri))) {
  1517.                 // Node has bound to a different namespace!
  1518.                 // Note that XmlNode doesn't let you change the NamespaceURI property
  1519.                 // so we have to recreate the XmlNode objects, and so we have to create
  1520.                 // a command for this since it is editing the tree!
  1521.                 EditNodeName rename = new EditNodeName(this, name, false);
  1522.                 cmd.Add(rename);
  1523.             }
  1525.             foreach (XmlTreeNode child in this.Nodes) {
  1526.                 switch (child.NodeType) {
  1527.                     case XmlNodeType.Attribute:
  1528.                     case XmlNodeType.Element:
  1529.                         child.RecalculateNamespaces(nsmgr, cmd);
  1530.                         break;
  1531.                     default:
  1532.                         // no change required on text nodes.
  1533.                         break;
  1534.                 }
  1535.             }
  1537.             if (hasXmlNs) {
  1538.                 nsmgr.PopScope();
  1539.             }
  1540.         }
  1542.         public override bool CanExpandAll {
  1543.             get {
  1544.                 return (this.NodeImage != NodeImage.Leaf); // don't expand the leaves
  1545.             }
  1546.         }
  1548.         public virtual string GetDefinition() {
  1549.             string ipath = this.GetIncludePath();
  1550.             if (string.IsNullOrEmpty(ipath)) {
  1551.                 ipath = this.GetSchemaLocation();
  1552.             }
  1553.             if (string.IsNullOrEmpty(ipath)) {
  1554.                 ipath = this.GetTypeInfo();
  1555.             }
  1557.             // todo: other forms of goto...
  1558.             return ipath;
  1559.         }
  1561.         public virtual string GetIncludePath() {
  1563.             if (this.NodeType == XmlNodeType.Attribute){
  1564.                 XmlTreeNode e = this.Parent as XmlTreeNode;
  1565.                 return e.GetIncludePath();
  1566.             }
  1568.             XmlNode n = this.Node;
  1569.             if (n != null && n.NamespaceURI == XmlIncludeReader.XIncludeNamespaceUri) {
  1570.                 string href = n.Attributes["href"].Value;
  1571.                 Uri resolved = ResolveUri(href);
  1572.                 return resolved.LocalPath;
  1573.             }
  1574.             return null;
  1575.         }
  1577.         public virtual string GetSchemaLocation() {
  1578.             XmlNode n = this.Node;
  1579.             if (this.NodeType == XmlNodeType.Attribute) {
  1580.                 if (n.NamespaceURI == "http://www.w3.org/2001/XMLSchema-instance") {
  1581.                     if (n.LocalName == "noNamespaceSchemaLocation") {
  1582.                         string href = n.Value;
  1583.                         Uri resolved = ResolveUri(href);
  1584.                         return resolved.LocalPath;
  1585.                     }
  1586.                 }
  1587.             }
  1588.             return null;
  1589.         }
  1591.         public virtual XmlSchemaAnnotated GetSchemaObject() {
  1592.             XmlSchemaInfo si = this.XmlTreeView.Model.GetTypeInfo(this.Node);
  1593.             if (si != null) {
  1594.                 XmlSchemaElement e = si.SchemaElement;
  1595.                 if (e != null) return e;
  1597.                 XmlSchemaAttribute a = si.SchemaAttribute;
  1598.                 if (a != null) return a;
  1600.                 XmlSchemaSimpleType st = si.MemberType;
  1601.                 if (st != null) return st;
  1603.                 return si.SchemaType;
  1604.             }
  1605.             return null;
  1606.         }
  1608.         public virtual string GetTypeInfo() {
  1609.             XmlSchemaObject o = GetSchemaObject();
  1610.             if (o != null) return GetSourceUri(o);
  1611.             return null;
  1612.         }
  1614.         public virtual string GetToolTip() {
  1615.             if (this.node == null) return null;
  1616.             XmlSchemaInfo si = this.XmlTreeView.Model.GetTypeInfo(this.Node);
  1617.             if (si != null) {
  1618.                 foreach (XmlSchemaAnnotated a in new XmlSchemaAnnotated[] {
  1619.                                                      si.SchemaElement, si.SchemaAttribute, 
  1620.                                                      si.MemberType, si.SchemaType}) {
  1621.                     if (a != null) {
  1622.                         string s = SchemaCache.GetAnnotation(a, SchemaCache.AnnotationNode.Tooltip);
  1623.                         if (!string.IsNullOrEmpty(s)) return s;
  1624.                     }
  1625.                 }
  1626.             }
  1627.             return null;
  1628.         }
  1630.         public virtual XmlDocument GetDocumentation() {
  1631.             if (this.node == null) return null;
  1632.             XmlDocument xmlDoc = new XmlDocument();
  1633.             XmlElement root = xmlDoc.CreateElement("documentation");
  1634.             xmlDoc.AppendChild(root);
  1635.             XmlSchemaInfo si = this.XmlTreeView.Model.GetTypeInfo(this.Node);
  1636.             if (si != null) {
  1637.                 foreach (XmlSchemaAnnotated a in new XmlSchemaAnnotated[] {
  1638.                                                      si.SchemaElement, si.SchemaAttribute, 
  1639.                                                      si.MemberType, si.SchemaType}) {
  1640.                     if (a != null) {
  1641.                         XmlSchemaDocumentation d = SchemaCache.GetDocumentation(a);
  1642.                         if (null != d && d.Markup != null && d.Markup.Length > 0) {
  1643.                             foreach (XmlNode n in d.Markup) {
  1644.                                 XmlNode node = xmlDoc.ImportNode(n, true);
  1645.                                 root.AppendChild(node);
  1646.                             }
  1647.                             return xmlDoc;
  1648.                         }
  1649.                     }
  1650.                 }
  1651.             }
  1652.             return null;
  1653.         }
  1655.         string GetSourceUri(XmlSchemaObject o) {
  1656.             while (o != null) {
  1657.                 string s = o.SourceUri;
  1658.                 if (!string.IsNullOrEmpty(s)) return s;
  1659.                 o = o.Parent;
  1660.             }
  1661.             return null;
  1662.         }
  1664.         public Uri ResolveUri(string href) {
  1665.             XmlNode n = this.Node;
  1666.             Uri baseUri = new Uri(this.XmlTreeView.Model.FileName);
  1667.             if (n != null) {
  1668.                 string uri = n.BaseURI;
  1669.                 if (!string.IsNullOrEmpty(uri))
  1670.                     baseUri = new Uri(uri);
  1671.             }
  1672.             Uri resolved = new Uri(baseUri, href);
  1673.             return resolved;
  1675.         }
  1676.     }
  1678.     public class XmlTreeNodeCollection : TreeNodeCollection, IEnumerable<XmlTreeNode> {
  1679.         XmlTreeNode parent;
  1680.         XmlNode node;
  1681.         XmlTreeView treeView;
  1682.         List<XmlTreeNode> children;
  1684.         public XmlTreeNodeCollection(XmlTreeView treeView, XmlNode parent) {
  1685.             this.node = parent;
  1686.             this.treeView = treeView;
  1687.         }
  1689.         public XmlTreeNodeCollection(XmlTreeNode parent) {
  1690.             this.treeView = parent.XmlTreeView;
  1691.             this.parent = parent;
  1692.             if (parent != null) this.children = parent.children;
  1693.             this.node = parent.Node;
  1694.         }
  1695.         
  1696.         IEnumerator<XmlTreeNode> IEnumerable<XmlTreeNode>.GetEnumerator() {
  1697.             Populate();
  1698.             return this.children.GetEnumerator();
  1699.         }
  1701.         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
  1702.             IEnumerable<XmlTreeNode> ie = (IEnumerable<XmlTreeNode>)this;
  1703.             return ie.GetEnumerator();
  1704.         }
  1706.         public override IEnumerator<TreeNode> GetEnumerator() {
  1707.             System.Collections.IEnumerable e = (System.Collections.IEnumerable)this;
  1708.             foreach (XmlTreeNode xn in e) {
  1709.                 yield return xn;
  1710.             }           
  1711.         }
  1713.         public override int Count {
  1714.             get {
  1715.                 Populate();
  1716.                 return this.children == null ? 0 : this.children.Count;
  1717.             }
  1718.         }
  1720.         public override int GetIndex(TreeNode node) {
  1721.             Populate();
  1722.             XmlTreeNode xn = ((XmlTreeNode)node);
  1723.             return this.children.IndexOf(xn);
  1724.         }
  1726.         public override void Add(TreeNode node) {
  1727.             node.Parent = this.parent;
  1728.             XmlTreeNode xn = ((XmlTreeNode)node);
  1729.             xn.XmlTreeView = this.treeView;
  1730.             Populate();
  1731.             this.children.Add(xn);
  1732.         }
  1734.         public override void Insert(int i, TreeNode node) {
  1735.             node.Parent = this.parent;
  1736.             XmlTreeNode xn = ((XmlTreeNode)node);
  1737.             xn.XmlTreeView = this.treeView;
  1738.             Populate();            
  1739.             if (i > this.children.Count) i = this.children.Count;
  1740.             this.children.Insert(i, xn);            
  1741.         }
  1743.         public override void Remove(TreeNode child) {
  1744.             if (this.children != null) {
  1745.                 XmlTreeNode xn = ((XmlTreeNode)child);            
  1746.                 if (this.children.Contains(xn)) {
  1747.                     this.children.Remove(xn);
  1748.                     return;
  1749.                 }
  1750.             }
  1751.             throw new InvalidOperationException(SR.NotAChild);
  1752.         }
  1754.         public override TreeNode this[int i] {
  1755.             get {
  1756.                 Populate();
  1757.                 return this.children[i] as TreeNode;
  1758.             }
  1759.         }
  1761.         void Populate() {
  1762.             if (this.children == null ) {
  1763.                 List<XmlTreeNode> children = new List<XmlTreeNode>();
  1764.                 if (node != null && !(node is XmlAttribute)) {
  1765.                     if (node.Attributes != null) {
  1766.                         foreach (XmlAttribute a in node.Attributes) {
  1767.                             if (a.Specified) {
  1768.                                 XmlTreeNode c = treeView.CreateTreeNode(parent, a);
  1769.                                 c.XmlTreeView = this.treeView;
  1770.                                 children.Add(c);
  1771.                             }
  1772.                         }
  1773.                     }
  1774.                     if (node.HasChildNodes) {
  1775.                         foreach (XmlNode n in node.ChildNodes) {
  1776.                             XmlTreeNode c = treeView.CreateTreeNode(parent, n);
  1777.                             c.XmlTreeView = this.treeView;
  1778.                             children.Add(c);
  1779.                         }
  1780.                     }
  1781.                 }
  1782.                 this.children = children;
  1783.                 if (parent != null) parent.children = children;
  1784.                 if (this.treeView != null) this.treeView.PerformLayout();
  1785.             }
  1786.         }
  1789.     }
  1791.     public sealed class StringHelper {
  1792.         StringHelper() { }
  1794.         public static bool IsNullOrEmpty(string s) {
  1795.             return (s == null || s.Length == 0);
  1796.         }
  1797.     }
  1799.     public class NodeChangeEventArgs : EventArgs {
  1800.         XmlTreeNode node;
  1802.         public XmlTreeNode Node {
  1803.             get { return node; }
  1804.             set { node = value; }
  1805.         }
  1807.         public NodeChangeEventArgs(XmlTreeNode node) {
  1808.             this.node = node;
  1809.         }
  1810.     }
  1812.     public class XmlTreeViewDropFeedback : TreeViewDropFeedback {
  1813.         int autoScrollCount;
  1815.         public override Point Position {
  1816.             get { return base.Position; }
  1817.             set {
  1818.                 base.Position = value;
  1819.                 CheckAutoScroll(value);
  1820.             }
  1821.         }
  1823.         void CheckAutoScroll(Point pt) {
  1824.             TreeView tv = this.TreeView;
  1825.             Point local = tv.PointToClient(pt);
  1826.             Point pos = tv.ApplyScrollOffset(local);
  1827.             XmlTreeView parent = (XmlTreeView)tv.Parent;
  1828.             int height = tv.ItemHeight;
  1829.             int halfheight = height / 2;
  1830.             TreeNode node = null;
  1831.             bool nearEnd = false;
  1832.             if (local.Y - height < tv.Top) {
  1833.                 node = tv.FindNodeAt(pos.X, pos.Y - height);
  1834.                 nearEnd = (local.Y - halfheight < tv.Top);
  1835.             } else if (local.Y + height > tv.Bottom) {
  1836.                 node = tv.FindNodeAt(pos.X, pos.Y + height);
  1837.                 nearEnd = (local.Y + halfheight > tv.Bottom);
  1838.             }
  1839.             if (node != null) {
  1840.                 if (nearEnd || autoScrollCount > 1) {
  1841.                     parent.ScrollIntoView(node);
  1842.                     autoScrollCount = 0;
  1843.                 } else {
  1844.                     autoScrollCount++;
  1845.                 }
  1846.                 ResetToggleCount();
  1847.             }
  1848.         }
  1850.     }
  1852. }