public bool DragDataDelete(TreePath path)
 {
     TreeIter iter;
     this.GetIter(out iter, path);
     //this.Remove(ref iter);
     return true;
 }

        /// <summary>
        /// Fill a list of events from a list of paths, if the first and unique path is an EventType the list
        /// is filled with al the child events in this EventType category.
        /// </summary>
        /// <param name = "model">Model.</param>
        /// <param name="events">Events.</param>
        /// <param name="paths">Paths.</param>
        public static List<TimelineEventLongoMatch> EventsListFromPaths(TreeModel model, TreePath[] paths)
        {
            List<TimelineEventLongoMatch> events = new List<TimelineEventLongoMatch> ();

            // If it's an EventType or a Player, traverse all children to fill the list
            if (paths.Length == 1 && !(model.GetValue (paths [0]) is TimelineEventLongoMatch)) {
                TreeIter parentIter;
                TreeIter child;
                bool hasChild;

                model.GetIter (out parentIter, paths [0]);
                hasChild = model.IterHasChild (parentIter);
                model.IterChildren (out child, parentIter);
                while (hasChild) {
                    TimelineEventLongoMatch evt = model.GetValue (child, 0) as TimelineEventLongoMatch;
                    if (evt != null) {
                        events.Add (evt);
                    }
                    hasChild = model.IterNext (ref child);
                }
            } else {
                foreach (var path in paths) {
                    TimelineEventLongoMatch evt = model.GetValue (path) as TimelineEventLongoMatch;
                    if (evt != null) {
                        events.Add (evt);
                    }
                }
            }
            return events;
        }

		void HandleRowsReordered (object sender, ListRowOrderEventArgs e)
		{
			var p = new Gtk.TreePath (new int[] { e.Row });
			var it = IterFromNode (e.Row);
			adapter.EmitRowsReordered (p, it, e.ChildrenOrder);
			parent.QueueResize ();
		}

	/// <summary>Base constructor for classes that inherit <see cref="MultipleSelectionCommand" />.</summary>
	/// <param name="description">The description of the command.</param>
	/// <param name="canGroup">Whether to possibly group the command with the previous command.</param>
	/// <param name="selectionIntended">The intended selection.</param>
	/// <param name="paths">The paths to select, or null to use auto selection if setPaths is enabled.</param>
	/// <param name="setPaths">Whether to set the paths based on the current selection and the selectionType</param>
	public MultipleSelectionCommand (string description, bool canGroup, SelectionIntended selectionIntended, TreePath[] paths, bool setPaths) : base(description, canGroup) {
		if (setPaths) {
			switch (selectionIntended) {
				case SelectionIntended.Simple:
					this.paths = (paths != null ? paths : Base.Ui.View.Selection.Paths);
					this.focus = Base.Ui.View.Selection.Focus;
					break;
				case SelectionIntended.Range:
					this.paths = (paths != null ? paths : Base.Ui.View.Selection.Range);
					this.focus = Base.Ui.View.Selection.Focus;
					break;
				case SelectionIntended.SimpleToFirst:
					this.paths = (paths != null ? paths : Base.Ui.View.Selection.PathsToFirst);
					this.focus = Base.Ui.View.Selection.Focus;
					break;
				case SelectionIntended.SimpleToLast:
					this.paths = (paths != null ? paths : Base.Ui.View.Selection.PathsToLast);
					this.focus = Base.Ui.View.Selection.Focus;
					break;
				default:
					if (paths != null)
						this.paths = paths;

					break;
			}
		}

		this.selectionType = GetSelectionType(selectionIntended);
	}

		void HandleRowInserted (object sender, ListRowEventArgs e)
		{
			var p = new Gtk.TreePath (new int[] { e.Row });
			var it = IterFromNode (e.Row);
			adapter.EmitRowInserted (p, it);
			parent.QueueResize ();
		}

		public void InitCell (Widget container, bool diffMode, string[] lines, TreePath path)
		{
			if (isDisposed)
				return;
			this.lines = lines;
			this.diffMode = diffMode;
			this.path = path;
			
			if (diffMode) {
				if (lines != null && lines.Length > 0) {
					int maxlen = -1;
					int maxlin = -1;
					for (int n=0; n<lines.Length; n++) {
						if (lines [n].Length > maxlen) {
							maxlen = lines [n].Length;
							maxlin = n;
						}
					}
					DisposeLayout ();
					layout = CreateLayout (container, lines [maxlin]);
					layout.GetPixelSize (out width, out lineHeight);
					height = lineHeight * lines.Length;
				}
				else
					width = height = 0;
			}
			else {
				DisposeLayout ();
				layout = CreateLayout (container, string.Join (Environment.NewLine, lines));
				layout.GetPixelSize (out width, out height);
			}
		}

        // the treeview is selected
        private bool tree_select(TreeSelection selection, TreeModel model, TreePath path, bool selected)
        {
            if (this != Global.Core.Library.DynamicTree)
                Global.Core.Library.DynamicTree.Selection.UnselectAll ();

            if (this != Global.Core.Library.FolderTree)
                Global.Core.Library.FolderTree.Selection.UnselectAll ();

            if (this != Global.Core.Library.PlaylistTree)
                Global.Core.Library.PlaylistTree.Selection.UnselectAll ();

            //if it isnt already selected
            if (!selected)
            {
                Global.Core.TopBar.SelectedTree = this;
                Global.Core.Library.MediaTree.SetFilter (FilterMedia);
                Global.Core.Library.MediaTree.Refilter ();

                //raise the event
                if (TreeSelected != null)
                {
                    TreeIter iter;
                    if (model.GetIter (out iter, path))
                        TreeSelected (model, iter);
                }
            }

            return true;
        }

 public new bool DragDataReceived(TreePath path, SelectionData data)
 {
     logger.Debug("DragDataReceived dstPath={0}", path);
     TreeModel srcModel;
     TreePath srcPath;
     TreeIter srcIter, dstIter, newIter, ParentIter;
     if(Tree.GetRowDragData(data, out srcModel, out srcPath))
     {
         logger.Debug("DragDataReceived srcPath={0}", srcPath);
         bool Last = false;
         if(!this.GetIter(out dstIter, path))
         {
             path.Prev();
             Last = true;
             this.GetIter(out dstIter, path);
         }
         this.GetIter(out srcIter, srcPath);
         this.IterParent(out ParentIter, dstIter);
         if(Last)
             newIter = this.InsertNodeAfter(ParentIter, dstIter);
         else
             newIter = this.InsertNodeBefore(ParentIter, dstIter);
         CopyValues(srcIter, newIter);
         return true;
     }
     return false;
 }

 public TreeIter GetIter(TreeView view, TreePath path)
 {
     TreeIter iter;
     if(!GetIter(out iter, path))
         throw new InvalidOperationException("Cesta ve stromu není platná");
     return iter;
 }

 public void removeImages(TreePath[] treePaths)
 {
     foreach(TreePath treePath in treePaths)
     {
         this.imagesModel.GetIter(out this.iter, treePath);
         this.imagesModel.Remove(ref this.iter);
     }
 }

	public void Remove (TreePath[] paths) {
		foreach (TreePath path in paths) {
			TreeIter iter;
			model.GetIter(out iter, path);
			model.Remove(ref iter);

			collection.Remove(Util.PathToInt(path));
		}
	}

	public Tag TagByPath (TreePath path) 
	{
		TreeIter iter;

		if (!Model.GetIter (out iter, path))
			return null;

		return TagByIter (iter);
	}

        public RadioTrackInfo GetRadioTrackInfo(TreePath path)
        {
            TreeIter iter;

            if(GetIter(out iter, path)) {
                return GetRadioTrackInfo(iter);
            }

            return null;
        }

		public TreePathReference (TreeModel model, TreePath path)
		{
			model.RowsReordered += HandleRowsReordered;
			model.RowInserted += HandleRowInserted;
			model.RowDeleted += HandleRowDeleted;

			indices = path.Indices;
			this.path = path;
			Model = model;
		}

        public string GetDN(TreePath path)
        {
            TreeIter iter;

            if (this.dataStore.GetIter (out iter, path)) {
                string dn = (string) this.dataStore.GetValue (iter, dnColumn);
                return dn;
            }

            return null;
        }

        public PodcastFeedInfo PathPodcastFeedInfo(TreePath path)
        {
            TreeIter iter;

            if(!GetIter (out iter, path))
            {
                return null;
            }

            return IterPodcastFeedInfo (iter);
        }

        void log_syscall_modified_cb(int num)
        {
            TreePath path;
            TreeIter iter;

            path = new TreePath (new int[] { num });

            if (!GetIter (out iter, path))
                Debug.Assert (false, "Get an iter in the list model to modify it");

            SetValue (iter, 0, 0);
        }

        public CopyCellMenuItem(TreePath[] selectedRows, string label, Func<TreePath, string> getValue)
            : base(label)
        {
            if (selectedRows.Length == 0) {
                throw new IndexOutOfRangeException ("Missing selected resource rows");
            }

            SelectedRows = selectedRows;
            GetValueFromRow = getValue;

            ButtonReleaseEvent += (o, e) => OnCopy ();
        }

 public bool HistoryItemSelected(TreeSelection selection, TreeModel model, TreePath path, bool path_currently_selected)
 {
     int current = path.Indices[0];
     if (!path_currently_selected) {
         while (PintaCore.History.Pointer < current) {
             PintaCore.History.Redo ();
         }
         while (PintaCore.History.Pointer > current) {
             PintaCore.History.Undo ();
         }
     }
     return true;
 }

        public void LoadProject(Project project, ProjectStats stats)
        {
            TreePath path;

            store.Clear();
            pstats = stats;
            categoriesviewer.LoadStats (pstats, project);
            AddTeam (project.LocalTeamTemplate, project.Dashboard);
            AddTeam (project.VisitorTeamTemplate, project.Dashboard);
            path = new TreePath ("0:0");
            treeview1.ExpandAll ();
            treeview1.SetCursor (path, null, false);
        }