static void
action_combo_box_constructed (GObject *object)
{
GtkComboBox *combo_box;
GtkCellRenderer *renderer;
combo_box = GTK_COMBO_BOX (object);
/* This needs to happen after constructor properties are set
* so that GtkCellLayout.get_area() returns something valid. */
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (
GTK_CELL_LAYOUT (combo_box), renderer, FALSE);
gtk_cell_layout_set_cell_data_func (
GTK_CELL_LAYOUT (combo_box), renderer,
(GtkCellLayoutDataFunc) action_combo_box_render_pixbuf,
combo_box, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (
GTK_CELL_LAYOUT (combo_box), renderer, TRUE);
gtk_cell_layout_set_cell_data_func (
GTK_CELL_LAYOUT (combo_box), renderer,
(GtkCellLayoutDataFunc) action_combo_box_render_text,
combo_box, NULL);
gtk_combo_box_set_row_separator_func (
combo_box, (GtkTreeViewRowSeparatorFunc)
action_combo_box_is_row_separator, NULL, NULL);
}
static void ui_refresh_users(dt_storage_facebook_gui_data_t *ui)
{
GSList *accountlist = load_account_info();
GtkListStore *list_store = GTK_LIST_STORE(gtk_combo_box_get_model(ui->comboBox_username));
GtkTreeIter iter;
gtk_list_store_clear(list_store);
gtk_list_store_append(list_store, &iter);
int active_account = 0;
if(g_slist_length(accountlist) == 0)
{
gtk_list_store_set(list_store, &iter, COMBO_USER_MODEL_NAME_COL, _("new account"),
COMBO_USER_MODEL_TOKEN_COL, NULL, COMBO_USER_MODEL_ID_COL, NULL, -1);
}
else
{
gtk_list_store_set(list_store, &iter, COMBO_USER_MODEL_NAME_COL, _("other account"),
COMBO_USER_MODEL_TOKEN_COL, NULL, COMBO_USER_MODEL_ID_COL, NULL, -1);
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_USER_MODEL_NAME_COL, "", COMBO_USER_MODEL_TOKEN_COL, NULL,
COMBO_USER_MODEL_ID_COL, NULL, -1); // separator
active_account = 2;
}
g_slist_foreach(accountlist, (GFunc)ui_refresh_users_fill, list_store);
gtk_combo_box_set_active(ui->comboBox_username, active_account);
g_slist_free_full(accountlist, (GDestroyNotify)fb_account_info_destroy);
gtk_combo_box_set_row_separator_func(ui->comboBox_username, combobox_separator, ui->comboBox_username, NULL);
}
void
init_object_combo_box(GtkWidget *cbox)
{
GtkCellRenderer *rend;
GtkTreeViewRowSeparatorFunc func;
func = gtk_combo_box_get_row_separator_func(GTK_COMBO_BOX(cbox));
if (func == NULL) {
gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(cbox), combo_box_separator_func, NULL, NULL);
}
gtk_cell_layout_clear(GTK_CELL_LAYOUT(cbox));
rend = gtk_cell_renderer_toggle_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(cbox), rend, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(cbox), rend,
"active", OBJECT_COLUMN_TYPE_TOGGLE,
"visible", OBJECT_COLUMN_TYPE_TOGGLE_VISIBLE,
"radio", OBJECT_COLUMN_TYPE_TOGGLE_IS_RADIO,
NULL);
rend = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(cbox), rend, FALSE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(cbox), rend, "text", OBJECT_COLUMN_TYPE_STRING);
rend = gtk_cell_renderer_pixbuf_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(cbox), rend, FALSE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(cbox), rend, "pixbuf", OBJECT_COLUMN_TYPE_PIXBUF);
}
static void
pluma_encodings_combo_box_init (PlumaEncodingsComboBox *menu)
{
GtkCellRenderer *text_renderer;
menu->priv = PLUMA_ENCODINGS_COMBO_BOX_GET_PRIVATE (menu);
menu->priv->store = gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_POINTER,
G_TYPE_BOOLEAN);
/* Setup up the cells */
text_renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (menu),
text_renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (menu),
text_renderer,
"text",
NAME_COLUMN,
NULL);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (menu),
separator_func, NULL,
NULL);
menu->priv->changed_id = g_signal_connect (menu, "changed",
G_CALLBACK (add_or_remove),
menu->priv->store);
update_menu (menu);
}
void
gnomegadu_ui_init_statusbar ()
{
GtkComboBox *combobox = GTK_COMBO_BOX (glade_xml_get_widget (gladexml, "StatusComboBox"));
GtkListStore *status_store = NULL;
GtkCellRenderer *render_text, *render_pixbuf;
GtkTreeIter iter, iter_init;
GdkPixbuf *pixbuf;
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox));
status_store = gtk_list_store_new (UI_STATUS_N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT);
render_pixbuf = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), render_pixbuf, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), render_pixbuf, "pixbuf", UI_STATUS_COLUMN_ICON, NULL);
render_text = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), render_text, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), render_text, "markup", UI_STATUS_COLUMN_NAME, NULL);
pixbuf = gnomegadu_stock_get_pixbuf ("gnomegadu-user-available");
gtk_list_store_append (status_store, &iter);
gtk_list_store_set (status_store, &iter, UI_STATUS_COLUMN_ICON, pixbuf, UI_STATUS_COLUMN_NAME, "Dostępny",
UI_STATUS_COLUMN_STATUS, GNOMEGADU_STATUS_AVAIL, -1);
gdk_pixbuf_unref (pixbuf);
pixbuf = gnomegadu_stock_get_pixbuf ("gnomegadu-user-away");
gtk_list_store_append (status_store, &iter);
gtk_list_store_set (status_store, &iter, UI_STATUS_COLUMN_ICON, pixbuf, UI_STATUS_COLUMN_NAME, "Zajęty",
UI_STATUS_COLUMN_STATUS, GNOMEGADU_STATUS_BUSY, -1);
gdk_pixbuf_unref (pixbuf);
pixbuf = gnomegadu_stock_get_pixbuf ("gnomegadu-user-invisible");
gtk_list_store_append (status_store, &iter);
gtk_list_store_set (status_store, &iter, UI_STATUS_COLUMN_ICON, pixbuf, UI_STATUS_COLUMN_NAME, "Niewidoczny",
UI_STATUS_COLUMN_STATUS, GNOMEGADU_STATUS_INVISIBLE, -1);
gdk_pixbuf_unref (pixbuf);
pixbuf = gnomegadu_stock_get_pixbuf ("gnomegadu-user-not-available");
gtk_list_store_append (status_store, &iter_init);
gtk_list_store_set (status_store, &iter_init, UI_STATUS_COLUMN_ICON, pixbuf, UI_STATUS_COLUMN_NAME, "Niedostępny",
UI_STATUS_COLUMN_STATUS, GNOMEGADU_STATUS_UNAVAIL, -1);
gdk_pixbuf_unref (pixbuf);
gtk_list_store_append (status_store, &iter);
gtk_list_store_set (status_store, &iter, UI_STATUS_COLUMN_STATUS, GNOMEGADU_STATUS_UNKNOWN, -1);
pixbuf = gnomegadu_stock_get_pixbuf ("gnomegadu-description");
gtk_list_store_append (status_store, &iter);
gtk_list_store_set (status_store, &iter, UI_STATUS_COLUMN_ICON, pixbuf, UI_STATUS_COLUMN_NAME, "Ustaw opis",
UI_STATUS_COLUMN_STATUS, GNOMEGADU_STATUS_DESC, -1);
gdk_pixbuf_unref (pixbuf);
gtk_combo_box_set_row_separator_func (combobox, userlist_combo_separator_func, NULL, NULL);
gtk_combo_box_set_model (combobox, GTK_TREE_MODEL (status_store));
gtk_combo_box_set_active_iter (combobox, &iter_init);
g_object_unref (status_store);
}
static void
gtk_app_chooser_button_build_ui (GtkAppChooserButton *self)
{
GtkCellRenderer *cell;
GtkCellArea *area;
gtk_combo_box_set_model (GTK_COMBO_BOX (self),
GTK_TREE_MODEL (self->priv->store));
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (self));
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (self),
row_separator_func, NULL, NULL);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_area_add_with_properties (area, cell,
"align", FALSE,
"expand", FALSE,
"fixed-size", FALSE,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self), cell,
"gicon", COLUMN_ICON,
NULL);
cell = gtk_cell_renderer_text_new ();
gtk_cell_area_add_with_properties (area, cell,
"align", FALSE,
"expand", TRUE,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self), cell,
"text", COLUMN_LABEL,
NULL);
gtk_app_chooser_button_populate (self);
}
static void
unicapgtk_device_selection_init (UnicapgtkDeviceSelection *combo)
{
GtkListStore *store;
GtkCellRenderer *cell;
store = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_STRING, /* UNICAPGTK_DEVICE_ID */
G_TYPE_STRING, /* UNICAPGTK_DEVICE_VENDOR */
G_TYPE_STRING, /* UNICAPGTK_DEVICE_MODEL */
G_TYPE_STRING, /* LABEL */
G_TYPE_BOOLEAN, /* SENSITIVE */
G_TYPE_INT /* SPECIAL */);
gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combo),
device_combo_box_row_separator,
NULL, NULL);
cell = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT,
"xalign", 0.0,
NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell,
"text", LABEL,
"sensitive", SENSITIVE,
NULL);
device_combo_box_add_none_entry (store);
combo->label_fmt_string = g_strdup( "%v %m" );
}
static void fill_combo_box (GtkIconTheme *theme, GtkComboBox *combo_box, GList *app_list)
{
GList *entry;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeIter iter;
GdkPixbuf *pixbuf;
if (theme == NULL) {
theme = gtk_icon_theme_get_default ();
}
gtk_combo_box_set_row_separator_func (combo_box, is_separator,
GINT_TO_POINTER (g_list_length (app_list)), NULL);
model = GTK_TREE_MODEL (gtk_list_store_new (2, GDK_TYPE_PIXBUF, G_TYPE_STRING));
gtk_combo_box_set_model (combo_box, model);
renderer = gtk_cell_renderer_pixbuf_new ();
/* not all cells have a pixbuf, this prevents the combo box to shrink */
gtk_cell_renderer_set_fixed_size (renderer, -1, 22);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer,
"pixbuf", PIXBUF_COL,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer,
"text", TEXT_COL,
NULL);
for (entry = app_list; entry != NULL; entry = g_list_next (entry)) {
MateDAItem *item;
item = (MateDAItem *) entry->data;
pixbuf = gtk_icon_theme_load_icon (theme, item->icon_name, 22, 0, NULL);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
PIXBUF_COL, pixbuf,
TEXT_COL, item->name,
-1);
item->icon_path = gtk_tree_model_get_string_from_iter (model, &iter);
if (pixbuf)
g_object_unref (pixbuf);
}
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, -1);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
PIXBUF_COL, NULL,
TEXT_COL, _("Custom"),
-1);
}
static void
editing_started (GtkCellRenderer *cell,
GtkCellEditable *editable,
const gchar *path,
gpointer data)
{
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (editable),
separator_row, NULL, NULL);
}
static VALUE
rg_set_row_separator_func(VALUE self)
{
VALUE func = rb_block_proc();
G_RELATIVE(self, func);
gtk_combo_box_set_row_separator_func(_SELF(self),
(GtkTreeViewRowSeparatorFunc)row_separator_func,
(gpointer)func, NULL);
return self;
}
static void
oauth_account_chooser_dialog_init (OAuthAccountChooserDialog *self)
{
GtkWidget *content;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, OAUTH_TYPE_ACCOUNT_CHOOSER_DIALOG, OAuthAccountChooserDialogPrivate);
self->priv->builder = _gtk_builder_new_from_file ("oauth-account-chooser.ui", "oauth");
gtk_window_set_resizable (GTK_WINDOW (self), FALSE);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), 5);
gtk_container_set_border_width (GTK_CONTAINER (self), 5);
content = _gtk_builder_get_widget (self->priv->builder, "account_chooser");
gtk_container_set_border_width (GTK_CONTAINER (content), 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), content, TRUE, TRUE, 0);
{
GtkCellLayout *cell_layout;
GtkCellRenderer *renderer;
cell_layout = GTK_CELL_LAYOUT (GET_WIDGET ("account_combobox"));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (cell_layout, renderer, FALSE);
gtk_cell_layout_set_attributes (cell_layout, renderer,
"icon-name", ACCOUNT_ICON_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (cell_layout, renderer, TRUE);
gtk_cell_layout_set_attributes (cell_layout, renderer,
"text", ACCOUNT_NAME_COLUMN,
NULL);
}
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (GET_WIDGET ("account_combobox")),
row_separator_func,
self,
NULL);
g_signal_connect (GET_WIDGET ("account_combobox"),
"changed",
G_CALLBACK (account_combobox_changed_cb),
self);
gtk_dialog_add_button (GTK_DIALOG (self),
GTK_STOCK_NEW,
OAUTH_ACCOUNT_CHOOSER_RESPONSE_NEW);
gtk_dialog_add_button (GTK_DIALOG (self),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (self),
GTK_STOCK_OK,
GTK_RESPONSE_OK);
gtk_dialog_set_default_response (GTK_DIALOG (self), GTK_RESPONSE_OK);
}
static void
hito_group_combo_init (HitoGroupCombo *self)
{
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self), renderer, TRUE);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (self), renderer,
group_name_data_func, NULL, NULL);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (self),
is_separator_func, NULL, NULL);
}
static void
gimp_color_profile_combo_box_init (GimpColorProfileComboBox *combo_box)
{
GtkCellRenderer *cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), cell, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell,
"text", GIMP_COLOR_PROFILE_STORE_LABEL,
NULL);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combo_box),
gimp_color_profile_row_separator_func,
NULL, NULL);
}
static void
gweather_timezone_menu_init (GWeatherTimezoneMenu *menu)
{
GtkCellRenderer *renderer;
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (menu),
row_separator_func, NULL, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (menu), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (menu), renderer,
"markup", 0,
NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (menu),
renderer, is_sensitive, NULL, NULL);
}
static void
build_branches_combo(GitgWindow *window, GtkBuilder *builder)
{
GtkComboBox *combo = GTK_COMBO_BOX(gtk_builder_get_object(builder, "combo_box_branches"));
window->priv->branches_store = gtk_list_store_new(1, G_TYPE_STRING);
window->priv->combo_branches = combo;
GtkTreeIter iter;
gtk_list_store_append(window->priv->branches_store, &iter);
gtk_list_store_set(window->priv->branches_store, &iter, 0, _("Select branch"), -1);
gtk_combo_box_set_model(combo, GTK_TREE_MODEL(window->priv->branches_store));
gtk_combo_box_set_active(combo, 0);
gtk_combo_box_set_row_separator_func(combo, branches_separator_func, window, NULL);
g_signal_connect(combo, "changed", G_CALLBACK(on_branches_combo_changed), window);
}
static void
gedit_encodings_combo_box_init (GeditEncodingsComboBox *menu)
{
menu->priv = GEDIT_ENCODINGS_COMBO_BOX_GET_PRIVATE (menu);
menu->priv->enc_settings = g_settings_new ("org.gnome.gedit.preferences.encodings");
menu->priv->store = gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_POINTER,
G_TYPE_BOOLEAN);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (menu),
separator_func, NULL,
NULL);
menu->priv->changed_id = g_signal_connect (menu, "changed",
G_CALLBACK (add_or_remove),
menu->priv->store);
}
void
gui_init (dt_imageio_module_storage_t *self)
{
self->gui_data = (dt_storage_flickr_gui_data_t *)g_malloc(sizeof(dt_storage_flickr_gui_data_t));
memset(self->gui_data,0,sizeof(dt_storage_flickr_gui_data_t));
dt_storage_flickr_gui_data_t *ui= self->gui_data;
self->widget = gtk_vbox_new(FALSE, 0);
GtkWidget *hbox1=gtk_hbox_new(FALSE,5);
GtkWidget *hbox0=gtk_hbox_new(FALSE,5);
GtkWidget *vbox1=gtk_vbox_new(FALSE,0);
GtkWidget *vbox2=gtk_vbox_new(FALSE,5);
ui->label1 = GTK_LABEL( gtk_label_new( _("flickr user") ) );
ui->label3 = GTK_LABEL( gtk_label_new( _("photosets") ) );
ui->labelPerms = GTK_LABEL( gtk_label_new( _("visible to") ) );
ui->label4 = GTK_LABEL( gtk_label_new( NULL ) );
set_status(ui,_("click login button to start"), "#ffffff");
ui->label5 = GTK_LABEL( gtk_label_new( _("title") ) );
ui->label6 = GTK_LABEL( gtk_label_new( _("summary") ) );
gtk_misc_set_alignment(GTK_MISC(ui->label1), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->labelPerms), 0.0, 0.9);
gtk_misc_set_alignment(GTK_MISC(ui->label3), 0.0, 0.7);
gtk_misc_set_alignment(GTK_MISC(ui->label5), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label6), 0.0, 0.5);
ui->entry1 = GTK_ENTRY( gtk_entry_new() );
ui->entry3 = GTK_ENTRY( gtk_entry_new() ); // Album title
ui->entry4 = GTK_ENTRY( gtk_entry_new() ); // Album summary
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry1));
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry3));
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry4));
/*
gtk_widget_add_events(GTK_WIDGET(ui->entry1), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry1), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry1), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(ui->entry2), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry2), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry2), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(ui->entry3), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry3), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry3), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(ui->entry4), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry4), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry4), "focus-out-event", G_CALLBACK(focus_out), NULL);
*/
GHashTable* table = dt_pwstorage_get("flickr");
gchar* _username = g_strdup( g_hash_table_lookup(table, "username"));
g_hash_table_destroy(table);
gtk_entry_set_text( ui->entry1, _username == NULL?"":_username );
gtk_entry_set_text( ui->entry3, _("my new photoset") );
gtk_entry_set_text( ui->entry4, _("exported from darktable") );
GtkWidget *albumlist=gtk_hbox_new(FALSE,0);
ui->comboBox1 = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new()); // Available albums
dt_ellipsize_combo(GTK_COMBO_BOX(ui->comboBox1));
ui->dtbutton1 = DTGTK_BUTTON( dtgtk_button_new(dtgtk_cairo_paint_refresh,0) );
g_object_set(G_OBJECT(ui->dtbutton1), "tooltip-text", _("refresh album list"), (char *)NULL);
ui->button = GTK_BUTTON(gtk_button_new_with_label(_("login")));
g_object_set(G_OBJECT(ui->button), "tooltip-text", _("flickr login"), (char *)NULL);
gtk_widget_set_sensitive( GTK_WIDGET(ui->comboBox1), FALSE);
gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(ui->comboBox1), combobox_separator,ui->comboBox1,NULL);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->dtbutton1), FALSE, FALSE, 0);
ui->checkButton2 = GTK_CHECK_BUTTON( gtk_check_button_new_with_label(_("export tags")) );
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON( ui->checkButton2 ),TRUE);
ui->permsComboBox = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new());
gtk_combo_box_text_append_text(ui->permsComboBox, _("you"));
gtk_combo_box_text_append_text(ui->permsComboBox, _("friends"));
gtk_combo_box_text_append_text(ui->permsComboBox, _("family"));
gtk_combo_box_text_append_text(ui->permsComboBox, _("friends + family"));
gtk_combo_box_text_append_text(ui->permsComboBox, _("everyone"));
gtk_combo_box_set_active(GTK_COMBO_BOX(ui->permsComboBox), 0); // Set default permission to private
gtk_box_pack_start(GTK_BOX(self->widget), hbox0, TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->label1 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->entry1 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->button ), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( hbox1 ), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( hbox1 ), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( gtk_label_new("")), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->labelPerms ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label3 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->label4 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->checkButton2 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->permsComboBox ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( albumlist ), TRUE, FALSE, 0);
// Create Album
ui->hbox1=GTK_BOX(gtk_hbox_new(FALSE,5));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox1), TRUE);
vbox1=gtk_vbox_new(FALSE,0);
vbox2=gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox1), TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label5 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label6 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry3 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry4 ), TRUE, FALSE, 0);
// Setup signals
// add signal on realize and hide gtk_widget_hide(GTK_WIDGET(ui->hbox1));
g_signal_connect(G_OBJECT(ui->dtbutton1), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->button), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->entry1), "changed", G_CALLBACK(flickr_entry_changed), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->comboBox1), "changed", G_CALLBACK(flickr_album_changed), (gpointer)ui);
/**
dont' populate the combo on startup, save 3 second
// If username and password is stored, let's populate the combo
if( _username && _password )
{
ui->user_token = _password;
refresh_albums(ui);
}
*/
if( _username )
g_free (_username);
gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox1), 0);
}
GtkDialog*
repair_dialog_new(GSList* files)
{
GObject* object;
GtkDialog* dialog;
GtkComboBox* combobox;
GtkTreeView* treeview;
GtkTreeModel* model;
GtkTreeViewColumn* column;
GtkCellRenderer* renderer;
GtkBuilder* builder;
gboolean include_subdir = FALSE;
builder = gtk_builder_new();
gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
gtk_builder_add_from_file(builder, REPAIR_DIALOG_UI, NULL);
object = gtk_builder_get_object(builder, "repair_dialog");
if (object == NULL)
return NULL;
dialog = GTK_DIALOG(object);
files = g_slist_copy(files);
g_slist_foreach(files, (GFunc)g_object_ref, NULL);
repair_dialog_set_file_list(dialog, files);
g_signal_connect(G_OBJECT(dialog), "destroy",
G_CALLBACK(on_dialog_destroy), NULL);
object = gtk_builder_get_object(builder, "apply_button");
if (object != NULL) {
g_object_set_data(G_OBJECT(dialog), "apply_button", object);
}
object = gtk_builder_get_object(builder, "encoding_combo");
if (object == NULL)
return NULL;
model = (GtkTreeModel*)encoding_list_model_new();
combobox = GTK_COMBO_BOX(object);
gtk_combo_box_set_model(combobox, model);
gtk_combo_box_set_row_separator_func(combobox, is_separator, NULL, NULL);
g_object_unref(G_OBJECT(model));
select_default_encoding(combobox, model);
repair_dialog_set_encoding_combo_box(dialog, combobox);
g_signal_connect(G_OBJECT(combobox), "changed",
G_CALLBACK(on_encoding_changed), dialog);
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox), renderer,
"text", ENCODING_COLUMN_LABEL, NULL);
object = gtk_builder_get_object(builder, "subdir_check_button");
if (object != NULL) {
include_subdir = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(object));
g_object_set_data(G_OBJECT(dialog), "subdir_check_button", object);
g_signal_connect(G_OBJECT(object), "toggled",
G_CALLBACK(on_subdir_check_toggled), dialog);
}
object = gtk_builder_get_object(builder, "file_list_view");
if (object == NULL)
return NULL;
treeview = GTK_TREE_VIEW(object);
repair_dialog_set_file_list_view(dialog, treeview);
model = (GtkTreeModel*)file_list_model_new(files, include_subdir);
repair_dialog_set_file_list_model(dialog, model);
repair_dialog_update_file_list_model(dialog, TRUE);
gtk_tree_view_set_model(treeview, model);
g_object_unref(G_OBJECT(model));
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("As is"),
renderer, "text", FILE_COLUMN_DISPLAY_NAME, NULL);
gtk_tree_view_column_set_sort_column_id(column, FILE_COLUMN_NAME);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(treeview, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("To be"),
renderer, "text", FILE_COLUMN_NEW_NAME, NULL);
gtk_tree_view_column_set_sort_column_id(column, FILE_COLUMN_NEW_NAME);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(treeview, column);
g_object_unref(builder);
return dialog;
}
/* construct widget above */
void gui_init(struct dt_imageio_module_storage_t *self)
{
self->gui_data = g_malloc0(sizeof(dt_storage_facebook_gui_data_t));
dt_storage_facebook_gui_data_t *ui = self->gui_data;
ui->facebook_api = fb_api_init();
self->widget = gtk_vbox_new(FALSE, 0);
//create labels
ui->label_album_title = GTK_LABEL( gtk_label_new( _("title") ) );
ui->label_album_summary = GTK_LABEL( gtk_label_new( _("summary") ) );
ui->label_album_privacy = GTK_LABEL(gtk_label_new(_("privacy")));
ui->label_status = GTK_LABEL(gtk_label_new(NULL));
gtk_misc_set_alignment(GTK_MISC(ui->label_album_title), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label_album_summary), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label_album_privacy), 0.0, 0.5);
//create entries
GtkListStore *model_username = gtk_list_store_new (COMBO_USER_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); //text, token, id
ui->comboBox_username = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_username)));
GtkCellRenderer *p_cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->comboBox_username), p_cell, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (ui->comboBox_username), p_cell, "text", 0, NULL);
ui->entry_album_title = GTK_ENTRY(gtk_entry_new());
ui->entry_album_summary = GTK_ENTRY(gtk_entry_new());
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->comboBox_username));
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_title));
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_summary));
//retrieve saved accounts
ui_refresh_users(ui);
//////// album list /////////
GtkWidget *albumlist = gtk_hbox_new(FALSE, 0);
GtkListStore *model_album = gtk_list_store_new (COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING); //name, id
ui->comboBox_album = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_album)));
p_cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT (ui->comboBox_album), p_cell, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (ui->comboBox_album), p_cell, "text", 0, NULL);
gtk_widget_set_sensitive(GTK_WIDGET(ui->comboBox_album), FALSE);
gtk_combo_box_set_row_separator_func(ui->comboBox_album,combobox_separator,ui->comboBox_album,NULL);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox_album), TRUE, TRUE, 0);
ui->comboBox_privacy= GTK_COMBO_BOX(gtk_combo_box_text_new());
GtkListStore *list_store = gtk_list_store_new (COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_INT);
GtkTreeIter iter;
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("only me"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_SELF, -1);
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_ALL_FRIENDS, -1);
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("public"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_EVERYONE, -1);
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends of friends"), COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_FRIENDS_OF_FRIENDS, -1);
gtk_combo_box_set_model(ui->comboBox_privacy, GTK_TREE_MODEL(list_store));
gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox_privacy), 1); // Set default permission to private
ui->button_login = GTK_BUTTON(gtk_button_new_with_label(_("login")));
ui->connected = FALSE;
//pack the ui
////the auth box
GtkWidget *hbox_auth = gtk_hbox_new(FALSE,5);
GtkWidget *vbox_auth_labels=gtk_vbox_new(FALSE,0);
GtkWidget *vbox_auth_fields=gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox_auth), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->comboBox_username), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_labels), GTK_WIDGET(gtk_label_new("")), TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->button_login), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(albumlist), TRUE, FALSE, 2);
////the album creation box
ui->hbox_album = GTK_BOX(gtk_hbox_new(FALSE,5));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox_album), TRUE); //hide it by default
GtkWidget *vbox_album_labels=gtk_vbox_new(FALSE,0);
GtkWidget *vbox_album_fields=gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox_album), TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_title), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_title), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_summary), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_summary), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_privacy), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->comboBox_privacy), TRUE, FALSE, 0);
//connect buttons to signals
g_signal_connect(G_OBJECT(ui->button_login), "clicked", G_CALLBACK(ui_login_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->comboBox_username), "changed", G_CALLBACK(ui_combo_username_changed), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->comboBox_album), "changed", G_CALLBACK(ui_combo_album_changed), (gpointer)ui);
g_object_unref(model_username);
g_object_unref(model_album);
g_object_unref(list_store);
}
int
main (int argc, char **argv)
{
GtkWidget *window, *cellview, *mainbox;
GtkWidget *combobox, *comboboxtext, *comboboxgrid;
GtkWidget *tmp, *boom;
GtkCellRenderer *renderer;
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
GdkRGBA color;
GtkCellArea *area;
gchar *text;
gint i;
gtk_init (&argc, &argv);
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
if (g_getenv ("LISTMODE"))
{
GtkCssProvider *provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (provider,
"* { -GtkComboBox-appears-as-list: true; }",
-1, NULL);
gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_FALLBACK);
}
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER (window), 5);
g_signal_connect (window, "destroy", gtk_main_quit, NULL);
mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_add (GTK_CONTAINER (window), mainbox);
/* GtkCellView */
tmp = gtk_frame_new ("GtkCellView");
gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
gtk_container_add (GTK_CONTAINER (tmp), boom);
cellview = gtk_cell_view_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cellview),
renderer,
FALSE);
g_object_set (renderer, "icon-name", "dialog-warning", NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (cellview),
renderer,
TRUE);
g_object_set (renderer, "text", "la la la", NULL);
gtk_container_add (GTK_CONTAINER (boom), cellview);
/* GtkComboBox list */
tmp = gtk_frame_new ("GtkComboBox (list)");
gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
gtk_container_add (GTK_CONTAINER (tmp), boom);
model = create_list_blaat ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (boom), combobox);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
renderer,
FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"icon-name", 0,
NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
renderer,
set_sensitive,
NULL, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
renderer,
TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"text", 1,
NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
renderer,
set_sensitive,
NULL, NULL);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox),
is_separator, NULL, NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
/* GtkComboBox dynamic list */
tmp = gtk_frame_new ("GtkComboBox (dynamic list)");
gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
gtk_container_add (GTK_CONTAINER (tmp), boom);
model = create_empty_list_blaat ();
combobox = gtk_combo_box_new_with_model (model);
g_signal_connect (combobox, "notify::popup-shown",
G_CALLBACK (populate_list_blaat), combobox);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (boom), combobox);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
renderer,
FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"icon-name", 0,
NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
renderer,
set_sensitive,
NULL, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
renderer,
TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"text", 1,
NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
renderer,
set_sensitive,
NULL, NULL);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox),
is_separator, NULL, NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
/* GtkComboBox custom entry */
tmp = gtk_frame_new ("GtkComboBox (custom)");
gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
gtk_container_add (GTK_CONTAINER (tmp), boom);
model = create_list_blaat ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (boom), combobox);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
renderer,
FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"icon-name", 0,
NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
renderer,
set_sensitive,
NULL, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
renderer,
TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"text", 1,
NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
renderer,
set_sensitive,
NULL, NULL);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox),
is_separator, NULL, NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
tmp = gtk_cell_view_new ();
gtk_widget_show (tmp);
gtk_cell_view_set_model (GTK_CELL_VIEW (tmp), model);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tmp), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tmp), renderer,
"text", 1,
NULL);
color.red = 1.0;
color.blue = 1.0;
color.green = 0;
color.alpha = 1.0;
gtk_cell_view_set_background_rgba (GTK_CELL_VIEW (tmp), &color);
displayed_row_changed (GTK_COMBO_BOX (combobox), GTK_CELL_VIEW (tmp));
g_signal_connect (combobox, "changed", G_CALLBACK (displayed_row_changed), tmp);
gtk_container_add (GTK_CONTAINER (combobox), tmp);
/* GtkComboBox tree */
tmp = gtk_frame_new ("GtkComboBox (tree)");
gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
gtk_container_add (GTK_CONTAINER (tmp), boom);
model = create_tree_blaat ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (boom), combobox);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
renderer,
FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"icon-name", 0,
NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
renderer,
set_sensitive,
NULL, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
renderer,
TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"text", 1,
NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
renderer,
set_sensitive,
NULL, NULL);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combobox),
is_separator, NULL, NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
#if 0
g_timeout_add (1000, (GSourceFunc) animation_timer, model);
#endif
/* GtkComboBox (grid mode) */
tmp = gtk_frame_new ("GtkComboBox (grid mode)");
gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
gtk_container_add (GTK_CONTAINER (tmp), boom);
comboboxgrid = create_combo_box_grid_demo ();
gtk_box_pack_start (GTK_BOX (boom), comboboxgrid, FALSE, FALSE, 0);
/* GtkComboBoxEntry */
tmp = gtk_frame_new ("GtkComboBox with entry");
gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
gtk_container_add (GTK_CONTAINER (tmp), boom);
comboboxtext = gtk_combo_box_text_new_with_entry ();
setup_combo_entry (GTK_COMBO_BOX_TEXT (comboboxtext));
gtk_container_add (GTK_CONTAINER (boom), comboboxtext);
/* Phylogenetic tree */
tmp = gtk_frame_new ("What are you ?");
gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
gtk_container_add (GTK_CONTAINER (tmp), boom);
model = create_phylogenetic_tree ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (boom), combobox);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
renderer,
TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"text", 0,
NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
/* Capitals */
tmp = gtk_frame_new ("Where are you ?");
gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
gtk_container_add (GTK_CONTAINER (tmp), boom);
model = create_capital_tree ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (boom), combobox);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox),
renderer,
TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"text", 0,
NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combobox),
renderer,
capital_sensitive,
NULL, NULL);
path = gtk_tree_path_new_from_indices (0, 8, -1);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combobox), &iter);
#if 1
gdk_threads_add_timeout (1000, (GSourceFunc) capital_animation, model);
#endif
/* Aligned Food */
tmp = gtk_frame_new ("Hungry ?");
gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
gtk_container_add (GTK_CONTAINER (tmp), boom);
model = create_food_list ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (boom), combobox);
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (combobox));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_area_add_with_properties (area, renderer,
"align", TRUE,
"expand", TRUE,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"text", 0,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_area_add_with_properties (area, renderer,
"align", TRUE,
"expand", TRUE,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"text", 1,
NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
/* Ellipsizing growing combos */
tmp = gtk_frame_new ("Unconstrained Menu");
gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
boom = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (boom), 5);
gtk_container_add (GTK_CONTAINER (tmp), boom);
model = create_list_long ();
combobox = gtk_combo_box_new_with_model (model);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (boom), combobox);
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"text", 0, NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 0);
gtk_combo_box_set_popup_fixed_width (GTK_COMBO_BOX (combobox), FALSE);
tmp = gtk_frame_new ("Looong");
gtk_box_pack_start (GTK_BOX (mainbox), tmp, FALSE, FALSE, 0);
combobox = gtk_combo_box_text_new ();
for (i = 0; i < 200; i++)
{
text = g_strdup_printf ("Item %d", i);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combobox), text);
g_free (text);
}
gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 53);
gtk_container_add (GTK_CONTAINER (tmp), combobox);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
void
caja_autorun_prepare_combo_box (GtkWidget *combo_box,
const char *x_content_type,
gboolean include_ask,
gboolean include_open_with_other_app,
gboolean update_settings,
CajaAutorunComboBoxChanged changed_cb,
gpointer user_data)
{
GList *l;
GList *app_info_list;
GAppInfo *default_app_info;
GtkListStore *list_store;
GtkTreeIter iter;
GdkPixbuf *pixbuf;
int icon_size;
int set_active;
int n;
int num_apps;
gboolean pref_ask;
gboolean pref_start_app;
gboolean pref_ignore;
gboolean pref_open_folder;
CajaAutorunComboBoxData *data;
GtkCellRenderer *renderer;
gboolean new_data;
caja_autorun_get_preferences (x_content_type, &pref_start_app, &pref_ignore, &pref_open_folder);
pref_ask = !pref_start_app && !pref_ignore && !pref_open_folder;
icon_size = caja_get_icon_size_for_stock_size (GTK_ICON_SIZE_MENU);
set_active = -1;
data = NULL;
new_data = TRUE;
app_info_list = g_app_info_get_all_for_type (x_content_type);
default_app_info = g_app_info_get_default_for_type (x_content_type, FALSE);
num_apps = g_list_length (app_info_list);
list_store = gtk_list_store_new (5,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_APP_INFO,
G_TYPE_STRING,
G_TYPE_INT);
/* no apps installed */
if (num_apps == 0)
{
gtk_list_store_append (list_store, &iter);
pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
GTK_STOCK_DIALOG_ERROR,
icon_size,
0,
NULL);
/* TODO: integrate with PackageKit-mate to find applications */
gtk_list_store_set (list_store, &iter,
COLUMN_AUTORUN_PIXBUF, pixbuf,
COLUMN_AUTORUN_NAME, _("No applications found"),
COLUMN_AUTORUN_APP_INFO, NULL,
COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type,
COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_ASK,
-1);
g_object_unref (pixbuf);
}
else
{
if (include_ask)
{
gtk_list_store_append (list_store, &iter);
pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
GTK_STOCK_DIALOG_QUESTION,
icon_size,
0,
NULL);
gtk_list_store_set (list_store, &iter,
COLUMN_AUTORUN_PIXBUF, pixbuf,
COLUMN_AUTORUN_NAME, _("Ask what to do"),
COLUMN_AUTORUN_APP_INFO, NULL,
COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type,
COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_ASK,
-1);
g_object_unref (pixbuf);
}
gtk_list_store_append (list_store, &iter);
pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
GTK_STOCK_CLOSE,
icon_size,
0,
NULL);
gtk_list_store_set (list_store, &iter,
COLUMN_AUTORUN_PIXBUF, pixbuf,
COLUMN_AUTORUN_NAME, _("Do Nothing"),
COLUMN_AUTORUN_APP_INFO, NULL,
COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type,
COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_IGNORE,
-1);
g_object_unref (pixbuf);
gtk_list_store_append (list_store, &iter);
pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
"folder-open",
icon_size,
0,
NULL);
gtk_list_store_set (list_store, &iter,
COLUMN_AUTORUN_PIXBUF, pixbuf,
COLUMN_AUTORUN_NAME, _("Open Folder"),
COLUMN_AUTORUN_APP_INFO, NULL,
COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type,
COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_OPEN_FOLDER,
-1);
g_object_unref (pixbuf);
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
COLUMN_AUTORUN_PIXBUF, NULL,
COLUMN_AUTORUN_NAME, NULL,
COLUMN_AUTORUN_APP_INFO, NULL,
COLUMN_AUTORUN_X_CONTENT_TYPE, NULL,
COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_SEP,
-1);
for (l = app_info_list, n = include_ask ? 4 : 3; l != NULL; l = l->next, n++)
{
GIcon *icon;
CajaIconInfo *icon_info;
char *open_string;
GAppInfo *app_info = l->data;
/* we deliberately ignore should_show because some apps might want
* to install special handlers that should be hidden in the regular
* application launcher menus
*/
icon = g_app_info_get_icon (app_info);
icon_info = caja_icon_info_lookup (icon, icon_size);
pixbuf = caja_icon_info_get_pixbuf_at_size (icon_info, icon_size);
g_object_unref (icon_info);
open_string = g_strdup_printf (_("Open %s"), g_app_info_get_display_name (app_info));
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
COLUMN_AUTORUN_PIXBUF, pixbuf,
COLUMN_AUTORUN_NAME, open_string,
COLUMN_AUTORUN_APP_INFO, app_info,
COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type,
COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_APP,
-1);
if (pixbuf != NULL)
{
g_object_unref (pixbuf);
}
g_free (open_string);
if (g_app_info_equal (app_info, default_app_info))
{
set_active = n;
}
}
}
if (include_open_with_other_app)
{
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter,
COLUMN_AUTORUN_PIXBUF, NULL,
COLUMN_AUTORUN_NAME, NULL,
COLUMN_AUTORUN_APP_INFO, NULL,
COLUMN_AUTORUN_X_CONTENT_TYPE, NULL,
COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_SEP,
-1);
gtk_list_store_append (list_store, &iter);
pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
"application-x-executable",
icon_size,
0,
NULL);
gtk_list_store_set (list_store, &iter,
COLUMN_AUTORUN_PIXBUF, pixbuf,
COLUMN_AUTORUN_NAME, _("Open with other Application..."),
COLUMN_AUTORUN_APP_INFO, NULL,
COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type,
COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_OTHER_APP,
-1);
g_object_unref (pixbuf);
}
if (default_app_info != NULL)
{
g_object_unref (default_app_info);
}
g_list_foreach (app_info_list, (GFunc) g_object_unref, NULL);
g_list_free(app_info_list);
gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (list_store));
g_object_unref (G_OBJECT (list_store));
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo_box));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer,
"pixbuf", COLUMN_AUTORUN_PIXBUF,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer,
"text", COLUMN_AUTORUN_NAME,
NULL);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combo_box), combo_box_separator_func, NULL, NULL);
if (num_apps == 0)
{
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0);
gtk_widget_set_sensitive (combo_box, FALSE);
}
else
{
gtk_widget_set_sensitive (combo_box, TRUE);
if (pref_ask && include_ask)
{
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0);
}
else if (pref_ignore)
{
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), include_ask ? 1 : 0);
}
else if (pref_open_folder)
{
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), include_ask ? 2 : 1);
}
else if (set_active != -1)
{
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), set_active);
}
else
{
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), include_ask ? 1 : 0);
}
/* See if we have an old data around */
data = g_object_get_data (G_OBJECT (combo_box), "caja_autorun_combobox_data");
if (data)
{
new_data = FALSE;
g_free (data->x_content_type);
}
else
{
data = g_new0 (CajaAutorunComboBoxData, 1);
}
data->x_content_type = g_strdup (x_content_type);
data->include_ask = include_ask;
data->include_open_with_other_app = include_open_with_other_app;
data->update_settings = update_settings;
data->changed_cb = changed_cb;
data->user_data = user_data;
data->combo_box = combo_box;
if (data->changed_signal_id == 0)
{
data->changed_signal_id = g_signal_connect (G_OBJECT (combo_box),
"changed",
G_CALLBACK (combo_box_changed),
data);
}
}
if (new_data)
{
g_object_set_data_full (G_OBJECT (combo_box),
"caja_autorun_combobox_data",
data,
(GDestroyNotify) caja_autorun_combobox_data_destroy);
}
}
static void
gth_location_chooser_init (GthLocationChooser *self)
{
GtkCellRenderer *renderer;
gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE);
gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_HORIZONTAL);
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GTH_TYPE_LOCATION_CHOOSER, GthLocationChooserPrivate);
self->priv->entry_points_changed_id = 0;
self->priv->arrow = NULL;
self->priv->show_entry_points = TRUE;
self->priv->relief = GTK_RELIEF_NORMAL;
self->priv->model = gtk_tree_store_new (N_COLUMNS,
G_TYPE_ICON,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
PANGO_TYPE_ELLIPSIZE_MODE);
self->priv->combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (self->priv->model));
g_object_unref (self->priv->model);
g_signal_connect (self->priv->combo,
"changed",
G_CALLBACK (combo_changed_cb),
self);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (self->priv->combo),
row_separator_func,
self,
NULL);
gtk_widget_set_size_request (self->priv->combo, MIN_WIDTH, -1);
/* icon column */
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer,
"follow-state", TRUE,
NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->priv->combo),
renderer,
FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self->priv->combo),
renderer,
"gicon", ICON_COLUMN,
NULL);
/* path column */
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self->priv->combo),
renderer,
TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self->priv->combo),
renderer,
"text", NAME_COLUMN,
"ellipsize", ELLIPSIZE_COLUMN,
NULL);
/**/
gtk_widget_show (self->priv->combo);
gtk_box_pack_start (GTK_BOX (self), self->priv->combo, TRUE, TRUE, 0);
}
void
create_main_window (ContactsData *data)
{
GtkWidget *main_window;
GtkWidget *vbox7;
GtkWidget *main_menubar;
GtkWidget *contacts_menu;
GtkWidget *contacts_menu_menu;
GtkWidget *new_menuitem;
GtkWidget *edit_menuitem;
GtkWidget *delete_menuitem;
GtkWidget *contacts_import;
GtkWidget *contacts_quit;
GtkWidget *contact_menu;
GtkWidget *contact_menu_menu;
GtkWidget *contact_delete;
GtkWidget *edit_groups;
GtkWidget *contact_export;
GtkWidget *contact_quit;
GtkWidget *edit_menu;
GtkWidget *menuitem5_menu;
GtkWidget *cut;
GtkWidget *copy;
GtkWidget *paste;
GtkWidget *help_menu;
GtkWidget *menuitem7_menu;
GtkWidget *about1;
GtkWidget *main_notebook;
GtkWidget *main_hpane;
GtkWidget *contacts_vbox;
GtkWidget *scrolledwindow2;
GtkWidget *contacts_treeview;
GtkWidget *search_hbox;
GtkWidget *search_entry_hbox;
GtkWidget *search_entry;
GtkWidget *search_tab_hbox;
GtkWidget *symbols_radiobutton;
GSList *symbols_radiobutton_group = NULL;
GtkWidget *atog_radiobutton;
GtkWidget *hton_radiobutton;
GtkWidget *otou_radiobutton;
GtkWidget *vtoz_radiobutton;
GtkWidget *vbox3;
GtkWidget *summary_vbox;
GtkWidget *preview_header_hbox;
GtkWidget *preview_namegroup_vbox;
GtkWidget *summary_name_label;
GtkWidget *summary_group_label;
GtkWidget *photo_image;
GtkWidget *scrolledwindow3;
GtkWidget *viewport1;
GtkWidget *summary_table;
GtkWidget *summary_hbuttonbox;
GtkWidget *new_button;
GtkWidget *edit_button;
GtkWidget *delete_button;
GtkWidget *vbox4;
GtkWidget *scrolledwindow4;
GtkWidget *viewport2;
GtkWidget *edit_table;
GtkWidget *hbuttonbox2;
GtkWidget *add_field_button;
GtkWidget *remove_field_button;
GtkWidget *edit_done_button;
GtkWidget *widget;
GtkAccelGroup *accel_group;
ContactsUI *ui = data->ui;
GtkSizeGroup *size_group;
#ifdef HAVE_GCONF
GConfClient *client;
gchar *search;
gint width, height;
#endif
accel_group = gtk_accel_group_new ();
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (main_window), _("Contacts"));
gtk_window_set_icon_name (GTK_WINDOW (main_window), "contacts");
gtk_window_set_default_size (GTK_WINDOW (main_window), 320, 240);
vbox7 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (main_window), vbox7);
main_menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (vbox7), main_menubar, FALSE, FALSE, 0);
contacts_menu = gtk_menu_item_new_with_mnemonic (_("C_ontacts"));
gtk_container_add (GTK_CONTAINER (main_menubar), contacts_menu);
contacts_menu_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (contacts_menu), contacts_menu_menu);
new_menuitem = gtk_image_menu_item_new_from_stock ("gtk-new", accel_group);
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), new_menuitem);
edit_menuitem = gtk_image_menu_item_new_from_stock ("gtk-open", accel_group);
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), edit_menuitem);
gtk_widget_set_sensitive (edit_menuitem, FALSE);
delete_menuitem = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group);
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), delete_menuitem);
gtk_widget_set_sensitive (delete_menuitem, FALSE);
contacts_import = gtk_menu_item_new_with_mnemonic (_("_Import..."));
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), contacts_import);
widget = gtk_separator_menu_item_new ();
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), widget);
gtk_widget_set_sensitive (widget, FALSE);
contacts_quit = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group);
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), contacts_quit);
contact_menu = gtk_menu_item_new_with_mnemonic (_("C_ontact"));
gtk_container_add (GTK_CONTAINER (main_menubar), contact_menu);
g_object_set (G_OBJECT (contact_menu), "no-show-all", TRUE, NULL);
contact_menu_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (contact_menu), contact_menu_menu);
contact_delete = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group);
gtk_container_add (GTK_CONTAINER (contact_menu_menu), contact_delete);
edit_groups = gtk_menu_item_new_with_mnemonic (_("_Groups"));
gtk_container_add (GTK_CONTAINER (contact_menu_menu), edit_groups);
contact_export = gtk_menu_item_new_with_mnemonic (_("_Export"));
gtk_container_add (GTK_CONTAINER (contact_menu_menu), contact_export);
widget = gtk_separator_menu_item_new ();
gtk_container_add (GTK_CONTAINER (contact_menu_menu), widget);
gtk_widget_set_sensitive (widget, FALSE);
contact_quit = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group);
gtk_container_add (GTK_CONTAINER (contact_menu_menu), contact_quit);
edit_menu = gtk_menu_item_new_with_mnemonic (_("Ed_it"));
gtk_container_add (GTK_CONTAINER (main_menubar), edit_menu);
menuitem5_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (edit_menu), menuitem5_menu);
cut = gtk_image_menu_item_new_from_stock ("gtk-cut", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem5_menu), cut);
copy = gtk_image_menu_item_new_from_stock ("gtk-copy", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem5_menu), copy);
paste = gtk_image_menu_item_new_from_stock ("gtk-paste", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem5_menu), paste);
help_menu = gtk_menu_item_new_with_mnemonic (_("_Help"));
gtk_container_add (GTK_CONTAINER (main_menubar), help_menu);
menuitem7_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (help_menu), menuitem7_menu);
about1 = gtk_image_menu_item_new_from_stock ("gtk-about", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem7_menu), about1);
main_notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (vbox7), main_notebook, TRUE, TRUE, 0);
GTK_WIDGET_UNSET_FLAGS (main_notebook, GTK_CAN_FOCUS);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (main_notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (main_notebook), FALSE);
main_hpane = gtk_hpaned_new ();
gtk_container_add (GTK_CONTAINER (main_notebook), main_hpane);
contacts_vbox = gtk_vbox_new (FALSE, 6);
gtk_paned_pack1 (GTK_PANED (main_hpane), contacts_vbox, FALSE, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (contacts_vbox), 6);
groups_combobox = gtk_combo_box_new ();
GtkListStore *ls = gtk_list_store_new (1, G_TYPE_STRING);
GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (groups_combobox),
groups_combo_seperator_func, NULL, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (groups_combobox), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (groups_combobox), renderer, "text", 0);
gtk_combo_box_set_model (GTK_COMBO_BOX (groups_combobox), GTK_TREE_MODEL(ls));
gtk_box_pack_start (GTK_BOX (contacts_vbox), groups_combobox, FALSE, TRUE, 0);
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (groups_combobox), FALSE);
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (contacts_vbox), scrolledwindow2, TRUE, TRUE, 0);
GTK_WIDGET_UNSET_FLAGS (scrolledwindow2, GTK_CAN_FOCUS);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN);
contacts_treeview = gtk_tree_view_new ();
gtk_container_add (GTK_CONTAINER (scrolledwindow2), contacts_treeview);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (contacts_treeview), FALSE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (contacts_treeview), FALSE);
search_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_end (GTK_BOX (contacts_vbox), search_hbox, FALSE, TRUE, 0);
search_entry_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (search_hbox), search_entry_hbox, TRUE, TRUE, 0);
search_entry = gtk_entry_new ();
gtk_box_pack_end (GTK_BOX (search_entry_hbox), search_entry, TRUE, TRUE, 0);
gtk_entry_set_activates_default (GTK_ENTRY (search_entry), TRUE);
widget = gtk_label_new_with_mnemonic (_("_Search:"));
gtk_box_pack_start (GTK_BOX (search_entry_hbox), widget, FALSE, FALSE, 0);
gtk_misc_set_padding (GTK_MISC (widget), 6, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), search_entry);
search_tab_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (search_hbox), search_tab_hbox, TRUE, TRUE, 0);
g_object_set (G_OBJECT (search_tab_hbox), "no-show-all", TRUE, NULL);
symbols_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("0-9#"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), symbols_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (symbols_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (symbols_radiobutton));
atog_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("A-G"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), atog_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (atog_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (atog_radiobutton));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (atog_radiobutton), TRUE);
hton_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("H-N"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), hton_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (hton_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (hton_radiobutton));
otou_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("O-U"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), otou_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (otou_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (otou_radiobutton));
vtoz_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("V-Z"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), vtoz_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (vtoz_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (vtoz_radiobutton));
vbox3 = gtk_vbox_new (FALSE, 6);
gtk_paned_pack2 (GTK_PANED (main_hpane), vbox3, TRUE, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (vbox3), 6);
summary_vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox3), summary_vbox, TRUE, TRUE, 0);
preview_header_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (summary_vbox), preview_header_hbox, FALSE, TRUE, 0);
preview_namegroup_vbox = gtk_vbox_new (FALSE, 0);
summary_name_label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (preview_namegroup_vbox), summary_name_label, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (summary_name_label, GTK_CAN_FOCUS);
gtk_label_set_use_markup (GTK_LABEL (summary_name_label), TRUE);
gtk_label_set_selectable (GTK_LABEL (summary_name_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (summary_name_label), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (summary_name_label), 6, 0);
gtk_label_set_ellipsize (GTK_LABEL (summary_name_label), PANGO_ELLIPSIZE_END);
summary_group_label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (preview_namegroup_vbox), summary_group_label, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (summary_group_label, GTK_CAN_FOCUS);
gtk_label_set_use_markup (GTK_LABEL (summary_group_label), TRUE);
gtk_label_set_selectable (GTK_LABEL (summary_group_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (summary_group_label), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (summary_group_label), 6, 0);
gtk_label_set_ellipsize (GTK_LABEL (summary_group_label), PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (preview_header_hbox), preview_namegroup_vbox, TRUE, TRUE, 0);
/* load stock_person as the default icon so the image has the correct
* size before a contact is loaded */
photo_image = gtk_image_new_from_icon_name ("stock_person", GTK_ICON_SIZE_DIALOG);
gtk_box_pack_end (GTK_BOX (preview_header_hbox), photo_image, FALSE, TRUE, 6);
gtk_misc_set_padding (GTK_MISC (photo_image), 1, 0);
scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (summary_vbox), scrolledwindow3, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
viewport1 = gtk_viewport_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolledwindow3), viewport1);
summary_table = gtk_table_new (1, 2, FALSE);
gtk_container_add (GTK_CONTAINER (viewport1), summary_table);
gtk_table_set_row_spacings (GTK_TABLE (summary_table), 6);
gtk_table_set_col_spacings (GTK_TABLE (summary_table), 6);
summary_hbuttonbox = gtk_hbutton_box_new ();
gtk_box_pack_end (GTK_BOX (vbox3), summary_hbuttonbox, FALSE, FALSE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (summary_hbuttonbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (summary_hbuttonbox), 6);
new_button = gtk_button_new_from_stock ("gtk-new");
gtk_container_add (GTK_CONTAINER (summary_hbuttonbox), new_button);
GTK_WIDGET_SET_FLAGS (new_button, GTK_CAN_DEFAULT);
edit_button = gtk_button_new_from_stock ("gtk-edit");
gtk_container_add (GTK_CONTAINER (summary_hbuttonbox), edit_button);
gtk_widget_set_sensitive (edit_button, FALSE);
GTK_WIDGET_SET_FLAGS (edit_button, GTK_CAN_DEFAULT);
delete_button = gtk_button_new_from_stock ("gtk-delete");
gtk_container_add (GTK_CONTAINER (summary_hbuttonbox), delete_button);
gtk_widget_set_sensitive (delete_button, FALSE);
GTK_WIDGET_SET_FLAGS (delete_button, GTK_CAN_DEFAULT);
gtk_button_set_focus_on_click (GTK_BUTTON (delete_button), FALSE);
vbox4 = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (main_notebook), vbox4);
gtk_container_set_border_width (GTK_CONTAINER (vbox4), 6);
scrolledwindow4 = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (vbox4), scrolledwindow4, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow4), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
viewport2 = gtk_viewport_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolledwindow4), viewport2);
edit_table = gtk_table_new (1, 2, FALSE);
gtk_container_add (GTK_CONTAINER (viewport2), edit_table);
gtk_container_set_border_width (GTK_CONTAINER (edit_table), 6);
gtk_table_set_row_spacings (GTK_TABLE (edit_table), 6);
hbuttonbox2 = gtk_hbutton_box_new ();
gtk_box_pack_start (GTK_BOX (vbox4), hbuttonbox2, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox2), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbuttonbox2), 6);
add_field_button = gtk_button_new_with_mnemonic (_("_Add Field"));
gtk_container_add (GTK_CONTAINER (hbuttonbox2), add_field_button);
GTK_WIDGET_SET_FLAGS (add_field_button, GTK_CAN_DEFAULT);
remove_field_button = gtk_button_new_with_mnemonic (_("_Remove Field"));
gtk_container_add (GTK_CONTAINER (hbuttonbox2), remove_field_button);
GTK_WIDGET_SET_FLAGS (remove_field_button, GTK_CAN_DEFAULT);
gtk_button_set_focus_on_click (GTK_BUTTON (remove_field_button), FALSE);
edit_done_button = gtk_button_new_from_stock ("gtk-close");
gtk_container_add (GTK_CONTAINER (hbuttonbox2), edit_done_button);
GTK_WIDGET_SET_FLAGS (edit_done_button, GTK_CAN_DEFAULT);
gtk_widget_grab_focus (contacts_treeview);
gtk_widget_grab_default (edit_button);
gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group);
/* Set up size group for bottom row of buttons and search */
size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
gtk_size_group_add_widget (size_group, search_hbox);
gtk_size_group_add_widget (size_group, summary_hbuttonbox);
g_object_unref (size_group);
/* connect signals */
g_signal_connect (G_OBJECT (main_window), "delete-event",
G_CALLBACK (contacts_main_window_delete_event_cb), data);
g_signal_connect ((gpointer) main_window, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect_swapped ((gpointer) main_window, "set_focus",
G_CALLBACK (contacts_edit_set_focus_cb),
GTK_OBJECT (remove_field_button));
g_signal_connect ((gpointer) contacts_quit, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect ((gpointer) contact_quit, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect_swapped ((gpointer) cut, "activate",
G_CALLBACK (contacts_cut_cb),
GTK_OBJECT (main_window));
g_signal_connect_swapped ((gpointer) copy, "activate",
G_CALLBACK (contacts_copy_cb),
GTK_OBJECT (main_window));
g_signal_connect_swapped ((gpointer) paste, "activate",
G_CALLBACK (contacts_paste_cb),
GTK_OBJECT (main_window));
g_signal_connect_swapped ((gpointer) about1, "activate",
G_CALLBACK (contacts_about_cb),
main_window);
g_signal_connect_swapped ((gpointer) groups_combobox, "changed",
G_CALLBACK (contacts_update_treeview),
data);
g_signal_connect_data ((gpointer) contacts_treeview, "key_press_event",
G_CALLBACK (contacts_treeview_search_cb),
GTK_OBJECT (search_entry),
NULL, G_CONNECT_AFTER | G_CONNECT_SWAPPED);
g_signal_connect ((gpointer) search_entry, "changed",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) symbols_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) atog_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) hton_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) otou_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) vtoz_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) remove_field_button, "clicked",
G_CALLBACK (contacts_remove_field_cb),
NULL);
g_signal_connect (G_OBJECT (new_button), "clicked",
G_CALLBACK (contacts_new_cb), data);
g_signal_connect (G_OBJECT (new_menuitem), "activate",
G_CALLBACK (contacts_new_cb), data);
g_signal_connect (G_OBJECT (edit_button), "clicked",
G_CALLBACK (contacts_edit_cb), data);
g_signal_connect (G_OBJECT (contacts_treeview), "row_activated",
G_CALLBACK (contacts_treeview_edit_cb), data);
g_signal_connect (G_OBJECT (edit_menuitem), "activate",
G_CALLBACK (contacts_edit_cb), data);
g_signal_connect (G_OBJECT (delete_button), "clicked",
G_CALLBACK (contacts_delete_cb), data);
g_signal_connect (G_OBJECT (delete_menuitem), "activate",
G_CALLBACK (contacts_delete_cb), data);
g_signal_connect (G_OBJECT (contacts_import), "activate",
G_CALLBACK (contacts_import_cb), data);
g_signal_connect (G_OBJECT (edit_menu), "activate",
G_CALLBACK (contacts_edit_menu_activate_cb), data);
g_signal_connect (G_OBJECT (groups_combobox), "changed",
G_CALLBACK (groups_combobox_changed_cb), data);
ui->contact_delete = contact_delete;
ui->contact_export = contact_export;
ui->contact_menu = contact_menu;
ui->contacts_import = contacts_import;
ui->contacts_menu = contacts_menu;
ui->contacts_treeview = contacts_treeview;
ui->new_menuitem = new_menuitem;
ui->copy_menuitem = copy;
ui->cut_menuitem = cut;
ui->delete_menuitem = delete_menuitem;
ui->delete_button = delete_button;
ui->edit_menuitem = edit_menuitem;
ui->edit_button = edit_button;
ui->edit_done_button = edit_done_button;
ui->edit_groups = edit_groups;
ui->edit_menu = edit_menu;
ui->edit_table = edit_table;
ui->main_menubar = main_menubar;
ui->main_notebook = main_notebook;
ui->main_window = main_window;
ui->new_button = new_button;
ui->paste_menuitem = paste;
ui->photo_image = photo_image;
ui->preview_header_hbox = preview_header_hbox;
ui->add_field_button = add_field_button;
ui->remove_field_button = remove_field_button;
ui->search_entry = search_entry;
ui->search_entry_hbox = search_entry_hbox;
ui->search_hbox = search_hbox;
ui->search_tab_hbox = search_tab_hbox;
//ui->groups_combobox = groups_combobox;
ui->summary_hbuttonbox = summary_hbuttonbox;
ui->summary_name_label = summary_name_label;
ui->summary_group_label = summary_group_label;
ui->summary_table = summary_table;
ui->summary_vbox = summary_vbox;
#ifdef HAVE_GCONF
client = gconf_client_get_default ();
search = gconf_client_get_string (client, GCONF_KEY_SEARCH, NULL);
if (!search) {
gconf_client_set_string (
client, GCONF_KEY_SEARCH, "entry", NULL);
} else {
if (strcmp (search, "alphatab") == 0) {
gtk_widget_hide (search_entry_hbox);
gtk_widget_show (search_tab_hbox);
}
g_free (search);
}
gconf_client_add_dir (client, GCONF_PATH, GCONF_CLIENT_PRELOAD_NONE,
NULL);
gconf_client_notify_add (client, GCONF_KEY_SEARCH,
contacts_gconf_search_cb, data, NULL, NULL);
width = gconf_client_get_int (client, GCONF_PATH "/width", NULL);
height = gconf_client_get_int (client, GCONF_PATH "/height", NULL);
gtk_window_set_default_size (GTK_WINDOW (main_window), width, height);
#endif
}
GtkWidget* file_properties_dlg_new( GtkWindow* parent,
const char* dir_path,
GList* sel_files, int page )
{
GtkBuilder* builder = _gtk_builder_new_from_file( PACKAGE_UI_DIR "/file_properties.ui", NULL );
GtkWidget * dlg = (GtkWidget*)gtk_builder_get_object( builder, "dlg" );
GtkNotebook* notebook = (GtkNotebook*)gtk_builder_get_object( builder, "notebook" );
FilePropertiesDialogData* data;
gboolean need_calc_size = TRUE;
VFSFileInfo *file, *file2;
VFSMimeType* mime;
const char* multiple_files = _( "( multiple files )" );
const char* calculating;
GtkWidget* name = (GtkWidget*)gtk_builder_get_object( builder, "file_name" );
GtkWidget* location = (GtkWidget*)gtk_builder_get_object( builder, "location" );
gtk_editable_set_editable ( GTK_EDITABLE( location ), FALSE );
GtkWidget* mime_type = (GtkWidget*)gtk_builder_get_object( builder, "mime_type" );
GtkWidget* open_with = (GtkWidget*)gtk_builder_get_object( builder, "open_with" );
GtkWidget* mtime = (GtkWidget*)gtk_builder_get_object( builder, "mtime" );
GtkWidget* atime = (GtkWidget*)gtk_builder_get_object( builder, "atime" );
char buf[ 64 ];
char buf2[ 32 ];
const char* time_format = "%Y-%m-%d %H:%M";
gchar* disp_path;
gchar* file_type;
int i;
GList* l;
gboolean same_type = TRUE;
gboolean is_dirs = FALSE;
char *owner_group, *tmp;
gtk_dialog_set_alternative_button_order( GTK_DIALOG(dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1 );
ptk_dialog_fit_small_screen( GTK_DIALOG(dlg) );
int width = xset_get_int( "app_dlg", "s" );
int height = xset_get_int( "app_dlg", "z" );
if ( width && height )
gtk_window_set_default_size( GTK_WINDOW( dlg ), width, height );
data = g_slice_new0( FilePropertiesDialogData );
/* FIXME: When will the data be freed??? */
g_object_set_data( G_OBJECT( dlg ), "DialogData", data );
data->file_list = sel_files;
data->dlg = dlg;
data->dir_path = g_strdup( dir_path );
disp_path = g_filename_display_name( dir_path );
//gtk_label_set_text( GTK_LABEL( location ), disp_path );
gtk_entry_set_text( GTK_ENTRY( location ), disp_path );
g_free( disp_path );
data->total_size_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "total_size" ) );
data->size_on_disk_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "size_on_disk" ) );
data->count_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "count" ) );
data->owner = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "owner" ) );
data->group = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "group" ) );
for ( i = 0; i < N_CHMOD_ACTIONS; ++i )
{
data->chmod_btns[ i ] = GTK_TOGGLE_BUTTON( (GtkWidget*)gtk_builder_get_object( builder, chmod_names[ i ] ) );
}
//MOD
VFSMimeType* type;
VFSMimeType* type2 = NULL;
for ( l = sel_files; l ; l = l->next )
{
file = ( VFSFileInfo* ) l->data;
type = vfs_file_info_get_mime_type( file );
if ( !type2 )
type2 = vfs_file_info_get_mime_type( file );
if ( vfs_file_info_is_dir( file ) )
is_dirs = TRUE;
if ( type != type2 )
same_type = FALSE;
vfs_mime_type_unref( type );
if ( is_dirs && !same_type )
break;
}
if ( type2 )
vfs_mime_type_unref( type2 );
data->recurse = (GtkWidget*)gtk_builder_get_object( builder, "recursive" );
gtk_widget_set_sensitive( data->recurse, is_dirs );
/* //MOD
for ( l = sel_files; l && l->next; l = l->next )
{
VFSMimeType *type, *type2;
file = ( VFSFileInfo* ) l->data;
file2 = ( VFSFileInfo* ) l->next->data;
type = vfs_file_info_get_mime_type( file );
type2 = vfs_file_info_get_mime_type( file2 );
if ( type != type2 )
{
vfs_mime_type_unref( type );
vfs_mime_type_unref( type2 );
same_type = FALSE;
break;
}
vfs_mime_type_unref( type );
vfs_mime_type_unref( type2 );
}
*/
file = ( VFSFileInfo* ) sel_files->data;
if ( same_type )
{
mime = vfs_file_info_get_mime_type( file );
file_type = g_strdup_printf( "%s ( %s )",
vfs_mime_type_get_description( mime ),
vfs_mime_type_get_type( mime ) );
gtk_label_set_text( GTK_LABEL( mime_type ), file_type );
g_free( file_type );
vfs_mime_type_unref( mime );
}
else
{
gtk_label_set_text( GTK_LABEL( mime_type ), _( "( multiple types )" ) );
}
/* Open with...
* Don't show this option menu if files of different types are selected,
* ,the selected file is a folder, or its type is unknown.
*/
if( ! same_type ||
vfs_file_info_is_dir( file ) ||
vfs_file_info_is_desktop_entry( file ) ||
vfs_file_info_is_unknown_type( file ) ||
vfs_file_info_is_executable( file, NULL ) )
{
/* if open with shouldn't show, destroy it. */
gtk_widget_destroy( open_with );
open_with = NULL;
gtk_widget_destroy( (GtkWidget*)gtk_builder_get_object( builder, "open_with_label" ) );
}
else /* Add available actions to the option menu */
{
GtkTreeIter it;
char **action, **actions;
mime = vfs_file_info_get_mime_type( file );
actions = vfs_mime_type_get_actions( mime );
GtkCellRenderer* renderer;
GtkListStore* model;
gtk_cell_layout_clear( GTK_CELL_LAYOUT(open_with) );
renderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, FALSE);
gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with), renderer,
"pixbuf", 0, NULL );
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, TRUE);
gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with),renderer,
"text", 1, NULL );
model = gtk_list_store_new( 3, GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING );
if( actions )
{
for( action = actions; *action; ++action )
{
VFSAppDesktop* desktop;
GdkPixbuf* icon;
desktop = vfs_app_desktop_new( *action );
gtk_list_store_append( model, &it );
icon = vfs_app_desktop_get_icon(desktop, 20, TRUE);
gtk_list_store_set( model, &it,
0, icon,
1, vfs_app_desktop_get_disp_name(desktop),
2, *action, -1 );
if( icon )
g_object_unref( icon );
vfs_app_desktop_unref( desktop );
}
}
else
{
g_object_set_data( G_OBJECT(open_with), "prev_sel", GINT_TO_POINTER(-1) );
}
/* separator */
gtk_list_store_append( model, &it );
gtk_list_store_append( model, &it );
gtk_list_store_set( model, &it,
0, NULL,
1, _("Choose..."), -1 );
gtk_combo_box_set_model( GTK_COMBO_BOX(open_with),
GTK_TREE_MODEL(model) );
gtk_combo_box_set_row_separator_func(
GTK_COMBO_BOX(open_with), combo_sep,
NULL, NULL );
gtk_combo_box_set_active(GTK_COMBO_BOX(open_with), 0);
g_signal_connect( open_with, "changed",
G_CALLBACK(on_combo_change), mime );
/* vfs_mime_type_unref( mime ); */
/* We can unref mime when combo box gets destroyed */
g_object_weak_ref( G_OBJECT(open_with),
(GWeakNotify)vfs_mime_type_unref, mime );
}
g_object_set_data( G_OBJECT(dlg), "open_with", open_with );
/* Multiple files are selected */
if ( sel_files && sel_files->next )
{
gtk_widget_set_sensitive( name, FALSE );
gtk_entry_set_text( GTK_ENTRY( name ), multiple_files );
gtk_label_set_text( GTK_LABEL( mtime ), "-" );
gtk_label_set_text( GTK_LABEL( atime ), "-" );
for ( i = 0; i < N_CHMOD_ACTIONS; ++i )
{
gtk_toggle_button_set_inconsistent ( data->chmod_btns[ i ], TRUE );
data->chmod_states[ i ] = 2; /* Don't touch this bit */
g_signal_connect( G_OBJECT( data->chmod_btns[ i ] ), "toggled",
G_CALLBACK( on_chmod_btn_toggled ), data );
}
}
else
{
/* special processing for files with special display names */
if( vfs_file_info_is_desktop_entry( file ) )
{
char* disp_name = g_filename_display_name( file->name );
gtk_entry_set_text( GTK_ENTRY( name ),
disp_name );
g_free( disp_name );
}
else
gtk_entry_set_text( GTK_ENTRY( name ),
vfs_file_info_get_disp_name( file ) );
gtk_editable_set_editable ( GTK_EDITABLE( name ), FALSE );
if ( ! vfs_file_info_is_dir( file ) )
{
/* Only single "file" is selected, so we don't need to
caculate total file size */
need_calc_size = FALSE;
sprintf( buf, _("%s ( %llu bytes )"),
vfs_file_info_get_disp_size( file ),
( guint64 ) vfs_file_info_get_size( file ) );
gtk_label_set_text( data->total_size_label, buf );
vfs_file_size_to_string( buf2,
vfs_file_info_get_blocks( file ) * 512 );
sprintf( buf, _("%s ( %llu bytes )"), buf2,
( guint64 ) vfs_file_info_get_blocks( file ) * 512 );
gtk_label_set_text( data->size_on_disk_label, buf );
gtk_label_set_text( data->count_label, _("1 file") );
}
gtk_label_set_text( GTK_LABEL( mtime ),
vfs_file_info_get_disp_mtime( file ) );
strftime( buf, sizeof( buf ),
time_format, localtime( vfs_file_info_get_atime( file ) ) );
gtk_label_set_text( GTK_LABEL( atime ), buf );
owner_group = (char *) vfs_file_info_get_disp_owner( file );
tmp = strchr( owner_group, ':' );
data->owner_name = g_strndup( owner_group, tmp - owner_group );
gtk_entry_set_text( GTK_ENTRY( data->owner ), data->owner_name );
data->group_name = g_strdup( tmp + 1 );
gtk_entry_set_text( GTK_ENTRY( data->group ), data->group_name );
for ( i = 0; i < N_CHMOD_ACTIONS; ++i )
{
if ( data->chmod_states[ i ] != 2 ) /* allow to touch this bit */
{
data->chmod_states[ i ] = ( vfs_file_info_get_mode( file ) & chmod_flags[ i ] ? 1 : 0 );
gtk_toggle_button_set_active( data->chmod_btns[ i ], data->chmod_states[ i ] );
}
}
}
if ( need_calc_size )
{
/* The total file size displayed in "File Properties" is not
completely calculated yet. So "Calculating..." is displayed. */
calculating = _( "Calculating..." );
gtk_label_set_text( data->total_size_label, calculating );
gtk_label_set_text( data->size_on_disk_label, calculating );
g_object_set_data( G_OBJECT( dlg ), "calc_size", data );
data->calc_size_thread = g_thread_create ( ( GThreadFunc ) calc_size,
data, TRUE, NULL );
data->update_label_timer = g_timeout_add( 250,
( GSourceFunc ) on_update_labels,
data );
}
g_signal_connect( dlg, "response",
G_CALLBACK(on_dlg_response), dlg );
g_signal_connect_swapped( gtk_builder_get_object(builder, "ok_button"),
"clicked",
G_CALLBACK(gtk_widget_destroy), dlg );
g_signal_connect_swapped( gtk_builder_get_object(builder, "cancel_button"),
"clicked",
G_CALLBACK(gtk_widget_destroy), dlg );
g_object_unref( builder );
gtk_notebook_set_current_page( notebook, page );
gtk_window_set_transient_for( GTK_WINDOW( dlg ), parent );
return dlg;
}
/**
* empathy_account_chooser_set_has_all_option:
* @chooser: an #EmpathyAccountChooser
* @has_all_option: a new value for the #EmpathyAccountChooser:has-all-option property
*
* Sets the #EmpathyAccountChooser:has-all-option property.
*/
void
empathy_account_chooser_set_has_all_option (EmpathyAccountChooser *chooser,
gboolean has_all_option)
{
EmpathyAccountChooserPriv *priv;
GtkComboBox *combobox;
GtkListStore *store;
GtkTreeModel *model;
GtkTreeIter iter;
g_return_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser));
priv = GET_PRIV (chooser);
if (priv->has_all_option == has_all_option) {
return;
}
combobox = GTK_COMBO_BOX (chooser);
model = gtk_combo_box_get_model (combobox);
store = GTK_LIST_STORE (model);
priv->has_all_option = has_all_option;
/*
* The first 2 options are the ALL and separator
*/
if (has_all_option) {
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (chooser),
(GtkTreeViewRowSeparatorFunc)
account_chooser_separator_func,
chooser,
NULL);
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter,
COL_ACCOUNT_TEXT, NULL,
COL_ACCOUNT_ENABLED, TRUE,
COL_ACCOUNT_POINTER, NULL,
-1);
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter,
COL_ACCOUNT_TEXT, _("All"),
COL_ACCOUNT_ENABLED, TRUE,
COL_ACCOUNT_POINTER, NULL,
-1);
} else {
if (gtk_tree_model_get_iter_first (model, &iter)) {
if (gtk_list_store_remove (GTK_LIST_STORE (model), &iter)) {
gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
}
}
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (chooser),
(GtkTreeViewRowSeparatorFunc)
NULL,
NULL,
NULL);
}
g_object_notify (G_OBJECT (chooser), "has-all-option");
}
GtkWidget *
gimp_paint_mode_menu_new (gboolean with_behind_mode,
gboolean with_replace_modes)
{
GtkListStore *store;
GtkWidget *combo;
store = gimp_enum_store_new_with_values (GIMP_TYPE_LAYER_MODE_EFFECTS,
25,
GIMP_NORMAL_MODE,
GIMP_DISSOLVE_MODE,
GIMP_LIGHTEN_ONLY_MODE,
GIMP_SCREEN_MODE,
GIMP_DODGE_MODE,
GIMP_ADDITION_MODE,
GIMP_DARKEN_ONLY_MODE,
GIMP_MULTIPLY_MODE,
GIMP_BURN_MODE,
GIMP_NEW_OVERLAY_MODE,
GIMP_SOFTLIGHT_MODE,
GIMP_HARDLIGHT_MODE,
GIMP_DIFFERENCE_MODE,
GIMP_SUBTRACT_MODE,
GIMP_GRAIN_EXTRACT_MODE,
GIMP_GRAIN_MERGE_MODE,
GIMP_DIVIDE_MODE,
GIMP_HUE_MODE,
GIMP_SATURATION_MODE,
GIMP_COLOR_MODE,
GIMP_VALUE_MODE,
GIMP_LCH_HUE_MODE,
GIMP_LCH_CHROMA_MODE,
GIMP_LCH_COLOR_MODE,
GIMP_LCH_LIGHTNESS_MODE);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_DISSOLVE_MODE, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_ADDITION_MODE, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_BURN_MODE, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_HARDLIGHT_MODE, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_DIVIDE_MODE, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_VALUE_MODE, -1);
if (with_behind_mode)
{
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_DISSOLVE_MODE,
GIMP_BEHIND_MODE);
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_BEHIND_MODE,
GIMP_COLOR_ERASE_MODE);
}
if (with_replace_modes)
{
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_NORMAL_MODE,
GIMP_REPLACE_MODE);
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_COLOR_ERASE_MODE,
GIMP_ERASE_MODE);
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_ERASE_MODE,
GIMP_ANTI_ERASE_MODE);
}
combo = gimp_enum_combo_box_new_with_model (GIMP_ENUM_STORE (store));
g_object_unref (store);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combo),
gimp_paint_mode_menu_separator_func,
GINT_TO_POINTER (-1),
NULL);
return combo;
}
/**
* autoar_gtk_chooser_simple_new:
* @default_format: an #AutoarFormat
* @default_filter: an #AutoarFilter
*
* Create a #GtkComboBox with a list of common archive format. There is also
* an option called "Other format…", which will use
* autoar_gtk_chooser_advanced_new() and
* autoar_gtk_chooser_advanced_get() to select less common archive
* format. Arguments @default_format and @default_filter are the default archive
* format selected on the returned widget. You may want to get the preferred
* format of users using autoar_pref_get_default_format() and
* autoar_pref_get_default_filter(), or just set them to 1 to select
* the default archive format.
*
* Returns: (transfer full): a new #GtkComboBox widget
**/
GtkWidget*
autoar_gtk_chooser_simple_new (AutoarFormat default_format,
AutoarFilter default_filter)
{
GtkWidget *simple_widget;
GtkComboBox *simple_combo;
GtkCellLayout *simple;
GtkCellRenderer *cell_renderer;
GtkTreeModel *model;
GtkListStore *store;
GtkTreeIter iter;
int i;
int *previous;
struct format_filter
{
AutoarFormat format;
AutoarFilter filter;
};
struct format_filter defaults [] = {
{ AUTOAR_FORMAT_ZIP, AUTOAR_FILTER_NONE },
{ AUTOAR_FORMAT_TAR, AUTOAR_FILTER_NONE },
{ AUTOAR_FORMAT_TAR, AUTOAR_FILTER_GZIP },
{ AUTOAR_FORMAT_TAR, AUTOAR_FILTER_BZIP2 },
{ AUTOAR_FORMAT_TAR, AUTOAR_FILTER_XZ },
{ AUTOAR_FORMAT_CPIO, AUTOAR_FILTER_NONE },
{ AUTOAR_FORMAT_7ZIP, AUTOAR_FILTER_NONE },
};
store = gtk_list_store_new (N_SIMPLE_COLS, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING);
model = GTK_TREE_MODEL (store);
for (i = 0; i < sizeof (defaults) / sizeof (struct format_filter); i++) {
char *description;
gtk_list_store_append (store, &iter);
description = format_filter_full_description (defaults[i].format,
defaults[i].filter);
gtk_list_store_set (store, &iter,
SIMPLE_COL_FORMAT, defaults[i].format,
SIMPLE_COL_FILTER, defaults[i].filter,
SIMPLE_COL_DESCRIPTION, description, -1);
g_free (description);
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
SIMPLE_COL_FORMAT, 0,
SIMPLE_COL_FILTER, 0,
SIMPLE_COL_DESCRIPTION, "", -1);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
SIMPLE_COL_FORMAT, 0,
SIMPLE_COL_FILTER, 0,
SIMPLE_COL_DESCRIPTION, _("Other format…"), -1);
simple_widget = gtk_combo_box_new_with_model (model);
simple = GTK_CELL_LAYOUT (simple_widget);
simple_combo = GTK_COMBO_BOX (simple_widget);
cell_renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (simple, cell_renderer, FALSE);
gtk_cell_layout_add_attribute (simple, cell_renderer, "text", SIMPLE_COL_DESCRIPTION);
previous = g_new (int, 2);
g_object_set_data_full ((GObject*)simple, "previous", previous, g_free);
simple_set_active (simple_combo, model, default_format, default_filter);
gtk_combo_box_set_row_separator_func (simple_combo, simple_row_separator_cb, NULL, NULL);
g_signal_connect (simple, "changed", G_CALLBACK (simple_changed_cb), NULL);
g_object_unref (store);
return simple_widget;
}
/* construct widget above */
void gui_init(struct dt_imageio_module_storage_t *self)
{
self->gui_data = g_malloc0(sizeof(dt_storage_gphoto_gui_data_t));
dt_storage_gphoto_gui_data_t *ui = self->gui_data;
ui->gphoto_api = gphoto_api_init();
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
// create labels
ui->label_album_title = GTK_LABEL(gtk_label_new(_("title")));
ui->label_status = GTK_LABEL(gtk_label_new(NULL));
gtk_widget_set_halign(GTK_WIDGET(ui->label_album_title), GTK_ALIGN_START);
// create entries
GtkListStore *model_username
= gtk_list_store_new(COMBO_USER_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING); // text, token, refresh_token, id
ui->combo_username = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_username)));
GtkCellRenderer *p_cell = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(p_cell), "ellipsize", PANGO_ELLIPSIZE_MIDDLE, "ellipsize-set", TRUE, "width-chars", 35,
(gchar *)0);
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->combo_username), p_cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->combo_username), p_cell, "text", 0, NULL);
ui->entry_album_title = GTK_ENTRY(gtk_entry_new());
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->combo_username));
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_title));
// retrieve saved accounts
ui_refresh_users(ui);
//////// album list /////////
GtkWidget *albumlist = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkListStore *model_album
= gtk_list_store_new(COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING); // name, id
ui->combo_album = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_album)));
p_cell = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(p_cell), "ellipsize", PANGO_ELLIPSIZE_MIDDLE, "ellipsize-set", TRUE, "width-chars", 35,
(gchar *)0);
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->combo_album), p_cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->combo_album), p_cell, "text", 0, NULL);
gtk_widget_set_sensitive(GTK_WIDGET(ui->combo_album), FALSE);
gtk_combo_box_set_row_separator_func(ui->combo_album, combobox_separator, ui->combo_album, NULL);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->combo_album), TRUE, TRUE, 0);
ui->button_login = GTK_BUTTON(gtk_button_new_with_label(_("login")));
ui->connected = FALSE;
// pack the ui
////the auth box
GtkWidget *hbox_auth = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
GtkWidget *vbox_auth_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *vbox_auth_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox_auth), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->combo_username), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_labels), GTK_WIDGET(gtk_label_new("")), TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->button_login), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(albumlist), TRUE, FALSE, 2);
////the album creation box
ui->hbox_album = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox_album), TRUE); // hide it by default
GtkWidget *vbox_album_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *vbox_album_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox_album), TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_title), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_title), TRUE, FALSE, 0);
// connect buttons to signals
g_signal_connect(G_OBJECT(ui->button_login), "clicked", G_CALLBACK(ui_login_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->combo_username), "changed", G_CALLBACK(ui_combo_username_changed),
(gpointer)ui);
g_signal_connect(G_OBJECT(ui->combo_album), "changed", G_CALLBACK(ui_combo_album_changed), (gpointer)ui);
g_object_unref(model_username);
g_object_unref(model_album);
}
GtkWidget *
status_menu_new (Ekiga::ServiceCore & core)
{
StatusMenu *self = NULL;
GtkCellRenderer *renderer = NULL;
GSList *custom_status_array [NUM_STATUS_TYPES];
self = (StatusMenu *) g_object_new (STATUS_MENU_TYPE, NULL);
self->priv = new StatusMenuPrivate ();
self->priv->personal_details = core.get<Ekiga::PersonalDetails> ("personal-details");
self->priv->personal_data_settings =
boost::shared_ptr<Ekiga::Settings> (new Ekiga::Settings (PERSONAL_DATA_SCHEMA));
self->priv->parent = NULL;
self->priv->list_store = gtk_list_store_new (NUM_COLUMNS,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_BOOLEAN);
gtk_combo_box_set_model (GTK_COMBO_BOX (self),
GTK_TREE_MODEL (self->priv->list_store));
g_object_unref (self->priv->list_store);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "yalign", 0.5, "xpad", 5, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self), renderer, "pixbuf", COL_ICON, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (self), renderer, "text", COL_MESSAGE, NULL);
g_object_set (renderer, "width", 130,
"ellipsize-set", true,
"ellipsize", PANGO_ELLIPSIZE_END, NULL);
for (int i = 0 ; i < NUM_STATUS_TYPES ; i++)
custom_status_array [i] = self->priv->personal_data_settings->get_slist (status_types_keys [i]);
status_menu_populate (self, custom_status_array);
for (int i = 0 ; i < NUM_STATUS_TYPES ; i++) {
g_slist_foreach (custom_status_array [i], (GFunc) g_free, 0);
g_slist_free (custom_status_array [i]);
}
gtk_combo_box_set_active (GTK_COMBO_BOX (self), 0);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (self),
(GtkTreeViewRowSeparatorFunc) status_menu_row_is_separator,
NULL, NULL);
gtk_container_set_border_width (GTK_CONTAINER (self), 0);
status_menu_set_option (self, self->priv->personal_details->get_presence (), self->priv->personal_details->get_status ());
g_signal_connect (self, "changed",
G_CALLBACK (status_menu_option_changed), self);
g_signal_connect (self->priv->personal_data_settings->get_g_settings (),
"changed::available-custom-status",
G_CALLBACK (status_menu_custom_messages_changed), self);
g_signal_connect (self->priv->personal_data_settings->get_g_settings (),
"changed::away-custom-status",
G_CALLBACK (status_menu_custom_messages_changed), self);
g_signal_connect (self->priv->personal_data_settings->get_g_settings (),
"changed::busy-custom-status",
G_CALLBACK (status_menu_custom_messages_changed), self);
self->priv->connection =
self->priv->personal_details->updated.connect (boost::bind (&on_details_updated, self));
return GTK_WIDGET (self);
}
GtkWidget *
do_combobox (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
GtkWidget *vbox, *frame, *box, *combo;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreePath *path;
GtkTreeIter iter;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Combo boxes");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_add (GTK_CONTAINER (window), vbox);
/* A combobox demonstrating cell renderers, separators and
* insensitive rows
*/
frame = gtk_frame_new ("Some stock icons");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
box = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (box), 5);
gtk_container_add (GTK_CONTAINER (frame), box);
model = create_stock_icon_store ();
combo = gtk_combo_box_new_with_model (model);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (box), combo);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer,
"pixbuf", PIXBUF_COL,
NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo),
renderer,
set_sensitive,
NULL, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer,
"text", TEXT_COL,
NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo),
renderer,
set_sensitive,
NULL, NULL);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combo),
is_separator, NULL, NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
/* A combobox demonstrating trees.
*/
frame = gtk_frame_new ("Where are we ?");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
box = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (box), 5);
gtk_container_add (GTK_CONTAINER (frame), box);
model = create_capital_store ();
combo = gtk_combo_box_new_with_model (model);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (box), combo);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer,
"text", 0,
NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo),
renderer,
is_capital_sensitive,
NULL, NULL);
path = gtk_tree_path_new_from_indices (0, 8, -1);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &iter);
/* A GtkComboBoxEntry
*/
frame = gtk_frame_new ("Editable");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
box = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (box), 5);
gtk_container_add (GTK_CONTAINER (frame), box);
combo = gtk_combo_box_entry_new_text ();
fill_combo_entry (combo);
gtk_container_add (GTK_CONTAINER (box), combo);
}
if (!GTK_WIDGET_VISIBLE (window))
{
gtk_widget_show_all (window);
}
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
