protected override bool OnDragDrop(Gdk.DragContext context, int x, int y, uint time)
        {
            ActionPaletteItem dropped = DND.Drop(context, null, time) as ActionPaletteItem;

            if (dropped == null)
            {
                return(false);
            }

            if (dropped.Node.Type != Gtk.UIManagerItemType.Menuitem &&
                dropped.Node.Type != Gtk.UIManagerItemType.Menu &&
                dropped.Node.Type != Gtk.UIManagerItemType.Toolitem &&
                dropped.Node.Type != Gtk.UIManagerItemType.Separator)
            {
                return(false);
            }

            ActionTreeNode newNode = null;

            // Toolitems are copied, not moved

            using (wrapper.UndoManager.AtomicChange)
            {
                if (dropped.Node.ParentNode != null && dropped.Node.Type != Gtk.UIManagerItemType.Toolitem)
                {
                    if (dropIndex < nodes.Count)
                    {
                        // Do nothing if trying to drop the node over the same node
                        ActionTreeNode dropNode = nodes [dropIndex];
                        if (dropNode == dropped.Node)
                        {
                            return(false);
                        }

                        dropped.Node.ParentNode.Children.Remove(dropped.Node);

                        // The drop position may have changed after removing the dropped node,
                        // so get it again.
                        dropIndex = nodes.IndexOf(dropNode);
                        nodes.Insert(dropIndex, dropped.Node);
                    }
                    else
                    {
                        dropped.Node.ParentNode.Children.Remove(dropped.Node);
                        nodes.Add(dropped.Node);
                        dropIndex = nodes.Count - 1;
                    }
                }
                else
                {
                    newNode = new ActionTreeNode(Gtk.UIManagerItemType.Menuitem, null, dropped.Node.Action);
                    nodes.Insert(dropIndex, newNode);
                }
                // Select the dropped node
                ActionMenuItem mi = (ActionMenuItem)menuItems [dropIndex];
                mi.Select();
            }

            return(base.OnDragDrop(context, x, y, time));
        }
Пример #2
0
    void Awake()
    {
        dragNDropUse = target as DragNDropUseInnerDrops;
        //dnd = new DND();

        dnd = dragNDropUse.dragNDrop;
    }
Пример #3
0
        public override void Wrap(object obj, bool initialized)
        {
            base.Wrap(obj, initialized);

            DND.DestSet(gtkfixed, true);
            gtkfixed.DragDrop         += FixedDragDrop;
            gtkfixed.DragDataReceived += FixedDragDataReceived;
        }
Пример #4
0
        void DragEnd(object obj, Gtk.DragEndArgs args)
        {
            Gtk.Invisible invis = obj as Gtk.Invisible;
            invis.DragEnd -= DragEnd;
            invis.Destroy();

            if (DND.DragWidget != null)
            {
                ToolItemize(DND.Cancel(), dragIndex);
            }
            dragIndex = -1;
        }
Пример #5
0
        void FixedDragDrop(object obj, Gtk.DragDropArgs args)
        {
            Gtk.Widget w  = DND.Drop(args.Context, gtkfixed, args.Time);
            Widget     ww = Widget.Lookup(w);

            if (ww != null)
            {
                gtkfixed.Put(w, args.X - DND.DragHotX, args.Y - DND.DragHotY);
                NotifyChildAdded(w);
                args.RetVal = true;
                ww.Select();
            }
        }
Пример #6
0
 public ActionItem(ActionTreeNode node, IMenuItemContainer parent, uint itemSpacing)
 {
     DND.SourceSet(this);
     this.parentMenu    = parent;
     this.node          = node;
     this.VisibleWindow = false;
     this.CanFocus      = true;
     this.Events       |= Gdk.EventMask.KeyPressMask;
     this.itemSpacing   = itemSpacing;
     if (node.Action != null)
     {
         node.Action.ObjectChanged += OnActionChanged;
     }
 }
Пример #7
0
        public virtual void ProcessDragBegin(Gdk.DragContext ctx, Gdk.EventMotion evt)
        {
            editOnRelease = false;
            ActionPaletteItem item = new ActionPaletteItem(node);

            if (ctx != null)
            {
                DND.Drag(parentMenu.Widget, ctx, item);
            }
            else
            {
                DND.Drag(parentMenu.Widget, evt, item);
            }
        }
