GtkWidget *
entry_create_widget (GtkWidget * dlg)
{
GtkWidget *c, *l = NULL, *w = NULL;
#if !GTK_CHECK_VERSION(3,0,0)
w = gtk_hbox_new (FALSE, 5);
#else
w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
#endif
if (options.entry_data.entry_label)
{
l = gtk_label_new (NULL);
if (options.data.no_markup)
gtk_label_set_text_with_mnemonic (GTK_LABEL (l), options.entry_data.entry_label);
else
gtk_label_set_markup_with_mnemonic (GTK_LABEL (l), options.entry_data.entry_label);
gtk_widget_set_name (l, "yad-entry-label");
gtk_box_pack_start (GTK_BOX (w), l, FALSE, FALSE, 1);
}
if (options.entry_data.numeric)
{
gdouble min, max, step, val;
guint prec;
min = 0.0;
max = 65535.0;
step = 1.0;
prec = 0;
val = 0.0;
if (options.extra_data && options.extra_data[0])
{
min = g_ascii_strtod (options.extra_data[0], NULL);
if (options.extra_data[1])
max = g_ascii_strtod (options.extra_data[1], NULL);
if (options.extra_data[2])
step = g_ascii_strtod (options.extra_data[2], NULL);
if (options.extra_data[3])
{
prec = (guint) g_ascii_strtoull (options.extra_data[3], NULL, 0);
if (prec > 20)
prec = 20;
}
}
c = entry = gtk_spin_button_new_with_range (min, max, step);
gtk_entry_set_alignment (GTK_ENTRY (c), 1.0);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (c), prec);
gtk_widget_set_name (entry, "yad-entry-spin");
if (options.entry_data.entry_text)
{
val = g_ascii_strtod (options.entry_data.entry_text, NULL);
if (min >= max)
{
g_printerr (_("Maximum value must be greater than minimum value.\n"));
min = 0.0;
max = 65535.0;
}
if (val < min)
{
g_printerr (_("Initial value less than minimal.\n"));
val = min;
}
else if (val > max)
{
g_printerr (_("Initial value greater than maximum.\n"));
val = max;
}
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (c), val);
}
else if (!options.entry_data.completion && options.extra_data && *options.extra_data)
{
gint active, i;
if (options.common_data.editable || settings.combo_always_editable)
{
#if GTK_CHECK_VERSION(2,24,0)
c = gtk_combo_box_text_new_with_entry ();
#else
c = gtk_combo_box_entry_new_text ();
#endif
gtk_widget_set_name (c, "yad-entry-edit-combo");
entry = gtk_bin_get_child (GTK_BIN (c));
if (options.entry_data.licon)
{
GdkPixbuf *pb = get_pixbuf (options.entry_data.licon, YAD_SMALL_ICON);
if (pb)
gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, pb);
}
if (options.entry_data.ricon)
{
GdkPixbuf *pb = get_pixbuf (options.entry_data.ricon, YAD_SMALL_ICON);
if (pb)
gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, pb);
}
}
else
{
#if GTK_CHECK_VERSION(2,24,0)
c = entry = gtk_combo_box_text_new ();
#else
c = entry = gtk_combo_box_new_text ();
#endif
gtk_widget_set_name (c, "yad-entry-combo");
is_combo = TRUE;
}
i = 0;
active = -1;
while (options.extra_data[i] != NULL)
{
if (options.entry_data.entry_text &&
g_ascii_strcasecmp (options.extra_data[i], options.entry_data.entry_text) == 0)
active = i;
#if GTK_CHECK_VERSION(2,24,0)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (c), options.extra_data[i]);
#else
gtk_combo_box_append_text (GTK_COMBO_BOX (c), options.extra_data[i]);
#endif
i++;
}
if (options.entry_data.entry_text && active == -1)
{
#if GTK_CHECK_VERSION(2,24,0)
gtk_combo_box_text_prepend_text (GTK_COMBO_BOX_TEXT (c), options.entry_data.entry_text);
#else
gtk_combo_box_prepend_text (GTK_COMBO_BOX (c), options.entry_data.entry_text);
#endif
}
/* set first iter active */
if (!options.common_data.editable)
gtk_combo_box_set_active (GTK_COMBO_BOX (c), (active != -1 ? active : 0));
}
else
{
c = entry = gtk_entry_new ();
gtk_widget_set_name (c, "yad-entry-widget");
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
if (options.entry_data.entry_text)
gtk_entry_set_text (GTK_ENTRY (entry), options.entry_data.entry_text);
if (options.entry_data.hide_text)
g_object_set (G_OBJECT (entry), "visibility", FALSE, NULL);
if (options.entry_data.completion)
{
GtkEntryCompletion *completion;
GtkTreeModel *completion_model;
completion = gtk_entry_completion_new ();
gtk_entry_set_completion (GTK_ENTRY (entry), completion);
completion_model = create_completion_model ();
gtk_entry_completion_set_model (completion, completion_model);
g_object_unref (completion_model);
gtk_entry_completion_set_text_column (completion, 0);
if (options.common_data.complete != YAD_COMPLETE_SIMPLE)
gtk_entry_completion_set_match_func (completion, check_complete, NULL, NULL);
g_object_unref (completion);
}
if (options.entry_data.licon)
{
GdkPixbuf *pb = get_pixbuf (options.entry_data.licon, YAD_SMALL_ICON);
if (pb)
gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, pb);
}
if (options.entry_data.ricon)
{
GdkPixbuf *pb = get_pixbuf (options.entry_data.ricon, YAD_SMALL_ICON);
if (pb)
gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, pb);
}
}
if (l)
gtk_label_set_mnemonic_widget (GTK_LABEL (l), entry);
if (!is_combo)
g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (entry_activate_cb), dlg);
else
g_signal_connect (G_OBJECT (entry), "key-press-event", G_CALLBACK (combo_activate_cb), dlg);
if (options.entry_data.licon || options.entry_data.ricon)
g_signal_connect (G_OBJECT (entry), "icon-press", G_CALLBACK (icon_cb), NULL);
gtk_box_pack_start (GTK_BOX (w), c, TRUE, TRUE, 1);
return w;
}
static void
gimp_color_tool_real_picked (GimpColorTool *color_tool,
GimpColorPickState pick_state,
const Babl *sample_format,
const GimpRGB *color,
gint color_index)
{
GimpTool *tool = GIMP_TOOL (color_tool);
GimpContext *context;
/* use this tool's own options here (NOT color_tool->options) */
context = GIMP_CONTEXT (gimp_tool_get_options (tool));
if (color_tool->pick_mode == GIMP_COLOR_PICK_MODE_FOREGROUND ||
color_tool->pick_mode == GIMP_COLOR_PICK_MODE_BACKGROUND)
{
GtkWidget *widget;
if (babl_format_is_palette (sample_format))
{
widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (),
"gimp-indexed-palette");
if (widget)
{
GimpColormapEditor *editor;
editor = GIMP_COLORMAP_EDITOR (gtk_bin_get_child (GTK_BIN (widget)));
gimp_colormap_editor_set_index (editor, color_index, NULL);
}
}
if (TRUE)
{
widget = gimp_dialog_factory_find_widget (gimp_dialog_factory_get_singleton (),
"gimp-palette-editor");
if (widget)
{
GimpPaletteEditor *editor;
gint index;
editor = GIMP_PALETTE_EDITOR (gtk_bin_get_child (GTK_BIN (widget)));
index = gimp_palette_editor_get_index (editor, color);
if (index != -1)
gimp_palette_editor_set_index (editor, index, NULL);
}
}
}
switch (color_tool->pick_mode)
{
case GIMP_COLOR_PICK_MODE_NONE:
break;
case GIMP_COLOR_PICK_MODE_FOREGROUND:
gimp_context_set_foreground (context, color);
break;
case GIMP_COLOR_PICK_MODE_BACKGROUND:
gimp_context_set_background (context, color);
break;
case GIMP_COLOR_PICK_MODE_PALETTE:
{
GimpDisplayShell *shell = gimp_display_get_shell (tool->display);
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (shell));
GtkWidget *dockable;
dockable =
gimp_window_strategy_show_dockable_dialog (GIMP_WINDOW_STRATEGY (gimp_get_window_strategy (tool->display->gimp)),
tool->display->gimp,
gimp_dialog_factory_get_singleton (),
screen,
"gimp-palette-editor");
if (dockable)
{
GtkWidget *palette_editor;
GimpData *data;
/* don't blink like mad when updating */
if (pick_state == GIMP_COLOR_PICK_STATE_UPDATE)
gimp_dockable_blink_cancel (GIMP_DOCKABLE (dockable));
palette_editor = gtk_bin_get_child (GTK_BIN (dockable));
data = gimp_data_editor_get_data (GIMP_DATA_EDITOR (palette_editor));
if (! data)
{
data = GIMP_DATA (gimp_context_get_palette (context));
gimp_data_editor_set_data (GIMP_DATA_EDITOR (palette_editor),
data);
}
gimp_palette_editor_pick_color (GIMP_PALETTE_EDITOR (palette_editor),
color, pick_state);
}
}
break;
}
}
GValue*
ghb_widget_value(GtkWidget *widget)
{
GValue *value = NULL;
const gchar *name;
GType type;
if (widget == NULL)
{
g_debug("NULL widget\n");
return NULL;
}
type = G_OBJECT_TYPE(widget);
name = ghb_get_setting_key(widget);
g_debug("ghb_widget_value widget (%s)\n", name);
if (type == GTK_TYPE_ENTRY)
{
const gchar *str = gtk_entry_get_text(GTK_ENTRY(widget));
value = ghb_string_value_new(str);
}
else if (type == GTK_TYPE_RADIO_BUTTON)
{
g_debug("\tradio_button");
gboolean bval;
bval = gtk_toggle_button_get_inconsistent(GTK_TOGGLE_BUTTON(widget));
if (bval)
{
value = ghb_boolean_value_new(FALSE);
}
else
{
bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
value = ghb_boolean_value_new(bval);
}
}
else if (type == GTK_TYPE_CHECK_BUTTON)
{
g_debug("\tcheck_button");
gboolean bval;
bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
value = ghb_boolean_value_new(bval);
}
else if (type == GTK_TYPE_TOGGLE_TOOL_BUTTON)
{
g_debug("\ttoggle_tool_button");
gboolean bval;
bval = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(widget));
value = ghb_boolean_value_new(bval);
}
else if (type == GTK_TYPE_TOGGLE_BUTTON)
{
g_debug("\ttoggle_button");
gboolean bval;
bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
value = ghb_boolean_value_new(bval);
}
else if (type == GTK_TYPE_CHECK_MENU_ITEM)
{
g_debug("\tcheck_menu_item");
gboolean bval;
bval = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
value = ghb_boolean_value_new(bval);
}
else if (type == GTK_TYPE_COMBO_BOX)
{
g_debug("\tcombo_box");
GtkTreeModel *store;
GtkTreeIter iter;
gchar *shortOpt;
store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter))
{
gtk_tree_model_get(store, &iter, 2, &shortOpt, -1);
value = ghb_string_value_new(shortOpt);
g_free(shortOpt);
}
else if (gtk_combo_box_get_has_entry(GTK_COMBO_BOX(widget)))
{
const gchar *str;
str = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(widget))));
if (str == NULL) str = "";
value = ghb_string_value_new(str);
}
else
{
value = ghb_string_value_new("");
}
}
else if (type == GTK_TYPE_SPIN_BUTTON)
{
gint ival;
ival = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
value = ghb_int64_value_new(ival);
}
else if (type == GTK_TYPE_SCALE)
{
gdouble dval;
gint digits;
digits = gtk_scale_get_digits(GTK_SCALE(widget));
dval = gtk_range_get_value(GTK_RANGE(widget));
if (digits)
{
value = ghb_double_value_new(dval);
}
else
{
value = ghb_int_value_new(dval);
}
}
else if (type == GTK_TYPE_SCALE_BUTTON)
{
gdouble dval;
dval = gtk_scale_button_get_value(GTK_SCALE_BUTTON(widget));
value = ghb_double_value_new(dval);
}
else if (type == GTK_TYPE_TEXT_VIEW)
{
GtkTextBuffer *buffer;
GtkTextIter start, end;
gchar *str;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
gtk_text_buffer_get_bounds(buffer, &start, &end);
str = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
value = ghb_string_value_new(str);
g_free(str);
}
else if (type == GTK_TYPE_LABEL)
{
const gchar *str;
str = gtk_label_get_text (GTK_LABEL(widget));
value = ghb_string_value_new(str);
}
else if (type == GTK_TYPE_FILE_CHOOSER_BUTTON)
{
gchar *str = NULL;
str = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(widget));
if (str == NULL)
{
str = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(widget));
}
value = ghb_string_value_new(str);
if (str != NULL)
g_free(str);
}
else
{
g_debug("Attempt to set unknown widget type: %s\n", name);
g_free(value);
value = NULL;
}
return value;
}
GtkImage* CagEImage::Image()
{
GtkWidget* wid = gtk_bin_get_child(GTK_BIN(iWidget));
return GTK_IMAGE(wid);
}
static gchar *input_dialog_open(const gchar *title, const gchar *message,
const gchar *checkbtn_label,
const gchar *default_string,
gboolean default_checkbtn_state,
gboolean *remember)
{
gchar *str;
if (dialog && gtk_widget_get_visible(dialog)) return NULL;
if (!dialog)
input_dialog_create(FALSE);
if (checkbtn_label)
gtk_button_set_label(GTK_BUTTON(remember_checkbtn), checkbtn_label);
else
gtk_button_set_label(GTK_BUTTON(remember_checkbtn), _("Remember this"));
input_dialog_set(title, message, default_string);
gtk_window_present(GTK_WINDOW(dialog));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remember_checkbtn),
default_checkbtn_state);
if (remember)
gtk_widget_show(remember_checkbtn);
else
gtk_widget_hide(remember_checkbtn);
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
manage_window_set_transient(GTK_WINDOW(dialog));
ack = fin = FALSE;
while (fin == FALSE)
gtk_main_iteration();
manage_window_focus_out(dialog, NULL, NULL);
if (ack) {
GtkEditable *editable;
if (type == INPUT_DIALOG_COMBO)
editable = GTK_EDITABLE(gtk_bin_get_child(GTK_BIN((combo))));
else
editable = GTK_EDITABLE(entry);
str = gtk_editable_get_chars(editable, 0, -1);
if (str && *str == '\0' && !is_pass) {
g_free(str);
str = NULL;
}
} else
str = NULL;
GTK_EVENTS_FLUSH();
if (remember) {
*remember = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remember_checkbtn));
}
gtk_widget_destroy(dialog);
dialog = NULL;
if (is_pass)
debug_print("return string = %s\n", str ? "********": ("none"));
else
debug_print("return string = %s\n", str ? str : "(none)");
return str;
}
static void _lib_recentcollection_updated(gpointer instance, gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_recentcollect_t *d = (dt_lib_recentcollect_t *)self->data;
// serialize, check for recently used
char confname[200];
const int bufsize = 4096;
char buf[bufsize];
if(dt_collection_serialize(buf, bufsize)) return;
// is the current position, i.e. the one to be stored with the old collection (pos0, pos1-to-be)
uint32_t curr_pos = dt_view_lighttable_get_position(darktable.view_manager);
uint32_t new_pos = -1;
if(!d->inited)
{
new_pos = dt_conf_get_int("plugins/lighttable/recentcollect/pos0");
d->inited = 1;
dt_view_lighttable_set_position(darktable.view_manager, new_pos);
}
else if(curr_pos != -1)
{
dt_conf_set_int("plugins/lighttable/recentcollect/pos0", curr_pos);
}
int n = -1;
for(int k = 0; k < CLAMPS(dt_conf_get_int("plugins/lighttable/recentcollect/num_items"), 0, NUM_LINES); k++)
{
// is it already in the current list?
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/line%1d", k);
gchar *line = dt_conf_get_string(confname);
if(!line) continue;
if(!strcmp(line, buf))
{
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/pos%1d", k);
new_pos = dt_conf_get_int(confname);
n = k;
break;
}
g_free(line);
}
if(n < 0)
{
const int num_items = CLAMPS(dt_conf_get_int("plugins/lighttable/recentcollect/num_items"), 0, NUM_LINES);
if(num_items < NUM_LINES)
{
// new, unused entry
n = num_items;
dt_conf_set_int("plugins/lighttable/recentcollect/num_items", num_items + 1);
}
else
{
// kill least recently used entry:
n = num_items - 1;
}
}
if(n >= 0 && n < NUM_LINES)
{
// sort n to the top
for(int k = n; k > 0; k--)
{
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/line%1d", k - 1);
gchar *line1 = dt_conf_get_string(confname);
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/pos%1d", k - 1);
uint32_t pos1 = dt_conf_get_int(confname);
if(line1 && line1[0] != '\0')
{
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/line%1d", k);
dt_conf_set_string(confname, line1);
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/pos%1d", k);
dt_conf_set_int(confname, pos1);
}
g_free(line1);
}
dt_conf_set_string("plugins/lighttable/recentcollect/line0", buf);
dt_conf_set_int("plugins/lighttable/recentcollect/pos0",
(new_pos != -1 ? new_pos : (curr_pos != -1 ? curr_pos : 0)));
}
// update button descriptions:
for(int k = 0; k < NUM_LINES; k++)
{
char str[2048] = { 0 };
char str_cut[200] = { 0 };
char str_pretty[200] = { 0 };
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/line%1d", k);
gchar *line2 = dt_conf_get_string(confname);
if(line2 && line2[0] != '\0') pretty_print(line2, str, sizeof(str));
g_free(line2);
g_object_set(G_OBJECT(d->item[k].button), "tooltip-text", str, (char *)NULL);
const int cut = 45;
if(g_utf8_validate(str, -1, NULL))
{
if(g_utf8_strlen(str, -1) > cut)
{
g_utf8_strncpy(str_cut, str, cut);
snprintf(str_pretty, sizeof(str_pretty), "%s...", str_cut);
gtk_button_set_label(GTK_BUTTON(d->item[k].button), str_pretty);
}
else
{
gtk_button_set_label(GTK_BUTTON(d->item[k].button), str);
}
}
else if(strlen(str) > cut)
{
g_strlcpy(str_cut, str, cut);
snprintf(str_pretty, sizeof(str_pretty), "%s...", str_cut);
gtk_button_set_label(GTK_BUTTON(d->item[k].button), str_pretty);
}
else
{
gtk_button_set_label(GTK_BUTTON(d->item[k].button), str);
}
GtkWidget *child = gtk_bin_get_child(GTK_BIN(d->item[k].button));
if(child)
gtk_widget_set_halign(child, GTK_ALIGN_START);
gtk_widget_set_no_show_all(d->item[k].button, TRUE);
gtk_widget_set_visible(d->item[k].button, FALSE);
}
for(int k = 0; k < CLAMPS(dt_conf_get_int("plugins/lighttable/recentcollect/num_items"), 0, NUM_LINES); k++)
{
gtk_widget_set_no_show_all(d->item[k].button, FALSE);
gtk_widget_set_visible(d->item[k].button, TRUE);
}
if((new_pos != -1) && (new_pos != curr_pos))
dt_view_lighttable_set_position(darktable.view_manager, new_pos);
}
static void
prefs_create_dialog(void)
{
GtkWidget *label;
GtkWidget *dialog_vbox;
GtkWidget *notebook;
GtkTable *top_table = NULL; /* top level table for the tab */
GtkTable *current_table = NULL;
int i;
int tab_idx = -1;
if (prefs_dialog != NULL)
return;
prefs_dialog = gtk_dialog_new_with_buttons(
_("Preferences"),
GTK_WINDOW(interface_get_toolbox_shell()),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
GTK_STOCK_APPLY, GTK_RESPONSE_APPLY,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG(prefs_dialog), GTK_RESPONSE_OK);
gtk_window_set_resizable (GTK_WINDOW (prefs_dialog), TRUE);
dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (prefs_dialog));
gtk_window_set_role (GTK_WINDOW (prefs_dialog), "preferences_window");
g_signal_connect(G_OBJECT (prefs_dialog), "response",
G_CALLBACK (prefs_respond), NULL);
g_signal_connect (G_OBJECT (prefs_dialog), "delete_event",
G_CALLBACK(gtk_widget_hide), NULL);
g_signal_connect (G_OBJECT (prefs_dialog), "destroy",
G_CALLBACK(gtk_widget_destroyed), &prefs_dialog);
notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
gtk_box_pack_start (GTK_BOX (dialog_vbox), notebook, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (notebook), 2);
gtk_widget_show (notebook);
for (i=0;i<NUM_PREFS_TABS;i++) {
GtkWidget *table;
GtkWidget *notebook_page;
label = gtk_label_new(gettext(prefs_tabs[i].title));
gtk_widget_show(label);
table = gtk_table_new (9, 2, FALSE);
prefs_tabs[i].table = GTK_TABLE(table);
gtk_widget_set_size_request(table, -1, -1);
gtk_widget_show(table);
#ifdef SCROLLED_PAGES
notebook_page = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (notebook_page),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show(notebook_page);
#else
notebook_page = table;
#endif/* SCROLLED_PAGES */
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), notebook_page, label);
#ifdef SCROLLED_PAGES
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(notebook_page),
table);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_bin_get_child(GTK_BIN(notebook_page))),
GTK_SHADOW_NONE);
#endif /* SCROLLED_PAGES */
}
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_LEFT);
tab_idx = -1;
for (i=0;i<NUM_PREFS_DATA;i++) {
GtkWidget *widget = NULL;
int row;
if (prefs_data[i].hidden)
continue;
if (tab_idx != prefs_data[i].tab) {
tab_idx = prefs_data[i].tab;
top_table = prefs_tabs[prefs_data[i].tab].table;
current_table = top_table;
}
row = prefs_tabs[tab_idx].row++;
switch(prefs_data[i].type) {
case PREF_NONE:
widget = gtk_frame_new(gettext(prefs_data[i].label_text));
gtk_widget_show (widget);
gtk_table_attach (current_table, widget, 0, 2,
row, row + 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1);
current_table = GTK_TABLE(gtk_table_new (9, 2, FALSE));
gtk_container_add(GTK_CONTAINER(widget), GTK_WIDGET(current_table));
gtk_widget_show(GTK_WIDGET(current_table));
break;
case PREF_END_GROUP:
current_table = top_table;
break;
case PREF_BOOLEAN:
widget = gtk_check_button_new_with_label (gettext(prefs_data[i].label_text));
gtk_widget_show (widget);
gtk_table_attach (current_table, widget, 0, 2,
row, row + 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1);
break;
default:
label = gtk_label_new (gettext(prefs_data[i].label_text));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.3);
gtk_widget_show (label);
gtk_table_attach (current_table, label, 0, 1,
row, row + 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1);
widget = prefs_get_property_widget(&prefs_data[i]);
if (widget != NULL) {
gtk_table_attach (current_table, widget, 1, 2,
row, row + 1,
GTK_FILL, GTK_FILL, 1, 1);
}
break;
}
prefs_data[i].widget = widget;
}
gtk_widget_show (prefs_dialog);
}
void gui_init(dt_lib_module_t *self)
{
GtkBox *hbox;
GtkWidget *button;
GtkWidget *label;
GtkEntryCompletion *completion;
int line = 0;
dt_lib_metadata_t *d = (dt_lib_metadata_t *)calloc(1, sizeof(dt_lib_metadata_t));
self->data = (void *)d;
d->imgsel = -1;
self->widget = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5));
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(10));
g_signal_connect(self->widget, "draw", G_CALLBACK(draw), self);
struct
{
char *name;
GtkComboBox **box;
} entries[] = {
// clang-format off
{N_("title"), &d->title},
{N_("description"), &d->description},
{N_("creator"), &d->creator},
{N_("publisher"), &d->publisher},
{N_("rights"), &d->rights}
// clang-format on
};
for(line = 0; line < sizeof(entries) / sizeof(entries[0]); line++)
{
label = gtk_label_new(_(entries[line].name));
g_object_set(G_OBJECT(label), "xalign", 0.0, NULL);
GtkWidget *combobox = gtk_combo_box_text_new_with_entry();
*(entries[line].box) = GTK_COMBO_BOX(combobox);
gtk_widget_set_hexpand(combobox, TRUE);
GtkWidget *entry = gtk_bin_get_child(GTK_BIN(combobox));
dt_gui_key_accel_block_on_focus_connect(entry);
completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(completion, gtk_combo_box_get_model(GTK_COMBO_BOX(combobox)));
gtk_entry_completion_set_text_column(completion, 0);
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_set_completion(GTK_ENTRY(entry), completion);
g_object_unref(completion);
g_signal_connect(entry, "key-press-event", G_CALLBACK(key_pressed), self);
gtk_entry_set_width_chars(GTK_ENTRY(entry), 0);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), combobox, label, GTK_POS_RIGHT, 1, 1);
}
// reset/apply buttons
hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));
button = gtk_button_new_with_label(_("clear"));
d->clear_button = button;
gtk_widget_set_hexpand(GTK_WIDGET(button), TRUE);
g_object_set(G_OBJECT(button), "tooltip-text", _("remove metadata from selected images"), (char *)NULL);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(clear_button_clicked), (gpointer)self);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
button = gtk_button_new_with_label(_("apply"));
d->apply_button = button;
gtk_widget_set_hexpand(GTK_WIDGET(button), TRUE);
g_object_set(G_OBJECT(button), "tooltip-text", _("write metadata for selected images"), (char *)NULL);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(apply_button_clicked), (gpointer)self);
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
gtk_widget_set_margin_top(GTK_WIDGET(hbox), DT_PIXEL_APPLY_DPI(5));
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(hbox), 0, line, 2, 1);
/* lets signup for mouse over image change signals */
dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE,
G_CALLBACK(_mouse_over_image_callback), self);
}
static void spamassassin_create_widget_func(PrefsPage * _page,
GtkWindow * window,
gpointer data)
{
struct SpamAssassinPage *page = (struct SpamAssassinPage *) _page;
SpamAssassinConfig *config;
guint i, active;
GtkWidget *vbox1, *vbox2;
GtkWidget *frame_transport, *table_transport, *vbox_transport;
GtkWidget *hbox_spamd, *hbox_max_size, *hbox_timeout;
GtkWidget *hbox_process_emails, *hbox_save_spam;
GtkWidget *hbox_mark_as_read, *hbox_whitelist;
GtkWidget *whitelist_ab_checkbtn;
GtkWidget *whitelist_ab_folder_combo;
GtkWidget *whitelist_ab_select_btn;
GtkWidget *enable_sa_checkbtn;
GtkWidget *transport_label;
GtkWidget *transport_optmenu;
GtkWidget *user_label;
GtkWidget *user_entry;
GtkWidget *spamd_label;
GtkWidget *spamd_hostname_entry;
GtkWidget *spamd_colon_label;
GtkAdjustment *spamd_port_spinbtn_adj;
GtkWidget *spamd_port_spinbtn;
GtkWidget *spamd_socket_entry;
GtkWidget *max_size_label;
GtkAdjustment *max_size_spinbtn_adj;
GtkWidget *max_size_spinbtn;
GtkWidget *max_size_kb_label;
GtkWidget *timeout_label;
GtkAdjustment *timeout_spinbtn_adj;
GtkWidget *timeout_spinbtn;
GtkWidget *timeout_seconds_label;
GtkWidget *process_emails_checkbtn;
GtkWidget *save_spam_checkbtn;
GtkWidget *save_spam_folder_entry;
GtkWidget *save_spam_folder_select;
GtkWidget *mark_as_read_checkbtn;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkTreeIter iter;
vbox1 = gtk_vbox_new (FALSE, VSPACING);
gtk_widget_show (vbox1);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), VBOX_BORDER);
vbox2 = gtk_vbox_new (FALSE, 4);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (vbox1), vbox2, FALSE, FALSE, 0);
enable_sa_checkbtn = gtk_check_button_new_with_label(_("Enable SpamAssassin plugin"));
gtk_widget_show(enable_sa_checkbtn);
gtk_box_pack_start(GTK_BOX(vbox2), enable_sa_checkbtn, TRUE, TRUE, 0);
vbox_transport = gtkut_get_options_frame(vbox2, &frame_transport, _("Transport"));
table_transport = gtk_table_new (3, 3, FALSE);
gtk_widget_show (table_transport);
gtk_box_pack_start(GTK_BOX(vbox_transport), table_transport, TRUE, TRUE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table_transport), 4);
gtk_table_set_col_spacings (GTK_TABLE (table_transport), 8);
transport_label = gtk_label_new(_("Type of transport"));
gtk_widget_show(transport_label);
gtk_table_attach (GTK_TABLE (table_transport), transport_label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify(GTK_LABEL(transport_label), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment(GTK_MISC(transport_label), 1, 0.5);
store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
transport_optmenu = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(transport_optmenu),
renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(transport_optmenu),
renderer, "text", 0, NULL);
gtk_widget_show(transport_optmenu);
gtk_table_attach (GTK_TABLE (table_transport), transport_optmenu, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
user_label = gtk_label_new(_("User"));
gtk_widget_show(user_label);
gtk_table_attach (GTK_TABLE (table_transport), user_label, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify(GTK_LABEL(user_label), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment(GTK_MISC(user_label), 1, 0.5);
user_entry = gtk_entry_new();
gtk_widget_show(user_entry);
gtk_table_attach (GTK_TABLE (table_transport), user_entry, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
CLAWS_SET_TIP(user_entry, _("User to use with spamd server"));
spamd_label = gtk_label_new(_("spamd"));
gtk_widget_show(spamd_label);
gtk_table_attach (GTK_TABLE (table_transport), spamd_label, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify(GTK_LABEL(spamd_label), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment(GTK_MISC(spamd_label), 1, 0.5);
hbox_spamd = gtk_hbox_new(FALSE, 8);
gtk_widget_show(hbox_spamd);
gtk_table_attach (GTK_TABLE (table_transport), hbox_spamd, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
spamd_hostname_entry = gtk_entry_new();
gtk_widget_show(spamd_hostname_entry);
gtk_box_pack_start(GTK_BOX(hbox_spamd), spamd_hostname_entry, TRUE, TRUE, 0);
CLAWS_SET_TIP(spamd_hostname_entry,
_("Hostname or IP address of spamd server"));
spamd_colon_label = gtk_label_new(":");
gtk_widget_show(spamd_colon_label);
gtk_box_pack_start(GTK_BOX(hbox_spamd), spamd_colon_label, FALSE, FALSE, 0);
spamd_port_spinbtn_adj = GTK_ADJUSTMENT(gtk_adjustment_new(783, 1, 65535, 1, 10, 0));
spamd_port_spinbtn = gtk_spin_button_new(GTK_ADJUSTMENT(spamd_port_spinbtn_adj), 1, 0);
gtk_widget_show(spamd_port_spinbtn);
gtk_box_pack_start(GTK_BOX(hbox_spamd), spamd_port_spinbtn, FALSE, FALSE, 0);
CLAWS_SET_TIP(spamd_port_spinbtn,
_("Port of spamd server"));
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spamd_port_spinbtn), TRUE);
spamd_socket_entry = gtk_entry_new();
gtk_widget_show(spamd_socket_entry);
gtk_box_pack_start(GTK_BOX(hbox_spamd), spamd_socket_entry, TRUE, TRUE, 0);
CLAWS_SET_TIP(spamd_socket_entry, _("Path of Unix socket"));
hbox_max_size = gtk_hbox_new(FALSE, 8);
gtk_widget_show(hbox_max_size);
gtk_box_pack_start (GTK_BOX (vbox2), hbox_max_size, TRUE, TRUE, 0);
max_size_label = gtk_label_new(_("Maximum size"));
gtk_widget_show(max_size_label);
gtk_box_pack_start(GTK_BOX(hbox_max_size), max_size_label, FALSE, FALSE, 0);
max_size_spinbtn_adj = GTK_ADJUSTMENT(gtk_adjustment_new(250, 0, 10000, 10, 10, 0));
max_size_spinbtn = gtk_spin_button_new(GTK_ADJUSTMENT(max_size_spinbtn_adj), 1, 0);
gtk_widget_show(max_size_spinbtn);
gtk_box_pack_start(GTK_BOX(hbox_max_size), max_size_spinbtn, FALSE, FALSE, 0);
CLAWS_SET_TIP(max_size_spinbtn,
_("Messages larger than this will not be checked"));
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(max_size_spinbtn), TRUE);
max_size_kb_label = gtk_label_new(_("KB"));
gtk_widget_show(max_size_kb_label);
gtk_box_pack_start(GTK_BOX(hbox_max_size), max_size_kb_label, FALSE, FALSE, 0);
hbox_timeout = gtk_hbox_new(FALSE, 8);
gtk_widget_show(hbox_timeout);
gtk_box_pack_start (GTK_BOX (vbox2), hbox_timeout, TRUE, TRUE, 0);
timeout_label = gtk_label_new(_("Timeout"));
gtk_widget_show(timeout_label);
gtk_box_pack_start(GTK_BOX(hbox_timeout), timeout_label, FALSE, FALSE, 0);
timeout_spinbtn_adj = GTK_ADJUSTMENT(gtk_adjustment_new(60, 0, 10000, 10, 10, 0));
timeout_spinbtn = gtk_spin_button_new(GTK_ADJUSTMENT(timeout_spinbtn_adj), 1, 0);
gtk_widget_show(timeout_spinbtn);
gtk_box_pack_start(GTK_BOX(hbox_timeout), timeout_spinbtn, FALSE, FALSE, 0);
CLAWS_SET_TIP(timeout_spinbtn,
_("Maximum time allowed for checking. If the check takes longer "
"it will be aborted."));
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(timeout_spinbtn), TRUE);
timeout_seconds_label = gtk_label_new(_("seconds"));
gtk_widget_show(timeout_seconds_label);
gtk_box_pack_start(GTK_BOX(hbox_timeout), timeout_seconds_label, FALSE, FALSE, 0);
hbox_process_emails = gtk_hbox_new(FALSE, 8);
gtk_widget_show(hbox_process_emails);
gtk_box_pack_start (GTK_BOX (vbox2), hbox_process_emails, TRUE, TRUE, 0);
process_emails_checkbtn = gtk_check_button_new_with_label(
_("Process messages on receiving"));
gtk_widget_show(process_emails_checkbtn);
gtk_box_pack_start(GTK_BOX(hbox_process_emails), process_emails_checkbtn, TRUE, TRUE, 0);
hbox_save_spam = gtk_hbox_new(FALSE, 8);
gtk_widget_show(hbox_save_spam);
gtk_box_pack_start (GTK_BOX (vbox2), hbox_save_spam, TRUE, TRUE, 0);
save_spam_checkbtn = gtk_check_button_new_with_label(_("Save spam in"));
gtk_widget_show(save_spam_checkbtn);
gtk_box_pack_start(GTK_BOX(hbox_save_spam), save_spam_checkbtn, FALSE, FALSE, 0);
save_spam_folder_entry = gtk_entry_new();
gtk_widget_show (save_spam_folder_entry);
gtk_box_pack_start (GTK_BOX (hbox_save_spam), save_spam_folder_entry, TRUE, TRUE, 0);
CLAWS_SET_TIP(save_spam_folder_entry,
_("Folder for storing identified spam. Leave empty to use the trash folder."));
save_spam_folder_select = gtkut_get_browse_directory_btn(_("_Browse"));
gtk_widget_show (save_spam_folder_select);
gtk_box_pack_start (GTK_BOX (hbox_save_spam), save_spam_folder_select, FALSE, FALSE, 0);
CLAWS_SET_TIP(save_spam_folder_select,
_("Click this button to select a folder for storing spam"));
hbox_mark_as_read = gtk_hbox_new(FALSE, 8);
gtk_widget_show(hbox_mark_as_read);
gtk_box_pack_start (GTK_BOX (vbox2), hbox_mark_as_read, TRUE, TRUE, 0);
mark_as_read_checkbtn = gtk_check_button_new_with_label(
_("Mark spam as read"));
gtk_widget_show(mark_as_read_checkbtn);
gtk_box_pack_start(GTK_BOX(hbox_mark_as_read), mark_as_read_checkbtn, TRUE, TRUE, 0);
hbox_whitelist = gtk_hbox_new(FALSE, 8);
gtk_widget_show(hbox_whitelist);
gtk_box_pack_start (GTK_BOX (vbox2), hbox_whitelist, TRUE, TRUE, 0);
whitelist_ab_checkbtn = gtk_check_button_new_with_label(_("Whitelist senders found in address book/folder"));
gtk_widget_show(whitelist_ab_checkbtn);
gtk_box_pack_start(GTK_BOX(hbox_whitelist), whitelist_ab_checkbtn, FALSE, FALSE, 0);
CLAWS_SET_TIP(whitelist_ab_checkbtn,
_("Messages coming from your address book contacts will be received in the normal folder even if detected as spam"));
whitelist_ab_folder_combo = combobox_text_new(TRUE, _("Any"), NULL);
gtk_widget_set_size_request(whitelist_ab_folder_combo, 100, -1);
gtk_box_pack_start (GTK_BOX (hbox_whitelist), whitelist_ab_folder_combo, TRUE, TRUE, 0);
whitelist_ab_select_btn = gtk_button_new_with_label(_("Select..."));
gtk_widget_show (whitelist_ab_select_btn);
gtk_box_pack_start (GTK_BOX (hbox_whitelist), whitelist_ab_select_btn, FALSE, FALSE, 0);
CLAWS_SET_TIP(whitelist_ab_select_btn,
_("Click this button to select a book or folder in the address book"));
SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, frame_transport);
SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_max_size);
SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_timeout);
SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_save_spam);
SET_TOGGLE_SENSITIVITY(save_spam_checkbtn, save_spam_folder_entry);
SET_TOGGLE_SENSITIVITY(save_spam_checkbtn, save_spam_folder_select);
SET_TOGGLE_SENSITIVITY(enable_sa_checkbtn, hbox_process_emails);
SET_TOGGLE_SENSITIVITY(save_spam_checkbtn, mark_as_read_checkbtn);
SET_TOGGLE_SENSITIVITY(whitelist_ab_checkbtn, whitelist_ab_folder_combo);
#ifndef USE_NEW_ADDRBOOK
SET_TOGGLE_SENSITIVITY(whitelist_ab_checkbtn, whitelist_ab_select_btn);
#endif
config = spamassassin_get_config();
g_signal_connect(G_OBJECT(save_spam_folder_select), "clicked",
G_CALLBACK(foldersel_cb), page);
#ifndef USE_NEW_ADDRBOOK
g_signal_connect(G_OBJECT (whitelist_ab_select_btn), "clicked",
G_CALLBACK(spamassassin_whitelist_ab_select_cb), page);
#else
gtk_widget_set_sensitive(GTK_WIDGET(whitelist_ab_select_btn), FALSE);
#endif
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enable_sa_checkbtn), config->enable);
if (config->username != NULL)
gtk_entry_set_text(GTK_ENTRY(user_entry), config->username);
if (config->hostname != NULL)
gtk_entry_set_text(GTK_ENTRY(spamd_hostname_entry), config->hostname);
if (config->socket != NULL)
gtk_entry_set_text(GTK_ENTRY(spamd_socket_entry), config->socket);
if (config->whitelist_ab_folder != NULL) {
/* translate "Any" (stored UNtranslated) */
if (strcasecmp(config->whitelist_ab_folder, "Any") == 0)
gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((whitelist_ab_folder_combo)))),
config->whitelist_ab_folder);
else
/* backward compatibility (when translated "Any" was stored) */
if (g_utf8_collate(config->whitelist_ab_folder, _("Any")) == 0)
gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((whitelist_ab_folder_combo)))),
config->whitelist_ab_folder);
else
gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((whitelist_ab_folder_combo)))),
config->whitelist_ab_folder);
}
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spamd_port_spinbtn), (float) config->port);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(max_size_spinbtn), (float) config->max_size);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(timeout_spinbtn), (float) config->timeout);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(process_emails_checkbtn), config->process_emails);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(save_spam_checkbtn), config->receive_spam);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(whitelist_ab_checkbtn), config->whitelist_ab);
if (config->save_folder != NULL)
gtk_entry_set_text(GTK_ENTRY(save_spam_folder_entry), config->save_folder);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mark_as_read_checkbtn), config->mark_as_read);
page->enable_sa_checkbtn = enable_sa_checkbtn;
page->transport_label = transport_label;
page->transport_optmenu = transport_optmenu;
page->username = user_entry;
page->hostname = spamd_hostname_entry;
page->colon = spamd_colon_label;
page->port = spamd_port_spinbtn;
page->socket = spamd_socket_entry;
page->max_size = max_size_spinbtn;
page->timeout = timeout_spinbtn;
page->process_emails = process_emails_checkbtn;
page->receive_spam = save_spam_checkbtn;
page->save_folder = save_spam_folder_entry;
page->save_folder_select = save_spam_folder_select;
page->mark_as_read = mark_as_read_checkbtn;
page->whitelist_ab = whitelist_ab_checkbtn;
page->whitelist_ab_folder_combo = whitelist_ab_folder_combo;
active = 0;
for (i = 0; i < (sizeof(transports) / sizeof(struct Transport)); i++) {
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
0, gettext(transports[i].name),
1, &transports[i], -1);
if (config->transport == transports[i].transport) {
show_transport(page, &transports[i]);
active = i;
} else if (config->transport == SPAMASSASSIN_DISABLED
&& transports[i].transport == SPAMASSASSIN_TRANSPORT_LOCALHOST) {
show_transport(page, &transports[i]);
active = i;
/* and disable via new way */
config->enable = FALSE;
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(enable_sa_checkbtn),
config->enable);
}
}
gtk_combo_box_set_active(GTK_COMBO_BOX(transport_optmenu), active);
g_signal_connect(G_OBJECT(transport_optmenu), "changed",
G_CALLBACK(transport_sel_cb), page);
page->page.widget = vbox1;
}
gboolean
create_folder_subscription_dialog (ExchangeAccount *account,
const gchar *fname)
{
ENameSelector *name_selector;
GtkWidget *dialog;
GtkWidget *dialog_vbox1;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label3;
GtkWidget *user_picker_placeholder;
GtkWidget *button_user;
GtkWidget *folder_name_combo;
GtkWidget *server_combobox;
SubscriptionInfo *subscription_info;
gint mode;
exchange_account_is_offline (account, &mode);
if (mode == OFFLINE_MODE)
return FALSE;
subscription_info = g_new0 (SubscriptionInfo, 1);
subscription_info->account = account;
dialog = gtk_dialog_new_with_buttons (
_("Subscribe to folder of other user"),
NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_widget_show (dialog_vbox1);
table1 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), table1, TRUE, TRUE, 2);
gtk_table_set_row_spacings (GTK_TABLE (table1), 3);
gtk_table_set_col_spacings (GTK_TABLE (table1), 3);
label1 = gtk_label_new_with_mnemonic (_("_Account:"));
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_CENTER);
label3 = gtk_label_new_with_mnemonic (_("_Folder Name:"));
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_CENTER);
user_picker_placeholder = gtk_hbox_new (FALSE, 0);
gtk_widget_show (user_picker_placeholder);
gtk_table_attach (GTK_TABLE (table1), user_picker_placeholder, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
button_user = gtk_button_new_with_mnemonic (_("_User:"******"changed",
G_CALLBACK (user_name_entry_changed_callback), dialog);
setup_server_combobox (server_combobox, account->account_name);
setup_folder_name_combo (folder_name_combo, fname);
subscription_info->folder_name_entry = gtk_bin_get_child (GTK_BIN (folder_name_combo));
g_signal_connect (dialog, "response", G_CALLBACK (subscribe_to_folder), subscription_info);
gtk_widget_show (dialog);
/* Connect the callback to set the OK button insensitive when there is
* no text in the folder_name_entry. Notice that we put a value there
* by default so the OK button is sensitive by default. */
g_signal_connect (subscription_info->folder_name_entry, "changed",
G_CALLBACK (folder_name_entry_changed_callback), dialog);
return TRUE;
}
GtkWidget *
gimp_paint_options_gui (GimpToolOptions *tool_options)
{
GObject *config = G_OBJECT (tool_options);
GimpPaintOptions *options = GIMP_PAINT_OPTIONS (tool_options);
GtkWidget *vbox = gimp_tool_options_gui (tool_options);
GtkWidget *menu;
GtkWidget *scale;
GType tool_type;
tool_type = tool_options->tool_info->tool_type;
/* the paint mode menu */
menu = gimp_prop_paint_mode_menu_new (config, "paint-mode", TRUE, FALSE);
gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (menu), _("Mode"));
g_object_set (menu, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_box_pack_start (GTK_BOX (vbox), menu, FALSE, FALSE, 0);
gtk_widget_show (menu);
if (tool_type == GIMP_TYPE_ERASER_TOOL ||
tool_type == GIMP_TYPE_CONVOLVE_TOOL ||
tool_type == GIMP_TYPE_DODGE_BURN_TOOL ||
tool_type == GIMP_TYPE_HEAL_TOOL ||
tool_type == GIMP_TYPE_SMUDGE_TOOL)
{
gtk_widget_set_sensitive (menu, FALSE);
}
/* the opacity scale */
scale = gimp_prop_spin_scale_new (config, "opacity",
_("Opacity"),
0.01, 0.1, 0);
gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
gtk_widget_show (scale);
/* temp debug foo */
if (g_type_is_a (tool_type, GIMP_TYPE_PAINT_TOOL))
{
GtkWidget *button;
button = gimp_prop_check_button_new (config, "use-applicator",
"Use GimpApplicator");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
}
/* the brush */
if (g_type_is_a (tool_type, GIMP_TYPE_BRUSH_TOOL))
{
GtkWidget *button;
GtkWidget *hbox;
GtkWidget *frame;
button = gimp_prop_brush_box_new (NULL, GIMP_CONTEXT (tool_options),
_("Brush"), 2,
"brush-view-type", "brush-view-size",
"gimp-brush-editor");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
scale = gimp_prop_spin_scale_new (config, "brush-size",
_("Size"),
1.0, 10.0, 2);
gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0);
gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), 1.7);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
button = gimp_icon_button_new (GIMP_STOCK_RESET, NULL);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_image_set_from_icon_name (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))),
GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_paint_options_gui_reset_size),
options);
gimp_help_set_help_data (button,
_("Reset size to brush's native size"), NULL);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
scale = gimp_prop_spin_scale_new (config, "brush-aspect-ratio",
_("Aspect Ratio"),
0.1, 1.0, 2);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
button = gimp_icon_button_new (GIMP_STOCK_RESET, NULL);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_image_set_from_icon_name (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))),
GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_paint_options_gui_reset_aspect_ratio),
options);
gimp_help_set_help_data (button,
_("Reset aspect ratio to brush's native"), NULL);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
scale = gimp_prop_spin_scale_new (config, "brush-angle",
_("Angle"),
1.0, 5.0, 2);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
button = gimp_icon_button_new (GIMP_STOCK_RESET, NULL);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_image_set_from_icon_name (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))),
GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_paint_options_gui_reset_angle),
options);
gimp_help_set_help_data (button,
_("Reset angle to zero"), NULL);
button = gimp_prop_dynamics_box_new (NULL, GIMP_CONTEXT (tool_options),
_("Dynamics"), 2,
"dynamics-view-type",
"dynamics-view-size",
"gimp-dynamics-editor");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
frame = dynamics_options_gui (options, tool_type);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
frame = jitter_options_gui (options, tool_type);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
}
/* the "smooth stroke" options */
if (g_type_is_a (tool_type, GIMP_TYPE_PAINT_TOOL))
{
GtkWidget *frame;
frame = smoothing_options_gui (options, tool_type);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
}
/* the "incremental" toggle */
if (tool_type == GIMP_TYPE_PENCIL_TOOL ||
tool_type == GIMP_TYPE_PAINTBRUSH_TOOL ||
tool_type == GIMP_TYPE_ERASER_TOOL)
{
GtkWidget *button;
button = gimp_prop_enum_check_button_new (config,
"application-mode",
_("Incremental"),
GIMP_PAINT_CONSTANT,
GIMP_PAINT_INCREMENTAL);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
}
/* the "hard edge" toggle */
if (tool_type == GIMP_TYPE_ERASER_TOOL ||
tool_type == GIMP_TYPE_CLONE_TOOL ||
tool_type == GIMP_TYPE_HEAL_TOOL ||
tool_type == GIMP_TYPE_PERSPECTIVE_CLONE_TOOL ||
tool_type == GIMP_TYPE_CONVOLVE_TOOL ||
tool_type == GIMP_TYPE_DODGE_BURN_TOOL ||
tool_type == GIMP_TYPE_SMUDGE_TOOL)
{
GtkWidget *button;
button = gimp_prop_check_button_new (config, "hard", _("Hard edge"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
}
return vbox;
}
static void
empathy_presence_chooser_init (EmpathyPresenceChooser *chooser)
{
EmpathyPresenceChooserPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chooser,
EMPATHY_TYPE_PRESENCE_CHOOSER, EmpathyPresenceChooserPriv);
GtkWidget *entry;
GtkCellRenderer *renderer;
chooser->priv = priv;
presence_chooser_create_model (chooser);
gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (chooser),
COL_STATUS_TEXT);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (chooser),
combo_row_separator_func,
NULL, NULL);
entry = gtk_bin_get_child (GTK_BIN (chooser));
gtk_entry_set_icon_activatable (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
FALSE);
g_signal_connect_swapped (entry, "icon-release",
G_CALLBACK (presence_chooser_entry_icon_release_cb),
chooser);
g_signal_connect_swapped (entry, "activate",
G_CALLBACK (presence_chooser_entry_activate_cb),
chooser);
g_signal_connect_swapped (entry, "key-press-event",
G_CALLBACK (presence_chooser_entry_key_press_event_cb),
chooser);
g_signal_connect_swapped (entry, "button-press-event",
G_CALLBACK (presence_chooser_entry_button_press_event_cb),
chooser);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (chooser));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (chooser), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (chooser), renderer,
"icon-name", COL_STATE_ICON_NAME,
NULL);
g_object_set (renderer, "stock-size", GTK_ICON_SIZE_MENU, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (chooser), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (chooser), renderer,
"markup", COL_DISPLAY_MARKUP,
NULL);
g_signal_connect (chooser, "notify::popup-shown",
G_CALLBACK (presence_chooser_popup_shown_cb), NULL);
g_signal_connect (chooser, "changed",
G_CALLBACK (presence_chooser_changed_cb), NULL);
g_signal_connect_swapped (entry, "changed",
G_CALLBACK (presence_chooser_entry_changed_cb),
chooser);
g_signal_connect_swapped (entry, "focus-out-event",
G_CALLBACK (presence_chooser_entry_focus_out_cb),
chooser);
priv->idle = empathy_idle_dup_singleton ();
presence_chooser_presence_changed_cb (chooser);
g_signal_connect_swapped (priv->idle, "notify",
G_CALLBACK (presence_chooser_presence_changed_cb),
chooser);
/* FIXME: this string sucks */
gtk_widget_set_tooltip_text (GTK_WIDGET (chooser),
_("Set your presence and current status"));
}
static void
presence_chooser_changed_cb (GtkComboBox *self, gpointer user_data)
{
EmpathyPresenceChooserPriv *priv = GET_PRIV (self);
GtkTreeIter iter;
char *icon_name;
TpConnectionPresenceType new_state;
gboolean customisable = TRUE;
PresenceChooserEntryType type = -1;
GtkWidget *entry;
GtkTreeModel *model;
if (priv->block_changed ||
!gtk_combo_box_get_active_iter (self, &iter)) {
return;
}
model = gtk_combo_box_get_model (self);
gtk_tree_model_get (model, &iter,
COL_STATE_ICON_NAME, &icon_name,
COL_STATE, &new_state,
COL_STATUS_CUSTOMISABLE, &customisable,
COL_TYPE, &type,
-1);
entry = gtk_bin_get_child (GTK_BIN (self));
/* some types of status aren't editable, set the editability of the
* entry appropriately. Unless we're just about to reset it anyway,
* in which case, don't fiddle with it */
if (type != ENTRY_TYPE_EDIT_CUSTOM) {
gtk_editable_set_editable (GTK_EDITABLE (entry), customisable);
priv->state = new_state;
}
if (type == ENTRY_TYPE_EDIT_CUSTOM) {
GtkWidget *window, *dialog;
presence_chooser_reset_status (EMPATHY_PRESENCE_CHOOSER (self));
/* attempt to get the toplevel for this widget */
window = gtk_widget_get_toplevel (GTK_WIDGET (self));
if (!GTK_WIDGET_TOPLEVEL (window) || !GTK_IS_WINDOW (window)) {
window = NULL;
}
dialog = empathy_status_preset_dialog_new (GTK_WINDOW (window));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
else if (type == ENTRY_TYPE_CUSTOM) {
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
icon_name);
/* preseed the status */
if (priv->previous_type == ENTRY_TYPE_BUILTIN) {
/* if their previous entry was a builtin, don't
* preseed */
gtk_entry_set_text (GTK_ENTRY (entry), "");
} else {
/* else preseed the text of their currently entered
* status message */
const char *status;
status = empathy_idle_get_status (priv->idle);
gtk_entry_set_text (GTK_ENTRY (entry), status);
}
/* grab the focus */
gtk_widget_grab_focus (entry);
} else {
char *status;
/* just in case we were setting a new status when
* things were changed */
presence_chooser_set_status_editing (
EMPATHY_PRESENCE_CHOOSER (self),
FALSE);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (entry),
GTK_ENTRY_ICON_PRIMARY,
icon_name);
gtk_tree_model_get (model, &iter,
COL_STATUS_TEXT, &status,
-1);
empathy_idle_set_presence (priv->idle, priv->state, status);
g_free (status);
}
if (type != ENTRY_TYPE_EDIT_CUSTOM) {
priv->previous_type = type;
}
g_free (icon_name);
}
GtkWidget *
gimp_foreground_select_options_gui (GimpToolOptions *tool_options)
{
GObject *config = G_OBJECT (tool_options);
GtkWidget *vbox = gimp_selection_options_gui (tool_options);
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *frame;
GtkWidget *scale;
GtkWidget *combo;
GtkWidget *table;
gchar *title;
gint row = 0;
GimpForegroundSelectOptions *options = GIMP_FOREGROUND_SELECT_OPTIONS (config);
frame = gimp_prop_enum_radio_frame_new (config, "draw-mode", title,
0,0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* stroke width */
scale = gimp_prop_spin_scale_new (config, "stroke-width",
_("Stroke width"),
1.0, 10.0, 2);
gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0);
gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), 1.7);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
button = gimp_stock_button_new (GIMP_STOCK_RESET, NULL);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_image_set_from_stock (GTK_IMAGE (gtk_bin_get_child (GTK_BIN (button))),
GIMP_STOCK_RESET, GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_foreground_select_options_gui_reset_stroke_width),
tool_options);
gimp_help_set_help_data (button,
_("Reset stroke width native size"), NULL);
/* mask color */
frame = gimp_frame_new (_("Preview color:"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
combo = gimp_prop_enum_combo_box_new (config, "mask-color",
GIMP_RED_CHANNEL, GIMP_GRAY_CHANNEL);
gtk_container_add (GTK_CONTAINER (frame), combo);
gtk_widget_show (combo);
/* engine */
frame = gimp_frame_new (_("Engine:"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
combo = gimp_prop_enum_combo_box_new (config, "engine", 0, 0);
gtk_container_add (GTK_CONTAINER (frame), combo);
gtk_widget_show (combo);
/* parameters */
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
options->dynamic_widgets.levels = gimp_prop_scale_entry_new (config, "levels",
GTK_TABLE (table), 0, row++, "Levels", 1, 1, 0, FALSE, 0, 0);
options->dynamic_widgets.active_levels = gimp_prop_scale_entry_new (config, "active-levels",
GTK_TABLE (table), 0, row++, "Act. Levels", 1, 1, 0, FALSE, 0, 0);
options->dynamic_widgets.iterations = gimp_prop_scale_entry_new (config, "iterations",
GTK_TABLE (table), 0, row++, "Iterations", 1, 1, 0, FALSE, 0, 0);
g_signal_connect_object (config, "notify::engine",
G_CALLBACK (gimp_foreground_select_notify_engine),
NULL, 0);
gimp_foreground_select_notify_engine(tool_options,NULL,NULL);
return vbox;
}
static GtkWidget*
find_label_child (GtkContainer *container,
gint *index,
gboolean allow_many)
{
GList *children, *tmp_list;
GtkWidget *child;
children = gtk_container_get_children (container);
child = NULL;
for (tmp_list = children; tmp_list != NULL; tmp_list = tmp_list->next)
{
if (GTK_IS_LABEL (tmp_list->data))
{
if (!allow_many)
{
if (child)
{
child = NULL;
break;
}
child = GTK_WIDGET (tmp_list->data);
}
else
{
if (*index == 0)
{
child = GTK_WIDGET (tmp_list->data);
break;
}
(*index)--;
}
}
/*
* Label for button which are GtkTreeView column headers are in a
* GtkHBox in a GtkAlignment.
*/
else if (GTK_IS_ALIGNMENT (tmp_list->data))
{
GtkWidget *widget;
widget = gtk_bin_get_child (GTK_BIN (tmp_list->data));
if (GTK_IS_LABEL (widget))
{
if (!allow_many)
{
if (child)
{
child = NULL;
break;
}
child = widget;
}
else
{
if (*index == 0)
{
child = widget;
break;
}
(*index)--;
}
}
}
else if (GTK_IS_CONTAINER (tmp_list->data))
{
child = find_label_child (GTK_CONTAINER (tmp_list->data), index, allow_many);
if (child)
break;
}
}
g_list_free (children);
return child;
}
static void spamassassin_save_func(PrefsPage *_page)
{
struct SpamAssassinPage *page = (struct SpamAssassinPage *) _page;
SpamAssassinConfig *config;
debug_print("Saving SpamAssassin Page\n");
config = spamassassin_get_config();
/* enable */
config->enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->enable_sa_checkbtn));
config->transport = page->trans;
/* username */
g_free(config->username);
config->username = gtk_editable_get_chars(GTK_EDITABLE(page->username), 0, -1);
spamassassin_check_username();
/* hostname */
g_free(config->hostname);
config->hostname = gtk_editable_get_chars(GTK_EDITABLE(page->hostname), 0, -1);
/* port */
config->port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->port));
/* hostname */
g_free(config->socket);
config->socket = gtk_editable_get_chars(GTK_EDITABLE(page->socket), 0, -1);
/* process_emails */
config->process_emails = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->process_emails));
/* receive_spam */
config->receive_spam = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->receive_spam));
/* save_folder */
g_free(config->save_folder);
config->save_folder = gtk_editable_get_chars(GTK_EDITABLE(page->save_folder), 0, -1);
/* max_size */
config->max_size = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->max_size));
/* timeout */
config->timeout = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->timeout));
/* mark_as_read */
config->mark_as_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->mark_as_read));
/* whitelist_ab */
config->whitelist_ab = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->whitelist_ab));
g_free(config->whitelist_ab_folder);
config->whitelist_ab_folder = gtk_editable_get_chars(
GTK_EDITABLE(gtk_bin_get_child(GTK_BIN((page->whitelist_ab_folder_combo)))), 0, -1);
/* store UNtranslated "Any" */
if (g_utf8_collate(config->whitelist_ab_folder, _("Any")) == 0) {
g_free(config->whitelist_ab_folder);
config->whitelist_ab_folder = g_strdup("Any");
}
if (config->process_emails) {
spamassassin_register_hook();
} else {
spamassassin_unregister_hook();
}
if (!config->enable) {
procmsg_unregister_spam_learner(spamassassin_learn);
procmsg_spam_set_folder(NULL, NULL);
} else {
if (config->transport == SPAMASSASSIN_TRANSPORT_TCP)
debug_print("enabling learner with a remote spamassassin server requires spamc/spamd 3.1.x\n");
procmsg_register_spam_learner(spamassassin_learn);
procmsg_spam_set_folder(config->save_folder, spamassassin_get_spam_folder);
}
spamassassin_save_config();
}
static void
gimp_action_set_proxy (GimpAction *action,
GtkWidget *proxy)
{
if (! GTK_IS_IMAGE_MENU_ITEM (proxy))
return;
if (action->color)
{
GtkWidget *area;
area = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy));
if (GIMP_IS_COLOR_AREA (area))
{
gimp_color_area_set_color (GIMP_COLOR_AREA (area), action->color);
}
else
{
gint width, height;
area = gimp_color_area_new (action->color,
GIMP_COLOR_AREA_SMALL_CHECKS, 0);
gimp_color_area_set_draw_border (GIMP_COLOR_AREA (area), TRUE);
gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (proxy),
GTK_ICON_SIZE_MENU,
&width, &height);
gtk_widget_set_size_request (area, width, height);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), area);
gtk_widget_show (area);
}
}
else if (action->viewable)
{
GtkWidget *view;
view = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy));
if (GIMP_IS_VIEW (view) &&
g_type_is_a (G_TYPE_FROM_INSTANCE (action->viewable),
GIMP_VIEW (view)->renderer->viewable_type))
{
gimp_view_set_viewable (GIMP_VIEW (view), action->viewable);
}
else
{
GtkIconSize size;
gint width, height;
gint border_width;
if (GIMP_IS_IMAGEFILE (action->viewable))
{
size = GTK_ICON_SIZE_LARGE_TOOLBAR;
border_width = 0;
}
else
{
size = GTK_ICON_SIZE_MENU;
border_width = 1;
}
gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (proxy),
size, &width, &height);
view = gimp_view_new_full (action->context, action->viewable,
width, height, border_width,
FALSE, FALSE, FALSE);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), view);
gtk_widget_show (view);
}
}
else
{
GtkWidget *image;
image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy));
if (GIMP_IS_VIEW (image) || GIMP_IS_COLOR_AREA (image))
{
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), NULL);
g_object_notify (G_OBJECT (action), "icon-name");
}
}
{
GtkWidget *child = gtk_bin_get_child (GTK_BIN (proxy));
if (GTK_IS_LABEL (child))
{
GtkLabel *label = GTK_LABEL (child);
gtk_label_set_ellipsize (label, action->ellipsize);
gtk_label_set_max_width_chars (label, action->max_width_chars);
}
}
}
/**
* @brief Build the GUI
*
* @return
*/
GtkWidget* buildDisplayUI() {
GtkWidget* label;
GtkWidget* box;
//display = gtk_window_new (GTK_WINDOW_TOPLEVEL);
////gtk_widget_modify_bg(display,GTK_STATE_NORMAL,&background);
//gtk_window_set_title(GTK_WINDOW(display),"Display and Decode");
displayFixed=gtk_fixed_new();
//gtk_widget_modify_bg(displayFixed,GTK_STATE_NORMAL,&background);
spectrum=newSpectrumDisplay(spectrumWIDTH);
gtk_fixed_put((GtkFixed*)displayFixed,spectrum,0,0);
box=gtk_hbox_new(FALSE,5);
speed48K=gtk_radio_button_new_with_label(NULL,"48K");
label=gtk_bin_get_child((GtkBin*)speed48K);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
//gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, &white);
//gtk_widget_modify_fg(label, GTK_STATE_ACTIVE, &white);
g_signal_connect(G_OBJECT(speed48K),"clicked",G_CALLBACK(speed48ButtonCallback),NULL);
gtk_widget_show(speed48K);
gtk_box_pack_start(GTK_BOX(box),speed48K,FALSE,FALSE,2);
speed96K=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(speed48K),"96K");
label=gtk_bin_get_child((GtkBin*)speed96K);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
//gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, &white);
//gtk_widget_modify_fg(label, GTK_STATE_ACTIVE, &white);
g_signal_connect(G_OBJECT(speed96K),"clicked",G_CALLBACK(speed96ButtonCallback),NULL);
gtk_widget_show(speed96K);
gtk_box_pack_start(GTK_BOX(box),speed96K,FALSE,FALSE,2);
speed192K=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(speed48K),"192K");
label=gtk_bin_get_child((GtkBin*)speed192K);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
//gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, &white);
//gtk_widget_modify_fg(label, GTK_STATE_ACTIVE, &white);
g_signal_connect(G_OBJECT(speed192K),"clicked",G_CALLBACK(speed192ButtonCallback),NULL);
gtk_widget_show(speed192K);
gtk_box_pack_start(GTK_BOX(box),speed192K,FALSE,FALSE,2);
gtk_widget_show(box);
gtk_fixed_put((GtkFixed*)displayFixed,box,700,spectrumHEIGHT);
buttonNone=gtk_button_new_with_label("NONE");
//gtk_widget_modify_bg(buttonNone, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonNone);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
gtk_widget_set_size_request(GTK_WIDGET(buttonNone),100,BUTTON_HEIGHT);
g_signal_connect(G_OBJECT(buttonNone),"clicked",G_CALLBACK(spectrumCallback),NULL);
gtk_widget_show(buttonNone);
gtk_fixed_put((GtkFixed*)displayFixed,buttonNone,0,spectrumHEIGHT);
buttonSpectrum=gtk_button_new_with_label("SPECTRUM");
//gtk_widget_modify_bg(buttonSpectrum, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonSpectrum);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
gtk_widget_set_size_request(GTK_WIDGET(buttonSpectrum),100,BUTTON_HEIGHT);
g_signal_connect(G_OBJECT(buttonSpectrum),"clicked",G_CALLBACK(spectrumCallback),NULL);
gtk_widget_show(buttonSpectrum);
gtk_fixed_put((GtkFixed*)displayFixed,buttonSpectrum,100,spectrumHEIGHT);
buttonPanadapter=gtk_button_new_with_label("PANADAPTER");
//gtk_widget_modify_bg(buttonPanadapter, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonPanadapter);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
gtk_widget_set_size_request(GTK_WIDGET(buttonPanadapter),100,BUTTON_HEIGHT);
g_signal_connect(G_OBJECT(buttonPanadapter),"clicked",G_CALLBACK(spectrumCallback),NULL);
gtk_widget_show(buttonPanadapter);
gtk_fixed_put((GtkFixed*)displayFixed,buttonPanadapter,200,spectrumHEIGHT);
buttonPanWater=gtk_button_new_with_label("PAN/WATER");
//gtk_widget_modify_bg(buttonPanWater, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonPanWater);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
gtk_widget_set_size_request(GTK_WIDGET(buttonPanWater),100,BUTTON_HEIGHT);
g_signal_connect(G_OBJECT(buttonPanWater),"clicked",G_CALLBACK(spectrumCallback),NULL);
gtk_widget_show(buttonPanWater);
gtk_fixed_put((GtkFixed*)displayFixed,buttonPanWater,300,spectrumHEIGHT);
buttonScope=gtk_button_new_with_label("SCOPE");
//gtk_widget_modify_bg(buttonScope, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonScope);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
gtk_widget_set_size_request(GTK_WIDGET(buttonScope),100,BUTTON_HEIGHT);
g_signal_connect(G_OBJECT(buttonScope),"clicked",G_CALLBACK(spectrumCallback),NULL);
gtk_widget_show(buttonScope);
gtk_fixed_put((GtkFixed*)displayFixed,buttonScope,400,spectrumHEIGHT);
buttonPhase=gtk_button_new_with_label("PHASE");
//gtk_widget_modify_bg(buttonPhase, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonPhase);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
gtk_widget_set_size_request(GTK_WIDGET(buttonPhase),100,BUTTON_HEIGHT);
g_signal_connect(G_OBJECT(buttonPhase),"clicked",G_CALLBACK(spectrumCallback),NULL);
gtk_widget_show(buttonPhase);
gtk_fixed_put((GtkFixed*)displayFixed,buttonPhase,500,spectrumHEIGHT);
buttonPhase2=gtk_button_new_with_label("PHASE2");
//gtk_widget_modify_bg(buttonPhase2, GTK_STATE_NORMAL, &buttonBackground);
label=gtk_bin_get_child((GtkBin*)buttonPhase2);
//gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
gtk_widget_set_size_request(GTK_WIDGET(buttonPhase2),100,BUTTON_HEIGHT);
g_signal_connect(G_OBJECT(buttonPhase2),"clicked",G_CALLBACK(spectrumCallback),NULL);
gtk_widget_show(buttonPhase2);
gtk_fixed_put((GtkFixed*)displayFixed,buttonPhase2,600,spectrumHEIGHT);
gtk_widget_set_size_request(GTK_WIDGET(displayFixed),spectrumWIDTH,spectrumHEIGHT+25);
gtk_widget_show(displayFixed);
//gtk_container_add(GTK_CONTAINER(display), displayFixed);
//gtk_window_set_position((GtkWindow*)display,GTK_WIN_POS_MOUSE);
//gtk_widget_show(display.g);
switch(speed)
{
case 0:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(speed48K),TRUE);
break;
case 1:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(speed96K),TRUE);
break;
case 2:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(speed192K),TRUE);
break;
}
currentSpectrumButton=NULL;
switch(spectrumMode)
{
case spectrumNONE:
spectrumCallback(buttonNone,NULL);
break;
case spectrumSPECTRUM:
spectrumCallback(buttonSpectrum,NULL);
break;
case spectrumPANADAPTER:
spectrumCallback(buttonPanadapter,NULL);
break;
case spectrumPANWATER:
spectrumCallback(buttonPanWater,NULL);
break;
case spectrumSCOPE:
spectrumCallback(buttonScope,NULL);
break;
case spectrumPHASE:
spectrumCallback(buttonPhase,NULL);
break;
case spectrumPHASE2:
spectrumCallback(buttonPhase2,NULL);
break;
}
return displayFixed;
}
void
ags_drum_init(AgsDrum *drum)
{
GtkVBox *vbox;
GtkHBox *hbox;
GtkToggleButton *toggle_button;
GtkFrame *frame;
GtkTable *table0, *table1;
GtkRadioButton *radio_button;
AgsAudio *audio;
GList *list;
guint stream_length;
int i, j;
g_signal_connect_after((GObject *) drum, "parent_set\0",
G_CALLBACK(ags_drum_parent_set_callback), (gpointer) drum);
audio = AGS_MACHINE(drum)->audio;
audio->flags |= (AGS_AUDIO_OUTPUT_HAS_RECYCLING |
AGS_AUDIO_INPUT_HAS_RECYCLING |
AGS_AUDIO_INPUT_TAKES_FILE |
AGS_AUDIO_SYNC |
AGS_AUDIO_ASYNC);
AGS_MACHINE(drum)->flags |= AGS_MACHINE_IS_SEQUENCER;
AGS_MACHINE(drum)->input_pad_type = AGS_TYPE_DRUM_INPUT_PAD;
AGS_MACHINE(drum)->input_line_type = AGS_TYPE_DRUM_INPUT_LINE;
AGS_MACHINE(drum)->output_pad_type = AGS_TYPE_DRUM_OUTPUT_PAD;
AGS_MACHINE(drum)->output_line_type = AGS_TYPE_DRUM_OUTPUT_LINE;
g_signal_connect_after(G_OBJECT(audio), "set_audio_channels\0",
G_CALLBACK(ags_drum_set_audio_channels), drum);
g_signal_connect_after(G_OBJECT(audio), "set_pads\0",
G_CALLBACK(ags_drum_set_pads), drum);
drum->flags = 0;
drum->name = NULL;
drum->xml_type = "ags-drum\0";
/* create widgets */
drum->vbox = (GtkVBox *) gtk_vbox_new(FALSE, 0);
gtk_container_add((GtkContainer*) gtk_bin_get_child((GtkBin *) drum), (GtkWidget *) drum->vbox);
hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0);
gtk_box_pack_start((GtkBox *) drum->vbox, (GtkWidget *) hbox, FALSE, FALSE, 0);
drum->input_pad = (GtkHBox *) gtk_hbox_new(FALSE, 0);
AGS_MACHINE(drum)->input = (GtkContainer *) drum->input_pad;
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) drum->input_pad, FALSE, FALSE, 0);
drum->output_pad = (GtkVBox *) gtk_vbox_new(FALSE, 0);
AGS_MACHINE(drum)->output = (GtkContainer *) drum->output_pad;
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) drum->output_pad, FALSE, FALSE, 0);
drum->selected_pad = NULL;
drum->selected_edit_button = NULL;
hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0);
gtk_box_pack_start((GtkBox *) drum->vbox, (GtkWidget *) hbox, FALSE, FALSE, 0);
frame = (GtkFrame *) gtk_frame_new("kit\0");
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) frame, FALSE, FALSE, 0);
vbox = (GtkVBox *) gtk_vbox_new(FALSE, 0);
gtk_container_add((GtkContainer*) frame, (GtkWidget *) vbox);
gtk_box_pack_start((GtkBox *) vbox,
(GtkWidget *) gtk_label_new("default\0"),
FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox *) vbox,
(GtkWidget *) (drum->open = (GtkButton *) gtk_button_new_from_stock(GTK_STOCK_OPEN)),
FALSE, FALSE, 0);
/* sequencer */
frame = (GtkFrame *) gtk_frame_new("Pattern\0");
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) frame, FALSE, FALSE, 0);
table0 = (GtkTable *) gtk_table_new(16, 4, FALSE);
gtk_container_add((GtkContainer*) frame, (GtkWidget *) table0);
drum->loop_button = (GtkCheckButton *) gtk_check_button_new_with_label("loop\0");
gtk_table_attach_defaults(table0,
(GtkWidget *) drum->loop_button,
0, 1, 2, 3);
AGS_MACHINE(drum)->play =
drum->run = (GtkToggleButton *) gtk_toggle_button_new_with_label("run\0");
gtk_table_attach_defaults(table0,
(GtkWidget *) drum->run,
1, 2, 2, 3);
/* bank */
table1 = (GtkTable *) gtk_table_new(3, 5, TRUE);
gtk_table_attach_defaults(table0,
(GtkWidget *) table1,
2, 3, 0, 3);
drum->selected1 = NULL;
for(i = 0; i < 3; i++)
for(j = 0; j < 4; j++){
gtk_table_attach_defaults(table1,
(GtkWidget *) (drum->index1[i * 4 + j] = (GtkToggleButton *) gtk_toggle_button_new()),
j, j +1, i, i +1);
g_object_set_data((GObject *) drum->index1[i * 4 + j], AGS_DRUM_INDEX, GUINT_TO_POINTER(i * 4 + j));
}
drum->selected1 = drum->index1[0];
gtk_toggle_button_set_active(drum->index1[0], TRUE);
drum->selected0 = NULL;
for(j = 0; j < 4; j++){
gtk_table_attach_defaults(table1,
(GtkWidget *) (drum->index0[j] = (GtkToggleButton *) gtk_toggle_button_new()),
j, j +1, 4, 5);
g_object_set_data((GObject *) drum->index0[j], AGS_DRUM_INDEX, GUINT_TO_POINTER(j));
}
drum->selected0 = drum->index0[0];
gtk_toggle_button_set_active(drum->index0[0], TRUE);
/* duration */
hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0);
gtk_table_attach(table0,
(GtkWidget *) hbox,
6, 7, 0, 1,
GTK_EXPAND, GTK_EXPAND,
0, 0);
gtk_box_pack_start((GtkBox*) hbox, gtk_label_new("length\0"), FALSE, FALSE, 0);
drum->length_spin = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 64.0, 1.0);
drum->length_spin->adjustment->value = 16.0;
gtk_box_pack_start((GtkBox*) hbox, (GtkWidget *) drum->length_spin, FALSE, FALSE, 0);
/* led */
drum->active_led = 0;
drum->led =
hbox = (GtkHBox *) gtk_hbox_new(FALSE, 16);
gtk_table_attach_defaults(table0, (GtkWidget *) hbox, 3, 15, 1, 2);
for(i = 0; i < 16; i++){
toggle_button = (GtkToggleButton *) ags_led_new();
gtk_widget_set_size_request((GtkWidget *) toggle_button, 8, 4);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) toggle_button, FALSE, FALSE, 0);
}
/* pattern */
drum->pattern =
hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0);
gtk_table_attach_defaults(table0, (GtkWidget *) hbox, 3, 15, 2, 3);
for(i = 0; i < 16; i++){
toggle_button = (GtkToggleButton *) gtk_toggle_button_new();
gtk_widget_set_size_request((GtkWidget *) toggle_button, 24, 24);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) toggle_button, FALSE, FALSE, 0);
}
/* page / offset */
drum->offset = (GtkVBox*) gtk_vbox_new(FALSE, 0);
gtk_table_attach_defaults(table0, (GtkWidget *) drum->offset, 15, 16, 0, 3);
radio_button = (GtkRadioButton *) gtk_radio_button_new_with_label(NULL, "1-16\0");
gtk_box_pack_start((GtkBox*) drum->offset, (GtkWidget *) radio_button, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*) drum->offset,
(GtkWidget *) gtk_radio_button_new_with_label(radio_button->group, "17-32\0"),
FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*) drum->offset,
(GtkWidget *) gtk_radio_button_new_with_label(radio_button->group, "33-48\0"),
FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*) drum->offset,
(GtkWidget *) gtk_radio_button_new_with_label(radio_button->group, "49-64\0"),
FALSE, FALSE, 0);
}
GtkWidget *
gimp_ink_options_gui (GimpToolOptions *tool_options)
{
GObject *config = G_OBJECT (tool_options);
GimpInkOptions *ink_options = GIMP_INK_OPTIONS (tool_options);
GtkWidget *vbox = gimp_paint_options_gui (tool_options);
GtkWidget *frame;
GtkWidget *table;
GtkWidget *blob_vbox;
GtkWidget *hbox;
GtkWidget *editor;
GtkObject *adj;
/* adjust sliders */
frame = gimp_frame_new (_("Adjustment"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
gtk_widget_show (frame);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
/* size slider */
adj = gimp_prop_scale_entry_new (config, "size",
GTK_TABLE (table), 0, 0,
_("Size:"),
1.0, 2.0, 1,
FALSE, 0.0, 0.0);
gimp_scale_entry_set_logarithmic (adj, TRUE);
/* angle adjust slider */
gimp_prop_scale_entry_new (config, "tilt-angle",
GTK_TABLE (table), 0, 1,
_("Angle:"),
1.0, 10.0, 1,
FALSE, 0.0, 0.0);
/* sens sliders */
frame = gimp_frame_new (_("Sensitivity"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
gtk_widget_show (frame);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
/* size sens slider */
gimp_prop_scale_entry_new (config, "size-sensitivity",
GTK_TABLE (table), 0, 0,
_("Size:"),
0.01, 0.1, 1,
FALSE, 0.0, 0.0);
/* tilt sens slider */
gimp_prop_scale_entry_new (config, "tilt-sensitivity",
GTK_TABLE (table), 0, 1,
_("Tilt:"),
0.01, 0.1, 1,
FALSE, 0.0, 0.0);
/* velocity sens slider */
gimp_prop_scale_entry_new (config, "vel-sensitivity",
GTK_TABLE (table), 0, 2,
_("Speed:"),
0.01, 0.1, 1,
FALSE, 0.0, 0.0);
/* bottom hbox */
hbox = gtk_hbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* Blob type radiobuttons */
frame = gimp_prop_enum_radio_frame_new (config, "blob-type",
_("Type"), 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
{
GtkWidget *frame_child = gtk_bin_get_child (GTK_BIN (frame));
GList *children;
GList *list;
GimpInkBlobType blob_type;
children = gtk_container_get_children (GTK_CONTAINER (frame_child));
for (list = children, blob_type = GIMP_INK_BLOB_TYPE_ELLIPSE;
list;
list = g_list_next (list), blob_type++)
{
GtkWidget *radio = GTK_WIDGET (list->data);
GtkWidget *blob;
gtk_container_remove (GTK_CONTAINER (radio),
gtk_bin_get_child (GTK_BIN (radio)));
blob = blob_image_new (blob_type);
gtk_container_add (GTK_CONTAINER (radio), blob);
gtk_widget_show (blob);
}
g_list_free (children);
}
/* Blob shape widget */
frame = gimp_frame_new (_("Shape"));
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
blob_vbox = gtk_vbox_new (FALSE, 2);
gtk_container_add (GTK_CONTAINER (frame), blob_vbox);
gtk_widget_show (blob_vbox);
frame = gtk_aspect_frame_new (NULL, 0.0, 0.5, 1.0, FALSE);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (blob_vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
editor = gimp_blob_editor_new (ink_options->blob_type,
ink_options->blob_aspect,
ink_options->blob_angle);
gtk_widget_set_size_request (editor, 60, 60);
gtk_container_add (GTK_CONTAINER (frame), editor);
gtk_widget_show (editor);
gimp_config_connect (config, G_OBJECT (editor), NULL);
return vbox;
}
static GtkWidget* gtk_widget_get_child_(GtkWidget* widget)
{
GtkWidget *child = gtk_bin_get_child(GTK_BIN(widget));
return child;
}
void gtkui_create_menu(int live)
{
GtkAccelGroup *accel_group;
GtkWidget *vbox, *item;
GtkItemFactory *root_menu;
int num_items = 0;
DEBUG_MSG("gtk_create_menu");
/* remove old menu, it will be automatically destroyed by gtk_main */
vbox = gtk_bin_get_child(GTK_BIN (window));
gtk_container_remove(GTK_CONTAINER (vbox), main_menu);
/* Prepare to generate menus from the definitions in ec_gtk.h */
accel_group = gtk_accel_group_new ();
root_menu = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
/* Start Menu */
num_items = sizeof (gmenu_start) / sizeof (gmenu_start[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_start, NULL);
/* Targets Menu */
num_items = sizeof (gmenu_targets) / sizeof (gmenu_targets[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_targets, NULL);
/* Hosts Menu */
if (live > 0 && GBL_SNIFF->type != SM_BRIDGED) {
num_items = sizeof (gmenu_hosts) / sizeof (gmenu_hosts[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_hosts, NULL);
}
/* View Menu */
num_items = sizeof (gmenu_view) / sizeof (gmenu_view[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_view, NULL);
/* MITM Menu */
if (live > 0 && GBL_SNIFF->type != SM_BRIDGED) {
num_items = sizeof (gmenu_mitm) / sizeof (gmenu_mitm[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_mitm, NULL);
}
/* Filters Menu */
num_items = sizeof (gmenu_filters) / sizeof (gmenu_filters[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_filters, NULL);
/* Logging Menu */
num_items = sizeof (gmenu_logging) / sizeof (gmenu_logging[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_logging, NULL);
#ifdef HAVE_PLUGINS
/* Plugins Menu */
if(live > 0) {
num_items = sizeof (gmenu_plugins) / sizeof (gmenu_plugins[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_plugins, NULL);
}
#endif
#ifndef OS_WINDOWS
/* Help Menu */
num_items = sizeof (gmenu_help) / sizeof (gmenu_help[0]);
gtk_item_factory_create_items (root_menu, num_items, gmenu_help, NULL);
#endif
if(GBL_OPTIONS->reversed) {
GBL_OPTIONS->reversed = 0;
item = gtk_item_factory_get_item(root_menu, "/Targets/Reverse matching");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE);
}
if(GBL_OPTIONS->resolve) {
GBL_OPTIONS->resolve = 0;
item = gtk_item_factory_get_item(root_menu, "/View/Resolve IP addresses");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE);
}
if(GBL_OPTIONS->compress) {
GBL_OPTIONS->compress = 0;
item = gtk_item_factory_get_item(root_menu, "/Logging/Compressed file");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE);
}
/* get the menu widget and add it to the window */
main_menu = gtk_item_factory_get_widget (root_menu, "<main>");
gtk_box_pack_start(GTK_BOX(vbox), main_menu, FALSE, FALSE, 0);
gtk_widget_show(main_menu);
}
static void input_dialog_create(gboolean is_password)
{
static PangoFontDescription *font_desc;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *cancel_button;
GtkWidget *confirm_area;
dialog = gtk_dialog_new();
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_window_set_default_size(GTK_WINDOW(dialog), 375, 100);
gtk_window_set_title(GTK_WINDOW(dialog), "");
g_signal_connect(G_OBJECT(dialog), "delete_event",
G_CALLBACK(delete_event), NULL);
g_signal_connect(G_OBJECT(dialog), "key_press_event",
G_CALLBACK(key_pressed), NULL);
MANAGE_WINDOW_SIGNALS_CONNECT(dialog);
vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_box_set_spacing (GTK_BOX (vbox), 14);
hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox,
FALSE, FALSE, 0);
/* for title label */
icon_q = gtk_image_new_from_stock(GTK_STOCK_DIALOG_QUESTION,
GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (icon_q), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox), icon_q, FALSE, FALSE, 0);
icon_p = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION,
GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (icon_p), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox), icon_p, FALSE, FALSE, 0);
vbox = gtk_vbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
msg_title = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(msg_title), 0, 0.5);
gtk_label_set_justify(GTK_LABEL(msg_title), GTK_JUSTIFY_LEFT);
gtk_label_set_use_markup (GTK_LABEL (msg_title), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), msg_title, FALSE, FALSE, 0);
gtk_label_set_line_wrap(GTK_LABEL(msg_title), TRUE);
if (!font_desc) {
gint size;
size = pango_font_description_get_size
(gtk_widget_get_style(msg_title)->font_desc);
font_desc = pango_font_description_new();
pango_font_description_set_weight
(font_desc, PANGO_WEIGHT_BOLD);
pango_font_description_set_size
(font_desc, size * PANGO_SCALE_LARGE);
}
if (font_desc)
gtk_widget_modify_font(msg_title, font_desc);
msg_label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(msg_label), 0, 0.5);
gtk_label_set_justify(GTK_LABEL(msg_label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(vbox), msg_label, FALSE, FALSE, 0);
gtk_widget_show(msg_label);
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(entry), "activate",
G_CALLBACK(entry_activated), NULL);
#if !GTK_CHECK_VERSION(2, 24, 0)
combo = gtk_combo_box_entry_new_text();
#else
combo = gtk_combo_box_text_new_with_entry();
#endif
gtk_box_pack_start(GTK_BOX(vbox), combo, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN((combo)))), "activate",
G_CALLBACK(combo_activated), NULL);
remember_checkbtn = gtk_check_button_new_with_label(_("Remember this"));
gtk_box_pack_start(GTK_BOX(vbox), remember_checkbtn, FALSE, FALSE, 0);
hbox = gtk_hbox_new(TRUE, 0);
gtkut_stock_button_set_create(&confirm_area,
&cancel_button, GTK_STOCK_CANCEL,
&ok_button, GTK_STOCK_OK,
NULL, NULL);
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(dialog))),
confirm_area, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5);
gtk_widget_show_all(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
gtk_widget_hide(remember_checkbtn);
if (is_password)
gtk_widget_hide(icon_q);
else
gtk_widget_hide(icon_p);
is_pass = is_password;
gtk_widget_grab_default(ok_button);
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK(ok_clicked), NULL);
g_signal_connect(G_OBJECT(cancel_button), "clicked",
G_CALLBACK(cancel_clicked), NULL);
}
static gboolean
internal_init (NMAWirelessDialog *self,
NMConnection *specific_connection,
NMDevice *specific_device,
gboolean auth_only,
gboolean create)
{
NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self);
GtkWidget *widget;
char *label, *icon_name = "network-wireless";
gboolean security_combo_focus = FALSE;
gtk_window_set_position (GTK_WINDOW (self), GTK_WIN_POS_CENTER_ALWAYS);
gtk_container_set_border_width (GTK_CONTAINER (self), 6);
gtk_window_set_default_size (GTK_WINDOW (self), 488, -1);
gtk_window_set_resizable (GTK_WINDOW (self), FALSE);
gtk_dialog_set_has_separator (GTK_DIALOG (self), FALSE);
if (auth_only)
icon_name = "dialog-password";
else
icon_name = "network-wireless";
gtk_window_set_icon_name (GTK_WINDOW (self), icon_name);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "image1"));
gtk_image_set_from_icon_name (GTK_IMAGE (widget), icon_name, GTK_ICON_SIZE_DIALOG);
gtk_box_set_spacing (GTK_BOX (gtk_bin_get_child (GTK_BIN (self))), 2);
widget = gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_box_set_child_packing (GTK_BOX (GTK_DIALOG (self)->action_area), widget,
FALSE, TRUE, 0, GTK_PACK_END);
/* Connect/Create button */
if (create) {
GtkWidget *image;
widget = gtk_button_new_with_mnemonic (_("C_reate"));
image = gtk_image_new_from_stock (GTK_STOCK_CONNECT, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (widget), image);
gtk_widget_show (widget);
gtk_dialog_add_action_widget (GTK_DIALOG (self), widget, GTK_RESPONSE_OK);
} else
widget = gtk_dialog_add_button (GTK_DIALOG (self), GTK_STOCK_CONNECT, GTK_RESPONSE_OK);
gtk_box_set_child_packing (GTK_BOX (GTK_DIALOG (self)->action_area), widget,
FALSE, TRUE, 0, GTK_PACK_END);
g_object_set (G_OBJECT (widget), "can-default", TRUE, NULL);
gtk_widget_grab_default (widget);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "hbox1"));
if (!widget) {
nm_warning ("Couldn't find UI wireless_dialog widget.");
return FALSE;
}
gtk_widget_reparent (widget, gtk_bin_get_child (GTK_BIN (self)));
/* If given a valid connection, hide the SSID bits and connection combo */
if (specific_connection) {
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_label"));
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_entry"));
gtk_widget_hide (widget);
security_combo_focus = TRUE;
} else {
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "network_name_entry"));
g_signal_connect (G_OBJECT (widget), "changed", (GCallback) ssid_entry_changed, self);
gtk_widget_grab_focus (widget);
}
gtk_dialog_set_response_sensitive (GTK_DIALOG (self), GTK_RESPONSE_OK, FALSE);
if (!device_combo_init (self, specific_device)) {
g_warning ("No wireless devices available.");
return FALSE;
}
if (!connection_combo_init (self, specific_connection)) {
g_warning ("Couldn't set up connection combo box.");
return FALSE;
}
if (!security_combo_init (self)) {
g_warning ("Couldn't set up wireless security combo box.");
return FALSE;
}
if (security_combo_focus)
gtk_widget_grab_focus (priv->sec_combo);
security_combo_changed (priv->sec_combo, self);
g_signal_connect (G_OBJECT (priv->sec_combo), "changed", G_CALLBACK (security_combo_changed), self);
if (priv->connection) {
char *tmp;
char *esc_ssid = NULL;
NMSettingWireless *s_wireless;
const GByteArray *ssid;
s_wireless = NM_SETTING_WIRELESS (nm_connection_get_setting (priv->connection, NM_TYPE_SETTING_WIRELESS));
ssid = s_wireless ? nm_setting_wireless_get_ssid (s_wireless) : NULL;
if (ssid)
esc_ssid = nm_utils_ssid_to_utf8 ((const char *) ssid->data, ssid->len);
tmp = g_strdup_printf (_("Passwords or encryption keys are required to access the wireless network '%s'."),
esc_ssid ? esc_ssid : "<unknown>");
gtk_window_set_title (GTK_WINDOW (self), _("Wireless Network Authentication Required"));
label = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s",
_("Authentication required by wireless network"),
tmp);
g_free (esc_ssid);
g_free (tmp);
} else if (priv->adhoc_create) {
gtk_window_set_title (GTK_WINDOW (self), _("Create New Wireless Network"));
label = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s",
_("New wireless network"),
_("Enter a name for the wireless network you wish to create."));
} else {
gtk_window_set_title (GTK_WINDOW (self), _("Connect to Hidden Wireless Network"));
label = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s",
_("Hidden wireless network"),
_("Enter the name and security details of the hidden wireless network you wish to connect to."));
}
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "caption_label"));
gtk_label_set_markup (GTK_LABEL (widget), label);
g_free (label);
/* Re-validate from an idle handler so that widgets like file choosers
* have had time to find their files.
*/
g_idle_add (revalidate, self);
return TRUE;
}
static void
mailwatch_iconbtn_clicked_cb(GtkWidget *w, gpointer user_data)
{
Control *c = user_data;
XfceMailwatchPlugin *mwp = c->data;
gint icon_type = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(w),
"mailwatch-icontype"));
GtkWidget *chooser, *toplevel;
g_return_if_fail(icon_type == 1 || icon_type == 2);
toplevel = gtk_widget_get_toplevel(w);
chooser = xfce_file_chooser_dialog_new(_("Select Icon"),
GTK_WINDOW(toplevel),
XFCE_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
if(gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_ACCEPT) {
gchar *filename = xfce_file_chooser_get_filename(XFCE_FILE_CHOOSER(chooser));
if(filename) {
switch(icon_type) {
case 1:
{
GtkWidget *vbox, *img, *lbl;
g_free(mwp->normal_icon);
mwp->normal_icon = filename;
mailwatch_set_size(c, settings.size);
gtk_container_remove(GTK_CONTAINER(w),
gtk_bin_get_child(GTK_BIN(w)));
vbox = gtk_vbox_new(FALSE, BORDER/2);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(w), vbox);
img = gtk_image_new_from_pixbuf(mwp->pix_normal);
gtk_widget_show(img);
gtk_box_pack_start(GTK_BOX(vbox), img, TRUE, TRUE, 0);
lbl = gtk_label_new_with_mnemonic(_("_Normal"));
gtk_widget_show(lbl);
gtk_box_pack_start(GTK_BOX(vbox), lbl, FALSE, FALSE, 0);
}
break;
case 2:
{
GtkWidget *vbox, *img, *lbl;
g_free(mwp->new_mail_icon);
mwp->new_mail_icon = filename;
mailwatch_set_size(c, settings.size);
gtk_container_remove(GTK_CONTAINER(w),
gtk_bin_get_child(GTK_BIN(w)));
vbox = gtk_vbox_new(FALSE, BORDER/2);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(w), vbox);
img = gtk_image_new_from_pixbuf(mwp->pix_newmail);
gtk_widget_show(img);
gtk_box_pack_start(GTK_BOX(vbox), img, TRUE, TRUE, 0);
lbl = gtk_label_new_with_mnemonic(_("Ne_w mail"));
gtk_widget_show(lbl);
gtk_box_pack_start(GTK_BOX(vbox), lbl, FALSE, FALSE, 0);
}
break;
}
}
}
gtk_widget_destroy(chooser);
}
VikLayerParamData a_uibuilder_widget_get_value ( GtkWidget *widget, VikLayerParam *param )
{
VikLayerParamData rv;
switch ( param->widget_type )
{
case VIK_LAYER_WIDGET_COLOR:
gtk_color_button_get_color ( GTK_COLOR_BUTTON(widget), &(rv.c) );
break;
case VIK_LAYER_WIDGET_CHECKBUTTON:
rv.b = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
break;
case VIK_LAYER_WIDGET_COMBOBOX:
if ( param->type == VIK_LAYER_PARAM_UINT )
{
rv.i = gtk_combo_box_get_active ( GTK_COMBO_BOX(widget) );
if ( rv.i == -1 ) rv.i = 0;
rv.u = rv.i;
if ( param->extra_widget_data )
rv.u = ((guint *)param->extra_widget_data)[rv.u];
}
if ( param->type == VIK_LAYER_PARAM_STRING)
{
if ( param->extra_widget_data )
{
/* Combobox displays labels and we want values from extra */
int pos = gtk_combo_box_get_active ( GTK_COMBO_BOX(widget) );
rv.s = ((const char **)param->extra_widget_data)[pos];
}
else
{
/* Return raw value */
#if GTK_CHECK_VERSION (2, 24, 0)
rv.s = gtk_entry_get_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (widget))));
#else
rv.s = gtk_combo_box_get_active_text ( GTK_COMBO_BOX(widget) );
#endif
}
g_debug("%s: %s", __FUNCTION__, rv.s);
}
break;
case VIK_LAYER_WIDGET_RADIOGROUP:
case VIK_LAYER_WIDGET_RADIOGROUP_STATIC:
rv.u = vik_radio_group_get_selected(VIK_RADIO_GROUP(widget));
if ( param->extra_widget_data )
rv.u = GPOINTER_TO_UINT ( g_list_nth_data(param->extra_widget_data, rv.u) );
break;
case VIK_LAYER_WIDGET_SPINBUTTON:
if ( param->type == VIK_LAYER_PARAM_UINT )
rv.u = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(widget) );
else if ( param->type == VIK_LAYER_PARAM_INT )
rv.i = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(widget) );
else
rv.d = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(widget) );
break;
case VIK_LAYER_WIDGET_ENTRY:
case VIK_LAYER_WIDGET_PASSWORD:
rv.s = gtk_entry_get_text ( GTK_ENTRY(widget) );
break;
case VIK_LAYER_WIDGET_FILEENTRY:
case VIK_LAYER_WIDGET_FOLDERENTRY:
rv.s = vik_file_entry_get_filename ( VIK_FILE_ENTRY(widget) );
break;
case VIK_LAYER_WIDGET_FILELIST:
rv.sl = vik_file_list_get_files ( VIK_FILE_LIST(widget) );
break;
case VIK_LAYER_WIDGET_HSCALE:
if ( param->type == VIK_LAYER_PARAM_UINT )
rv.u = (guint32) gtk_range_get_value ( GTK_RANGE(widget) );
else if ( param->type == VIK_LAYER_PARAM_INT )
rv.i = (gint32) gtk_range_get_value ( GTK_RANGE(widget) );
else
rv.d = gtk_range_get_value ( GTK_RANGE(widget) );
break;
default: break;
}
// Perform conversion if necessary
if ( param->convert_to_internal )
rv = param->convert_to_internal ( rv );
return rv;
}
static void
update_editor_sheet (EggToolbarEditor *editor)
{
gint y;
GPtrArray *items;
GList *to_move = NULL, *to_copy = NULL;
GtkWidget *table;
GtkWidget *viewport;
g_return_if_fail (EGG_IS_TOOLBAR_EDITOR (editor));
/* Create new table. */
table = gtk_table_new (0, 0, TRUE);
editor->priv->table = table;
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
gtk_table_set_row_spacings (GTK_TABLE (table), 24);
gtk_widget_show (table);
gtk_drag_dest_set (table, GTK_DEST_DEFAULT_ALL,
dest_drag_types, G_N_ELEMENTS (dest_drag_types),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
/* Build two lists of items (one for copying, one for moving). */
items = egg_toolbars_model_get_name_avail (editor->priv->model);
while (items->len > 0)
{
GtkWidget *item;
const char *name;
gint flags;
name = g_ptr_array_index (items, 0);
g_ptr_array_remove_index_fast (items, 0);
flags = egg_toolbars_model_get_name_flags (editor->priv->model, name);
if ((flags & EGG_TB_MODEL_NAME_INFINITE) == 0)
{
item = editor_create_item_from_name (editor, name, GDK_ACTION_MOVE);
if (item != NULL)
to_move = g_list_insert_sorted (to_move, item, compare_items);
}
else
{
item = editor_create_item_from_name (editor, name, GDK_ACTION_COPY);
if (item != NULL)
to_copy = g_list_insert_sorted (to_copy, item, compare_items);
}
}
/* Add them to the sheet. */
y = 0;
y = append_table (GTK_TABLE (table), to_move, y, 4);
y = append_table (GTK_TABLE (table), to_copy, y, 4);
g_list_free (to_move);
g_list_free (to_copy);
g_ptr_array_free (items, TRUE);
/* Delete old table. */
viewport = gtk_bin_get_child (GTK_BIN (editor->priv->scrolled_window));
if (viewport)
{
gtk_container_remove (GTK_CONTAINER (viewport),
gtk_bin_get_child (GTK_BIN (viewport)));
}
/* Add table to window. */
gtk_scrolled_window_add_with_viewport
(GTK_SCROLLED_WINDOW (editor->priv->scrolled_window), table);
}
static gboolean budgie_popover_draw(GtkWidget *widget,
cairo_t *cr,
gboolean draw)
{
BudgiePopover *self = BUDGIE_POPOVER(widget);
GtkStyleContext *style;
GtkAllocation alloc;
GtkPositionType gap_side;
GdkRGBA color;
gdouble x, y, tail_height, gap_width;
gdouble margin, width, height, gap1, gap2;
x = 0;
y = 0;
tail_height = 12;
gap_width = 24;
margin = 11;
x += margin;
y += margin;
style = gtk_widget_get_style_context(widget);
gtk_style_context_add_class(style, GTK_STYLE_CLASS_FRAME);
gtk_widget_get_allocation(widget, &alloc);
/* Have parent class do drawing, so we gain shadows */
((GtkWidgetClass*)budgie_popover_parent_class)->draw(widget, cr);
/* Remove height of tail, and margin, from our rendered size */
width = alloc.width;
height = alloc.height - tail_height;
height -= margin;
width -= margin*2;
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
gap1 = (alloc.width/2)-(gap_width/2);
gap1 = self->widg_x;
gap2 = gap1 + gap_width;
gap2 -= margin;
gap_side = self->top == TRUE ? GTK_POS_TOP : GTK_POS_BOTTOM;
/* Render a gap in the bottom center for our arrow */
gtk_render_frame_gap(style, cr, x, y, width, height,
gap_side, gap1, gap2);
/* Fill in the background (pre-clip) */
gtk_render_background(style, cr, x, y, width, height);
/* Clip to the tail, fill in the arrow background */
cairo_save(cr);
if (self->top)
budgie_tail_path(cr, gap1, gap_width, y-margin, tail_height, self->top);
else
budgie_tail_path(cr, gap1, gap_width, height+margin, tail_height, self->top);
cairo_clip(cr);
if (self->top)
gtk_render_background(style, cr, x, y-tail_height, alloc.width, alloc.height);
else
gtk_render_background(style, cr, x, y, alloc.width, alloc.height);
cairo_restore(cr);
/* Draw in the border */
gtk_style_context_get_border_color(style, gtk_widget_get_state_flags(widget), &color);
gdk_cairo_set_source_rgba(cr, &color);
cairo_set_line_width(cr, 1);
if (self->top)
budgie_tail_path(cr, gap1, gap_width, y-margin, tail_height, self->top);
else
budgie_tail_path(cr, gap1, gap_width, height+margin, tail_height, self->top);
cairo_stroke(cr);
/* Draw children */
gtk_container_propagate_draw(GTK_CONTAINER(widget),
gtk_bin_get_child(GTK_BIN(widget)),
cr);
return TRUE;
}
void
ghb_update_widget(GtkWidget *widget, const GValue *value)
{
GType type;
gchar *str;
gint ival;
gdouble dval;
g_debug("ghb_update_widget");
type = G_VALUE_TYPE(value);
if (type == ghb_array_get_type() || type == ghb_dict_get_type())
return;
if (value == NULL) return;
str = ghb_value_string(value);
ival = ghb_value_int(value);
dval = ghb_value_double(value);
type = G_OBJECT_TYPE(widget);
if (type == GTK_TYPE_ENTRY)
{
g_debug("entry");
gtk_entry_set_text((GtkEntry*)widget, str);
}
else if (type == GTK_TYPE_RADIO_BUTTON)
{
g_debug("radio button");
if (ival)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), !!ival);
}
else if (type == GTK_TYPE_CHECK_BUTTON)
{
g_debug("check button");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), ival);
}
else if (type == GTK_TYPE_TOGGLE_TOOL_BUTTON)
{
g_debug("toggle button");
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), ival);
}
else if (type == GTK_TYPE_TOGGLE_BUTTON)
{
g_debug("toggle button");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), ival);
}
else if (type == GTK_TYPE_CHECK_MENU_ITEM)
{
g_debug("check menu item");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), ival);
}
else if (type == GTK_TYPE_COMBO_BOX)
{
GtkTreeModel *store;
GtkTreeIter iter;
gchar *shortOpt;
gdouble ivalue;
gboolean foundit = FALSE;
g_debug("combo (%s)", str);
store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
if (gtk_tree_model_get_iter_first (store, &iter))
{
do
{
gtk_tree_model_get(store, &iter, 2, &shortOpt, -1);
if (strcasecmp(shortOpt, str) == 0)
{
gtk_combo_box_set_active_iter (
GTK_COMBO_BOX(widget), &iter);
g_free(shortOpt);
foundit = TRUE;
break;
}
g_free(shortOpt);
} while (gtk_tree_model_iter_next (store, &iter));
}
if (!foundit && gtk_tree_model_get_iter_first (store, &iter))
{
do
{
gtk_tree_model_get(store, &iter, 3, &ivalue, -1);
if ((gint)ivalue == ival || ivalue == dval)
{
gtk_combo_box_set_active_iter (
GTK_COMBO_BOX(widget), &iter);
foundit = TRUE;
break;
}
} while (gtk_tree_model_iter_next (store, &iter));
}
if (!foundit)
{
if (gtk_combo_box_get_has_entry(GTK_COMBO_BOX(widget)))
{
GtkEntry *entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(widget)));
if (entry)
{
gtk_entry_set_text (entry, str);
}
else
{
gtk_combo_box_set_active (GTK_COMBO_BOX(widget), 0);
}
}
else
{
gtk_combo_box_set_active (GTK_COMBO_BOX(widget), 0);
}
}
}
else if (type == GTK_TYPE_SPIN_BUTTON)
{
g_debug("spin (%s)", str);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), dval);
}
else if (type == GTK_TYPE_SCALE)
{
g_debug("hscale");
gtk_range_set_value(GTK_RANGE(widget), dval);
}
else if (type == GTK_TYPE_SCALE_BUTTON)
{
g_debug("scale_button");
gtk_scale_button_set_value(GTK_SCALE_BUTTON(widget), dval);
}
else if (type == GTK_TYPE_TEXT_VIEW)
{
g_debug("textview (%s)", str);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(
GTK_TEXT_VIEW(widget));
gtk_text_buffer_set_text (buffer, str, -1);
}
else if (type == GTK_TYPE_LABEL)
{
gtk_label_set_markup (GTK_LABEL(widget), str);
}
else if (type == GTK_TYPE_FILE_CHOOSER_BUTTON)
{
GtkFileChooserAction act;
act = gtk_file_chooser_get_action(GTK_FILE_CHOOSER(widget));
if (str[0] == 0)
{
// Do nothing
;
}
else if (act == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
act == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str);
}
else if (act == GTK_FILE_CHOOSER_ACTION_SAVE)
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str);
}
else
{
if (g_file_test(str, G_FILE_TEST_IS_DIR))
{
gtk_file_chooser_set_current_folder(
GTK_FILE_CHOOSER(widget), str);
}
else if (g_file_test(str, G_FILE_TEST_EXISTS))
{
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(widget), str);
}
else
{
gchar *dirname;
dirname = g_path_get_dirname(str);
gtk_file_chooser_set_current_folder(
GTK_FILE_CHOOSER(widget), dirname);
g_free(dirname);
}
}
}
else
{
g_debug("Attempt to set unknown widget type");
}
g_free(str);
}
void
ags_desk_init(AgsDesk *desk)
{
GtkHBox *hbox;
GtkAlignment *alignment;
GtkHBox *balance_hbox;
desk->name = NULL;
desk->xml_type = "ags-desk";
/* create widgets */
desk->vbox = (GtkVBox *) gtk_vbox_new(FALSE,
0);
gtk_container_add((GtkContainer*) gtk_bin_get_child((GtkBin *) desk),
(GtkWidget *) desk->vbox);
hbox = (GtkHBox *) gtk_hbox_new(FALSE,
0);
gtk_box_pack_start((GtkBox *) desk->vbox,
(GtkWidget *) hbox,
FALSE, FALSE,
0);
/* left pad */
desk->left_pad = ags_desk_input_pad_new(NULL);
gtk_box_pack_start((GtkBox *) hbox,
(GtkWidget *) desk->left_pad,
FALSE, FALSE,
0);
/* console */
alignment = gtk_alignment_new(0.0,
0.0,
0.0,
0.0);
gtk_box_pack_start((GtkBox *) hbox,
(GtkWidget *) alignment,
FALSE, FALSE,
0);
desk->console = (GtkVBox *) gtk_vbox_new(FALSE,
0);
gtk_container_add((GtkContainer *) alignment,
(GtkWidget *) desk->console);
balance_hbox = (GtkHBox *) gtk_hbox_new(FALSE,
0);
gtk_box_pack_start((GtkBox *) desk->console,
(GtkWidget *) balance_hbox,
FALSE, FALSE,
0);
desk->move_left = (GtkButton *) gtk_button_new_with_label(i18n("left"));
gtk_box_pack_start((GtkBox *) balance_hbox,
(GtkWidget *) desk->move_left,
FALSE, FALSE,
0);
desk->balance = (GtkScale *) gtk_hscale_new_with_range(-1.0, 1.0, 0.1);
gtk_widget_set_size_request((GtkWidget *) desk->balance,
200, -1);
gtk_box_pack_start((GtkBox *) balance_hbox,
(GtkWidget *) desk->balance,
FALSE, FALSE,
0);
desk->move_right = (GtkButton *) gtk_button_new_with_label(i18n("right"));
gtk_box_pack_start((GtkBox *) balance_hbox,
(GtkWidget *) desk->move_right,
FALSE, FALSE,
0);
/* left pad */
desk->right_pad = ags_desk_input_pad_new(NULL);
gtk_box_pack_start((GtkBox *) hbox,
(GtkWidget *) desk->right_pad,
FALSE, FALSE,
0);
/* file chooser */
desk->file_chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_widget_set_size_request((GtkWidget *) desk->file_chooser,
-1, 400);
gtk_box_pack_start((GtkBox *) desk->vbox,
(GtkWidget *) desk->file_chooser,
FALSE, FALSE,
0);
}
