static void
preferences_radio_button_toggled_cb (GtkWidget *button,
gpointer user_data)
{
const gchar *key;
const gchar *value = NULL;
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) {
return;
}
key = g_object_get_data (G_OBJECT (button), "key");
if (key && strcmp (key, EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM) == 0) {
GSList *group;
GType type;
GEnumClass *enum_class;
GEnumValue *enum_value;
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
/* Get string from index */
type = empathy_contact_list_store_sort_get_type ();
enum_class = G_ENUM_CLASS (g_type_class_peek (type));
enum_value = g_enum_get_value (enum_class, g_slist_index (group, button));
if (!enum_value) {
g_warning ("No GEnumValue for EmpathyContactListSort with GtkRadioButton index:%d",
g_slist_index (group, button));
return;
}
value = enum_value->value_nick;
}
empathy_conf_set_string (empathy_conf_get (), key, value);
}
static void koneplus_dcu_frame_init(KoneplusDcuFrame *frame) {
KoneplusDcuFramePrivate *priv = KONEPLUS_DCU_FRAME_GET_PRIVATE(frame);
GtkWidget *box;
GtkWidget *radio;
int i;
frame->priv = priv;
box = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), box);
struct {
KoneplusControlUnitDcu state;
gchar const *title;
} radios[4] = {
{KONEPLUS_DISTANCE_CONTROL_UNIT_OFF, N_("Off")},
{KONEPLUS_DISTANCE_CONTROL_UNIT_EXTRA_LOW, N_("Extra low")},
{KONEPLUS_DISTANCE_CONTROL_UNIT_LOW, N_("Low")},
{KONEPLUS_DISTANCE_CONTROL_UNIT_NORMAL, N_("Normal")},
};
priv->radios = NULL;
for (i = 3; i >= 0; --i) {
radio = gtk_radio_button_new_with_label(priv->radios, _N(radios[i].title));
g_object_set_data(G_OBJECT(radio), state_key, GUINT_TO_POINTER(radios[i].state));
priv->radios = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio));
g_signal_connect(G_OBJECT(radio), "toggled", G_CALLBACK(radio_toggled_cb), frame);
}
g_slist_foreach(priv->radios, pack_radio_button, box);
gtk_frame_set_label(GTK_FRAME(frame), _("Distance control unit"));
gtk_widget_show_all(box);
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkCheckboxPeer_nativeSetCheckboxGroup
(JNIEnv *env, jobject obj, jobject group)
{
GtkRadioButton *button;
void *native_group, *ptr;
gdk_threads_enter ();
ptr = NSA_GET_PTR (env, obj);
/* FIXME: we can't yet switch between a checkbutton and a
radiobutton. However, AWT requires this. For now we just
crash. */
button = GTK_RADIO_BUTTON (ptr);
native_group = NSA_GET_PTR (env, group);
if (native_group == NULL)
gtk_radio_button_set_group (button, NULL);
else
gtk_radio_button_set_group (button,
gtk_radio_button_get_group
(GTK_RADIO_BUTTON (native_group)));
/* If the native group wasn't set on the new CheckboxGroup, then set
it now so that the right thing will happen with the next
radiobutton. The native state for a CheckboxGroup is a pointer
to one of the widgets in the group. We are careful to keep this
always pointing at a live widget; whenever a widget is destroyed
(or otherwise removed from the group), the CheckboxGroup peer is
notified. */
if (native_group == NULL)
NSA_SET_PTR (env, group, native_group);
gdk_threads_leave ();
}
/*
* Finds the radio button matching value and selects it and returns 1. If
* the value is not found, return 0.
*/
static int xv_sync_to_display_enable_index(CtkXVideo *ctk_xvideo, int value)
{
gpointer user_data;
GSList *slist = gtk_radio_button_get_group(
GTK_RADIO_BUTTON(ctk_xvideo->xv_sync_to_display_buttons));
while (slist) {
GtkWidget *button = GTK_WIDGET(slist->data);
user_data = g_object_get_data(G_OBJECT(button), "display_id");
if (GPOINTER_TO_INT(user_data) == value &&
value != NV_CTRL_XV_SYNC_TO_DISPLAY_ID_AUTO) {
xv_sync_to_display_set_enabled(ctk_xvideo, button, TRUE);
return 1;
} else {
xv_sync_to_display_set_enabled(ctk_xvideo, button, FALSE);
}
slist = g_slist_next(slist);
}
return 0;
}
static void
proxy_mode_radiobutton_clicked_cb (GtkWidget *widget,
GtkBuilder *builder)
{
GSList *mode_group;
int mode;
int old_mode;
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget)))
return;
mode_group = g_slist_copy (gtk_radio_button_get_group
(GTK_RADIO_BUTTON (gtk_builder_get_object (builder, "none_radiobutton"))));
mode_group = g_slist_reverse (mode_group);
mode = g_slist_index (mode_group, widget);
g_slist_free (mode_group);
old_mode = g_settings_get_enum (proxy_settings, PROXY_MODE_KEY);
if (mode == old_mode)
return;
g_settings_set_enum (proxy_settings, PROXY_MODE_KEY, mode);
}
/*
* xv_sync_to_display_radio_button_add() - create a radio button and plug it
* into the xv_sync_display_buttons radio group.
*/
static GtkWidget *xv_sync_to_display_radio_button_add(CtkXVideo *ctk_xvideo,
GtkWidget *last_button,
gint display_id)
{
gchar *label;
GtkWidget *button;
GSList *slist;
if (display_id == NV_CTRL_XV_SYNC_TO_DISPLAY_ID_AUTO) {
label = g_strdup("Auto");
} else {
label = xv_sync_to_display_radio_button_label(ctk_xvideo, display_id);
}
if (last_button) {
slist = gtk_radio_button_get_group(GTK_RADIO_BUTTON(last_button));
} else {
slist = NULL;
}
button = gtk_radio_button_new_with_label(slist, label);
g_free(label);
gtk_box_pack_start(GTK_BOX(ctk_xvideo->xv_sync_to_display_button_box),
button, FALSE, FALSE, 0);
g_object_set_data(G_OBJECT(button), "display_id",
GINT_TO_POINTER(display_id));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE);
g_signal_connect(G_OBJECT(button), "toggled",
G_CALLBACK(xv_sync_to_display_id_toggled),
(gpointer) ctk_xvideo);
return button;
}
/*
* Creates a radio button.
* box - the containing box.
* orient_type - The orientation ID
* label, help_string - self-describing
* radio_group -
* A pointer to a radio group. The function assigns its value
* as the radio group of the radio button. Afterwards, it assigns it
* a new value of the new radio group of the button.
* This is useful to group buttons. Just reset the variable to NULL,
* to create a new group.
* */
GtkWidget *
create_radio_button (GtkWidget *box,
int orient_type,
void (*callback) (GtkWidget *wg, void *d),
gchar *label,
gchar *help_string,
GSList **radio_group,
GtkWidget **buttons_array)
{
GtkWidget *tmpw;
buttons_array[orient_type] = tmpw =
gtk_radio_button_new_with_label ((*radio_group), label);
gtk_box_pack_start (GTK_BOX (box), tmpw, FALSE, FALSE, 0);
gtk_widget_show (tmpw);
g_signal_connect (tmpw, "clicked",
G_CALLBACK (callback), GINT_TO_POINTER (orient_type));
gimp_help_set_help_data (tmpw, help_string, NULL);
*radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (tmpw));
return tmpw;
}
static void
create_screenshot_frame (GtkWidget *outer_vbox,
const gchar *frame_title)
{
GtkWidget *main_vbox, *vbox, *hbox;
GtkWidget *align;
GtkWidget *radio;
GtkWidget *image;
GtkWidget *spin;
GtkWidget *label;
GtkAdjustment *adjust;
GSList *group;
gchar *title;
#if GTK_CHECK_VERSION (3, 0, 0)
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
#else
main_vbox = gtk_vbox_new (FALSE, 6);
#endif
gtk_box_pack_start (GTK_BOX (outer_vbox), main_vbox, FALSE, FALSE, 0);
gtk_widget_show (main_vbox);
title = g_strconcat ("<b>", frame_title, "</b>", NULL);
label = gtk_label_new (title);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_yalign (GTK_LABEL (label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (title);
#if GTK_CHECK_VERSION (3, 0, 0)
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
#else
hbox = gtk_hbox_new (FALSE, 12);
#endif
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
align = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
gtk_widget_set_size_request (align, 48, -1);
gtk_box_pack_start (GTK_BOX (hbox), align, FALSE, FALSE, 0);
gtk_widget_show (align);
image = gtk_image_new_from_stock (SCREENSHOOTER_ICON,
GTK_ICON_SIZE_DIALOG);
gtk_container_add (GTK_CONTAINER (align), image);
gtk_widget_show (image);
#if GTK_CHECK_VERSION (3, 0, 0)
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
#else
vbox = gtk_vbox_new (FALSE, 6);
#endif
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
/** Grab whole desktop **/
group = NULL;
radio = gtk_radio_button_new_with_mnemonic (group,
_("Grab the whole _desktop"));
if (take_window_shot || take_area_shot)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), FALSE);
g_signal_connect (radio, "toggled",
G_CALLBACK (target_toggled_cb),
GINT_TO_POINTER (TARGET_TOGGLE_DESKTOP));
gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio));
gtk_widget_show (radio);
/** Grab current window **/
radio = gtk_radio_button_new_with_mnemonic (group,
_("Grab the current _window"));
if (take_window_shot)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE);
g_signal_connect (radio, "toggled",
G_CALLBACK (target_toggled_cb),
GINT_TO_POINTER (TARGET_TOGGLE_WINDOW));
gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio));
gtk_widget_show (radio);
/** Grab area of the desktop **/
radio = gtk_radio_button_new_with_mnemonic (group,
_("Select _area to grab"));
if (take_area_shot)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE);
g_signal_connect (radio, "toggled",
G_CALLBACK (target_toggled_cb),
GINT_TO_POINTER (TARGET_TOGGLE_AREA));
gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0);
gtk_widget_show (radio);
/** Grab after delay **/
#if GTK_CHECK_VERSION (3, 0, 0)
delay_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
#else
delay_hbox = gtk_hbox_new (FALSE, 6);
#endif
gtk_widget_set_sensitive (delay_hbox, !take_area_shot);
gtk_box_pack_start (GTK_BOX (vbox), delay_hbox, FALSE, FALSE, 0);
gtk_widget_show (delay_hbox);
/* translators: this is the first part of the "grab after a
* delay of <spin button> seconds".
*/
label = gtk_label_new_with_mnemonic (_("Grab _after a delay of"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_yalign (GTK_LABEL (label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
gtk_box_pack_start (GTK_BOX (delay_hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adjust = GTK_ADJUSTMENT (gtk_adjustment_new ((gdouble) delay,
0.0, 99.0,
1.0, 1.0,
0.0));
spin = gtk_spin_button_new (adjust, 1.0, 0);
g_signal_connect (spin, "value-changed",
G_CALLBACK (delay_spin_value_changed_cb),
NULL);
gtk_box_pack_start (GTK_BOX (delay_hbox), spin, FALSE, FALSE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin);
gtk_widget_show (spin);
/* translators: this is the last part of the "grab after a
* delay of <spin button> seconds".
*/
label = gtk_label_new (_("seconds"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_yalign (GTK_LABEL (label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
gtk_box_pack_end (GTK_BOX (delay_hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
}
GtkWidget *
do_form_model_change (GtkWidget *do_widget)
{
if (!window) {
GdaStatement *stmt;
GtkWidget *vbox;
GtkWidget *label;
GdaDataModel *models [3];
window = gtk_dialog_new_with_buttons ("Changing data in a GdauiForm",
GTK_WINDOW (do_widget),
0,
"Close", GTK_RESPONSE_NONE,
NULL);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
label = gtk_label_new ("The data in the same GdauiForm widget can be change don the fly.");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
/* creating data models */
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT * FROM products ORDER BY ref, category LIMIT 15", NULL, NULL);
models[0] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[0]), NULL);
g_object_unref (stmt);
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT * FROM products WHERE price > 20.2 ORDER BY ref, category LIMIT 10", NULL, NULL);
models[1] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[1]), NULL);
g_object_unref (stmt);
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT name, price, ref, category FROM products WHERE price > 20.2 ORDER BY name LIMIT 30", NULL, NULL);
models[2] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[2]), NULL);
g_object_unref (stmt);
/* allow choosing which data model to display */
label = gtk_label_new ("");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_label_set_markup (GTK_LABEL (label), "<b>Choose which data model to display:</b>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
GtkWidget *layout, *rb;
GSList *group = NULL;
gint i;
layout = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (vbox), layout, FALSE, FALSE, 0);
for (i = 0; i < 3; i++) {
gchar *str;
str = g_strdup_printf ("%d columns x %d rows", gda_data_model_get_n_columns (models[i]),
gda_data_model_get_n_rows (models[i]));
rb = gtk_radio_button_new_with_label (group, str);
g_free (str);
gtk_grid_attach (GTK_GRID (layout), rb, i, 0, 1, 1);
g_signal_connect (rb, "toggled", G_CALLBACK (model_toggled_cb), models[i]);
g_object_set_data_full (G_OBJECT (rb), "model", models[i], g_object_unref);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (rb));
}
/* Create the form widget */
label = gtk_label_new ("");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_label_set_markup (GTK_LABEL (label), "<b>GdauiForm:</b>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
form = gdaui_form_new (models[0]);
g_object_set (G_OBJECT (form), "info-flags",
GDAUI_DATA_PROXY_INFO_CURRENT_ROW |
GDAUI_DATA_PROXY_INFO_ROW_MOVE_BUTTONS |
GDAUI_DATA_PROXY_INFO_ROW_MODIFY_BUTTONS, NULL);
gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
GdaDataProxy *proxy;
proxy = gdaui_data_proxy_get_proxy (GDAUI_DATA_PROXY (form));
g_object_set (proxy, "cache-changes", TRUE, NULL);
}
gboolean visible;
g_object_get (G_OBJECT (window), "visible", &visible, NULL);
if (!visible)
gtk_widget_show_all (window);
else {
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
GtkWidget *create_kbm_widget()
{
if (kbm_widget != NULL)
fprintf(stderr, "create_kbm_widget: kbm_widget was not NULL!\n");
load_settings();
GtkWidget *vbox_top = gtk_vbox_new (FALSE, 3);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL);
kbm_widget = vbox_top;
GtkWidget *hbox_lr = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_top), hbox_lr, FALSE, FALSE, 0);
GtkWidget *vbox_l = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_l), GTK_ORIENTATION_VERTICAL);
gtk_container_set_border_width (GTK_CONTAINER (vbox_l), 10);
gtk_box_pack_start (GTK_BOX (hbox_lr), vbox_l, TRUE, TRUE, 10);
GtkWidget *vbox_r = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_r), GTK_ORIENTATION_VERTICAL);
gtk_container_set_border_width (GTK_CONTAINER (vbox_r), 10);
gtk_box_pack_start (GTK_BOX (hbox_lr), vbox_r, TRUE, TRUE, 10);
GtkWidget *frame_kbm = gtk_frame_new(_("鍵盤排列方式/選擇鍵/選單每列字數"));
gtk_box_pack_start (GTK_BOX (vbox_l), frame_kbm, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_kbm), 1);
gtk_container_add (GTK_CONTAINER (frame_kbm), create_kbm_opts());
gtk_box_pack_start (GTK_BOX (vbox_l), create_en_pho_key_sel(_("(詞音) 切換[中/英]輸入"), 0), FALSE, FALSE, 0);
GtkWidget *frame_tsin_space_opt = gtk_frame_new(_("(詞音) 鍵入空白鍵"));
gtk_box_pack_start (GTK_BOX (vbox_l), frame_tsin_space_opt, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_space_opt), 1);
GtkWidget *box_tsin_space_opt = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(box_tsin_space_opt), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (frame_tsin_space_opt), box_tsin_space_opt);
gtk_container_set_border_width (GTK_CONTAINER (box_tsin_space_opt), 1);
GSList *group_tsin_space_opt = NULL;
int current_idx = get_currnet_tsin_space_option_idx();
new_select_idx_tsin_space_opt = current_idx;
gsize i;
for(i=0; i< tsin_space_optionsN; i++) {
GtkWidget *button = gtk_radio_button_new_with_label (group_tsin_space_opt, _(tsin_space_options[i].name));
gtk_box_pack_start (GTK_BOX (box_tsin_space_opt), button, FALSE, FALSE, 0);
group_tsin_space_opt = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (callback_button_clicked_tsin_space_opt), (gpointer) i);
if (i==current_idx)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
}
GtkWidget *hbox_tsin_phrase_pre_select = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_l), hbox_tsin_phrase_pre_select , FALSE, FALSE, 1);
check_button_tsin_phrase_pre_select = gtk_check_button_new_with_label(_("詞音輸入預選詞視窗"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_phrase_pre_select), check_button_tsin_phrase_pre_select, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_phrase_pre_select), tsin_phrase_pre_select);
GtkWidget *hbox_phonetic_char_dynamic_sequence = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_l), hbox_phonetic_char_dynamic_sequence , FALSE, FALSE, 1);
check_button_phonetic_char_dynamic_sequence = gtk_check_button_new_with_label(_("依使用頻率調整字的順序"));
gtk_box_pack_start (GTK_BOX (hbox_phonetic_char_dynamic_sequence), check_button_phonetic_char_dynamic_sequence, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_phonetic_char_dynamic_sequence), phonetic_char_dynamic_sequence);
GtkWidget *hbox_pho_hide_row2 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_pho_hide_row2 , FALSE, FALSE, 1);
check_button_pho_hide_row2 = gtk_check_button_new_with_label(_("注音隱藏第二列 (注音符號)"));
gtk_box_pack_start (GTK_BOX (hbox_pho_hide_row2), check_button_pho_hide_row2, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_pho_hide_row2), pho_hide_row2);
GtkWidget *hbox_pho_in_row1 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_pho_in_row1 , FALSE, FALSE, 1);
check_button_pho_in_row1 = gtk_check_button_new_with_label(_("注音符號移至第一列"));
gtk_box_pack_start (GTK_BOX (hbox_pho_in_row1), check_button_pho_in_row1, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_pho_in_row1), pho_in_row1);
GtkWidget *hbox_phonetic_huge_tab = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_phonetic_huge_tab , FALSE, FALSE, 1);
check_button_phonetic_huge_tab = gtk_check_button_new_with_label(_("使用巨大 UTF-8 字集"));
gtk_box_pack_start (GTK_BOX (hbox_phonetic_huge_tab), check_button_phonetic_huge_tab, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_phonetic_huge_tab), phonetic_huge_tab);
GtkWidget *hbox_tsin_tone_char_input = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tone_char_input , FALSE, FALSE, 1);
check_button_tsin_tone_char_input = gtk_check_button_new_with_label(_("(詞音) 輸入注音聲調符號"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_tone_char_input), check_button_tsin_tone_char_input, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_tone_char_input), tsin_tone_char_input);
GtkWidget *hbox_tsin_tab_phrase_end = gtk_hbox_new(FALSE, 1);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tab_phrase_end , FALSE, FALSE, 1);
check_button_tsin_tab_phrase_end = gtk_check_button_new_with_label(_("(詞音) 使用 Escape/Tab 斷詞"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_tab_phrase_end), check_button_tsin_tab_phrase_end, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_tab_phrase_end), tsin_tab_phrase_end);
GtkWidget *hbox_tsin_tail_select_key = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tail_select_key , FALSE, FALSE, 1);
check_button_tsin_tail_select_key = gtk_check_button_new_with_label(_("選擇鍵顯示於候選字(詞)後方"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_tail_select_key), check_button_tsin_tail_select_key, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_tail_select_key), tsin_tail_select_key);
GtkWidget *hbox_tsin_buffer_editing_mode = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_buffer_editing_mode , FALSE, FALSE, 1);
check_button_tsin_buffer_editing_mode = gtk_check_button_new_with_label(_("\\ 鍵可切換 jkx 鍵編輯模式"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_buffer_editing_mode), check_button_tsin_buffer_editing_mode, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_buffer_editing_mode), tsin_buffer_editing_mode);
GtkWidget *hbox_tsin_use_pho_near = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_use_pho_near , FALSE, FALSE, 1);
check_button_tsin_use_pho_near = gtk_check_button_new_with_label(_("按下 ↑ 鍵查詢近似音"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_use_pho_near), check_button_tsin_use_pho_near, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_use_pho_near), tsin_use_pho_near);
GtkWidget *frame_tsin_buffer_size = gtk_frame_new(_("(詞音) 的編輯緩衝區大小"));
gtk_box_pack_start (GTK_BOX (vbox_r), frame_tsin_buffer_size, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_buffer_size), 1);
GtkAdjustment *adj_gtab_in =
(GtkAdjustment *) gtk_adjustment_new (tsin_buffer_size, 10.0, MAX_PH_BF, 1.0, 1.0, 0.0);
spinner_tsin_buffer_size = gtk_spin_button_new (adj_gtab_in, 0, 0);
gtk_container_add (GTK_CONTAINER (frame_tsin_buffer_size), spinner_tsin_buffer_size);
return kbm_widget;
}
static gboolean
shoot_dialog (GdkScreen **screen)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *notebook;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *button;
GtkWidget *toggle;
GtkWidget *spinner;
GdkPixbuf *pixbuf;
GSList *radio_group = NULL;
GtkObject *adj;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Screenshot"), PLUG_IN_BINARY,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
button = gtk_dialog_add_button (GTK_DIALOG (dialog),
_("S_nap"), GTK_RESPONSE_OK);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
pixbuf = gdk_pixbuf_new_from_inline (-1, screenshot_icon, FALSE, NULL);
if (pixbuf)
{
gtk_button_set_image (GTK_BUTTON (button),
gtk_image_new_from_pixbuf (pixbuf));
g_object_unref (pixbuf);
}
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox,
FALSE, FALSE, 0);
gtk_widget_show (main_vbox);
/* Hints */
notebook = g_object_new (GTK_TYPE_NOTEBOOK,
"show-border", FALSE,
"show-tabs", FALSE,
NULL);
gtk_box_pack_end (GTK_BOX (main_vbox), notebook, FALSE, FALSE, 0);
gtk_widget_show (notebook);
shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_ROOT,
_("After the delay, the screenshot is taken."));
shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_REGION,
_("After the delay, drag your mouse to select "
"the region for the screenshot."));
shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_WINDOW,
_("At the end of the delay, click in a window "
"to snap it."));
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), shootvals.shoot_type);
/* Area */
frame = gimp_frame_new (_("Area"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
/* single window */
button = gtk_radio_button_new_with_mnemonic (radio_group,
_("Take a screenshot of "
"a single _window"));
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
shootvals.shoot_type == SHOOT_WINDOW);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_object_set_data (G_OBJECT (button), "gimp-item-data",
GINT_TO_POINTER (SHOOT_WINDOW));
g_signal_connect (button, "toggled",
G_CALLBACK (shoot_radio_button_toggled),
notebook);
#ifdef HAVE_X11_XMU_WINUTIL_H
hbox = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
toggle = gtk_check_button_new_with_mnemonic (_("Include window _decoration"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), shootvals.decorate);
gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 24);
gtk_widget_show (toggle);
g_object_set_data (G_OBJECT (button), "set_sensitive", toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&shootvals.decorate);
#endif /* HAVE_X11_XMU_WINUTIL_H */
/* whole screen */
button = gtk_radio_button_new_with_mnemonic (radio_group,
_("Take a screenshot of "
"the entire _screen"));
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
shootvals.shoot_type == SHOOT_ROOT);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_object_set_data (G_OBJECT (button), "gimp-item-data",
GINT_TO_POINTER (SHOOT_ROOT));
g_signal_connect (button, "toggled",
G_CALLBACK (shoot_radio_button_toggled),
notebook);
/* dragged region */
button = gtk_radio_button_new_with_mnemonic (radio_group,
_("Select a _region to grab"));
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
shootvals.shoot_type == SHOOT_REGION);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_object_set_data (G_OBJECT (button), "gimp-item-data",
GINT_TO_POINTER (SHOOT_REGION));
g_signal_connect (button, "toggled",
G_CALLBACK (shoot_radio_button_toggled),
notebook);
/* Delay */
frame = gimp_frame_new (_("Delay"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
spinner = gimp_spin_button_new (&adj, shootvals.select_delay,
0.0, 100.0, 1.0, 5.0, 0.0, 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0);
gtk_widget_show (spinner);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&shootvals.select_delay);
/* this is the unit label of a spinbutton */
label = gtk_label_new (_("seconds"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
if (run)
{
/* get the screen on which we are running */
*screen = gtk_widget_get_screen (dialog);
}
gtk_widget_destroy (dialog);
if (run)
{
/* A short timeout to give the server a chance to
* redraw the area that was obscured by our dialog.
*/
g_timeout_add (100, shoot_quit_timeout, NULL);
gtk_main ();
}
return run;
}
dialogo_propiedades_red_t * dialogo_propiedades_red_crear() {
dialogo_propiedades_red_t * dialogo_propiedades_red =
(dialogo_propiedades_red_t*)malloc(sizeof(dialogo_propiedades_red_t));
dialogo_propiedades_red->rbt_ordenes_group = NULL;
dialogo_propiedades_red->dlg_propiedades_red = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialogo_propiedades_red->dlg_propiedades_red), "Propiedades de la red");
dialogo_propiedades_red->dialog_vbox1 = GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red)->vbox;
gtk_widget_show (dialogo_propiedades_red->dialog_vbox1);
dialogo_propiedades_red->vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (dialogo_propiedades_red->vbox1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->dialog_vbox1), dialogo_propiedades_red->vbox1, TRUE, TRUE, 0);
dialogo_propiedades_red->label1 = gtk_label_new_with_mnemonic ("_Ruta del archivo:");
gtk_widget_show (dialogo_propiedades_red->label1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->label1, FALSE, FALSE, 0);
dialogo_propiedades_red->hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (dialogo_propiedades_red->hbox1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->hbox1, TRUE, TRUE, 0);
dialogo_propiedades_red->entry_ruta = gtk_entry_new ();
gtk_widget_show (dialogo_propiedades_red->entry_ruta);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox1), dialogo_propiedades_red->entry_ruta, TRUE, TRUE, 0);
dialogo_propiedades_red->button1 = gtk_button_new ();
gtk_widget_show (dialogo_propiedades_red->button1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox1), dialogo_propiedades_red->button1, FALSE, FALSE, 0);
dialogo_propiedades_red->alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (dialogo_propiedades_red->alignment1);
gtk_container_add (GTK_CONTAINER (dialogo_propiedades_red->button1), dialogo_propiedades_red->alignment1);
dialogo_propiedades_red->hbox2 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (dialogo_propiedades_red->hbox2);
gtk_container_add (GTK_CONTAINER (dialogo_propiedades_red->alignment1), dialogo_propiedades_red->hbox2);
dialogo_propiedades_red->image1 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (dialogo_propiedades_red->image1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox2), dialogo_propiedades_red->image1, FALSE, FALSE, 0);
dialogo_propiedades_red->label4 = gtk_label_new_with_mnemonic ("_...");
gtk_widget_show (dialogo_propiedades_red->label4);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox2), dialogo_propiedades_red->label4, FALSE, FALSE, 0);
dialogo_propiedades_red->hseparator1 = gtk_hseparator_new ();
gtk_widget_show (dialogo_propiedades_red->hseparator1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->hseparator1, TRUE, TRUE, 0);
dialogo_propiedades_red->frame1 = gtk_frame_new (NULL);
gtk_widget_show (dialogo_propiedades_red->frame1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->frame1, TRUE, TRUE, 0);
dialogo_propiedades_red->vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (dialogo_propiedades_red->vbox2);
gtk_container_add (GTK_CONTAINER (dialogo_propiedades_red->frame1), dialogo_propiedades_red->vbox2);
dialogo_propiedades_red->rbt_ordenes = gtk_radio_button_new_with_mnemonic (NULL, "\303\223_rdenes");
gtk_widget_show (dialogo_propiedades_red->rbt_ordenes);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox2), dialogo_propiedades_red->rbt_ordenes, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_ordenes), dialogo_propiedades_red->rbt_ordenes_group);
dialogo_propiedades_red->rbt_ordenes_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_ordenes));
dialogo_propiedades_red->rbt_parametros = gtk_radio_button_new_with_mnemonic (NULL, "P_ar\303\241metros");
gtk_widget_show (dialogo_propiedades_red->rbt_parametros);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox2), dialogo_propiedades_red->rbt_parametros, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_parametros), dialogo_propiedades_red->rbt_ordenes_group);
dialogo_propiedades_red->rbt_ordenes_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_parametros));
dialogo_propiedades_red->label3 = gtk_label_new ("M\303\263dulo");
gtk_widget_show (dialogo_propiedades_red->label3);
gtk_frame_set_label_widget (GTK_FRAME (dialogo_propiedades_red->frame1), dialogo_propiedades_red->label3);
dialogo_propiedades_red->dialog_action_area1 = GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red)->action_area;
gtk_widget_show (dialogo_propiedades_red->dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialogo_propiedades_red->dialog_action_area1), GTK_BUTTONBOX_END);
dialogo_propiedades_red->cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (dialogo_propiedades_red->cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red), dialogo_propiedades_red->cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (dialogo_propiedades_red->cancelbutton1, GTK_CAN_DEFAULT);
dialogo_propiedades_red->okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (dialogo_propiedades_red->okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red), dialogo_propiedades_red->okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (dialogo_propiedades_red->okbutton1, GTK_CAN_DEFAULT);
g_signal_connect((gpointer) dialogo_propiedades_red->button1, "clicked",
G_CALLBACK(boton_abrir), dialogo_propiedades_red);
return dialogo_propiedades_red;
}
static gboolean
vpropagate_dialog (GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle_vbox;
GtkWidget *button;
GtkObject *adj;
GSList *group = NULL;
gint index = 0;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Value Propagate"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, VPROPAGATE_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
main_vbox, TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
preview = gimp_drawable_preview_new (drawable, NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0);
gtk_widget_show (preview);
g_signal_connect_swapped (preview, "invalidated",
G_CALLBACK (value_propagate_body),
drawable);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* Propagate Mode */
frame = gimp_frame_new (_("Mode"));
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
toggle_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_add (GTK_CONTAINER (frame), toggle_vbox);
gtk_widget_show (toggle_vbox);
for (index = 0; index < num_mode; index++)
{
button =
gtk_radio_button_new_with_mnemonic (group,
gettext (modes[index].name));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_box_pack_start (GTK_BOX (toggle_vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_object_set_data (G_OBJECT (button), "gimp-item-data",
GINT_TO_POINTER (index));
g_signal_connect (button, "toggled",
G_CALLBACK (gimp_radio_button_update),
&vpvals.propagate_mode);
g_signal_connect_swapped (button, "toggled",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
index == vpvals.propagate_mode);
}
/* Parameter settings */
frame = gimp_frame_new (_("Propagate"));
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (8, 3, FALSE); /* 4 raw, 2 columns(name and value) */
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacing (GTK_TABLE (table), 2, 12);
gtk_table_set_row_spacing (GTK_TABLE (table), 5, 12);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Lower t_hreshold:"), SCALE_WIDTH, 4,
vpvals.lower_limit, 0, 255, 1, 8, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&vpvals.lower_limit);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("_Upper threshold:"), SCALE_WIDTH, 4,
vpvals.upper_limit, 0, 255, 1, 8, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&vpvals.upper_limit);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2,
_("_Propagating rate:"), SCALE_WIDTH, 4,
vpvals.propagating_rate, 0, 1, 0.01, 0.1, 2,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&vpvals.propagating_rate);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_table_add_toggle (table, _("To l_eft"), 0, 1, 4,
G_CALLBACK (vpropagate_toggle_button_update),
&direction_mask_vec[Right2Left]);
gtk_table_add_toggle (table, _("To _right"), 2, 3, 4,
G_CALLBACK (vpropagate_toggle_button_update),
&direction_mask_vec[Left2Right]);
gtk_table_add_toggle (table, _("To _top"), 1, 2, 3,
G_CALLBACK (vpropagate_toggle_button_update),
&direction_mask_vec[Bottom2Top]);
gtk_table_add_toggle (table, _("To _bottom"), 1, 2, 5,
G_CALLBACK (vpropagate_toggle_button_update),
&direction_mask_vec[Top2Bottom]);
if (gimp_drawable_has_alpha (drawable->drawable_id))
{
GtkWidget *toggle;
toggle =
gtk_table_add_toggle (table, _("Propagating _alpha channel"),
0, 3, 6,
G_CALLBACK (vpropagate_toggle_button_update),
&propagate_alpha);
if (gimp_layer_get_lock_alpha (drawable->drawable_id))
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), 0);
gtk_widget_set_sensitive (toggle, FALSE);
}
gtk_table_add_toggle (table, _("Propagating value channel"), 0, 3, 7,
G_CALLBACK (vpropagate_toggle_button_update),
&propagate_value);
}
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
if (run)
{
gint i, result;
for (i = result = 0; i < 4; i++)
result |= (direction_mask_vec[i] ? 1 : 0) << i;
vpvals.direction_mask = result;
vpvals.propagating_channel = ((propagate_alpha ? PROPAGATING_ALPHA : 0) |
(propagate_value ? PROPAGATING_VALUE : 0));
}
gtk_widget_destroy (dialog);
return run;
}
/* Set up the property editors in the dialog. */
static void
setup_dialog (GtkBuilder *dialog)
{
GtkRadioButton *radio;
/* Orientation radio buttons */
radio = GTK_RADIO_BUTTON (WID ("left_handed_radio"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(radio),
g_settings_get_boolean(mouse_settings, "left-handed"));
/* explicitly connect to button-release so that you can change orientation with either button */
g_signal_connect (WID ("right_handed_radio"), "button_release_event",
G_CALLBACK (orientation_radio_button_release_event), NULL);
g_signal_connect (WID ("left_handed_radio"), "button_release_event",
G_CALLBACK (orientation_radio_button_release_event), NULL);
g_signal_connect (WID ("left_handed_radio"), "toggled",
G_CALLBACK (orientation_radio_button_toggled), dialog);
/* Locate pointer toggle */
g_settings_bind (mouse_settings, "locate-pointer", WID ("locate_pointer_toggle"),
"active", G_SETTINGS_BIND_DEFAULT);
/* Double-click time */
g_settings_bind (mouse_settings, DOUBLE_CLICK_KEY,
gtk_range_get_adjustment (GTK_RANGE (WID ("delay_scale"))), "value",
G_SETTINGS_BIND_DEFAULT);
gtk_image_set_from_stock (GTK_IMAGE (WID ("double_click_image")), MOUSE_DBLCLCK_OFF, mouse_capplet_dblclck_icon_get_size ());
g_object_set_data (G_OBJECT (WID ("double_click_eventbox")), "image", WID ("double_click_image"));
g_signal_connect (WID ("double_click_eventbox"), "button_press_event",
G_CALLBACK (event_box_button_press_event), NULL);
/* speed */
g_settings_bind (mouse_settings, "motion-acceleration",
gtk_range_get_adjustment (GTK_RANGE (WID ("accel_scale"))), "value",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (mouse_settings, "motion-threshold",
gtk_range_get_adjustment (GTK_RANGE (WID ("sensitivity_scale"))), "value",
G_SETTINGS_BIND_DEFAULT);
/* DnD threshold */
g_settings_bind (mouse_settings, "drag-threshold",
gtk_range_get_adjustment (GTK_RANGE (WID ("drag_threshold_scale"))), "value",
G_SETTINGS_BIND_DEFAULT);
/* Trackpad page */
if (find_synaptics () == FALSE)
gtk_notebook_remove_page (GTK_NOTEBOOK (WID ("prefs_widget")), -1);
else {
g_settings_bind (touchpad_settings, "touchpad-enabled",
WID ("touchpad_enable"), "active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (touchpad_settings, "touchpad-enabled",
WID ("vbox_touchpad_general"), "sensitive",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (touchpad_settings, "touchpad-enabled",
WID ("vbox_touchpad_scrolling"), "sensitive",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (touchpad_settings, "disable-while-typing",
WID ("disable_w_typing_toggle"), "active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (touchpad_settings, "tap-to-click",
WID ("tap_to_click_toggle"), "active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (touchpad_settings, "horiz-scroll-enabled",
WID ("horiz_scroll_toggle"), "active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (touchpad_settings, "natural-scroll",
WID ("natural_scroll_toggle"), "active",
G_SETTINGS_BIND_DEFAULT);
scrollmethod_gsettings_changed_event (touchpad_settings, "scroll-method", dialog);
char * emulation_values[] = { _("Disabled"), _("Left button"), _("Middle button"), _("Right button") };
GtkWidget *two_click_comboxbox = gtk_combo_box_text_new ();
GtkWidget *three_click_comboxbox = gtk_combo_box_text_new ();
gtk_box_pack_start (GTK_BOX (WID ("hbox_two_finger_click")), two_click_comboxbox, FALSE, FALSE, 6);
gtk_box_pack_start (GTK_BOX (WID ("hbox_three_finger_click")), three_click_comboxbox, FALSE, FALSE, 6);
int i;
for (i=0; i<4; i++) {
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (two_click_comboxbox), emulation_values[i]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (three_click_comboxbox), emulation_values[i]);
}
gtk_combo_box_set_active (GTK_COMBO_BOX (two_click_comboxbox), g_settings_get_int (touchpad_settings, "two-finger-click"));
gtk_combo_box_set_active (GTK_COMBO_BOX (three_click_comboxbox), g_settings_get_int (touchpad_settings, "three-finger-click"));
gtk_widget_show (two_click_comboxbox);
gtk_widget_show (three_click_comboxbox);
g_signal_connect (two_click_comboxbox, "changed", G_CALLBACK (comboxbox_changed_callback), "two-finger-click");
g_signal_connect (three_click_comboxbox, "changed", G_CALLBACK (comboxbox_changed_callback), "three-finger-click");
radio = GTK_RADIO_BUTTON (WID ("scroll_disabled_radio"));
GSList *radio_group = gtk_radio_button_get_group (radio);
GSList *item = NULL;
synaptics_check_capabilities (dialog);
for (item = radio_group; item != NULL; item = item->next) {
g_signal_connect (G_OBJECT (item->data), "clicked",
G_CALLBACK(scrollmethod_clicked_event),
dialog);
}
g_signal_connect (touchpad_settings,
"changed::scroll-method",
G_CALLBACK(scrollmethod_gsettings_changed_event),
dialog);
}
}
static void
greeter_system_handler (GreeterItemInfo *info,
gpointer user_data)
{
GtkWidget *w = NULL;
GtkWidget *hbox = NULL;
GtkWidget *main_vbox = NULL;
GtkWidget *vbox = NULL;
GtkWidget *cat_vbox = NULL;
GtkWidget *group_radio = NULL;
GtkWidget *halt_radio = NULL;
GtkWidget *suspend_radio = NULL;
GtkWidget *restart_radio = NULL;
GtkWidget *config_radio = NULL;
gchar *s;
int ret;
gint i;
GSList *radio_group = NULL;
static GtkTooltips *tooltips = NULL;
/* should never be allowed by the UI */
if ( ! mdm_config_get_bool (MDM_KEY_SYSTEM_MENU) ||
ve_string_empty (g_getenv ("MDM_IS_LOCAL")))
return;
dialog = gtk_dialog_new ();
if (tooltips == NULL)
tooltips = gtk_tooltips_new ();
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
main_vbox = gtk_vbox_new (FALSE, 18);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 5);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
main_vbox,
FALSE, FALSE, 0);
cat_vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (main_vbox),
cat_vbox,
FALSE, FALSE, 0);
s = g_strdup_printf ("<b>%s</b>",
_("Choose an Action"));
w = gtk_label_new (s);
gtk_label_set_use_markup (GTK_LABEL (w), TRUE);
g_free (s);
gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (cat_vbox), w, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (cat_vbox),
hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox),
gtk_label_new (" "),
FALSE, FALSE, 0);
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox),
vbox,
TRUE, TRUE, 0);
if (MdmHaltFound) {
if (group_radio != NULL)
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio));
halt_radio = gtk_radio_button_new_with_mnemonic (radio_group,
_("Shut _down the computer"));
group_radio = halt_radio;
gtk_tooltips_set_tip (tooltips, GTK_WIDGET (halt_radio),
_("Shut Down your computer so that "
"you may turn it off."),
NULL);
g_signal_connect (G_OBJECT(halt_radio), "button_press_event",
G_CALLBACK(radio_button_press_event), NULL);
gtk_box_pack_start (GTK_BOX (vbox),
halt_radio,
FALSE, FALSE, 4);
gtk_widget_show (halt_radio);
}
if (MdmRebootFound) {
if (group_radio != NULL)
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio));
restart_radio = gtk_radio_button_new_with_mnemonic (radio_group,
_("_Restart the computer"));
group_radio = restart_radio;
gtk_tooltips_set_tip (tooltips, GTK_WIDGET (restart_radio),
_("Restart your computer"),
NULL);
g_signal_connect (G_OBJECT(restart_radio), "button_press_event",
G_CALLBACK(radio_button_press_event), NULL);
gtk_box_pack_start (GTK_BOX (vbox),
restart_radio,
FALSE, FALSE, 4);
gtk_widget_show (restart_radio);
}
if (MdmSuspendFound) {
if (group_radio != NULL)
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio));
suspend_radio = gtk_radio_button_new_with_mnemonic (radio_group,
_("Sus_pend the computer"));
group_radio = suspend_radio;
gtk_tooltips_set_tip (tooltips, GTK_WIDGET (suspend_radio),
_("Suspend your computer"),
NULL);
g_signal_connect (G_OBJECT(suspend_radio), "button_press_event",
G_CALLBACK(radio_button_press_event), NULL);
gtk_box_pack_start (GTK_BOX (vbox),
suspend_radio,
FALSE, FALSE, 4);
gtk_widget_show (suspend_radio);
}
/*
* Disable Configuration if using accessibility (AddGtkModules) since
* using it with accessibility causes a hang.
*/
if (mdm_config_get_bool (MDM_KEY_CONFIG_AVAILABLE) &&
!mdm_config_get_bool (MDM_KEY_ADD_GTK_MODULES) &&
bin_exists (mdm_config_get_string (MDM_KEY_CONFIGURATOR))) {
if (group_radio != NULL)
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio));
config_radio = gtk_radio_button_new_with_mnemonic (radio_group,
_("Confi_gure the login manager"));
group_radio = config_radio;
gtk_tooltips_set_tip (tooltips, GTK_WIDGET (config_radio),
_("Configure MDM (this login manager). "
"This will require the root password."),
NULL);
g_signal_connect (G_OBJECT(config_radio), "button_press_event",
G_CALLBACK(radio_button_press_event), NULL);
gtk_box_pack_start (GTK_BOX (vbox),
config_radio,
FALSE, FALSE, 4);
gtk_widget_show (config_radio);
}
gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_OK,
GTK_RESPONSE_OK);
gtk_dialog_set_default_response (GTK_DIALOG (dialog),
GTK_RESPONSE_OK);
gtk_widget_show_all (dialog);
mdm_wm_center_window (GTK_WINDOW (dialog));
mdm_wm_no_login_focus_push ();
ret = gtk_dialog_run (GTK_DIALOG (dialog));
mdm_wm_no_login_focus_pop ();
if (ret != GTK_RESPONSE_OK)
{
gtk_widget_destroy (dialog);
return;
}
if (halt_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (halt_radio)))
greeter_halt_handler ();
else if (restart_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (restart_radio)))
greeter_restart_handler ();
else if (suspend_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (suspend_radio)))
greeter_suspend_handler ();
else if (config_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (config_radio)))
greeter_config_handler ();
gtk_widget_destroy (dialog);
}
GtkWidget *AP_UnixDialog_Lists::_constructWindowContents (void)
{
GtkWidget *vbox2;
GtkWidget *hbox2;
GtkWidget *vbox4;
GtkWidget *table1;
GtkWidget *style_om;
GtkWidget *type_om;
GtkWidget *type_lb;
GtkWidget *style_lb;
GtkWidget *customized_cb;
GtkWidget *frame1;
GtkWidget *table2;
GtkComboBox *font_om;
GtkListStore *font_om_menu;
GtkWidget *format_en;
GtkWidget *decimal_en;
GtkAdjustment *start_sb_adj;
GtkWidget *start_sb;
GtkAdjustment *text_align_sb_adj;
GtkWidget *text_align_sb;
GtkAdjustment *label_align_sb_adj;
GtkWidget *label_align_sb;
GtkWidget *format_lb;
GtkWidget *font_lb;
GtkWidget *delimiter_lb;
GtkWidget *start_at_lb;
GtkWidget *text_align_lb;
GtkWidget *label_align_lb;
GtkWidget *vbox3;
GtkWidget *preview_lb;
GtkWidget *hbox1;
GSList *action_group = NULL;
GtkWidget *start_list_rb;
GtkWidget *apply_list_rb;
GtkWidget *resume_list_rb;
GtkWidget *preview_area;
GtkWidget *preview_frame;
const XAP_StringSet * pSS = m_pApp->getStringSet();
UT_UTF8String s;
GtkWidget * wNoteBook = NULL;
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox2);
if(!isModal())
{
// Note Book creation
wNoteBook = gtk_notebook_new ();
gtk_widget_show(wNoteBook);
// Container for the lists
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageProperties,s);
GtkWidget * lbPageLists = gtk_label_new(s.utf8_str());
gtk_widget_show(lbPageLists);
gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),vbox2,lbPageLists);
m_iPageLists = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),vbox2);
// Container for Text Folding
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageFolding,s);
GtkWidget * lbPageFolding = gtk_label_new(s.utf8_str());
GtkWidget * wFoldingTable = gtk_table_new(6,3,FALSE);
gtk_widget_show(lbPageFolding);
gtk_widget_show(wFoldingTable);
gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),wFoldingTable,lbPageFolding);
m_iPageFold = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),wFoldingTable);
// Left Spacing Here
GtkWidget * lbLeftSpacer = gtk_label_new("");
gtk_misc_set_padding(GTK_MISC(lbLeftSpacer),8,0);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbLeftSpacer,0,1,0,6,GTK_SHRINK,GTK_FILL,0,0);
gtk_widget_show(lbLeftSpacer);
// Bold markup
GtkWidget * lbFoldHeading = gtk_label_new("<b>%s</b>");
gtk_label_set_use_markup(GTK_LABEL(lbFoldHeading),TRUE);
localizeLabelMarkup(lbFoldHeading,pSS,AP_STRING_ID_DLG_Lists_FoldingLevelexp);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbFoldHeading,1,3,0,1,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(lbFoldHeading);
// Mid Left Spacing Here
GtkWidget * lbMidLeftSpacer = gtk_label_new("");
gtk_misc_set_padding(GTK_MISC(lbMidLeftSpacer),8,0);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbMidLeftSpacer,1,2,1,6,GTK_SHRINK,GTK_FILL,0,0);
gtk_widget_show(lbMidLeftSpacer);
m_vecFoldCheck.clear();
m_vecFoldID.clear();
UT_uint32 ID =0;
// RadioButtons
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel0,s);
GtkWidget * wF = gtk_radio_button_new_with_label(NULL, s.utf8_str());
GSList *wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"0");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,1,2,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel1,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"1");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,2,3,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel2,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"2");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,3,4,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel3,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"3");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,4,5,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel4,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"4");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,5,6,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
gtk_widget_show(wFoldingTable);
gtk_notebook_set_current_page(GTK_NOTEBOOK(wNoteBook),m_iPageLists);
}
// List Page
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 8);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
vbox4 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
gtk_widget_show (vbox4);
gtk_box_pack_start (GTK_BOX (hbox2), vbox4, FALSE, TRUE, 0);
table1 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox4), table1, FALSE, TRUE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table1), 4);
style_om = gtk_combo_box_text_new();
gtk_widget_show (style_om);
gtk_table_attach (GTK_TABLE (table1), style_om, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
m_wListStyleNone_menu = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_INT);
_fillNoneStyleMenu(m_wListStyleNone_menu.obj());
m_wListStyleNumbered_menu = gtk_list_store_new (2, G_TYPE_STRING,
G_TYPE_INT);
_fillNumberedStyleMenu(m_wListStyleNumbered_menu.obj());
m_wListStyleBulleted_menu = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_INT);
_fillBulletedStyleMenu(m_wListStyleBulleted_menu.obj());
// This is the default list. Change if the list style changes
//
m_wListStyle_menu = m_wListStyleNumbered_menu;
gtk_combo_box_set_model(GTK_COMBO_BOX (style_om),
GTK_TREE_MODEL(m_wListStyleNumbered_menu.obj()));
type_om = gtk_combo_box_text_new();
gtk_widget_show (type_om);
gtk_table_attach (GTK_TABLE (table1), type_om, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_none,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_bullet,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_numbered,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
gtk_combo_box_set_active(GTK_COMBO_BOX(type_om), 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type,s);
type_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (type_lb);
gtk_table_attach (GTK_TABLE (table1), type_lb, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (type_lb), 0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Style,s);
style_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (style_lb);
gtk_table_attach (GTK_TABLE (table1), style_lb, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (style_lb), 0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_SetDefault,s);
customized_cb = gtk_dialog_add_button (GTK_DIALOG(m_wMainWindow), s.utf8_str(), BUTTON_RESET);
gtk_widget_show (customized_cb);
/* todo
gtk_table_attach (GTK_TABLE (table1), customized_cb, 0, 2, 2, 3,
(GtkAttachOptions) (GTK_SHRINK),
(GtkAttachOptions) (0), 0, 0);
*/
frame1 = gtk_frame_new (NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame1), GTK_SHADOW_NONE);
//gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox4), frame1, TRUE, TRUE, 0);
table2 = gtk_table_new (6, 2, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (frame1), table2);
gtk_container_set_border_width (GTK_CONTAINER (table2), 4);
gtk_widget_set_sensitive (table2, TRUE);
gtk_table_set_row_spacings (GTK_TABLE (table2), 4);
gtk_table_set_col_spacings (GTK_TABLE (table2), 4);
font_om_menu = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
_fillFontMenu(font_om_menu);
font_om = GTK_COMBO_BOX(gtk_combo_box_new());
gtk_combo_box_set_model(font_om, GTK_TREE_MODEL(font_om_menu));
gtk_widget_show (GTK_WIDGET(font_om));
gtk_table_attach (GTK_TABLE (table2), GTK_WIDGET(font_om), 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
format_en = gtk_entry_new ();
gtk_entry_set_max_length(GTK_ENTRY(format_en), 20);
gtk_widget_show (format_en);
gtk_table_attach (GTK_TABLE (table2), format_en, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_entry_set_text (GTK_ENTRY (format_en), "%L");
decimal_en = gtk_entry_new ();
gtk_widget_show (decimal_en);
gtk_table_attach (GTK_TABLE (table2), decimal_en, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_entry_set_text (GTK_ENTRY (format_en), "");
start_sb_adj = (GtkAdjustment*)gtk_adjustment_new (1, 0, G_MAXINT32, 1, 10, 10);
start_sb = gtk_spin_button_new (GTK_ADJUSTMENT (start_sb_adj), 1, 0);
gtk_widget_show (start_sb);
gtk_table_attach (GTK_TABLE (table2), start_sb, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
text_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0.25, 0, 10, 0.01, 0.2, 1);
text_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (text_align_sb_adj), 0.05, 2);
gtk_widget_show (text_align_sb);
gtk_table_attach (GTK_TABLE (table2), text_align_sb, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (text_align_sb), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (text_align_sb), TRUE);
label_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0, 0, 10, 0.01, 0.2, 1);
label_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (label_align_sb_adj), 0.05, 2);
gtk_widget_show (label_align_sb);
gtk_table_attach (GTK_TABLE (table2), label_align_sb, 1, 2, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (label_align_sb), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (label_align_sb), TRUE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Format,s);
format_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (format_lb);
gtk_table_attach (GTK_TABLE (table2), format_lb, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (format_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Font,s);
font_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (font_lb);
gtk_table_attach (GTK_TABLE (table2), font_lb, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (font_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_DelimiterString,s);
delimiter_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (delimiter_lb);
gtk_table_attach (GTK_TABLE (table2), delimiter_lb, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (delimiter_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start,s);
start_at_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (start_at_lb);
gtk_table_attach (GTK_TABLE (table2), start_at_lb, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (start_at_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Align,s);
text_align_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (text_align_lb);
gtk_table_attach (GTK_TABLE (table2), text_align_lb, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (text_align_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Indent,s);
label_align_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (label_align_lb);
gtk_table_attach (GTK_TABLE (table2), label_align_lb, 0, 1, 5, 6,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_align_lb), 0.0, 0.5);
vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox3);
gtk_box_pack_start (GTK_BOX (hbox2), vbox3, TRUE, TRUE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Preview,s);
preview_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (preview_lb);
gtk_box_pack_start (GTK_BOX (vbox3), preview_lb, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (preview_lb), 0.0, 0.5);
preview_frame = gtk_frame_new (NULL);
gtk_widget_show (preview_frame);
gtk_box_pack_start (GTK_BOX (vbox3), preview_frame, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (preview_frame), 3);
gtk_frame_set_shadow_type (GTK_FRAME (preview_frame), GTK_SHADOW_NONE);
preview_area = createDrawingArea ();
gtk_widget_set_size_request (preview_area,180,225);
gtk_widget_show (preview_area);
gtk_container_add (GTK_CONTAINER (preview_frame), preview_area);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
if(!isModal())
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start_New,s);
start_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (start_list_rb));
if(!isModal())
gtk_widget_show (start_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), start_list_rb, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (start_list_rb), TRUE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Apply_Current,s);
apply_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (apply_list_rb));
if(!isModal())
gtk_widget_show (apply_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), apply_list_rb, FALSE, FALSE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Resume,s);
resume_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (resume_list_rb));
if(!isModal())
gtk_widget_show (resume_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), resume_list_rb, FALSE, FALSE, 0);
// Save useful widgets in member variables
if(isModal())
{
m_wContents = vbox2;
}
else
{
m_wContents = wNoteBook;
}
m_wStartNewList = start_list_rb;
m_wStartNew_label = gtk_bin_get_child(GTK_BIN(start_list_rb));
m_wApplyCurrent = apply_list_rb;
m_wStartSubList = resume_list_rb;
m_wStartSub_label = gtk_bin_get_child(GTK_BIN(resume_list_rb));
m_wRadioGroup = action_group;
m_wPreviewArea = preview_area;
m_wDelimEntry = format_en;
m_oAlignList_adj = text_align_sb_adj;
m_wAlignListSpin = text_align_sb;
m_oIndentAlign_adj = label_align_sb_adj;
m_wIndentAlignSpin = label_align_sb;
m_wDecimalEntry = decimal_en;
m_oStartSpin_adj = start_sb_adj;
m_wStartSpin = start_sb;
m_wFontOptions = font_om;
m_wFontOptions_menu = font_om_menu;
m_wCustomFrame = frame1;
m_wCustomLabel = customized_cb;
m_wCustomTable = table2;
m_wListStyleBox = GTK_COMBO_BOX(style_om);
m_wListTypeBox = GTK_COMBO_BOX(type_om);
m_wListType_menu = m_wListStyleNumbered_menu;
// Start by hiding the Custom frame
//
// gtk_widget_hide(m_wCustomFrame);
gtk_widget_show(m_wCustomFrame);
setbisCustomized(false);
return m_wContents;
}
static void
setup_dialog (GtkBuilder *builder)
{
GSList *mode_group;
GtkListStore *store;
g_signal_connect (proxy_settings, "changed::" IGNORE_HOSTS_KEY,
G_CALLBACK (cb_ignore_hosts_gsettings_changed), NULL);
/* Mode */
proxy_mode_gsettings_changed (proxy_settings, PROXY_MODE_KEY, builder);
mode_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (gtk_builder_get_object (builder, "none_radiobutton")));
connect_sensitivity_signals (builder, mode_group);
g_signal_connect (proxy_settings, "changed::" PROXY_MODE_KEY,
G_CALLBACK (proxy_mode_gsettings_changed), builder);
/* Http */
g_settings_bind (http_proxy_settings, HTTP_PROXY_PORT_KEY,
gtk_builder_get_object (builder, "http_port_spinbutton"), "value",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (http_proxy_settings, HTTP_PROXY_HOST_KEY,
gtk_builder_get_object (builder, "http_host_entry"), "text",
G_SETTINGS_BIND_DEFAULT);
g_signal_connect (gtk_builder_get_object (builder, "details_button"),
"clicked",
G_CALLBACK (cb_http_details_button_clicked),
_gtk_builder_get_widget (builder, "network_dialog"));
/* Secure */
g_settings_bind (https_proxy_settings, SECURE_PROXY_PORT_KEY,
gtk_builder_get_object (builder, "secure_port_spinbutton"), "value",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (https_proxy_settings, SECURE_PROXY_HOST_KEY,
gtk_builder_get_object (builder, "secure_host_entry"), "text",
G_SETTINGS_BIND_DEFAULT);
/* Ftp */
g_settings_bind (ftp_proxy_settings, FTP_PROXY_PORT_KEY,
gtk_builder_get_object (builder, "ftp_port_spinbutton"), "value",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (ftp_proxy_settings, FTP_PROXY_HOST_KEY,
gtk_builder_get_object (builder, "ftp_host_entry"), "text",
G_SETTINGS_BIND_DEFAULT);
/* Socks */
g_settings_bind (socks_proxy_settings, SOCKS_PROXY_PORT_KEY,
gtk_builder_get_object (builder, "socks_port_spinbutton"), "value",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (socks_proxy_settings, SOCKS_PROXY_HOST_KEY,
gtk_builder_get_object (builder, "socks_host_entry"), "text",
G_SETTINGS_BIND_DEFAULT);
/* Autoconfiguration */
g_settings_bind (proxy_settings, PROXY_AUTOCONFIG_URL_KEY,
gtk_builder_get_object (builder, "autoconfig_entry"), "text",
G_SETTINGS_BIND_DEFAULT);
g_signal_connect (gtk_builder_get_object (builder, "network_dialog"),
"response", G_CALLBACK (cb_dialog_response), NULL);
read_ignore_hosts_from_gsettings ();
model = create_listmodel();
populate_listmodel(GTK_LIST_STORE(model), ignore_hosts);
config_treeview(GTK_TREE_VIEW(gtk_builder_get_object (builder, "treeview_ignore_host")), model);
g_signal_connect (gtk_builder_get_object (builder, "button_add_url"),
"clicked", G_CALLBACK (cb_add_url), builder);
g_signal_connect (gtk_builder_get_object (builder, "entry_url"),
"activate", G_CALLBACK (cb_add_url), builder);
g_signal_connect (gtk_builder_get_object (builder, "button_remove_url"),
"clicked", G_CALLBACK (cb_remove_url), builder);
}
GtkWidget *
palette_import_dialog_new (GimpContext *context)
{
ImportDialog *dialog;
GimpGradient *gradient;
GtkWidget *button;
GtkWidget *main_hbox;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *abox;
GtkSizeGroup *size_group;
GSList *group = NULL;
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
gradient = gimp_context_get_gradient (context);
dialog = g_slice_new0 (ImportDialog);
dialog->import_type = GRADIENT_IMPORT;
dialog->context = gimp_context_new (context->gimp, "Palette Import",
context);
dialog->dialog = gimp_dialog_new (_("Import a New Palette"),
"gimp-palette-import", NULL, 0,
gimp_standard_help_func,
GIMP_HELP_PALETTE_IMPORT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
button = gtk_dialog_add_button (GTK_DIALOG (dialog->dialog),
_("_Import"), GTK_RESPONSE_OK);
gtk_button_set_image (GTK_BUTTON (button),
gtk_image_new_from_icon_name ("gtk-convert",
GTK_ICON_SIZE_BUTTON));
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_object_set_data_full (G_OBJECT (dialog->dialog), "palette-import-dialog",
dialog, (GDestroyNotify) palette_import_free);
g_signal_connect (dialog->dialog, "response",
G_CALLBACK (palette_import_response),
dialog);
gimp_dnd_viewable_dest_add (dialog->dialog,
GIMP_TYPE_GRADIENT,
import_dialog_drop_callback,
dialog);
gimp_dnd_viewable_dest_add (dialog->dialog,
GIMP_TYPE_IMAGE,
import_dialog_drop_callback,
dialog);
main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog->dialog))),
main_hbox, TRUE, TRUE, 0);
gtk_widget_show (main_hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
/* The "Source" frame */
frame = gimp_frame_new (_("Select Source"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (5, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
dialog->gradient_radio =
gtk_radio_button_new_with_mnemonic (group, _("_Gradient"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->gradient_radio));
gtk_table_attach (GTK_TABLE (table), dialog->gradient_radio,
0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (dialog->gradient_radio);
g_signal_connect (dialog->gradient_radio, "toggled",
G_CALLBACK (palette_import_grad_callback),
dialog);
dialog->image_radio =
gtk_radio_button_new_with_mnemonic (group, _("I_mage"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->image_radio));
gtk_table_attach (GTK_TABLE (table), dialog->image_radio,
0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (dialog->image_radio);
g_signal_connect (dialog->image_radio, "toggled",
G_CALLBACK (palette_import_image_callback),
dialog);
gtk_widget_set_sensitive (dialog->image_radio,
! gimp_container_is_empty (context->gimp->images));
dialog->sample_merged_toggle =
gtk_check_button_new_with_mnemonic (_("Sample _Merged"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->sample_merged_toggle),
TRUE);
gtk_table_attach (GTK_TABLE (table), dialog->sample_merged_toggle,
1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (dialog->sample_merged_toggle);
g_signal_connect_swapped (dialog->sample_merged_toggle, "toggled",
G_CALLBACK (palette_import_make_palette),
dialog);
dialog->selection_only_toggle =
gtk_check_button_new_with_mnemonic (_("_Selected Pixels only"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->selection_only_toggle),
FALSE);
gtk_table_attach (GTK_TABLE (table), dialog->selection_only_toggle,
1, 2, 3, 4, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (dialog->selection_only_toggle);
g_signal_connect_swapped (dialog->selection_only_toggle, "toggled",
G_CALLBACK (palette_import_make_palette),
dialog);
dialog->file_radio =
gtk_radio_button_new_with_mnemonic (group, _("Palette _file"));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->image_radio));
gtk_table_attach (GTK_TABLE (table), dialog->file_radio,
0, 1, 4, 5, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (dialog->file_radio);
g_signal_connect (dialog->file_radio, "toggled",
G_CALLBACK (palette_import_file_callback),
dialog);
size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
/* The gradient menu */
dialog->gradient_combo =
gimp_container_combo_box_new (gimp_data_factory_get_container (context->gimp->gradient_factory),
dialog->context, 24, 1);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
NULL, 0.0, 0.5, dialog->gradient_combo, 1, FALSE);
gtk_size_group_add_widget (size_group, dialog->gradient_combo);
/* The image menu */
dialog->image_combo =
gimp_container_combo_box_new (context->gimp->images, dialog->context,
24, 1);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
NULL, 0.0, 0.5, dialog->image_combo, 1, FALSE);
gtk_size_group_add_widget (size_group, dialog->image_combo);
/* Palette file name entry */
dialog->file_chooser = gtk_file_chooser_button_new (_("Select Palette File"),
GTK_FILE_CHOOSER_ACTION_OPEN);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 4,
NULL, 0.0, 0.5, dialog->file_chooser, 1, FALSE);
gtk_size_group_add_widget (size_group, dialog->file_chooser);
g_object_unref (size_group);
/* The "Import" frame */
frame = gimp_frame_new (_("Import Options"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (4, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
/* The source's name */
dialog->entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (dialog->entry),
gradient ?
gimp_object_get_name (gradient) : _("New import"));
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("Palette _name:"), 0.0, 0.5,
dialog->entry, 2, FALSE);
/* The # of colors */
dialog->num_colors =
GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("N_umber of colors:"), -1, 5,
256, 2, 10000, 1, 10, 0,
TRUE, 0.0, 0.0,
NULL, NULL));
g_signal_connect_swapped (dialog->num_colors,
"value-changed",
G_CALLBACK (palette_import_make_palette),
dialog);
/* The columns */
dialog->columns =
GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 2,
_("C_olumns:"), -1, 5,
16, 0, 64, 1, 8, 0,
TRUE, 0.0, 0.0,
NULL, NULL));
g_signal_connect (dialog->columns, "value-changed",
G_CALLBACK (palette_import_columns_changed),
dialog);
/* The interval */
dialog->threshold =
GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 3,
_("I_nterval:"), -1, 5,
1, 1, 128, 1, 8, 0,
TRUE, 0.0, 0.0,
NULL, NULL));
g_signal_connect_swapped (dialog->threshold, "value-changed",
G_CALLBACK (palette_import_make_palette),
dialog);
/* The "Preview" frame */
frame = gimp_frame_new (_("Preview"));
gtk_box_pack_start (GTK_BOX (main_hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
abox = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0);
gtk_widget_show (abox);
dialog->preview = gimp_view_new_full_by_types (dialog->context,
GIMP_TYPE_VIEW,
GIMP_TYPE_PALETTE,
192, 192, 1,
TRUE, FALSE, FALSE);
gtk_container_add (GTK_CONTAINER (abox), dialog->preview);
gtk_widget_show (dialog->preview);
dialog->no_colors_label =
gtk_label_new (_("The selected source contains no colors."));
gtk_widget_set_size_request (dialog->no_colors_label, 194, -1);
gtk_label_set_line_wrap (GTK_LABEL (dialog->no_colors_label), TRUE);
gimp_label_set_attributes (GTK_LABEL (dialog->no_colors_label),
PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
-1);
gtk_box_pack_start (GTK_BOX (vbox), dialog->no_colors_label, FALSE, FALSE, 0);
gtk_widget_show (dialog->no_colors_label);
/* keep the dialog up-to-date */
g_signal_connect (context->gimp->images, "add",
G_CALLBACK (palette_import_image_add),
dialog);
g_signal_connect (context->gimp->images, "remove",
G_CALLBACK (palette_import_image_remove),
dialog);
g_signal_connect (dialog->context, "gradient-changed",
G_CALLBACK (palette_import_gradient_changed),
dialog);
g_signal_connect (dialog->context, "image-changed",
G_CALLBACK (palette_import_image_changed),
dialog);
g_signal_connect (dialog->file_chooser, "selection-changed",
G_CALLBACK (palette_import_filename_changed),
dialog);
palette_import_grad_callback (dialog->gradient_radio, dialog);
return dialog->dialog;
}
void
greeter_session_init (void)
{
GtkWidget *w = NULL;
GtkWidget *hbox = NULL;
GtkWidget *main_vbox = NULL;
GtkWidget *vbox = NULL;
GtkWidget *cat_vbox = NULL;
GtkWidget *radio;
GtkWidget *dialog;
GtkWidget *button;
GList *tmp;
static GtkTooltips *tooltips = NULL;
GtkRequisition req;
char *s;
int num = 1;
char *label;
greeter_set_session (NULL);
session_dialog = dialog = gtk_dialog_new ();
if (tooltips == NULL)
tooltips = gtk_tooltips_new ();
gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
button = gtk_button_new_with_mnemonic (_("Change _Session"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,
GTK_RESPONSE_OK);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 2);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
main_vbox = gtk_vbox_new (FALSE, 18);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 5);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
main_vbox,
FALSE, FALSE, 0);
cat_vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (main_vbox),
cat_vbox,
FALSE, FALSE, 0);
s = g_strdup_printf ("<b>%s</b>", _("Sessions"));
w = gtk_label_new (s);
gtk_label_set_use_markup (GTK_LABEL (w), TRUE);
g_free (s);
gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (cat_vbox), w, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (cat_vbox),
hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox),
gtk_label_new (" "),
FALSE, FALSE, 0);
vbox = gtk_vbox_new (FALSE, 6);
/* we will pack this later depending on size */
if (mdm_config_get_bool (MDM_KEY_SHOW_LAST_SESSION))
{
greeter_set_session (LAST_SESSION);
radio = gtk_radio_button_new_with_mnemonic (session_group, _("_Last session"));
g_object_set_data (G_OBJECT (radio),
SESSION_NAME,
LAST_SESSION);
session_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio));
gtk_tooltips_set_tip (tooltips, radio,
_("Log in using the session that you have used "
"last time you logged in"),
NULL);
gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0);
gtk_widget_show (radio);
}
mdm_session_list_init ();
for (tmp = sessions; tmp != NULL; tmp = tmp->next)
{
MdmSession *session;
char *file;
file = (char *) tmp->data;
session = g_hash_table_lookup (sessnames, file);
if (num < 10 &&
(strcmp (file, MDM_SESSION_FAILSAFE_GNOME) != 0) &&
(strcmp (file, MDM_SESSION_FAILSAFE_XTERM) != 0))
label = g_strdup_printf ("_%d. %s", num, session->name);
else
label = g_strdup (session->name);
num++;
radio = gtk_radio_button_new_with_mnemonic (session_group, label);
g_free (label);
g_object_set_data_full (G_OBJECT (radio), SESSION_NAME,
file, (GDestroyNotify) g_free);
session_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio));
gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0);
gtk_widget_show (radio);
if (! ve_string_empty (session->comment))
gtk_tooltips_set_tip
(tooltips, GTK_WIDGET (radio), session->comment, NULL);
}
gtk_widget_show_all (vbox);
gtk_widget_size_request (vbox, &req);
/* if too large */
if (req.height > 0.7 * mdm_wm_screen.height) {
GtkWidget *sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (sw,
req.width,
0.7 * mdm_wm_screen.height);
gtk_scrolled_window_set_shadow_type
(GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy
(GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport
(GTK_SCROLLED_WINDOW (sw), vbox);
gtk_widget_show (sw);
gtk_box_pack_start (GTK_BOX (hbox),
sw,
TRUE, TRUE, 0);
} else {
gtk_box_pack_start (GTK_BOX (hbox),
vbox,
TRUE, TRUE, 0);
}
}
RevertDialog::RevertDialog(Reference * reference)
{
// Save variables.
extern Settings *settings;
project = settings->genconfig.project_get();
ProjectConfiguration *projectconfig = settings->projectconfig(project);
language = projectconfig->language_get();
reference_chapter = reference->chapter_get();
revisionloaded = false;
branch = 0;
// Build dialog.
Shortcuts shortcuts(0);
revertdialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(revertdialog), _("Revert"));
gtk_window_set_position(GTK_WINDOW(revertdialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_type_hint(GTK_WINDOW(revertdialog), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (revertdialog));
gtk_widget_show(dialog_vbox1);
hbox1 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox1);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), hbox1, TRUE, TRUE, 0);
vbox1 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox1);
gtk_box_pack_start(GTK_BOX(hbox1), vbox1, TRUE, TRUE, 0);
table1 = gtk_table_new(2, 2, FALSE);
gtk_widget_show(table1);
gtk_box_pack_start(GTK_BOX(vbox1), table1, FALSE, TRUE, 0);
comboboxbook = gtk_combo_box_new_text();
gtk_widget_show(comboboxbook);
gtk_table_attach(GTK_TABLE(table1), comboboxbook, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
comboboxchapter = gtk_combo_box_new_text();
gtk_widget_show(comboboxchapter);
gtk_table_attach(GTK_TABLE(table1), comboboxchapter, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0);
labelbook = gtk_label_new(_("Book"));
gtk_widget_show(labelbook);
gtk_table_attach(GTK_TABLE(table1), labelbook, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(labelbook), 0, 0.5);
shortcuts.label(labelbook);
gtk_label_set_mnemonic_widget(GTK_LABEL(labelbook), comboboxbook);
labelchapter = gtk_label_new(_("Chapter"));
gtk_widget_show(labelchapter);
gtk_table_attach(GTK_TABLE(table1), labelchapter, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(labelchapter), 0, 0.5);
shortcuts.label(labelchapter);
gtk_label_set_mnemonic_widget(GTK_LABEL(labelchapter), comboboxchapter);
hseparator1 = gtk_hseparator_new();
gtk_widget_show(hseparator1);
gtk_box_pack_start(GTK_BOX(vbox1), hseparator1, FALSE, TRUE, 0);
labelrevisions = gtk_label_new(_("Revisions"));
gtk_widget_show(labelrevisions);
gtk_box_pack_start(GTK_BOX(vbox1), labelrevisions, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(labelrevisions), 0, 0.5);
shortcuts.label(labelrevisions);
scrolledwindowrevisions = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindowrevisions);
gtk_box_pack_start(GTK_BOX(vbox1), scrolledwindowrevisions, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindowrevisions), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindowrevisions), GTK_SHADOW_IN);
treeviewrevisions = gtk_tree_view_new();
gtk_widget_show(treeviewrevisions);
gtk_container_add(GTK_CONTAINER(scrolledwindowrevisions), treeviewrevisions);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeviewrevisions), FALSE);
gtk_label_set_mnemonic_widget(GTK_LABEL(labelrevisions), treeviewrevisions);
// Create treeview related stuff.
store = gtk_list_store_new(1, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeviewrevisions), GTK_TREE_MODEL(store));
g_object_unref(store);
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeviewrevisions), column);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviewrevisions));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
vseparator1 = gtk_vseparator_new();
gtk_widget_show(vseparator1);
gtk_box_pack_start(GTK_BOX(hbox1), vseparator1, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox2);
gtk_box_pack_start(GTK_BOX(hbox1), vbox2, TRUE, TRUE, 0);
GSList *radiobutton_current_group = NULL;
radiobutton_current = gtk_radio_button_new_with_mnemonic (NULL, _("View current version"));
gtk_widget_show (radiobutton_current);
gtk_box_pack_start (GTK_BOX (vbox2), radiobutton_current, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_current), radiobutton_current_group);
radiobutton_current_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_current));
shortcuts.button(radiobutton_current);
radiobutton_previous = gtk_radio_button_new_with_mnemonic (NULL, _("View previous revision"));
gtk_widget_show (radiobutton_previous);
gtk_box_pack_start (GTK_BOX (vbox2), radiobutton_previous, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_previous), radiobutton_current_group);
radiobutton_current_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_previous));
shortcuts.button(radiobutton_previous);
radiobutton_changes = gtk_radio_button_new_with_mnemonic (NULL, _("View changes if reverting to previous revision"));
gtk_widget_show (radiobutton_changes);
gtk_box_pack_start (GTK_BOX (vbox2), radiobutton_changes, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_changes), radiobutton_current_group);
radiobutton_current_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_changes));
shortcuts.button(radiobutton_changes);
changes_gui = new DisplayChangesGui (vbox2);
gtk_widget_set_size_request(changes_gui->textview, 450, 500);
dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(revertdialog));
gtk_widget_show(dialog_action_area1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
new InDialogHelp(revertdialog, NULL, &shortcuts, "edit/revert");
cancelbutton1 = gtk_button_new_from_stock("gtk-cancel");
gtk_widget_show(cancelbutton1);
gtk_dialog_add_action_widget(GTK_DIALOG(revertdialog), cancelbutton1, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true);
okbutton1 = gtk_button_new_from_stock("gtk-ok");
gtk_widget_show(okbutton1);
gtk_dialog_add_action_widget(GTK_DIALOG(revertdialog), okbutton1, GTK_RESPONSE_OK);
gtk_widget_set_can_default (GTK_WIDGET (okbutton1), true);
shortcuts.stockbutton(cancelbutton1);
shortcuts.stockbutton(okbutton1);
shortcuts.process();
g_signal_connect((gpointer) comboboxbook, "changed", G_CALLBACK(on_comboboxbook_changed), gpointer(this));
g_signal_connect((gpointer) comboboxchapter, "changed", G_CALLBACK(on_comboboxchapter_changed), gpointer(this));
g_signal_connect((gpointer) treeviewrevisions, "row_activated", G_CALLBACK(on_treeviewrevisions_row_activated), gpointer(this));
g_signal_connect((gpointer) okbutton1, "clicked", G_CALLBACK(on_okbutton1_clicked), gpointer(this));
g_signal_connect ((gpointer) radiobutton_current, "toggled", G_CALLBACK (on_radiobutton_toggled), gpointer(this));
g_signal_connect ((gpointer) radiobutton_previous, "toggled", G_CALLBACK (on_radiobutton_toggled), gpointer(this));
g_signal_connect ((gpointer) radiobutton_changes, "toggled", G_CALLBACK (on_radiobutton_toggled), gpointer(this));
gtk_widget_grab_focus(okbutton1);
gtk_widget_grab_default(okbutton1);
// Load books. This also loads the chapters through the callback.
vector < unsigned int >books = project_get_books(project);
vector < ustring > localbooks;
for (unsigned int i = 0; i < books.size(); i++) {
localbooks.push_back(books_id_to_name(language, books[i]));
}
combobox_set_strings(comboboxbook, localbooks);
combobox_set_string(comboboxbook, books_id_to_name(language, reference->book_get()));
// By default view changes.
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radiobutton_changes), true);
}
static void
target_version_box_fill (GladeProjectProperties *properties)
{
GladeProjectPropertiesPrivate *priv = properties->priv;
GladeProject *project = priv->project;
GtkWidget *vbox = priv->toolkit_box;
GtkWidget *label, *active_radio, *target_radio, *hbox;
GList *list, *targets;
/* Add stuff to vbox */
for (list = glade_app_get_catalogs (); list; list = g_list_next (list))
{
GladeCatalog *catalog = list->data;
gint minor, major;
/* Skip if theres only one option */
if (g_list_length (glade_catalog_get_targets (catalog)) <= 1)
continue;
glade_project_get_target_version (project,
glade_catalog_get_name (catalog),
&major, &minor);
/* Special case to mark GTK+ in upper case */
if (strcmp (glade_catalog_get_name (catalog), "gtk+") == 0)
label = gtk_label_new ("GTK+");
else
label = gtk_label_new (glade_catalog_get_name (catalog));
gtk_misc_set_alignment (GTK_MISC (label), 0.0F, 0.5F);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 2);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
active_radio = target_radio = NULL;
for (targets = glade_catalog_get_targets (catalog);
targets; targets = targets->next)
{
GladeTargetableVersion *version = targets->data;
gchar *name = g_strdup_printf ("%d.%d",
version->major,
version->minor);
if (!target_radio)
target_radio = gtk_radio_button_new_with_label (NULL, name);
else
target_radio =
gtk_radio_button_new_with_label_from_widget
(GTK_RADIO_BUTTON (target_radio), name);
g_free (name);
g_signal_connect (G_OBJECT (target_radio), "clicked",
G_CALLBACK (target_button_clicked), properties);
g_object_set_data (G_OBJECT (target_radio), "version", version);
g_object_set_data (G_OBJECT (target_radio), "catalog",
(gchar *) glade_catalog_get_name (catalog));
gtk_widget_show (target_radio);
gtk_box_pack_end (GTK_BOX (hbox), target_radio, TRUE, TRUE, 2);
if (major == version->major && minor == version->minor)
active_radio = target_radio;
}
if (active_radio)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (active_radio), TRUE);
g_hash_table_insert (priv->target_radios,
g_strdup (glade_catalog_get_name (catalog)),
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(active_radio)));
}
else
g_warning ("Corrupt catalog versions");
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 2);
}
}
static GtkWidget *build_empty_disk_dialog(void)
{
GtkWidget *d, *box, *hbox, *tmp, *frame;
int i;
d = gtk_dialog_new_with_buttons(_("Create empty disk"),
NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
box = gtk_hbox_new(0, FALSE);
fileentry = vice_file_entry(_("Create disk"), NULL, "*.[gdxGDX]*",
GTK_FILE_CHOOSER_ACTION_SAVE);
gtk_dialog_set_default_response(GTK_DIALOG(d), GTK_RESPONSE_ACCEPT);
gtk_box_pack_start(GTK_BOX(box), fileentry,
TRUE, TRUE, 0);
gtk_widget_show(fileentry);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(d)->vbox), box, TRUE, TRUE, 0);
gtk_widget_show(box);
frame = gtk_frame_new(_("Disk options"));
box = gtk_vbox_new(0, FALSE);
/* Diskname */
hbox = gtk_hbox_new(0, FALSE);
tmp = gtk_label_new(_("Diskname: "));
gtk_box_pack_start(GTK_BOX(hbox), tmp, FALSE, FALSE, 0);
gtk_widget_show(tmp);
diskname = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(diskname), 16);
gtk_editable_set_editable(GTK_EDITABLE(diskname), TRUE);
gtk_box_pack_start(GTK_BOX(hbox), diskname, FALSE, FALSE, 0);
gtk_widget_show(diskname);
tmp = gtk_label_new("ID: ");
gtk_box_pack_start(GTK_BOX(hbox), tmp, FALSE, FALSE, 0);
gtk_widget_show(tmp);
diskid = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(diskid), 2);
gtk_editable_set_editable(GTK_EDITABLE(diskid), TRUE);
gtk_box_pack_start(GTK_BOX(hbox), diskid, FALSE, FALSE, 0);
gtk_widget_set_size_request(diskid, 25, 22);
gtk_widget_show(diskid);
gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
hbox = gtk_hbox_new(0, FALSE);
for (i = 0; type_radio[i].label; i++)
{
if (i == 0)
{
type_radio[i].w =
gtk_radio_button_new_with_label(NULL, type_radio[i].label);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(type_radio[i].w ), TRUE);
}
else
type_radio[i].w = gtk_radio_button_new_with_label(
gtk_radio_button_get_group(
GTK_RADIO_BUTTON(type_radio[i - 1].w)),
type_radio[i].label);
gtk_box_pack_start(GTK_BOX(hbox), type_radio[i].w, FALSE, FALSE, 0);
gtk_widget_show(type_radio[i].w);
}
gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
gtk_container_add(GTK_CONTAINER(frame), box);
gtk_widget_show(box);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(d)->vbox), frame,
FALSE, FALSE, 0);
gtk_widget_show(frame);
gtk_widget_show(d);
return d;
}
int
gnc_choose_radio_option_dialog(GtkWidget *parent,
const char *title,
const char *msg,
const char *button_name,
int default_value,
GList *radio_list)
{
int radio_result = 0; /* initial selected value is first one */
GtkWidget *vbox;
GtkWidget *main_vbox;
GtkWidget *label;
GtkWidget *radio_button;
GtkWidget *dialog;
GtkWidget *dvbox;
GSList *group = NULL;
GList *node;
int i;
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
gtk_box_set_homogeneous (GTK_BOX (main_vbox), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 6);
gtk_widget_show(main_vbox);
label = gtk_label_new(msg);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(main_vbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);
gtk_container_add(GTK_CONTAINER(main_vbox), vbox);
gtk_widget_show(vbox);
for (node = radio_list, i = 0; node; node = node->next, i++)
{
radio_button = gtk_radio_button_new_with_mnemonic(group, node->data);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio_button));
gtk_widget_set_halign (GTK_WIDGET(radio_button), GTK_ALIGN_START);
if (i == default_value) /* default is first radio button */
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_button), TRUE);
radio_result = default_value;
}
gtk_widget_show(radio_button);
gtk_box_pack_start(GTK_BOX(vbox), radio_button, FALSE, FALSE, 0);
g_object_set_data(G_OBJECT(radio_button), INDEX_LABEL, GINT_TO_POINTER(i));
g_signal_connect(radio_button, "clicked",
G_CALLBACK(gnc_choose_radio_button_cb),
&radio_result);
}
if (!button_name)
button_name = _("_OK");
dialog = gtk_dialog_new_with_buttons (title, GTK_WINDOW(parent),
GTK_DIALOG_DESTROY_WITH_PARENT,
_("_Cancel"), GTK_RESPONSE_CANCEL,
button_name, GTK_RESPONSE_OK,
NULL);
/* default to ok */
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
dvbox = gtk_dialog_get_content_area (GTK_DIALOG(dialog));
gtk_box_pack_start(GTK_BOX(dvbox), main_vbox, TRUE, TRUE, 0);
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK)
radio_result = -1;
gtk_widget_destroy (dialog);
return radio_result;
}
void create_kbm_window()
{
if (hime_kbm_window) {
gtk_window_present(GTK_WINDOW(hime_kbm_window));
return;
}
load_setttings();
hime_kbm_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(hime_kbm_window), GTK_WIN_POS_MOUSE);
gtk_window_set_has_resize_grip(GTK_WINDOW(hime_kbm_window), FALSE);
g_signal_connect (G_OBJECT (hime_kbm_window), "delete_event",
G_CALLBACK (close_kbm_window),
NULL);
gtk_window_set_title (GTK_WINDOW (hime_kbm_window), _("HIME 注音/詞音設定"));
gtk_container_set_border_width (GTK_CONTAINER (hime_kbm_window), 1);
GtkWidget *vbox_top = gtk_vbox_new (FALSE, 3);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (hime_kbm_window), vbox_top);
GtkWidget *hbox_lr = gtk_hbox_new (FALSE, 3);
gtk_box_pack_start (GTK_BOX (vbox_top), hbox_lr, TRUE, TRUE, 0);
GtkWidget *vbox_l = gtk_vbox_new (FALSE, 3);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_l), GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (hbox_lr), vbox_l, TRUE, TRUE, 10);
GtkWidget *vbox_r = gtk_vbox_new (FALSE, 3);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_r), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_homogeneous(GTK_GRID(vbox_r), TRUE);
gtk_box_pack_start (GTK_BOX (hbox_lr), vbox_r, TRUE, TRUE, 10);
GtkWidget *frame_kbm = gtk_frame_new(_("鍵盤排列方式/選擇鍵/選單每列字數"));
gtk_box_pack_start (GTK_BOX (vbox_l), frame_kbm, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_kbm), 1);
gtk_container_add (GTK_CONTAINER (frame_kbm), create_kbm_opts());
gtk_box_pack_start (GTK_BOX (vbox_l), create_en_pho_key_sel(_("(詞音) 切換[中/英]輸入")), TRUE, TRUE, 0);
GtkWidget *frame_tsin_space_opt = gtk_frame_new(_("(詞音) 鍵入空白鍵"));
gtk_box_pack_start (GTK_BOX (vbox_l), frame_tsin_space_opt, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_space_opt), 1);
GtkWidget *box_tsin_space_opt = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(box_tsin_space_opt), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (frame_tsin_space_opt), box_tsin_space_opt);
gtk_container_set_border_width (GTK_CONTAINER (box_tsin_space_opt), 1);
GSList *group_tsin_space_opt = NULL;
int current_idx = get_currnet_tsin_space_option_idx();
new_select_idx_tsin_space_opt = current_idx;
gsize i;
for(i=0; i< tsin_space_optionsN; i++) {
GtkWidget *button = gtk_radio_button_new_with_label (group_tsin_space_opt, _(tsin_space_options[i].name));
gtk_box_pack_start (GTK_BOX (box_tsin_space_opt), button, TRUE, TRUE, 0);
group_tsin_space_opt = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (callback_button_clicked_tsin_space_opt), (gpointer) i);
if (i==current_idx)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
}
GtkWidget *hbox_tsin_phrase_pre_select = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_l), hbox_tsin_phrase_pre_select , TRUE, TRUE, 1);
check_button_tsin_phrase_pre_select = gtk_check_button_new_with_label(_("詞音輸入預選詞視窗"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_phrase_pre_select), check_button_tsin_phrase_pre_select, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_phrase_pre_select), tsin_phrase_pre_select);
GtkWidget *hbox_phonetic_char_dynamic_sequence = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_l), hbox_phonetic_char_dynamic_sequence , TRUE, TRUE, 1);
check_button_phonetic_char_dynamic_sequence = gtk_check_button_new_with_label(_("依使用頻率調整字的順序"));
gtk_box_pack_start (GTK_BOX (hbox_phonetic_char_dynamic_sequence), check_button_phonetic_char_dynamic_sequence, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_phonetic_char_dynamic_sequence), phonetic_char_dynamic_sequence);
GtkWidget *hbox_pho_hide_row2 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_l), hbox_pho_hide_row2 , TRUE, TRUE, 1);
check_button_pho_hide_row2 = gtk_check_button_new_with_label(_("注音隱藏第二列 (注音符號)"));
gtk_box_pack_start (GTK_BOX (hbox_pho_hide_row2), check_button_pho_hide_row2, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_pho_hide_row2), pho_hide_row2);
GtkWidget *hbox_pho_in_row1 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_l), hbox_pho_in_row1 , TRUE, TRUE, 1);
check_button_pho_in_row1 = gtk_check_button_new_with_label(_("注音符號移至第一列"));
gtk_box_pack_start (GTK_BOX (hbox_pho_in_row1), check_button_pho_in_row1, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_pho_in_row1), pho_in_row1);
GtkWidget *hbox_phonetic_huge_tab = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_phonetic_huge_tab , TRUE, TRUE, 1);
check_button_phonetic_huge_tab = gtk_check_button_new_with_label(_("使用巨大 UTF-8 字集"));
gtk_box_pack_start (GTK_BOX (hbox_phonetic_huge_tab), check_button_phonetic_huge_tab, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_phonetic_huge_tab), phonetic_huge_tab);
GtkWidget *hbox_tsin_tone_char_input = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tone_char_input , TRUE, TRUE, 1);
check_button_tsin_tone_char_input = gtk_check_button_new_with_label(_("(詞音) 輸入注音聲調符號"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_tone_char_input), check_button_tsin_tone_char_input, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_tone_char_input), tsin_tone_char_input);
GtkWidget *hbox_tsin_tab_phrase_end = gtk_hbox_new(FALSE, 1);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tab_phrase_end , TRUE, TRUE, 1);
check_button_tsin_tab_phrase_end = gtk_check_button_new_with_label(_("(詞音) 使用 Escape/Tab 斷詞"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_tab_phrase_end), check_button_tsin_tab_phrase_end, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_tab_phrase_end), tsin_tab_phrase_end);
GtkWidget *hbox_tsin_tail_select_key = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tail_select_key , TRUE, TRUE, 1);
check_button_tsin_tail_select_key = gtk_check_button_new_with_label(_("選擇鍵顯示於候選字(詞)後方"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_tail_select_key), check_button_tsin_tail_select_key, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_tail_select_key), tsin_tail_select_key);
GtkWidget *hbox_tsin_buffer_editing_mode = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_buffer_editing_mode , TRUE, TRUE, 1);
check_button_tsin_buffer_editing_mode = gtk_check_button_new_with_label(_("\\ 鍵可切換 jkx 鍵編輯模式"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_buffer_editing_mode), check_button_tsin_buffer_editing_mode, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_buffer_editing_mode), tsin_buffer_editing_mode);
GtkWidget *hbox_tsin_use_pho_near = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_use_pho_near , TRUE, TRUE, 1);
check_button_tsin_use_pho_near = gtk_check_button_new_with_label(_("按下 ↑ 鍵查詢近似音"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_use_pho_near), check_button_tsin_use_pho_near, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_use_pho_near), tsin_use_pho_near);
GtkWidget *frame_tsin_buffer_size = gtk_frame_new(_("(詞音) 的編輯緩衝區大小"));
gtk_box_pack_start (GTK_BOX (vbox_r), frame_tsin_buffer_size, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_buffer_size), 1);
GtkAdjustment *adj_gtab_in =
(GtkAdjustment *) gtk_adjustment_new (tsin_buffer_size, 10.0, MAX_PH_BF, 1.0, 1.0, 0.0);
spinner_tsin_buffer_size = gtk_spin_button_new (adj_gtab_in, 0, 0);
gtk_container_add (GTK_CONTAINER (frame_tsin_buffer_size), spinner_tsin_buffer_size);
GtkWidget *frame_tsin_cursor_color = gtk_frame_new(_("詞音游標的顏色"));
gtk_box_pack_start (GTK_BOX (vbox_r), frame_tsin_cursor_color, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_cursor_color), 1);
GtkWidget *button_tsin_cursor_color = gtk_button_new();
g_signal_connect (G_OBJECT (button_tsin_cursor_color), "clicked",
G_CALLBACK (cb_tsin_cursor_color), G_OBJECT (hime_kbm_window));
da_cursor = gtk_drawing_area_new();
gtk_container_add (GTK_CONTAINER (button_tsin_cursor_color), da_cursor);
gdk_color_parse(tsin_cursor_color, &tsin_cursor_gcolor);
#if !GTK_CHECK_VERSION(2,91,6)
gtk_widget_modify_bg(da_cursor, GTK_STATE_NORMAL, &tsin_cursor_gcolor);
#else
GdkRGBA rgbbg;
gdk_rgba_parse(&rgbbg, gdk_color_to_string(&tsin_cursor_gcolor));
gtk_widget_override_background_color(da_cursor, GTK_STATE_FLAG_NORMAL, &rgbbg);
#endif
gtk_widget_set_size_request(da_cursor, 16, 2);
gtk_container_add (GTK_CONTAINER (frame_tsin_cursor_color), button_tsin_cursor_color);
GtkWidget *hbox_cancel_ok = gtk_hbox_new (FALSE, 10);
gtk_grid_set_column_homogeneous(GTK_GRID(hbox_cancel_ok), TRUE);
gtk_box_pack_start (GTK_BOX (vbox_top), hbox_cancel_ok , FALSE, FALSE, 5);
GtkWidget *button_cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
if (button_order)
gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0);
else
gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0);
GtkWidget *button_ok = gtk_button_new_from_stock (GTK_STOCK_OK);
#if !GTK_CHECK_VERSION(2,91,2)
if (button_order)
gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 5);
else
gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 5);
#else
if (button_order)
gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_LEFT, 1, 1);
else
gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_RIGHT, 1, 1);
#endif
g_signal_connect (G_OBJECT (button_cancel), "clicked",
G_CALLBACK (close_kbm_window),
G_OBJECT (hime_kbm_window));
g_signal_connect_swapped (G_OBJECT (button_ok), "clicked",
G_CALLBACK (cb_ok),
G_OBJECT (hime_kbm_window));
GTK_WIDGET_SET_FLAGS (button_cancel, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button_cancel);
gtk_widget_show_all (hime_kbm_window);
return;
}
GtkWidget *create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *notebook1;
GtkWidget *table1;
GtkWidget *radioCQ;
GSList *radioCQ_group = NULL;
GtkWidget *radioCBR;
GtkWidget *radio2Pass;
GtkWidget *entryCQ;
GtkWidget *entryCBR;
GtkWidget *entry2Pass;
GtkWidget *label1;
GtkWidget *table2;
GtkWidget *label5;
GtkWidget *label6;
GtkWidget *label7;
GtkObject *spinbuttonMaxIFrame_adj;
GtkWidget *spinbuttonMaxIFrame;
GtkWidget *label8;
GtkObject *spinbuttonMinIFrame_adj;
GtkWidget *spinbuttonMinIFrame;
GtkWidget *optionME;
GtkWidget *menu4;
GtkWidget *_0___none1;
GtkWidget *_1__very_low1;
GtkWidget *_2__low1;
GtkWidget *_3__medium1;
GtkWidget *_4__high1;
GtkWidget *_5__very_high1;
GtkWidget *_6__ultra_high1;
GtkWidget *optionQzer;
GtkWidget *menu5;
GtkWidget *h263_quantizer1;
GtkWidget *mpeg_quantizer1;
GtkWidget *label2;
GtkWidget *table3;
GtkWidget *label9;
GtkWidget *label10;
GtkWidget *label11;
GtkWidget *label12;
GtkObject *spinImin_adj;
GtkWidget *spinImin;
GtkObject *spinImax_adj;
GtkWidget *spinImax;
GtkObject *spinPmin_adj;
GtkWidget *spinPmin;
GtkObject *spinPmax_adj;
GtkWidget *spinPmax;
GtkWidget *label3;
GtkWidget *label13;
GtkWidget *label4;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), _("Xvid Encoder"));
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
notebook1 = gtk_notebook_new ();
gtk_widget_show (notebook1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), notebook1, TRUE, TRUE, 0);
table1 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table1);
gtk_container_add (GTK_CONTAINER (notebook1), table1);
radioCQ = gtk_radio_button_new_with_mnemonic (NULL, _("Constant Quantizer"));
gtk_widget_show (radioCQ);
gtk_table_attach (GTK_TABLE (table1), radioCQ, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioCQ), radioCQ_group);
radioCQ_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioCQ));
radioCBR = gtk_radio_button_new_with_mnemonic (NULL, _("Constant Bitrate (kbps)"));
gtk_widget_show (radioCBR);
gtk_table_attach (GTK_TABLE (table1), radioCBR, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioCBR), radioCQ_group);
radioCQ_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioCBR));
radio2Pass = gtk_radio_button_new_with_mnemonic (NULL, _("Dual pass (MBytes)"));
gtk_widget_show (radio2Pass);
gtk_table_attach (GTK_TABLE (table1), radio2Pass, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radio2Pass), radioCQ_group);
radioCQ_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio2Pass));
entryCQ = gtk_entry_new ();
gtk_widget_show (entryCQ);
gtk_table_attach (GTK_TABLE (table1), entryCQ, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
entryCBR = gtk_entry_new ();
gtk_widget_show (entryCBR);
gtk_table_attach (GTK_TABLE (table1), entryCBR, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
entry2Pass = gtk_entry_new ();
gtk_widget_show (entry2Pass);
gtk_table_attach (GTK_TABLE (table1), entry2Pass, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label1 = gtk_label_new (_("Basic"));
gtk_widget_show (label1);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 0), label1);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
table2 = gtk_table_new (4, 2, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (notebook1), table2);
label5 = gtk_label_new (_("Motion Search"));
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table2), label5, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
label6 = gtk_label_new (_("Quantization"));
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table2), label6, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);
label7 = gtk_label_new (_("Max I frame interval "));
gtk_widget_show (label7);
gtk_table_attach (GTK_TABLE (table2), label7, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5);
spinbuttonMaxIFrame_adj = gtk_adjustment_new (300, 0, 600, 1, 10, 10);
spinbuttonMaxIFrame = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonMaxIFrame_adj), 1, 0);
gtk_widget_show (spinbuttonMaxIFrame);
gtk_table_attach (GTK_TABLE (table2), spinbuttonMaxIFrame, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonMaxIFrame), TRUE);
label8 = gtk_label_new (_("Min I frame interval"));
gtk_widget_show (label8);
gtk_table_attach (GTK_TABLE (table2), label8, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5);
spinbuttonMinIFrame_adj = gtk_adjustment_new (1, 0, 600, 1, 10, 10);
spinbuttonMinIFrame = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonMinIFrame_adj), 1, 0);
gtk_widget_show (spinbuttonMinIFrame);
gtk_table_attach (GTK_TABLE (table2), spinbuttonMinIFrame, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonMinIFrame), TRUE);
optionME = gtk_option_menu_new ();
gtk_widget_show (optionME);
gtk_table_attach (GTK_TABLE (table2), optionME, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
menu4 = gtk_menu_new ();
_0___none1 = gtk_menu_item_new_with_mnemonic (_("0 - None"));
gtk_widget_show (_0___none1);
gtk_container_add (GTK_CONTAINER (menu4), _0___none1);
_1__very_low1 = gtk_menu_item_new_with_mnemonic (_("1- Very low"));
gtk_widget_show (_1__very_low1);
gtk_container_add (GTK_CONTAINER (menu4), _1__very_low1);
_2__low1 = gtk_menu_item_new_with_mnemonic (_("2- Low"));
gtk_widget_show (_2__low1);
gtk_container_add (GTK_CONTAINER (menu4), _2__low1);
_3__medium1 = gtk_menu_item_new_with_mnemonic (_("3- Medium"));
gtk_widget_show (_3__medium1);
gtk_container_add (GTK_CONTAINER (menu4), _3__medium1);
_4__high1 = gtk_menu_item_new_with_mnemonic (_("4- High"));
gtk_widget_show (_4__high1);
gtk_container_add (GTK_CONTAINER (menu4), _4__high1);
_5__very_high1 = gtk_menu_item_new_with_mnemonic (_("5- Very High"));
gtk_widget_show (_5__very_high1);
gtk_container_add (GTK_CONTAINER (menu4), _5__very_high1);
_6__ultra_high1 = gtk_menu_item_new_with_mnemonic (_("6- Ultra High"));
gtk_widget_show (_6__ultra_high1);
gtk_container_add (GTK_CONTAINER (menu4), _6__ultra_high1);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionME), menu4);
optionQzer = gtk_option_menu_new ();
gtk_widget_show (optionQzer);
gtk_table_attach (GTK_TABLE (table2), optionQzer, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
menu5 = gtk_menu_new ();
h263_quantizer1 = gtk_menu_item_new_with_mnemonic (_("H263 Quantizer"));
gtk_widget_show (h263_quantizer1);
gtk_container_add (GTK_CONTAINER (menu5), h263_quantizer1);
mpeg_quantizer1 = gtk_menu_item_new_with_mnemonic (_("MPEG Quantizer"));
gtk_widget_show (mpeg_quantizer1);
gtk_container_add (GTK_CONTAINER (menu5), mpeg_quantizer1);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionQzer), menu5);
label2 = gtk_label_new (_("Advanced"));
gtk_widget_show (label2);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 1), label2);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
table3 = gtk_table_new (4, 2, FALSE);
gtk_widget_show (table3);
gtk_container_add (GTK_CONTAINER (notebook1), table3);
label9 = gtk_label_new (_("Min I Frame Qzer"));
gtk_widget_show (label9);
gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5);
label10 = gtk_label_new (_("Max I Frame Qzer"));
gtk_widget_show (label10);
gtk_table_attach (GTK_TABLE (table3), label10, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5);
label11 = gtk_label_new (_("Min P Frame Qzer"));
gtk_widget_show (label11);
gtk_table_attach (GTK_TABLE (table3), label11, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label11), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label11), 0, 0.5);
label12 = gtk_label_new (_("Max P Frame Qzer"));
gtk_widget_show (label12);
gtk_table_attach (GTK_TABLE (table3), label12, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label12), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5);
spinImin_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10);
spinImin = gtk_spin_button_new (GTK_ADJUSTMENT (spinImin_adj), 1, 0);
gtk_widget_show (spinImin);
gtk_table_attach (GTK_TABLE (table3), spinImin, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinImin), TRUE);
spinImax_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10);
spinImax = gtk_spin_button_new (GTK_ADJUSTMENT (spinImax_adj), 1, 0);
gtk_widget_show (spinImax);
gtk_table_attach (GTK_TABLE (table3), spinImax, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinImax), TRUE);
spinPmin_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10);
spinPmin = gtk_spin_button_new (GTK_ADJUSTMENT (spinPmin_adj), 1, 0);
gtk_widget_show (spinPmin);
gtk_table_attach (GTK_TABLE (table3), spinPmin, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinPmin), TRUE);
spinPmax_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10);
spinPmax = gtk_spin_button_new (GTK_ADJUSTMENT (spinPmax_adj), 1, 0);
gtk_widget_show (spinPmax);
gtk_table_attach (GTK_TABLE (table3), spinPmax, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinPmax), TRUE);
label3 = gtk_label_new (_("Quantizer"));
gtk_widget_show (label3);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 2), label3);
gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT);
label13 = gtk_label_new (_("Not Yet!"));
gtk_widget_show (label13);
gtk_container_add (GTK_CONTAINER (notebook1), label13);
gtk_label_set_justify (GTK_LABEL (label13), GTK_JUSTIFY_LEFT);
label4 = gtk_label_new (_("B Frames"));
gtk_widget_show (label4);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 3), label4);
gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, notebook1, "notebook1");
GLADE_HOOKUP_OBJECT (dialog1, table1, "table1");
GLADE_HOOKUP_OBJECT (dialog1, radioCQ, "radioCQ");
GLADE_HOOKUP_OBJECT (dialog1, radioCBR, "radioCBR");
GLADE_HOOKUP_OBJECT (dialog1, radio2Pass, "radio2Pass");
GLADE_HOOKUP_OBJECT (dialog1, entryCQ, "entryCQ");
GLADE_HOOKUP_OBJECT (dialog1, entryCBR, "entryCBR");
GLADE_HOOKUP_OBJECT (dialog1, entry2Pass, "entry2Pass");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, table2, "table2");
GLADE_HOOKUP_OBJECT (dialog1, label5, "label5");
GLADE_HOOKUP_OBJECT (dialog1, label6, "label6");
GLADE_HOOKUP_OBJECT (dialog1, label7, "label7");
GLADE_HOOKUP_OBJECT (dialog1, spinbuttonMaxIFrame, "spinbuttonMaxIFrame");
GLADE_HOOKUP_OBJECT (dialog1, label8, "label8");
GLADE_HOOKUP_OBJECT (dialog1, spinbuttonMinIFrame, "spinbuttonMinIFrame");
GLADE_HOOKUP_OBJECT (dialog1, optionME, "optionME");
GLADE_HOOKUP_OBJECT (dialog1, menu4, "menu4");
GLADE_HOOKUP_OBJECT (dialog1, _0___none1, "_0___none1");
GLADE_HOOKUP_OBJECT (dialog1, _1__very_low1, "_1__very_low1");
GLADE_HOOKUP_OBJECT (dialog1, _2__low1, "_2__low1");
GLADE_HOOKUP_OBJECT (dialog1, _3__medium1, "_3__medium1");
GLADE_HOOKUP_OBJECT (dialog1, _4__high1, "_4__high1");
GLADE_HOOKUP_OBJECT (dialog1, _5__very_high1, "_5__very_high1");
GLADE_HOOKUP_OBJECT (dialog1, _6__ultra_high1, "_6__ultra_high1");
GLADE_HOOKUP_OBJECT (dialog1, optionQzer, "optionQzer");
GLADE_HOOKUP_OBJECT (dialog1, menu5, "menu5");
GLADE_HOOKUP_OBJECT (dialog1, h263_quantizer1, "h263_quantizer1");
GLADE_HOOKUP_OBJECT (dialog1, mpeg_quantizer1, "mpeg_quantizer1");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, table3, "table3");
GLADE_HOOKUP_OBJECT (dialog1, label9, "label9");
GLADE_HOOKUP_OBJECT (dialog1, label10, "label10");
GLADE_HOOKUP_OBJECT (dialog1, label11, "label11");
GLADE_HOOKUP_OBJECT (dialog1, label12, "label12");
GLADE_HOOKUP_OBJECT (dialog1, spinImin, "spinImin");
GLADE_HOOKUP_OBJECT (dialog1, spinImax, "spinImax");
GLADE_HOOKUP_OBJECT (dialog1, spinPmin, "spinPmin");
GLADE_HOOKUP_OBJECT (dialog1, spinPmax, "spinPmax");
GLADE_HOOKUP_OBJECT (dialog1, label3, "label3");
GLADE_HOOKUP_OBJECT (dialog1, label13, "label13");
GLADE_HOOKUP_OBJECT (dialog1, label4, "label4");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
int
nsSetupTypeDlg::Show(int aDirection)
{
int err = OK;
int numSetupTypes = 0;
GtkWidget *radbtn;
nsSetupType *currST = NULL;
GtkWidget *frame = NULL;
XI_VERIFY(gCtx);
XI_VERIFY(gCtx->notebook);
if (mWidgetsInit == FALSE)
{
// add a vbox as a page of the notebook
mBox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(mBox), 12);
gtk_notebook_append_page(GTK_NOTEBOOK(gCtx->notebook), mBox, NULL);
mPageNum = gtk_notebook_get_current_page(GTK_NOTEBOOK(gCtx->notebook));
// add the top text label
GtkWidget *msg0 = gtk_label_new(mMsg0);
gtk_misc_set_alignment(GTK_MISC(msg0), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(mBox), msg0, FALSE, FALSE, 12);
// for each setup type, pack into the vbox:
// an hbox containing: (this is to pad the radio button on the right)
// the radio button with short description
// a label with the long description
numSetupTypes = GetNumSetupTypes();
currST = GetSetupTypeList();
for (int i = 0; i < numSetupTypes; ++i, currST = currST->GetNext()) {
if (i == 0) {
radbtn = gtk_radio_button_new_with_mnemonic(NULL,
currST->GetDescShort());
mRadioGroup = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radbtn));
} else {
radbtn = gtk_radio_button_new_with_mnemonic(mRadioGroup,
currST->GetDescShort());
}
GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), radbtn, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mBox), hbox, FALSE, FALSE, 6);
GtkWidget *desc = gtk_label_new(currST->GetDescLong());
gtk_label_set_line_wrap(GTK_LABEL(desc), TRUE);
gtk_misc_set_alignment(GTK_MISC(desc), 0.0, 0.5);
// Pad the labels so that they line up with the radio button text
gint ind_size, ind_spacing;
gtk_widget_style_get(radbtn,
"indicator_size", &ind_size,
"indicator_spacing", &ind_spacing,
NULL);
gtk_misc_set_padding(GTK_MISC(desc), ind_size + ind_spacing * 3, 0);
gtk_box_pack_start(GTK_BOX(mBox), desc, FALSE, FALSE, 6);
}
frame = gtk_frame_new(gCtx->Res("DEST_DIR"));
gtk_box_pack_start(GTK_BOX(mBox), frame, FALSE, FALSE, 12);
GtkWidget *frame_hbox = gtk_hbox_new(FALSE, 6);
gtk_container_set_border_width(GTK_CONTAINER(frame_hbox), 6);
gtk_container_add(GTK_CONTAINER(frame), frame_hbox);
if (!gCtx->opt->mDestination) {
gCtx->opt->mDestination = (char*)malloc(MAXPATHLEN * sizeof(char));
getcwd(gCtx->opt->mDestination, MAXPATHLEN);
}
sFolder = gtk_label_new(gCtx->opt->mDestination);
gtk_label_set_line_wrap(GTK_LABEL(sFolder), TRUE);
gtk_misc_set_alignment(GTK_MISC(sFolder), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(frame_hbox), sFolder, TRUE, TRUE, 0);
sBrowseBtn = gtk_button_new_with_label(gCtx->Res("BROWSE"));
gtk_box_pack_start(GTK_BOX(frame_hbox), sBrowseBtn, FALSE, FALSE, 0);
mWidgetsInit = TRUE;
} else {
gtk_notebook_set_page(GTK_NOTEBOOK(gCtx->notebook), mPageNum);
}
// <b>title</b>\0
char *titleBuf = new char[strlen(mTitle) + 9];
sprintf(titleBuf, "<b>%s</b>", mTitle);
gtk_label_set_markup(GTK_LABEL(gCtx->header_title), titleBuf);
gtk_label_set_text(GTK_LABEL(gCtx->header_subtitle), mSubTitle);
delete[] titleBuf;
gtk_widget_show_all(mBox);
// signal connect the buttons
// NOTE: back button disfunctional in this dlg since user accepted license
gCtx->backID = gtk_signal_connect(GTK_OBJECT(gCtx->back), "clicked",
GTK_SIGNAL_FUNC(nsSetupTypeDlg::Back), gCtx->sdlg);
gCtx->nextID = gtk_signal_connect(GTK_OBJECT(gCtx->next), "clicked",
GTK_SIGNAL_FUNC(nsSetupTypeDlg::Next), gCtx->sdlg);
sBrowseBtnID = gtk_signal_connect(GTK_OBJECT(sBrowseBtn), "clicked",
GTK_SIGNAL_FUNC(nsSetupTypeDlg::SelectFolder), NULL);
if (aDirection == nsXInstallerDlg::FORWARD_MOVE)
{
// change the button titles back to Back/Next
gtk_button_set_label(GTK_BUTTON(gCtx->next), GTK_STOCK_GO_FORWARD);
gtk_button_set_label(GTK_BUTTON(gCtx->back), GTK_STOCK_GO_BACK);
}
// from install dlg
if (aDirection == nsXInstallerDlg::BACKWARD_MOVE &&
// not custom setup type
gCtx->opt->mSetupType != (gCtx->sdlg->GetNumSetupTypes() - 1))
{
DUMP("Back from Install to Setup Type");
gtk_button_set_label(GTK_BUTTON(gCtx->next), GTK_STOCK_GO_FORWARD);
}
gtk_widget_set_sensitive(gCtx->back, FALSE);
return err;
}
/*
* snap_dialog
*
* Bring up the GTK dialog for setting snapshot
* parameters.
*/
static gboolean
snap_dialog (void)
{
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkObject *adj;
GSList *radio_group = NULL;
gint radio_pressed[2];
gint decorations;
gboolean run;
/* Set defaults */
radio_pressed[0] = (winsnapvals.root == FALSE);
radio_pressed[1] = (winsnapvals.root == TRUE);
decorations = winsnapvals.decor;
/* Init GTK */
gimp_ui_init (PLUG_IN_BINARY, FALSE);
/* Main Dialog */
dialog = gimp_dialog_new (PLUG_IN_PRINT_NAME, PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("Grab"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
winsnapintf.single_button =
gtk_radio_button_new_with_label (radio_group,
_("Grab a single window"));
gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.single_button, FALSE, FALSE, 0);
g_signal_connect (winsnapintf.single_button, "toggled",
G_CALLBACK (snap_toggle_update),
&radio_pressed[0]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.single_button),
radio_pressed[0]);
gtk_widget_show (winsnapintf.single_button);
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.single_button));
winsnapintf.root_button =
gtk_radio_button_new_with_label (radio_group,
_("Grab the whole screen"));
gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.root_button, FALSE, FALSE, 0);
g_signal_connect (winsnapintf.root_button, "toggled",
G_CALLBACK (snap_toggle_update),
&radio_pressed[1]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.root_button),
radio_pressed[1]);
gtk_widget_show (winsnapintf.root_button);
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.root_button));
/* with delay */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("after"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
winsnapintf.delay_spinner = gimp_spin_button_new (&adj,
winsnapvals.delay,
0.0, 100.0,
1.0, 5.0, 0.0, 0, 0);
gtk_box_pack_start (GTK_BOX (hbox),
winsnapintf.delay_spinner, FALSE, FALSE, 0);
gtk_widget_show (winsnapintf.delay_spinner);
label = gtk_label_new (_("Seconds delay"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
#ifdef CAN_SET_DECOR
/* With decorations */
winsnapintf.decor_button =
gtk_check_button_new_with_label (_("Include decorations"));
g_signal_connect (winsnapintf.decor_button, "toggled",
G_CALLBACK (snap_toggle_update),
&decorations);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.decor_button),
decorations);
gtk_box_pack_end (GTK_BOX (vbox), winsnapintf.decor_button, FALSE, FALSE, 0);
gtk_widget_set_sensitive (winsnapintf.decor_button, radio_pressed[0]);
gtk_widget_show (winsnapintf.decor_button);
#endif /* CAN_SET_DECOR */
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
if (run)
{
winsnapvals.root = radio_pressed[1];
winsnapvals.decor = decorations;
winsnapvals.delay =
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (winsnapintf.delay_spinner));
}
gtk_widget_destroy (dialog);
return run;
}
GtkWidget* build_gui ( void ) {
GtkWidget *window1;
GtkWidget *vbox1;
GtkWidget *vbox2;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *label3;
GtkWidget *label4;
GtkWidget *radiobutton1;
GSList *radiobutton1_group = NULL;
GtkWidget *radiobutton2;
GtkWidget *entry1;
window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window1), "tracking antenna");
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (window1), vbox1);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0);
table1 = gtk_table_new (4, 3, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox2), table1, TRUE, TRUE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table1), 5);
label1 = gtk_label_new ("Azimuth");
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
label2 = gtk_label_new ("Elevation");
gtk_widget_show (label2);
gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
label3 = gtk_label_new ("Id");
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label4 = gtk_label_new ("mode");
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
radiobutton1 = gtk_radio_button_new_with_mnemonic (NULL, "manual");
gtk_widget_show (radiobutton1);
gtk_table_attach (GTK_TABLE (table1), radiobutton1, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton1), radiobutton1_group);
radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton1));
radiobutton2 = gtk_radio_button_new_with_mnemonic (NULL, "tracking");
gtk_widget_show (radiobutton2);
gtk_table_attach (GTK_TABLE (table1), radiobutton2, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton2), radiobutton1_group);
radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton2));
azim_scale = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (144.7, 0, 360, 1, 1, 1)));
gtk_widget_show (azim_scale);
gtk_table_attach (GTK_TABLE (table1), azim_scale, 1, 3, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_range_set_update_policy (GTK_RANGE (azim_scale), GTK_UPDATE_DELAYED);
elev_scale = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (32.3, 0, 90, 1, 1, 1)));
gtk_widget_show (elev_scale);
gtk_table_attach (GTK_TABLE (table1), elev_scale, 1, 3, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
entry1 = gtk_entry_new ();
gtk_widget_show (entry1);
gtk_table_attach (GTK_TABLE (table1), entry1, 1, 3, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect ((gpointer) radiobutton1, "toggled",
G_CALLBACK (on_mode_changed),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (window1, window1, "window1");
GLADE_HOOKUP_OBJECT (window1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (window1, vbox2, "vbox2");
GLADE_HOOKUP_OBJECT (window1, table1, "table1");
GLADE_HOOKUP_OBJECT (window1, label1, "label1");
GLADE_HOOKUP_OBJECT (window1, label2, "label2");
GLADE_HOOKUP_OBJECT (window1, label3, "label3");
GLADE_HOOKUP_OBJECT (window1, label4, "label4");
GLADE_HOOKUP_OBJECT (window1, radiobutton1, "radiobutton1");
GLADE_HOOKUP_OBJECT (window1, radiobutton2, "radiobutton2");
GLADE_HOOKUP_OBJECT (window1, entry1, "entry1");
return window1;
}
void
grg_pref_dialog (GtkWidget * parent)
{
GtkWidget *prefs, *notebook, *tab1, *tab2, *tab3;
GtkWidget *frame1, *frame2, *frame3;
GtkWidget *crypt_box, *hash_box, *comp_box;
GtkWidget *frame_font;
GtkWidget *frame_file, *but_file, *box_file, *but_file_clear;
GtkWidget *frame_save, *box_save;
GtkWidget *frame_misc, *box_misc;
GtkWidget *frame_xpire, *box_xpire, *xpire_lbl;
GtkWidget *frame_passes, *box_passes, *lbl_passes;
GtkWidget *frame_clip, *box_clip;
gint response;
PangoFontDescription *fdesc;
if (active_flag)
return;
prefs = gtk_dialog_new_with_buttons (_("Preferences"),
GTK_WINDOW (parent),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_OK,
GTK_STOCK_APPLY,
GTK_RESPONSE_APPLY,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL, NULL);
//first page: algorithms
tab1 = gtk_table_new (3, 2, FALSE);
frame1 = gtk_frame_new (_("Encryption"));
gtk_table_attach_defaults (GTK_TABLE (tab1), frame1, 0, 1, 0, 3);
crypt_box = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame1), crypt_box);
NEW_RADIO_BUTTON (rij1_but, NULL, modify_crypto, GRG_AES,
"AES (Rijndael 128)", crypt_box);
NEW_RADIO_BUTTON (ser_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_SERPENT, "Serpent", crypt_box);
NEW_RADIO_BUTTON (twof_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_TWOFISH, "Twofish", crypt_box);
NEW_RADIO_BUTTON (cast_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_CAST_256, "Cast 256", crypt_box);
NEW_RADIO_BUTTON (safer_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_SAFERPLUS, "Safer+", crypt_box);
NEW_RADIO_BUTTON (loki_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_LOKI97, "Loki97", crypt_box);
NEW_RADIO_BUTTON (tdes_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_3DES, "3-DES", crypt_box);
NEW_RADIO_BUTTON (rij2_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_RIJNDAEL_256, "Rijndael 256",
crypt_box);
NEW_ROW_SEPARATOR (crypt_box);
NEW_LABEL (crypto_block_lbl, crypt_box, "");
NEW_LABEL (crypto_key_lbl, crypt_box, "");
update_crypto_label ();
frame2 = gtk_frame_new (_("Hashing"));
gtk_table_attach_defaults (GTK_TABLE (tab1), frame2, 1, 2, 0, 1);
hash_box = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame2), hash_box);
NEW_RADIO_BUTTON (sha_but, NULL, modify_hash, GRG_SHA1, "SHA1",
hash_box);
NEW_RADIO_BUTTON (ripe_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(sha_but)), modify_hash,
GRG_RIPEMD_160, "RIPEMD 160", hash_box);
frame3 = gtk_frame_new (_("Compression"));
gtk_table_attach_defaults (GTK_TABLE (tab1), frame3, 1, 2, 1, 2);
comp_box = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame3), comp_box);
NEW_RADIO_BUTTON (zlib_but, NULL, modify_comp, GRG_ZLIB, "ZLib",
comp_box);
NEW_RADIO_BUTTON (bz_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(zlib_but)),
modify_comp, GRG_BZIP, "BZip2", comp_box);
NEW_ROW_SEPARATOR (comp_box);
NEW_RADIO_BUTTON (r0_but, NULL, modify_ratio, GRG_LVL_NONE, _("None"),
comp_box);
NEW_RADIO_BUTTON (r3_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(r0_but)), modify_ratio,
GRG_LVL_FAST, _("Fast"), comp_box);
NEW_RADIO_BUTTON (r6_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(r0_but)), modify_ratio,
GRG_LVL_GOOD, _("Good"), comp_box);
NEW_RADIO_BUTTON (r9_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(r0_but)), modify_ratio,
GRG_LVL_BEST, _("Best"), comp_box);
notebook = gtk_notebook_new ();
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab1,
gtk_label_new (_("Algorithms")));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (prefs)->vbox), notebook,
TRUE, TRUE, GRG_PAD);
//second page: General options
tab2 = gtk_vbox_new (FALSE, GRG_PAD);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab2,
gtk_label_new (_("General options")));
frame_font = gtk_frame_new (_("Editor font"));
gtk_box_pack_start (GTK_BOX (tab2), frame_font, FALSE, TRUE, 1);
but_font =
gtk_button_new_with_label (_
("Click to change the editor font"));
gtk_container_add (GTK_CONTAINER (frame_font), but_font);
fdesc = pango_font_description_from_string (grg_prefs_editor_font);
gtk_widget_modify_font (but_font, fdesc);
g_free (fdesc);
g_signal_connect (G_OBJECT (but_font), "clicked",
G_CALLBACK (modify_font), prefs);
frame_misc = gtk_frame_new (_("Decorations"));
gtk_box_pack_start (GTK_BOX (tab2), frame_misc, FALSE, TRUE, 1);
box_misc = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_misc), box_misc);
NEW_ROW_SEPARATOR (tab2);
splash_check = gtk_check_button_new_with_label (_("Splash screen"));
g_signal_connect (G_OBJECT (splash_check), "toggled",
G_CALLBACK (modify_splash), NULL);
gtk_box_pack_start (GTK_BOX (box_misc), splash_check, FALSE, TRUE, 1);
frame_file = gtk_frame_new (_("File to open at startup"));
gtk_box_pack_start (GTK_BOX (tab2), frame_file, FALSE, TRUE, 1);
box_file = gtk_hbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_file), box_file);
file_entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (box_file), file_entry, FALSE, TRUE, 1);
but_file = gtk_button_new_from_stock (GTK_STOCK_OPEN);
gtk_box_pack_start (GTK_BOX (box_file), but_file, FALSE, TRUE, 1);
g_signal_connect (G_OBJECT (but_file), "clicked",
G_CALLBACK (meta_open_startup_file),
(gpointer) prefs);
but_file_clear = gtk_button_new_from_stock (GTK_STOCK_CLEAR);
gtk_box_pack_start (GTK_BOX (box_file), but_file_clear, FALSE, TRUE,
1);
g_signal_connect (G_OBJECT (but_file_clear), "clicked",
G_CALLBACK (clear_file), NULL);
frame_save = gtk_frame_new (_("File saving"));
gtk_box_pack_start (GTK_BOX (tab2), frame_save, FALSE, TRUE, 1);
box_save = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_save), box_save);
bak_check =
gtk_check_button_new_with_label (_("Make backups of files"));
g_signal_connect (G_OBJECT (bak_check), "toggled",
G_CALLBACK (modify_bak), NULL);
gtk_box_pack_start (GTK_BOX (box_save), bak_check, FALSE, TRUE, 1);
over_check =
gtk_check_button_new_with_label (_
("Ask when overwriting files"));
g_signal_connect (G_OBJECT (over_check), "toggled",
G_CALLBACK (modify_over), NULL);
gtk_box_pack_start (GTK_BOX (box_save), over_check, FALSE, TRUE, 1);
//third page: Security
tab3 = gtk_vbox_new (FALSE, GRG_PAD);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab3,
gtk_label_new (_("Security")));
frame_xpire = gtk_frame_new (_("Password expiration"));
gtk_box_pack_start (GTK_BOX (tab3), frame_xpire, FALSE, TRUE, 1);
box_xpire = gtk_hbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_xpire), box_xpire);
xpire_check =
gtk_check_button_new_with_label (_("Password expires in"));
xpire_spin =
gtk_spin_button_new_with_range (EXP_TIME_MIN, EXP_TIME_MAX,
1);
xpire_lbl = gtk_label_new (_("days"));
g_signal_connect (G_OBJECT (xpire_check), "toggled",
G_CALLBACK (modify_xpire), xpire_spin);
g_signal_connect (G_OBJECT (xpire_spin), "value-changed",
G_CALLBACK (modify_xpin), xpire_check);
gtk_box_pack_start (GTK_BOX (box_xpire), xpire_check, FALSE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_xpire), xpire_spin, FALSE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_xpire), xpire_lbl, FALSE, TRUE, 1);
//this means "passes in wiping a file", not "wipe the passes" :)
frame_passes = gtk_frame_new (_("Wipe passes"));
gtk_box_pack_start (GTK_BOX (tab3), frame_passes, FALSE, TRUE, 1);
box_passes = gtk_hbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_passes), box_passes);
lbl_passes = gtk_label_new (_("Number of overwritings with random\n"
"data, when wiping a file:"));
gtk_box_pack_start (GTK_BOX (box_passes), lbl_passes, FALSE, TRUE, 1);
passes_spin =
gtk_spin_button_new_with_range (WIPE_PASSES_MIN,
WIPE_PASSES_MAX, 1);
gtk_box_pack_start (GTK_BOX (box_passes), passes_spin, FALSE, TRUE,
1);
g_signal_connect (G_OBJECT (passes_spin), "value-changed",
G_CALLBACK (modify_passes), NULL);
frame_clip = gtk_frame_new (_("Clipboard"));
gtk_box_pack_start (GTK_BOX (tab3), frame_clip, FALSE, TRUE, 1);
box_clip = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_clip), box_clip);
cclip_check =
gtk_check_button_new_with_label (_
("Clear clipboard on closing file"));
g_signal_connect (G_OBJECT (cclip_check), "toggled",
G_CALLBACK (modify_cclip), NULL);
gtk_box_pack_start (GTK_BOX (box_clip), cclip_check, FALSE, TRUE, 1);
qclip_check =
gtk_check_button_new_with_label (_
("Clear clipboard on exit"));
g_signal_connect (G_OBJECT (qclip_check), "toggled",
G_CALLBACK (modify_qclip), NULL);
gtk_box_pack_start (GTK_BOX (box_clip), qclip_check, FALSE, TRUE, 1);
//end of last tab
active_flag = TRUE;
reset_values (prefs);
update_buttons ();
gtk_widget_show_all (prefs);
while (TRUE)
{
gboolean exit = TRUE;
response = gtk_dialog_run (GTK_DIALOG (prefs));
switch (response)
{
case GTK_RESPONSE_OK:
apply_values ();
break;
case GTK_RESPONSE_APPLY:
apply_values ();
exit = FALSE;
break;
case GTK_RESPONSE_CANCEL:
default:
break;
}
if (exit)
{
gtk_widget_destroy (prefs);
active_flag = FALSE;
break;
}
}
}
/*
* change the visualization method
*/
void gtkui_vis_method(void)
{
GtkWidget *dialog, *button, *prev, *vbox;
GSList *curr = NULL;
gint active = 0, response = 0;
GList *lang_list = NULL;
GtkWidget *hbox, *lang_combo, *label;
char encoding[50], *local_lang, def_lang[75];
DEBUG_MSG("gtk_vis_method");
dialog = gtk_dialog_new_with_buttons("Visualization method...", GTK_WINDOW (window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_OK,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(dialog), 10);
vbox = GTK_DIALOG (dialog)->vbox;
button = gtk_radio_button_new_with_label(NULL,
"hex Print the packets in hex format.");
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), button, FALSE, FALSE, 0);
if(strcmp(vmethod, "hex") == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (button), TRUE);
prev = button;
button = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (prev),
"ascii Print only \"printable\" characters, the others are displayed as dots '.'");
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), button, FALSE, FALSE, 0);
if(strcmp(vmethod, "ascii") == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (button), TRUE);
prev = button;
button = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (prev),
"text Print only the \"printable\" characters and skip the others.");
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), button, FALSE, FALSE, 0);
if(strcmp(vmethod, "text") == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (button), TRUE);
prev = button;
button = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (prev),
"ebcdic Convert an EBCDIC text to ASCII.");
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), button, FALSE, FALSE, 0);
if(strcmp(vmethod, "ebcdic") == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (button), TRUE);
prev = button;
button = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (prev),
"html Strip all the html tags from the text. A tag is every string between < and >.");
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), button, FALSE, FALSE, 0);
if(strcmp(vmethod, "html") == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (button), TRUE);
prev = button;
/* start UTF8 */
button = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (prev),
"utf8 Convert the data from the encoding specified below to UTF8 before displaying it.");
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), button, FALSE, FALSE, 0);
if(strcmp(vmethod, "utf8") == 0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (button), TRUE);
prev = button;
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new ("Character encoding : ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
/* get the system's default encoding, and if it's not UTF8, add it to the list */
if(!g_get_charset(&local_lang)) {
snprintf(def_lang, 75, "%s (System Default)", local_lang);
lang_list = g_list_append(lang_list, def_lang);
}
/* some other common encodings */
lang_list = g_list_append(lang_list, "UTF-8");
lang_list = g_list_append(lang_list, "EBCDIC-US (IBM)");
lang_list = g_list_append(lang_list, "ISO-8859-15 (Western Europe)");
lang_list = g_list_append(lang_list, "ISO-8859-2 (Central Europe)");
lang_list = g_list_append(lang_list, "ISO-8859-7 (Greek)");
lang_list = g_list_append(lang_list, "ISO-8859-8 (Hebrew)");
lang_list = g_list_append(lang_list, "ISO-8859-9 (Turkish)");
lang_list = g_list_append(lang_list, "ISO-2022-JP (Japanese)");
lang_list = g_list_append(lang_list, "SJIS (Japanese)");
lang_list = g_list_append(lang_list, "CP949 (Korean)");
lang_list = g_list_append(lang_list, "CP1251 (Cyrillic)");
lang_list = g_list_append(lang_list, "CP1256 (Arabic)");
lang_list = g_list_append(lang_list, "GB18030 (Chinese)");
/* make a drop down box and assign the list to it */
lang_combo = gtk_combo_new();
gtk_combo_set_popdown_strings (GTK_COMBO (lang_combo), lang_list);
gtk_box_pack_start (GTK_BOX (hbox), lang_combo, TRUE, TRUE, 0);
/* list is stored in the widget, can safely free this copy */
g_list_free(lang_list);
/* end UTF8 */
gtk_widget_show_all(GTK_DIALOG(dialog)->vbox);
response = gtk_dialog_run(GTK_DIALOG (dialog));
if(response == GTK_RESPONSE_OK) {
gtk_widget_hide(dialog);
/* see which button was clicked */
active = 0;
for(curr = gtk_radio_button_get_group(GTK_RADIO_BUTTON (button)); curr; curr = curr->next) {
active++;
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (curr->data)))
break;
}
/* set vmethod string */
int i=0;
switch(active) {
case 6: strncpy(vmethod, "hex", 3); break;
case 5: strncpy(vmethod, "ascii", 5); break;
case 4: strncpy(vmethod, "text", 4); break;
case 3: strncpy(vmethod, "ebcdic", 6); break;
case 2: strncpy(vmethod, "html", 4); break;
case 1: /* utf8 */
/* copy first word from encoding choice */
i=sscanf(gtk_entry_get_text(GTK_ENTRY (GTK_COMBO (lang_combo)->entry)),
"%[^ ]", encoding);
BUG_IF(i!=1);
if(strlen(encoding) > 0) {
strncpy(vmethod, "utf8", 4);
set_utf8_encoding(encoding);
break;
}
default: strncpy(vmethod, "ascii", 5);
}
set_format(vmethod);
}
gtk_widget_destroy(dialog);
}