public void RemoveTag (Tag t)
		{
			if (tags_removed == null)
				tags_removed = new List<Tag> ();
			if (tags_added != null)
				tags_added.Remove (t);
			tags_removed.Add (t);
		}

 void PopulatePeopleCategories(TreeStore treeStore ,Tag parent,TreeIter parentIter,int level)
 {
     foreach (Tag tag in (parent as Category).Children) {
         if (tag is Category) {
             //Log.Debug("Append  : "+tag.Name + " to "+parent.Name);
             TreeIter iter =
                 (parentIter.Equals(TreeIter.Zero) ?
                 treeStore.AppendValues(tag.Name,/*parent,*/tag):
                     treeStore.AppendValues(parentIter,tag.Name,/*parent,*/tag)) ;
             PopulatePeopleCategories (treeStore,tag,iter,level+1);
         }
     }
 }

		public static void Create (Tag [] tags, Gtk.Menu menu)
		{
			Gtk.MenuItem item = new Gtk.MenuItem (String.Format (Catalog.GetPluralString ("Find _With", "Find _With", tags.Length), tags.Length));

			Gtk.Menu submenu = GetSubmenu (tags);
			if (submenu == null)
				item.Sensitive = false;
			else
				item.Submenu = submenu;

			menu.Append (item);
			item.Show ();
		}

        public static Tag[] GetTagsData(this SelectionData selection_data)
        {
            int size = sizeof (uint);
            int length = selection_data.Length / size;

            TagStore tag_store = MainWindow.Toplevel.Database.Tags;

            Tag [] tags = new Tag [length];

            for (int i = 0; i < length; i ++) {
                uint id = System.BitConverter.ToUInt32 (selection_data.Data, i * size);
                tags[i] = tag_store.Get (id);
            }

            return tags;
        }

        public Face(uint id,uint leftX,uint topY,uint width,Photo photo,
		             Tag tag,bool tagConfirmed, bool autoDetected, bool autoRecognized, Pixbuf icon,long unix_time)
            : base(id)
        {
            this.leftX = leftX;
            this.topY = topY;
            this.width = width;
            this.photo = photo;
            this.tag = tag;
            this.tagConfirmed = tagConfirmed;
            this.autoDetected = autoDetected;
            this.autoRecognized = autoRecognized;
            this.iconPixbuf = icon;
            this.unix_time = unix_time;
            //FIXME Possible Error HERE
            photo_md5 = photo.MD5Sum;
        }

        public static Gtk.Menu GetSubmenu(Tag [] tags)
        {
            Tag single_tag = null;
            if (tags != null && tags.Length == 1)
                single_tag = tags[0];

            //Console.WriteLine ("creating find with menu item");
            if (LogicWidget.Root == null || LogicWidget.Root.SubTerms.Count == 0) {
                //Console.WriteLine ("root is null or has no terms");
                return null;
            } else {
                //Console.WriteLine ("root is not null and has terms");
                Gtk.Menu m = new Gtk.Menu ();

                Gtk.MenuItem all_item = GtkUtil.MakeMenuItem (m, Catalog.GetString ("All"), new EventHandler (MainWindow.Toplevel.HandleRequireTag));
                GtkUtil.MakeMenuSeparator (m);

                int sensitive_items = 0;
                foreach (Term term in LogicWidget.Root.SubTerms) {
                    ArrayList term_parts = new ArrayList ();

                    bool contains_tag = AppendTerm (term_parts, term, single_tag);

                    string name = "_" + String.Join (", ", (string []) term_parts.ToArray (typeof(string)));

                    Gtk.MenuItem item = GtkUtil.MakeMenuItem (m, name, new EventHandler (MainWindow.Toplevel.HandleAddTagToTerm));
                    item.Sensitive = !contains_tag;

                    if (!contains_tag)
                        sensitive_items++;
                }

                if (sensitive_items == 0)
                    all_item.Sensitive = false;

                return m;
            }
        }

 private void HandleAttachTag(Tag tag, Term parent, Literal after)
 {
     InsertTerm (new Tag [] {tag}, parent, after);
 }

        public void UnInclude(Tag [] tags)
        {
            ArrayList new_tags = new ArrayList(tags.Length);
            foreach (Tag tag in tags) {
                if (rootTerm.TagIncluded (tag))
                    new_tags.Add (tag);
            }

            if (new_tags.Count == 0)
                return;

            tags = (Tag []) new_tags.ToArray (typeof (Tag));

            bool needsUpdate = false;
            preventUpdate = true;
            foreach (Term parent in rootTerm.LiteralParents ()) {
                if (parent.Count == 1) {
                    foreach (Tag tag in tags) {
                        if ((parent.Last as Literal).Tag == tag) {
                            (parent.Last as Literal).RemoveSelf ();
                            needsUpdate = true;
                            break;
                        }
                    }
                }
            }
            preventUpdate = false;

            if (needsUpdate)
                UpdateQuery ();
        }

 public bool TagIncluded(Tag tag)
 {
     return rootTerm.TagIncluded (tag);
 }

        /** Helper Functions **/
        public void PhotoTagsChanged(Tag [] tags)
        {
            bool refresh_required = false;

            foreach (Tag tag in tags) {
                if ((rootTerm.FindByTag (tag)).Count > 0) {
                    refresh_required = true;
                    break;
                }
            }

            if (refresh_required)
                UpdateQuery ();
        }

        // Add a tag or group of tags to the rootTerm, at the end of the Box
        public void Include(Tag [] tags)
        {
            // Filter out any tags that are already included
            ArrayList new_tags = new ArrayList(tags.Length);
            foreach (Tag tag in tags) {
                if (! rootTerm.TagIncluded (tag))
                    new_tags.Add (tag);

            }

            if (new_tags.Count == 0)
                return;

            tags = (Tag []) new_tags.ToArray (typeof (Tag));

            InsertTerm (tags, rootTerm, null);
        }

 public void UnRequire(Tag [] tags)
 {
     logic_widget.UnRequire (tags);
 }

 public void UnInclude(Tag [] tags)
 {
     logic_widget.UnInclude (tags);
 }

 public bool TagRequired(Tag tag)
 {
     return logic_widget.TagRequired (tag);
 }

 public bool TagIncluded(Tag tag)
 {
     return logic_widget.TagIncluded (tag);
 }

        public static void SetTagsData(this SelectionData selection_data, Tag [] tags, Atom target)
        {
            byte [] data = new byte [tags.Length * sizeof (uint)];

            int i = 0;
            foreach (Tag tag in tags) {
                byte [] bytes = System.BitConverter.GetBytes (tag.Id);

                foreach (byte b in bytes) {
                    data[i] = b;
                    i++;
                }
            }

            selection_data.Set (target, 8, data, data.Length);
        }

 void HandleTagSelected(Tag t)
 {
     tag_button.Label = t.Name;
     Preferences.Set (SCREENSAVER_TAG, (int) t.Id);
 }

		private void HandleTagMenuSelected (Tag t) 
		{
			selected_tags = new Tag [] { t };
		}

        public ArrayList InsertTerm(Tag [] tags, Term parent, Literal after)
        {
            int position;
            if (after != null)
                position = WidgetPosition (after.Widget) + 1;
            else
                position = Children.Length - 1;

            ArrayList added = new ArrayList ();

            foreach (Tag tag in tags) {
                //Console.WriteLine ("Adding tag {0}", tag.Name);

                // Don't put a tag into a Term twice
                if (parent != Root && (parent.FindByTag (tag, true)).Count > 0)
                    continue;

                if (parent.Count > 0) {
                    Widget sep = parent.SeparatorWidget ();

                    InsertWidget (position, sep);
                    position++;
                }

                // Encapsulate new OR terms within a new AND term of which they are the
                // only member, so later other terms can be AND'd with them
                //
                // TODO should really see what type of term the parent is, and
                // encapsulate this term in a term of the opposite type. This will
                // allow the query system to be expanded to work for multiple levels much easier.
                if (parent == rootTerm) {
                    parent = new AndTerm (rootTerm, after);
                    after = null;
                }

                Literal term  = new Literal (parent, tag, after);
                term.TagsAdded  += HandleTagsAdded;
                term.LiteralsMoved += HandleLiteralsMoved;
                term.AttachTag  += HandleAttachTag;
                term.NegatedToggled += HandleNegated;
                term.Removing  += HandleRemoving;
                term.Removed  += HandleRemoved;
                term.RequireTag  += Require;
                term.UnRequireTag += UnRequire;

                added.Add (term);

                // Insert this widget into the appropriate place in the hbox
                InsertWidget (position, term.Widget);
            }

            UpdateQuery ();

            return added;
        }

		void MergeTags (Tag tag_to_merge)
		{
			TagStore from_store = from_db.Tags;
			TagStore to_store = to_db.Tags;

			if (tag_to_merge != from_store.RootCategory) { //Do not merge RootCategory
				Tag dest_tag = to_store.GetTagByName (tag_to_merge.Name);
				if (dest_tag == null) {
					Category parent = (tag_to_merge.Category == from_store.RootCategory) ?
							to_store.RootCategory :
							to_store.GetTagByName (tag_to_merge.Category.Name) as Category;
					dest_tag = to_store.CreateTag (parent, tag_to_merge.Name);
					//FIXME: copy the tag icon and commit
				}
				tag_map [tag_to_merge.Id] = dest_tag;
			}

			if (!(tag_to_merge is Category))
				return;

			foreach (Tag t in (tag_to_merge as Category).Children)
				MergeTags (t);
		}