Gdk.Drop¶

Subclasses:: None

Methods¶

Inherited:: GObject.Object (37)
Structs:: GObject.ObjectClass (5)

	`finish` (action)
	`get_actions` ()
	`get_device` ()
	`get_display` ()
	`get_drag` ()
	`get_formats` ()
	`get_surface` ()
	`read_async` (mime_types, io_priority, cancellable, callback, *user_data)
	`read_finish` (result)
	`read_value_async` (type, io_priority, cancellable, callback, *user_data)
	`read_value_finish` (result)
	`status` (actions, preferred)

Virtual Methods¶

Inherited:: GObject.Object (7)

Properties¶

Name	Type	Flags
`actions`	`Gdk.DragAction`	r/w/co/en
`device`	`Gdk.Device`	r/w/co/en
`display`	`Gdk.Display`	r/en
`drag`	`Gdk.Drag`	r/w/co/en
`formats`	`Gdk.ContentFormats`	r/w/co/en
`surface`	`Gdk.Surface`	r/w/co/en

Signals¶

Inherited:: GObject.Object (1)

Fields¶

Inherited:: GObject.Object (1)

Class Details¶

class Gdk.Drop(**kwargs)¶

Bases:: GObject.Object
Abstract:: Yes

The GdkDrop object represents the target of an ongoing DND operation.

Possible drop sites get informed about the status of the ongoing drag operation with events of type Gdk.EventType.DRAG_ENTER, Gdk.EventType.DRAG_LEAVE, Gdk.EventType.DRAG_MOTION and Gdk.EventType.DROP_START. The GdkDrop object can be obtained from these [class`Gdk`.Event] types using [method`Gdk`.DNDEvent.get_drop].

The actual data transfer is initiated from the target side via an async read, using one of the GdkDrop methods for this purpose: [method`Gdk`.Drop.read_async] or [method`Gdk`.Drop.read_value_async].

GTK provides a higher level abstraction based on top of these functions, and so they are not normally needed in GTK applications. See the “Drag and Drop” section of the GTK documentation for more information.

finish(action)[source]¶

Parameters:: action (Gdk.DragAction) – the action performed by the destination or 0 if the drop failed

Ends the drag operation after a drop.

The action must be a single action selected from the actions available via [method`Gdk`.Drop.get_actions].

get_actions()[source]¶

Returns:: The possible GdkDragActions
Return type:: Gdk.DragAction

Returns the possible actions for this GdkDrop.

If this value contains multiple actions - i.e. [func`Gdk`.DragAction.is_unique] returns False for the result - [method`Gdk`.Drop.finish] must choose the action to use when accepting the drop. This will only happen if you passed Gdk.DragAction.ASK as one of the possible actions in [method`Gdk`.Drop.status]. Gdk.DragAction.ASK itself will not be included in the actions returned by this function.

This value may change over the lifetime of the [class`Gdk`.Drop] both as a response to source side actions as well as to calls to [method`Gdk`.Drop.status] or [method`Gdk`.Drop.finish]. The source side will not change this value anymore once a drop has started.

get_device()[source]¶

Returns:: The GdkDevice performing the drop.
Return type:: Gdk.Device

Returns the GdkDevice performing the drop.

get_display()[source]¶

Returns:: a GdkDisplay
Return type:: Gdk.Display

Gets the GdkDisplay that self was created for.

get_drag()[source]¶

Returns:: the corresponding GdkDrag
Return type:: Gdk.Drag or None

If this is an in-app drag-and-drop operation, returns the GdkDrag that corresponds to this drop.

If it is not, None is returned.

get_formats()[source]¶

Returns:: The possible GdkContentFormats
Return type:: Gdk.ContentFormats

Returns the GdkContentFormats that the drop offers the data to be read in.

get_surface()[source]¶

Returns:: The GdkSurface performing the drop.
Return type:: Gdk.Surface

Returns the GdkSurface performing the drop.

read_async(mime_types, io_priority, cancellable, callback, *user_data)[source]¶

Parameters:

mime_types ([str]) – pointer to an array of mime types
io_priority (int) – the I/O priority for the read operation
cancellable (Gio.Cancellable or None) – optional GCancellable object
callback (Gio.AsyncReadyCallback or None) – a GAsyncReadyCallback to call when the request is satisfied
user_data (object or None) – the data to pass to callback

Asynchronously read the dropped data from a GdkDrop in a format that complies with one of the mime types.

read_finish(result)[source]¶

Parameters:

result (Gio.AsyncResult) – a GAsyncResult

Raises:

GLib.Error

Returns:

the GInputStream

out_mime_type:: return location for the used mime type

Return type:

(Gio.InputStream or None, out_mime_type: str)

Finishes an async drop read operation.

Note that you must not use blocking read calls on the returned stream in the GTK thread, since some platforms might require communication with GTK to complete the data transfer. You can use async APIs such as Gio.InputStream.read_bytes_async().

See [method`Gdk`.Drop.read_async].

read_value_async(type, io_priority, cancellable, callback, *user_data)[source]¶

Parameters:

type (GObject.GType) – a GType to read
io_priority (int) – the I/O priority of the request.
cancellable (Gio.Cancellable or None) – optional GCancellable object, None to ignore.
callback (Gio.AsyncReadyCallback or None) – callback to call when the request is satisfied
user_data (object or None) – the data to pass to callback function

Asynchronously request the drag operation’s contents converted to the given type.

When the operation is finished callback will be called. You must then call [method`Gdk`.Drop.read_value_finish] to get the resulting GValue.

For local drag-and-drop operations that are available in the given GType, the value will be copied directly. Otherwise, GDK will try to use [func`Gdk`.content_deserialize_async] to convert the data.

read_value_finish(result)[source]¶

Parameters:: result (Gio.AsyncResult) – a GAsyncResult
Raises:: GLib.Error
Returns:: a GValue containing the result.
Return type:: GObject.Value

Finishes an async drop read.

See [method`Gdk`.Drop.read_value_async].

status(actions, preferred)[source]¶

Parameters:

actions (Gdk.DragAction) – Supported actions of the destination, or 0 to indicate that a drop will not be accepted
preferred (Gdk.DragAction) – A unique action that’s a member of actions indicating the preferred action

Selects all actions that are potentially supported by the destination.

When calling this function, do not restrict the passed in actions to the ones provided by [method`Gdk`.Drop.get_actions]. Those actions may change in the future, even depending on the actions you provide here.

The preferred action is a hint to the drag-and-drop mechanism about which action to use when multiple actions are possible.

This function should be called by drag destinations in response to Gdk.EventType.DRAG_ENTER or Gdk.EventType.DRAG_MOTION events. If the destination does not yet know the exact actions it supports, it should set any possible actions first and then later call this function again.