static void
did_not_drag (EphyNodeView *view,
GdkEventButton *event)
{
GtkTreeView *tree_view;
GtkTreeSelection *selection;
GtkTreePath *path;
tree_view = GTK_TREE_VIEW (view);
selection = gtk_tree_view_get_selection (tree_view);
if (gtk_tree_view_get_path_at_pos (tree_view, event->x, event->y,
&path, NULL, NULL, NULL))
{
if((event->button == 1 || event->button == 2) &&
gtk_tree_selection_path_is_selected (selection, path) &&
!button_event_modifies_selection (event))
{
if (gtk_tree_selection_get_mode (selection) == GTK_SELECTION_MULTIPLE)
{
gtk_tree_selection_unselect_all (selection);
}
gtk_tree_selection_select_path (selection, path);
}
gtk_tree_path_free (path);
}
}
static void
gnc_search_callback_button_execute (GNCSearchCallbackButton *cb,
GNCSearchWindow *sw)
{
GNCQueryView *qview = GNC_QUERY_VIEW(sw->result_view);
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter;
// Sanity check
g_assert(qview);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(qview));
g_assert(gtk_tree_selection_get_mode(selection) == GTK_SELECTION_MULTIPLE);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(qview));
/* Do we have a callback for multi-selections ? */
if (cb->cb_multiselect_fn && (!cb->cb_fcn ))
{
/* We have allready populated the selected_item_list from the select row callback */
// We use g_list_prepend (for performance reasons), so we have to reverse once here
sw->selected_item_list = g_list_reverse(sw->selected_item_list);
// Call the callback
(cb->cb_multiselect_fn)(sw->selected_item_list, sw->user_data);
}
else
{
// No, stick to the single-item callback
if (cb->cb_fcn)
(cb->cb_fcn)(&(sw->selected_item), sw->user_data);
}
}
/*
* apply-button of if_window
*/
void on_button_if_apply_clicked(GtkWidget * gw, GtkTreeView * view)
{
GtkTreeSelection *sel;
GtkTreeModel *model;
GtkTreeIter selected_row;
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
g_assert(gtk_tree_selection_get_mode(sel) == GTK_SELECTION_SINGLE);
if (gtk_tree_selection_get_selected(sel, &model, &selected_row)) {
// gtk_list_store_remove(GTK_LIST_STORE(model), &selected_row);
gchar *name;
gtk_tree_model_get(model, &selected_row, 1, &name, -1);
g_print("Apply, you have selected the row of %s\n", name);
strcpy(select_dev, name);
g_free(name);
} else {
/*
* If no row is selected, the button should not be clickable in
* the first place
*/
g_assert_not_reached();
}
}
/*
* Retrieve the selected owner from an owner tree view. The
* owner tree must be in single selection mode.
*/
GncOwner *
gnc_tree_view_owner_get_selected_owner (GncTreeViewOwner *view)
{
GtkTreeSelection *selection;
GtkTreeModel *f_model, *s_model;
GtkTreeIter iter, f_iter, s_iter;
GncOwner *owner;
GtkSelectionMode mode;
ENTER("view %p", view);
g_return_val_if_fail (GNC_IS_TREE_VIEW_OWNER (view), NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
mode = gtk_tree_selection_get_mode(selection);
if ((mode != GTK_SELECTION_SINGLE) && (mode != GTK_SELECTION_BROWSE))
{
return NULL;
}
if (!gtk_tree_selection_get_selected (selection, &s_model, &s_iter))
{
LEAVE("no owner, get_selected failed");
return FALSE;
}
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (s_model),
&f_iter, &s_iter);
f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model));
gtk_tree_model_filter_convert_iter_to_child_iter (
GTK_TREE_MODEL_FILTER (f_model), &iter, &f_iter);
owner = iter.user_data;
LEAVE("owner %p (%s)", owner, gncOwnerGetName (owner));
return owner;
}
/**
* e_webdav_discover_content_get_multiselect:
* @content: a WebDAV discovery content, created by e_webdav_discover_content_new()
*
* Returns: whether multiselect is allowed for the @content.
*
* Since: 3.18
**/
gboolean
e_webdav_discover_content_get_multiselect (GtkWidget *content)
{
EWebDAVDiscoverContentData *data;
GtkTreeSelection *selection;
g_return_val_if_fail (GTK_IS_GRID (content), FALSE);
data = g_object_get_data (G_OBJECT (content), WEBDAV_DISCOVER_CONTENT_DATA_KEY);
g_return_val_if_fail (data != NULL, FALSE);
selection = gtk_tree_view_get_selection (data->sources_tree_view);
return gtk_tree_selection_get_mode (selection) == GTK_SELECTION_MULTIPLE;
}
int
clip_GTK_TREESELECTIONGETMODE(ClipMachine * cm)
{
C_object *ctreesel = _fetch_co_arg(cm);
GtkSelectionMode mode;
CHECKOPT2(1, MAP_t, NUMERIC_t); CHECKCOBJ(ctreesel,GTK_IS_TREE_SELECTION(ctreesel->object));
mode = gtk_tree_selection_get_mode(GTK_TREE_SELECTION(ctreesel->object));
_clip_retni(cm, mode);
return 0;
err:
return 1;
}
static void
onAbsenceSelectionChanged (GtkTreeSelection *sel,gpointer user_data)
{
GtkTreeIter selected_row;
GtkWidget *text_view;
GtkWidget *view;
GtkWidget *entry;
GtkTreeModel *model;
GtkTextBuffer *buffer;
gint index;
gchar *title;
gchar *message;
view=GTK_WIDGET(gtk_tree_selection_get_tree_view(sel));
g_assert(view);
g_assert(gtk_tree_selection_get_mode(sel) == GTK_SELECTION_SINGLE);
entry=GTK_WIDGET(lookup_widget(view,"AbsenceTitleEntry"));
g_assert(entry);
text_view=GTK_WIDGET(lookup_widget(view,"fuzaiText"));
g_assert(text_view);
if (gtk_tree_selection_get_selected(sel, &model, &selected_row))
{
gtk_tree_model_get (model, &selected_row,
1, &index,
-1);
dbg_out("Selected index:%d\n",index);
if (!hostinfo_get_absent_title(index,(const char **)&title)) {
gtk_entry_set_text(GTK_ENTRY(entry), title);
g_free(title);
}
if (!hostinfo_get_absent_message(index, &message)) {
buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
gtk_text_buffer_set_text(buffer,message,-1);
g_free(message);
}
}
else
{
g_assert_not_reached();
}
}
void
brasero_file_chooser_customize (GtkWidget *widget, gpointer null_data)
{
/* we explore everything until we reach a treeview (there are two) */
if (GTK_IS_TREE_VIEW (widget)) {
GtkTargetList *list;
GdkAtom target;
gboolean found;
guint num;
list = gtk_drag_source_get_target_list (widget);
target = gdk_atom_intern ("text/uri-list", TRUE);
found = gtk_target_list_find (list, target, &num);
/* FIXME: should we unref them ? apparently not according to
* the warning messages we get if we do */
if (found
&& gtk_tree_selection_get_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (widget))) == GTK_SELECTION_MULTIPLE) {
GtkTreeModel *model;
/* This is done because GtkFileChooser does not use a
* GtkListStore or GtkTreeStore any more. */
egg_tree_multi_drag_add_drag_support (GTK_TREE_VIEW (widget));
model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
if (model) {
GType type;
type = G_OBJECT_TYPE (model);
brasero_enable_multi_DND_for_model_type (type);
}
else
g_signal_connect (widget,
"notify::model",
G_CALLBACK (brasero_file_chooser_notify_model),
NULL);
}
}
else if (GTK_IS_BUTTON (widget)) {
GtkWidget *image;
gchar *stock_id = NULL;
image = gtk_button_get_image (GTK_BUTTON (widget));
if (!GTK_IS_IMAGE (image))
return;
gtk_image_get_stock (GTK_IMAGE (image), &stock_id, NULL);
if (stock_id
&& (!strcmp (stock_id,GTK_STOCK_ADD)
|| !strcmp (stock_id, GTK_STOCK_REMOVE))) {
GtkRequisition request;
gint width;
GtkWidget *parent;
/* This is to avoid having the left part too small */
parent = gtk_widget_get_parent (widget);
gtk_widget_get_requisition (parent, &request);
width = request.width;
gtk_widget_get_preferred_size (parent, &request, NULL);
if (request.width >= width)
gtk_widget_set_size_request (parent,
request.width,
request.height);
gtk_widget_hide (widget);
}
}
else if (GTK_IS_CONTAINER (widget)) {
if (GTK_IS_PANED (widget)) {
GtkWidget *left;
/* This is to allow the left part to be shrunk as much
* as the user want. */
left = gtk_paned_get_child1 (GTK_PANED (widget));
g_object_ref (left);
gtk_container_remove (GTK_CONTAINER (widget), left);
gtk_paned_pack1 (GTK_PANED (widget),
left,
TRUE,
TRUE);
g_object_unref (left);
g_signal_connect (widget,
"size-allocate",
G_CALLBACK (brasero_file_chooser_allocation_changed),
NULL);
}
gtk_container_foreach (GTK_CONTAINER (widget),
brasero_file_chooser_customize,
NULL);
}
}
static gboolean
exo_tree_view_single_click_timeout (gpointer user_data)
{
GtkTreeViewColumn *cursor_column;
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreePath *cursor_path;
GtkTreeIter iter;
ExoTreeView *tree_view = EXO_TREE_VIEW (user_data);
gboolean hover_path_selected;
GList *rows;
GList *lp;
//GDK_THREADS_ENTER (); //sfm not needed because called from g_idle?
/* verify that we are in single-click mode, have focus and a hover path */
if (gtk_widget_has_focus (GTK_WIDGET (tree_view)) && tree_view->priv->single_click && tree_view->priv->hover_path != NULL)
{
/* transform the hover_path to a tree iterator */
model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
if (model != NULL && gtk_tree_model_get_iter (model, &iter, tree_view->priv->hover_path))
{
/* determine the current cursor path/column */
gtk_tree_view_get_cursor (GTK_TREE_VIEW (tree_view), &cursor_path, &cursor_column);
/* be sure the row is fully visible */
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (tree_view),
tree_view->priv->hover_path,
0, //sfm was cursor_column - caused horizontal scroll
FALSE, 0.0f, 0.0f);
/* determine the selection and change it appropriately */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
if (gtk_tree_selection_get_mode (selection) == GTK_SELECTION_NONE)
{
/* just place the cursor on the row */
gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree_view), tree_view->priv->hover_path, cursor_column, FALSE);
}
else if ((tree_view->priv->single_click_timeout_state & GDK_SHIFT_MASK) != 0
&& gtk_tree_selection_get_mode (selection) == GTK_SELECTION_MULTIPLE)
{
/* check if the item is not already selected (otherwise do nothing) */
if (!gtk_tree_selection_path_is_selected (selection, tree_view->priv->hover_path))
{
/* unselect all previously selected items */
gtk_tree_selection_unselect_all (selection);
/* since we cannot access the anchor of a GtkTreeView, we
* use the cursor instead which is usually the same row.
*/
if (G_UNLIKELY (cursor_path == NULL))
{
/* place the cursor on the new row */
gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree_view), tree_view->priv->hover_path, cursor_column, FALSE);
}
else
{
/* select all between the cursor and the current row */
gtk_tree_selection_select_range (selection, tree_view->priv->hover_path, cursor_path);
}
}
}
else
{
/* remember the previously selected rows as set_cursor() clears the selection */
rows = gtk_tree_selection_get_selected_rows (selection, NULL);
/* check if the hover path is selected (as it will be selected after the set_cursor() call) */
hover_path_selected = gtk_tree_selection_path_is_selected (selection, tree_view->priv->hover_path);
/* place the cursor on the hover row */
gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree_view), tree_view->priv->hover_path, cursor_column, FALSE);
/* restore the previous selection */
for (lp = rows; lp != NULL; lp = lp->next)
{
gtk_tree_selection_select_path (selection, lp->data);
gtk_tree_path_free (lp->data);
}
g_list_free (rows);
/* check what to do */
if ((gtk_tree_selection_get_mode (selection) == GTK_SELECTION_MULTIPLE ||
(gtk_tree_selection_get_mode (selection) == GTK_SELECTION_SINGLE && hover_path_selected))
&& (tree_view->priv->single_click_timeout_state & GDK_CONTROL_MASK) != 0)
{
/* toggle the selection state of the row */
if (G_UNLIKELY (hover_path_selected))
gtk_tree_selection_unselect_path (selection, tree_view->priv->hover_path);
else
gtk_tree_selection_select_path (selection, tree_view->priv->hover_path);
}
else if (G_UNLIKELY (!hover_path_selected))
{
/* unselect all other rows */
gtk_tree_selection_unselect_all (selection);
/* select only the hover row */
gtk_tree_selection_select_path (selection, tree_view->priv->hover_path);
}
}
/* cleanup */
if (G_LIKELY (cursor_path != NULL))
gtk_tree_path_free (cursor_path);
}
}
//GDK_THREADS_LEAVE ();
return FALSE;
}
static gboolean
exo_tree_view_button_press_event (GtkWidget *widget,
GdkEventButton *event)
{
GtkTreeSelection *selection;
ExoTreeView *tree_view = EXO_TREE_VIEW (widget);
GtkTreePath *path = NULL;
gboolean result;
GList *selected_paths = NULL;
GList *lp;
GtkTreeViewColumn* col;
gboolean treat_as_blank = FALSE;
/* by default we won't emit "row-activated" on button-release-events */
tree_view->priv->button_release_activates = FALSE;
/* grab the tree selection */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
/* be sure to cancel any pending single-click timeout */
if (G_UNLIKELY (tree_view->priv->single_click_timeout_id >= 0))
g_source_remove (tree_view->priv->single_click_timeout_id);
/* check if the button press was on the internal tree view window */
if (G_LIKELY (event->window == gtk_tree_view_get_bin_window (GTK_TREE_VIEW (tree_view))))
{
/* determine the path at the event coordinates */
if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (tree_view), event->x, event->y, &path, &col, NULL, NULL))
path = NULL;
if( tree_view->priv->activable_column && col != tree_view->priv->activable_column )
{
treat_as_blank = TRUE;
if( path )
{
gtk_tree_path_free( path );
path = NULL;
}
gtk_tree_selection_unselect_all (selection);
}
/* we unselect all selected items if the user clicks on an empty
* area of the tree view and no modifier key is active.
*/
if (path == NULL && (event->state & gtk_accelerator_get_default_mod_mask ()) == 0)
gtk_tree_selection_unselect_all (selection);
/* completely ignore double-clicks in single-click mode */
if (tree_view->priv->single_click && event->type == GDK_2BUTTON_PRESS)
{
/* make sure we ignore the GDK_BUTTON_RELEASE
* event for this GDK_2BUTTON_PRESS event.
*/
gtk_tree_path_free (path);
return TRUE;
}
/* check if the next button-release-event should activate the selected row (single click support) */
tree_view->priv->button_release_activates = (tree_view->priv->single_click && event->type == GDK_BUTTON_PRESS && event->button == 1
&& (event->state & gtk_accelerator_get_default_mod_mask ()) == 0);
}
/* unfortunately GtkTreeView will unselect rows except the clicked one,
* which makes dragging from a GtkTreeView problematic. That's why we
* remember the selected paths here and restore them later.
*/
if (event->type == GDK_BUTTON_PRESS && (event->state & gtk_accelerator_get_default_mod_mask ()) == 0
&& path != NULL && gtk_tree_selection_path_is_selected (selection, path))
{
/* if no custom select function is set, we simply use exo_noop_false here,
* to tell the tree view that it may not alter the selection.
*/
//MOD disabled exo_noop_false due to GTK 2.20 bug https://bugzilla.gnome.org/show_bug.cgi?id=612802
/* if (G_LIKELY (selection->user_func == NULL))
gtk_tree_selection_set_select_function (selection, (GtkTreeSelectionFunc) exo_noop_false, NULL, NULL);
else
*/
selected_paths = gtk_tree_selection_get_selected_rows (selection, NULL);
}
/* Rubberbanding in GtkTreeView 2.9.0 and above is rather buggy, unfortunately, and
* doesn't interact properly with GTKs own DnD mechanism. So we need to block all
* dragging here when pressing the mouse button on a not yet selected row if
* rubberbanding is active, or disable rubberbanding when starting a drag.
*/
if (gtk_tree_selection_get_mode (selection) == GTK_SELECTION_MULTIPLE
&& gtk_tree_view_get_rubber_banding (GTK_TREE_VIEW (tree_view))
&& event->button == 1 && event->type == GDK_BUTTON_PRESS)
{
/* check if clicked on empty area or on a not yet selected row */
if (G_LIKELY (path == NULL || !gtk_tree_selection_path_is_selected (selection, path)))
{
/* need to disable drag and drop because we're rubberbanding now */
gpointer drag_data = g_object_get_data (G_OBJECT (tree_view), I_("gtk-site-data"));
if (G_LIKELY (drag_data != NULL))
{
g_signal_handlers_block_matched (G_OBJECT (tree_view),
G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL,
drag_data);
}
/* remember to re-enable drag and drop later */
tree_view->priv->button_release_unblocks_dnd = TRUE;
}
else
{
/* need to disable rubberbanding because we're dragging now */
gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (tree_view), FALSE);
/* remember to re-enable rubberbanding later */
tree_view->priv->button_release_enables_rubber_banding = TRUE;
}
}
/* call the parent's button press handler */
result = (*GTK_WIDGET_CLASS (exo_tree_view_parent_class)->button_press_event) (widget, event);
if( treat_as_blank )
gtk_tree_selection_unselect_all( selection );
/* restore previous selection if the path is still selected */
if (event->type == GDK_BUTTON_PRESS && (event->state & gtk_accelerator_get_default_mod_mask ()) == 0
&& path != NULL && gtk_tree_selection_path_is_selected (selection, path))
{
/* check if we have to restore paths */
if (G_LIKELY (gtk_tree_selection_get_select_function (selection) == (GtkTreeSelectionFunc) exo_noop_false))
{
/* just reset the select function (previously set to exo_noop_false),
* there's no clean way to do this, so what the heck.
*/
gtk_tree_selection_set_select_function (selection, NULL, NULL, NULL);
}
else
{
/* select all previously selected paths */
for (lp = selected_paths; lp != NULL; lp = lp->next)
gtk_tree_selection_select_path (selection, lp->data);
}
}
/* release the path (if any) */
if (G_LIKELY (path != NULL))
gtk_tree_path_free (path);
/* release the selected paths list */
g_list_foreach (selected_paths, (GFunc) gtk_tree_path_free, NULL);
g_list_free (selected_paths);
return result;
}
Php::Value GtkTreeSelection_::get_mode()
{
GtkSelectionMode ret = gtk_tree_selection_get_mode (GTK_TREE_SELECTION(instance));
return ret;
}
