static void
_gtk_user_list_dialog_tree_checkbox_toggled(GtkCellRendererToggle *renderer, gchar *path, GtkTreeView *widget)
{
GtkUserListDialogPrivate *priv;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeIter child;
g_assert(GTK_IS_DELETABLE_DIALOG(widget));
priv = GTK_USER_LIST_DIALOG(widget)->priv;
if(priv->checkbox_column_activatable)
{
model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->tree));
if(gtk_tree_model_get_iter_from_string(model, &iter, path))
{
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(model), &child, &iter);
model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model));
gtk_list_store_set(GTK_LIST_STORE(model),
&child,
GTK_USER_LIST_TREEVIEW_COLUMN_CHECKBOX,
gtk_cell_renderer_toggle_get_active(renderer) ? FALSE : TRUE,
-1);
}
}
}
/*
* Retrieve the selected commodity from an commodity tree view. The
* commodity tree must be in single selection mode.
*/
gnc_commodity *
gnc_tree_view_commodity_get_selected_commodity (GncTreeViewCommodity *view)
{
GtkTreeSelection *selection;
GtkTreeModel *model, *f_model, *s_model;
GtkTreeIter iter, f_iter, s_iter;
gnc_commodity *commodity;
g_return_val_if_fail (GNC_IS_TREE_VIEW_COMMODITY (view), NULL);
ENTER("view %p", view);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
if (!gtk_tree_selection_get_selected (selection, &s_model, &s_iter))
{
LEAVE("no commodity, 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);
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
commodity = gnc_tree_model_commodity_get_commodity (GNC_TREE_MODEL_COMMODITY(model),
&iter);
LEAVE("commodity %p (%s)", commodity,
commodity ? gnc_commodity_get_mnemonic(commodity) : "");
return commodity;
}
/*
* Retrieve the selected price from an price tree view. The
* price tree must be in single selection mode.
*/
GNCPrice *
gnc_tree_view_price_get_selected_price (GncTreeViewPrice *view)
{
GtkTreeSelection *selection;
GtkTreeModel *model, *f_model, *s_model;
GtkTreeIter iter, f_iter, s_iter;
GNCPrice *price;
ENTER("view %p", view);
g_return_val_if_fail (GNC_IS_TREE_VIEW_PRICE (view), NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
if (!gtk_tree_selection_get_selected (selection, &s_model, &s_iter))
{
LEAVE("no price, 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);
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
price = gnc_tree_model_price_get_price (GNC_TREE_MODEL_PRICE(model),
&iter);
LEAVE("price %p", price);
return price;
}
static gboolean
file_view_key_press_event (GtkWidget* widget, GdkEventKey* event)
{
if (event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_KP_Enter)
{
AnjutaFileView* view = ANJUTA_FILE_VIEW (widget);
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (view);
GtkTreeIter selected;
GtkTreeSelection* selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
if (gtk_tree_selection_get_selected (selection, NULL, &selected))
{
GFile* file;
GtkTreeIter select_iter;
GtkTreeModel* sort_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(sort_model),
&select_iter, &selected);
file = file_model_get_file (priv->model, &select_iter);
if (file != NULL)
{
g_signal_emit_by_name (G_OBJECT (view),
"file-open",
file);
g_object_unref (file);
}
}
}
return
GTK_WIDGET_CLASS (file_view_parent_class)->key_press_event (widget,
event);
}
static gboolean
file_view_query_tooltip (GtkWidget* widget, gint x, gint y, gboolean keyboard,
GtkTooltip* tooltip)
{
AnjutaFileView* view = ANJUTA_FILE_VIEW (widget);
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (view);
GtkTreeModel* model_sort;
GtkTreeModel* file_model = GTK_TREE_MODEL (priv->model);
GtkTreePath* path;
GtkTreeIter iter;
GtkTreeIter real_iter;
gchar* filename;
gboolean result = TRUE;
GdkRectangle visible_rect, column_rect;
GdkScreen *screen = gdk_screen_get_default ();
PangoContext *context;
PangoLayout *layout;
gint width, height;
if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (view),
&x, &y, keyboard,
&model_sort,
&path,
&iter))
return FALSE;
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model_sort),
&real_iter, &iter);
filename = file_model_get_filename (FILE_MODEL (file_model), &real_iter);
context = gdk_pango_context_get_for_screen (screen);
layout = pango_layout_new (context);
pango_layout_set_text (layout, filename, -1);
pango_layout_get_pixel_size (layout, &width, &height);
gtk_tree_view_get_visible_rect (GTK_TREE_VIEW (view), &visible_rect);
gtk_tree_view_get_cell_area (GTK_TREE_VIEW (view), path,
gtk_tree_view_get_column (GTK_TREE_VIEW (view), 0), &column_rect);
if (column_rect.x + width > visible_rect.x + visible_rect.width ||
column_rect.x < visible_rect.x)
{
gtk_tooltip_set_text (tooltip, filename);
gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (view),
tooltip,
path);
} else
{
result = FALSE;
}
g_free (filename);
gtk_tree_path_free (path);
g_object_unref (layout);
g_object_unref (context);
return result;
}
static void
shortcuts_accel_cleared_cb (GtkCellRenderer* renderer,
const gchar* tree_path,
GtkTreeModel* model)
{
GtkTreeIter iter;
if (gtk_tree_model_get_iter_from_string (model, &iter, tree_path))
{
GtkAction* action;
const gchar* accel_path;
GtkTreeIter child_iter;
GtkTreeModel* liststore;
gtk_tree_model_get (model, &iter, 6, &action, -1);
accel_path = gtk_action_get_accel_path (action);
gtk_accel_map_change_entry (accel_path, 0, 0, FALSE);
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model),
&child_iter, &iter);
liststore = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (model));
gtk_list_store_set (GTK_LIST_STORE (liststore),
&child_iter, 1, 0, 2, 0, -1);
g_object_unref (action);
}
}
int
_pygtk_tree_model_remove_row(GtkTreeModel *model, GtkTreeIter *iter)
{
GtkTreeModel *child;
GtkTreeIter citer;
if (GTK_IS_LIST_STORE(model)) {
gtk_list_store_remove(GTK_LIST_STORE(model), iter);
return 0;
}
if (GTK_IS_TREE_STORE(model)) {
gtk_tree_store_remove(GTK_TREE_STORE(model), iter);
return 0;
}
if (GTK_IS_TREE_MODEL_SORT(model)) {
child = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model));
gtk_tree_model_sort_convert_iter_to_child_iter(
GTK_TREE_MODEL_SORT(model), &citer, iter);
return _pygtk_tree_model_remove_row(child, &citer);
}
if (GTK_IS_TREE_MODEL_FILTER(model)) {
child = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
gtk_tree_model_filter_convert_iter_to_child_iter(
GTK_TREE_MODEL_FILTER(model), &citer, iter);
return _pygtk_tree_model_remove_row(child, &citer);
}
PyErr_SetString(PyExc_TypeError,
"cannot remove rows in this tree model");
return -1;
}
/*
* 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;
}
/*
* This helper function is called once for each row in the tree view
* that is currently selected. Its task is to append the corresponding
* owner to the end of a glist.
*/
static void
get_selected_owners_helper (GtkTreeModel *s_model,
GtkTreePath *s_path,
GtkTreeIter *s_iter,
gpointer data)
{
GncTreeViewSelectionInfo *gtvsi = data;
GtkTreeModel *f_model;
GtkTreeIter iter, f_iter;
GncOwner *owner;
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;
/* Only selected if it passes the filter */
if (gtvsi->priv->filter_fn == NULL || gtvsi->priv->filter_fn(owner, gtvsi->priv->filter_data))
{
gtvsi->return_list = g_list_append(gtvsi->return_list, owner);
}
}
GncOwner *
gnc_tree_view_owner_get_owner_from_iter (GtkTreeModel *s_model,
GtkTreeIter *s_iter)
{
GtkTreeModel *model, *f_model;
GtkTreeIter iter, f_iter;
GncOwner *owner;
g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT(s_model), NULL);
g_return_val_if_fail (s_iter != NULL, NULL);
ENTER("model %p, iter %p", s_model, s_iter);
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);
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
owner = gnc_tree_model_owner_get_owner (
GNC_TREE_MODEL_OWNER(model), &iter);
LEAVE("owner %p (%s)", owner, gncOwnerGetName (owner));
return owner;
}
static void
cell_renderer_edited (GtkCellRendererText *cell,
const char *path_str,
const char *new_text,
EphyNodeView *view)
{
GtkTreePath *path;
GtkTreeIter iter, iter2;
EphyNode *node;
view->priv->edited_node = NULL;
g_object_set (G_OBJECT (view->priv->editable_renderer),
"editable", FALSE,
NULL);
path = gtk_tree_path_new_from_string (path_str);
gtk_tree_model_get_iter (view->priv->sortmodel, &iter, path);
gtk_tree_model_sort_convert_iter_to_child_iter
(GTK_TREE_MODEL_SORT (view->priv->sortmodel), &iter2, &iter);
gtk_tree_model_filter_convert_iter_to_child_iter
(GTK_TREE_MODEL_FILTER (view->priv->filtermodel), &iter, &iter2);
node = ephy_tree_model_node_node_from_iter (view->priv->nodemodel, &iter);
ephy_node_set_property_string (node, view->priv->editable_property,
new_text);
gtk_tree_path_free (path);
view->priv->remove_if_cancelled = FALSE;
}
/* helper_on_contents_row_activated */
static void _helper_on_contents_row_activated(GtkWidget * widget,
GtkTreePath * path, GtkTreeViewColumn * column, gpointer data)
{
Helper * helper = data;
GtkTreeModel * model;
GtkTreeIter iter;
GtkTreeIter parent;
gchar * package;
gchar * command;
(void) column;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
gtk_tree_model_get_iter(model, &iter, path);
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(
model), &parent, &iter);
model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model));
gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(
model), &iter, &parent);
model = GTK_TREE_MODEL(helper->store);
if(gtk_tree_model_iter_parent(model, &parent, &iter) == FALSE)
{
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);
return;
}
gtk_tree_model_get(model, &parent, HSC_CONTENTS_PACKAGE, &package, -1);
gtk_tree_model_get(model, &iter, HSC_CONTENTS_PACKAGE, &command, -1);
helper_open_contents(helper, package, command);
g_free(package);
g_free(command);
}
/* Given a treeview iter, get the base store iterator */
static void
key_store_get_base_iter (CryptUIKeyStore *ckstore, const GtkTreeIter *iter,
GtkTreeIter *base_iter)
{
GtkTreeIter i;
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (ckstore), &i, (GtkTreeIter*)iter);
gtk_tree_model_filter_convert_iter_to_child_iter (ckstore->priv->filter, base_iter, &i);
}
GncSxInstances*
gnc_sx_list_tree_model_adapter_get_sx_instances(GncSxListTreeModelAdapter *model, GtkTreeIter *sort_iter)
{
GtkTreeIter translated_iter;
gtk_tree_model_sort_convert_iter_to_child_iter(model->real,
&translated_iter,
sort_iter);
return gsltma_get_sx_instances_from_orig_iter(model, &translated_iter);
}
static void
file_view_selection_changed (GtkTreeSelection* selection, AnjutaFileView* view)
{
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (view);
GtkTreeModel* file_model = GTK_TREE_MODEL(priv->model);
GtkTreeIter selected;
GtkTreeModel* model = gtk_tree_view_get_model (GTK_TREE_VIEW(view));
if (priv->current_selection)
{
GtkTreeIter iter;
GtkTreePath* path = gtk_tree_row_reference_get_path (priv->current_selection);
if (path && gtk_tree_model_get_iter (file_model, &iter, path))
{
gchar* filename;
gtk_tree_model_get (file_model, &iter, COLUMN_FILENAME, &filename, -1);
gtk_tree_store_set (GTK_TREE_STORE (file_model), &iter,
COLUMN_DISPLAY, filename, -1);
g_free(filename);
gtk_tree_path_free(path);
}
gtk_tree_row_reference_free(priv->current_selection);
priv->current_selection = NULL;
}
if (gtk_tree_selection_get_selected (selection, &model, &selected))
{
GtkTreeIter real_selection;
GtkTreePath* path;
GFile* file;
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(model),
&real_selection, &selected);
path = gtk_tree_model_get_path(file_model, &real_selection);
priv->current_selection = gtk_tree_row_reference_new (file_model, path);
gtk_tree_path_free(path);
file_view_show_extended_data (view, &real_selection);
file = file_model_get_file(FILE_MODEL(file_model), &real_selection);
g_signal_emit_by_name (G_OBJECT (view), "current-file-changed",
file, NULL);
g_object_unref (file);
}
else
{
g_signal_emit_by_name (G_OBJECT (view), "current-file-changed",
NULL, NULL);
}
/* The pending selection is now either done or if the user changed the
* selection before it was finished we cancel it. */
g_clear_object (&priv->pending_selected_file);
DEBUG_PRINT ("%s", "selection_changed");
}
static void
rejilla_split_dialog_remove_clicked_cb (GtkButton *button,
RejillaSplitDialog *self)
{
RejillaSplitDialogPrivate *priv;
GList *references = NULL;
GtkTreeModel *model;
GList *selected;
GList *iter;
priv = REJILLA_SPLIT_DIALOG_PRIVATE (self);
selected = gtk_tree_selection_get_selected_rows (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree)), &model);
/* since we are going to modify the tree take references */
for (iter = selected; iter; iter = iter->next) {
GtkTreePath *treepath;
GtkTreeRowReference *reference;
treepath = iter->data;
reference = gtk_tree_row_reference_new (model, treepath);
gtk_tree_path_free (treepath);
references = g_list_prepend (references, reference);
}
g_list_free (selected);
for (iter = references; iter; iter = iter->next) {
GtkTreeRowReference *reference;
GtkTreePath *treepath;
GtkTreeIter child;
GtkTreeIter row;
reference = iter->data;
treepath = gtk_tree_row_reference_get_path (reference);
gtk_tree_row_reference_free (reference);
if (!treepath)
continue;
if (!gtk_tree_model_get_iter (model, &row, treepath)) {
gtk_tree_path_free (treepath);
continue;
}
gtk_tree_path_free (treepath);
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model),
&child,
&row);
gtk_list_store_remove (priv->model, &child);
}
g_list_free (references);
}
/* notes_get_iter */
static gboolean _notes_get_iter(Notes * notes, GtkTreeIter * iter,
GtkTreePath * path)
{
GtkTreeIter p;
if(gtk_tree_model_get_iter(GTK_TREE_MODEL(notes->filter_sort), iter,
path) == FALSE)
return FALSE;
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(
notes->filter_sort), &p, iter);
gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(
notes->filter), iter, &p);
return TRUE;
}
static void
file_view_row_activated (GtkTreeView* widget, GtkTreePath* sort_path,
GtkTreeViewColumn* column)
{
AnjutaFileView* view = ANJUTA_FILE_VIEW (widget);
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (view);
GtkTreeIter selected;
GtkTreePath* path = NULL;
gboolean is_dir;
GFile* file;
GtkTreeIter select_iter;
GtkTreeModel* sort_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
gtk_tree_model_get_iter (sort_model, &selected, sort_path);
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(sort_model),
&select_iter, &selected);
gtk_tree_model_get (GTK_TREE_MODEL(priv->model), &select_iter,
COLUMN_IS_DIR, &is_dir,
-1);
file = file_model_get_file (priv->model, &select_iter);
path = gtk_tree_model_get_path(sort_model, &selected);
if (is_dir)
{
if (!gtk_tree_view_row_expanded (GTK_TREE_VIEW (view),
path))
{
gtk_tree_view_expand_row (GTK_TREE_VIEW (view),
path,
FALSE);
}
else
{
gtk_tree_view_collapse_row (GTK_TREE_VIEW (view),
path);
}
}
else
{
g_signal_emit_by_name (G_OBJECT (view),
"file-open",
file);
}
if (file)
g_object_unref (file);
if (path)
gtk_tree_path_free(path);
}
/* settings_get_iter */
static gboolean _settings_get_iter(Settings * settings, GtkTreeIter * iter,
GtkTreePath * path)
{
GtkTreeModel * model;
GtkTreeIter p;
model = gtk_icon_view_get_model(GTK_ICON_VIEW(settings->view));
if(gtk_tree_model_get_iter(model, iter, path) == FALSE)
return FALSE;
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(
model), &p, iter);
model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model));
gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(
model), iter, &p);
return TRUE;
}
static EphyNode *
process_middle_click (GtkTreePath *path,
EphyNodeView *view)
{
EphyNode *node;
GtkTreeIter iter, iter2;
gtk_tree_model_get_iter (view->priv->sortmodel, &iter, path);
gtk_tree_model_sort_convert_iter_to_child_iter
(GTK_TREE_MODEL_SORT (view->priv->sortmodel), &iter2, &iter);
gtk_tree_model_filter_convert_iter_to_child_iter
(GTK_TREE_MODEL_FILTER (view->priv->filtermodel), &iter, &iter2);
node = ephy_tree_model_node_node_from_iter (view->priv->nodemodel, &iter);
return node;
}
void
on_action_bookmark_edit (GtkAction *action,
GeditCollaborationWindowHelper *helper)
{
GtkTreeIter iter;
InfcBrowser *browser;
GeditCollaborationBookmark *bookmark;
InfXmlConnection *connection;
GtkTreeIter selected;
if (!inf_gtk_browser_view_get_selected (INF_GTK_BROWSER_VIEW (helper->priv->browser_view),
&selected))
{
return;
}
gtk_tree_model_sort_convert_iter_to_child_iter (
GTK_TREE_MODEL_SORT (
gtk_tree_view_get_model (
GTK_TREE_VIEW (helper->priv->browser_view)
)
),
&iter,
&selected
);
gtk_tree_model_get (GTK_TREE_MODEL (helper->priv->browser_store),
&iter,
INF_GTK_BROWSER_MODEL_COL_BROWSER,
&browser,
-1);
if (browser == NULL)
{
return;
}
connection = infc_browser_get_connection (browser);
bookmark = g_object_get_data (G_OBJECT (connection),
BOOKMARK_DATA_KEY);
create_bookmark_dialog (helper, bookmark);
g_object_unref (browser);
}
void
on_action_session_disconnect (GtkAction *action,
GeditCollaborationWindowHelper *helper)
{
GtkTreeIter iter;
GtkTreeIter selected;
InfcBrowser *browser;
InfXmlConnection *connection;
if (!inf_gtk_browser_view_get_selected (INF_GTK_BROWSER_VIEW (helper->priv->browser_view),
&selected))
{
return;
}
gtk_tree_model_sort_convert_iter_to_child_iter (
GTK_TREE_MODEL_SORT (
gtk_tree_view_get_model (
GTK_TREE_VIEW (helper->priv->browser_view)
)
),
&iter,
&selected
);
gtk_tree_model_get (GTK_TREE_MODEL (helper->priv->browser_store),
&iter,
INF_GTK_BROWSER_MODEL_COL_BROWSER,
&browser,
-1);
if (browser == NULL)
{
return;
}
connection = infc_browser_get_connection (browser);
inf_xml_connection_close (connection);
inf_gtk_browser_store_clear_connection_error (helper->priv->browser_store,
connection);
g_object_unref (browser);
}
static gboolean
set_selection_foreach (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer user_data)
{
gboolean selection = GPOINTER_TO_INT (user_data);
GtkTreeModel *actual_model;
GtkTreeIter real_iter;
if (GTK_IS_TREE_MODEL_FILTER (model))
{
actual_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model),
&real_iter, iter);
}
else if (GTK_IS_TREE_MODEL_SORT (model))
{
actual_model = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (model));
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model),
&real_iter, iter);
}
else
{
actual_model = model;
real_iter = *iter;
}
if (GTK_IS_LIST_STORE (actual_model))
{
gtk_list_store_set (GTK_LIST_STORE (actual_model), &real_iter,
GD_MAIN_COLUMN_SELECTED, selection,
-1);
}
else
{
gtk_tree_store_set (GTK_TREE_STORE (actual_model), &real_iter,
GD_MAIN_COLUMN_SELECTED, selection,
-1);
}
return FALSE;
}
static void
ephy_node_view_row_activated_cb (GtkTreeView *treeview,
GtkTreePath *path,
GtkTreeViewColumn *column,
EphyNodeView *view)
{
GtkTreeIter iter, iter2;
EphyNode *node;
gtk_tree_model_get_iter (view->priv->sortmodel, &iter, path);
gtk_tree_model_sort_convert_iter_to_child_iter
(GTK_TREE_MODEL_SORT (view->priv->sortmodel), &iter2, &iter);
gtk_tree_model_filter_convert_iter_to_child_iter
(GTK_TREE_MODEL_FILTER (view->priv->filtermodel), &iter, &iter2);
node = ephy_tree_model_node_node_from_iter (view->priv->nodemodel, &iter);
g_signal_emit (G_OBJECT (view), ephy_node_view_signals[NODE_ACTIVATED], 0, node);
}
static void
nsp_app_feed_item_list_sel (GtkTreeSelection *selection, gpointer user_data)
{
NspApp *app = nsp_app_get();
GtkTreeIter iter, child_iter;
GtkTreeModel *model;
NspFeedItem *feed_item = NULL;
char *markup;
if ( gtk_tree_selection_get_selected(selection, &model, &iter) ) {
gtk_tree_model_get(model, &iter, ITEM_LIST_COL_ITEM_REF, &feed_item, -1);
}
if ( feed_item == NULL ) {
return;
}
app->current_feed_item = feed_item;
g_mutex_lock(app->current_feed->mutex);
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(app->current_feed->items_sorter), &child_iter, &iter);
if ( feed_item->status & NSP_FEED_ITEM_UNREAD ) {
feed_item->status ^= NSP_FEED_ITEM_UNREAD;
nsp_jobs_queue(app->jobs, nsp_job_new((NspCallback*)nsp_feed_item_save_status_to_db, (void*)feed_item));
nsp_feed_item_list_update_iter(child_iter, app->current_feed->items_store, feed_item);
app->current_feed->unread_items --;
nsp_feed_list_update_entry(app->window->feed_list, app->current_feed);
}
g_mutex_unlock(app->current_feed->mutex);
nsp_webview_load_string (app->window->webview, feed_item->description);
if ( feed_item->link == NULL ) {
gtk_label_set_text(GTK_LABEL(gtk_builder_get_object(app->window->builder, "feed_item_label")), feed_item->title);
} else {
markup = g_markup_printf_escaped("<a href=\"%s\">%s</a>", feed_item->link, feed_item->title);
gtk_label_set_markup(GTK_LABEL(gtk_builder_get_object(app->window->builder, "feed_item_label")), markup);
g_free(markup);
}
return;
}
static void
_gtk_user_list_dialog_set_user_pixbuf(GtkUserListDialog *dialog, const gchar *username, GdkPixbuf *pixbuf)
{
GtkUserListDialogPrivate *priv = dialog->priv;
GtkWidget *tree;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeIter child;
GtkListStore *store;
tree = priv->tree;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree));
if(gtk_helpers_tree_model_find_iter_by_string(model, username, GTK_USER_LIST_TREEVIEW_COLUMN_USERNAME, &iter))
{
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(model), &child, &iter);
store = GTK_LIST_STORE(gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model)));
gtk_list_store_set(store, &child, GTK_USER_LIST_TREEVIEW_COLUMN_PIXBUF, pixbuf, -1);
}
}
static void item_selected_cb (GtkTreeSelection *treeselection, PhidiasItemsClassic *item)
{
gchar *desc;
gchar *is_read;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeIter original_iter;
if (gtk_tree_selection_get_selected (treeselection, &model, &iter) == TRUE) {
gtk_tree_model_get (model, &iter, ITEM_INFO_READ, &is_read, ITEM_INFO_DESCRIPTION, &desc, -1);
webkit_web_view_load_html_string (WEBKIT_WEB_VIEW (item->priv->description), desc, "file://");
if (strcmp (is_read, "false") == 0) {
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model), &original_iter, &iter);
g_signal_emit_by_name (item, "item-update-required", &original_iter, ITEM_INFO_READ, "true");
}
g_free (is_read);
g_free (desc);
}
}
static void
file_view_do_popup_menu (GtkWidget* widget, GdkEventButton* event)
{
AnjutaFileView* view = ANJUTA_FILE_VIEW (widget);
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (view);
GtkTreeSelection* selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
GFile* file = NULL;
gboolean is_dir = FALSE;
GtkTreeIter selected;
gint button, event_time;
if (gtk_tree_selection_get_selected (selection, NULL, &selected))
{
GtkTreeIter select_iter;
GtkTreeModel* sort_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(sort_model),
&select_iter, &selected);
gtk_tree_model_get (GTK_TREE_MODEL(priv->model), &select_iter,
COLUMN_IS_DIR, &is_dir,
-1);
file = file_model_get_file (priv->model, &select_iter);
}
if (event)
{
button = event->button;
event_time = event->time;
}
else
{
button = 0;
event_time = gtk_get_current_event_time ();
}
g_signal_emit_by_name (G_OBJECT(widget), "show-popup-menu",
file, is_dir, button, event_time);
if (file)
g_object_unref (file);
}
static EphyNode *
get_node_from_path (EphyNodeView *view, GtkTreePath *path)
{
EphyNode *node;
GtkTreeIter iter, iter2, iter3;
if (path == NULL) return NULL;
gtk_tree_model_get_iter (view->priv->sortmodel, &iter, path);
gtk_tree_model_sort_convert_iter_to_child_iter
(GTK_TREE_MODEL_SORT (view->priv->sortmodel), &iter2, &iter);
if (iter2.stamp == 0) {
return NULL;
}
gtk_tree_model_filter_convert_iter_to_child_iter
(GTK_TREE_MODEL_FILTER (view->priv->filtermodel), &iter3, &iter2);
node = ephy_tree_model_node_node_from_iter (view->priv->nodemodel, &iter3);
return node;
}
GFile*
file_view_get_selected (AnjutaFileView* view)
{
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (view);
GtkTreeSelection* selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
GtkTreeIter selected;
if (gtk_tree_selection_get_selected (selection, NULL, &selected))
{
GFile* file;
GtkTreeIter real_iter;
GtkTreeModel* sort_model = gtk_tree_view_get_model (GTK_TREE_VIEW(view));
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(sort_model),
&real_iter, &selected);
file = file_model_get_file (priv->model, &real_iter);
return file;
}
else
return NULL;
}
