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);
}
