public void StructureChanged_event_should_bubble_up()
        {
            var flag = false;
            decorator.StructureChanged += (s, e) => { flag = true; };
            var eventArgs = new TreeModelEventArgs(new TreePath(), new object[0]);

            treeModel.Raise(tm => tm.StructureChanged += null, null, eventArgs);

            Assert.IsTrue(flag);
        }

 void model_NodesInserted(object sender, TreeModelEventArgs e)
 {
     insert++;
 }

 internal void OnNodeRemoved(Node parent, int index, Node node)
 {
     if (NodesRemoved != null)
     {
         TreeModelEventArgs args = new TreeModelEventArgs(GetPath(parent), new int[] { index }, new object[] { node });
         NodesRemoved(this, args);
     }
 }

		internal protected virtual void OnNodesChanged(Node parent, int index, Node node)
		{
			if (NodesChanged != null)
			{
				TreePath path = GetPath(parent);
				if (path == null) return;
				TreeModelEventArgs args = new TreeModelEventArgs(path, new int[] { index }, new object[] { node });
				NodesChanged(this, args);
			}
		}

        private void NotifyNodesChanged()
        {
            if (!_notify)
                return;

            var model = FindModel();
            if (model != null)
            {
                TreePath path = model.GetPath(this);
                if (path != null)
                {
                    var args = new TreeModelEventArgs(path, new object[] { this });
                    model.RaiseNodesChanged(args);
                }
            }
        }

 public void OnNodeRemoved(TreeModelEventArgs args)
 {
     if (NodesRemoved != null)
     NodesRemoved(this, args);
 }

 private void ClearNodesSize(TreeModelEventArgs e, TreeNodeAdv parent)
 {
     if (e.Indices != null)
        {
     foreach (int index in e.Indices)
     {
      if (index >= 0 && index < parent.Nodes.Count)
      {
       TreeNodeAdv node = parent.Nodes[index];
       node.Height = node.RightBounds = null;
      }
      else
       throw new ArgumentOutOfRangeException("Index out of range");
     }
        }
        else
        {
     foreach (TreeNodeAdv node in parent.Nodes)
     {
      foreach (object obj in e.Children)
       if (node.Tag == obj)
       {
        node.Height = node.RightBounds = null;
       }
     }
        }
 }

        private void _model_NodesInserted(object sender, TreeModelEventArgs e)
        {
            if (e.Indices == null)
            throw new ArgumentNullException("Indices");

               TreeNodeAdv parent = FindNode(e.Path);
               if (parent != null)
               {
            for (int i = 0; i < e.Children.Length; i++)
             AddNewNode(parent, e.Children[i], e.Indices[i]);
               }
               SmartFullUpdate();
        }

 private void TreeNodesRemoved(object sender, TreeModelEventArgs e)
 {
     OnNodesRemoved(e);
 }

 private void TreeNodesInserted(object sender, TreeModelEventArgs e)
 {
     OnNodesInserted(e);
 }

 /// <summary>
 /// Nodes have been removed.  Remove the event handlers
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 void mTreeModel_NodesRemoved(object sender, TreeModelEventArgs e)
 {
     foreach (Node node in e.Children)
     {
         SetHandlers(node, false);
     }
 }

 /// <summary>
 /// Called when new nodes were inserted into the tree model.
 /// We need to set the nodes' event handlers accordingly.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 void mTreeModel_NodesInserted(object sender, TreeModelEventArgs e)
 {
     foreach (Node node in e.Children)
     {
         SetHandlers(node, true);
     }
 }

 protected void OnNodesRemoved(TreeModelEventArgs args)
 {
     if (NodesRemoved != null)
         NodesRemoved(this, args);
 }

 internal void RaiseNodesChanged(TreeModelEventArgs args)
 {
     base.OnNodesChanged(args);
 }

 void model_NodesRemoved(object sender, TreeModelEventArgs e)
 {
     remove++;
 }

        void _treeModel_NodesChanged(object sender, TreeModelEventArgs e)
        {
            if (this.InvokeRequired)
            {
                TreeModelEventDelegate del = new TreeModelEventDelegate(
                    _treeModel_NodesChanged);
                this.Invoke(del, new object[] { sender, e });

                return;
            }

            //authPanel.ValidateChildren();
            _workArea.Invalidate(true);
        }

 private void _model_NodesChanged(object sender, TreeModelEventArgs e)
 {
     TreeNodeAdv parent = FindNode(e.Path);
        if (parent != null && parent.IsVisible && parent.IsExpanded)
        {
     if (InvokeRequired)
      Invoke(new UpdateContentWidthDelegate(ClearNodesSize), e, parent);
     else
      ClearNodesSize(e, parent);
     SmartFullUpdate();
        }
 }

 void _innerModel_NodesRemoved(object sender, TreeModelEventArgs e)
 {
     OnStructureChanged(new TreePathEventArgs(e.Path));
 }

        private void _model_NodesRemoved(object sender, TreeModelEventArgs e)
        {
            TreeNodeAdv parent = FindNode(e.Path);
               if (parent != null)
               {
            if (e.Indices != null)
            {
             List<int> list = new List<int>(e.Indices);
             list.Sort();
             for (int n = list.Count - 1; n >= 0; n--)
             {
              int index = list[n];
              if (index >= 0 && index <= parent.Nodes.Count)
               parent.Nodes.RemoveAt(index);
              else
               throw new ArgumentOutOfRangeException("Index out of range");
             }
            }
            else
            {
             for (int i = parent.Nodes.Count - 1; i >= 0; i--)
             {
              for (int n = 0; n < e.Children.Length; n++)
               if (parent.Nodes[i].Tag == e.Children[n])
               {
            parent.Nodes.RemoveAt(i);
            break;
               }
             }
            }
               }

               UpdateSelection();
               SmartFullUpdate();
        }

 private void _model_NodesChanged(object sender, TreeModelEventArgs e)
 {
     TreeNodeAdv parent = FindNode(e.Path);
     if (parent != null)
     {
         if (e.Indices != null)
         {
             foreach (int index in e.Indices)
             {
                 if (index >= 0 && index < parent.Nodes.Count)
                 {
                     TreeNodeAdv node = parent.Nodes[index];
                     Rectangle rect = GetNodeBounds(node);
                     _contentWidth = Math.Max(_contentWidth, rect.Right);
                 }
                 else
                     throw new ArgumentOutOfRangeException("Index out of range");
             }
         }
         else
         {
             foreach (TreeNodeAdv node in parent.Nodes)
             {
                 foreach (object obj in e.Children)
                     if (node.Tag == obj)
                     {
                         Rectangle rect = GetNodeBounds(node);
                         _contentWidth = Math.Max(_contentWidth, rect.Right);
                     }
             }
         }
     }
     _rowLayout.ClearCache();
     SafeUpdateScrollBars();
     UpdateView();
 }