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; }
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 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); }
private IDictionary<string, object> CreateDictFromTag (Tag t) { Dictionary<string, object> result = new Dictionary<string, object> (); result.Add ("Id", t.Id); result.Add ("Name", t.Name); StringBuilder builder = new StringBuilder (); if (t is Category) { foreach (Tag child in (t as Category).Children) { if (builder.Length > 0) builder.Append (","); builder.Append (child.Name); } } result.Add ("Children", builder.ToString ()); return result; }
// FIXME: This should be removed (I think) public bool HasTag(Tag tag) { return(tags.Contains(tag)); }
// This doesn't check if the tag is already there, use with caution. public void AddTagUnsafely(Tag tag) { tags.Add(tag); changes.AddTag(tag); }
public string Upload(IBrowsableItem photo, IFilter filter, bool is_public, bool is_family, bool is_friend) { if (token == null) { throw new Exception("Must Login First"); } // FIXME flickr needs rotation string error_verbose; using (FilterRequest request = new FilterRequest(photo.DefaultVersionUri)) { try { string tags = null; filter.Convert(request); string path = request.Current.LocalPath; if (ExportTags && photo.Tags != null) { StringBuilder taglist = new StringBuilder(); FSpot.Tag [] t = photo.Tags; FSpot.Tag tag_iter = null; for (int i = 0; i < t.Length; i++) { if (i > 0) { taglist.Append(","); } taglist.Append(String.Format("\"{0}\"", t[i].Name)); // Go through the tag parents if (ExportTagHierarchy) { tag_iter = t[i].Category; while (tag_iter != Core.Database.Tags.RootCategory && tag_iter != null) { // Skip top level tags because they have no meaning in a linear tag database if (ExportIgnoreTopLevel && tag_iter.Category == Core.Database.Tags.RootCategory) { break; } // FIXME Look if the tag is already there! taglist.Append(","); taglist.Append(String.Format("\"{0}\"", tag_iter.Name)); tag_iter = tag_iter.Category; } } } tags = taglist.ToString(); } try { string photoid = flickr.UploadPicture(path, photo.Name, photo.Description, tags, is_public, is_family, is_friend); return(photoid); } catch (FlickrNet.FlickrException ex) { Console.WriteLine("Problems uploading picture: " + ex.ToString()); error_verbose = ex.ToString(); } } catch (Exception e) { // FIXME we need to distinguish between file IO errors and xml errors here throw new System.Exception("Error while uploading", e); } } throw new System.Exception(error_verbose); }
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 HandleTagMenuSelected(Tag t) { selected_tags = new Tag [] { t }; }
public bool TagIncluded(Tag tag) { return logic_widget.TagIncluded (tag); }
private bool RemoveTag (Tag t) { if (t == null) return false; try { // remove tags from photos first Core.Database.Photos.Remove (new Tag [] { t }); // then remove tag tag_store.Remove (t); return true; } catch { return false; } }
public bool TagRequired(Tag tag) { return logic_widget.TagRequired (tag); }
void HandleTagSelected(Tag t) { tag_button.Label = t.Name; Preferences.Set (SCREENSAVER_TAG, (int) t.Id); }
public void UnInclude(Tag [] tags) { logic_widget.UnInclude (tags); }
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; }
public void UnRequire(Tag [] tags) { logic_widget.UnRequire (tags); }
// AND this tag with all terms public void Require(Tag [] tags) { // TODO it would be awesome if this was done by putting parentheses around // OR terms and ANDing the result with this term (eg factored out) // Trim out tags that are already required ArrayList new_tags = new ArrayList(tags.Length); foreach (Tag tag in tags) { if (! rootTerm.TagRequired (tag)) new_tags.Add (tag); } if (new_tags.Count == 0) return; tags = (Tag []) new_tags.ToArray (typeof (Tag)); bool added = false; preventUpdate = true; foreach (Term parent in rootTerm.LiteralParents ()) { // TODO logic could be broken if a term's SubTerms are a mixture // of Literals and non-Literals InsertTerm (tags, parent, parent.Last as Literal); added = true; } // If there were no LiteralParents to add this tag to, then add it to the rootTerm // TODO should add the first tag in the array, // then add the others to the first's parent (so they will be ANDed together) if (!added) InsertTerm (tags, rootTerm, null); preventUpdate = false; UpdateQuery (); }
private void HandleTagMenuSelected (Tag t) { selected_tags = new Tag [] { t }; }
public bool TagRequired(Tag tag) { return rootTerm.TagRequired (tag); }
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); }
public void UnRequire(Tag [] tags) { // Trim out tags that are not required ArrayList new_tags = new ArrayList(tags.Length); foreach (Tag tag in tags) { if (rootTerm.TagRequired (tag)) new_tags.Add (tag); } if (new_tags.Count == 0) return; tags = (Tag []) new_tags.ToArray (typeof (Tag)); preventUpdate = true; foreach (Term parent in rootTerm.LiteralParents ()) { // Don't remove if this tag is the only child of a term if (parent.Count > 1) { foreach (Tag tag in tags) { ((parent.FindByTag (tag))[0] as Literal).RemoveSelf (); } } } preventUpdate = false; UpdateQuery (); }
void HandleQueryTagSelected(Tag tag) { options.QueryTag = tag; tag_button.Label = tag.Name; tag_button.Image = tag.Icon != null ? new Gtk.Image (PixbufUtils.ScaleDown (tag.Icon, 16, 16)) : null; }
private void HandleTagsAdded(Tag[] tags, Term parent, Literal after) { InsertTerm (tags, parent, after); }
private void AddTagNameToList (List<string> list, Tag tag) { if (tag != tag_store.RootCategory) list.Add (tag.Name); if (tag is Category) { foreach (Tag child in (tag as Category).Children) AddTagNameToList (list, child); } }
private static bool AppendTerm(ArrayList parts, Term term, Tag single_tag) { bool tag_matches = false; if (term != null) { Literal literal = term as Literal; if (literal != null) { if (literal.Tag == single_tag) tag_matches = true; if (literal.IsNegated) parts.Add (String.Format (Catalog.GetString ("Not {0}"), literal.Tag.Name)); else parts.Add (literal.Tag.Name); } else { foreach (Term subterm in term.SubTerms) { tag_matches |= AppendTerm (parts, subterm, single_tag); } } } return tag_matches; }
private void AddTagIdToList (List<uint> list, Tag tag) { if (tag != tag_store.RootCategory) list.Add (tag.Id); if (tag is Category) { foreach (Tag child in (tag as Category).Children) AddTagIdToList (list, child); } }