Exemple #1
0
        void Toolbox_DragBegin(object sender, EventArgs args)
        {
            var selectedNode = toolbox.SelectedNode;

            if (!isDragging && selectedNode != null)
            {
                DesignerSupport.Service.ToolboxService.SelectItem(selectedNode);

                Gtk.Drag.SourceUnset(widget);
                if (selectedNode is IDragDataToolboxNode node)
                {
                    foreach (var format in node.Formats)
                    {
                        targets.Add(format, 0, 0);
                    }
                }
                // Gtk.Application.CurrentEvent and other copied gdk_events seem to have a problem
                // when used as they use gdk_event_copy which seems to crash on de-allocating the private slice.
                IntPtr currentEvent = GtkWorkarounds.GetCurrentEventHandle();
                Gtk.Drag.Begin(widget, targets, Gdk.DragAction.Copy | Gdk.DragAction.Move, 1, new Gdk.Event(currentEvent, false));

                // gtk_drag_begin does not store the event, so we're okay
                GtkWorkarounds.FreeEvent(currentEvent);
            }
        }
Exemple #2
0
        protected override void Initialize(IPadWindow container)
        {
            base.Initialize(container);
#if MAC
            toolbox                 = new Toolbox.MacToolbox(DesignerSupport.Service.ToolboxService, container);
            widget                  = GtkMacInterop.NSViewToGtkWidget(toolbox);
            widget.CanFocus         = true;
            widget.Sensitive        = true;
            widget.KeyPressEvent   += toolbox.OnKeyPressed;
            widget.KeyReleaseEvent += toolbox.KeyReleased;

            widget.DragBegin += (o, args) => {
                if (!isDragging)
                {
                    DesignerSupport.Service.ToolboxService.DragSelectedItem(widget, args.Context);
                    isDragging = true;
                }
            };

            widget.DragEnd += (o, args) => {
                isDragging = false;
            };

            widget.Focused += (s, e) => {
                toolbox.FocusSelectedView();
            };

            toolbox.ContentFocused += (s, e) => {
                if (!widget.HasFocus)
                {
                    widget.HasFocus = true;
                    toolbox.FocusSelectedView();
                }
            };
            toolbox.DragSourceSet += (s, e) => {
                targets = new Gtk.TargetList();
                targets.AddTable(e);
            };
            toolbox.DragBegin += (object sender, EventArgs e) => {
                if (!isDragging)
                {
                    Gtk.Drag.SourceUnset(widget);

                    // Gtk.Application.CurrentEvent and other copied gdk_events seem to have a problem
                    // when used as they use gdk_event_copy which seems to crash on de-allocating the private slice.
                    IntPtr currentEvent = GtkWorkarounds.GetCurrentEventHandle();
                    Gtk.Drag.Begin(widget, targets, Gdk.DragAction.Copy | Gdk.DragAction.Move, 1, new Gdk.Event(currentEvent));

                    // gtk_drag_begin does not store the event, so we're okay
                    GtkWorkarounds.FreeEvent(currentEvent);
                }
            };

            widget.ShowAll();
#else
            widget = new Toolbox.Toolbox(DesignerSupport.Service.ToolboxService, container);
#endif
        }
        public TimeSpan GetEventTime(Gdk.EventKey eventKey)
        {
            // Gtk.Application.CurrentEvent and other copied gdk_events seem to have a problem
            // when used as they use gdk_event_copy which seems to crash on de-allocating the private slice.
            IntPtr currentEvent = GtkWorkarounds.GetCurrentEventHandle();
            bool   equals       = currentEvent == eventKey.Handle;

            GtkWorkarounds.FreeEvent(currentEvent);

            // If this GDK event is the current Gtk.Application event, assume that NSApplication's
            // current event is the event from which the GDK event was created and use its timestamp
            // instead, which has a much higher precision than the GDK time.
            if (equals)
            {
                return(FromNSTimeInterval(AppKit.NSApplication.SharedApplication.CurrentEvent.Timestamp));
            }

            return(TimeSpan.FromMilliseconds(eventKey.Time));
        }