Пример #8
0
 public override void Wrap(object obj, bool initialized)
 {
     base.Wrap(obj, initialized);
     if (!initialized && AllowPlaceholders)
     {
         Placeholder ph = CreatePlaceholder();
         box.PackStart(ph);
         NotifyChildAdded(ph);
         ph = CreatePlaceholder();
         box.PackStart(ph);
         NotifyChildAdded(ph);
         box.Spacing = 6;
     }
     box.SizeAllocated   += box_SizeAllocated;
     ContainerOrientation = obj is Gtk.HBox ? Gtk.Orientation.Horizontal : Gtk.Orientation.Vertical;
     DND.ClearFaults(this);
 }
        internal ActionMenu(Widget wrapper, IMenuItemContainer parentMenu, ActionTreeNode node)
        {
            DND.DestSet(this, true);
            parentNode          = node;
            this.parentMenu     = parentMenu;
            this.wrapper        = wrapper;
            this.nodes          = node.Children;
            table               = new Gtk.Table(0, 0, false);
            table.ColumnSpacing = 5;
            table.RowSpacing    = 5;
            table.BorderWidth   = 5;
            this.AppPaintable   = true;

            Add(table);

            Fill();

            parentNode.ChildNodeAdded   += OnChildAdded;
            parentNode.ChildNodeRemoved += OnChildRemoved;
        }
Пример #10
0
        protected override void DoSync()
        {
            DND.ClearFaults(this);
            Gtk.Orientation faultOrientation =
                Orientation == Gtk.Orientation.Horizontal ? Gtk.Orientation.Vertical : Gtk.Orientation.Horizontal;
            Gdk.Rectangle tbAlloc = toolbar.Allocation;

            Gtk.Widget[] children = toolbar.Children;
            if (children.Length == 0)
            {
                DND.AddFault(this, 0, faultOrientation, tbAlloc);
                return;
            }

            if (faultOrientation == Gtk.Orientation.Horizontal)
            {
                DND.AddHFault(this, 0, null, children[0]);
                DND.AddHFault(this, children.Length, children[children.Length - 1], null);
            }
            else
            {
                DND.AddVFault(this, 0, null, children[0]);
                DND.AddVFault(this, children.Length, children[children.Length - 1], null);
            }

            for (int i = 1; i < children.Length; i++)
            {
                if (faultOrientation == Gtk.Orientation.Horizontal)
                {
                    DND.AddHFault(this, i, children[i - 1], children[i]);
                }
                else
                {
                    DND.AddVFault(this, i, children[i - 1], children[i]);
                }
            }
        }
