void wxBitmapComboBox::GTKCreateComboBoxWidget()
{
GtkListStore *store;
store = gtk_list_store_new( 2, G_TYPE_OBJECT, G_TYPE_STRING );
if ( HasFlag(wxCB_READONLY) )
{
m_widget = gtk_combo_box_new_with_model( GTK_TREE_MODEL(store) );
}
else
{
m_widget = gtk_combo_box_entry_new_with_model( GTK_TREE_MODEL(store), m_stringCellIndex );
m_entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(m_widget)));
gtk_editable_set_editable(GTK_EDITABLE(m_entry), true);
}
g_object_ref(m_widget);
// This must be called as gtk_combo_box_entry_new_with_model adds
// automatically adds one text column.
gtk_cell_layout_clear( GTK_CELL_LAYOUT(m_widget) );
GtkCellRenderer* imageRenderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(m_widget),
imageRenderer, FALSE);
gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(m_widget),
imageRenderer, "pixbuf", 0);
GtkCellRenderer* textRenderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_end( GTK_CELL_LAYOUT(m_widget),
textRenderer, TRUE );
gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(m_widget),
textRenderer, "text", 1);
}
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
brasero_medium_selection_set_show_used_space (BraseroMediumSelection *selector)
{
GtkCellRenderer *renderer;
gtk_cell_layout_clear (GTK_CELL_LAYOUT (selector));
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "follow-state", TRUE, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector), renderer,
"gicon", ICON_COL,
NULL);
renderer = gtk_cell_renderer_progress_new ();
g_object_set (renderer, "xpad", 4, "text-xalign", 0.0, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector), renderer,
"text", NAME_COL,
"value", USED_COL,
"visible", VISIBLE_PROGRESS_COL,
NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "xpad", 4, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector), renderer,
"markup", NAME_COL,
"visible", VISIBLE_TEXT_COL,
NULL);
}
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
scheme_combo_init (GtkComboBox *combo)
{
GtkListStore *store;
MooLangMgr *mgr;
GSList *list, *l;
GtkCellRenderer *cell;
mgr = moo_lang_mgr_default ();
list = moo_lang_mgr_list_schemes (mgr);
g_return_if_fail (list != NULL);
store = gtk_list_store_new (1, MOO_TYPE_TEXT_STYLE_SCHEME);
for (l = list; l != NULL; l = l->next)
{
GtkTreeIter iter;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, l->data, -1);
}
gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store));
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), cell,
(GtkCellLayoutDataFunc) scheme_combo_data_func,
NULL, NULL);
g_object_unref (store);
g_slist_foreach (list, (GFunc) g_object_unref, NULL);
g_slist_free (list);
}
void
seahorse_combo_keys_attach (GtkComboBox *combo,
GcrCollection *collection,
const gchar *none_option)
{
GtkTreeModel *model;
GtkTreeIter iter;
GtkCellRenderer *renderer;
GList *l, *objects;
g_object_set_data_full (G_OBJECT (combo), "combo-keys-closure",
combo_closure_new (), combo_closure_free);
/* Setup the None Option */
model = gtk_combo_box_get_model (combo);
if (!model) {
model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER));
gtk_combo_box_set_model (combo, model);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer,
"markup", COMBO_MARKUP);
}
/* Setup the object list */
objects = gcr_collection_get_objects (collection);
for (l = objects; l != NULL; l = g_list_next (l))
on_collection_added (collection, l->data, combo);
g_list_free (objects);
g_signal_connect_after (collection, "added", G_CALLBACK (on_collection_added), combo);
g_signal_connect_after (collection, "removed", G_CALLBACK (on_collection_removed), combo);
if (none_option) {
gtk_list_store_prepend (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
COMBO_LABEL, NULL,
COMBO_MARKUP, none_option,
COMBO_POINTER, NULL,
-1);
}
gtk_tree_model_get_iter_first (model, &iter);
gtk_combo_box_set_active_iter (combo, &iter);
g_signal_connect_data (combo, "destroy", G_CALLBACK (on_combo_destroy),
g_object_ref (collection), (GClosureNotify)g_object_unref, 0);
}
static void
account_chooser_constructed (GObject *object)
{
EmpathyAccountChooser *self = (EmpathyAccountChooser *) object;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkComboBox *combobox;
if (G_OBJECT_CLASS (empathy_account_chooser_parent_class)->constructed)
G_OBJECT_CLASS
(empathy_account_chooser_parent_class)->constructed (object);
/* Set up combo box with new store */
combobox = GTK_COMBO_BOX (self);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox));
store = gtk_list_store_new (COL_ACCOUNT_COUNT,
GDK_TYPE_PIXBUF, /* Image */
G_TYPE_STRING, /* Name */
G_TYPE_BOOLEAN, /* Enabled */
G_TYPE_UINT, /* Row type */
TP_TYPE_ACCOUNT);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store),
account_cmp, self, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
gtk_combo_box_set_model (combobox, GTK_TREE_MODEL (store));
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,
"pixbuf", COL_ACCOUNT_IMAGE,
"sensitive", COL_ACCOUNT_ENABLED,
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", COL_ACCOUNT_TEXT,
"sensitive", COL_ACCOUNT_ENABLED,
NULL);
/* Populate accounts */
tp_proxy_prepare_async (self->priv->manager, NULL,
account_manager_prepared_cb, self);
g_object_unref (store);
}
void XAP_makeGtkComboBoxText2(GtkComboBox * combo, GType secondary,
GType tertiary)
{
GtkListStore * store;
store = gtk_list_store_new(3, G_TYPE_STRING, secondary, tertiary);
gtk_combo_box_set_model(combo, GTK_TREE_MODEL(store));
gtk_cell_layout_clear(GTK_CELL_LAYOUT(combo));
GtkCellRenderer *cell = GTK_CELL_RENDERER(gtk_cell_renderer_text_new());
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), cell, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), cell,
"text", 0, NULL);
}
static void
ipreferences_merge(IAnjutaPreferences* ipref, AnjutaPreferences* prefs, GError** e)
{
/* Add preferences */
SourceviewPlugin* plugin = ANJUTA_PLUGIN_SOURCEVIEW (ipref);
GtkCellRenderer* renderer_name = gtk_cell_renderer_text_new ();
GtkCellRenderer* renderer_desc = gtk_cell_renderer_text_new ();
GtkTreeIter* iter = NULL;
GError* error = NULL;
builder = gtk_builder_new ();
if (!gtk_builder_add_from_file(builder, PREFS_GLADE, &error))
{
DEBUG_PRINT ("Could load sourceview preferences: %s", error->message);
g_error_free (error);
return;
}
anjuta_preferences_add_from_builder (prefs,
builder,
plugin->settings,
"Editor",
_("GtkSourceView Editor"),
ICON_FILE);
plugin->check_font = GTK_WIDGET (gtk_builder_get_object (builder,
FONT_USE_THEME_BUTTON));
g_signal_connect(G_OBJECT(plugin->check_font), "toggled",
G_CALLBACK(on_font_check_toggled), builder);
on_font_check_toggled (GTK_TOGGLE_BUTTON (plugin->check_font), builder);
/* Init styles combo */
plugin->combo_styles = GTK_WIDGET (gtk_builder_get_object (builder, COMBO_STYLES));
gtk_combo_box_set_model (GTK_COMBO_BOX (plugin->combo_styles),
create_style_model(plugin->settings, &iter));
g_signal_connect (plugin->combo_styles, "changed", G_CALLBACK (on_style_changed), plugin);
gtk_cell_layout_clear (GTK_CELL_LAYOUT(plugin->combo_styles));
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(plugin->combo_styles), renderer_name, TRUE);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(plugin->combo_styles), renderer_desc, FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(plugin->combo_styles), renderer_name,
"text", COLUMN_NAME);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(plugin->combo_styles), renderer_desc,
"text", COLUMN_DESC);
g_object_set (renderer_desc,
"style", PANGO_STYLE_ITALIC, NULL);
if (iter)
{
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (plugin->combo_styles),
iter);
gtk_tree_iter_free (iter);
}
}
/* col 0 is for the full path, col 1 is just the filename and is what gets displayed */
void filename_combo_box_build_model(GtkComboBox *cbox)
{
GtkListStore *store;
GtkCellRenderer *renderer;
store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
gtk_combo_box_set_model(GTK_COMBO_BOX(cbox), GTK_TREE_MODEL(store));
gtk_cell_layout_clear(GTK_CELL_LAYOUT(cbox));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(cbox), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(cbox), renderer,
"text", 1,
NULL);
}
static void
account_chooser_setup (EmpathyAccountChooser *chooser)
{
EmpathyAccountChooserPriv *priv;
GList *accounts;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkComboBox *combobox;
priv = GET_PRIV (chooser);
/* Set up combo box with new store */
combobox = GTK_COMBO_BOX (chooser);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox));
store = gtk_list_store_new (COL_ACCOUNT_COUNT,
G_TYPE_STRING, /* Image */
G_TYPE_STRING, /* Name */
G_TYPE_BOOLEAN, /* Enabled */
EMPATHY_TYPE_ACCOUNT);
gtk_combo_box_set_model (combobox, GTK_TREE_MODEL (store));
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", COL_ACCOUNT_IMAGE,
"sensitive", COL_ACCOUNT_ENABLED,
NULL);
g_object_set (renderer, "stock-size", GTK_ICON_SIZE_BUTTON, 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", COL_ACCOUNT_TEXT,
"sensitive", COL_ACCOUNT_ENABLED,
NULL);
/* Populate accounts */
accounts = empathy_account_manager_dup_accounts (priv->manager);
g_list_foreach (accounts,
(GFunc) account_chooser_account_add_foreach,
chooser);
g_list_free (accounts);
g_object_unref (store);
}
void on_btnSearch_clicked (GtkWidget *widget, void * user_data) {
puts("\nFunction on_btnSearch_clicked:");
if (!strcmp((const char *)gtk_entry_get_text(gui->urlTxt),"")) puts("Empty URL provided");
else puts((const char *)gtk_entry_get_text(gui->urlTxt));
if (strcmp((const char *)gtk_entry_get_text(gui->urlTxt),"")) {
int size,k;
GtkListStore* list_store;
GtkCellRenderer* renderer;
GtkTreeIter iter;
gtk_cell_layout_clear(GTK_CELL_LAYOUT(gui->qualBox));
list_store = gtk_list_store_new ( 1 , GTK_TYPE_STRING);
gtk_combo_box_set_model(GTK_COMBO_BOX(gui->qualBox), GTK_TREE_MODEL(list_store));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(gui->qualBox), renderer, 0x01);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(gui->qualBox), renderer, "text", 0, NULL);
gtk_widget_set_sensitive(widget,0x00);
get_format((const char *)gtk_entry_get_text(gui->urlTxt), &size);
printf("Got format. Size: %d\n", size);
// cstring format[size];
puts("Format info:");
for (k=0; k<size; ++k) {
cstring format = malloc(35*sizeof(char));
sprintf(format,"%d: %s [%s]%c",quality[k]->value,quality[k]->format, quality[k]->size,'\0');
GtkTreeIter * iter;
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, 0, format,-1);
free(format);
}
// cstring filename = malloc(257*sizeof(char));
get_title((const char *) gtk_entry_get_text(gui->urlTxt), &title);
printf("%s.%s\n",title,quality[0]->format);
// sprintf(filename,"%s.%s", title, quality[0]->format);
gtk_combo_box_set_active(GTK_COMBO_BOX(gui->qualBox),0);
gtk_widget_set_sensitive(widget,0x01);
//http://www.youtube.com/watch?v=SniIBm-PWUM
}
}
static void
gtk_cell_layout_default_clear (GtkCellLayout *cell_layout)
{
GtkCellLayoutIface *iface;
GtkCellArea *area;
iface = GTK_CELL_LAYOUT_GET_IFACE (cell_layout);
if (iface->get_area)
{
area = iface->get_area (cell_layout);
if (area)
gtk_cell_layout_clear (GTK_CELL_LAYOUT (area));
else
warn_no_cell_area ("GtkCellLayoutIface->clear()");
}
}
static void
combo_add_columns (GtkComboBox *combo)
{
GtkCellRenderer *renderer;
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer,
"pixbuf", NFS_HOST_COL_PIXBUF);
g_object_unref (renderer);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer,
"text", NFS_HOST_COL_NAME);
g_object_unref (renderer);
}
static void
set_combo_box_enum_model (GtkComboBox* combo_box, const ATPEnumType* list)
{
GtkTreeModel *model;
GtkCellRenderer * renderer;
model = GTK_TREE_MODEL (gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT));
for (; list->id != -1;++list)
{
GtkTreeIter iter;
gtk_list_store_append (GTK_LIST_STORE(model), &iter);
gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, _(list->name), 1, list->id, -1);
}
gtk_combo_box_set_model (combo_box, model);
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_clear (GTK_CELL_LAYOUT(combo_box));
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(combo_box), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(combo_box), renderer, "text", 0 );
}
void populate_combo_box(GtkWidget *widget, GList *list) {
GtkListStore *store;
GtkCellRenderer *renderer;
store = gtk_list_store_new(1, G_TYPE_STRING);
// Clear existing data from combo box
gtk_cell_layout_clear(GTK_CELL_LAYOUT(widget));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(widget), renderer, FALSE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(widget), renderer, "text", 0);
while (list != NULL) {
GtkTreeIter iter;
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, (char *)list->data, -1);
list = list->next;
}
gtk_combo_box_set_model(GTK_COMBO_BOX(widget), GTK_TREE_MODEL(store));
}
static void
fill_pilots_combo (GnomePilotCapplet *gpcap)
{
GnomePilotCappletPrivate *priv;
GList *tmp;
GPilotPilot *pilot = NULL;
GtkListStore *store;
GtkTreeIter iter;
priv = gpcap->priv;
store = gtk_list_store_new(1, G_TYPE_STRING);
tmp = priv->state->pilots;
while (tmp != NULL) {
if (pilot == NULL)
pilot = tmp->data;
gtk_list_store_append(store, &iter);
gtk_list_store_set (store, &iter, 0, ((GPilotPilot*)tmp->data)->name, -1);
tmp = tmp->next;
}
g_signal_connect (G_OBJECT(priv->pilots_combo),"changed",
G_CALLBACK (gpcap_conduits_choose_pilot),
gpcap);
gtk_combo_box_set_model (GTK_COMBO_BOX (priv->pilots_combo), GTK_TREE_MODEL(store));
gtk_cell_layout_clear(GTK_CELL_LAYOUT(priv->pilots_combo));
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->pilots_combo),
renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (priv->pilots_combo),
renderer, "text", 0);
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->pilots_combo), 0);
set_conduit_pilot (gpcap, pilot);
}
static void
lang_combo_init (GtkComboBox *combo,
MooPrefsPage *page,
PrefsLangsXml *gxml)
{
GtkTreeModel *model;
GtkCellRenderer *cell;
MooTreeHelper *helper;
fix_style (GTK_WIDGET (combo));
model = page_get_lang_model (page);
g_return_if_fail (model != NULL);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell,
"text", COLUMN_NAME, NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), cell,
set_sensitive, NULL, NULL);
gtk_combo_box_set_model (combo, model);
_moo_combo_box_select_first (combo);
helper = _moo_tree_helper_new (GTK_WIDGET (combo), NULL, NULL, NULL, NULL);
g_return_if_fail (helper != NULL);
g_object_set_data_full (G_OBJECT (page), "moo-tree-helper",
helper, g_object_unref);
g_signal_connect_swapped (helper, "update-widgets",
G_CALLBACK (helper_update_widgets), gxml);
g_signal_connect_swapped (helper, "update-model",
G_CALLBACK (helper_update_model), gxml);
_moo_tree_helper_update_widgets (helper);
}
static void
gimp_unit_combo_box_style_set (GtkWidget *widget,
GtkStyle *prev_style)
{
GtkCellLayout *layout;
GtkCellRenderer *cell;
gdouble scale;
GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
gtk_widget_style_get (widget, "label-scale", &scale, NULL);
/* hackedehack ... */
layout = GTK_CELL_LAYOUT (gtk_bin_get_child (GTK_BIN (widget)));
gtk_cell_layout_clear (layout);
cell = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT,
"scale", scale,
NULL);
gtk_cell_layout_pack_start (layout, cell, TRUE);
gtk_cell_layout_set_attributes (layout, cell,
"text", GIMP_UNIT_STORE_UNIT_SHORT_FORMAT,
NULL);
}
static void
fill_model_combo (GtkWidget *combo, const char *mount_path)
{
GHashTable *models;
Itdb_Device *device;
GtkTreeStore *store;
const Itdb_IpodInfo *ipod_info;
GtkCellRenderer *renderer;
struct FillModelContext ctx;
device = itdb_device_new ();
itdb_device_set_mountpoint (device, mount_path);
itdb_device_read_sysinfo (device);
ipod_info = itdb_device_get_ipod_info (device);
itdb_device_free (device);
store = gtk_tree_store_new (1, G_TYPE_POINTER);
gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (store));
ctx.combo = combo;
ctx.store = store;
ctx.ipod_info = ipod_info;
models = build_model_table (mount_path);
g_hash_table_foreach (models, fill_one_generation, &ctx);
g_hash_table_destroy (models);
g_object_unref (store);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo),
renderer,
set_cell,
NULL, NULL);
}
void
desktop_init (AppearanceData *data,
const gchar **uris)
{
GtkWidget *add_button, *w;
GtkCellRenderer *cr;
char *url;
data->wp_update_settings = TRUE;
data->wp_uris = NULL;
if (uris != NULL) {
while (*uris != NULL) {
data->wp_uris = g_slist_append (data->wp_uris, g_strdup (*uris));
uris++;
}
}
w = appearance_capplet_get_widget (data, "more_backgrounds_linkbutton");
url = g_settings_get_string (data->settings, MORE_BACKGROUNDS_URL_KEY);
if (url != NULL && url[0] != '\0') {
gtk_link_button_set_uri (GTK_LINK_BUTTON (w), url);
gtk_widget_show (w);
} else {
gtk_widget_hide (w);
}
g_free (url);
data->wp_hash = g_hash_table_new (g_str_hash, g_str_equal);
g_signal_connect (data->wp_settings,
"changed::" WP_FILE_KEY,
G_CALLBACK (wp_file_changed),
data);
g_signal_connect (data->wp_settings,
"changed::" WP_OPTIONS_KEY,
G_CALLBACK (wp_options_changed),
data);
g_signal_connect (data->wp_settings,
"changed::" WP_SHADING_KEY,
G_CALLBACK (wp_shading_changed),
data);
g_signal_connect (data->wp_settings,
"changed::" WP_PCOLOR_KEY,
G_CALLBACK (wp_color1_changed),
data);
g_signal_connect (data->wp_settings,
"changed::" WP_SCOLOR_KEY,
G_CALLBACK (wp_color2_changed),
data);
data->wp_model = GTK_TREE_MODEL (gtk_list_store_new (2, GDK_TYPE_PIXBUF,
G_TYPE_POINTER));
data->wp_view = GTK_ICON_VIEW (appearance_capplet_get_widget (data, "wp_view"));
gtk_icon_view_set_model (data->wp_view, GTK_TREE_MODEL (data->wp_model));
g_signal_connect_after (data->wp_view, "realize",
(GCallback) wp_select_after_realize, data);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (data->wp_view));
cr = gtk_cell_renderer_pixbuf_new ();
g_object_set (cr, "xpad", 5, "ypad", 5, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->wp_view), cr, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->wp_view), cr,
"pixbuf", 0,
NULL);
cr = gtk_cell_renderer_pixbuf_new ();
create_button_images (data);
g_object_set (cr,
"mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE,
"pixbuf", buttons[0],
NULL);
g_object_set_data (G_OBJECT (cr), "buttons", GINT_TO_POINTER (TRUE));
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->wp_view), cr, FALSE);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (data->wp_view), cr,
buttons_cell_data_func, data, NULL);
g_signal_connect (data->wp_view, "selection-changed",
(GCallback) wp_selected_changed_cb, data);
g_signal_connect (data->wp_view, "button-press-event",
G_CALLBACK (wp_button_press_cb), data);
data->frame = -1;
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (data->wp_model), 1,
(GtkTreeIterCompareFunc) wp_list_sort,
data, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->wp_model),
1, GTK_SORT_ASCENDING);
gtk_drag_dest_set (GTK_WIDGET (data->wp_view), GTK_DEST_DEFAULT_ALL, drop_types,
G_N_ELEMENTS (drop_types), GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect (data->wp_view, "drag_data_received",
(GCallback) wp_drag_received, data);
gtk_drag_source_set (GTK_WIDGET (data->wp_view), GDK_BUTTON1_MASK,
drag_types, G_N_ELEMENTS (drag_types), GDK_ACTION_COPY);
g_signal_connect (data->wp_view, "drag-data-get",
(GCallback) wp_drag_get_data, data);
data->wp_style_menu = appearance_capplet_get_widget (data, "wp_style_menu");
g_signal_connect (data->wp_style_menu, "changed",
(GCallback) wp_scale_type_changed, data);
data->wp_color_menu = appearance_capplet_get_widget (data, "wp_color_menu");
g_signal_connect (data->wp_color_menu, "changed",
(GCallback) wp_shade_type_changed, data);
data->wp_scpicker = appearance_capplet_get_widget (data, "wp_scpicker");
g_signal_connect (data->wp_scpicker, "color-set",
(GCallback) wp_scolor_changed, data);
data->wp_pcpicker = appearance_capplet_get_widget (data, "wp_pcpicker");
g_signal_connect (data->wp_pcpicker, "color-set",
(GCallback) wp_scolor_changed, data);
add_button = appearance_capplet_get_widget (data, "wp_add_button");
gtk_button_set_image (GTK_BUTTON (add_button),
gtk_image_new_from_stock ("gtk-add", GTK_ICON_SIZE_BUTTON));
g_signal_connect (add_button, "clicked",
(GCallback) wp_file_open_dialog, data);
data->wp_rem_button = appearance_capplet_get_widget (data, "wp_rem_button");
g_signal_connect (data->wp_rem_button, "clicked",
(GCallback) wp_remove_wallpaper, data);
data->screen_monitors_handler = g_signal_connect (gtk_widget_get_screen (GTK_WIDGET (data->wp_view)),
"monitors-changed",
G_CALLBACK (screen_monitors_changed),
data);
data->screen_size_handler = g_signal_connect (gtk_widget_get_screen (GTK_WIDGET (data->wp_view)),
"size-changed",
G_CALLBACK (screen_monitors_changed),
data);
g_signal_connect (data->wp_view, "selection-changed",
(GCallback) wp_props_wp_selected, data);
g_signal_connect (data->wp_view, "query-tooltip",
(GCallback) wp_view_tooltip_cb, data);
gtk_widget_set_has_tooltip (GTK_WIDGET (data->wp_view), TRUE);
wp_set_sensitivities (data);
/* create the file selector later to save time on startup */
data->wp_filesel = NULL;
}
void
info_load_iface (Netinfo *info)
{
GtkTreeModel *model;
GtkTreeIter iter;
GtkCellRenderer *renderer;
GList *items = NULL;
GList *p;
GdkPixbuf *pixbuf = NULL;
gchar *iface = NULL;
gchar *text;
items = info_get_interfaces (info);
p = items;
model = gtk_combo_box_get_model (GTK_COMBO_BOX (info->combo));
if (!items) {
iface = g_strdup_printf ("<i>%s</i>", _("Network Devices Not Found"));
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
0, NULL,
1, iface,
2, (gpointer) NULL,
-1);
g_free (iface);
} else {
while (p) {
text = g_strdup (p->data);
info_get_interface_from_dev_name (text, &iface, &pixbuf);
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
0, pixbuf,
1, iface,
2, (gpointer) text,
-1);
g_free (iface);
g_object_unref (pixbuf);
p = g_list_next (p);
}
g_list_free (items);
}
gtk_cell_layout_clear (GTK_CELL_LAYOUT (info->combo));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (info->combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (info->combo), renderer,
"pixbuf", 0, NULL);
g_object_unref (renderer);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (info->combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (info->combo), renderer,
"markup", 1, NULL);
g_object_unref (renderer);
gtk_combo_box_set_active (GTK_COMBO_BOX (info->combo), 0);
}
/* Gets the widgets from the XML file and returns TRUE if they are all available. */
static gboolean
get_widgets (Dialog *dialog)
{
dialog->toplevel = e_builder_get_widget (dialog->builder, "alarm-dialog");
if (!dialog->toplevel)
return FALSE;
dialog->action_combo = e_builder_get_widget (dialog->builder, "action-combobox");
dialog->interval_value = e_builder_get_widget (dialog->builder, "interval-value");
dialog->value_units_combo = e_builder_get_widget (dialog->builder, "value-units-combobox");
dialog->relative_combo = e_builder_get_widget (dialog->builder, "relative-combobox");
dialog->time_combo = e_builder_get_widget (dialog->builder, "time-combobox");
dialog->repeat_toggle = e_builder_get_widget (dialog->builder, "repeat-toggle");
dialog->repeat_group = e_builder_get_widget (dialog->builder, "repeat-group");
dialog->repeat_quantity = e_builder_get_widget (dialog->builder, "repeat-quantity");
dialog->repeat_value = e_builder_get_widget (dialog->builder, "repeat-value");
dialog->repeat_unit_combo = e_builder_get_widget (dialog->builder, "repeat-unit-combobox");
dialog->option_notebook = e_builder_get_widget (dialog->builder, "option-notebook");
dialog->dalarm_group = e_builder_get_widget (dialog->builder, "dalarm-group");
dialog->dalarm_message = e_builder_get_widget (dialog->builder, "dalarm-message");
dialog->dalarm_description = e_builder_get_widget (dialog->builder, "dalarm-description");
dialog->aalarm_group = e_builder_get_widget (dialog->builder, "aalarm-group");
dialog->aalarm_sound = e_builder_get_widget (dialog->builder, "aalarm-sound");
dialog->aalarm_file_chooser = e_builder_get_widget (dialog->builder, "aalarm-file-chooser");
dialog->malarm_group = e_builder_get_widget (dialog->builder, "malarm-group");
dialog->malarm_address_group = e_builder_get_widget (dialog->builder, "malarm-address-group");
dialog->malarm_addressbook = e_builder_get_widget (dialog->builder, "malarm-addressbook");
dialog->malarm_message = e_builder_get_widget (dialog->builder, "malarm-message");
dialog->malarm_description = e_builder_get_widget (dialog->builder, "malarm-description");
dialog->palarm_group = e_builder_get_widget (dialog->builder, "palarm-group");
dialog->palarm_program = e_builder_get_widget (dialog->builder, "palarm-program");
dialog->palarm_args = e_builder_get_widget (dialog->builder, "palarm-args");
if (dialog->action_combo) {
const gchar *actions[] = {
N_("Pop up an alert"),
N_("Play a sound"),
N_("Run a program"),
N_("Send an email")
};
GtkComboBox *combo = (GtkComboBox *) dialog->action_combo;
GtkCellRenderer *cell;
GtkListStore *store;
gint i;
g_return_val_if_fail (combo != NULL, FALSE);
g_return_val_if_fail (GTK_IS_COMBO_BOX (combo), FALSE);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell,
"text", 0,
"sensitive", 1,
NULL);
for (i = 0; i < G_N_ELEMENTS (actions); i++) {
GtkTreeIter iter;
gtk_list_store_append (store, &iter);
gtk_list_store_set (
store, &iter,
0, _(actions[i]),
1, TRUE,
-1);
}
}
return (dialog->action_combo
&& dialog->interval_value
&& dialog->value_units_combo
&& dialog->relative_combo
&& dialog->time_combo
&& dialog->repeat_toggle
&& dialog->repeat_group
&& dialog->repeat_quantity
&& dialog->repeat_value
&& dialog->repeat_unit_combo
&& dialog->option_notebook
&& dialog->dalarm_group
&& dialog->dalarm_message
&& dialog->dalarm_description
&& dialog->aalarm_group
&& dialog->aalarm_sound
&& dialog->aalarm_file_chooser
&& dialog->malarm_group
&& dialog->malarm_address_group
&& dialog->malarm_addressbook
&& dialog->malarm_message
&& dialog->malarm_description
&& dialog->palarm_group
&& dialog->palarm_program
&& dialog->palarm_args);
}
/* Build the multiple file dialog */
static SeahorseWidget*
prepare_dialog (FilesCtx *ctx, guint nfolders, guint nfiles, GFileInfo *info, gchar* ext)
{
SeahorseWidget *swidget;
const gchar* pkg;
GtkWidget *tog;
GtkWidget *w;
GtkWidget *combo;
gchar *msg, *display;
gboolean sep;
gint i;
GtkCellRenderer *cell;
GtkTreeModel *store;
FRFileType *save_type_list;
g_assert (info);
swidget = seahorse_widget_new ("multi-encrypt", NULL);
g_return_val_if_fail (swidget != NULL, NULL);
/* The main 'selected' message */
msg = make_message (nfolders, nfiles);
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "message"));
gtk_label_set_markup (GTK_LABEL(w), msg);
g_free (msg);
/* Setup the remote or local messages */
w = GTK_WIDGET (seahorse_widget_get_widget (swidget,
ctx->remote ? "remote-options" : "local-options"));
gtk_widget_show (w);
tog = GTK_WIDGET (seahorse_widget_get_widget (swidget, "do-separate"));
if (ctx->remote) {
/* Always use the seperate option */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tog), TRUE);
/* The local stuff */
} else {
sep = g_settings_get_boolean (seahorse_tool_settings, "separate-files");
/* Setup the package */
w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "package-name"));
display = g_strdup (g_file_info_get_display_name (info));
pkg = seahorse_util_uri_split_last (display);
gtk_entry_set_text (GTK_ENTRY (w), pkg);
g_free (display);
/* Setup the URI combo box */
combo = GTK_WIDGET (seahorse_widget_get_widget (swidget, "package-extension"));
store = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING));
gtk_combo_box_set_model (GTK_COMBO_BOX (combo), store);
g_object_unref (store);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell,
"text", 0,
NULL);
compute_supported_archive_types ();
save_type_list = save_type;
for (i = 0; save_type_list[i] != FR_FILE_TYPE_NULL; i++) {
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo),
file_type_desc[save_type_list[i]].ext);
if (strcmp(ext, file_type_desc[save_type_list[i]].ext) == 0)
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), i);
}
if(sep == FALSE) {
gtk_widget_grab_focus (w);
gtk_editable_select_region (GTK_EDITABLE (w), 0, strlen (pkg));
}
/* Setup the main radio buttons */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tog), sep);
g_signal_connect (tog, "toggled", G_CALLBACK (seperate_toggled), w);
seperate_toggled (tog, w);
}
return swidget;
}
static void
subversion_commit_dialog (GtkAction* action, Subversion* plugin,
gchar *filename)
{
GtkBuilder* bxml = gtk_builder_new ();
GtkWidget* dialog;
GtkWidget *logtext;
GtkWidget *commit_select_all_button;
GtkWidget *commit_clear_button;
GtkWidget *commit_status_view;
GtkWidget *commit_status_progress_bar;
GtkWidget *commit_prev_msg_enable;
GtkWidget *commit_prev_msg_combo;
GtkCellRenderer *cell;
GtkListStore *store;
SvnStatusCommand *status_command;
SubversionData* data;
GError* error = NULL;
if (!gtk_builder_add_from_file (bxml, GLADE_FILE, &error))
{
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free (error);
}
dialog = GTK_WIDGET (gtk_builder_get_object (bxml, "subversion_commit"));
commit_select_all_button = GTK_WIDGET (gtk_builder_get_object (bxml,
"commit_select_all_button"));
commit_clear_button = GTK_WIDGET (gtk_builder_get_object (bxml,
"commit_clear_button"));
commit_status_view = GTK_WIDGET (gtk_builder_get_object (bxml, "commit_status_view"));
commit_status_progress_bar = GTK_WIDGET (gtk_builder_get_object (bxml,
"commit_status_progress_bar"));
logtext = GTK_WIDGET (gtk_builder_get_object (bxml, "subversion_log_view"));
status_command = svn_status_command_new (plugin->project_root_dir,
TRUE, TRUE);
commit_prev_msg_enable = GTK_WIDGET (gtk_builder_get_object (bxml,
"commit_prev_msg_enable"));
commit_prev_msg_combo = GTK_WIDGET (gtk_builder_get_object (bxml,
"commit_prev_msg_combo"));
g_signal_connect (G_OBJECT (commit_select_all_button), "clicked",
G_CALLBACK (select_all_status_items),
commit_status_view);
g_signal_connect (G_OBJECT (commit_clear_button), "clicked",
G_CALLBACK (clear_all_status_selections),
commit_status_view);
g_signal_connect (G_OBJECT (status_command), "command-finished",
G_CALLBACK (select_all_files),
commit_status_view);
g_signal_connect(G_OBJECT (commit_prev_msg_enable), "toggled",
G_CALLBACK(on_prev_message_enable_clicked),
logtext);
pulse_progress_bar (GTK_PROGRESS_BAR (commit_status_progress_bar));
g_signal_connect (G_OBJECT (status_command), "command-finished",
G_CALLBACK (cancel_data_arrived_signal_disconnect),
commit_status_view);
g_signal_connect (G_OBJECT (status_command), "command-finished",
G_CALLBACK (hide_pulse_progress_bar),
commit_status_progress_bar);
g_signal_connect (G_OBJECT (status_command), "command-finished",
G_CALLBACK (on_status_command_finished),
NULL);
g_signal_connect (G_OBJECT (status_command), "data-arrived",
G_CALLBACK (on_status_command_data_arrived),
commit_status_view);
g_object_weak_ref (G_OBJECT (commit_status_view),
(GWeakNotify) disconnect_data_arrived_signals,
status_command);
anjuta_command_start (ANJUTA_COMMAND (status_command));
data = subversion_data_new(plugin, bxml);
g_signal_connect(G_OBJECT(dialog), "response",
G_CALLBACK(on_subversion_commit_response), data);
store = gtk_list_store_new (1, G_TYPE_STRING);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_clear(GTK_CELL_LAYOUT(commit_prev_msg_combo));
gtk_combo_box_set_model(GTK_COMBO_BOX(commit_prev_msg_combo), NULL);
gtk_combo_box_set_model(GTK_COMBO_BOX(commit_prev_msg_combo), GTK_TREE_MODEL(store));
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (commit_prev_msg_combo), cell, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (commit_prev_msg_combo), cell,
"text", 0,
NULL);
g_object_unref (store);
gtk_widget_show_all (dialog);
g_list_foreach(plugin->svn_commit_logs, subversion_commit_dialog_populate_logs, commit_prev_msg_combo);
gtk_combo_box_set_active(GTK_COMBO_BOX(commit_prev_msg_combo), 0);
}
static VALUE
rg_clear(VALUE self)
{
gtk_cell_layout_clear(_SELF(self));
return self;
}
void
empathy_account_widget_irc_build (EmpathyAccountWidget *self,
const char *filename,
GtkWidget **table_common_settings)
{
EmpathyAccountWidgetIrc *settings;
gchar *dir, *user_file_with_path, *global_file_with_path;
GtkListStore *store;
GtkCellRenderer *renderer;
settings = g_slice_new0 (EmpathyAccountWidgetIrc);
settings->self = self;
dir = g_build_filename (g_get_user_config_dir (), PACKAGE_NAME, NULL);
g_mkdir_with_parents (dir, S_IRUSR | S_IWUSR | S_IXUSR);
user_file_with_path = g_build_filename (dir, IRC_NETWORKS_FILENAME, NULL);
g_free (dir);
global_file_with_path = g_build_filename (g_getenv ("EMPATHY_SRCDIR"),
"libempathy-gtk", IRC_NETWORKS_FILENAME, NULL);
if (!g_file_test (global_file_with_path, G_FILE_TEST_EXISTS))
{
g_free (global_file_with_path);
global_file_with_path = g_build_filename (DATADIR, "empathy",
IRC_NETWORKS_FILENAME, NULL);
}
settings->network_manager = empathy_irc_network_manager_new (
global_file_with_path,
user_file_with_path);
g_free (global_file_with_path);
g_free (user_file_with_path);
self->ui_details->gui = empathy_builder_get_file (filename,
"table_irc_settings", table_common_settings,
"vbox_irc", &self->ui_details->widget,
"table_irc_settings", &settings->vbox_settings,
"combobox_network", &settings->combobox_network,
NULL);
/* Fill the networks combobox */
store = gtk_list_store_new (2, G_TYPE_OBJECT, G_TYPE_STRING);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (settings->combobox_network));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (settings->combobox_network),
renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (settings->combobox_network),
renderer,
"text", COL_NETWORK_NAME,
NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
COL_NETWORK_NAME,
GTK_SORT_ASCENDING);
gtk_combo_box_set_model (GTK_COMBO_BOX (settings->combobox_network),
GTK_TREE_MODEL (store));
g_object_unref (store);
account_widget_irc_setup (settings);
empathy_account_widget_handle_params (self,
"entry_nick", "account",
"entry_fullname", "fullname",
"entry_password", "password",
"entry_quit_message", "quit-message",
NULL);
empathy_builder_connect (self->ui_details->gui, settings,
"table_irc_settings", "destroy", account_widget_irc_destroy_cb,
"button_network", "clicked",
account_widget_irc_button_edit_network_clicked_cb,
"button_add_network", "clicked",
account_widget_irc_button_add_network_clicked_cb,
"button_remove_network", "clicked",
account_widget_irc_button_remove_clicked_cb,
"combobox_network", "changed",
account_widget_irc_combobox_network_changed_cb,
NULL);
self->ui_details->default_focus = g_strdup ("entry_nick");
}
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
finish_setup (CEPageSecurity *page)
{
NMConnection *connection = CE_PAGE (page)->connection;
NMSettingWireless *sw;
NMSettingWirelessSecurity *sws;
gboolean is_adhoc = FALSE;
GtkListStore *sec_model;
GtkTreeIter iter;
const gchar *mode;
const gchar *security;
guint32 dev_caps = 0;
NMUtilsSecurityType default_type = NMU_SEC_NONE;
int active = -1;
int item = 0;
GtkComboBox *combo;
GtkCellRenderer *renderer;
sw = nm_connection_get_setting_wireless (connection);
g_assert (sw);
page->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
page->security_heading = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "heading_sec"));
page->security_combo = combo = GTK_COMBO_BOX (gtk_builder_get_object (CE_PAGE (page)->builder, "combo_sec"));
dev_caps = NM_WIFI_DEVICE_CAP_CIPHER_WEP40
| NM_WIFI_DEVICE_CAP_CIPHER_WEP104
| NM_WIFI_DEVICE_CAP_CIPHER_TKIP
| NM_WIFI_DEVICE_CAP_CIPHER_CCMP
| NM_WIFI_DEVICE_CAP_WPA
| NM_WIFI_DEVICE_CAP_RSN;
mode = nm_setting_wireless_get_mode (sw);
if (mode && !strcmp (mode, "adhoc"))
is_adhoc = TRUE;
page->adhoc = is_adhoc;
sws = nm_connection_get_setting_wireless_security (connection);
security = nm_setting_wireless_get_security (sw);
if (!security || strcmp (security, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME) != 0)
sws = NULL;
if (sws)
default_type = get_default_type_for_security (sws);
sec_model = gtk_list_store_new (3, G_TYPE_STRING, wireless_security_get_g_type (), G_TYPE_BOOLEAN);
if (nm_utils_security_valid (NMU_SEC_NONE, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
gtk_list_store_insert_with_values (sec_model, &iter, -1,
S_NAME_COLUMN, C_("Wi-Fi/Ethernet security", "None"),
S_ADHOC_VALID_COLUMN, TRUE,
-1);
if (default_type == NMU_SEC_NONE)
active = item;
item++;
}
if (nm_utils_security_valid (NMU_SEC_STATIC_WEP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityWEPKey *ws_wep;
NMWepKeyType wep_type = NM_WEP_KEY_TYPE_KEY;
if (default_type == NMU_SEC_STATIC_WEP) {
sws = nm_connection_get_setting_wireless_security (connection);
if (sws)
wep_type = nm_setting_wireless_security_get_wep_key_type (sws);
if (wep_type == NM_WEP_KEY_TYPE_UNKNOWN)
wep_type = NM_WEP_KEY_TYPE_KEY;
}
ws_wep = ws_wep_key_new (connection, NM_WEP_KEY_TYPE_KEY, FALSE, FALSE);
if (ws_wep) {
add_security_item (page, WIRELESS_SECURITY (ws_wep), sec_model,
&iter, _("WEP 40/128-bit Key (Hex or ASCII)"),
TRUE);
if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_KEY))
active = item;
item++;
}
ws_wep = ws_wep_key_new (connection, NM_WEP_KEY_TYPE_PASSPHRASE, FALSE, FALSE);
if (ws_wep) {
add_security_item (page, WIRELESS_SECURITY (ws_wep), sec_model,
&iter, _("WEP 128-bit Passphrase"), TRUE);
if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_PASSPHRASE))
active = item;
item++;
}
}
if (nm_utils_security_valid (NMU_SEC_LEAP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityLEAP *ws_leap;
ws_leap = ws_leap_new (connection, FALSE);
if (ws_leap) {
add_security_item (page, WIRELESS_SECURITY (ws_leap), sec_model,
&iter, _("LEAP"), FALSE);
if ((active < 0) && (default_type == NMU_SEC_LEAP))
active = item;
item++;
}
}
if (nm_utils_security_valid (NMU_SEC_DYNAMIC_WEP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityDynamicWEP *ws_dynamic_wep;
ws_dynamic_wep = ws_dynamic_wep_new (connection, TRUE, FALSE);
if (ws_dynamic_wep) {
add_security_item (page, WIRELESS_SECURITY (ws_dynamic_wep), sec_model,
&iter, _("Dynamic WEP (802.1x)"), FALSE);
if ((active < 0) && (default_type == NMU_SEC_DYNAMIC_WEP))
active = item;
item++;
}
}
if (nm_utils_security_valid (NMU_SEC_WPA_PSK, dev_caps, FALSE, is_adhoc, 0, 0, 0) ||
nm_utils_security_valid (NMU_SEC_WPA2_PSK, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityWPAPSK *ws_wpa_psk;
ws_wpa_psk = ws_wpa_psk_new (connection, FALSE);
if (ws_wpa_psk) {
add_security_item (page, WIRELESS_SECURITY (ws_wpa_psk), sec_model,
&iter, _("WPA & WPA2 Personal"), FALSE);
if ((active < 0) && ((default_type == NMU_SEC_WPA_PSK) || (default_type == NMU_SEC_WPA2_PSK)))
active = item;
item++;
}
}
if (nm_utils_security_valid (NMU_SEC_WPA_ENTERPRISE, dev_caps, FALSE, is_adhoc, 0, 0, 0) ||
nm_utils_security_valid (NMU_SEC_WPA2_ENTERPRISE, dev_caps, FALSE, is_adhoc, 0, 0, 0)) {
WirelessSecurityWPAEAP *ws_wpa_eap;
ws_wpa_eap = ws_wpa_eap_new (connection, TRUE, FALSE);
if (ws_wpa_eap) {
add_security_item (page, WIRELESS_SECURITY (ws_wpa_eap), sec_model,
&iter, _("WPA & WPA2 Enterprise"), FALSE);
if ((active < 0) && ((default_type == NMU_SEC_WPA_ENTERPRISE) || (default_type == NMU_SEC_WPA2_ENTERPRISE)))
active = item;
item++;
}
}
gtk_combo_box_set_model (combo, GTK_TREE_MODEL (sec_model));
gtk_cell_layout_clear (GTK_CELL_LAYOUT (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", S_NAME_COLUMN, NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), renderer, set_sensitive, &page->adhoc, NULL);
gtk_combo_box_set_active (combo, active < 0 ? 0 : (guint32) active);
g_object_unref (G_OBJECT (sec_model));
page->security_combo = combo;
security_combo_changed (combo, page);
g_signal_connect (combo, "changed",
G_CALLBACK (security_combo_changed), page);
}
static void
gimp_scale_combo_box_constructed (GObject *object)
{
GimpScaleComboBox *combo_box = GIMP_SCALE_COMBO_BOX (object);
GtkWidget *entry;
GtkListStore *store;
GtkCellLayout *layout;
GtkCellRenderer *cell;
GtkTreeIter iter;
GtkBorder border = { 0, 0, 0, 0 };
gint i;
G_OBJECT_CLASS (parent_class)->constructed (object);
store = gtk_list_store_new (N_COLUMNS,
G_TYPE_DOUBLE, /* SCALE */
G_TYPE_STRING, /* LABEL */
G_TYPE_BOOLEAN); /* PERSISTENT */
gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (combo_box),
COLUMN_LABEL);
entry = gtk_bin_get_child (GTK_BIN (combo_box));
g_object_set (entry,
"xalign", 1.0,
"width-chars", 7,
"truncate-multiline", TRUE,
"inner-border", &border,
NULL);
layout = GTK_CELL_LAYOUT (combo_box);
cell = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT,
"xalign", 1.0,
NULL);
gtk_cell_layout_clear (layout);
gtk_cell_layout_pack_start (layout, cell, TRUE);
gtk_cell_layout_set_attributes (layout, cell,
"text", COLUMN_LABEL,
NULL);
for (i = 8; i > 0; i /= 2)
{
gtk_list_store_append (store, &iter);
gimp_scale_combo_box_scale_iter_set (store, &iter, i, TRUE);
}
for (i = 2; i <= 8; i *= 2)
{
gtk_list_store_append (store, &iter);
gimp_scale_combo_box_scale_iter_set (store, &iter, 1.0 / i, TRUE);
}
g_signal_connect (combo_box, "changed",
G_CALLBACK (gimp_scale_combo_box_changed),
NULL);
g_signal_connect (entry, "activate",
G_CALLBACK (gimp_scale_combo_box_entry_activate),
combo_box);
g_signal_connect (entry, "key-press-event",
G_CALLBACK (gimp_scale_combo_box_entry_key_press),
combo_box);
}
