static gboolean cell_renderer_activatable_activate (GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget, const gchar *path_string, const GdkRectangle *background_area, const GdkRectangle *cell_area, GtkCellRendererState flags) { EmpathyCellRendererActivatable *activatable; gint ex, ey, bx, by, bw, bh; activatable = EMPATHY_CELL_RENDERER_ACTIVATABLE (cell); if (!GTK_IS_TREE_VIEW (widget) || event == NULL || event->type != GDK_BUTTON_PRESS) { return FALSE; } ex = (gint) ((GdkEventButton *) event)->x; ey = (gint) ((GdkEventButton *) event)->y; bx = background_area->x; by = background_area->y; bw = background_area->width; bh = background_area->height; if (ex < bx || ex > (bx+bw) || ey < by || ey > (by+bh)) { /* Click wasn't on the icon */ return FALSE; } g_signal_emit (activatable, signals[PATH_ACTIVATED], 0, path_string); return TRUE; }
/** * gwy_grain_value_tree_view_select: * @treeview: A tree view with grain values. * @gvalue: The grain value to select. * * Selects a particular grain value in a grain value tree view. * * If the @gvalue group is currently unexpanded, it will be expanded to * show it, and the tree view may scroll to make it visible. * * Since: 2.8 **/ void gwy_grain_value_tree_view_select(GtkTreeView *treeview, GwyGrainValue *gvalue) { GtkTreeSelection *selection; GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter; g_return_if_fail(GTK_IS_TREE_VIEW(treeview)); g_return_if_fail(GWY_IS_GRAIN_VALUE(gvalue)); g_return_if_fail(priv_quark && g_object_get_qdata(G_OBJECT(treeview), priv_quark)); model = gtk_tree_view_get_model(treeview); if (!find_grain_value(model, gvalue, &iter)) { g_warning("Grain value not in tree model."); return; } path = gtk_tree_model_get_path(model, &iter); gtk_tree_view_expand_to_path(treeview, path); gtk_tree_view_scroll_to_cell(treeview, path, NULL, FALSE, 0.0, 0.0); gtk_tree_path_free(path); selection = gtk_tree_view_get_selection(treeview); gtk_tree_selection_select_iter(selection, &iter); }
void setup(GtkWidget *widget) { GtkWidgetProps props(widget); if (widget && GTK_IS_SCROLLED_WINDOW(widget) && !props->scrolledWindowHacked) { GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(widget); GtkWidget *child; if ((child = gtk_scrolled_window_get_hscrollbar(scrolledWindow))) { setupConnections(child, widget); } if ((child = gtk_scrolled_window_get_vscrollbar(scrolledWindow))) { setupConnections(child, widget); } if ((child = gtk_bin_get_child(GTK_BIN(widget)))) { if (GTK_IS_TREE_VIEW(child) || GTK_IS_TEXT_VIEW(child) || GTK_IS_ICON_VIEW(child)) { setupConnections(child, widget); } else if (oneOf(gTypeName(child), "ExoIconView", "FMIconContainer")) { setupConnections(child, widget); } } props->scrolledWindowHacked = true; } }
static void on_name_field_changed (GtkEditable *editable, gpointer user_data) { GtkTreeIter iter; g_return_if_fail(GTK_IS_TREE_VIEW(bookmark_list_widget)); g_return_if_fail(GTK_IS_ENTRY(name_field)); if (!get_selection_exists()) return; /* Update text displayed in list instantly. Also remember that * user has changed text so we update real bookmark later. */ gtk_tree_selection_get_selected (bookmark_selection, NULL, &iter); gtk_list_store_set (bookmark_list_store, &iter, BOOKMARK_LIST_COLUMN_NAME, gtk_entry_get_text (GTK_ENTRY (name_field)), -1); text_changed = TRUE; name_text_changed = TRUE; }
static gboolean tree_view_button_press(GtkWidget *widget, GdkEventButton *event, gpointer data) { UIMCandWinVerticalGtk *vertical_cwin; UIMCandWinGtk *cwin; GtkTreePath *path; gboolean exist, retval = FALSE; gint *indicies; g_return_val_if_fail(GTK_IS_TREE_VIEW(widget), FALSE); g_return_val_if_fail(UIM_CAND_WIN_VERTICAL_GTK(data), FALSE); vertical_cwin = UIM_CAND_WIN_VERTICAL_GTK(data); cwin = UIM_CAND_WIN_GTK(vertical_cwin); exist = gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), event->x, event->y, &path, NULL, NULL, NULL); if (!exist) return FALSE; indicies = gtk_tree_path_get_indices(path); /* don't relay button press event to empty row */ if (cwin->display_limit * cwin->page_index + *indicies >= cwin->nr_candidates) retval = TRUE; gtk_tree_path_free(path); return retval; }
static gboolean qtcTreeViewLeave(GtkWidget *widget, GdkEventMotion *event, void *data) { QTC_UNUSED(event); QTC_UNUSED(data); if (GTK_IS_TREE_VIEW(widget)) { QtCTreeView *tv = qtcTreeViewLookupHash(widget, false); if (tv) { GtkTreeView *treeView = GTK_TREE_VIEW(widget); QtcRect rect = {0, 0, -1, -1 }; QtcRect alloc = qtcWidgetGetAllocation(widget); if (tv->path && tv->column) { gtk_tree_view_get_background_area( treeView, tv->path, tv->column, (GdkRectangle*)&rect); } if (tv->fullWidth) { rect.x = 0; rect.width = alloc.width; } if (tv->path) { gtk_tree_path_free(tv->path); } tv->path = NULL; tv->column = NULL; gtk_tree_view_convert_bin_window_to_widget_coords( treeView, rect.x, rect.y, &rect.x, &rect.y); gtk_widget_queue_draw_area( widget, rect.x, rect.y, rect.width, rect.height); } } return false; }
/* Get a new thumbnail region of GtkTreeView widget in which event falls. It is an error to call this function if !in_thumbnail (widget, event). */ static GdkRegion * thumbnail_region (GtkWidget *widget, GdkEventMotion *event) { g_assert (GTK_IS_TREE_VIEW (widget)); g_assert (in_thumbnail (widget, event)); GtkTreePath *tp = thumbnail_path (widget, event); g_assert (tp != NULL); /* Rectangle of region to be returned. */ GdkRectangle tn_rect; /* If over the input image thumbnail, return the input thumbnail region, */ GtkTreeViewColumn *tc = NULL; /* Thumbnail column we are over. */ if ( in_input_thumbnail (widget, event) ) { tc = input_thumbnail_column (widget, event); } gtk_tree_view_get_cell_area (GTK_TREE_VIEW (widget), tp, tc, &tn_rect); /* Here we depend on the fact that the thumbnails are packed at the beginning of the cell horizontally, and centered in the cell vertically (FIXME: find a way to verify this with assertions). */ GdkRectangle itn_rect; /* Image thumbnail rectangle. */ /* FIXME: fix this border hackery to be precise somehow. */ itn_rect.x = tn_rect.x + 1; /* There is probably a small border so +1. */ itn_rect.y = tn_rect.y + 1; itn_rect.width = THUMB_SIZE; itn_rect.height = THUMB_SIZE; return gdk_region_rectangle (&itn_rect); }
static void set_role_for_button (AtkObject *accessible, GtkWidget *button) { GtkWidget *parent; AtkRole role; parent = gtk_widget_get_parent (button); if (GTK_IS_TREE_VIEW (parent)) { role = ATK_ROLE_TABLE_COLUMN_HEADER; /* * Even though the accessible parent of the column header will * be reported as the table because the parent widget of the * GtkTreeViewColumn's button is the GtkTreeView we set * the accessible parent for column header to be the table * to ensure that atk_object_get_index_in_parent() returns * the correct value; see gail_widget_get_index_in_parent(). */ atk_object_set_parent (accessible, gtk_widget_get_accessible (parent)); } else role = ATK_ROLE_PUSH_BUTTON; accessible->role = role; }
static void gmpc_meta_data_widgets_similar_songs_tree_row_activated (GmpcMetaDataWidgetsSimilarSongs* self, GtkWidget* tree, GtkTreePath* path, GtkTreeViewColumn* column) { GtkWidget* _tmp0_; GtkTreeModel* _tmp1_ = NULL; GtkTreeModel* _tmp2_; GtkTreeModel* model; GtkTreeIter iter = {0}; GtkTreeIter _tmp3_ = {0}; gboolean _tmp4_; g_return_if_fail (self != NULL); g_return_if_fail (tree != NULL); g_return_if_fail (path != NULL); g_return_if_fail (column != NULL); _tmp0_ = tree; _tmp1_ = gtk_tree_view_get_model (GTK_IS_TREE_VIEW (_tmp0_) ? ((GtkTreeView*) _tmp0_) : NULL); _tmp2_ = _g_object_ref0 (_tmp1_); model = _tmp2_; _tmp4_ = gtk_tree_model_get_iter (model, &_tmp3_, path); iter = _tmp3_; if (_tmp4_) { const mpd_Song* song; song = NULL; gtk_tree_model_get (model, &iter, 0, &song, -1, -1); if (song != NULL) { play_path (song->file); } } _g_object_unref0 (model); }
void bastile_gkr_item_properties_show (BastileGkrItem *git, GtkWindow *parent) { BastileObject *object = BASTILE_OBJECT (git); BastileWidget *swidget = NULL; GtkWidget *widget; swidget = bastile_object_widget_new ("gkr-item-properties", parent, object); /* This happens if the window is already open */ if (swidget == NULL) return; bastile_object_refresh (object); widget = GTK_WIDGET (bastile_widget_get_widget (swidget, swidget->name)); g_signal_connect (widget, "response", G_CALLBACK (properties_response), swidget); /* * The signals don't need to keep getting connected. Everytime a key changes the * do_* functions get called. Therefore, seperate functions connect the signals * have been created */ setup_main (swidget); setup_details (swidget); setup_application (swidget); widget = bastile_widget_get_widget (swidget, "application-list"); g_return_if_fail (GTK_IS_TREE_VIEW (widget)); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)), "changed", G_CALLBACK (application_selection_changed), swidget); }
static gboolean empathy_cell_renderer_expander_activate (GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget, const gchar *path_string, const GdkRectangle *background_area, const GdkRectangle *cell_area, GtkCellRendererState flags) { EmpathyCellRendererExpanderPriv *priv; GtkTreePath *path; priv = GET_PRIV (cell); if (!GTK_IS_TREE_VIEW (widget) || !priv->activatable) return FALSE; path = gtk_tree_path_new_from_string (path_string); if (gtk_tree_path_get_depth (path) > 1) { gtk_tree_path_free (path); return TRUE; } if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (widget), path)) { gtk_tree_view_collapse_row (GTK_TREE_VIEW (widget), path); } else { gtk_tree_view_expand_row (GTK_TREE_VIEW (widget), path, FALSE); } gtk_tree_path_free (path); return TRUE; }
GObject * seahorse_key_manager_store_get_selected_object (GtkTreeView *view) { SeahorseKeyManagerStore* skstore; GObject *obj = NULL; GList *paths = NULL; GtkTreeSelection *selection; g_return_val_if_fail (GTK_IS_TREE_VIEW (view), NULL); skstore = SEAHORSE_KEY_MANAGER_STORE (gtk_tree_view_get_model (view)); g_return_val_if_fail (SEAHORSE_IS_KEY_MANAGER_STORE (skstore), NULL); selection = gtk_tree_view_get_selection (view); paths = gtk_tree_selection_get_selected_rows (selection, NULL); /* choose first object */ if (paths != NULL) { obj = seahorse_key_manager_store_get_object_from_path (view, paths->data); /* free selected paths */ g_list_foreach (paths, (GFunc)gtk_tree_path_free, NULL); g_list_free (paths); } return obj; }
void seahorse_key_manager_store_set_selected_objects (GtkTreeView *view, GList* objects) { SeahorseKeyManagerStore* skstore; GtkTreeSelection* selection; gboolean first = TRUE; GtkTreePath *path; GList *l; GtkTreeIter iter; g_return_if_fail (GTK_IS_TREE_VIEW (view)); selection = gtk_tree_view_get_selection (view); gtk_tree_selection_unselect_all (selection); skstore = SEAHORSE_KEY_MANAGER_STORE (gtk_tree_view_get_model (view)); g_return_if_fail (SEAHORSE_IS_KEY_MANAGER_STORE (skstore)); for (l = objects; l; l = g_list_next (l)) { if (gcr_collection_model_iter_for_object (GCR_COLLECTION_MODEL (skstore), l->data, &iter)) { gtk_tree_selection_select_iter (selection, &iter); /* Scroll the first row selected into view */ if (first) { path = gtk_tree_model_get_path (gtk_tree_view_get_model (view), &iter); gtk_tree_view_scroll_to_cell (view, path, NULL, FALSE, 0.0, 0.0); gtk_tree_path_free (path); first = FALSE; } } } }
/** * cact_providers_list_init_view: * @window: the parent #BaseWindow which embeds the view. * @treeview: the #GtkTreeView. * * Connects signals at runtime initialization of the widget, and setup * current default values. */ void cact_providers_list_init_view( BaseWindow *window, GtkTreeView *treeview ) { static const gchar *thisfn = "cact_providers_list_init_view"; ProvidersListData *data; CactApplication *application; NAUpdater *updater; g_return_if_fail( BASE_IS_WINDOW( window )); g_return_if_fail( GTK_IS_TREE_VIEW( treeview )); g_debug( "%s: treeview=%p, window=%p", thisfn, ( void * ) treeview, ( void * ) window ); g_object_set_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW, treeview ); data = get_providers_list_data( treeview ); data->window = window; application = CACT_APPLICATION( base_window_get_application( window )); updater = cact_application_get_updater( application ); data->preferences_locked = na_updater_are_preferences_locked( updater ); init_view_setup_providers( treeview, window ); init_view_connect_signals( treeview, window ); init_view_select_first_row( treeview ); }
void baobab_treeview_show_allocated_size (GtkWidget *tv, gboolean show_allocated) { gint sort_id; gint new_sort_id; GtkSortType order; GtkTreeViewColumn *size_col; g_return_if_fail (GTK_IS_TREE_VIEW (tv)); gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (baobab.model), &sort_id, &order); /* set the sort id for the size column */ size_col = g_object_get_data (G_OBJECT (tv), "baobab_size_col"); new_sort_id = show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE; gtk_tree_view_column_set_sort_column_id (size_col, new_sort_id); /* if we are currently sorted on size or allocated size, * then trigger a resort (with the same order) */ if (sort_id == COL_H_SIZE || sort_id == COL_H_ALLOCSIZE) { gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (baobab.model), new_sort_id, order); } }
/** * rb_tree_dnd_add_drag_source_support: * @tree_view: a #GtkTreeView that wants to be a drag source * @start_button_mask: a mask describing modifier keys to handle when dragging * @targets: an array of #GtkTargetEntry structures describing drag data types * @n_targets: the number of elements in @targets * @actions: a mask describing drag actions that are allowed from this source * * Adds event handlers to perform multi-row drag and drop operations from the * specified #GtkTreeView widget. The model backing the #GtkTreeView must * implement the #RbTreeDragSource interface. This should be called immediately * after the tree view is created. */ void rb_tree_dnd_add_drag_source_support (GtkTreeView *tree_view, GdkModifierType start_button_mask, const GtkTargetEntry *targets, gint n_targets, GdkDragAction actions) { RbTreeDndData *priv_data = NULL; g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); priv_data = init_rb_tree_dnd_data (GTK_WIDGET(tree_view)); if (!priv_data->button_press_event_handler) { priv_data->source_target_list = gtk_target_list_new (targets, n_targets); priv_data->source_actions = actions; priv_data->start_button_mask = start_button_mask; priv_data->button_press_event_handler = g_signal_connect (G_OBJECT (tree_view), "button_press_event", G_CALLBACK (rb_tree_dnd_button_press_event_cb), NULL); priv_data->drag_data_get_handler = g_signal_connect (G_OBJECT (tree_view), "drag_data_get", G_CALLBACK (rb_tree_dnd_drag_data_get_cb), NULL); priv_data->drag_data_delete_handler = g_signal_connect (G_OBJECT (tree_view), "drag_data_delete", G_CALLBACK (rb_tree_dnd_drag_data_delete_cb), NULL); } }
/* Set tree of the tree-store. This includes getting the folder tree and * storing it */ static void foldercheck_set_tree(SpecificFolderArrayEntry *entry) { Folder *folder; GList *list; for(list = folder_get_list(); list != NULL; list = list->next) { folder = FOLDER(list->data); if(folder == NULL) { debug_print("Notification plugin::foldercheck_set_tree(): Found a NULL folder.\n"); continue; } /* Only regard built-in folders, because folders from plugins (such as RSS, calendar, * or plugin-provided mailbox storage systems like Maildir or MBox) may vanish * without letting us know. */ switch(folder->klass->type) { case F_MH: case F_IMAP: case F_NEWS: foldercheck_insert_gnode_in_store(entry->tree_store, folder->node, NULL); break; default: break; } } gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(entry->tree_store), FOLDERCHECK_FOLDERNAME, GTK_SORT_ASCENDING); if(GTK_IS_TREE_VIEW(entry->treeview)) gtk_tree_view_expand_all(GTK_TREE_VIEW(entry->treeview)); }
/** * gel_ui_tree_view_get_selected_indices: * @tv: A #GtkTreeView * * Returns a %NULL terminated array of gint with the indices of selected * rows, only works with a #GtkTreeView holding a #GtkListModel * * Returns: (allow-none) (transfer full): The selected indices, each index and the value * it self must be freeed with g_free */ gint * gel_ui_tree_view_get_selected_indices(GtkTreeView *tv) { g_return_val_if_fail(GTK_IS_TREE_VIEW(tv), NULL); g_return_val_if_fail(GTK_IS_LIST_STORE(gtk_tree_view_get_model(tv)), NULL); GtkTreeSelection *selection = gtk_tree_view_get_selection(tv); GtkTreeModel *model = gtk_tree_view_get_model(tv); GList *l, *iter; // iter over selected treepaths gint *indices; // hold treepath's indices gint i = 0; // index l = iter = gtk_tree_selection_get_selected_rows(selection, &model); gint *ret = g_new0(gint, g_list_length(l) + 1); while (iter) { indices = gtk_tree_path_get_indices((GtkTreePath *) iter->data); if (!indices || !indices[0] || !indices[1] || (indices[1] != -1)) { g_warning(_("Invalid GtkTreePath in selection, use %s only with ListModels"), __FUNCTION__); continue; } ret[i++] = indices[0]; l = l->next; } g_list_foreach(l, (GFunc) gtk_tree_path_free, NULL); g_list_free(l); return ret; }
static gboolean in_input_thumbnail (GtkWidget *widget, GdkEventMotion *event) { g_assert (GTK_IS_TREE_VIEW (widget)); gboolean result = FALSE; /* Result to be returned. */ GtkTreePath *tp = thumbnail_path (widget, event); if ( tp == NULL ) { return FALSE; /* Pointer is not over a filled in row. */ } /* Check if we are over the input image thumbnail. */ GtkTreeViewColumn *itc = input_thumbnail_column (widget, event); GdkRectangle itnc_rect; /* Input thumbnail cell rectangle. */ gtk_tree_view_get_cell_area (GTK_TREE_VIEW (widget), tp, itc, &itnc_rect); /* Here we depend on the fact that the input thumbnail is packed at the beginning of the cell horizontally, and centered in the cell vertically (FIXME: find a way to verify this with assertions). */ GdkRectangle itn_rect; /* Input thumbnail rectangle. */ /* FIXME: fix this border hackery to be precise somehow. */ itn_rect.x = itnc_rect.x + 1; /* There is probably a small border so +1. */ itn_rect.y = itnc_rect.y + 1; itn_rect.width = THUMB_SIZE; itn_rect.height = THUMB_SIZE; GdkRegion *itn_region = gdk_region_rectangle (&itn_rect); if ( gdk_region_point_in (itn_region, (int) event->x, (int) event->y) ) { result = TRUE; // g_message ("Over input thumbnail!"); } gdk_region_destroy (itn_region); return result; }
static gboolean gm_cell_renderer_expander_activate (GtkCellRenderer *cell, G_GNUC_UNUSED GdkEvent *event, GtkWidget *widget, const gchar *path_string, G_GNUC_UNUSED const GdkRectangle *background_area, G_GNUC_UNUSED const GdkRectangle *cell_area, G_GNUC_UNUSED GtkCellRendererState flags) { GmCellRendererExpander *expander; GmCellRendererExpanderPriv *priv; GtkTreePath *path; expander = (GmCellRendererExpander *) cell; priv = expander->priv; if (!GTK_IS_TREE_VIEW (widget) || !priv->activatable) return FALSE; path = gtk_tree_path_new_from_string (path_string); if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (widget), path)) { gtk_tree_view_collapse_row (GTK_TREE_VIEW (widget), path); } else { gtk_tree_view_expand_row (GTK_TREE_VIEW (widget), path, FALSE); } gtk_tree_path_free (path); return TRUE; }
/** * cryptui_key_store_have_selected_keys: * @ckstore: a libcryptui key store * @view: a GtkTreeView * * Determines whether keys are selected or not. * * Returns: TRUE if keys have been selected, FALSE otherwise */ gboolean cryptui_key_store_have_selected_keys (CryptUIKeyStore *ckstore, GtkTreeView *view) { GtkTreeSelection *selection; g_return_val_if_fail (CRYPTUI_IS_KEY_STORE (ckstore), FALSE); g_return_val_if_fail (GTK_IS_TREE_VIEW (view), FALSE); if (ckstore->priv->use_checks) { GtkTreeModel* model = GTK_TREE_MODEL (ckstore->priv->store); GtkTreeIter iter; gboolean check; if (gtk_tree_model_get_iter_first (model, &iter)) { do { check = FALSE; gtk_tree_model_get (model, &iter, CRYPTUI_KEY_STORE_CHECK, &check, -1); if (check) return TRUE; } while (gtk_tree_model_iter_next (model, &iter)); } } else { /* Fall back if none checked, or not using checks */ selection = gtk_tree_view_get_selection (view); if (gtk_tree_selection_count_selected_rows (selection)) return TRUE; } return FALSE; }
static void edited_callback (GtkCellRendererText *renderer, const gchar *path_string, const gchar *new_text, GtkTreeView *tree_view) { GtkTreeModel *model = NULL; GtkTreeModelSort *sort_model = NULL; GtkTreePath *path; GtkTreeIter iter; guint value = atoi (new_text); g_return_if_fail (GTK_IS_TREE_VIEW (tree_view)); model = gtk_tree_view_get_model (tree_view); if (GTK_IS_TREE_MODEL_SORT (model)) { sort_model = GTK_TREE_MODEL_SORT (model); model = gtk_tree_model_sort_get_model (sort_model); } if (model == NULL) return; if (sort_model) { g_warning ("FIXME implement conversion from TreeModelSort iter to child model iter"); return; } path = gtk_tree_path_new_from_string (path_string); if (!gtk_tree_model_get_iter (model, &iter, path)) { g_warning ("%s: bad path?", G_STRLOC); return; } gtk_tree_path_free (path); if (GTK_IS_LIST_STORE (model)) { gtk_list_store_set (GTK_LIST_STORE (model), &iter, 4, value, -1); } else if (GTK_IS_TREE_STORE (model)) { gtk_tree_store_set (GTK_TREE_STORE (model), &iter, 4, value, -1); } else g_warning ("don't know how to actually toggle value for model type %s", g_type_name (G_TYPE_FROM_INSTANCE (model))); }
static void bookmarks_delete_bookmark (void) { GtkTreeIter iter; GtkTreePath *path; gint *indices, row, rows; g_assert (GTK_IS_TREE_VIEW (bookmark_list_widget)); if (!gtk_tree_selection_get_selected (bookmark_selection, NULL, &iter)) return; /* Remove the selected item from the list store. on_row_deleted() will remove it from the bookmark list. */ path = gtk_tree_model_get_path (GTK_TREE_MODEL (bookmark_list_store), &iter); indices = gtk_tree_path_get_indices (path); row = indices[0]; gtk_tree_path_free (path); gtk_list_store_remove (bookmark_list_store, &iter); /* Try to select the same row, or the last one in the list. */ rows = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (bookmark_list_store), NULL); if (row >= rows) row = rows - 1; if (row < 0) { bookmarks_set_empty (TRUE); } else { gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (bookmark_list_store), &iter, NULL, row); gtk_tree_selection_select_iter (bookmark_selection, &iter); } }
void qtcScrolledWindowSetup(GtkWidget *widget) { if (widget && GTK_IS_SCROLLED_WINDOW(widget) && !g_object_get_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_SET")) { GtkScrolledWindow *scrolledWindow=GTK_SCROLLED_WINDOW(widget); GtkWidget *child; if((child=gtk_scrolled_window_get_hscrollbar(scrolledWindow))) qtcScrolledWindowSetupConnections(child, widget); if((child=gtk_scrolled_window_get_vscrollbar(scrolledWindow))) qtcScrolledWindowSetupConnections(child, widget); if((child=gtk_bin_get_child(GTK_BIN(widget)))) { if(GTK_IS_TREE_VIEW(child) || GTK_IS_TEXT_VIEW(child) || GTK_IS_ICON_VIEW(child)) qtcScrolledWindowSetupConnections(child, widget); else { const gchar *type=g_type_name(qtcWidgetType(child)); if(type && (0==strcmp(type, "ExoIconView") || 0==strcmp(type, "FMIconContainer"))) qtcScrolledWindowSetupConnections(child, widget); } } g_object_set_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_SET", (gpointer)1); } }
/** * gwy_grain_value_tree_view_get_expanded_groups: * @treeview: A tree view with grain values. * * Obtains the group expansion state of a grain value tree view. * * Returns: The expansion state, see * gwy_grain_value_tree_view_set_expanded_groups() for details. * * Since: 2.8 **/ guint gwy_grain_value_tree_view_get_expanded_groups(GtkTreeView *treeview) { GtkTreeModel *model; GtkTreeIter siter; guint expanded_bits = 0; g_return_val_if_fail(GTK_IS_TREE_VIEW(treeview), 0); g_return_val_if_fail(priv_quark && g_object_get_qdata(G_OBJECT(treeview), priv_quark), 0); model = gtk_tree_view_get_model(treeview); if (!gtk_tree_model_get_iter_first(model, &siter)) { g_warning("Grain value tree view is empty?!"); return 0; } do { GwyGrainValueGroup group; GtkTreePath *path; gtk_tree_model_get(model, &siter, GWY_GRAIN_VALUE_STORE_COLUMN_GROUP, &group, -1); path = gtk_tree_model_get_path(model, &siter); if (gtk_tree_view_row_expanded(treeview, path)) expanded_bits |= (1 << group); gtk_tree_path_free(path); } while (gtk_tree_model_iter_next(model, &siter)); return expanded_bits; }
/* copied from uim-cand-win-gtk.c */ static gboolean tree_view_button_press(GtkWidget *widget, GdkEventButton *event, gpointer data) { GtkTreePath *path; gboolean exist, retval = FALSE; gint *indicies; fprintf(stderr, "tree_view_button_press\n"); g_return_val_if_fail(GTK_IS_TREE_VIEW(widget), FALSE); g_return_val_if_fail(UIM_CANDIDATE_WINDOW(data), FALSE); /* cwin = UIM_CANDIDATE_WINDOW(data); */ exist = gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), event->x, event->y, &path, NULL, NULL, NULL); if (!exist) return FALSE; indicies = gtk_tree_path_get_indices(path); /* don't relay button press event to empty row */ if (cwin->display_limit * cwin->page_index + *indicies >= cwin->nr_candidates) retval = TRUE; gtk_tree_path_free(path); return retval; }
/************************************************************************** Mouse button press handler for the message window treeview. We only care about right clicks on a row; this action centers on the tile associated with the event at that row (if applicable). **************************************************************************/ static gboolean meswin_button_press_callback(GtkWidget *widget, GdkEventButton *ev, gpointer data) { GtkTreePath *path = NULL; GtkTreeModel *model; GtkTreeIter iter; gint row; g_return_val_if_fail(GTK_IS_TREE_VIEW(widget), FALSE); if (ev->type != GDK_BUTTON_PRESS || ev->button != 3) { return FALSE; } if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), (gint) ev->x, (gint) ev->y, &path, NULL, NULL, NULL)) { return TRUE; } model = gtk_tree_view_get_model(GTK_TREE_VIEW(widget)); if (gtk_tree_model_get_iter(model, &iter, path)) { gtk_tree_model_get(model, &iter, 2, &row, -1); meswin_goto(row); } gtk_tree_path_free(path); return TRUE; }
/************************************************************************** Convenience function to add a column to a GtkTreeView. Returns the added column, or NULL if an error occurred. **************************************************************************/ GtkTreeViewColumn *add_treeview_column(GtkWidget *view, const char *title, GType gtype, int model_index) { GtkTreeViewColumn *col; GtkCellRenderer *rend; const char *attr; fc_assert_ret_val(view != NULL, NULL); fc_assert_ret_val(GTK_IS_TREE_VIEW(view), NULL); fc_assert_ret_val(title != NULL, NULL); if (gtype == G_TYPE_BOOLEAN) { rend = gtk_cell_renderer_toggle_new(); attr = "active"; } else if (gtype == GDK_TYPE_PIXBUF) { rend = gtk_cell_renderer_pixbuf_new(); attr = "pixbuf"; } else { rend = gtk_cell_renderer_text_new(); attr = "text"; } col = gtk_tree_view_column_new_with_attributes(title, rend, attr, model_index, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), col); return col; }
static void gtk_button_accessible_initialize (AtkObject *obj, gpointer data) { GtkWidget *parent; ATK_OBJECT_CLASS (gtk_button_accessible_parent_class)->initialize (obj, data); g_signal_connect (data, "state-flags-changed", G_CALLBACK (state_changed_cb), NULL); parent = gtk_widget_get_parent (gtk_accessible_get_widget (GTK_ACCESSIBLE (obj))); if (GTK_IS_TREE_VIEW (parent)) { /* Even though the accessible parent of the column header will * be reported as the table because the parent widget of the * GtkTreeViewColumn's button is the GtkTreeView we set * the accessible parent for column header to be the table * to ensure that atk_object_get_index_in_parent() returns * the correct value; see gail_widget_get_index_in_parent(). */ atk_object_set_parent (obj, gtk_widget_get_accessible (parent)); obj->role = ATK_ROLE_TABLE_COLUMN_HEADER; } else obj->role = ATK_ROLE_PUSH_BUTTON; }
void uim_cand_win_gtk_layout(UIMCandWinGtk *cwin, gint topwin_x, gint topwin_y, gint topwin_width, gint topwin_height) { GtkRequisition req; int x, y; int cursor_x, cursor_y; int sc_he, cw_he; /*screen height, candidate window height*/ int sc_wi, cw_wi; g_return_if_fail(UIM_IS_CAND_WIN_GTK(cwin)); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_get_preferred_size(GTK_WIDGET(cwin), &req, NULL); #else gtk_widget_size_request(GTK_WIDGET(cwin), &req); #endif cw_wi = req.width; cw_he = req.height; sc_he = gdk_screen_get_height(gdk_screen_get_default ()); sc_wi = gdk_screen_get_width (gdk_screen_get_default ()); /* FIXME */ switch (cwin->position) { case UIM_CAND_WIN_POS_LEFT: cursor_x = 0; break; case UIM_CAND_WIN_POS_RIGHT: cursor_x = topwin_width - cw_wi; break; default: cursor_x = cwin->cursor.x; break; } cursor_y = cwin->cursor.y; if (sc_wi < topwin_x + cursor_x + cw_wi) { /* x = topwin_x + cursor_x - cw_wi; */ x = sc_wi - cw_wi; } else { x = topwin_x + cursor_x; } if (sc_he < topwin_y + cursor_y + cwin->cursor.height + cw_he) { y = topwin_y + cursor_y - cw_he; } else { y = topwin_y + cursor_y + cwin->cursor.height; } gtk_window_move(GTK_WINDOW(cwin), x, y); #if GTK_CHECK_VERSION(3, 7, 8) if (gtk_widget_get_mapped(cwin->view) && GTK_IS_TREE_VIEW(cwin->view)) gtk_widget_queue_resize_no_redraw(cwin->view); #endif uim_cand_win_gtk_layout_sub_window(cwin); }