Пример #11
0
/*
 *              FIXME: why was this needed?
 *              protected override bool AllowPlaceholders {
 *                      get {
 *                              return InternalChildProperty != null;
 *                      }
 *              }
 */
        // DoSync() does two things: first, it makes sure that all of the
        // PackStart widgets have Position numbers less than all of the
        // PackEnd widgets. Second, it creates faults anywhere two widgets
        // could be split apart. The fault IDs correspond to the Position
        // a widget would have to be assigned to end up in that slot
        // (negated for PackEnd slots).
        //
        // Position/PackType:   0S 1S 2S     4E  3E
        //                    +----------------------+
        //                    | AA BB CC     DD  EE  |
        //                    +----------------------+
        // Fault Id:           0  1  2  3  -5  -4  -3

        protected override void DoSync()
        {
            if (!box.IsRealized)
            {
                return;
            }

            DND.ClearFaults(this);

            Gtk.Widget[] children = box.Children;
            if (children.Length == 0)
            {
                return;
            }

            Gtk.Widget[] sorted     = new Gtk.Widget[children.Length];
            int          last_start = -1;
            bool         hbox       = ContainerOrientation == Gtk.Orientation.Horizontal;

            foreach (Gtk.Widget child in children)
            {
                Gtk.Box.BoxChild bc = box[child] as Gtk.Box.BoxChild;
                if (AutoSize[child])
                {
                    bool exp = hbox ? ChildHExpandable(child) : ChildVExpandable(child);
                    if (bc.Expand != exp)
                    {
                        bc.Expand = exp;
                    }
                    if (bc.Fill != exp)
                    {
                        bc.Fill = exp;
                    }
                }

                // Make sure all of the PackStart widgets are before
                // any PackEnd widgets in the list.
                if (bc.PackType == Gtk.PackType.Start)
                {
                    if (bc.Position != ++last_start)
                    {
                        Array.Copy(sorted, last_start, sorted, last_start + 1, bc.Position - last_start);
                        box.ReorderChild(child, last_start);
                    }
                }

                if (!(child is Placeholder))
                {
                    sorted[bc.Position] = child;
                }
            }

            // The orientation of the faults is the opposite of the
            // orientation of the box
            Gtk.Orientation orientation = hbox ? Gtk.Orientation.Vertical : Gtk.Orientation.Horizontal;
            Gtk.SideType    before      = hbox ? Gtk.SideType.Left : Gtk.SideType.Top;
            Gtk.SideType    after       = hbox ? Gtk.SideType.Right : Gtk.SideType.Bottom;

            if (!Unselectable)
            {
                // If there are no PackStart widgets, we need a fault at the leading
                // edge. Otherwise if there's a widget at the leading edge, we need a
                // fault before it.
                if (last_start == -1)
                {
                    DND.AddFault(this, 0, before, null);
                }
                else if (sorted[0] != null)
                {
                    DND.AddFault(this, 0, before, sorted[0]);
                }

                // Add a fault between each pair of (non-placeholder) start widgets
                for (int i = 1; i <= last_start; i++)
                {
                    if (sorted[i - 1] != null && sorted[i] != null)
                    {
                        DND.AddFault(this, i, orientation, sorted[i - 1], sorted[i]);
                    }
                }

                // If there's a non-placeholder at the end of the PackStart
                // range, add a fault after it
                if (last_start > -1 && sorted[last_start] != null)
                {
                    DND.AddFault(this, last_start + 1, after, sorted[last_start]);
                }

                // Now the PackEnd widgets
                if (last_start == sorted.Length - 1)
                {
                    DND.AddFault(this, -(last_start + 1), after, null);
                }
                else if (sorted[last_start + 1] != null)
                {
                    DND.AddFault(this, -(last_start + 1), after, sorted[last_start + 1]);
                }

                for (int i = last_start + 2; i < sorted.Length; i++)
                {
                    if (sorted[i - 1] != null && sorted[i] != null)
                    {
                        DND.AddFault(this, -i, orientation, sorted[i - 1], sorted[i]);
                    }
                }

                if (sorted.Length > last_start + 1 && sorted[sorted.Length - 1] != null)
                {
                    DND.AddFault(this, -sorted.Length, before, sorted[sorted.Length - 1]);
                }
            }
        }
Пример #12
0
        protected override bool OnDragDrop(Gdk.DragContext context, int x, int y, uint time)
        {
            ActionPaletteItem dropped = DND.Drop(context, null, time) as ActionPaletteItem;

            if (dropped == null)
            {
                return(false);
            }

            if (dropped.Node.Type != Gtk.UIManagerItemType.Menuitem &&
                dropped.Node.Type != Gtk.UIManagerItemType.Menu &&
                dropped.Node.Type != Gtk.UIManagerItemType.Toolitem &&
                dropped.Node.Type != Gtk.UIManagerItemType.Separator)
            {
                return(false);
            }

            ActionTreeNode newNode = dropped.Node;

            if (dropped.Node.Type == Gtk.UIManagerItemType.Toolitem)
            {
                newNode      = newNode.Clone();
                newNode.Type = Gtk.UIManagerItemType.Menuitem;
            }

            Widget wrapper = Widget.Lookup(this);

            using (wrapper.UndoManager.AtomicChange) {
                if (dropIndex < actionTree.Children.Count)
                {
                    // Do nothing if trying to drop the node over the same node
                    ActionTreeNode dropNode = actionTree.Children [dropIndex];
                    if (dropNode == dropped.Node)
                    {
                        return(false);
                    }

                    if (newNode.ParentNode != null)
                    {
                        newNode.ParentNode.Children.Remove(newNode);
                    }

                    // The drop position may have changed after removing the dropped node,
                    // so get it again.
                    dropIndex = actionTree.Children.IndexOf(dropNode);
                    actionTree.Children.Insert(dropIndex, newNode);
                }
                else
                {
                    if (newNode.ParentNode != null)
                    {
                        newNode.ParentNode.Children.Remove(newNode);
                    }
                    actionTree.Children.Add(newNode);
                    dropIndex = actionTree.Children.Count - 1;
                }

                // Select the dropped node
                ActionMenuItem mi = (ActionMenuItem)menuItems [dropIndex];
                mi.Select();
            }

            return(base.OnDragDrop(context, x, y, time));
        }
Пример #13
0
 public ActionMenuBar()
 {
     DND.DestSet(this, true);
 }
 public ActionToolbar()
 {
     DND.DestSet(this, true);
     this.ShowArrow = false;
 }