static void
ok_button_clicked_cb (GtkWidget *widget,
DialogData *data)
{
GList *list;
list = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (data->icon_view));
if (list != NULL) {
GtkTreePath *path;
GtkTreeModel *model;
GtkTreeIter iter;
path = list->data;
model = gtk_icon_view_get_model (GTK_ICON_VIEW (data->icon_view));
if (gtk_tree_model_get_iter (model, &iter, path)) {
GdkPixbuf *image;
gtk_tree_model_get (model, &iter, IMAGE_COLUMN, &image, -1);
goo_window_set_cover_image_from_pixbuf (data->window, image);
g_object_unref (image);
}
g_list_foreach (list, (GFunc) gtk_tree_path_free, NULL);
g_list_free (list);
}
}
static gboolean
wp_button_press_cb (GtkWidget *widget,
GdkEventButton *event,
AppearanceData *data)
{
GtkCellRenderer *cell;
GdkEventButton *button_event = (GdkEventButton *) event;
if (event->type != GDK_BUTTON_PRESS)
return FALSE;
if (gtk_icon_view_get_item_at_pos (GTK_ICON_VIEW (widget),
button_event->x, button_event->y,
NULL, &cell)) {
if (g_object_get_data (G_OBJECT (cell), "buttons")) {
gint w, h;
GtkCellRenderer *cell2 = NULL;
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
if (gtk_icon_view_get_item_at_pos (GTK_ICON_VIEW (widget),
button_event->x + w, button_event->y,
NULL, &cell2) && cell == cell2)
next_frame (data, cell, -1);
else
next_frame (data, cell, 1);
return TRUE;
}
}
return FALSE;
}
/**
* callback pour traiter les changements de sélection dans le GtkIconView
*
* \param le GtkIconView appellant
*
* \return
*
* */
void gsb_select_icon_selection_changed ( GtkIconView *icon_view,
gpointer user_data )
{
GList * liste;
GtkTreePath *path;
GtkTreeModel *model;
GtkTreeIter iter;
gchar *name_icon = NULL;
liste = gtk_icon_view_get_selected_items ( GTK_ICON_VIEW ( icon_view ) );
/* Could happen if selection is unset, exiting then. */
if ( ! liste )
return;
path = liste -> data;
model = gtk_icon_view_get_model ( GTK_ICON_VIEW ( icon_view ) );
if (gtk_tree_model_get_iter ( GTK_TREE_MODEL (model), &iter, path ))
gtk_tree_model_get (model, &iter, TEXT_COLUMN, &name_icon, -1);
name_icon = my_strdelimit ( name_icon, "\n", "" );
devel_debug ( name_icon );
if ( name_icon && strlen ( name_icon ) > 0 )
{
new_icon = g_strconcat ( path_icon, G_DIR_SEPARATOR_S,
name_icon, NULL );
gtk_entry_set_text ( GTK_ENTRY (GTK_BIN (entry_text)->child ),
new_icon );
gtk_widget_set_sensitive (bouton_OK, TRUE );
}
}
static void
hcp_app_view_set_n_columns (GtkWidget *widget,
gpointer data)
{
gint n_columns;
/* 4px is the HCP_GRID_X_PADDING */
#define PORTRAIT_WIDTH 480 - 3 * HILDON_MARGIN_DOUBLE
#define LANDSCAPE_WIDTH (800 / 2) - 2 * HILDON_MARGIN_DOUBLE
if (! HCP_IS_GRID (widget))
return;
n_columns = GPOINTER_TO_INT (data);
/*
* g_debug ("WIDTH = %d", (n_columns == 1) ? PORTRAIT_WIDTH : LANDSCAPE_WIDTH);
*/
/* grid view, set proper no. of colunms */
gtk_icon_view_set_columns (GTK_ICON_VIEW (widget), n_columns);
gtk_icon_view_set_item_width (GTK_ICON_VIEW (widget),
(n_columns == 1) ?
PORTRAIT_WIDTH :
LANDSCAPE_WIDTH);
hcp_grid_refresh_icons (HCP_GRID (widget));
}
// Iconview Dialog
static void
mud_connections_show_icon_dialog(MudConnections *conn)
{
GladeXML *glade;
gint result;
glade = glade_xml_new(GLADEDIR "/muds.glade", "iconselect", NULL);
conn->priv->icon_dialog = glade_xml_get_widget(glade, "iconselect");
conn->priv->icon_dialog_view = glade_xml_get_widget(glade, "view");
conn->priv->icon_dialog_chooser =
glade_xml_get_widget(glade, "chooser");
g_object_unref(glade);
conn->priv->icon_dialog_view_model =
GTK_TREE_MODEL(gtk_list_store_new(MODEL_COLUMN_N,
G_TYPE_STRING,
GDK_TYPE_PIXBUF));
gtk_icon_view_set_model(GTK_ICON_VIEW(conn->priv->icon_dialog_view),
conn->priv->icon_dialog_view_model);
gtk_icon_view_set_text_column(
GTK_ICON_VIEW(conn->priv->icon_dialog_view),
MODEL_COLUMN_STRING);
gtk_icon_view_set_pixbuf_column(
GTK_ICON_VIEW(conn->priv->icon_dialog_view),
MODEL_COLUMN_PIXBUF);
if(conn->priv->icon_current != NULL)
g_free(conn->priv->icon_current);
conn->priv->icon_current = NULL;
g_signal_connect(
conn->priv->icon_dialog_chooser, "current-folder-changed",
G_CALLBACK(mud_connections_icon_fileset_cb),
conn);
g_signal_connect(conn->priv->icon_dialog_view, "selection-changed",
G_CALLBACK(mud_connections_icon_select_cb),
conn);
g_object_set(conn->priv->icon_dialog_view, "item-width", 64, NULL);
gtk_file_chooser_set_current_folder(
GTK_FILE_CHOOSER(conn->priv->icon_dialog_chooser),
"/usr/share/icons");
result = gtk_dialog_run(GTK_DIALOG(conn->priv->icon_dialog));
gtk_widget_destroy(conn->priv->icon_dialog);
if(result == GTK_RESPONSE_OK)
{
if(conn->priv->icon_current == NULL)
return;
GdkPixbuf *icon = gdk_pixbuf_new_from_file_at_size(
conn->priv->icon_current, 48, 48, NULL);
gtk_image_set_from_pixbuf(GTK_IMAGE(conn->priv->icon_image),
icon);
g_object_unref(icon);
}
}
static void
load_themes (DialogData *data)
{
GFile *style_dir;
GFile *data_dir;
char *default_theme;
GtkTreeModel *model;
GtkTreeIter iter;
/* local themes */
style_dir = gth_user_dir_get_file_for_read (GTH_DIR_DATA, PIX_DIR, "albumthemes", NULL);
add_themes_from_dir (data, style_dir);
g_object_unref (style_dir);
/* system themes */
data_dir = g_file_new_for_path (WEBALBUM_DATADIR);
style_dir = _g_file_get_child (data_dir, "albumthemes", NULL);
add_themes_from_dir (data, style_dir);
g_object_unref (style_dir);
g_object_unref (data_dir);
/**/
gtk_widget_set_size_request (GET_WIDGET ("theme_iconview"), (150 * 3), 140);
gtk_widget_realize (GET_WIDGET ("theme_iconview"));
default_theme = g_settings_get_string (data->settings, PREF_WEBALBUMS_THEME);
model = GTK_TREE_MODEL (GET_WIDGET ("theme_liststore"));
if (gtk_tree_model_get_iter_first (model, &iter)) {
do {
char *name;
gtk_tree_model_get(model, &iter, THEME_COLUMN_ID, &name, -1);
if (g_strcmp0 (name, default_theme) == 0) {
GtkTreePath *path;
path = gtk_tree_model_get_path (model, &iter);
gtk_icon_view_select_path (GTK_ICON_VIEW (GET_WIDGET ("theme_iconview")), path);
gtk_icon_view_scroll_to_path (GTK_ICON_VIEW (GET_WIDGET ("theme_iconview")), path, TRUE, 0.5, 0.5);
gtk_tree_path_free (path);
g_free (name);
break;
}
g_free (name);
}
while (gtk_tree_model_iter_next (model, &iter));
}
g_free (default_theme);
}
void addGroup (const gchar *name, const gchar *icon_path,
const gchar *nick, const gchar *sort_key)
{
// calculate position
int pos;
{
std::list <std::string>::iterator it;
for (it = sort_keys.begin(), pos = 0; it != sort_keys.end(); it++, pos++)
if (strcmp (it->c_str(), sort_key) >= 0)
break;
sort_keys.insert (it, sort_key);
}
// label widget
GtkWidget *tab_label, *image, *label;
GdkPixbuf *icon = NULL;
if (icon_path) {
GError *error = 0;
std::string path = ICONS + std::string (icon_path) + ".png";
icon = gdk_pixbuf_new_from_file (path.c_str(), &error);
if (!icon)
g_warning ("Could not load icon: %s.\nReason: %s", icon_path, error->message);
}
tab_label = gtk_hbox_new (FALSE, 0);
label = gtk_label_new (name);
if (icon)
image = gtk_image_new_from_pixbuf (icon);
if (icon)
gtk_box_pack_start (GTK_BOX (tab_label), image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (tab_label), label, TRUE, TRUE, icon ? 6 : 0);
// page widget
GtkListStore *store = gtk_list_store_new (3, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING);
m_stores [nick] = store;
GtkWidget *icons_view;
icons_view = gtk_icon_view_new_with_model (GTK_TREE_MODEL (store));
gtk_icon_view_set_text_column (GTK_ICON_VIEW (icons_view), 0);
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icons_view), 1);
g_signal_connect(G_OBJECT (icons_view), "item-activated",
G_CALLBACK (executeCommand), this);
GtkWidget *page;
page = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (page),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (page), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (page), icons_view);
// add those to the notebook
gtk_widget_show_all (tab_label);
gtk_notebook_insert_page_menu (GTK_NOTEBOOK (m_widget), page, tab_label, NULL, pos);
}
static void
fcitx_main_window_init(FcitxMainWindow* self)
{
GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
GtkWidget* hbox = gtk_hbox_new(FALSE, 0);
self->pagestore = _fcitx_main_window_create_model();
self->pageview = gtk_icon_view_new_with_model(GTK_TREE_MODEL(self->pagestore));
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(self->pageview), PAGE_LIST_ICON);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(self->pageview), PAGE_LIST_NAME);
#if GTK_CHECK_VERSION(2, 22, 0)
gtk_icon_view_set_item_orientation(GTK_ICON_VIEW(self->pageview), GTK_ORIENTATION_VERTICAL);
#endif
_fcitx_main_window_add_im_page(self);
_fcitx_main_window_add_config_file_page(self);
_fcitx_main_window_add_addon_page(self);
gtk_widget_set_size_request(GTK_WIDGET(self), -1, 500);
self->vbox = gtk_vbox_new(FALSE, 0);
self->pagelabel = gtk_label_new("");
gtk_label_set_use_markup(GTK_LABEL(self->pagelabel), true);
gtk_misc_set_alignment(GTK_MISC(self->pagelabel), 0, 0.5);
gtk_box_pack_start(GTK_BOX(self->vbox), self->pagelabel, FALSE, FALSE, 14);
GtkWidget* scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
gtk_container_add(GTK_CONTAINER(scrolledwindow), self->pageview);
gtk_box_pack_start(GTK_BOX(hbox), scrolledwindow, FALSE, TRUE, 4);
gtk_box_pack_start(GTK_BOX(hbox), self->vbox, TRUE, TRUE, 8);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 8);
gtk_container_add(GTK_CONTAINER(self), vbox);
gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(self->pageview), GTK_SELECTION_SINGLE);
gtk_icon_view_set_item_padding(GTK_ICON_VIEW(self->pageview), 0);
gtk_icon_view_set_margin(GTK_ICON_VIEW(self->pageview), 0);
gtk_icon_view_set_column_spacing(GTK_ICON_VIEW(self->pageview), 0);
gtk_icon_view_set_row_spacing(GTK_ICON_VIEW(self->pageview), 0);
gtk_icon_view_set_item_width(GTK_ICON_VIEW(self->pageview), 96);
g_signal_connect_swapped(G_OBJECT(self), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(self->pageview), "selection-changed",
G_CALLBACK(_fcitx_main_window_selection_changed_cb), self);
GtkTreePath* path = gtk_tree_model_get_path(GTK_TREE_MODEL(self->pagestore), &self->impage->iter);
gtk_icon_view_select_path(GTK_ICON_VIEW(self->pageview), path);
gtk_tree_path_free(path);
gtk_window_set_icon_name(GTK_WINDOW(self), "fcitx-configtool");
gtk_window_set_title(GTK_WINDOW(self), _("Fcitx Config"));
}
static int _settings(void)
{
Settings settings;
GtkAccelGroup * accel;
GtkWidget * widget;
GtkListStore * store;
GtkTreeModel * model;
accel = gtk_accel_group_new();
settings.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_add_accel_group(GTK_WINDOW(settings.window), accel);
desktop_accel_create(_settings_accel, &settings, accel);
g_object_unref(accel);
gtk_window_set_default_size(GTK_WINDOW(settings.window), 400, 300);
gtk_window_set_icon_name(GTK_WINDOW(settings.window),
GTK_STOCK_PREFERENCES);
gtk_window_set_title(GTK_WINDOW(settings.window),
_("System preferences"));
g_signal_connect_swapped(settings.window, "delete-event", G_CALLBACK(
_settings_on_closex), NULL);
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
store = gtk_list_store_new(SC_COUNT,
GDK_TYPE_PIXBUF, /* SC_ICON */
G_TYPE_STRING, /* SC_NAME */
G_TYPE_STRING, /* SC_EXEC */
G_TYPE_BOOLEAN); /* SC_PRIVILEGED */
model = gtk_tree_model_filter_new(GTK_TREE_MODEL(store), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model),
_settings_on_filter_view, &settings, NULL);
model = gtk_tree_model_sort_new_with_model(model);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), SC_NAME,
GTK_SORT_ASCENDING);
settings.view = gtk_icon_view_new_with_model(model);
gtk_icon_view_set_item_width(GTK_ICON_VIEW(settings.view), 96);
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(settings.view), SC_ICON);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(settings.view), SC_NAME);
gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(settings.view),
GTK_SELECTION_SINGLE);
#if GTK_CHECK_VERSION(2, 10, 0)
g_signal_connect(settings.view, "item-activated", G_CALLBACK(
_settings_on_item_activated), &settings);
#endif
gtk_container_add(GTK_CONTAINER(widget), settings.view);
gtk_container_add(GTK_CONTAINER(settings.window), widget);
gtk_widget_show_all(settings.window);
g_idle_add(_settings_on_idle, &settings);
gtk_main();
return 0;
}
static void
cheese_thumb_view_constructed (GObject *object)
{
CheeseThumbView *thumb_view = CHEESE_THUMB_VIEW (object);
CheeseThumbViewPrivate *priv = cheese_thumb_view_get_instance_private (thumb_view);
G_OBJECT_CLASS (cheese_thumb_view_parent_class)->constructed (object);
gtk_icon_view_set_model (GTK_ICON_VIEW (thumb_view), GTK_TREE_MODEL (priv->store));
gtk_widget_set_size_request (GTK_WIDGET (thumb_view),
THUMB_VIEW_MINIMUM_WIDTH,
THUMB_VIEW_MINIMUM_HEIGHT);
gtk_icon_view_set_margin (GTK_ICON_VIEW (thumb_view), 0);
gtk_icon_view_set_row_spacing (GTK_ICON_VIEW (thumb_view), 0);
gtk_icon_view_set_column_spacing (GTK_ICON_VIEW (thumb_view), 0);
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (thumb_view), 0);
gtk_icon_view_set_columns (GTK_ICON_VIEW (thumb_view), -1);
gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW (thumb_view), GDK_BUTTON1_MASK,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_COPY);
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (thumb_view), GTK_SELECTION_MULTIPLE);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (priv->store),
THUMBNAIL_BASENAME_URL_COLUMN, GTK_SORT_ASCENDING);
cheese_thumb_view_fill (thumb_view);
cheese_thumb_view_set_vertical (thumb_view, FALSE);
}
/**
* Crée le GtkIconView
*
* \param nom de l'icône
*
* \return le GtkIconView rempli avec l'icône sélectionnée au premier plan
*
* */
GtkWidget * gsb_select_icon_create_icon_view ( gchar * name_icon )
{
GtkTreePath * tree_path;
/* construct the GtkIconView */
icon_view = gtk_icon_view_new ();
gtk_icon_view_set_margin ( GTK_ICON_VIEW ( icon_view ), 0 );
gtk_icon_view_set_spacing (GTK_ICON_VIEW ( icon_view ), 0 );
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW ( icon_view ),
GTK_SELECTION_SINGLE );
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW ( icon_view ), PIXBUF_COLUMN);
gtk_icon_view_set_text_column (GTK_ICON_VIEW ( icon_view ), TEXT_COLUMN);
/* remplissage et positionnement initial du curseur dans le GtkIconView */
tree_path = gsb_select_icon_fill_icon_view ( name_icon );
gtk_icon_view_select_path ( GTK_ICON_VIEW ( icon_view ), tree_path );
gtk_icon_view_set_cursor (GTK_ICON_VIEW ( icon_view ), tree_path,
NULL, TRUE);
gtk_icon_view_scroll_to_path (GTK_ICON_VIEW ( icon_view ),
tree_path, TRUE, 0.5, 0 );
return icon_view;
}
void
cheese_thumb_view_set_vertical (CheeseThumbView *thumb_view, gboolean vertical)
{
CheeseThumbViewPrivate *priv = cheese_thumb_view_get_instance_private (thumb_view);
priv->vertical = vertical;
if (!priv->vertical && priv->n_items)
gtk_icon_view_set_columns(GTK_ICON_VIEW (thumb_view), priv->n_items);
else
gtk_icon_view_set_columns(GTK_ICON_VIEW (thumb_view), 1);
gtk_widget_set_hexpand (GTK_WIDGET (thumb_view), !vertical);
gtk_widget_set_vexpand (GTK_WIDGET (thumb_view), vertical);
}
static void
gtk_icon_view_item_accessible_get_image_position (AtkImage *image,
gint *x,
gint *y,
AtkCoordType coord_type)
{
GtkIconViewItemAccessible *item;
GdkRectangle box;
item = GTK_ICON_VIEW_ITEM_ACCESSIBLE (image);
if (!GTK_IS_ICON_VIEW (item->widget))
return;
if (atk_state_set_contains_state (item->state_set, ATK_STATE_DEFUNCT))
return;
atk_component_get_position (ATK_COMPONENT (image), x, y, coord_type);
if (get_pixbuf_box (GTK_ICON_VIEW (item->widget), item->item, &box))
{
*x+= box.x - item->item->cell_area.x;
*y+= box.y - item->item->cell_area.y;
}
}
static void
gtk_icon_view_item_accessible_get_image_size (AtkImage *image,
gint *width,
gint *height)
{
GtkIconViewItemAccessible *item;
GdkRectangle box;
item = GTK_ICON_VIEW_ITEM_ACCESSIBLE (image);
if (!GTK_IS_ICON_VIEW (item->widget))
return;
if (atk_state_set_contains_state (item->state_set, ATK_STATE_DEFUNCT))
return;
*width = 0;
*height = 0;
if (get_pixbuf_box (GTK_ICON_VIEW (item->widget), item->item, &box))
{
*width = box.width;
*height = box.height;
}
}
static gboolean
gtk_icon_view_accessible_remove_selection (AtkSelection *selection,
gint i)
{
GtkWidget *widget;
GtkIconView *icon_view;
GtkIconViewItem *item;
GList *l;
gint count;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
if (widget == NULL)
return FALSE;
icon_view = GTK_ICON_VIEW (widget);
l = icon_view->priv->items;
count = 0;
while (l)
{
item = l->data;
if (item->selected)
{
if (count == i)
{
_gtk_icon_view_unselect_item (icon_view, item);
return TRUE;
}
count++;
}
l = l->next;
}
return FALSE;
}
static gint
gtk_icon_view_accessible_get_selection_count (AtkSelection *selection)
{
GtkWidget *widget;
GtkIconView *icon_view;
GtkIconViewItem *item;
GList *l;
gint count;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
if (widget == NULL)
return 0;
icon_view = GTK_ICON_VIEW (widget);
l = icon_view->priv->items;
count = 0;
while (l)
{
item = l->data;
if (item->selected)
count++;
l = l->next;
}
return count;
}
static AtkObject*
gtk_icon_view_accessible_ref_selection (AtkSelection *selection,
gint i)
{
GList *l;
GtkWidget *widget;
GtkIconView *icon_view;
GtkIconViewItem *item;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
if (widget == NULL)
return NULL;
icon_view = GTK_ICON_VIEW (widget);
l = icon_view->priv->items;
while (l)
{
item = l->data;
if (item->selected)
{
if (i == 0)
return atk_object_ref_accessible_child (gtk_widget_get_accessible (widget), item->index);
else
i--;
}
l = l->next;
}
return NULL;
}
static HCPApp *
hcp_app_view_get_selected_app (GtkWidget *widget, GtkTreePath *path)
{
GtkTreeModel *model;
HCPApp *app = NULL;
GtkTreeIter iter;
gint item_pos;
g_return_val_if_fail (widget, NULL);
g_return_val_if_fail (GTK_IS_ICON_VIEW (widget), NULL);
g_return_val_if_fail (path, NULL);
model = gtk_icon_view_get_model (GTK_ICON_VIEW (widget));
if (path == NULL) return NULL;
item_pos = gtk_tree_path_get_indices (path) [0];
if (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (model),
&iter, NULL, item_pos)) {
gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
HCP_STORE_APP, &app,
-1);
}
return app;
}
static void
mud_connections_icon_select_cb(GtkIconView *view, MudConnections *conn)
{
GList *selected =
gtk_icon_view_get_selected_items(
GTK_ICON_VIEW(conn->priv->icon_dialog_view));
GtkTreeIter iter;
gchar *buf;
if(g_list_length(selected) == 0)
return;
gtk_tree_model_get_iter(conn->priv->icon_dialog_view_model,
&iter, (GtkTreePath *)selected->data);
gtk_tree_model_get(conn->priv->icon_dialog_view_model,
&iter, 0, &buf, -1);
if(conn->priv->icon_current != NULL)
g_free(conn->priv->icon_current);
conn->priv->icon_current = g_strconcat(
gtk_file_chooser_get_current_folder(
GTK_FILE_CHOOSER(conn->priv->icon_dialog_chooser)),
G_DIR_SEPARATOR_S,
buf, NULL);
g_free(buf);
g_list_foreach(selected, (GFunc)gtk_tree_path_free, NULL);
g_list_free(selected);
}
static gboolean
search_entry_key_press_event_cb (GtkEntry *entry,
GdkEventKey *event,
GnomeControlCenterPrivate *priv)
{
if (event->keyval == GDK_KEY_Return)
{
GtkTreePath *path;
path = gtk_tree_path_new_first ();
priv->last_time = event->time;
gtk_icon_view_item_activated (GTK_ICON_VIEW (priv->search_view), path);
gtk_tree_path_free (path);
return TRUE;
}
if (event->keyval == GDK_KEY_Escape)
{
gtk_entry_set_text (entry, "");
return TRUE;
}
return FALSE;
}
static void
gd_thumb_nav_constructed (GObject *object)
{
GdThumbNav *self = GD_THUMB_NAV (object);
GdThumbNavPrivate *priv = self->priv;
G_OBJECT_CLASS (gd_thumb_nav_parent_class)->constructed (object);
if (priv->thumbview != NULL) {
gtk_container_add (GTK_CONTAINER (priv->sw), priv->thumbview);
gtk_widget_show_all (priv->sw);
gtk_icon_view_set_columns (GTK_ICON_VIEW (priv->thumbview),
G_MAXINT);
gtk_widget_set_size_request (priv->thumbview, -1, -1);
gd_sidebar_thumbnails_set_item_height (GD_SIDEBAR_THUMBNAILS (priv->thumbview),
115);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_NEVER);
}
gd_thumb_nav_set_show_buttons (self, priv->show_buttons);
}
/**
* gimp_page_selector_page_is_selected:
* @selector: Pointer to a #GimpPageSelector.
* @page_no: The number of the page to check.
*
* Returns: %TRUE if the page is selected, %FALSE otherwise.
*
* Since: 2.4
**/
gboolean
gimp_page_selector_page_is_selected (GimpPageSelector *selector,
gint page_no)
{
GimpPageSelectorPrivate *priv;
GtkTreeIter iter;
GtkTreePath *path;
gboolean selected;
g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector), FALSE);
priv = GIMP_PAGE_SELECTOR_GET_PRIVATE (selector);
g_return_val_if_fail (page_no >= 0 && page_no < priv->n_pages, FALSE);
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->store),
&iter, NULL, page_no);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->store), &iter);
selected = gtk_icon_view_path_is_selected (GTK_ICON_VIEW (priv->view),
path);
gtk_tree_path_free (path);
return selected;
}
/**
* gimp_page_selector_get_selected_pages:
* @selector: Pointer to a #GimpPageSelector.
* @n_selected_pages: Returns the number of selected pages.
*
* Returns: A sorted array of page numbers of selected pages. Use g_free() if
* you don't need the array any longer.
*
* Since: 2.4
**/
gint *
gimp_page_selector_get_selected_pages (GimpPageSelector *selector,
gint *n_selected_pages)
{
GimpPageSelectorPrivate *priv;
GList *selected;
GList *list;
gint *array;
gint i;
g_return_val_if_fail (GIMP_IS_PAGE_SELECTOR (selector), NULL);
g_return_val_if_fail (n_selected_pages != NULL, NULL);
priv = GIMP_PAGE_SELECTOR_GET_PRIVATE (selector);
selected = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (priv->view));
*n_selected_pages = g_list_length (selected);
array = g_new0 (gint, *n_selected_pages);
for (list = selected, i = 0; list; list = g_list_next (list), i++)
{
gint *indices = gtk_tree_path_get_indices (list->data);
array[i] = indices[0];
}
qsort (array, *n_selected_pages, sizeof (gint),
gimp_page_selector_int_compare);
g_list_free_full (selected, (GDestroyNotify) gtk_tree_path_free);
return array;
}
static void
eog_thumb_view_dispose (GObject *object)
{
EogThumbViewPrivate *priv = EOG_THUMB_VIEW (object)->priv;
GtkTreeModel *model;
if (priv->visible_range_changed_id != 0) {
g_source_remove (priv->visible_range_changed_id);
priv->visible_range_changed_id = 0;
}
model = gtk_icon_view_get_model (GTK_ICON_VIEW (object));
if (model && priv->image_add_id != 0) {
g_signal_handler_disconnect (model, priv->image_add_id);
priv->image_add_id = 0;
}
if (model && priv->image_removed_id) {
g_signal_handler_disconnect (model, priv->image_removed_id);
priv->image_removed_id = 0;
}
G_OBJECT_CLASS (eog_thumb_view_parent_class)->dispose (object);
}
static void
remove_button_clicked (GtkButton *button,
CcBackgroundPanel *panel)
{
CcBackgroundItem *item;
GtkListStore *store;
GtkTreePath *path;
CcBackgroundPanelPrivate *priv;
priv = panel->priv;
item = get_selected_item (panel);
if (item == NULL)
g_assert_not_reached ();
bg_pictures_source_remove (panel->priv->pictures_source, item);
g_object_unref (item);
/* Are there any items left in the pictures tree store? */
store = bg_source_get_liststore (BG_SOURCE (panel->priv->pictures_source));
if (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL) == 0)
gtk_combo_box_set_active (GTK_COMBO_BOX (WID ("sources-combobox")), SOURCE_WALLPAPERS);
path = gtk_tree_path_new_from_string ("0");
gtk_icon_view_select_path (GTK_ICON_VIEW (WID ("backgrounds-iconview")), path);
gtk_tree_path_free (path);
}
static void
buttons_cell_data_func (GtkCellLayout *layout,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer user_data)
{
AppearanceData *data = user_data;
GtkTreePath *path;
MateWPItem *item;
gboolean visible;
path = gtk_tree_model_get_path (model, iter);
if (gtk_icon_view_path_is_selected (GTK_ICON_VIEW (layout), path)) {
item = get_selected_item (data, NULL);
visible = mate_bg_changes_with_time (item->bg);
}
else
visible = FALSE;
g_object_set (G_OBJECT (cell), "visible", visible, NULL);
gtk_tree_path_free (path);
}
static CcBackgroundItem *
get_selected_item (CcBackgroundPanel *panel)
{
CcBackgroundPanelPrivate *priv = panel->priv;
GtkIconView *icon_view;
GtkTreeIter iter;
GtkTreeModel *model;
GList *list;
CcBackgroundItem *item;
icon_view = GTK_ICON_VIEW (WID ("backgrounds-iconview"));
item = NULL;
list = gtk_icon_view_get_selected_items (icon_view);
if (!list)
return NULL;
model = gtk_icon_view_get_model (icon_view);
if (gtk_tree_model_get_iter (model, &iter, (GtkTreePath*) list->data) == FALSE)
goto bail;
gtk_tree_model_get (model, &iter, 1, &item, -1);
bail:
g_list_foreach (list, (GFunc)gtk_tree_path_free, NULL);
g_list_free (list);
return item;
}
static void
gtk_icon_view_accessible_notify_gtk (GObject *obj,
GParamSpec *pspec)
{
GtkIconView *icon_view;
GtkWidget *widget;
AtkObject *atk_obj;
GtkIconViewAccessible *view;
if (strcmp (pspec->name, "model") == 0)
{
widget = GTK_WIDGET (obj);
atk_obj = gtk_widget_get_accessible (widget);
view = (GtkIconViewAccessible*)atk_obj;
if (view->model)
{
g_object_remove_weak_pointer (G_OBJECT (view->model),
(gpointer *)&view->model);
gtk_icon_view_accessible_disconnect_model_signals (view->model, widget);
}
gtk_icon_view_accessible_clear_cache (view);
icon_view = GTK_ICON_VIEW (obj);
view->model = icon_view->priv->model;
/* If there is no model the GtkIconView is probably being destroyed */
if (view->model)
{
g_object_add_weak_pointer (G_OBJECT (view->model), (gpointer *)&view->model);
gtk_icon_view_accessible_connect_model_signals (icon_view);
}
}
return;
}
static void
attachment_bar_set_store (EAttachmentBar *bar,
EAttachmentStore *store)
{
g_return_if_fail (E_IS_ATTACHMENT_STORE (store));
bar->priv->model = g_object_ref (store);
gtk_icon_view_set_model (
GTK_ICON_VIEW (bar->priv->icon_view),
bar->priv->model);
gtk_tree_view_set_model (
GTK_TREE_VIEW (bar->priv->tree_view),
bar->priv->model);
e_signal_connect_notify_object (
bar->priv->model, "notify::num-attachments",
G_CALLBACK (attachment_bar_update_status), bar,
G_CONNECT_SWAPPED);
e_signal_connect_notify_object (
bar->priv->model, "notify::total-size",
G_CALLBACK (attachment_bar_update_status), bar,
G_CONNECT_SWAPPED);
/* Initialize */
attachment_bar_update_status (bar);
}
static void
hcp_app_view_add_app (HCPApp *app, HCPGrid *grid)
{
GtkTreeModel *store;
GtkTreePath *path;
GtkTreeIter iter;
gchar *name = NULL;
gchar *text_domain = NULL;
store = gtk_icon_view_get_model (GTK_ICON_VIEW (grid));
g_object_get (G_OBJECT (app),
"name", &name,
"text-domain", &text_domain,
NULL);
gtk_list_store_append (GTK_LIST_STORE (store), &iter);
gtk_list_store_set (GTK_LIST_STORE (store), &iter,
HCP_STORE_LABEL, ((text_domain && *text_domain) ?
dgettext(text_domain, name) : _(name)),
HCP_STORE_APP, app,
-1);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter);
g_object_set (G_OBJECT (app),
"grid", grid,
"item-pos", gtk_tree_path_get_indices (path) [0],
NULL);
gtk_tree_path_free (path);
g_free (name);
}
