/** Handlers **/

        // When the user edits a tag (it's icon, name, etc) we get called
        // and update the images/text in the query as needed to reflect the changes.
        private void HandleTagChanged(object sender, DbItemEventArgs args)
        {
            foreach (DbItem item in args.Items)
            {
                foreach (Literal term in rootTerm.FindByTag(item as Tag))
                {
                    term.Update();
                }
            }
        }
Exemple #2
0
        /** Handlers **/

        // When the user edits a tag (it's icon, name, etc) we get called
        // and update the images/text in the query as needed to reflect the changes.
        void HandleTagChanged(object sender, DbItemEventArgs <Tag> args)
        {
            foreach (Tag t in args.Items)
            {
                foreach (Literal term in rootTerm.FindByTag(t))
                {
                    term.Update();
                }
            }
        }
Exemple #3
0
        public List<Literal> InsertTerm(Tag [] tags, Term parent, Literal after)
        {
            int position;
            if (after != null)
                position = WidgetPosition (after.Widget) + 1;
            else
                position = Children.Length - 1;

            var added = new List<Literal>();

            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;
        }
Exemple #4
0
        public List <Literal> InsertTerm(Tag [] tags, Term parent, Literal after)
        {
            int position;

            if (after != null)
            {
                position = WidgetPosition(after.Widget) + 1;
            }
            else
            {
                position = Children.Length - 1;
            }

            var added = new List <Literal>();

            foreach (var 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 == Root)
                {
                    parent = new AndTerm(Root, after);
                    after  = null;
                }

                var 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);
        }