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);
}
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);
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkIconView_gtk_1icon_1view_1set_1model
(
JNIEnv* env,
jclass cls,
jlong _self,
jlong _model
)
{
GtkIconView* self;
GtkTreeModel* model;
// convert parameter self
self = (GtkIconView*) _self;
// convert parameter model
model = (GtkTreeModel*) _model;
// call function
gtk_icon_view_set_model(self, model);
// cleanup parameter self
// cleanup parameter model
}
// 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);
}
}
/*
* Set up the model and attach it to the GtkIconView.
*/
static void
populate_model(char *dir, GtkIconView *icon_view)
{
GtkListStore *model;
model = populated_model(dir);
gtk_icon_view_set_model(icon_view, GTK_TREE_MODEL(model));
g_object_unref(model);
}
/* Add a page in the project notebook */
static void
cb_druid_insert_project_page (gpointer value, gpointer user_data)
{
NPWDruid* druid = (NPWDruid*)user_data;
GtkBuilder *builder;
GtkWidget* label;
GtkWidget* child;
GtkWidget* assistant;
GtkIconView* view;
GtkNotebook *book;
GtkListStore *store;
GList *template_list = (GList *)value;
const gchar* category;
category = npw_header_get_category ((NPWHeader *)template_list->data);
/* Build another complete wizard dialog from the gtk builder file
* but keep only the project selection notebook page */
builder = gtk_builder_new ();
if (!gtk_builder_add_from_file (builder, GTK_BUILDER_UI_FILE, NULL))
{
g_warn_if_reached ();
g_object_unref (builder);
return;
}
/* Fill icon view */
view = GTK_ICON_VIEW (gtk_builder_get_object (builder, PROJECT_LIST));
gtk_icon_view_set_pixbuf_column (view, PIXBUF_COLUMN);
gtk_icon_view_set_markup_column (view, TEXT_COLUMN);
store = gtk_list_store_new (4, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
g_list_foreach (template_list, cb_druid_insert_project_icon, store);
gtk_icon_view_set_model (view, GTK_TREE_MODEL (store));
/* Connect signal to update dialog */
g_signal_connect (G_OBJECT (view), "selection-changed", G_CALLBACK (on_druid_project_update_selected), druid);
g_signal_connect (G_OBJECT (view), "map", G_CALLBACK (on_druid_project_update_selected), druid);
g_signal_connect_swapped (G_OBJECT (view), "item-activated", G_CALLBACK (gtk_assistant_next_page), druid->window);
/* Set new page label */
assistant = GTK_WIDGET (gtk_builder_get_object (builder, NEW_PROJECT_DIALOG));
book = GTK_NOTEBOOK (gtk_builder_get_object (builder, PROJECT_BOOK));
child = gtk_notebook_get_nth_page (book, 0);
label = gtk_notebook_get_tab_label (book, child);
gtk_label_set_text (GTK_LABEL(label), (const gchar *)category);
/* Pick up the filled project selection page from the newly created dialog
* add it to the wizard project notebook and destroy the dialog
*/
gtk_notebook_remove_page (book, 0);
gtk_notebook_append_page (druid->project_book, child, label);
gtk_widget_destroy (assistant);
g_object_unref (builder);
}
static void
hcp_app_view_add_category (HCPCategory *category, HCPAppView *view)
{
/* If a group has items */
if (category->apps)
{
GtkWidget *grid, *separator;
GtkListStore *store;
GList *focus_chain = NULL;
grid = hcp_app_view_create_grid ();
store = hcp_app_view_create_store ();
g_signal_connect (grid, "item-activated",
G_CALLBACK (hcp_app_view_launch_app),
NULL);
/* If we are creating a group with a defined name, we use
* it in the separator */
separator = hcp_app_view_create_separator (_(category->name));
gtk_box_pack_start (GTK_BOX (view), separator, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (view), GTK_WIDGET(grid), FALSE, FALSE, 0);
gtk_container_get_focus_chain (GTK_CONTAINER (view), &focus_chain);
focus_chain = g_list_append (focus_chain, grid);
gtk_container_set_focus_chain (GTK_CONTAINER (view), focus_chain);
g_list_free (focus_chain);
gtk_icon_view_set_model (GTK_ICON_VIEW (grid),
GTK_TREE_MODEL (store));
g_slist_foreach (category->apps,
(GFunc) hcp_app_view_add_app,
grid);
hcp_grid_refresh_icons (HCP_GRID(grid));
/* first group */
if (!view->priv->first_grid)
view->priv->first_grid = grid;
}
}
static void
source_changed_cb (GtkComboBox *combo,
CcBackgroundPanelPrivate *priv)
{
GtkTreeIter iter;
GtkTreeModel *model;
GtkIconView *view;
guint type;
BgSource *source;
gtk_combo_box_get_active_iter (combo, &iter);
model = gtk_combo_box_get_model (combo);
gtk_tree_model_get (model, &iter,
COL_SOURCE_TYPE, &type,
COL_SOURCE, &source, -1);
view = (GtkIconView *) gtk_builder_get_object (priv->builder,
"backgrounds-iconview");
gtk_icon_view_set_model (view,
GTK_TREE_MODEL (bg_source_get_liststore (source)));
}
void toolbar2___::init__(GtkWidget* box1, icon_item___* item) {
if(item->is_init_)
return;
item->is_init_ = true;
init1__(box1, item);
GtkWidget *view = gtk_icon_view_new();
item->widget_ = view;
GtkIconView *view2 = item->icon_view__();
gtk_container_add(item->container__(),view);
gtk_icon_view_set_item_width (view2, 0);
g_signal_connect (view, "selection-changed", G_CALLBACK (selection_changed__), NULL);
g_signal_connect (view, "item-activated", G_CALLBACK (item_activated__), NULL);
init2__(item);
GtkListStore *store = gtk_list_store_new (COLUMNS, G_TYPE_INT, GDK_TYPE_PIXBUF, G_TYPE_STRING);
item->store_ = store;
gtk_icon_view_set_model (view2, item->model__());
gtk_icon_view_set_pixbuf_column (view2, PIXBUF_COLUMN);
//gtk_icon_view_set_text_column (view2, TITLE_COLUMN);
gtk_icon_view_set_markup_column (view2, TITLE_COLUMN);
}
static GtkWidget *
simple_iconview (void)
{
GtkTreeModel *model;
GtkWidget *iconview;
GtkCellArea *area;
GtkCellRenderer *renderer;
iconview = gtk_icon_view_new ();
gtk_widget_show (iconview);
model = simple_list_model ();
gtk_icon_view_set_model (GTK_ICON_VIEW (iconview), model);
gtk_icon_view_set_item_orientation (GTK_ICON_VIEW (iconview), GTK_ORIENTATION_HORIZONTAL);
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (iconview));
cell_1 = renderer = gtk_cell_renderer_text_new ();
gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, FALSE, FALSE, FALSE);
gtk_cell_area_attribute_connect (area, renderer, "text", SIMPLE_COLUMN_NAME);
cell_2 = renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (G_OBJECT (renderer), "xalign", 0.0F, NULL);
gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, TRUE, FALSE, FALSE);
gtk_cell_area_attribute_connect (area, renderer, "icon-name", SIMPLE_COLUMN_ICON);
cell_3 = renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer),
"wrap-mode", PANGO_WRAP_WORD,
"wrap-width", 215,
NULL);
gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, FALSE, TRUE, FALSE);
gtk_cell_area_attribute_connect (area, renderer, "text", SIMPLE_COLUMN_DESCRIPTION);
return iconview;
}
/* The main GUI function for saving multi-paged PDFs */
static gboolean
gui_multi (void)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *file_label;
GtkWidget *file_entry;
GtkWidget *file_browse;
GtkWidget *file_hbox;
GtkWidget *vectorize_c;
GtkWidget *ignore_hidden_c;
GtkWidget *apply_c;
GtkWidget *scroll;
GtkWidget *page_view;
GtkWidget *h_but_box;
GtkWidget *del;
GtkWidget *h_box;
GtkWidget *img_combo;
GtkWidget *add_image;
gboolean run;
const gchar *temp;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
window = gimp_export_dialog_new ("PDF", PLUG_IN_ROLE, SAVE_MULTI_PROC);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (window)),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (window), 12);
file_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
file_label = gtk_label_new (_("Save to:"));
file_entry = gtk_entry_new ();
if (file_name != NULL)
gtk_entry_set_text (GTK_ENTRY (file_entry), file_name);
file_browse = gtk_button_new_with_label (_("Browse..."));
file_choose = gtk_file_chooser_dialog_new (_("Multipage PDF export"),
GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_SAVE,
"gtk-save", GTK_RESPONSE_OK,
"gtk-cancel", GTK_RESPONSE_CANCEL,
NULL);
gtk_box_pack_start (GTK_BOX (file_hbox), file_label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (file_hbox), file_entry, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (file_hbox), file_browse, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), file_hbox, TRUE, TRUE, 0);
page_view = gtk_icon_view_new ();
model = create_model ();
gtk_icon_view_set_model (GTK_ICON_VIEW (page_view), model);
gtk_icon_view_set_reorderable (GTK_ICON_VIEW (page_view), TRUE);
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (page_view), GTK_SELECTION_MULTIPLE);
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (page_view), THUMB);
gtk_icon_view_set_text_column (GTK_ICON_VIEW (page_view), PAGE_NUMBER);
gtk_icon_view_set_tooltip_column (GTK_ICON_VIEW (page_view), IMAGE_NAME);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (scroll, -1, 300);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_add (GTK_CONTAINER (scroll), page_view);
gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 0);
h_but_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (h_but_box), GTK_BUTTONBOX_START);
del = gtk_button_new_with_label (_("Remove the selected pages"));
gtk_box_pack_start (GTK_BOX (h_but_box), del, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), h_but_box, FALSE, FALSE, 0);
h_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
img_combo = gimp_image_combo_box_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (h_box), img_combo, FALSE, FALSE, 0);
add_image = gtk_button_new_with_label (_("Add this image"));
gtk_box_pack_start (GTK_BOX (h_box), add_image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), h_box, FALSE, FALSE, 0);
ignore_hidden_c = gtk_check_button_new_with_label (_("Omit hidden layers and layers with zero opacity"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ignore_hidden_c), optimize.ignore_hidden);
gtk_box_pack_end (GTK_BOX (vbox), ignore_hidden_c, FALSE, FALSE, 0);
vectorize_c = gtk_check_button_new_with_label (_("Convert bitmaps to vector graphics where possible"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (vectorize_c), optimize.vectorize);
gtk_box_pack_end (GTK_BOX (vbox), vectorize_c, FALSE, FALSE, 0);
apply_c = gtk_check_button_new_with_label (_("Apply layer masks before saving"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (apply_c), optimize.apply_masks);
gtk_box_pack_end (GTK_BOX (vbox), apply_c, FALSE, FALSE, 0);
gimp_help_set_help_data (apply_c, _("Keeping the masks will not change the output"), NULL);
gtk_widget_show_all (window);
g_signal_connect (G_OBJECT (file_browse), "clicked",
G_CALLBACK (choose_file_call), G_OBJECT (file_entry));
g_signal_connect (G_OBJECT (add_image), "clicked",
G_CALLBACK (add_image_call), G_OBJECT (img_combo));
g_signal_connect (G_OBJECT (del), "clicked",
G_CALLBACK (del_image_call), G_OBJECT (page_view));
g_signal_connect (G_OBJECT (model), "row-deleted",
G_CALLBACK (remove_call), NULL);
run = gtk_dialog_run (GTK_DIALOG (window)) == GTK_RESPONSE_OK;
run &= get_image_list ();
temp = gtk_entry_get_text (GTK_ENTRY (file_entry));
g_stpcpy (file_name, temp);
optimize.ignore_hidden = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ignore_hidden_c));
optimize.vectorize = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (vectorize_c));
optimize.apply_masks = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (apply_c));
gtk_widget_destroy (window);
return run;
}
/**
* remplit le modèle qu'il crée et attache au GtkIconView
*
* \param nom de l'icône initiale ou NULL
*
* \return un GtkTreePath qui donne la position de l'icône passée
* en paramètre
* */
GtkTreePath * gsb_select_icon_fill_icon_view ( gchar * name_icon )
{
GDir *dir;
GError *error = NULL;
GtkTreePath *tree_path = NULL;
devel_debug ( path_icon );
dir = g_dir_open ( path_icon, 0, &error );
if ( dir )
{
GtkListStore *store;
GtkTreeIter iter;
GdkPixbuf *pixbuf;
GSList *liste = NULL;
gint i = 0;
const gchar *name = NULL;
while ( (name = g_dir_read_name ( dir ) ) )
{
liste = g_slist_append ( liste, g_strdup ( name ) );
}
liste = g_slist_sort ( liste, (GCompareFunc) my_strcasecmp );
store = gtk_list_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER);
while ( liste )
{
gchar *tmpstr = g_strconcat ( path_icon, G_DIR_SEPARATOR_S,
liste -> data, NULL );
if ( g_strcmp0 ( tmpstr, name_icon ) == 0 )
{
gchar *tmpstr = utils_str_itoa ( i );
tree_path = gtk_tree_path_new_from_string ( tmpstr );
g_free ( tmpstr );
}
pixbuf = gdk_pixbuf_new_from_file_at_size ( tmpstr, 32, 32, NULL);
if ( pixbuf )
{
gchar *tmpstr;
gtk_list_store_append ( store, &iter );
tmpstr = gsb_select_icon_troncate_name_icon ( liste -> data, 10 );
gtk_list_store_set (store, &iter, PIXBUF_COLUMN, pixbuf,
TEXT_COLUMN, tmpstr, -1);
g_free ( tmpstr );
g_object_unref (pixbuf);
}
g_free ( tmpstr );
liste = liste -> next;
i++;
}
gtk_icon_view_set_model (GTK_ICON_VIEW ( icon_view ), GTK_TREE_MODEL (store));
g_dir_close ( dir );
}
else
{
dialogue_error ( error -> message );
g_error_free ( error );
}
if ( tree_path == NULL )
tree_path = gtk_tree_path_new_from_string ( "0" );
return tree_path;
}
/*
* Set up the window: build the interface, connect the signals, insert the
* file icons.
*/
static GtkWidget *
prepare_window(char *dir, struct geometry *geometry, struct state *d)
{
GtkBuilder *builder;
GtkWidget *icons, *window, *directory_close, *file_open;
GtkWidget *directory_up, *directory_open, *help_about;
GtkListStore *model;
builder = gtk_builder_new_from_file(INTERFACE_PATH);
window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
icons = GTK_WIDGET(gtk_builder_get_object(builder, "icons"));
directory_up = GTK_WIDGET(gtk_builder_get_object(builder, "directory-up-menu-item"));
directory_open = GTK_WIDGET(gtk_builder_get_object(builder, "directory-open-menu-item"));
directory_close = GTK_WIDGET(gtk_builder_get_object(builder, "directory-close-menu-item"));
file_open = GTK_WIDGET(gtk_builder_get_object(builder, "file-open-menu-item"));
help_about = GTK_WIDGET(gtk_builder_get_object(builder, "help-about-menu-item"));
d->icon_view = GTK_ICON_VIEW(icons);
g_object_unref(builder);
gtk_window_set_default_size(GTK_WINDOW(window), geometry->w,
geometry->h);
gtk_window_move(GTK_WINDOW(window), geometry->x, geometry->y);
gtk_window_set_title(GTK_WINDOW(window), dir);
model = gtk_list_store_new(MODEL_CNT,
G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT);
if (populate(model, dir) == -1)
err(66, "failed to populate icon model from %s", dir);
watch_dir(model, dir);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(icons), 0);
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(icons), 1);
gtk_icon_view_set_model(GTK_ICON_VIEW(icons), GTK_TREE_MODEL(model));
g_object_unref(model);
gtk_widget_set_sensitive(directory_up, strlen(d->dir) > 1);
/* Drag */
gtk_drag_source_set(icons, GDK_BUTTON1_MASK,
dnd_targets, TARGET_COUNT,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_source_add_text_targets(icons);
gtk_drag_source_add_uri_targets(icons);
g_signal_connect(icons, "drag-begin", G_CALLBACK(on_icons_drag_begin), d);
g_signal_connect(icons, "drag-data-get", G_CALLBACK(on_icons_drag_data_get), d);
g_signal_connect(icons, "drag-end", G_CALLBACK(on_icons_drag_end), d);
/* Drop */
gtk_drag_dest_set(icons, GTK_DEST_DEFAULT_ALL,
dnd_targets, TARGET_COUNT,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_dest_add_text_targets(icons);
gtk_drag_dest_add_uri_targets(icons);
g_signal_connect(icons, "drag-motion", G_CALLBACK(on_icons_drag_motion), d);
g_signal_connect(icons, "drag-leave", G_CALLBACK(on_icons_data_leave), d);
g_signal_connect(icons, "drag-data-received", G_CALLBACK(on_icons_drag_data_received), d);
/* Activations */
g_signal_connect(icons, "item-activated", G_CALLBACK(on_icons_item_activated), d);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(window, "configure-event", G_CALLBACK(on_window_configure_event), dir);
g_signal_connect(directory_up, "activate", G_CALLBACK(on_directory_up_menu_item_activate), d);
g_signal_connect(directory_open, "activate", G_CALLBACK(on_directory_open_menu_item_activate), d);
g_signal_connect(directory_close, "activate", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(file_open, "activate", G_CALLBACK(on_file_open_menu_item_activate), d);
g_signal_connect(help_about, "activate", G_CALLBACK(on_help_about_menu_item_activate), NULL);
g_signal_connect(icons, "button-press-event", G_CALLBACK(on_icons_button_press_event), d);
return window;
}
void
desktop_init (AppearanceData *data,
const gchar **uris)
{
GtkWidget *add_button, *w;
GtkCellRenderer *cr;
char *url;
data->wp_update_settings = TRUE;
data->wp_uris = NULL;
if (uris != NULL) {
while (*uris != NULL) {
data->wp_uris = g_slist_append (data->wp_uris, g_strdup (*uris));
uris++;
}
}
w = appearance_capplet_get_widget (data, "more_backgrounds_linkbutton");
url = g_settings_get_string (data->settings, MORE_BACKGROUNDS_URL_KEY);
if (url != NULL && url[0] != '\0') {
gtk_link_button_set_uri (GTK_LINK_BUTTON (w), url);
gtk_widget_show (w);
} else {
gtk_widget_hide (w);
}
g_free (url);
data->wp_hash = g_hash_table_new (g_str_hash, g_str_equal);
g_signal_connect (data->wp_settings,
"changed::" WP_FILE_KEY,
G_CALLBACK (wp_file_changed),
data);
g_signal_connect (data->wp_settings,
"changed::" WP_OPTIONS_KEY,
G_CALLBACK (wp_options_changed),
data);
g_signal_connect (data->wp_settings,
"changed::" WP_SHADING_KEY,
G_CALLBACK (wp_shading_changed),
data);
g_signal_connect (data->wp_settings,
"changed::" WP_PCOLOR_KEY,
G_CALLBACK (wp_color1_changed),
data);
g_signal_connect (data->wp_settings,
"changed::" WP_SCOLOR_KEY,
G_CALLBACK (wp_color2_changed),
data);
data->wp_model = GTK_TREE_MODEL (gtk_list_store_new (2, GDK_TYPE_PIXBUF,
G_TYPE_POINTER));
data->wp_view = GTK_ICON_VIEW (appearance_capplet_get_widget (data, "wp_view"));
gtk_icon_view_set_model (data->wp_view, GTK_TREE_MODEL (data->wp_model));
g_signal_connect_after (data->wp_view, "realize",
(GCallback) wp_select_after_realize, data);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (data->wp_view));
cr = gtk_cell_renderer_pixbuf_new ();
g_object_set (cr, "xpad", 5, "ypad", 5, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->wp_view), cr, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->wp_view), cr,
"pixbuf", 0,
NULL);
cr = gtk_cell_renderer_pixbuf_new ();
create_button_images (data);
g_object_set (cr,
"mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE,
"pixbuf", buttons[0],
NULL);
g_object_set_data (G_OBJECT (cr), "buttons", GINT_TO_POINTER (TRUE));
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->wp_view), cr, FALSE);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (data->wp_view), cr,
buttons_cell_data_func, data, NULL);
g_signal_connect (data->wp_view, "selection-changed",
(GCallback) wp_selected_changed_cb, data);
g_signal_connect (data->wp_view, "button-press-event",
G_CALLBACK (wp_button_press_cb), data);
data->frame = -1;
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (data->wp_model), 1,
(GtkTreeIterCompareFunc) wp_list_sort,
data, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->wp_model),
1, GTK_SORT_ASCENDING);
gtk_drag_dest_set (GTK_WIDGET (data->wp_view), GTK_DEST_DEFAULT_ALL, drop_types,
G_N_ELEMENTS (drop_types), GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect (data->wp_view, "drag_data_received",
(GCallback) wp_drag_received, data);
gtk_drag_source_set (GTK_WIDGET (data->wp_view), GDK_BUTTON1_MASK,
drag_types, G_N_ELEMENTS (drag_types), GDK_ACTION_COPY);
g_signal_connect (data->wp_view, "drag-data-get",
(GCallback) wp_drag_get_data, data);
data->wp_style_menu = appearance_capplet_get_widget (data, "wp_style_menu");
g_signal_connect (data->wp_style_menu, "changed",
(GCallback) wp_scale_type_changed, data);
data->wp_color_menu = appearance_capplet_get_widget (data, "wp_color_menu");
g_signal_connect (data->wp_color_menu, "changed",
(GCallback) wp_shade_type_changed, data);
data->wp_scpicker = appearance_capplet_get_widget (data, "wp_scpicker");
g_signal_connect (data->wp_scpicker, "color-set",
(GCallback) wp_scolor_changed, data);
data->wp_pcpicker = appearance_capplet_get_widget (data, "wp_pcpicker");
g_signal_connect (data->wp_pcpicker, "color-set",
(GCallback) wp_scolor_changed, data);
add_button = appearance_capplet_get_widget (data, "wp_add_button");
gtk_button_set_image (GTK_BUTTON (add_button),
gtk_image_new_from_stock ("gtk-add", GTK_ICON_SIZE_BUTTON));
g_signal_connect (add_button, "clicked",
(GCallback) wp_file_open_dialog, data);
data->wp_rem_button = appearance_capplet_get_widget (data, "wp_rem_button");
g_signal_connect (data->wp_rem_button, "clicked",
(GCallback) wp_remove_wallpaper, data);
data->screen_monitors_handler = g_signal_connect (gtk_widget_get_screen (GTK_WIDGET (data->wp_view)),
"monitors-changed",
G_CALLBACK (screen_monitors_changed),
data);
data->screen_size_handler = g_signal_connect (gtk_widget_get_screen (GTK_WIDGET (data->wp_view)),
"size-changed",
G_CALLBACK (screen_monitors_changed),
data);
g_signal_connect (data->wp_view, "selection-changed",
(GCallback) wp_props_wp_selected, data);
g_signal_connect (data->wp_view, "query-tooltip",
(GCallback) wp_view_tooltip_cb, data);
gtk_widget_set_has_tooltip (GTK_WIDGET (data->wp_view), TRUE);
wp_set_sensitivities (data);
/* create the file selector later to save time on startup */
data->wp_filesel = NULL;
}
int main(int argc, char** argv) {
//gtk wdiget init start...
GtkWidget *window, *icon_view, *notebook;
GtkWidget *current_user_name, *current_time, *network_speed;
GtkWidget *home_button, *access_token_entry, *access_token_ok_button;
GtkWidget *access_token_cancel_button;
GtkWidget *get_access_token_button, *post_blog_title_entry;
GtkWidget *post_blog_content_text_view, *post_blog_content_text_buffer;
GtkWidget *post_blog_ok_button, *post_blog_cancel_button;
GtkWidget *blog_access_permission, *blog_password;
GList *post_blog_page = NULL;
GtkBuilder *builder;
GError *error = NULL;
//widget init
gtk_init(&argc, &argv);
builder = gtk_builder_new();
if(!gtk_builder_add_from_file(builder, "./sources/glade.glade", &error))
{
g_print("Error occured while loading UI files\n");
g_print("Message: %s\n", error->message);
g_free(error);
return 1;
}
//widget get from builder(glade files)
window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
notebook = GTK_WIDGET(gtk_builder_get_object(builder, "notebook1"));
icon_view = GTK_WIDGET(gtk_builder_get_object(builder, "iconview1"));
current_user_name = GTK_WIDGET(gtk_builder_get_object(builder,"label4"));
current_time = GTK_WIDGET(gtk_builder_get_object(builder, "label5"));
network_speed = GTK_WIDGET(gtk_builder_get_object(builder, "label6"));
access_token_ok_button = GTK_WIDGET(gtk_builder_get_object(builder, "button3"));
access_token_cancel_button = GTK_WIDGET(gtk_builder_get_object(builder, "button6"));
get_access_token_button = GTK_WIDGET(gtk_builder_get_object(builder, "button2"));
home_button = GTK_WIDGET(gtk_builder_get_object(builder, "button1"));
access_token_entry = GTK_WIDGET(gtk_builder_get_object(builder, "entry1"));
post_blog_content_text_view= GTK_WIDGET(gtk_builder_get_object(builder, "textview1"));
post_blog_ok_button = GTK_WIDGET(gtk_builder_get_object(builder, "button4"));
post_blog_title_entry = GTK_WIDGET(gtk_builder_get_object(builder, "entry2"));
blog_access_permission = GTK_WIDGET(gtk_builder_get_object(builder, "comboboxtext1"));
blog_password = GTK_WIDGET(gtk_builder_get_object(builder, "entry4"));
//set object attributes
gtk_window_set_title(GTK_WINDOW(window), "Xiao nei Gtk App");
gtk_window_set_default_size(GTK_WINDOW(window), 800, 400);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_icon_view_set_model(GTK_ICON_VIEW(icon_view), create_model());
gtk_icon_view_set_text_column(GTK_ICON_VIEW(icon_view), COL_DISPLAY_NAME);
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(icon_view), COL_PIXBUF);
gtk_icon_view_set_columns(GTK_ICON_VIEW(icon_view), 4);
gtk_label_set_text(GTK_LABEL(current_user_name), "Current user:fengtianba");
g_timeout_add_seconds(1, (GSourceFunc)set_label_time, current_time);
gtk_label_set_text(GTK_LABEL(network_speed), "Network Speed:100M");
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
int n = gtk_notebook_page_num(GTK_NOTEBOOK(notebook), icon_view);
//gtk_combo_box_set_model(GTK_COMBO_BOX(blog_access_permission), create_combo_box_tree_model());
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "private", "PRIVATE");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "public", "PUBLIC");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "password", "PASSWORD");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(blog_access_permission), "friend", "FRIEND");
printf("n is %d\n", n);
struct tm *time_ptr;
time_t the_time;
char *time_malloc;
(void)time(&the_time);
time_ptr = localtime(&the_time);
time_malloc = malloc(sizeof(struct tm));
memset(time_malloc, 0, sizeof(struct tm));
sprintf(time_malloc, "%d/%d/%d/%d:%d:%d", 1900 + time_ptr->tm_year, time_ptr->tm_mon, time_ptr->tm_mday,
time_ptr->tm_hour, time_ptr->tm_min, time_ptr->tm_sec);
gtk_label_set_text(GTK_LABEL(current_time), time_malloc);
post_blog_page = g_list_append(post_blog_page, post_blog_title_entry);
post_blog_page = g_list_append(post_blog_page, post_blog_content_text_view);
post_blog_page = g_list_append(post_blog_page, blog_access_permission);
post_blog_page = g_list_append(post_blog_page, blog_password);
//signal to connect to widget
g_signal_connect(window, "delete-event", gtk_main_quit, NULL);
g_signal_connect(GTK_BUTTON(get_access_token_button), "clicked", G_CALLBACK(get_access_token_button_clicked), NULL);
g_signal_connect(GTK_ICON_VIEW(icon_view), "item-activated", G_CALLBACK(icon_view_item_select), notebook);
g_signal_connect(GTK_BUTTON(home_button), "clicked", G_CALLBACK(home_button_clicked), notebook);
g_signal_connect(GTK_BUTTON(access_token_ok_button), "clicked", G_CALLBACK(access_token_ok_button_clicked), access_token_entry);
g_signal_connect(GTK_BUTTON(post_blog_ok_button), "clicked", G_CALLBACK(post_blog_ok_button_clicked), post_blog_page);
//object unref
g_object_unref(G_OBJECT(builder));
//show widget
gtk_widget_show_all(window);
gtk_main();
int i = 100;
char *decode_string;
/*CURL *curl;
curl_global_init(CURL_GLOBAL_ALL);
curl = curl_easy_init();
decode_string = curl_easy_unescape(curl, ACCESS_TOKEN, 0, &i);
printf("origin url: %s\n", ACCESS_TOKEN);
printf("new url: %s\n", decode_string);
curl_easy_cleanup(curl);*/
//puts("enter access token\n");
//scanf("%s", accesstoken);
//调用自己写的SDK
xiaonei_gtk_get_blog_list(accesstoken);
xiaonei_gtk_get_one_blog(accesstoken);
return (EXIT_SUCCESS);
}
static GtkWidget*
create_icon_view ()
{
GtkWidget *scroll = gtk_scrolled_window_new (NULL, NULL);
GtkWidget *icon_view = gtk_icon_view_new ();
int col_text = 0,col_icon = 1;
GtkTreeModel *list_model = gtk_list_store_new (2,
G_TYPE_STRING,
GDK_TYPE_PIXBUF );
gtk_icon_view_set_model (GTK_ICON_VIEW (icon_view), list_model);
gtk_icon_view_set_text_column (GTK_ICON_VIEW (icon_view), col_text);
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icon_view), col_icon);
gtk_icon_view_set_item_width (GTK_ICON_VIEW (icon_view), 100);
GtkTreeIter iter;
GtkIconTheme *icon_theme = gtk_icon_theme_get_default ();
GList *contxt_list, *icon_names_list, *ctx, *icn;
gint max_icons = 100;
gint icon_size = 32;
ctx = contxt_list = gtk_icon_theme_list_contexts (icon_theme);
while (ctx && max_icons) {
gchar *context = ctx->data;
icn = icon_names_list = gtk_icon_theme_list_icons (icon_theme, context);
g_debug ("Context %s: %d icons listed", context, g_list_length (icn));
while (icn && max_icons) {
gchar *icon_name = icn->data;
g_debug (" - %s", icon_name);
GdkPixbuf *pixbuf = NULL;
pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name,
icon_size, GTK_ICON_LOOKUP_FORCE_SVG, NULL);
if (pixbuf != NULL){
gtk_list_store_append (list_model, &iter);
gtk_list_store_set (list_model, &iter,
col_text, icon_name,
col_icon, pixbuf,
-1);
--max_icons;
}else{
g_free (icon_name);
}
icn = g_list_next (icn);
}
g_list_free (icon_names_list);
g_free (context);
ctx = g_list_next (ctx);
}
g_list_free (contxt_list);
gtk_container_add (GTK_CONTAINER (scroll), icon_view);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_name (scroll, "Icon View");
return scroll;
}
void
img_load_slideshow( img_window_struct *img,
const gchar *input )
{
GdkPixbuf *thumb;
slide_struct *slide_info;
GtkTreeIter iter;
GKeyFile *img_key_file;
gchar *dummy, *slide_filename, *time;
GtkWidget *dialog;
gint number,i,transition_id, duration, no_points, previous_nr_of_slides;
guint speed;
GtkTreeModel *model;
void (*render);
GHashTable *table;
gchar *spath, *conf;
gdouble *color, *font_color, *font_bgcolor;
gboolean old_file = FALSE;
gboolean first_slide = TRUE;
gchar *video_config_name, *aspect_ratio, *fps;
gint old_video_size, bitrate;
/* Cretate new key file */
img_key_file = g_key_file_new();
if( ! g_key_file_load_from_file( img_key_file, input,
G_KEY_FILE_KEEP_COMMENTS, NULL ) )
{
g_key_file_free( img_key_file );
return;
}
/* Are we able to load this project? */
dummy = g_key_file_get_comment( img_key_file, NULL, NULL, NULL);
if( strncmp( dummy, comment_string, strlen( comment_string ) ) != 0 )
{
/* Enable loading of old projects too */
if( strncmp( dummy, old_comment_string,
strlen( old_comment_string ) ) != 0 )
{
dialog = gtk_message_dialog_new(
GTK_WINDOW( img->imagination_window ), GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
_("This is not an Imagination project file!") );
gtk_window_set_title( GTK_WINDOW( dialog ), "Imagination" );
gtk_dialog_run( GTK_DIALOG( dialog ) );
gtk_widget_destroy( GTK_WIDGET( dialog ) );
g_free( dummy );
return;
}
old_file = TRUE;
}
g_free( dummy );
/* Create hash table for efficient searching */
table = g_hash_table_new_full( g_direct_hash, g_direct_equal,
NULL, g_free );
model = gtk_combo_box_get_model( GTK_COMBO_BOX( img->transition_type ) );
gtk_tree_model_foreach( model,
(GtkTreeModelForeachFunc)img_populate_hash_table,
&table );
/* Set the slideshow options */
/* Video Format, first check if we have a buggy, old file format (imagination <= 3.0) */
old_video_size = g_key_file_get_integer(img_key_file, "slideshow settings", "video format", NULL);
if (old_video_size != 0)
{
img_message(img, FALSE, "Old imagination project file, guessing format as VOB");
img->video_format_index = 0; /* index for VOB format*/
for (i = 0;
video_format_list[0].sizelist[i].name != NULL
&& video_format_list[0].sizelist[i].y != old_video_size;
i++);
if (video_format_list[0].sizelist[i].name != NULL)
{
img->video_size[0] = video_format_list[0].sizelist[i].x;
img->video_size[1] = old_video_size;
}
else /* we could not find the appropriate format, so we guess 4:3 format */
{
img->video_size[0] = old_video_size * 4 / 3;
img->video_size[1] = old_video_size;
}
/* Guess fps from video size */
if (img->video_size[1] == 576)
img->fps_index = 1; /* NTSC */
else
img->fps_index = 0; /* PAL */
img->export_fps = video_format_list[img->video_format_index].fps_list[img->fps_index].value;
/* set other parameters to defaults, as they can't be checked */
img->aspect_ratio_index = 0; /* 4:3 */
img->bitrate_index = 0; /* Not used in vob */
}
else
{
/* Video Codec */
video_config_name = g_key_file_get_string(img_key_file, "slideshow settings",
"video codec", NULL);
i = 0;
while (video_config_name != NULL
&& video_format_list[i].name != NULL
&& strcmp (video_format_list[i].config_name, video_config_name) != 0)
i++;
if (video_config_name == NULL || video_format_list[i].name == NULL)
{
img_message(img, FALSE, "Could not find a video format, guessing VOB\n");
img->video_format_index = 0; /* index for VOB format*/
}
else
img->video_format_index = i;
/* Video Size */
img->video_size[0] = g_key_file_get_integer(img_key_file, "slideshow settings",
"video width", NULL);
img->video_size[1] = g_key_file_get_integer(img_key_file, "slideshow settings",
"video height", NULL);
/* fps */
fps = g_key_file_get_string(img_key_file, "slideshow settings", "fps", NULL);
i = 0;
while (fps != NULL
&& strcmp (video_format_list[img->video_format_index].fps_list[i].name, fps) != 0)
i++;
if (fps == NULL
|| video_format_list[img->video_format_index].fps_list[i].name == NULL)
{
img_message(img, FALSE, "Could not find a fps, set to default\n");
img->fps_index = 0; /* index for VOB format*/
}
else
img->fps_index = i;
img->export_fps = video_format_list[img->video_format_index].fps_list[img->fps_index].value;
/* Aspect ratio */
if (NULL != video_format_list[img->video_format_index].aspect_ratio_list)
{
aspect_ratio = g_key_file_get_string(img_key_file, "slideshow settings",
"aspect ratio", NULL);
i = 0;
while (aspect_ratio != NULL
&& video_format_list[img->video_format_index].aspect_ratio_list[i].name != NULL
&& strcmp (video_format_list[img->video_format_index].aspect_ratio_list[i].name, aspect_ratio) != 0)
i++;
if (aspect_ratio == NULL
|| video_format_list[img->video_format_index].aspect_ratio_list[i].name == NULL)
{
img_message(img, FALSE, "Could not find an aspect ratio, set to default\n");
img->aspect_ratio_index = 0; /* index for VOB format*/
}
else
img->aspect_ratio_index = i;
}
/* Bitrate */
if (NULL != video_format_list[img->video_format_index].bitratelist)
{
bitrate = g_key_file_get_integer(img_key_file, "slideshow settings",
"bitrate", NULL);
i = 0;
while (video_format_list[img->video_format_index].bitratelist[i].name != NULL
&& video_format_list[img->video_format_index].bitratelist[i].value != bitrate)
i++;
if (video_format_list[img->video_format_index].bitratelist[i].name == NULL)
{
img_message(img, FALSE, "Could not find a bitrate, set to default\n");
img->bitrate_index = 0; /* index for VOB format*/
}
else
img->bitrate_index = i;
}
}
img_zoom_fit(NULL, img);
/* Make loading more efficient by removing model from icon view */
g_object_ref( G_OBJECT( img->thumbnail_model ) );
gtk_icon_view_set_model( GTK_ICON_VIEW( img->thumbnail_iconview ), NULL );
gtk_icon_view_set_model( GTK_ICON_VIEW( img->over_icon ), NULL );
/* Enable loading of old projects too */
if( old_file )
{
guint32 tmp;
dummy = g_key_file_get_string( img_key_file, "slideshow settings",
"background color", NULL );
tmp = (guint32)strtoul( dummy, NULL, 16 );
img->background_color[0] = (gdouble)( ( tmp >> 24 ) & 0xff ) / 0xff;
img->background_color[1] = (gdouble)( ( tmp >> 16 ) & 0xff ) / 0xff;
img->background_color[2] = (gdouble)( ( tmp >> 8 ) & 0xff ) / 0xff;
/* Loads the thumbnails and set the slides info */
number = g_key_file_get_integer(img_key_file,"images","number", NULL);
/* Store the previous number of slides and set img->slides_nr so to have the correct number of slides displayed on the status bar */
previous_nr_of_slides = img->slides_nr;
img->slides_nr = number;
gtk_widget_show(img->progress_bar);
for (i = 1; i <= number; i++)
{
dummy = g_strdup_printf("image_%d",i);
slide_filename = g_key_file_get_string(img_key_file,"images",dummy, NULL);
if( img_scale_image( slide_filename, img->video_ratio, 88, 0,
img->distort_images, img->background_color,
&thumb, NULL ) )
{
GdkPixbuf *pix;
speed = g_key_file_get_integer(img_key_file, "transition speed", dummy, NULL);
duration= g_key_file_get_integer(img_key_file, "slide duration", dummy, NULL);
transition_id = g_key_file_get_integer(img_key_file, "transition type", dummy, NULL);
/* Get the mem address of the transition */
spath = (gchar *)g_hash_table_lookup( table, GINT_TO_POINTER( transition_id ) );
if (spath)
{
gtk_tree_model_get_iter_from_string( model, &iter, spath );
gtk_tree_model_get( model, &iter, 2, &render, 0, &pix, -1 );
}
slide_info = img_create_new_slide();
if( slide_info )
{
img_set_slide_file_info( slide_info, slide_filename );
gtk_list_store_append( img->thumbnail_model, &iter );
gtk_list_store_set( img->thumbnail_model, &iter, 0, thumb, 1, slide_info, -1 );
g_object_unref( G_OBJECT( thumb ) );
/* Set non-default data */
img_set_slide_still_info( slide_info, duration, img );
img_set_slide_transition_info( slide_info,
img->thumbnail_model, &iter,
pix, spath, transition_id,
render, speed, img );
g_object_unref( G_OBJECT( pix ) );
/* Increment slide counter */
img->slides_nr++;
/* If we're loading the first slide, apply some of it's
* data to final pseudo-slide */
if( first_slide )
{
first_slide = FALSE;
img->final_transition.speed = slide_info->speed;
img->final_transition.render = slide_info->render;
}
}
}
img_increase_progressbar(img, i);
g_free(slide_filename);
g_free(dummy);
}
}
else
{
gint
main (gint argc, gchar **argv)
{
GtkWidget *paned, *tv;
GtkWidget *window, *icon_list, *scrolled_window;
GtkWidget *vbox, *bbox;
GtkWidget *button;
GtkWidget *prop_editor;
GtkTreeModel *model;
GtkCellRenderer *cell;
GtkTreeViewColumn *tvc;
gtk_init (&argc, &argv);
/* to test rtl layout, set RTL=1 in the environment */
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 700, 400);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0);
icon_list = gtk_icon_view_new ();
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (icon_list), GTK_SELECTION_MULTIPLE);
tv = gtk_tree_view_new ();
tvc = gtk_tree_view_column_new ();
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), tvc);
g_signal_connect_after (icon_list, "button_press_event",
G_CALLBACK (button_press_event_handler), NULL);
g_signal_connect (icon_list, "selection_changed",
G_CALLBACK (selection_changed), NULL);
g_signal_connect (icon_list, "popup_menu",
G_CALLBACK (popup_menu_handler), NULL);
g_signal_connect (icon_list, "item_activated",
G_CALLBACK (item_activated), NULL);
model = create_model ();
gtk_icon_view_set_model (GTK_ICON_VIEW (icon_list), model);
gtk_tree_view_set_model (GTK_TREE_VIEW (tv), model);
fill_model (model);
#if 0
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icon_list), 0);
gtk_icon_view_set_text_column (GTK_ICON_VIEW (icon_list), 1);
#else
cell = gtk_cell_renderer_toggle_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
g_object_set (cell, "activatable", TRUE, NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
cell, "active", 4, NULL);
g_signal_connect (cell, "toggled", G_CALLBACK (toggled), model);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
g_object_set (cell,
"follow-state", TRUE,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
cell, "pixbuf", 0, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
g_object_set (cell,
"editable", TRUE,
"xalign", 0.5,
"wrap-mode", PANGO_WRAP_WORD_CHAR,
"wrap-width", 100,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
cell, "text", 1, NULL);
g_signal_connect (cell, "edited", G_CALLBACK (edited), model);
/* now the tree view... */
cell = gtk_cell_renderer_toggle_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
g_object_set (cell, "activatable", TRUE, NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
cell, "active", 4, NULL);
g_signal_connect (cell, "toggled", G_CALLBACK (toggled), model);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
g_object_set (cell,
"follow-state", TRUE,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
cell, "pixbuf", 0, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
g_object_set (cell, "editable", TRUE, NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
cell, "text", 1, NULL);
g_signal_connect (cell, "edited", G_CALLBACK (edited), model);
#endif
/* Allow DND between the icon view and the tree view */
gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW (icon_list),
GDK_BUTTON1_MASK,
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
gtk_icon_view_enable_model_drag_dest (GTK_ICON_VIEW (icon_list),
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv),
GDK_BUTTON1_MASK,
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv),
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
prop_editor = create_prop_editor (G_OBJECT (icon_list), 0);
gtk_widget_show_all (prop_editor);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), icon_list);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add1 (GTK_PANED (paned), scrolled_window);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), tv);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add2 (GTK_PANED (paned), scrolled_window);
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Add some");
g_signal_connect (button, "clicked", G_CALLBACK (add_some), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Add many");
g_signal_connect (button, "clicked", G_CALLBACK (add_many), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Add large");
g_signal_connect (button, "clicked", G_CALLBACK (add_large), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Remove selected");
g_signal_connect (button, "clicked", G_CALLBACK (foreach_selected_remove), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Swap");
g_signal_connect (button, "clicked", G_CALLBACK (swap_rows), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Select all");
g_signal_connect (button, "clicked", G_CALLBACK (select_all), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Unselect all");
g_signal_connect (button, "clicked", G_CALLBACK (unselect_all), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Select nonexisting");
g_signal_connect (button, "clicked", G_CALLBACK (select_nonexisting), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
icon_list = gtk_icon_view_new ();
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), icon_list);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add2 (GTK_PANED (paned), scrolled_window);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static void update_db(BudgieMediaView *self)
{
GtkIconTheme *theme;
GtkListStore *model;
GPtrArray *albums = NULL;
GPtrArray *results = NULL;
GdkPixbuf *pixbuf;
GtkTreeIter iter;
gchar *album = NULL;
gchar *markup = NULL;
MediaInfo *current;
const gchar *cache;
gchar *album_id = NULL, *path = NULL;
int i;
/* No albums */
if (!budgie_db_get_all_by_field(self->db, MEDIA_QUERY_ALBUM, &albums))
return;
cache = g_get_user_cache_dir();
/* We don't *yet* support album art, use generic symbol */
theme = gtk_icon_theme_get_default();
model = gtk_list_store_new(ALBUM_COLUMNS, G_TYPE_STRING, GDK_TYPE_PIXBUF);
for (i=0; i < albums->len; i++) {
album = (gchar *)albums->pdata[i];
/* Try to gain at least one artist */
if (!budgie_db_search_field(self->db, MEDIA_QUERY_ALBUM,
MATCH_QUERY_EXACT, album, 1, &results))
goto fail;
current = results->pdata[0];
if (current->album == NULL)
goto albumfail;
album_id = albumart_name_for_media(current, "jpeg");
path = g_strdup_printf("%s/media-art/%s", cache, album_id);
g_free(album_id);
pixbuf = gdk_pixbuf_new_from_file_at_size(path, 64, 64, NULL);
if (!pixbuf)
pixbuf = gtk_icon_theme_load_icon(theme, "folder-music-symbolic",
64, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
/* Pretty label */
markup = g_markup_printf_escaped("<big><b>%s</b>\n<span color='grey'>%s</span></big>",
current->album, current->artist);
gtk_list_store_append(model, &iter);
gtk_list_store_set(model, &iter, ALBUM_TITLE, markup, -1);
gtk_list_store_set(model, &iter, ALBUM_PIXBUF, pixbuf, -1);
g_object_unref(pixbuf);
albumfail:
free_media_info(current);
g_ptr_array_free(results, TRUE);
fail:
g_free(album);
}
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model),
ALBUM_TITLE, GTK_SORT_ASCENDING);
gtk_icon_view_set_model(GTK_ICON_VIEW(self->icon_view),
GTK_TREE_MODEL(model));
g_ptr_array_free(albums, TRUE);
}
static GtkWidget *
focus_iconview (gboolean color_bg, GtkCellRenderer **focus, GtkCellRenderer **sibling)
{
GtkTreeModel *model;
GtkWidget *iconview;
GtkCellArea *area;
GtkCellRenderer *renderer, *toggle;
iconview = gtk_icon_view_new ();
gtk_widget_show (iconview);
model = focus_list_model ();
gtk_icon_view_set_model (GTK_ICON_VIEW (iconview), model);
gtk_icon_view_set_item_orientation (GTK_ICON_VIEW (iconview), GTK_ORIENTATION_HORIZONTAL);
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (iconview));
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, NULL);
gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, TRUE, FALSE, FALSE);
gtk_cell_area_attribute_connect (area, renderer, "text", FOCUS_COLUMN_NAME);
if (color_bg)
g_object_set (G_OBJECT (renderer), "cell-background", "red", NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (cell_edited), iconview);
toggle = renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "xalign", 0.0F, NULL);
gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, FALSE, TRUE, FALSE);
gtk_cell_area_attribute_connect (area, renderer, "active", FOCUS_COLUMN_CHECK);
if (color_bg)
g_object_set (G_OBJECT (renderer), "cell-background", "green", NULL);
if (focus)
*focus = renderer;
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (cell_toggled), iconview);
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer),
"wrap-mode", PANGO_WRAP_WORD,
"wrap-width", 150,
NULL);
if (color_bg)
g_object_set (G_OBJECT (renderer), "cell-background", "blue", NULL);
if (sibling)
*sibling = renderer;
gtk_cell_area_box_pack_start (GTK_CELL_AREA_BOX (area), renderer, FALSE, TRUE, FALSE);
gtk_cell_area_attribute_connect (area, renderer, "text", FOCUS_COLUMN_STATIC_TEXT);
gtk_cell_area_add_focus_sibling (area, toggle, renderer);
return iconview;
}
void themes_init(AppearanceData* data)
{
GtkWidget *w, *del_button;
GList *theme_list, *l;
GtkListStore *theme_store;
GtkTreeModel *sort_model;
MateThemeMetaInfo *meta_theme = NULL;
GtkIconView *icon_view;
GtkCellRenderer *renderer;
GtkSettings *settings;
char *url;
/* initialise some stuff */
mate_theme_init ();
mate_wm_manager_init ();
data->revert_application_font = NULL;
data->revert_documents_font = NULL;
data->revert_desktop_font = NULL;
data->revert_windowtitle_font = NULL;
data->revert_monospace_font = NULL;
data->theme_save_dialog = NULL;
data->theme_message_area = NULL;
data->theme_info_icon = NULL;
data->theme_error_icon = NULL;
data->theme_custom = mate_theme_meta_info_new ();
data->theme_icon = gdk_pixbuf_new_from_file (MATECC_PIXMAP_DIR "/theme-thumbnailing.png", NULL);
data->theme_store = theme_store =
gtk_list_store_new (NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
/* set up theme list */
theme_list = mate_theme_meta_info_find_all ();
mate_theme_info_register_theme_change ((ThemeChangedCallback) theme_changed_on_disk_cb, data);
data->theme_custom = theme_load_from_mateconf (data->client);
data->theme_custom->name = g_strdup (CUSTOM_THEME_NAME);
data->theme_custom->readable_name = g_strdup_printf ("<i>%s</i>", _("Custom"));
for (l = theme_list; l; l = l->next) {
MateThemeMetaInfo *info = l->data;
gtk_list_store_insert_with_values (theme_store, NULL, 0,
COL_LABEL, info->readable_name,
COL_NAME, info->name,
COL_THUMBNAIL, data->theme_icon,
-1);
if (!meta_theme && theme_is_equal (data->theme_custom, info))
meta_theme = info;
}
if (!meta_theme) {
/* add custom theme */
meta_theme = data->theme_custom;
gtk_list_store_insert_with_values (theme_store, NULL, 0,
COL_LABEL, meta_theme->readable_name,
COL_NAME, meta_theme->name,
COL_THUMBNAIL, data->theme_icon,
-1);
theme_thumbnail_generate (meta_theme, data);
}
theme_list = g_list_sort (theme_list, (GCompareFunc) theme_list_sort_func);
g_list_foreach (theme_list, (GFunc) theme_thumbnail_generate, data);
g_list_free (theme_list);
icon_view = GTK_ICON_VIEW (appearance_capplet_get_widget (data, "theme_list"));
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "xpad", 5, "ypad", 5,
"xalign", 0.5, "yalign", 1.0, NULL);
gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (icon_view), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_view), renderer,
"pixbuf", COL_THUMBNAIL, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "alignment", PANGO_ALIGN_CENTER,
"wrap-mode", PANGO_WRAP_WORD_CHAR,
"wrap-width", gtk_icon_view_get_item_width (icon_view),
"width", gtk_icon_view_get_item_width (icon_view),
"xalign", 0.0, "yalign", 0.0, NULL);
gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (icon_view), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_view), renderer,
"markup", COL_LABEL, NULL);
sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (theme_store));
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model), COL_LABEL, theme_store_sort_func, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model), COL_LABEL, GTK_SORT_ASCENDING);
gtk_icon_view_set_model (icon_view, GTK_TREE_MODEL (sort_model));
g_signal_connect (icon_view, "selection-changed", (GCallback) theme_selection_changed_cb, data);
g_signal_connect_after (icon_view, "realize", (GCallback) theme_select_name, meta_theme->name);
w = appearance_capplet_get_widget (data, "theme_install");
gtk_button_set_image (GTK_BUTTON (w),
gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON));
g_signal_connect (w, "clicked", (GCallback) theme_install_cb, data);
w = appearance_capplet_get_widget (data, "theme_save");
gtk_button_set_image (GTK_BUTTON (w),
gtk_image_new_from_stock (GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_BUTTON));
g_signal_connect (w, "clicked", (GCallback) theme_save_cb, data);
w = appearance_capplet_get_widget (data, "theme_custom");
gtk_button_set_image (GTK_BUTTON (w),
gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON));
g_signal_connect (w, "clicked", (GCallback) theme_custom_cb, data);
del_button = appearance_capplet_get_widget (data, "theme_delete");
g_signal_connect (del_button, "clicked", (GCallback) theme_delete_cb, data);
w = appearance_capplet_get_widget (data, "theme_vbox");
gtk_drag_dest_set (w, GTK_DEST_DEFAULT_ALL,
drop_types, G_N_ELEMENTS (drop_types),
GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_MOVE);
g_signal_connect (w, "drag-data-received", (GCallback) theme_drag_data_received_cb, data);
if (is_locked_down (data->client))
gtk_widget_set_sensitive (w, FALSE);
w = appearance_capplet_get_widget (data, "more_themes_linkbutton");
url = mateconf_client_get_string (data->client, MORE_THEMES_URL_KEY, NULL);
if (url != NULL && url[0] != '\0') {
gtk_link_button_set_uri (GTK_LINK_BUTTON (w), url);
gtk_widget_show (w);
} else {
gtk_widget_hide (w);
}
g_free (url);
/* listen to mateconf changes, too */
mateconf_client_add_dir (data->client, "/apps/marco/general", MATECONF_CLIENT_PRELOAD_NONE, NULL);
mateconf_client_add_dir (data->client, "/desktop/mate/interface", MATECONF_CLIENT_PRELOAD_NONE, NULL);
mateconf_client_notify_add (data->client, MARCO_THEME_KEY, (MateConfClientNotifyFunc) theme_mateconf_changed, data, NULL, NULL);
mateconf_client_notify_add (data->client, CURSOR_THEME_KEY, (MateConfClientNotifyFunc) theme_mateconf_changed, data, NULL, NULL);
#ifdef HAVE_XCURSOR
mateconf_client_notify_add (data->client, CURSOR_SIZE_KEY, (MateConfClientNotifyFunc) theme_mateconf_changed, data, NULL, NULL);
#endif
mateconf_client_notify_add (data->client, BACKGROUND_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL);
mateconf_client_notify_add (data->client, APPLICATION_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL);
mateconf_client_notify_add (data->client, DOCUMENTS_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL);
mateconf_client_notify_add (data->client, DESKTOP_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL);
mateconf_client_notify_add (data->client, WINDOWTITLE_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL);
mateconf_client_notify_add (data->client, MONOSPACE_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL);
settings = gtk_settings_get_default ();
g_signal_connect (settings, "notify::gtk-color-scheme", (GCallback) theme_setting_changed_cb, data);
g_signal_connect (settings, "notify::gtk-theme-name", (GCallback) theme_setting_changed_cb, data);
g_signal_connect (settings, "notify::gtk-icon-theme-name", (GCallback) theme_setting_changed_cb, data);
/* monitor individual font choice buttons, so
"revert font" option (if any) can be cleared */
w = appearance_capplet_get_widget (data, "application_font");
g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data);
w = appearance_capplet_get_widget (data, "document_font");
g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data);
w = appearance_capplet_get_widget (data, "desktop_font");
g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data);
w = appearance_capplet_get_widget (data, "window_title_font");
g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data);
w = appearance_capplet_get_widget (data, "monospace_font");
g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data);
}
static GObject *
mud_connections_constructor (GType gtype,
guint n_properties,
GObjectConstructParam *properties)
{
MudConnections *conn;
GladeXML *glade;
GConfClient *client;
GtkWidget *main_window;
GObject *obj;
MudConnectionsClass *klass;
GObjectClass *parent_class;
/* Chain up to parent constructor */
klass = MUD_CONNECTIONS_CLASS( g_type_class_peek(MUD_TYPE_CONNECTIONS) );
parent_class = G_OBJECT_CLASS( g_type_class_peek_parent(klass) );
obj = parent_class->constructor(gtype, n_properties, properties);
conn = MUD_CONNECTIONS(obj);
if(!conn->parent_window)
g_error("Tried to instantiate MudConnections without passing parent MudWindow\n");
g_object_get(conn->parent_window,
"window", &conn->priv->winwidget,
"tray", &conn->priv->tray,
NULL);
glade = glade_xml_new(GLADEDIR "/muds.glade", "mudviewwindow", NULL);
conn->priv->window = glade_xml_get_widget(glade, "mudviewwindow");
conn->priv->iconview = glade_xml_get_widget(glade, "iconview");
conn->priv->qconnect_host_entry =
glade_xml_get_widget(glade, "qconnect_host_entry");
conn->priv->qconnect_port_entry =
glade_xml_get_widget(glade, "qconnect_port_entry");
conn->priv->qconnect_connect_button =
glade_xml_get_widget(glade, "qconnect_connect_button");
conn->priv->icon_model =
GTK_TREE_MODEL(gtk_list_store_new(MODEL_COLUMN_N,
G_TYPE_STRING,
GDK_TYPE_PIXBUF));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(conn->priv->icon_model),
MODEL_COLUMN_STRING,
GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(conn->priv->icon_model),
MODEL_COLUMN_STRING,
mud_connections_compare_func,
NULL,
NULL);
conn->priv->original_name = NULL;
conn->priv->original_char_name = NULL;
gtk_icon_view_set_model(GTK_ICON_VIEW(conn->priv->iconview),
conn->priv->icon_model);
g_object_unref(conn->priv->icon_model);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(conn->priv->iconview),
MODEL_COLUMN_STRING);
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(conn->priv->iconview),
MODEL_COLUMN_PIXBUF);
client = gconf_client_get_default();
gconf_client_add_dir(client, "/apps/gnome-mud/muds",
GCONF_CLIENT_PRELOAD_NONE, NULL);
conn->priv->connection =
gconf_client_notify_add(client, "/apps/gnome-mud/muds",
(GConfClientNotifyFunc)
mud_connections_gconf_notify_cb,
conn, NULL, NULL);
g_signal_connect(conn->priv->iconview, "item-activated",
G_CALLBACK(mud_connections_iconview_activate_cb),
conn);
g_signal_connect(conn->priv->iconview, "button-press-event",
G_CALLBACK(mud_connections_button_press_cb),
conn);
g_signal_connect(conn->priv->window, "destroy",
G_CALLBACK(mud_connections_close_cb), conn);
g_signal_connect(glade_xml_get_widget(glade, "connect_button"),
"clicked", G_CALLBACK(mud_connections_connect_cb),
conn);
g_signal_connect(glade_xml_get_widget(glade, "add_button"),
"clicked", G_CALLBACK(mud_connections_add_cb), conn);
g_signal_connect(glade_xml_get_widget(glade, "delete_button"),
"clicked", G_CALLBACK(mud_connections_delete_cb),
conn);
g_signal_connect(glade_xml_get_widget(glade, "properties_button"),
"clicked", G_CALLBACK(mud_connections_properties_cb),
conn);
g_signal_connect(conn->priv->qconnect_connect_button, "clicked",
G_CALLBACK(mud_connections_qconnect_cb), conn);
mud_connections_populate_iconview(conn);
g_object_get(conn->parent_window, "window", &main_window, NULL);
g_object_set(conn->priv->window,
"transient-for", GTK_WINDOW(main_window),
NULL);
gtk_widget_show_all(conn->priv->window);
g_object_unref(glade);
g_object_unref(client);
return obj;
}
