static void fm_places_view_init(FmPlacesView *self)
{
GtkTreeViewColumn* col;
GtkCellRenderer* renderer;
GtkTargetList* targets;
GdkPixbuf* pix;
guint handler;
if(G_UNLIKELY(!model))
{
model = fm_places_model_new();
g_object_add_weak_pointer(G_OBJECT(model), &model);
}
else
g_object_ref(model);
gtk_tree_view_set_model(GTK_TREE_VIEW(self), model);
g_object_unref(model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(self), FALSE);
gtk_tree_view_set_row_separator_func(GTK_TREE_VIEW(self), (GtkTreeViewRowSeparatorFunc)sep_func, NULL, NULL );
col = gtk_tree_view_column_new();
renderer = fm_cell_renderer_pixbuf_new();
handler = g_signal_connect(fm_config, "changed::pane_icon_size", G_CALLBACK(on_renderer_icon_size_changed), renderer);
g_object_weak_ref(G_OBJECT(renderer), (GDestroyNotify)on_cell_renderer_pixbuf_destroy, GUINT_TO_POINTER(handler));
fm_cell_renderer_pixbuf_set_fixed_size(FM_CELL_RENDERER_PIXBUF(renderer), fm_config->pane_icon_size, fm_config->pane_icon_size);
gtk_tree_view_column_pack_start( col, renderer, FALSE );
gtk_tree_view_column_set_attributes( col, renderer,
"pixbuf", FM_PLACES_MODEL_COL_ICON, NULL );
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start( col, renderer, TRUE );
g_object_set(renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_set_attributes( col, renderer,
"text", FM_PLACES_MODEL_COL_LABEL, NULL );
renderer = gtk_cell_renderer_pixbuf_new();
self->mount_indicator_renderer = renderer;
gtk_tree_view_column_pack_start( col, renderer, FALSE );
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(col), renderer,
fm_places_model_mount_indicator_cell_data_func,
NULL, NULL);
gtk_tree_view_append_column ( GTK_TREE_VIEW(self), col );
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(self), GDK_BUTTON1_MASK,
dnd_src_targets, G_N_ELEMENTS(dnd_src_targets), GDK_ACTION_MOVE);
gtk_drag_dest_set(self, 0,
fm_default_dnd_dest_targets, N_FM_DND_DEST_DEFAULT_TARGETS,
GDK_ACTION_COPY|GDK_ACTION_MOVE|GDK_ACTION_LINK|GDK_ACTION_ASK);
targets = gtk_drag_dest_get_target_list((GtkWidget*)self);
/* add our own targets */
gtk_target_list_add_table(targets, dnd_dest_targets, G_N_ELEMENTS(dnd_dest_targets));
self->dnd_dest = fm_dnd_dest_new((GtkWidget*)self);
g_signal_connect(self->dnd_dest, "files_dropped", G_CALLBACK(on_dnd_dest_files_dropped), self);
}
static void
ide_editor_frame_init (IdeEditorFrame *self)
{
g_autoptr(GSettings) settings = NULL;
g_autoptr(GSettings) insight_settings = NULL;
GtkTargetList *target_list;
gtk_widget_init_template (GTK_WIDGET (self));
ide_editor_frame_actions_init (self);
settings = g_settings_new ("org.gnome.builder.editor");
g_settings_bind (settings, "draw-spaces", self->source_view, "draw-spaces", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (settings, "font-name", self->source_view, "font-name", G_SETTINGS_BIND_GET);
g_settings_bind (settings, "highlight-current-line", self->source_view, "highlight-current-line", G_SETTINGS_BIND_GET);
g_settings_bind (settings, "overscroll", self->source_view, "overscroll", G_SETTINGS_BIND_GET);
g_settings_bind (settings, "scroll-offset", self->source_view, "scroll-offset", G_SETTINGS_BIND_GET);
g_settings_bind (settings, "show-grid-lines", self->source_view, "show-grid-lines", G_SETTINGS_BIND_GET);
g_settings_bind (settings, "show-line-changes", self->source_view, "show-line-changes", G_SETTINGS_BIND_GET);
g_settings_bind (settings, "show-line-numbers", self->source_view, "show-line-numbers", G_SETTINGS_BIND_GET);
g_settings_bind (settings, "smart-backspace", self->source_view, "smart-backspace", G_SETTINGS_BIND_GET);
g_settings_bind_with_mapping (settings, "smart-home-end", self->source_view, "smart-home-end", G_SETTINGS_BIND_GET, get_smart_home_end, NULL, NULL, NULL);
g_settings_bind (settings, "show-map", self, "show-map", G_SETTINGS_BIND_GET);
g_settings_bind (settings, "auto-hide-map", self, "auto-hide-map", G_SETTINGS_BIND_GET);
g_signal_connect_object (settings, "changed::keybindings", G_CALLBACK (keybindings_changed), self, 0);
insight_settings = g_settings_new ("org.gnome.builder.code-insight");
g_settings_bind (insight_settings, "word-completion", self->source_view, "enable-word-completion", G_SETTINGS_BIND_GET);
g_signal_connect_object (self->source_view,
"notify::overwrite",
G_CALLBACK (ide_editor_frame_update_ruler),
self,
G_CONNECT_SWAPPED);
g_signal_connect_object (self->source_view,
"notify::mode-display-name",
G_CALLBACK (ide_editor_frame_update_ruler),
self,
G_CONNECT_SWAPPED);
/*
* we want to rubberbanding search until enter has been pressed or next/previous actions
* have been activated.
*/
g_object_bind_property (self->search_revealer, "visible",
self->source_view, "rubberband-search",
G_BINDING_SYNC_CREATE);
/*
* Drag and drop support
*/
target_list = gtk_drag_dest_get_target_list (GTK_WIDGET (self->source_view));
if (target_list)
gtk_target_list_add_uri_targets (target_list, TARGET_URI_LIST);
}
/**
* gtk_drag_dest_add_uri_targets: (method)
* @widget: a #GtkWidget that’s a drag destination
*
* Add the URI targets supported by #GtkSelectionData to
* the target list of the drag destination. The targets
* are added with @info = 0. If you need another value,
* use gtk_target_list_add_uri_targets() and
* gtk_drag_dest_set_target_list().
*
* Since: 2.6
*/
void
gtk_drag_dest_add_uri_targets (GtkWidget *widget)
{
GtkTargetList *target_list;
target_list = gtk_drag_dest_get_target_list (widget);
if (target_list)
gtk_target_list_ref (target_list);
else
target_list = gtk_target_list_new (NULL, 0);
gtk_target_list_add_uri_targets (target_list, 0);
gtk_drag_dest_set_target_list (widget, target_list);
gtk_target_list_unref (target_list);
}
void
nemo_icon_dnd_init (NemoIconContainer *container)
{
GtkTargetList *targets;
int n_elements;
g_return_if_fail (container != NULL);
g_return_if_fail (NEMO_IS_ICON_CONTAINER (container));
container->details->dnd_info = g_new0 (NemoIconDndInfo, 1);
nemo_drag_init (&container->details->dnd_info->drag_info,
drag_types, G_N_ELEMENTS (drag_types), TRUE);
/* Set up the widget as a drag destination.
* (But not a source, as drags starting from this widget will be
* implemented by dealing with events manually.)
*/
n_elements = G_N_ELEMENTS (drop_types);
if (!nemo_icon_container_get_is_desktop (container)) {
/* Don't set up rootwindow drop */
n_elements -= 1;
}
gtk_drag_dest_set (GTK_WIDGET (container),
0,
drop_types, n_elements,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK);
targets = gtk_drag_dest_get_target_list (GTK_WIDGET (container));
gtk_target_list_add_text_targets (targets, NEMO_ICON_DND_TEXT);
/* Messages for outgoing drag. */
g_signal_connect (container, "drag_begin",
G_CALLBACK (drag_begin_callback), NULL);
g_signal_connect (container, "drag_data_get",
G_CALLBACK (drag_data_get_callback), NULL);
g_signal_connect (container, "drag_end",
G_CALLBACK (drag_end_callback), NULL);
/* Messages for incoming drag. */
g_signal_connect (container, "drag_data_received",
G_CALLBACK (drag_data_received_callback), NULL);
g_signal_connect (container, "drag_motion",
G_CALLBACK (drag_motion_callback), NULL);
g_signal_connect (container, "drag_drop",
G_CALLBACK (drag_drop_callback), NULL);
g_signal_connect (container, "drag_leave",
G_CALLBACK (drag_leave_callback), NULL);
}
static void
wikipad_document_init (WikipadDocument *document)
{
GtkTargetList *target_list;
/* private structure */
document->priv = WIKIPAD_DOCUMENT_GET_PRIVATE (document);
/* initialize the variables */
document->priv->utf8_filename = NULL;
document->priv->utf8_basename = NULL;
document->priv->label = NULL;
/* setup the scolled window */
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (document), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (document), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_hadjustment (GTK_SCROLLED_WINDOW (document), NULL);
gtk_scrolled_window_set_vadjustment (GTK_SCROLLED_WINDOW (document), NULL);
/* create a textbuffer */
document->buffer = GTK_TEXT_BUFFER (gtk_source_buffer_new (NULL));
/* initialize the file */
document->file = wikipad_file_new (document->buffer);
/* connect signals to the file */
g_signal_connect_swapped (G_OBJECT (document->file), "filename-changed", G_CALLBACK (wikipad_document_filename_changed), document);
/* create the highlight tag */
document->tag = gtk_text_buffer_create_tag (document->buffer, NULL, "background", "#ffff78", NULL);
/* setup the textview */
document->textview = g_object_new (WIKIPAD_TYPE_VIEW, "buffer", document->buffer, NULL);
gtk_container_add (GTK_CONTAINER (document), GTK_WIDGET (document->textview));
gtk_widget_show (GTK_WIDGET (document->textview));
/* also allow dropping of uris and tabs in the textview */
target_list = gtk_drag_dest_get_target_list (GTK_WIDGET (document->textview));
gtk_target_list_add_table (target_list, drop_targets, G_N_ELEMENTS (drop_targets));
/* attach signals to the text view and buffer */
g_signal_connect (G_OBJECT (document->buffer), "notify::cursor-position", G_CALLBACK (wikipad_document_notify_cursor_position), document);
g_signal_connect (G_OBJECT (document->buffer), "notify::has-selection", G_CALLBACK (wikipad_document_notify_has_selection), document);
g_signal_connect_swapped (G_OBJECT (document->buffer), "modified-changed", G_CALLBACK (wikipad_document_label_color), document);
g_signal_connect_swapped (G_OBJECT (document->file), "readonly-changed", G_CALLBACK (wikipad_document_label_color), document);
g_signal_connect (G_OBJECT (document->textview), "notify::overwrite", G_CALLBACK (wikipad_document_notify_overwrite), document);
g_signal_connect (G_OBJECT (document->textview), "drag-data-received", G_CALLBACK (wikipad_document_drag_data_received), document);
g_signal_connect (G_OBJECT (document->buffer), "notify::language", G_CALLBACK (wikipad_document_notify_language), document);
}
static void fm_places_view_init(FmPlacesView *self)
{
GtkTreeViewColumn* col;
GtkCellRenderer* renderer;
GtkTargetList* targets;
GdkPixbuf* pix;
guint handler;
init_model();
gtk_tree_view_set_model(GTK_TREE_VIEW(self), model);
g_object_unref(model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(self), FALSE);
gtk_tree_view_set_row_separator_func(GTK_TREE_VIEW(self), (GtkTreeViewRowSeparatorFunc)sep_func, NULL, NULL );
col = gtk_tree_view_column_new();
renderer = fm_cell_renderer_pixbuf_new();
handler = g_signal_connect(fm_config, "changed::pane_icon_size", G_CALLBACK(on_renderer_icon_size_changed), renderer);
g_object_weak_ref(G_OBJECT(renderer), (GDestroyNotify)on_cell_renderer_pixbuf_destroy, GUINT_TO_POINTER(handler));
fm_cell_renderer_pixbuf_set_fixed_size(FM_CELL_RENDERER_PIXBUF(renderer), fm_config->pane_icon_size, fm_config->pane_icon_size);
gtk_tree_view_column_pack_start( col, renderer, FALSE );
gtk_tree_view_column_set_attributes( col, renderer,
"pixbuf", COL_ICON, NULL );
renderer = gtk_cell_renderer_text_new();
// g_signal_connect( renderer, "edited", G_CALLBACK(on_bookmark_edited), view );
gtk_tree_view_column_pack_start( col, renderer, TRUE );
gtk_tree_view_column_set_attributes( col, renderer,
"text", COL_LABEL, NULL );
gtk_tree_view_append_column ( GTK_TREE_VIEW(self), col );
/*
gtk_drag_source_set(fv->view, GDK_BUTTON1_MASK,
fm_default_dnd_src_targets, N_FM_DND_SRC_DEFAULT_TARGETS,
GDK_ACTION_COPY|GDK_ACTION_MOVE|GDK_ACTION_LINK|GDK_ACTION_ASK);
fm_dnd_src_set_widget(fv->dnd_src, fv->view);
*/
gtk_drag_dest_set(self, 0,
fm_default_dnd_dest_targets, N_FM_DND_DEST_DEFAULT_TARGETS,
GDK_ACTION_COPY|GDK_ACTION_MOVE|GDK_ACTION_LINK|GDK_ACTION_ASK);
targets = gtk_drag_dest_get_target_list((GtkWidget*)self);
/* add our own targets */
gtk_target_list_add_table(targets, dnd_dest_targets, G_N_ELEMENTS(dnd_dest_targets));
self->dnd_dest = fm_dnd_dest_new((GtkWidget*)self);
g_signal_connect(self->dnd_dest, "query-info", G_CALLBACK(on_dnd_dest_query_info), self);
g_signal_connect(self->dnd_dest, "files_dropped", G_CALLBACK(on_dnd_dest_files_dropped), self);
}
/**
* gtk_drag_dest_find_target: (method)
* @widget: drag destination widget
* @context: drag context
* @target_list: (allow-none): list of droppable targets, or %NULL to use
* gtk_drag_dest_get_target_list (@widget).
*
* Looks for a match between the supported targets of @context and the
* @dest_target_list, returning the first matching target, otherwise
* returning %GDK_NONE. @dest_target_list should usually be the return
* value from gtk_drag_dest_get_target_list(), but some widgets may
* have different valid targets for different parts of the widget; in
* that case, they will have to implement a drag_motion handler that
* passes the correct target list to this function.
*
* Returns: (transfer none): first target that the source offers
* and the dest can accept, or %GDK_NONE
*/
GdkAtom
gtk_drag_dest_find_target (GtkWidget *widget,
GdkDragContext *context,
GtkTargetList *target_list)
{
GList *tmp_target;
GList *tmp_source = NULL;
GtkWidget *source_widget;
g_return_val_if_fail (GTK_IS_WIDGET (widget), GDK_NONE);
g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), GDK_NONE);
source_widget = gtk_drag_get_source_widget (context);
if (target_list == NULL)
target_list = gtk_drag_dest_get_target_list (widget);
if (target_list == NULL)
return GDK_NONE;
tmp_target = target_list->list;
while (tmp_target)
{
GtkTargetPair *pair = tmp_target->data;
tmp_source = gdk_drag_context_list_targets (context);
while (tmp_source)
{
if (tmp_source->data == GUINT_TO_POINTER (pair->target))
{
if ((!(pair->flags & GTK_TARGET_SAME_APP) || source_widget) &&
(!(pair->flags & GTK_TARGET_SAME_WIDGET) || (source_widget == widget)) &&
(!(pair->flags & GTK_TARGET_OTHER_APP) || !source_widget) &&
(!(pair->flags & GTK_TARGET_OTHER_WIDGET) || (source_widget != widget)))
return pair->target;
else
break;
}
tmp_source = tmp_source->next;
}
tmp_target = tmp_target->next;
}
return GDK_NONE;
}
int
clip_GTK_DRAGDESTGETTARGETLIST(ClipMachine * cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
GtkTargetList *list ;
C_object *ctlist ;
CHECKCWID(cwid, GTK_IS_WIDGET);
list = gtk_drag_dest_get_target_list(GTK_WIDGET(cwid->widget));
if (list)
{
ctlist = _list_get_cobject(cm, list);
if (!ctlist) ctlist = _register_object(cm, list, GDK_TYPE_ATOM, NULL, NULL);
if (ctlist) _clip_mclone(cm, RETPTR(cm), &ctlist->obj);
}
return 0;
err:
return 1;
}
static void
configure_drag_dest (EggEditableToolbar *etoolbar,
GtkToolbar *toolbar)
{
EggToolbarsItemType *type;
GtkTargetList *targets;
GList *list;
/* Make every toolbar able to receive drag-drops. */
gtk_drag_dest_set (GTK_WIDGET (toolbar), 0,
dest_drag_types, G_N_ELEMENTS (dest_drag_types),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
/* Add any specialist drag-drop abilities. */
targets = gtk_drag_dest_get_target_list (GTK_WIDGET (toolbar));
list = egg_toolbars_model_get_types (etoolbar->priv->model);
while (list)
{
type = list->data;
if (type->new_name != NULL || type->get_name != NULL)
gtk_target_list_add (targets, type->type, 0, 0);
list = list->next;
}
}
static gboolean
gimp_container_tree_view_drop_status (GimpContainerTreeView *tree_view,
GdkDragContext *context,
gint x,
gint y,
guint time,
GtkTreePath **return_path,
GdkAtom *return_atom,
GimpDndType *return_src_type,
GimpViewable **return_src,
GimpViewable **return_dest,
GtkTreeViewDropPosition *return_pos)
{
GimpViewable *src_viewable = NULL;
GimpViewable *dest_viewable = NULL;
GtkTreePath *drop_path = NULL;
GtkTargetList *target_list;
GdkAtom target_atom;
GimpDndType src_type;
GtkTreeViewDropPosition drop_pos = GTK_TREE_VIEW_DROP_BEFORE;
GdkDragAction drag_action = 0;
if (! gimp_container_view_get_container (GIMP_CONTAINER_VIEW (tree_view)) ||
! gimp_container_view_get_reorderable (GIMP_CONTAINER_VIEW (tree_view)))
goto drop_impossible;
target_list = gtk_drag_dest_get_target_list (GTK_WIDGET (tree_view->view));
target_atom = gtk_drag_dest_find_target (GTK_WIDGET (tree_view->view),
context, target_list);
if (! gtk_target_list_find (target_list, target_atom, &src_type))
goto drop_impossible;
switch (src_type)
{
case GIMP_DND_TYPE_URI_LIST:
case GIMP_DND_TYPE_TEXT_PLAIN:
case GIMP_DND_TYPE_NETSCAPE_URL:
case GIMP_DND_TYPE_COLOR:
case GIMP_DND_TYPE_SVG:
case GIMP_DND_TYPE_SVG_XML:
case GIMP_DND_TYPE_COMPONENT:
case GIMP_DND_TYPE_PIXBUF:
break;
default:
{
GtkWidget *src_widget = gtk_drag_get_source_widget (context);
if (! src_widget)
goto drop_impossible;
src_viewable = gimp_dnd_get_drag_data (src_widget);
if (! GIMP_IS_VIEWABLE (src_viewable))
goto drop_impossible;
}
break;
}
if (gtk_tree_view_get_path_at_pos (tree_view->view, x, y,
&drop_path, NULL, NULL, NULL))
{
GimpViewRenderer *renderer;
GtkTreeIter iter;
GdkRectangle cell_area;
gtk_tree_model_get_iter (tree_view->model, &iter, drop_path);
gtk_tree_model_get (tree_view->model, &iter,
GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER, &renderer,
-1);
dest_viewable = renderer->viewable;
g_object_unref (renderer);
gtk_tree_view_get_cell_area (tree_view->view, drop_path, NULL, &cell_area);
if (gimp_viewable_get_children (dest_viewable))
{
if (gtk_tree_view_row_expanded (tree_view->view, drop_path))
{
if (y >= (cell_area.y + cell_area.height / 2))
drop_pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
else
drop_pos = GTK_TREE_VIEW_DROP_BEFORE;
}
else
{
if (y >= (cell_area.y + 2 * (cell_area.height / 3)))
drop_pos = GTK_TREE_VIEW_DROP_AFTER;
else if (y <= (cell_area.y + cell_area.height / 3))
drop_pos = GTK_TREE_VIEW_DROP_BEFORE;
else
drop_pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
}
}
else
{
if (y >= (cell_area.y + cell_area.height / 2))
drop_pos = GTK_TREE_VIEW_DROP_AFTER;
else
drop_pos = GTK_TREE_VIEW_DROP_BEFORE;
}
}
else
{
GtkTreeIter iter;
gint n_children;
n_children = gtk_tree_model_iter_n_children (tree_view->model, NULL);
if (n_children > 0 &&
gtk_tree_model_iter_nth_child (tree_view->model, &iter,
NULL, n_children - 1))
{
GimpViewRenderer *renderer;
gtk_tree_model_get (tree_view->model, &iter,
GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER,
&renderer,
-1);
drop_path = gtk_tree_model_get_path (tree_view->model, &iter);
dest_viewable = renderer->viewable;
drop_pos = GTK_TREE_VIEW_DROP_AFTER;
g_object_unref (renderer);
}
}
if (dest_viewable || tree_view->priv->dnd_drop_to_empty)
{
if (GIMP_CONTAINER_TREE_VIEW_GET_CLASS (tree_view)->drop_possible (tree_view,
src_type,
src_viewable,
dest_viewable,
drop_path,
drop_pos,
&drop_pos,
&drag_action))
{
gdk_drag_status (context, drag_action, time);
if (return_path)
*return_path = drop_path;
else
gtk_tree_path_free (drop_path);
if (return_atom)
*return_atom = target_atom;
if (return_src)
*return_src = src_viewable;
if (return_dest)
*return_dest = dest_viewable;
if (return_pos)
*return_pos = drop_pos;
return TRUE;
}
gtk_tree_path_free (drop_path);
}
drop_impossible:
gdk_drag_status (context, 0, time);
return FALSE;
}
static VALUE
rg_m_dest_get_target_list(G_GNUC_UNUSED VALUE self, VALUE widget)
{
GtkTargetList* list = gtk_drag_dest_get_target_list(RVAL2WIDGET(widget));
return BOXED2RVAL(list, GTK_TYPE_TARGET_LIST);
}
