static GSList*
gwy_radio_buttons_create_real(const GwyEnum *entries,
gint nentries,
GCallback callback,
gpointer cbdata,
gint current,
gboolean translate)
{
GtkWidget *button, *curbutton;
GSList *group;
gint i;
if (nentries < 0) {
for (nentries = 0; entries[nentries].name != NULL; nentries++)
;
}
setup_quark();
button = curbutton = NULL;
/* FIXME: this relies on undocumented GtkRadioButton behaviour;
* we assume it puts the items into the group in reverse order */
for (i = nentries-1; i >= 0; i--) {
if (translate)
button = gtk_radio_button_new_with_mnemonic_from_widget
(GTK_RADIO_BUTTON(button),
gwy_sgettext(entries[i].name));
else
button = gtk_radio_button_new_with_mnemonic_from_widget
(GTK_RADIO_BUTTON(button), entries[i].name);
g_object_set_qdata(G_OBJECT(button), gwyrb_quark,
GINT_TO_POINTER(entries[i].value));
if (entries[i].value == current)
curbutton = button;
}
gwy_debug("current: %p", curbutton);
if (curbutton)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(curbutton), TRUE);
if (callback) {
for (group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(button));
group;
group = g_slist_next(group))
g_signal_connect(group->data, "clicked", callback, cbdata);
}
return gtk_radio_button_get_group(GTK_RADIO_BUTTON(button));
}
void ui_import_csv(void) {
GtkWidget *dia_file_import;
GtkWidget *vbox;
GtkWidget *radio_comma, *radio_tab;
import_ *import;
import = malloc(sizeof(import_));
import->delimiter = ',';
dia_file_import = gtk_file_chooser_dialog_new(
"Import character separated file",
GTK_WINDOW(win_main),
GTK_FILE_CHOOSER_ACTION_OPEN,
NULL);
gtk_dialog_add_buttons(
GTK_DIALOG(dia_file_import),
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
/* Build options widget */
radio_comma = gtk_radio_button_new_with_mnemonic(NULL, "_Comma separated");
radio_tab = gtk_radio_button_new_with_mnemonic_from_widget(
GTK_RADIO_BUTTON(radio_comma),
"_Tab separated");
g_signal_connect(
radio_comma,
"toggled",
GTK_SIGNAL_FUNC(ui_import_delimiter_comma_cb),
import);
g_signal_connect(
radio_tab,
"toggled",
GTK_SIGNAL_FUNC(ui_import_delimiter_tab_cb),
import);
vbox = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), radio_comma, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), radio_tab, FALSE, FALSE, 3);
gtk_widget_show_all(vbox);
/* Prepare import dialog and show */
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dia_file_import), vbox);
if (gtk_dialog_run(GTK_DIALOG(dia_file_import)) == GTK_RESPONSE_ACCEPT) {
list_clear(list);
list = list_create();
import->filename = strdup(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dia_file_import)));
list_import_csv(list, import->filename, import->delimiter);
free(import->filename);
}
gtk_widget_destroy(dia_file_import);
free(import);
}
static void
fill_radio (GtkRadioButton *group,
MouseClickModifier *modifier)
{
modifier->radio = gtk_radio_button_new_with_mnemonic_from_widget (group, modifier->name);
gtk_box_pack_start (GTK_BOX (alt_click_vbox), modifier->radio, FALSE, FALSE, 0);
gtk_widget_show (modifier->radio);
}
GtkWidget*
gtr_relocate_dialog_new( GtkWindow * parent,
TrCore * core,
GSList * torrent_ids )
{
int row;
GtkWidget * w;
GtkWidget * d;
GtkWidget * t;
struct relocate_dialog_data * data;
d = gtk_dialog_new_with_buttons( _( "Set Torrent Location" ), parent,
GTK_DIALOG_DESTROY_WITH_PARENT |
GTK_DIALOG_MODAL |
GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_APPLY, GTK_RESPONSE_APPLY,
NULL );
gtk_dialog_set_default_response( GTK_DIALOG( d ),
GTK_RESPONSE_CANCEL );
gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ),
GTK_RESPONSE_APPLY,
GTK_RESPONSE_CANCEL,
-1 );
g_signal_connect( d, "response", G_CALLBACK( onResponse ), NULL );
row = 0;
t = hig_workarea_create( );
hig_workarea_add_section_title( t, &row, _( "Location" ) );
if( previousLocation == NULL )
previousLocation = g_strdup( pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR ) );
w = gtk_file_chooser_button_new( _( "Set Torrent Location" ), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), previousLocation );
g_object_set_data( G_OBJECT( d ), "chooser", w );
hig_workarea_add_row( t, &row, _( "Torrent _location:" ), w, NULL );
w = gtk_radio_button_new_with_mnemonic( NULL, _( "_Move from the current folder" ) );
g_object_set_data( G_OBJECT( d ), "move_rb", w );
hig_workarea_add_wide_control( t, &row, w );
w = gtk_radio_button_new_with_mnemonic_from_widget( GTK_RADIO_BUTTON( w ), _( "Local data is _already there" ) );
hig_workarea_add_wide_control( t, &row, w );
hig_workarea_finish( t, &row );
gtk_widget_show_all( t );
gtk_box_pack_start( GTK_BOX( GTK_DIALOG( d )->vbox ), t, TRUE, TRUE, 0 );
data = g_new0( struct relocate_dialog_data, 1 );
data->core = core;
data->torrent_ids = torrent_ids;
data->chooser_dialog = d;
g_object_set_data_full( G_OBJECT( d ), DATA_KEY, data, data_free );
return d;
}
GtkWidget *
dialog_radio_button_from_widget_in_table(GtkRadioButton * radio_group_member, const gchar * label,
GtkWidget * table, guint left_attach, guint right_attach,
guint top_attach, guint bottom_attach)
{
GtkWidget *button;
button = gtk_radio_button_new_with_mnemonic_from_widget(radio_group_member, label);
gtk_table_attach(GTK_TABLE(table), button, left_attach, right_attach, top_attach, bottom_attach, GTK_FILL,
GTK_SHRINK, 0, 0);
return button;
}
void
gtk_utils_create_radio_chain (GtkWidget **radio_buttons,
const gchar **label_texts,
gint num_radio_buttons)
{
GtkRadioButton *last_button = NULL;
int k;
g_return_if_fail (radio_buttons);
g_return_if_fail (label_texts);
for (k = 0; k < num_radio_buttons; k++) {
radio_buttons[k]
= gtk_radio_button_new_with_mnemonic_from_widget (last_button,
_(label_texts[k]));
last_button = GTK_RADIO_BUTTON (radio_buttons[k]);
}
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkRadioButton_gtk_1radio_1button_1new_1with_1mnemonic_1from_1widget
(
JNIEnv* env,
jclass cls,
jlong _group,
jstring _label
)
{
GtkWidget* result;
jlong _result;
GtkRadioButton* group;
const gchar* label;
// convert parameter group
group = (GtkRadioButton*) _group;
// convert parameter label
label = (const gchar*) bindings_java_getString(env, _label);
if (label == NULL) {
return 0L; // Java Exception already thrown
}
// call function
result = gtk_radio_button_new_with_mnemonic_from_widget(group, label);
// cleanup parameter group
// cleanup parameter label
bindings_java_releaseString(label);
// translate return value to JNI type
_result = (jlong) result;
// cleanup return value
if (result != NULL) {
bindings_java_memory_cleanup((GObject*)result, TRUE);
}
// and finally
return _result;
}
/**
* gwy_radio_buttons_create:
* @entries: Radio button group items.
* @nentries: The number of items.
* @key: Value object data key.
* @callback: A callback called when a menu item is activated (or %NULL for
* no callback).
* @cbdata: User data passed to the callback.
* @current: Value to be shown as currently selected (-1 to use what happens
* to be first).
*
* Creates a radio button group for an enum.
*
* It sets object data identified by @key for each menu item to its value.
* Try to avoid -1 as an enum value.
*
* Returns: The newly created radio button group (a #GSList). Iterate over
* the list and pack the widgets (the order is the same as in
* @entries).
*
* Since: 1.2.
**/
GSList*
gwy_radio_buttons_create(const GwyEnum *entries,
gint nentries,
const gchar *key,
GCallback callback,
gpointer cbdata,
gint current)
{
GtkWidget *button, *curbutton;
GSList *group;
GQuark quark;
gint i;
quark = g_quark_from_string(key);
button = curbutton = NULL;
/* FIXME: this relies on undocumented GtkRadioButton behaviour;
* we assume it puts the items into the group in reverse order */
for (i = nentries-1; i >= 0; i--) {
button = gtk_radio_button_new_with_mnemonic_from_widget
(GTK_RADIO_BUTTON(button), _(entries[i].name));
g_object_set_qdata(G_OBJECT(button), quark,
GINT_TO_POINTER(entries[i].value));
if (entries[i].value == current)
curbutton = button;
}
gwy_debug("current: %p", curbutton);
if (curbutton)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(curbutton), TRUE);
if (callback) {
for (group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(button));
group;
group = g_slist_next(group))
g_signal_connect(group->data, "clicked", callback, cbdata);
}
return gtk_radio_button_get_group(GTK_RADIO_BUTTON(button));
}
static GtkWidget*
create_button(VALUE group, VALUE label, VALUE use_underline)
{
GtkWidget* widget = NULL;
if (TYPE(label) == T_STRING){
if (NIL_P(use_underline) || RVAL2CBOOL(use_underline)){
widget = gtk_radio_button_new_with_mnemonic_from_widget(_GROUP(group), RVAL2CSTR(label));
} else {
widget = gtk_radio_button_new_with_label_from_widget(_GROUP(group), RVAL2CSTR(label));
}
} else if (TYPE(label) == T_SYMBOL){
widget = gtk_radio_button_new_with_label_from_widget(_GROUP(group), rb_id2name(SYM2ID(label)));
gtk_button_set_use_stock(GTK_BUTTON(widget), TRUE);
} else if (NIL_P(label)){
widget = gtk_radio_button_new_from_widget(_GROUP(group));
} else {
rb_raise(rb_eArgError, "invalid argument %s (expect Symbol(Gtk::Stock constants) or String)",
rb_class2name(CLASS_OF(label)));
}
return widget;
}
void
mobile_connection_new (GtkWindow *parent,
const char *detail,
NMRemoteSettings *settings,
PageNewConnectionResultFunc result_func,
gpointer user_data)
{
NMAMobileWizard *wizard;
WizardInfo *info;
GtkWidget *dialog, *vbox, *gsm_radio, *cdma_radio, *label, *content, *alignment;
GtkWidget *hbox, *image;
gint response;
NMAMobileWizardAccessMethod method;
info = g_malloc0 (sizeof (WizardInfo));
info->result_func = result_func;
info->settings = g_object_ref (settings);
info->user_data = user_data;
wizard = nma_mobile_wizard_new (parent, NULL, NM_DEVICE_MODEM_CAPABILITY_NONE, FALSE,
new_connection_mobile_wizard_done, info);
if (wizard) {
nma_mobile_wizard_present (wizard);
return;
}
/* Fall back to just asking for GSM vs. CDMA */
dialog = gtk_dialog_new_with_buttons (_("Select Mobile Broadband Provider Type"),
parent,
GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
g_signal_connect (dialog, "delete-event", G_CALLBACK (cancel_dialog), NULL);
gtk_window_set_icon_name (GTK_WINDOW (dialog), "nm-device-wwan");
content = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
alignment = gtk_alignment_new (0, 0, 0.5, 0.5);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12);
gtk_box_pack_start (GTK_BOX (content), alignment, TRUE, FALSE, 6);
#if GTK_CHECK_VERSION (3,1,6)
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
#else
hbox = gtk_hbox_new (FALSE, 6);
#endif
gtk_container_add (GTK_CONTAINER (alignment), hbox);
image = gtk_image_new_from_icon_name ("nm-device-wwan", GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0);
gtk_misc_set_padding (GTK_MISC (image), 0, 6);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 6);
#if GTK_CHECK_VERSION (3,1,6)
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
#else
vbox = gtk_vbox_new (FALSE, 6);
#endif
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, FALSE, 0);
label = gtk_label_new (_("Select the technology your mobile broadband provider uses. If you are unsure, ask your provider."));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 12);
gsm_radio = gtk_radio_button_new_with_mnemonic (NULL, _("My provider uses _GSM-based technology (i.e. GPRS, EDGE, UMTS, HSDPA)"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gsm_radio), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), gsm_radio, FALSE, FALSE, 6);
/* Translators: CDMA has 'D' accelerator key; 'C' collides with 'Cancel' button.
You may need to change it according to your language. */
cdma_radio = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (gsm_radio),
_("My provider uses C_DMA-based technology (i.e. 1xRTT, EVDO)"));
gtk_box_pack_start (GTK_BOX (vbox), cdma_radio, FALSE, FALSE, 6);
gtk_widget_show_all (dialog);
memset (&method, 0, sizeof (method));
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_OK) {
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (cdma_radio))) {
method.devtype = NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO;
method.provider_name = _("CDMA");
} else {
method.devtype = NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS;
method.provider_name = _("GSM");
}
}
gtk_widget_destroy (dialog);
new_connection_mobile_wizard_done (NULL,
(response != GTK_RESPONSE_OK),
(response == GTK_RESPONSE_OK) ? &method : NULL,
info);
}
static void ugtk_download_form_init_page1 (UgtkDownloadForm* dform, UgtkProxyForm* proxy)
{
GtkWidget* widget;
GtkGrid* top_grid;
GtkGrid* grid;
GtkWidget* frame;
GtkBox* top_vbox;
GtkWidget* vbox;
GtkWidget* hbox;
dform->page1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
top_vbox = (GtkBox*) dform->page1;
gtk_container_set_border_width (GTK_CONTAINER (top_vbox), 2);
top_grid = (GtkGrid*) gtk_grid_new ();
gtk_box_pack_start (top_vbox, (GtkWidget*) top_grid, FALSE, FALSE, 0);
// URL - entry
widget = gtk_entry_new ();
// gtk_entry_set_width_chars (GTK_ENTRY (widget), 20); // remove for GTK+ 3.12
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin-left", 1, "margin-right", 1, NULL);
g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL);
g_object_set (widget, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, widget, 1, 0, 2, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_uri_entry_changed), dform);
dform->uri_entry = widget;
// URL - label
widget = gtk_label_new_with_mnemonic (_("_URI:"));
gtk_label_set_mnemonic_widget (GTK_LABEL(widget), dform->uri_entry);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL);
gtk_grid_attach (top_grid, widget, 0, 0, 1, 1);
dform->uri_label = widget;
// Mirrors - entry
widget = gtk_entry_new ();
// gtk_entry_set_width_chars (GTK_ENTRY (widget), 20); // remove for GTK+ 3.12
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin-left", 1, "margin-right", 1, NULL);
g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL);
g_object_set (widget, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, widget, 1, 1, 2, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_uri_entry_changed), dform);
dform->mirrors_entry = widget;
// Mirrors - label
widget = gtk_label_new_with_mnemonic (_("Mirrors:"));
gtk_label_set_mnemonic_widget (GTK_LABEL(widget), dform->mirrors_entry);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 2, "margin-bottom", 2, NULL);
gtk_grid_attach (top_grid, widget, 0, 1, 1, 1);
dform->mirrors_label = widget;
// File - entry
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, widget, 1, 2, 2, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_entry_changed), dform);
dform->file_entry = widget;
// File - label
widget = gtk_label_new_with_mnemonic (_("File:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->file_entry);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (top_grid, widget, 0, 2, 1, 1);
dform->file_label = widget;
// Folder - combo entry + icon
dform->folder_combo = gtk_combo_box_text_new_with_entry ();
dform->folder_entry = gtk_bin_get_child (GTK_BIN (dform->folder_combo));
widget = dform->folder_entry;
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
#if GTK_MAJOR_VERSION >= 3 && GTK_MINOR_VERSION >= 10
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, "folder");
#else
gtk_entry_set_icon_from_stock (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_DIRECTORY);
#endif
gtk_entry_set_icon_tooltip_text (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, _("Select Folder"));
g_object_set (dform->folder_combo, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, dform->folder_combo, 1, 3, 1, 1);
g_signal_connect (widget, "icon-release",
G_CALLBACK (on_select_folder), dform);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_entry_changed), dform);
// Folder - label
widget = gtk_label_new_with_mnemonic (_("_Folder:"));
gtk_label_set_mnemonic_widget(GTK_LABEL (widget), dform->folder_combo);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (top_grid, widget, 0, 3, 1, 1);
// Referrer - entry
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (top_grid, widget, 1, 4, 2, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_http_entry_changed), dform);
dform->referrer_entry = widget;
// Referrer - label
widget = gtk_label_new_with_mnemonic (_("Referrer:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dform->referrer_entry);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (top_grid, widget, 0, 4, 1, 1);
// dform->referrer_label = widget;
// ----------------------------------------------------
// Connections
// HBox for Connections
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (top_vbox, hbox, FALSE, FALSE, 2);
// connections - label
// widget = gtk_label_new (_("connections"));
// gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 2);
// dform->label_connections = widget;
// connections - spin button
widget = gtk_spin_button_new_with_range (1.0, 16.0, 1.0);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
// gtk_entry_set_width_chars (GTK_ENTRY (widget), 3); // remove for GTK+ 3.12
gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 2);
dform->spin_connections = widget;
// "Max Connections:" - title label
widget = gtk_label_new_with_mnemonic (_("_Max Connections:"));
gtk_label_set_mnemonic_widget ((GtkLabel*)widget, dform->spin_connections);
gtk_box_pack_end (GTK_BOX (hbox), widget, FALSE, FALSE, 2);
dform->title_connections = widget;
// ----------------------------------------------------
// HBox for "Status" and "Login"
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (top_vbox, hbox, FALSE, FALSE, 2);
// ----------------------------------------------------
// frame for Status (start mode)
frame = gtk_frame_new (_("Status"));
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
dform->radio_runnable = gtk_radio_button_new_with_mnemonic (NULL,
_("_Runnable"));
dform->radio_pause = gtk_radio_button_new_with_mnemonic_from_widget (
(GtkRadioButton*)dform->radio_runnable, _("P_ause"));
gtk_box_pack_start (GTK_BOX (vbox), dform->radio_runnable, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), dform->radio_pause, FALSE, FALSE, 0);
// ----------------------------------------------------
// frame for login
frame = gtk_frame_new (_("Login"));
grid = (GtkGrid*) gtk_grid_new ();
gtk_container_set_border_width (GTK_CONTAINER (grid), 2);
gtk_container_add (GTK_CONTAINER (frame), (GtkWidget*) grid);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 2);
// User - entry
widget = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 1, 0, 1, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_entry_changed), dform);
dform->username_entry = widget;
// User - label
widget = gtk_label_new (_("User:"******"margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 0, 1, 1);
// dform->username_label = widget;
// Password - entry
widget = gtk_entry_new ();
gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
g_object_set (widget, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 1, 1, 1, 1);
g_signal_connect (GTK_EDITABLE (widget), "changed",
G_CALLBACK (on_entry_changed), dform);
dform->password_entry = widget;
// Password - label
widget = gtk_label_new (_("Password:"******"margin-left", 2, "margin-right", 2, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
gtk_grid_attach (grid, widget, 0, 1, 1, 1);
// dform->password_label = widget;
// ----------------------------------------------------
// proxy
// ug_proxy_widget_init (&dform->proxy_dform);
if (proxy) {
widget = proxy->self;
gtk_box_pack_start (top_vbox, widget, FALSE, FALSE, 2);
}
}
int main (int argc, char *argv[])
{
/* GUI widgets */
GtkWidget *window;
GtkWidget *align;
GtkWidget *expander;
GtkWidget *label;
GtkWidget *radio1, *radio2;
GtkWidget *check;
GtkWidget *button;
GtkWidget *entry;
GtkTooltips *tooltip;
/* Packing boxes */
GtkWidget *vbMain; /* main vertical box */
GtkWidget *hbox1, *vbox1, *vbox2; /* username/password */
GtkWidget *hbox2, *vbox3, *hbMac; /* login options */
GtkWidget *hbox3; /* cancel/login buttons */
GtkWidget *hbox9; /* show pwd & gtl */
/* Initialize multihreading and gtk functions */
g_thread_init (NULL);
gdk_threads_init ();
gdk_threads_enter ();
gtk_init (&argc, &argv);
/* Create main window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW(window), "Glawn");
gtk_window_set_resizable (GTK_WINDOW(window), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
g_signal_connect (window, "destroy", G_CALLBACK(quit_glawn), NULL);
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file ("./icons/glawn-icon.png", NULL);
gtk_window_set_icon (GTK_WINDOW(window), pixbuf);
/* Create pack boxes */
vbMain= gtk_vbox_new (FALSE, 3);
vbox1 = gtk_vbox_new (FALSE, 0);
vbox2 = gtk_vbox_new (FALSE, 3);
vbox3 = gtk_vbox_new (FALSE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
hbox2 = gtk_hbox_new (FALSE, 0);
hbox3 = gtk_hbox_new (FALSE, 0);
hbMac = gtk_hbox_new (FALSE, 0);
hbox9 = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbMain);
/* Username entry label */
label = gtk_label_new ("GT Account : ");
gtk_misc_set_alignment ((GtkMisc *)label, 0, 0);
gtk_box_pack_start (GTK_BOX(vbox1), label, TRUE, FALSE, 0);
/* Password entry label */
label = gtk_label_new ("Password : "******"");
gtk_box_pack_start (GTK_BOX(vbox1),label,FALSE, FALSE, 2);
/* Username entry field */
data.nameEntry = entry = gtk_entry_new_with_max_length (50);
gtk_entry_set_width_chars (GTK_ENTRY(entry), 25);
g_signal_connect (entry, "activate", G_CALLBACK(login), NULL);
gtk_box_pack_start (GTK_BOX(vbox2), entry, FALSE, FALSE, 0);
/* Password entry field */
data.pwdEntry = entry = gtk_entry_new_with_max_length(50);
gtk_entry_set_visibility (GTK_ENTRY(entry), FALSE);
g_signal_connect (entry, "activate", G_CALLBACK(login), NULL);
gtk_box_pack_start (GTK_BOX(vbox2), entry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(hbox1), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX(vbMain), hbox1, FALSE, FALSE, 0);
/* Show password checkbox */
data.pwdCBox = check = gtk_check_button_new_with_mnemonic ("_Show password");
g_signal_connect (check, "toggled", G_CALLBACK(show_pass), GTK_ENTRY(entry));
gtk_box_pack_start (GTK_BOX(hbox9), check, FALSE, FALSE, 0);
/* Location checkbox */
data.locCBox = check = gtk_check_button_new_with_mnemonic ("_GTL");
tooltip = gtk_tooltips_new ();
gtk_tooltips_set_tip (tooltip, check, "Enable Georgia Tech-Lorraine support", NULL);
gtk_box_pack_start (GTK_BOX(hbox9), check, FALSE, FALSE, 9);
gtk_box_pack_start (GTK_BOX(vbox2), hbox9, FALSE, FALSE, 0);
/* Options expander */
expander = gtk_expander_new_with_mnemonic ("_Options");
gtk_box_pack_start (GTK_BOX(vbMain), expander, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER(expander), hbox2);
/* Left indent alignment for expander */
align = gtk_alignment_new (0, 0, 1 , 1);
gtk_widget_set_size_request (align, 17, 0);
gtk_box_pack_start (GTK_BOX(hbox2), align, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(hbox2), vbox3, FALSE, FALSE, 0);
/* ISS checkbox */
data.issCBox = check = gtk_check_button_new_with_mnemonic
("_Enable Inbound Service Security");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check), TRUE);
gtk_box_pack_start (GTK_BOX(vbox3), check, FALSE, FALSE, 0);
tooltip = gtk_tooltips_new ();
gtk_tooltips_set_tip (tooltip, check, "When turned on,"
" devices outside of the LAWN network are blocked from "
"connecting to services running on your device.", NULL);
/* Login this device radio */
data.radio_this = radio1 = gtk_radio_button_new_with_mnemonic_from_widget
(NULL, "Lo_gin this device");
g_signal_connect (radio1, "toggled", G_CALLBACK(mac_switch), (gpointer) FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(radio1), TRUE);
gtk_box_pack_start (GTK_BOX(vbox3), radio1, FALSE, FALSE, 0);
/* Login other device radio */
data.radio_other = radio2 = gtk_radio_button_new_with_mnemonic_from_widget
(GTK_RADIO_BUTTON(radio1), "Login a _different device");
g_signal_connect (radio2, "toggled", G_CALLBACK(mac_switch), (gpointer) TRUE);
gtk_box_pack_start (GTK_BOX(vbox3), radio2, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltip, radio2, "You can authenticate other"
" devices currently on LAWN. The login will last as long as the"
" device maintains a valid DHCP lease. You accept responsibility"
" for all usage associated with this device.", NULL);
/* MAC address label and entry */
label = gtk_label_new (" MAC Address : "); // more elegance
data.macEntry = entry = gtk_entry_new_with_max_length (12);
gtk_entry_set_width_chars (GTK_ENTRY(entry), 18);
gtk_widget_set_sensitive (entry, FALSE);
gtk_box_pack_start (GTK_BOX(hbMac), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(hbMac), entry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(vbox3), hbMac, FALSE, FALSE, 0);
/* Login button */
data.login = button = gtk_button_new_with_mnemonic (" _Login ");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK(login), NULL);
gtk_box_pack_end (GTK_BOX(hbox3), button, FALSE, FALSE, 5);
/* Logout button */
data.logout = button = gtk_button_new_with_mnemonic ("Logou_t");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK(logout), NULL);
gtk_box_pack_end (GTK_BOX(hbox3), button, FALSE, FALSE, 0);
/* Spinner */
data.spinner = gtk_spinner_new ();
gtk_box_pack_start (GTK_BOX(hbox3), data.spinner, FALSE, FALSE, 2);
/* Statusbar */
data.status = label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX(hbox3), label, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX(vbMain), hbox3, FALSE, FALSE, 0);
/* Display window */
gtk_widget_show_all (window);
/* Ascii art */
g_printf ("\n===========================\n"
" Welcome to Glawn!\n"
"===========================\n\n");
/*Load_settings */
init_mutex();
load_settings();
update_gui (LOAD_INI_START);
// send curl request for status
update_gui (CHECK_STAT_START);
g_thread_create((GThreadFunc)check_status, NULL, FALSE, NULL);
g_timeout_add_seconds_full(G_PRIORITY_LOW, 1, init_check_status, NULL, NULL);
/* Start main loop */
gtk_main ();
gdk_threads_leave ();
return 0;
}
static void
mate_password_dialog_init (MatePasswordDialog *password_dialog)
{
MatePasswordDialogDetails *priv;
GtkDialog *dialog = GTK_DIALOG (password_dialog);
GtkWindow *window = GTK_WINDOW (password_dialog);
GtkWidget *hbox, *main_vbox, *vbox, *icon;
GSList *group;
priv = password_dialog->details = MATE_PASSWORD_DIALOG_GET_PRIVATE (password_dialog);
priv->show_username = TRUE;
priv->show_password = TRUE;
/* Set the dialog up with HIG properties */
gtk_dialog_set_has_separator (dialog, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (GTK_BOX (dialog->vbox), 2); /* 2 * 5 + 2 = 12 */
gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 5);
gtk_box_set_spacing (GTK_BOX (dialog->action_area), 6);
gtk_window_set_resizable (window, FALSE);
gtk_window_set_icon_name (window, GTK_STOCK_DIALOG_AUTHENTICATION);
gtk_dialog_add_buttons (dialog,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("Co_nnect"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (dialog, GTK_RESPONSE_OK);
/* Build contents */
hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (dialog->vbox), hbox, TRUE, TRUE, 0);
icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (icon), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
main_vbox = gtk_vbox_new (FALSE, 18);
gtk_box_pack_start (GTK_BOX (hbox), main_vbox, TRUE, TRUE, 0);
priv->message_label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (priv->message_label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (priv->message_label), TRUE);
gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (priv->message_label),
FALSE, FALSE, 0);
gtk_widget_set_no_show_all (priv->message_label, TRUE);
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
/* the radio buttons for anonymous login */
priv->radio_vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), priv->radio_vbox,
FALSE, FALSE, 0);
gtk_widget_set_no_show_all (priv->radio_vbox, TRUE);
priv->connect_with_no_userpass_button =
gtk_radio_button_new_with_mnemonic (NULL, _("Connect _anonymously"));
group = gtk_radio_button_get_group (
GTK_RADIO_BUTTON (priv->connect_with_no_userpass_button));
priv->connect_with_userpass_button =
gtk_radio_button_new_with_mnemonic (
group, _("Connect as u_ser:"));
g_signal_connect (priv->connect_with_no_userpass_button, "toggled",
G_CALLBACK (userpass_radio_button_toggled), password_dialog);
g_signal_connect (priv->connect_with_userpass_button, "toggled",
G_CALLBACK (userpass_radio_button_toggled), password_dialog);
gtk_box_pack_start (GTK_BOX (priv->radio_vbox),
priv->connect_with_no_userpass_button,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (priv->radio_vbox),
priv->connect_with_userpass_button,
FALSE, FALSE, 0);
gtk_widget_show (priv->connect_with_no_userpass_button);
gtk_widget_show (priv->connect_with_userpass_button);
/* The table that holds the entries */
priv->table_alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
gtk_box_pack_start (GTK_BOX (vbox), priv->table_alignment,
FALSE, FALSE, 0);
priv->table = gtk_table_new (3, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (priv->table), 12);
gtk_table_set_row_spacings (GTK_TABLE (priv->table), 6);
gtk_container_add (GTK_CONTAINER (priv->table_alignment), priv->table);
priv->username_entry = g_object_ref_sink (gtk_entry_new ());
priv->domain_entry = g_object_ref_sink (gtk_entry_new ());
priv->password_entry = g_object_ref_sink (gtk_entry_new ());
gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry), FALSE);
priv->new_password_entry = g_object_ref_sink (gtk_entry_new ());
gtk_entry_set_visibility (GTK_ENTRY (priv->new_password_entry), FALSE);
priv->confirm_new_password_entry = g_object_ref_sink (gtk_entry_new ());
gtk_entry_set_visibility (GTK_ENTRY (priv->confirm_new_password_entry), FALSE);
g_signal_connect (priv->username_entry, "activate",
G_CALLBACK (username_entry_activate), password_dialog);
g_signal_connect (priv->domain_entry, "activate",
G_CALLBACK (domain_entry_activate), password_dialog);
g_signal_connect (priv->password_entry, "activate",
G_CALLBACK (password_entry_activate), password_dialog);
g_signal_connect (priv->new_password_entry, "activate",
G_CALLBACK (new_password_entry_activate), password_dialog);
g_signal_connect_swapped (priv->confirm_new_password_entry, "activate",
G_CALLBACK (gtk_window_activate_default),
password_dialog);
g_signal_connect (priv->new_password_entry, "changed",
G_CALLBACK (new_password_entries_changed), password_dialog);
g_signal_connect (priv->confirm_new_password_entry, "changed",
G_CALLBACK (new_password_entries_changed), password_dialog);
priv->quality_meter = g_object_ref_sink (gtk_progress_bar_new ());
update_entries_table (password_dialog);
gtk_widget_show_all (hbox);
priv->remember_box = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), priv->remember_box,
FALSE, FALSE, 0);
priv->remember_buttons[0] =
gtk_radio_button_new_with_mnemonic (NULL, _("_Forget password immediately"));
g_signal_connect (priv->remember_buttons[0], "toggled",
G_CALLBACK (remember_button_toggled), password_dialog);
priv->remember_buttons[1] =
gtk_radio_button_new_with_mnemonic_from_widget (
GTK_RADIO_BUTTON (priv->remember_buttons[0]),
_("_Remember password until you logout"));
g_signal_connect (priv->remember_buttons[1], "toggled",
G_CALLBACK (remember_button_toggled), password_dialog);
priv->remember_buttons[2] =
gtk_radio_button_new_with_mnemonic_from_widget (
GTK_RADIO_BUTTON (priv->remember_buttons[0]),
_("_Remember forever"));
g_signal_connect (priv->remember_buttons[2], "toggled",
G_CALLBACK (remember_button_toggled), password_dialog);
gtk_box_pack_start (GTK_BOX (priv->remember_box), priv->remember_buttons[0],
FALSE, FALSE, 0);
gtk_widget_show (priv->remember_buttons[0]);
gtk_box_pack_start (GTK_BOX (priv->remember_box), priv->remember_buttons[1],
FALSE, FALSE, 0);
gtk_widget_show (priv->remember_buttons[1]);
gtk_box_pack_start (GTK_BOX (priv->remember_box), priv->remember_buttons[2],
FALSE, FALSE, 0);
gtk_widget_show (priv->remember_buttons[2]);
}
static SettingsDialog_t*
create_settings_dialog(void)
{
SettingsDialog_t *data = g_new(SettingsDialog_t, 1);
GtkWidget *table, *view, *frame, *hbox, *label, *swin;
DefaultDialog_t *dialog;
dialog = data->dialog = make_default_dialog(_("Settings for this Mapfile"));
default_dialog_set_ok_cb(dialog, settings_ok_cb, (gpointer) data);
table = default_dialog_add_table(dialog, 9, 2);
create_label_in_table(table, 0, 0, _("Filename:"));
data->filename = create_label_in_table(table, 0, 1, "");
create_label_in_table(table, 1, 0, _("Image name:"));
data->imagename = browse_widget_new(_("Select Image File"));
gtk_table_attach_defaults(GTK_TABLE(table), data->imagename->hbox, 1, 2,
1, 2);
label = create_label_in_table(table, 2, 0, _("_Title:"));
data->title = create_entry_in_table(table, label, 2, 1);
label = create_label_in_table(table, 3, 0, _("Aut_hor:"));
data->author = create_entry_in_table(table, label, 3, 1);
label = create_label_in_table(table, 4, 0, _("Default _URL:"));
data->default_url = create_entry_in_table(table, label, 4, 1);
label = create_label_in_table(table, 5, 0, _("_Description:"));
data->description = gtk_text_buffer_new(NULL);
view = gtk_text_view_new_with_buffer(data->description);
gtk_widget_set_size_request(view, -1, 128);
gtk_widget_show(view);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), view);
swin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin),
GTK_SHADOW_IN);
gtk_table_attach(GTK_TABLE(table), swin, 1, 2, 5, 8,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_widget_show(swin);
gtk_container_add(GTK_CONTAINER(swin), view);
frame = gimp_frame_new(_("Map File Format"));
gtk_widget_show(frame);
gtk_table_attach_defaults(GTK_TABLE(table), frame, 0, 2, 9, 10);
hbox = gtk_hbox_new(FALSE, 6);
gtk_container_add(GTK_CONTAINER(frame), hbox);
gtk_widget_show(hbox);
data->ncsa = gtk_radio_button_new_with_mnemonic_from_widget(NULL, "_NCSA");
g_signal_connect(data->ncsa, "toggled",
G_CALLBACK(type_toggled_cb), (gpointer) NCSA);
gtk_box_pack_start(GTK_BOX(hbox), data->ncsa, FALSE, FALSE, 0);
gtk_widget_show(data->ncsa);
data->cern = gtk_radio_button_new_with_mnemonic_from_widget(
GTK_RADIO_BUTTON(data->ncsa), "C_ERN");
g_signal_connect(data->cern, "toggled",
G_CALLBACK(type_toggled_cb), (gpointer) CERN);
gtk_box_pack_start(GTK_BOX(hbox), data->cern, FALSE, FALSE, 0);
gtk_widget_show(data->cern);
data->csim = gtk_radio_button_new_with_mnemonic_from_widget(
GTK_RADIO_BUTTON(data->cern), "C_SIM");
g_signal_connect(data->csim, "toggled",
G_CALLBACK(type_toggled_cb), (gpointer) CSIM);
gtk_box_pack_start(GTK_BOX(hbox), data->csim, FALSE, FALSE, 0);
gtk_widget_show(data->csim);
return data;
}
static GridDialog_t*
create_grid_settings_dialog(void)
{
GridDialog_t *data = g_new(GridDialog_t, 1);
DefaultDialog_t *dialog;
GtkWidget *main_table, *table, *label;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *chain_button;
data->dialog = dialog = make_default_dialog(_("Grid Settings"));
default_dialog_set_ok_cb(dialog, grid_settings_ok_cb, (gpointer) data);
main_table = default_dialog_add_table(dialog, 4, 2);
data->snap = gtk_check_button_new_with_mnemonic(_("_Snap-to grid enabled"));
g_signal_connect(data->snap, "toggled",
G_CALLBACK (snap_toggled_cb), data);
gtk_table_attach_defaults(GTK_TABLE(main_table), data->snap, 0, 1, 0, 1);
gtk_widget_show(data->snap);
data->type_frame = frame = gimp_frame_new(_("Grid Visibility and Type"));
gtk_widget_show(frame);
gtk_table_attach_defaults(GTK_TABLE(main_table), frame, 0, 2, 1, 2);
hbox = gtk_hbox_new(FALSE, 6);
gtk_container_add(GTK_CONTAINER(frame), hbox);
gtk_widget_show(hbox);
button = gtk_radio_button_new_with_mnemonic_from_widget(NULL, _("_Hidden"));
data->hidden = button;
g_signal_connect(button, "toggled",
G_CALLBACK (type_toggled_cb), (gpointer) GRID_HIDDEN);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = gtk_radio_button_new_with_mnemonic_from_widget(
GTK_RADIO_BUTTON(button), _("_Lines"));
data->lines = button;
g_signal_connect(button, "toggled",
G_CALLBACK (type_toggled_cb), (gpointer) GRID_LINES);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = gtk_radio_button_new_with_mnemonic_from_widget(
GTK_RADIO_BUTTON(button), _("C_rosses"));
data->crosses = button;
g_signal_connect(button, "toggled",
G_CALLBACK (type_toggled_cb),
(gpointer) GRID_CROSSES);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
data->granularity_frame = frame = gimp_frame_new(_("Grid Granularity"));
gtk_table_attach_defaults(GTK_TABLE(main_table), frame, 0, 1, 2, 3);
table = gtk_table_new(2, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 6);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_add(GTK_CONTAINER(frame), table);
label = create_label_in_table(table, 0, 0, _("_Width"));
data->width = create_spin_button_in_table(table, label, 0, 1, 15, 1, 100);
g_signal_connect(data->width, "value-changed",
G_CALLBACK (width_changed_cb), (gpointer) data);
create_label_in_table(table, 0, 3, _("pixels"));
label = create_label_in_table(table, 1, 0, _("_Height"));
data->height = create_spin_button_in_table(table, label, 1, 1, 15, 1, 100);
g_signal_connect(data->height, "value-changed",
G_CALLBACK (height_changed_cb), (gpointer) data);
create_label_in_table(table, 1, 3, _("pixels"));
chain_button = gimp_chain_button_new(GIMP_CHAIN_RIGHT);
data->chain_width_height = chain_button;
gtk_table_attach_defaults(GTK_TABLE(table), chain_button, 2, 3, 0, 2);
gtk_widget_show(chain_button);
gtk_widget_show(table);
gtk_widget_show(frame);
data->offset_frame = frame = gimp_frame_new(_("Grid Offset"));
gtk_table_attach_defaults(GTK_TABLE(main_table), frame, 1, 2, 2, 3);
table = gtk_table_new(2, 3, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 6);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_add(GTK_CONTAINER(frame), table);
label = create_label_in_table(table, 0, 2, _("pixels from l_eft"));
data->left = create_spin_button_in_table(table, label, 0, 0, 0, 0, 100);
g_signal_connect(data->left, "value-changed",
G_CALLBACK (left_changed_cb), (gpointer) data);
label = create_label_in_table(table, 1, 2, _("pixels from _top"));
data->top = create_spin_button_in_table(table, label, 1, 0, 0, 0, 100);
g_signal_connect(data->top, "value-changed",
G_CALLBACK (top_changed_cb), (gpointer) data);
chain_button = gimp_chain_button_new(GIMP_CHAIN_RIGHT);
data->chain_left_top = chain_button;
gtk_table_attach_defaults(GTK_TABLE(table), chain_button, 1, 2, 0, 2);
gtk_widget_show(chain_button);
data->preview = create_check_button_in_table(main_table, 3, 0,
_("_Preview"));
g_signal_connect(data->preview, "toggled",
G_CALLBACK (toggle_preview_cb), (gpointer) data);
gtk_widget_show(data->preview);
snap_toggled_cb(data->snap, data);
gtk_widget_show(table);
gtk_widget_show(frame);
return data;
}
void show_export_crl_dialog(FRONTEND * fe) {
/* export dialog ->
* dialog (OK, cancel),
* filename entry & browse,
* format choice (DER, text)
*/
GtkWidget *dlg;
GtkEntry *filename_entry;
GtkButton *browse_button;
GtkRadioButton *rb_text, *rb_der;
GtkBox *box;
gint result;
dlg =
gtk_dialog_new_with_buttons("Export CRL", GTK_WINDOW(fe->mainWindow),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
box = GTK_BOX(gtk_hbox_new(0, 5));
gtk_box_pack_start(box, gtk_label_new("Export to"), FALSE, FALSE, 0);
filename_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(filename_entry), FALSE, FALSE, 0);
browse_button = GTK_BUTTON(gtk_button_new_with_mnemonic("_Browse..."));
gtk_box_pack_start(box, GTK_WIDGET(browse_button), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(browse_button), "clicked",
G_CALLBACK(on_browse_button_clicked), dlg);
/* don't ref the entry -- same lifetime */
g_object_set_data_full(G_OBJECT(browse_button), "entry", filename_entry, NULL);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg)->vbox), GTK_WIDGET(box), FALSE,
FALSE, 0);
rb_der =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_mnemonic
(NULL, "_DER (Binary)"));
rb_text =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_mnemonic_from_widget
(rb_der, "_PEM (Text)"));
box = GTK_BOX(gtk_hbox_new(0, 5));
gtk_box_pack_start(box, gtk_label_new("Format:"), FALSE, FALSE, 0);
gtk_box_pack_start(box, GTK_WIDGET(rb_der), FALSE, FALSE, 0);
gtk_box_pack_start(box, GTK_WIDGET(rb_text), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg)->vbox), GTK_WIDGET(box), FALSE,
FALSE, 0);
gtk_widget_show_all(GTK_WIDGET(GTK_DIALOG(dlg)->vbox));
result = gtk_dialog_run(GTK_DIALOG(dlg));
if (result == GTK_RESPONSE_ACCEPT) {
void *buf;
int status;
int len;
gboolean text_format;
CRYPT_CERTFORMAT_TYPE fmt;
FILE *f;
gchar *filename;
CRYPT_CERTIFICATE crl;
CRYPT_CONTEXT key;
gchar *password;
/* get password */
password = do_get_password(GTK_WINDOW(dlg));
if (password == NULL) {
/* cancelled? */
goto cleanup;
}
/* sign */
status = lmz_ca_get_signing_key(fe->db, password, &key);
g_free(password); /* dynamic */
if (status == CRYPT_ERROR_WRONGKEY) {
show_error_dialog(GTK_WINDOW(dlg), "Wrong password");
goto cleanup;
}
else if (!cryptStatusOK(status)) {
show_error_dialog(GTK_WINDOW(dlg),
"Error getting signing key (cryptlib error %d)",
status);
goto cleanup;
}
status = lmz_ca_gen_crl(fe->db, &crl);
if (cryptStatusOK(status)) {
/* sign it */
status = cryptSignCert(crl, key);
if (cryptStatusOK(status)) {
text_format =
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(rb_text));
fmt =
text_format ? CRYPT_CERTFORMAT_TEXT_CERTIFICATE :
CRYPT_CERTFORMAT_CERTIFICATE;
status = cryptExportCert(NULL, 0, &len, fmt, crl);
buf = malloc(len);
status = cryptExportCert(buf, len, &len, fmt, crl);
if (cryptStatusOK(status)) {
filename =
g_filename_from_utf8(gtk_entry_get_text(filename_entry),
-1, NULL, NULL, NULL);
if (filename != NULL) {
f = fopen(filename, "w");
if (f != NULL) {
if (fwrite(buf, len, 1, f) != 1) {
show_error_dialog(NULL,
"error fully writing data");
}
fclose(f);
}
else {
show_error_dialog(NULL,
"error opening file for writing");
}
g_free(filename);
}
else {
show_error_dialog(NULL, "filename conversion error");
}
free(buf);
}
}
else {
show_error_dialog(NULL, "error signing crl (cl error %d)",
status);
}
cryptDestroyCert(crl);
}
else {
show_error_dialog(NULL, "error generating crl (cl error %d)",
status);
}
cryptDestroyContext(key);
}
cleanup:
gtk_widget_destroy(dlg);
}
GtkWidget *plugin_configure(GtkDialog *dialog)
{
GtkWidget *vbox, *check_openuri, *check_tasks, *check_systray;
GtkWidget *check_doclist, *vbox_doclist, *frame_doclist;
GtkWidget *radio_doclist_name, *radio_doclist_occurrence;
GtkWidget *check_bookmarklist, *check_markword, *frame_tasks, *vbox_tasks;
GtkWidget *check_tasks_scan_mode, *entry_tasks_tokens, *label_tasks_tokens, *tokens_hbox;
GtkWidget *check_blanklines, *check_xmltagging;
vbox = gtk_vbox_new(FALSE, 6);
check_doclist = gtk_check_button_new_with_label(
_("Show toolbar item to show a list of currently open documents"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_doclist), ao_info->enable_doclist);
g_signal_connect(check_doclist, "toggled", G_CALLBACK(ao_configure_doclist_toggled_cb), dialog);
radio_doclist_name = gtk_radio_button_new_with_mnemonic(NULL, _("Sort documents by _name"));
ui_widget_set_tooltip_text(radio_doclist_name,
_("Sort the documents in the list by their filename"));
radio_doclist_occurrence = gtk_radio_button_new_with_mnemonic_from_widget(
GTK_RADIO_BUTTON(radio_doclist_name), _("Sort documents by _occurrence"));
ui_widget_set_tooltip_text(radio_doclist_name,
_("Sort the documents in the order of the document tabs"));
if (ao_info->doclist_sort_mode == DOCLIST_SORT_BY_NAME)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_doclist_name), TRUE);
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_doclist_occurrence), TRUE);
vbox_doclist = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_doclist), radio_doclist_name, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox_doclist), radio_doclist_occurrence, TRUE, TRUE, 3);
frame_doclist = gtk_frame_new(NULL);
gtk_frame_set_label_widget(GTK_FRAME(frame_doclist), check_doclist);
gtk_container_add(GTK_CONTAINER(frame_doclist), vbox_doclist);
gtk_box_pack_start(GTK_BOX(vbox), frame_doclist, FALSE, FALSE, 3);
check_openuri = gtk_check_button_new_with_label(
/* TODO fix the string */
_("Show a 'Open URI' menu item in the editor menu"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_openuri),
ao_info->enable_openuri);
gtk_box_pack_start(GTK_BOX(vbox), check_openuri, FALSE, FALSE, 3);
check_tasks = gtk_check_button_new_with_label(
_("Show available Tasks in the Messages Window"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_tasks),
ao_info->enable_tasks);
g_signal_connect(check_tasks, "toggled", G_CALLBACK(ao_configure_tasks_toggled_cb), dialog);
check_tasks_scan_mode = gtk_check_button_new_with_label(
_("Show tasks of all documents"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_tasks_scan_mode),
ao_info->tasks_scan_all_documents);
ui_widget_set_tooltip_text(check_tasks_scan_mode,
_("Whether to show the tasks of all open documents in the list or only those of the current document."));
entry_tasks_tokens = gtk_entry_new();
if (NZV(ao_info->tasks_token_list))
gtk_entry_set_text(GTK_ENTRY(entry_tasks_tokens), ao_info->tasks_token_list);
ui_entry_add_clear_icon(GTK_ENTRY(entry_tasks_tokens));
ui_widget_set_tooltip_text(entry_tasks_tokens,
_("Specify a semicolon separated list of search tokens."));
label_tasks_tokens = gtk_label_new_with_mnemonic(_("Search tokens:"));
gtk_label_set_mnemonic_widget(GTK_LABEL(label_tasks_tokens), entry_tasks_tokens);
tokens_hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(tokens_hbox), label_tasks_tokens, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(tokens_hbox), entry_tasks_tokens, TRUE, TRUE, 3);
vbox_tasks = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_tasks), check_tasks_scan_mode, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox_tasks), tokens_hbox, TRUE, TRUE, 3);
frame_tasks = gtk_frame_new(NULL);
gtk_frame_set_label_widget(GTK_FRAME(frame_tasks), check_tasks);
gtk_container_add(GTK_CONTAINER(frame_tasks), vbox_tasks);
gtk_box_pack_start(GTK_BOX(vbox), frame_tasks, FALSE, FALSE, 3);
check_systray = gtk_check_button_new_with_label(
_("Show status icon in the Notification Area"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_systray),
ao_info->enable_systray);
gtk_box_pack_start(GTK_BOX(vbox), check_systray, FALSE, FALSE, 3);
check_bookmarklist = gtk_check_button_new_with_label(
_("Show defined bookmarks (marked lines) in the sidebar"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_bookmarklist),
ao_info->enable_bookmarklist);
gtk_box_pack_start(GTK_BOX(vbox), check_bookmarklist, FALSE, FALSE, 3);
check_markword = gtk_check_button_new_with_label(
_("Mark all occurrences of a word when double-clicking it"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_markword),
ao_info->enable_markword);
gtk_box_pack_start(GTK_BOX(vbox), check_markword, FALSE, FALSE, 3);
check_blanklines = gtk_check_button_new_with_label(
_("Strip trailing blank lines"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_blanklines),
ao_info->strip_trailing_blank_lines);
gtk_box_pack_start(GTK_BOX(vbox), check_blanklines, FALSE, FALSE, 3);
check_xmltagging = gtk_check_button_new_with_label(
_("XML tagging for selection"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_xmltagging),
ao_info->enable_xmltagging);
gtk_box_pack_start(GTK_BOX(vbox), check_xmltagging, FALSE, FALSE, 3);
g_object_set_data(G_OBJECT(dialog), "check_doclist", check_doclist);
g_object_set_data(G_OBJECT(dialog), "radio_doclist_name", radio_doclist_name);
g_object_set_data(G_OBJECT(dialog), "radio_doclist_occurrence", radio_doclist_occurrence);
g_object_set_data(G_OBJECT(dialog), "check_openuri", check_openuri);
g_object_set_data(G_OBJECT(dialog), "check_tasks", check_tasks);
g_object_set_data(G_OBJECT(dialog), "entry_tasks_tokens", entry_tasks_tokens);
g_object_set_data(G_OBJECT(dialog), "check_tasks_scan_mode", check_tasks_scan_mode);
g_object_set_data(G_OBJECT(dialog), "check_systray", check_systray);
g_object_set_data(G_OBJECT(dialog), "check_bookmarklist", check_bookmarklist);
g_object_set_data(G_OBJECT(dialog), "check_markword", check_markword);
g_object_set_data(G_OBJECT(dialog), "check_blanklines", check_blanklines);
g_object_set_data(G_OBJECT(dialog), "check_xmltagging", check_xmltagging);
g_signal_connect(dialog, "response", G_CALLBACK(ao_configure_response_cb), NULL);
ao_configure_tasks_toggled_cb(GTK_TOGGLE_BUTTON(check_tasks), dialog);
ao_configure_doclist_toggled_cb(GTK_TOGGLE_BUTTON(check_doclist), dialog);
gtk_widget_show_all(vbox);
#if ! GTK_CHECK_VERSION(2, 10, 0)
gtk_widget_hide(check_systray);
#endif
return vbox;
}
int
DialogRadio(GtkWidget *parent, const char *title, const char *caption, struct narray *array, int *r, int *x, int *y)
{
GtkWidget *dlg, *btn, **btn_ary;
GtkBox *vbox;
int data;
gint res_id;
char **d;
int i, anum;
d = arraydata(array);
anum = arraynum(array);
btn_ary = g_malloc(anum * sizeof(*btn_ary));
if (btn_ary == NULL)
return IDCANCEL;
dlg = gtk_dialog_new_with_buttons(title,
GTK_WINDOW(parent),
#if GTK_CHECK_VERSION(3, 12, 0) && USE_HEADER_BAR
GTK_DIALOG_USE_HEADER_BAR |
#endif
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK);
gtk_window_set_resizable(GTK_WINDOW(dlg), FALSE);
vbox = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg)));
if (caption) {
GtkWidget *label;
label = gtk_label_new(caption);
gtk_box_pack_start(vbox, label, FALSE, FALSE, 5);
}
btn = NULL;
for (i = 0; i < anum; i++) {
btn = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(btn), d[i]);
gtk_box_pack_start(vbox, btn, FALSE, FALSE, 2);
btn_ary[i] = btn;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn), i == *r);
}
set_dialog_position(dlg, x, y);
gtk_widget_show_all(dlg);
res_id = ndialog_run(dlg);
switch (res_id) {
case GTK_RESPONSE_OK:
*r = -1;
for (i = 0; i < anum; i++) {
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(btn_ary[i]))) {
*r = i;
break;
}
}
data = IDOK;
break;
default:
data = IDCANCEL;
break;
}
g_free(btn_ary);
get_dialog_position(dlg, x, y);
gtk_widget_destroy(dlg);
reset_event();
return data;
}
void CUIHandler::ShowSettingsDlg(void)
{
GtkWidget* settingsDlg;
GtkWidget* dialog_vbox1;
GtkWidget* frame4;
GtkWidget* alignment4;
GtkWidget* vbox2;
GtkWidget* radiobuttonBt;
GtkWidget* hbox2;
GtkWidget* radiobuttonInet;
GtkWidget* label5;
GtkWidget* inetPort;
GtkWidget* label4;
GtkWidget* dialog_action_area1;
CUserSettings crtSettings = pSmartEngine->GetSettings();
settingsDlg = gtk_dialog_new_with_buttons("SmartCam Preferences",
GTK_WINDOW(pSmartEngine->GetMainWindow()),
GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
gtk_window_set_type_hint(GTK_WINDOW (settingsDlg), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (settingsDlg)->vbox;
gtk_widget_show (dialog_vbox1);
frame4 = gtk_frame_new (NULL);
gtk_widget_show (frame4);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), frame4, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame4), GTK_SHADOW_IN);
alignment4 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment4);
gtk_container_add (GTK_CONTAINER (frame4), alignment4);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment4), 10, 10, 12, 12);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_container_add (GTK_CONTAINER (alignment4), vbox2);
radiobuttonBt = gtk_radio_button_new_with_mnemonic(NULL, "Bluetooth");
gtk_box_pack_start(GTK_BOX (vbox2), radiobuttonBt, FALSE, FALSE, 0);
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox2);
gtk_box_pack_start(GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
radiobuttonInet = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(radiobuttonBt), "TCP/IP (WiFi)");
gtk_box_pack_start(GTK_BOX (hbox2), radiobuttonInet, FALSE, FALSE, 0);
label5 = gtk_label_new(" Port: ");
gtk_box_pack_start(GTK_BOX(hbox2), label5, FALSE, FALSE, 0);
inetPort = gtk_spin_button_new_with_range(1025, 65536, 1);
gtk_box_pack_start(GTK_BOX(hbox2), inetPort, TRUE, TRUE, 0);
label4 = gtk_label_new("Connection");
gtk_frame_set_label_widget(GTK_FRAME(frame4), label4);
gtk_label_set_use_markup(GTK_LABEL(label4), TRUE);
dialog_action_area1 = GTK_DIALOG(settingsDlg)->action_area;
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
g_signal_connect(G_OBJECT(radiobuttonBt), "toggled", G_CALLBACK(OnRadiobuttonBluetooth), inetPort);
if(crtSettings.connectionType == CONN_BLUETOOTH)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonBt), TRUE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonInet), FALSE);
g_object_set(G_OBJECT(inetPort), "sensitive", FALSE, NULL);
}
else
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonBt), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonInet), TRUE);
g_object_set(G_OBJECT(inetPort), "sensitive", TRUE, NULL);
}
gtk_spin_button_set_value(GTK_SPIN_BUTTON(inetPort), crtSettings.inetPort);
gtk_widget_show_all(settingsDlg);
if(gtk_dialog_run(GTK_DIALOG(settingsDlg)) == GTK_RESPONSE_OK)
{
CUserSettings newSettings = crtSettings;
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobuttonBt)))
{
newSettings.connectionType = CONN_BLUETOOTH;
}
else
{
newSettings.connectionType = CONN_INET;
newSettings.inetPort = gtk_spin_button_get_value(GTK_SPIN_BUTTON(inetPort));
}
pSmartEngine->SaveSettings(newSettings);
}
gtk_widget_destroy(settingsDlg);
}
void
dialog_graphical_options_new (GtkWindow * parent)
{
int i;
DialogGraphicalOptions dlg;
char *string_animation[3]
= { gettext ("_No animation"), gettext ("_Fast"), gettext ("_Detailed") };
char *string_options[sys->nt + 8];
char *string_channels[sys->n + 1];
for (i = 0; i <= sys->n; ++i)
string_channels[i] = sys->channel[i].name;
string_graphical_options (string_options, sys);
dlg.button_adjust = (GtkCheckButton *) gtk_check_button_new_with_mnemonic
(gettext ("_Manual adjust"));
g_signal_connect_swapped (dlg.button_adjust, "clicked",
(void (*)()) dialog_graphical_options_actualize,
&dlg);
dlg.button_grid = (GtkCheckButton *) gtk_check_button_new_with_mnemonic
(gettext ("_Show grid"));
dlg.label_profile_xmax = (GtkLabel *) gtk_label_new (gettext ("Maximum"));
dlg.entry_profile_xmax = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.label_profile_xmin = (GtkLabel *) gtk_label_new (gettext ("Minimum"));
dlg.entry_profile_xmin = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.table_profile_x = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach
(dlg.table_profile_x, GTK_WIDGET (dlg.label_profile_xmax), 0, 0, 1, 1);
gtk_grid_attach
(dlg.table_profile_x, GTK_WIDGET (dlg.entry_profile_xmax), 1, 0, 1, 1);
gtk_grid_attach
(dlg.table_profile_x, GTK_WIDGET (dlg.label_profile_xmin), 0, 1, 1, 1);
gtk_grid_attach
(dlg.table_profile_x, GTK_WIDGET (dlg.entry_profile_xmin), 1, 1, 1, 1);
dlg.frame_profile_x = (GtkFrame *) gtk_frame_new (gettext ("Position"));
gtk_container_add
(GTK_CONTAINER (dlg.frame_profile_x), GTK_WIDGET (dlg.table_profile_x));
dlg.combo_profile_y =
jbw_combo_box_new_with_strings (string_options, 8 + sys->nt);
dlg.label_profile_ymax = (GtkLabel *) gtk_label_new (gettext ("Maximum"));
dlg.entry_profile_ymax = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.label_profile_ymin = (GtkLabel *) gtk_label_new (gettext ("Minimum"));
dlg.entry_profile_ymin = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.table_profile_y = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach
(dlg.table_profile_y, GTK_WIDGET (dlg.combo_profile_y), 0, 0, 2, 1);
gtk_grid_attach
(dlg.table_profile_y, GTK_WIDGET (dlg.label_profile_ymax), 0, 1, 1, 1);
gtk_grid_attach
(dlg.table_profile_y, GTK_WIDGET (dlg.entry_profile_ymax), 1, 1, 1, 1);
gtk_grid_attach
(dlg.table_profile_y, GTK_WIDGET (dlg.label_profile_ymin), 0, 2, 1, 1);
gtk_grid_attach
(dlg.table_profile_y, GTK_WIDGET (dlg.entry_profile_ymin), 1, 2, 1, 1);
dlg.frame_profile_y = (GtkFrame *) gtk_frame_new (gettext ("Parameter 1"));
gtk_container_add
(GTK_CONTAINER (dlg.frame_profile_y), GTK_WIDGET (dlg.table_profile_y));
dlg.combo_profile_z =
jbw_combo_box_new_with_strings (string_options, 8 + sys->nt);
dlg.label_profile_zmax = (GtkLabel *) gtk_label_new (gettext ("Maximum"));
dlg.entry_profile_zmax = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.label_profile_zmin = (GtkLabel *) gtk_label_new (gettext ("Minimum"));
dlg.entry_profile_zmin = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.table_profile_z = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach
(dlg.table_profile_z, GTK_WIDGET (dlg.combo_profile_z), 0, 0, 2, 1);
gtk_grid_attach
(dlg.table_profile_z, GTK_WIDGET (dlg.label_profile_zmax), 0, 1, 1, 1);
gtk_grid_attach
(dlg.table_profile_z, GTK_WIDGET (dlg.entry_profile_zmax), 1, 1, 1, 1);
gtk_grid_attach
(dlg.table_profile_z, GTK_WIDGET (dlg.label_profile_zmin), 0, 2, 1, 1);
gtk_grid_attach
(dlg.table_profile_z, GTK_WIDGET (dlg.entry_profile_zmin), 1, 2, 1, 1);
dlg.frame_profile_z = (GtkFrame *) gtk_frame_new (gettext ("Parameter 2"));
gtk_container_add
(GTK_CONTAINER (dlg.frame_profile_z), GTK_WIDGET (dlg.table_profile_z));
dlg.table_profile = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach
(dlg.table_profile, GTK_WIDGET (dlg.frame_profile_x), 0, 1, 1, 1);
gtk_grid_attach
(dlg.table_profile, GTK_WIDGET (dlg.frame_profile_y), 0, 2, 1, 1);
gtk_grid_attach
(dlg.table_profile, GTK_WIDGET (dlg.frame_profile_z), 0, 3, 1, 1);
if (simulated)
{
char *string_profile[nstep];
for (i = 0; i < nstep; ++i)
{
string_profile[i] = (char *) g_malloc (32 * sizeof (char));
snprintf (string_profile[i], 32, FGL, (JBDOUBLE) fmin (i * ti, tf));
}
dlg.combo_profile = jbw_combo_box_new_with_strings (string_profile, i);
dlg.label_profile_time = (GtkLabel *) gtk_label_new (gettext ("Time"));
dlg.box_profile = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach (dlg.box_profile, GTK_WIDGET (dlg.label_profile_time),
0, 0, 1, 1);
gtk_grid_attach (dlg.box_profile, GTK_WIDGET (dlg.combo_profile),
1, 0, 1, 1);
gtk_grid_attach (dlg.table_profile, GTK_WIDGET (dlg.box_profile),
0, 0, 1, 1);
}
dlg.label_evolution_xmax = (GtkLabel *) gtk_label_new (gettext ("Maximum"));
dlg.entry_evolution_xmax = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.label_evolution_xmin = (GtkLabel *) gtk_label_new (gettext ("Minimum"));
dlg.entry_evolution_xmin = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.table_evolution_x = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach (dlg.table_evolution_x, GTK_WIDGET (dlg.label_evolution_xmax),
0, 0, 1, 1);
gtk_grid_attach (dlg.table_evolution_x, GTK_WIDGET (dlg.entry_evolution_xmax),
1, 0, 2, 1);
gtk_grid_attach (dlg.table_evolution_x, GTK_WIDGET (dlg.label_evolution_xmin),
0, 1, 1, 1);
gtk_grid_attach (dlg.table_evolution_x, GTK_WIDGET (dlg.entry_evolution_xmin),
1, 1, 2, 1);
dlg.frame_evolution_x = (GtkFrame *) gtk_frame_new (gettext ("Time"));
gtk_container_add (GTK_CONTAINER (dlg.frame_evolution_x),
GTK_WIDGET (dlg.table_evolution_x));
dlg.combo_evolution_y =
jbw_combo_box_new_with_strings (string_options, 8 + sys->nt);
dlg.label_evolution_ymax = (GtkLabel *) gtk_label_new (gettext ("Maximum"));
dlg.entry_evolution_ymax = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.label_evolution_ymin = (GtkLabel *) gtk_label_new (gettext ("Minimum"));
dlg.entry_evolution_ymin = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.table_evolution_y = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach (dlg.table_evolution_y, GTK_WIDGET (dlg.combo_evolution_y),
0, 0, 2, 1);
gtk_grid_attach (dlg.table_evolution_y, GTK_WIDGET (dlg.label_evolution_ymax),
0, 1, 1, 1);
gtk_grid_attach (dlg.table_evolution_y, GTK_WIDGET (dlg.entry_evolution_ymax),
1, 1, 1, 1);
gtk_grid_attach (dlg.table_evolution_y, GTK_WIDGET (dlg.label_evolution_ymin),
0, 2, 1, 1);
gtk_grid_attach (dlg.table_evolution_y, GTK_WIDGET (dlg.entry_evolution_ymin),
1, 2, 1, 1);
dlg.frame_evolution_y = (GtkFrame *) gtk_frame_new (gettext ("Parameter 1"));
gtk_container_add (GTK_CONTAINER (dlg.frame_evolution_y),
GTK_WIDGET (dlg.table_evolution_y));
dlg.combo_evolution_z =
jbw_combo_box_new_with_strings (string_options, 8 + sys->nt);
dlg.label_evolution_zmax = (GtkLabel *) gtk_label_new (gettext ("Maximum"));
dlg.entry_evolution_zmax = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.label_evolution_zmin = (GtkLabel *) gtk_label_new (gettext ("Minimum"));
dlg.entry_evolution_zmin = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.table_evolution_z = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach (dlg.table_evolution_z, GTK_WIDGET (dlg.combo_evolution_z),
0, 0, 2, 1);
gtk_grid_attach (dlg.table_evolution_z, GTK_WIDGET (dlg.label_evolution_zmax),
0, 1, 1, 1);
gtk_grid_attach (dlg.table_evolution_z, GTK_WIDGET (dlg.entry_evolution_zmax),
1, 1, 1, 1);
gtk_grid_attach (dlg.table_evolution_z, GTK_WIDGET (dlg.label_evolution_zmin),
0, 2, 1, 1);
gtk_grid_attach (dlg.table_evolution_z, GTK_WIDGET (dlg.entry_evolution_zmin),
1, 2, 1, 1);
dlg.frame_evolution_z = (GtkFrame *) gtk_frame_new (gettext ("Parameter 2"));
gtk_container_add (GTK_CONTAINER (dlg.frame_evolution_z),
GTK_WIDGET (dlg.table_evolution_z));
dlg.label_evolution_section =
(GtkLabel *) gtk_label_new (gettext ("Transient section"));
dlg.combo_evolution_section = (GtkComboBoxText *) gtk_combo_box_text_new ();
dlg.combo_section = (GtkComboBoxText *) gtk_combo_box_text_new ();
dialog_graphical_options_sections (&dlg);
dlg.table_evolution = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach (dlg.table_evolution,
GTK_WIDGET (dlg.label_evolution_section), 0, 0, 1, 1);
gtk_grid_attach (dlg.table_evolution,
GTK_WIDGET (dlg.combo_evolution_section), 0, 1, 1, 1);
gtk_grid_attach (dlg.table_evolution,
GTK_WIDGET (dlg.frame_evolution_x), 0, 2, 1, 1);
gtk_grid_attach (dlg.table_evolution,
GTK_WIDGET (dlg.frame_evolution_y), 0, 3, 1, 1);
gtk_grid_attach (dlg.table_evolution,
GTK_WIDGET (dlg.frame_evolution_z), 0, 4, 1, 1);
dlg.label_section_xmax = (GtkLabel *) gtk_label_new (gettext ("Maximum"));
dlg.entry_section_xmax = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.label_section_xmin = (GtkLabel *) gtk_label_new (gettext ("Minimum"));
dlg.entry_section_xmin = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.table_section_x = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach
(dlg.table_section_x, GTK_WIDGET (dlg.label_section_xmax), 0, 0, 1, 1);
gtk_grid_attach
(dlg.table_section_x, GTK_WIDGET (dlg.entry_section_xmax), 1, 0, 1, 1);
gtk_grid_attach
(dlg.table_section_x, GTK_WIDGET (dlg.label_section_xmin), 0, 1, 1, 1);
gtk_grid_attach
(dlg.table_section_x, GTK_WIDGET (dlg.entry_section_xmin), 1, 1, 1, 1);
dlg.frame_section_x = (GtkFrame *) gtk_frame_new (gettext ("Position"));
gtk_container_add (GTK_CONTAINER (dlg.frame_section_x),
GTK_WIDGET (dlg.table_section_x));
dlg.label_section_ymax = (GtkLabel *) gtk_label_new (gettext ("Maximum"));
dlg.entry_section_ymax = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.label_section_ymin = (GtkLabel *) gtk_label_new (gettext ("Minimum"));
dlg.entry_section_ymin = (JBWFloatEntry *) jbw_float_entry_new ();
dlg.table_section_y = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach
(dlg.table_section_y, GTK_WIDGET (dlg.label_section_ymax), 0, 0, 1, 1);
gtk_grid_attach
(dlg.table_section_y, GTK_WIDGET (dlg.entry_section_ymax), 1, 0, 1, 1);
gtk_grid_attach
(dlg.table_section_y, GTK_WIDGET (dlg.label_section_ymin), 0, 1, 1, 1);
gtk_grid_attach
(dlg.table_section_y, GTK_WIDGET (dlg.entry_section_ymin), 1, 1, 1, 1);
dlg.frame_section_y = (GtkFrame *) gtk_frame_new (gettext ("Level"));
gtk_container_add
(GTK_CONTAINER (dlg.frame_section_y), GTK_WIDGET (dlg.table_section_y));
dlg.label_section_section =
(GtkLabel *) gtk_label_new (gettext ("Transient section"));
dlg.table_section = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach
(dlg.table_section, GTK_WIDGET (dlg.label_section_section), 0, 0, 1, 1);
gtk_grid_attach
(dlg.table_section, GTK_WIDGET (dlg.combo_section), 0, 1, 1, 1);
gtk_grid_attach
(dlg.table_section, GTK_WIDGET (dlg.frame_section_x), 0, 2, 1, 1);
gtk_grid_attach
(dlg.table_section, GTK_WIDGET (dlg.frame_section_y), 0, 3, 1, 1);
dlg.label_profile
= (GtkLabel *) gtk_label_new (gettext ("Longitudinal profile"));
dlg.label_evolution = (GtkLabel *) gtk_label_new (gettext ("Time evolution"));
dlg.label_section =
(GtkLabel *) gtk_label_new (gettext ("Transient section"));
dlg.notebook = (GtkNotebook *) gtk_notebook_new ();
gtk_notebook_append_page (dlg.notebook,
GTK_WIDGET (dlg.table_profile),
GTK_WIDGET (dlg.label_profile));
gtk_notebook_append_page (dlg.notebook, GTK_WIDGET (dlg.table_evolution),
GTK_WIDGET (dlg.label_evolution));
gtk_notebook_append_page (dlg.notebook, GTK_WIDGET (dlg.table_section),
GTK_WIDGET (dlg.label_section));
dlg.array_animation[0] = 0;
dlg.box_animation = (GtkGrid *) gtk_grid_new ();
for (i = 0; i < 3; ++i)
{
dlg.array_animation[i] = (GtkRadioButton *)
gtk_radio_button_new_with_mnemonic_from_widget
(dlg.array_animation[0], string_animation[i]);
gtk_grid_attach (dlg.box_animation, GTK_WIDGET (dlg.array_animation[i]),
0, i, 1, 1);
}
dlg.frame_animation = (GtkFrame *) gtk_frame_new (gettext ("Animation"));
gtk_container_add (GTK_CONTAINER (dlg.frame_animation),
GTK_WIDGET (dlg.box_animation));
dlg.combo_channel =
jbw_combo_box_new_with_strings (string_channels, sys->n + 1);
dlg.vbox = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach (dlg.vbox, GTK_WIDGET (dlg.combo_channel), 0, 0, 1, 1);
gtk_grid_attach (dlg.vbox, GTK_WIDGET (dlg.frame_animation), 0, 1, 1, 1);
gtk_grid_attach (dlg.vbox, GTK_WIDGET (dlg.button_adjust), 0, 2, 1, 1);
gtk_grid_attach (dlg.vbox, GTK_WIDGET (dlg.button_grid), 0, 3, 1, 1);
dlg.box = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach (dlg.box, GTK_WIDGET (dlg.notebook), 0, 0, 1, 1);
gtk_grid_attach (dlg.box, GTK_WIDGET (dlg.vbox), 1, 0, 1, 1);
dlg.window =
(GtkDialog *) gtk_dialog_new_with_buttons (gettext ("Graphical options"),
parent, GTK_DIALOG_MODAL,
gettext ("_OK"), GTK_RESPONSE_OK,
gettext ("_Cancel"),
GTK_RESPONSE_CANCEL, NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (dlg.window)),
GTK_WIDGET (dlg.box));
gtk_widget_show_all (GTK_WIDGET (dlg.box));
jbw_float_entry_set_value (dlg.entry_profile_xmax, profile_xmax);
jbw_float_entry_set_value (dlg.entry_profile_xmin, profile_xmin);
jbw_float_entry_set_value (dlg.entry_profile_ymax, profile_ymax);
jbw_float_entry_set_value (dlg.entry_profile_ymin, profile_ymin);
jbw_float_entry_set_value (dlg.entry_profile_zmax, profile_zmax);
jbw_float_entry_set_value (dlg.entry_profile_zmin, profile_zmin);
if (simulated)
gtk_combo_box_set_active (GTK_COMBO_BOX (dlg.combo_profile), istep);
gtk_combo_box_set_active
(GTK_COMBO_BOX (dlg.combo_profile_y), profile_parameter1);
gtk_combo_box_set_active
(GTK_COMBO_BOX (dlg.combo_profile_z), profile_parameter2);
jbw_float_entry_set_value (dlg.entry_evolution_xmax, evolution_xmax);
jbw_float_entry_set_value (dlg.entry_evolution_xmin, evolution_xmin);
jbw_float_entry_set_value (dlg.entry_evolution_ymax, evolution_ymax);
jbw_float_entry_set_value (dlg.entry_evolution_ymin, evolution_ymin);
jbw_float_entry_set_value (dlg.entry_evolution_zmax, evolution_zmax);
jbw_float_entry_set_value (dlg.entry_evolution_zmin, evolution_zmin);
gtk_combo_box_set_active
(GTK_COMBO_BOX (dlg.combo_evolution_y), evolution_parameter1);
gtk_combo_box_set_active
(GTK_COMBO_BOX (dlg.combo_evolution_z), evolution_parameter2);
gtk_combo_box_set_active
(GTK_COMBO_BOX (dlg.combo_evolution_section), evolution_section);
gtk_toggle_button_set_active
((GtkToggleButton *) dlg.button_adjust, draw_adjust);
gtk_toggle_button_set_active ((GtkToggleButton *) dlg.button_grid, draw_grid);
jbw_float_entry_set_value (dlg.entry_section_xmax, section_xmax);
jbw_float_entry_set_value (dlg.entry_section_xmin, section_xmin);
jbw_float_entry_set_value (dlg.entry_section_ymax, section_ymax);
jbw_float_entry_set_value (dlg.entry_section_ymin, section_ymin);
gtk_combo_box_set_active (GTK_COMBO_BOX (dlg.combo_section), section);
jbw_array_radio_buttons_set_active (dlg.array_animation, type_animation, 1);
gtk_notebook_set_current_page (dlg.notebook, type_draw);
gtk_combo_box_set_active (GTK_COMBO_BOX (dlg.combo_channel), channel);
dialog_graphical_options_actualize (&dlg);
g_signal_connect_swapped (dlg.combo_channel, "changed",
(void (*)) dialog_graphical_options_channel, &dlg);
if (gtk_dialog_run (dlg.window) == GTK_RESPONSE_OK)
{
if (simulated)
{
istep = gtk_combo_box_get_active (GTK_COMBO_BOX (dlg.combo_profile));
t = fmin (t0 + istep * ti, tf);
dialog_simulator_actualize_bar (dialog_simulator);
}
channel = gtk_combo_box_get_active (GTK_COMBO_BOX (dlg.combo_channel));
draw_adjust =
gtk_toggle_button_get_active ((GtkToggleButton *) dlg.button_adjust);
draw_grid =
gtk_toggle_button_get_active ((GtkToggleButton *) dlg.button_grid);
profile_parameter1 =
gtk_combo_box_get_active (GTK_COMBO_BOX (dlg.combo_profile_y));
profile_parameter2 =
gtk_combo_box_get_active (GTK_COMBO_BOX (dlg.combo_profile_z));
profile_xmin = jbw_float_entry_get_value (dlg.entry_profile_xmin);
profile_xmax = jbw_float_entry_get_value (dlg.entry_profile_xmax);
profile_ymin = jbw_float_entry_get_value (dlg.entry_profile_ymin);
profile_ymax = jbw_float_entry_get_value (dlg.entry_profile_ymax);
profile_zmin = jbw_float_entry_get_value (dlg.entry_profile_zmin);
profile_zmax = jbw_float_entry_get_value (dlg.entry_profile_zmax);
evolution_parameter1 =
gtk_combo_box_get_active (GTK_COMBO_BOX (dlg.combo_evolution_y));
evolution_parameter2 =
gtk_combo_box_get_active (GTK_COMBO_BOX (dlg.combo_evolution_z));
evolution_xmin = jbw_float_entry_get_value (dlg.entry_evolution_xmin);
evolution_xmax = jbw_float_entry_get_value (dlg.entry_evolution_xmax);
evolution_ymin = jbw_float_entry_get_value (dlg.entry_evolution_ymin);
evolution_ymax = jbw_float_entry_get_value (dlg.entry_evolution_ymax);
evolution_zmin = jbw_float_entry_get_value (dlg.entry_evolution_zmin);
evolution_zmax = jbw_float_entry_get_value (dlg.entry_evolution_zmax);
evolution_section = gtk_combo_box_get_active
(GTK_COMBO_BOX (dlg.combo_evolution_section));
section_xmin = jbw_float_entry_get_value (dlg.entry_section_xmin);
section_xmax = jbw_float_entry_get_value (dlg.entry_section_xmax);
section_ymin = jbw_float_entry_get_value (dlg.entry_section_ymin);
section_ymax = jbw_float_entry_get_value (dlg.entry_section_ymax);
section = gtk_combo_box_get_active (GTK_COMBO_BOX (dlg.combo_section));
type_draw = gtk_notebook_get_current_page (dlg.notebook);
type_animation = jbw_array_radio_buttons_get_active (dlg.array_animation);
dialog_simulator_actualize (dialog_simulator);
}
gtk_widget_destroy (GTK_WIDGET (dlg.window));
draw ();
}
static gboolean
lens_dialog (GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *preview;
GtkWidget *label;
GtkWidget *toggle;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *spinbutton;
GtkObject *adj;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Lens Effect"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_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_aspect_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 (drawlens),
drawable);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
toggle = gtk_radio_button_new_with_mnemonic_from_widget
(NULL, _("_Keep original surroundings"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), lvals.keep_surr);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&lvals.keep_surr);
g_signal_connect_swapped (toggle, "toggled",
G_CALLBACK (gimp_preview_invalidate),
preview);
toggle = gtk_radio_button_new_with_mnemonic_from_widget
(GTK_RADIO_BUTTON (toggle),
gimp_drawable_is_indexed (drawable->drawable_id)
? _("_Set surroundings to index 0")
: _("_Set surroundings to background color"));
gtk_box_pack_start(GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), lvals.use_bkgr);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&lvals.use_bkgr);
g_signal_connect_swapped (toggle, "toggled",
G_CALLBACK (gimp_preview_invalidate),
preview);
if (gimp_drawable_has_alpha (drawable->drawable_id))
{
toggle = gtk_radio_button_new_with_mnemonic_from_widget
(GTK_RADIO_BUTTON (toggle), _("_Make surroundings transparent"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
lvals.set_transparent);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&lvals.set_transparent);
g_signal_connect_swapped (toggle, "toggled",
G_CALLBACK (gimp_preview_invalidate),
preview);
}
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic (_("_Lens refraction index:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
spinbutton = gimp_spin_button_new (&adj, lvals.refraction,
1.0, 100.0, 0.1, 1.0, 0, 1, 2);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&lvals.refraction);
g_signal_connect_swapped (adj, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_widget_show (hbox);
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dialog);
return run;
}
static GObject*
gpa_file_sign_dialog_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
GObject *object;
GpaFileSignDialog *dialog;
GtkWidget *vboxSign;
GtkWidget *label;
GtkWidget *frameMode;
GtkWidget *vboxMode;
GtkWidget *radio_sign_comp;
GtkWidget *radio_sign;
GtkWidget *radio_sign_sep;
GtkWidget *checkerArmor;
GtkWidget *frameWho;
GtkWidget *vboxWho;
GtkWidget *labelWho;
GtkWidget *scrollerWho;
GtkWidget *clistWho;
/* Invoke parent's constructor */
object = parent_class->constructor (type,
n_construct_properties,
construct_properties);
dialog = GPA_FILE_SIGN_DIALOG (object);
/* Initialize */
/* Set up the dialog */
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
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);
gpa_window_set_title (GTK_WINDOW (dialog), _("Sign documents"));
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
vboxSign = gtk_vbox_new (FALSE, 5);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), vboxSign);
frameWho = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frameWho), GTK_SHADOW_NONE);
labelWho = gtk_label_new_with_mnemonic (_("<b>Sign _as</b>"));
gtk_label_set_use_markup (GTK_LABEL (labelWho), TRUE);
gtk_frame_set_label_widget (GTK_FRAME (frameWho), labelWho);
gtk_box_pack_start (GTK_BOX (vboxSign), frameWho, FALSE, FALSE, 0);
vboxWho = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (frameWho), vboxWho);
scrollerWho = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (scrollerWho, 400, 200);
gtk_box_pack_start (GTK_BOX (vboxWho), scrollerWho, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollerWho),
GTK_SHADOW_IN);
clistWho = gpa_key_selector_new (TRUE, TRUE);
dialog->clist_who = clistWho;
gtk_container_add (GTK_CONTAINER (scrollerWho), clistWho);
gtk_label_set_mnemonic_widget (GTK_LABEL (labelWho), clistWho);
frameMode = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frameMode), GTK_SHADOW_NONE);
label = gtk_label_new (_("<b>Signing Mode</b>"));
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_frame_set_label_widget (GTK_FRAME (frameMode), label);
gtk_box_pack_start (GTK_BOX (vboxSign), frameMode, FALSE, FALSE, 0);
vboxMode = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (frameMode), vboxMode);
dialog->frame_mode = frameMode;
radio_sign_comp = gtk_radio_button_new_with_mnemonic
(NULL, _("Si_gn and compress"));
gtk_box_pack_start (GTK_BOX (vboxMode), radio_sign_comp, FALSE, FALSE, 0);
dialog->radio_comp = radio_sign_comp;
radio_sign =
gtk_radio_button_new_with_mnemonic_from_widget
(GTK_RADIO_BUTTON (radio_sign_comp), _("Clear_text signature"));
gtk_box_pack_start (GTK_BOX (vboxMode), radio_sign, FALSE, FALSE, 0);
dialog->radio_sign = radio_sign;
/* FIXME: We hide the radio button here. It still can be activated
invisibly by setting the "sig-mode" property. This is used by
the clipboard code, which also hides the whole sig mode selection
frame, so no harm done. For the file sign mode, hiding the
cleartext option is the right thing to do. But eventually, all
this should be freely configurable by the caller, instead of
relying on such knowledge. */
gtk_widget_set_no_show_all (radio_sign, TRUE);
gtk_widget_hide (radio_sign);
radio_sign_sep =
gtk_radio_button_new_with_mnemonic_from_widget
(GTK_RADIO_BUTTON (radio_sign_comp), _("_Detached signature"));
gtk_box_pack_start (GTK_BOX (vboxMode), radio_sign_sep, FALSE, FALSE, 0);
dialog->radio_sep = radio_sign_sep;
/* Allow for the frameMode to be hidden despite what show_all
does. */
gtk_widget_show_all (frameMode);
gtk_widget_set_no_show_all (frameMode, TRUE);
checkerArmor = gtk_check_button_new_with_mnemonic (_("A_rmor"));
gtk_box_pack_start (GTK_BOX (vboxSign), checkerArmor, FALSE, FALSE, 0);
/* Take care of any child widgets there might be. */
gtk_widget_show_all (checkerArmor);
gtk_widget_set_no_show_all (checkerArmor, TRUE);
dialog->check_armor = checkerArmor;
return object;
}
GtkWidget *plugin_configure(GtkDialog *dialog)
{
GtkWidget *vbox, *label, *notebook_vbox, *checkbox_enable;
GtkWidget *notebook, *inner_vbox;
vbox = gtk_vbox_new(FALSE, 6);
notebook = gtk_notebook_new();
gtk_widget_set_can_focus(notebook, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(notebook), 5);
gtk_box_pack_start(GTK_BOX(vbox), notebook, FALSE, TRUE, 0);
/*
* Auto Save
*/
{
GtkWidget *spin, *hbox, *checkbox, *checkbox_enable_as_lf, *radio1, *radio2;
notebook_vbox = gtk_vbox_new(FALSE, 2);
inner_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(inner_vbox), 5);
gtk_box_pack_start(GTK_BOX(notebook_vbox), inner_vbox, TRUE, TRUE, 5);
gtk_notebook_insert_page(GTK_NOTEBOOK(notebook),
notebook_vbox, gtk_label_new(_("Auto Save")), NOTEBOOK_PAGE_AUTOSAVE);
checkbox_enable_as_lf = gtk_check_button_new_with_mnemonic(_("Enable save when losing _focus"));
gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_enable_as_lf), FALSE);
pref_widgets.checkbox_enable_autosave_losing_focus = checkbox_enable_as_lf;
gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox_enable_as_lf, FALSE, FALSE, 6);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_enable_as_lf), enable_autosave_losing_focus);
checkbox_enable = gtk_check_button_new_with_mnemonic(_("_Enable"));
gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_enable), FALSE);
pref_widgets.checkbox_enable_autosave = checkbox_enable;
gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox_enable, FALSE, FALSE, 6);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_enable), enable_autosave);
g_signal_connect(checkbox_enable, "toggled",
G_CALLBACK(checkbox_toggled_cb), GINT_TO_POINTER(NOTEBOOK_PAGE_AUTOSAVE));
label = gtk_label_new_with_mnemonic(_("Auto save _interval:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(inner_vbox), label, TRUE, TRUE, 0);
pref_widgets.autosave_interval_spin = spin = gtk_spin_button_new_with_range(1, 1800, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), autosave_interval);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin);
label = gtk_label_new(_("seconds"));
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), spin, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(inner_vbox), hbox, FALSE, FALSE, 5);
checkbox = gtk_check_button_new_with_mnemonic(
_("_Print status message if files have been automatically saved"));
gtk_button_set_focus_on_click(GTK_BUTTON(checkbox), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), autosave_print_msg);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), checkbox);
gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox, FALSE, FALSE, 5);
pref_widgets.autosave_print_msg_checkbox = checkbox;
radio1 = gtk_radio_button_new_with_mnemonic(NULL,
_("Save only current open _file"));
pref_widgets.autosave_save_all_radio1 = radio1;
gtk_label_set_mnemonic_widget(GTK_LABEL(label), radio1);
gtk_button_set_focus_on_click(GTK_BUTTON(radio1), FALSE);
gtk_container_add(GTK_CONTAINER(inner_vbox), radio1);
radio2 = gtk_radio_button_new_with_mnemonic_from_widget(
GTK_RADIO_BUTTON(radio1), _("Sa_ve all open files"));
pref_widgets.autosave_save_all_radio2 = radio2;
gtk_label_set_mnemonic_widget(GTK_LABEL(label), radio2);
gtk_button_set_focus_on_click(GTK_BUTTON(radio2), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio2), autosave_save_all);
gtk_container_add(GTK_CONTAINER(inner_vbox), radio2);
}
/*
* Instant Save
*/
{
GtkWidget *combo;
guint i;
const GSList *node;
notebook_vbox = gtk_vbox_new(FALSE, 2);
inner_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(inner_vbox), 5);
gtk_box_pack_start(GTK_BOX(notebook_vbox), inner_vbox, TRUE, TRUE, 5);
gtk_notebook_insert_page(GTK_NOTEBOOK(notebook),
notebook_vbox, gtk_label_new(_("Instant Save")), NOTEBOOK_PAGE_INSTANTSAVE);
checkbox_enable = gtk_check_button_new_with_mnemonic(_("_Enable"));
pref_widgets.checkbox_enable_instantsave = checkbox_enable;
gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_enable), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_enable), enable_instantsave);
gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox_enable, FALSE, FALSE, 6);
g_signal_connect(checkbox_enable, "toggled",
G_CALLBACK(checkbox_toggled_cb), GINT_TO_POINTER(NOTEBOOK_PAGE_INSTANTSAVE));
label = gtk_label_new_with_mnemonic(_("_Filetype to use for newly opened files:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(inner_vbox), label, FALSE, FALSE, 0);
pref_widgets.instantsave_ft_combo = combo = gtk_combo_box_text_new();
i = 0;
foreach_slist(node, filetypes_get_sorted_by_name())
{
GeanyFiletype *ft = node->data;
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), ft->name);
if (utils_str_equal(ft->name, instantsave_default_ft))
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), i);
i++;
}
gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(combo), 3);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), combo);
gtk_box_pack_start(GTK_BOX(inner_vbox), combo, FALSE, FALSE, 0);
}
/**
* \fn void dialog_options_create()
* \brief Function to create a dialog to set the fractal options.
*/
void
dialog_options_create ()
{
int i;
const char *array_fractals[N_FRACTAL_TYPES] =
{ gettext ("_Tree"), gettext ("_Forest"), gettext ("_Neuron") };
const char *array_algorithms[N_RANDOM_TYPES] = {
"_mt19937",
"_ranlxs0",
"r_anlxs1",
"ra_nlxs2",
"ran_lxd1",
"ranlx_d2",
"ranlu_x",
"ranlux_389",
"_cmrg",
"mr_g",
"_taus2",
"g_fsr4"
};
const char *array_seeds[N_RANDOM_SEED_TYPES] =
{ gettext ("_Default"), gettext ("_Clock based"), gettext ("_Fixed") };
DialogOptions *dlg = dialog_options;
dlg->button_diagonal = (GtkCheckButton *) gtk_check_button_new_with_mnemonic
(gettext ("_Diagonal movement"));
dlg->button_3D =
(GtkCheckButton *) gtk_check_button_new_with_mnemonic ("3_D");
g_signal_connect (dlg->button_3D, "clicked", dialog_options_update, NULL);
dlg->label_length = (GtkLabel *) gtk_label_new (gettext ("Length"));
dlg->label_width = (GtkLabel *) gtk_label_new (gettext ("Width"));
dlg->label_height = (GtkLabel *) gtk_label_new (gettext ("Height"));
dlg->label_seed = (GtkLabel *) gtk_label_new (gettext ("Random seed"));
dlg->entry_length =
(GtkSpinButton *) gtk_spin_button_new_with_range (320., 2400., 1.);
dlg->entry_width =
(GtkSpinButton *) gtk_spin_button_new_with_range (320., 2400., 1.);
dlg->entry_height =
(GtkSpinButton *) gtk_spin_button_new_with_range (200., 2400., 1.);
dlg->entry_seed =
(GtkSpinButton *) gtk_spin_button_new_with_range (0., 4294967295., 1.);
dlg->grid_fractal = (GtkGrid *) gtk_grid_new ();
dlg->array_fractals[0] = NULL;
for (i = 0; i < N_FRACTAL_TYPES; ++i)
{
dlg->array_fractals[i] =
(GtkRadioButton *) gtk_radio_button_new_with_mnemonic_from_widget
(dlg->array_fractals[0], array_fractals[i]);
gtk_grid_attach (dlg->grid_fractal, GTK_WIDGET (dlg->array_fractals[i]),
0, i, 1, 1);
}
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (dlg->array_fractals[fractal_type]), 1);
dlg->frame_fractal = (GtkFrame *) gtk_frame_new (gettext ("Fractal type"));
gtk_container_add (GTK_CONTAINER (dlg->frame_fractal),
GTK_WIDGET (dlg->grid_fractal));
dlg->button_animate = (GtkCheckButton *) gtk_check_button_new_with_mnemonic
(gettext ("_Animate"));
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (dlg->button_animate), animating);
dlg->grid_algorithm = (GtkGrid *) gtk_grid_new ();
dlg->array_algorithms[0] = NULL;
for (i = 0; i < N_RANDOM_TYPES; ++i)
{
dlg->array_algorithms[i] =
(GtkRadioButton *) gtk_radio_button_new_with_mnemonic_from_widget
(dlg->array_algorithms[0], array_algorithms[i]);
gtk_grid_attach (dlg->grid_algorithm,
GTK_WIDGET (dlg->array_algorithms[i]), 0, i, 1, 1);
}
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (dlg->array_algorithms[random_algorithm]), 1);
dlg->frame_algorithm
= (GtkFrame *) gtk_frame_new (gettext ("Random algorithm"));
gtk_container_add (GTK_CONTAINER (dlg->frame_algorithm),
GTK_WIDGET (dlg->grid_algorithm));
dlg->grid_seed = (GtkGrid *) gtk_grid_new ();
dlg->array_seeds[0] = NULL;
for (i = 0; i < N_RANDOM_SEED_TYPES; ++i)
{
dlg->array_seeds[i] =
(GtkRadioButton *) gtk_radio_button_new_with_mnemonic_from_widget
(dlg->array_seeds[0], array_seeds[i]);
gtk_grid_attach (dlg->grid_seed, GTK_WIDGET (dlg->array_seeds[i]),
0, i, 1, 1);
g_signal_connect (dlg->array_seeds[i], "clicked", dialog_options_update,
NULL);
}
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON (dlg->array_seeds[random_seed_type]), 1);
dlg->frame_seed = (GtkFrame *) gtk_frame_new (gettext ("Random seed type"));
gtk_container_add (GTK_CONTAINER (dlg->frame_seed),
GTK_WIDGET (dlg->grid_seed));
dlg->grid = (GtkGrid *) gtk_grid_new ();
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->button_diagonal), 0, 0, 2, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->button_3D), 0, 1, 2, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->label_length), 0, 2, 1, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->entry_length), 1, 2, 1, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->label_width), 0, 3, 1, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->entry_width), 1, 3, 1, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->label_height), 0, 4, 1, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->entry_height), 1, 4, 1, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->frame_fractal), 0, 5, 2, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->button_animate), 0, 6, 2, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->frame_algorithm), 2, 0, 1, 8);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->frame_seed), 0, 7, 2, 2);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->label_seed), 0, 9, 1, 1);
gtk_grid_attach (dlg->grid, GTK_WIDGET (dlg->entry_seed), 1, 9, 1, 1);
dlg->dialog
= (GtkDialog *) gtk_dialog_new_with_buttons (gettext ("Options"),
dialog_simulator->window,
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
gettext ("_OK"),
GTK_RESPONSE_OK,
gettext ("_Cancel"),
GTK_RESPONSE_CANCEL, NULL);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (dlg->dialog)),
GTK_WIDGET (dlg->grid));
gtk_widget_show_all (GTK_WIDGET (dlg->dialog));
gtk_toggle_button_set_active
((GtkToggleButton *) dlg->button_diagonal, fractal_diagonal);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dlg->button_3D), fractal_3D);
gtk_spin_button_set_value (dlg->entry_length, length);
gtk_spin_button_set_value (dlg->entry_width, width);
gtk_spin_button_set_value (dlg->entry_height, height);
gtk_spin_button_set_value (dlg->entry_seed, random_seed);
dialog_options_update ();
if (gtk_dialog_run (dlg->dialog) == GTK_RESPONSE_OK)
{
fractal_diagonal = gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (dlg->button_diagonal));
fractal_3D =
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dlg->button_3D));
for (i = 0; i < N_FRACTAL_TYPES; ++i)
if (gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (dlg->array_fractals[i])))
fractal_type = i;
length = gtk_spin_button_get_value_as_int (dlg->entry_length);
width = gtk_spin_button_get_value_as_int (dlg->entry_width);
height = gtk_spin_button_get_value_as_int (dlg->entry_height);
random_seed = gtk_spin_button_get_value_as_int (dlg->entry_seed);
animating = gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (dlg->button_animate));
for (i = 0; i < N_RANDOM_TYPES; ++i)
if (gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (dlg->array_algorithms[i])))
random_algorithm = i;
for (i = 0; i < N_RANDOM_SEED_TYPES; ++i)
if (gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (dlg->array_seeds[i])))
random_seed_type = i;
medium_start ();
set_perspective ();
breaking = 1;
}
gtk_widget_destroy (GTK_WIDGET (dlg->dialog));
}
static GtkWidget *
get_config_frame(PurplePlugin *plugin)
{
GtkWidget *ret = NULL, *frame = NULL;
GtkWidget *vbox = NULL, *toggle = NULL;
ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, 18);
gtk_container_set_border_width(GTK_CONTAINER (ret), 12);
/* Alerts */
frame = pidgin_make_frame(ret, _("Chatroom alerts"));
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(frame), vbox);
toggle = gtk_check_button_new_with_mnemonic(_("Chatroom message alerts _only where someone says your username"));
gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
purple_prefs_get_bool("/plugins/gtk/unity/alert_chat_nick"));
g_signal_connect(G_OBJECT(toggle), "toggled",
G_CALLBACK(alert_config_cb), NULL);
/* Launcher integration */
frame = pidgin_make_frame(ret, _("Launcher Icon"));
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(frame), vbox);
toggle = gtk_radio_button_new_with_mnemonic(NULL, _("_Disable launcher integration"));
gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
purple_prefs_get_int("/plugins/gtk/unity/launcher_count") == LAUNCHER_COUNT_DISABLE);
g_signal_connect(G_OBJECT(toggle), "toggled",
G_CALLBACK(launcher_config_cb), GUINT_TO_POINTER(LAUNCHER_COUNT_DISABLE));
toggle = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(toggle),
_("Show number of unread _messages on launcher icon"));
gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
purple_prefs_get_int("/plugins/gtk/unity/launcher_count") == LAUNCHER_COUNT_MESSAGES);
g_signal_connect(G_OBJECT(toggle), "toggled",
G_CALLBACK(launcher_config_cb), GUINT_TO_POINTER(LAUNCHER_COUNT_MESSAGES));
toggle = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(toggle),
_("Show number of unread co_nversations on launcher icon"));
gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
purple_prefs_get_int("/plugins/gtk/unity/launcher_count") == LAUNCHER_COUNT_SOURCES);
g_signal_connect(G_OBJECT(toggle), "toggled",
G_CALLBACK(launcher_config_cb), GUINT_TO_POINTER(LAUNCHER_COUNT_SOURCES));
/* Messaging menu integration */
frame = pidgin_make_frame(ret, _("Messaging Menu"));
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(frame), vbox);
toggle = gtk_radio_button_new_with_mnemonic(NULL,
_("Show number of _unread messages for conversations in messaging menu"));
gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
purple_prefs_get_int("/plugins/gtk/unity/messaging_menu_text") == MESSAGING_MENU_COUNT);
g_signal_connect(G_OBJECT(toggle), "toggled",
G_CALLBACK(messaging_menu_config_cb), GUINT_TO_POINTER(MESSAGING_MENU_COUNT));
toggle = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(toggle),
_("Show _elapsed time for unread conversations in messaging menu"));
gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
purple_prefs_get_int("/plugins/gtk/unity/messaging_menu_text") == MESSAGING_MENU_TIME);
g_signal_connect(G_OBJECT(toggle), "toggled",
G_CALLBACK(messaging_menu_config_cb), GUINT_TO_POINTER(MESSAGING_MENU_TIME));
gtk_widget_show_all(ret);
return ret;
}
static void
xpad_preferences_init (XpadPreferences *pref)
{
GtkWidget *hbox, *font_hbox, *vbox;
const GdkColor *color;
const gchar *fontname;
GtkStyle *style;
GtkWidget *label, *appearance_frame, *alignment, *appearance_vbox;
GtkWidget *options_frame, *options_vbox, *global_vbox;
gchar *text;
GtkSizeGroup *size_group_labels = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
GtkRequisition req;
pref->priv = XPAD_PREFERENCES_GET_PRIVATE (pref);
text = g_strconcat ("<b>", _("Appearance"), "</b>", NULL);
label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
"label", text,
"use-markup", TRUE,
"xalign", 0.0,
NULL));
g_free (text);
appearance_vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX,
"homogeneous", FALSE,
"spacing", 18,
NULL));
alignment = gtk_alignment_new (1, 1, 1, 1);
g_object_set (G_OBJECT (alignment),
"left-padding", 12,
"top-padding", 12,
"child", appearance_vbox,
NULL);
appearance_frame = GTK_WIDGET (g_object_new (GTK_TYPE_FRAME,
"label-widget", label,
"shadow-type", GTK_SHADOW_NONE,
"child", alignment,
NULL));
pref->priv->textbutton = gtk_color_button_new ();
pref->priv->backbutton = gtk_color_button_new ();
pref->priv->fontbutton = gtk_font_button_new ();
pref->priv->antifontcheck = gtk_radio_button_new_with_mnemonic (NULL, _("Use font from theme"));
pref->priv->fontcheck = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (pref->priv->antifontcheck), _("Use this font:"));
pref->priv->anticolorcheck = gtk_radio_button_new_with_mnemonic (NULL, _("Use colors from theme"));
pref->priv->colorcheck = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (pref->priv->anticolorcheck), _("Use these colors:"));
font_hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (font_hbox), pref->priv->fontcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (font_hbox), pref->priv->fontbutton, TRUE, TRUE, 0);
pref->priv->colorbox = gtk_vbox_new (FALSE, 6);
hbox = gtk_hbox_new (FALSE, 12);
label = gtk_label_new_with_mnemonic (_("Background:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_size_group_add_widget (size_group_labels, label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), pref->priv->backbutton, TRUE, TRUE, 0);
g_object_set (G_OBJECT (pref->priv->colorbox), "child", hbox, NULL);
hbox = gtk_hbox_new (FALSE, 12);
label = gtk_label_new_with_mnemonic (_("Foreground:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_size_group_add_widget (size_group_labels, label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), pref->priv->textbutton, TRUE, TRUE, 0);
g_object_set (G_OBJECT (pref->priv->colorbox), "child", hbox, NULL);
alignment = gtk_alignment_new (1, 1, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);
gtk_container_add (GTK_CONTAINER (alignment), pref->priv->colorbox);
pref->priv->editcheck = gtk_check_button_new_with_mnemonic (_("_Edit lock"));
pref->priv->stickycheck = gtk_check_button_new_with_mnemonic (_("_Pads start on all workspaces"));
pref->priv->confirmcheck = gtk_check_button_new_with_mnemonic (_("_Confirm pad deletion"));
gtk_dialog_add_button (GTK_DIALOG (pref), "gtk-close", GTK_RESPONSE_CLOSE);
gtk_dialog_set_default_response (GTK_DIALOG (pref), GTK_RESPONSE_CLOSE);
gtk_dialog_set_has_separator (GTK_DIALOG (pref), FALSE);
g_signal_connect (pref, "response", G_CALLBACK (xpad_preferences_response), NULL);
gtk_window_set_title (GTK_WINDOW (pref), _("Xpad Preferences"));
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pref->priv->textbutton), FALSE);
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pref->priv->backbutton), xpad_app_get_translucent ());
gtk_color_button_set_title (GTK_COLOR_BUTTON (pref->priv->textbutton), _("Set Foreground Color"));
gtk_color_button_set_title (GTK_COLOR_BUTTON (pref->priv->backbutton), _("Set Background Color"));
gtk_font_button_set_title (GTK_FONT_BUTTON (pref->priv->fontbutton), _("Set Font"));
/* Set current state */
style = gtk_widget_get_default_style ();
color = xpad_settings_get_back_color (xpad_settings ());
if (color)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->colorcheck), TRUE);
gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->backbutton), color);
}
else
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->anticolorcheck), TRUE);
gtk_widget_set_sensitive (pref->priv->colorbox, FALSE);
gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->backbutton), &style->base[GTK_STATE_NORMAL]);
}
color = xpad_settings_get_text_color (xpad_settings ());
if (color)
gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->textbutton), color);
else
gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->textbutton), &style->text[GTK_STATE_NORMAL]);
fontname = xpad_settings_get_fontname (xpad_settings ());
if (fontname)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->fontcheck), TRUE);
gtk_font_button_set_font_name (GTK_FONT_BUTTON (pref->priv->fontbutton), fontname);
}
else
{
gchar *str;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->antifontcheck), TRUE);
gtk_widget_set_sensitive (pref->priv->fontbutton, FALSE);
str = pango_font_description_to_string (style->font_desc);
gtk_font_button_set_font_name (GTK_FONT_BUTTON (pref->priv->fontbutton), str);
g_free (str);
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->editcheck), xpad_settings_get_edit_lock (xpad_settings ()));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->stickycheck), xpad_settings_get_sticky (xpad_settings ()));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->confirmcheck), xpad_settings_get_confirm_destroy (xpad_settings ()));
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->antifontcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), font_hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (appearance_vbox), vbox, FALSE, FALSE, 0);
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->anticolorcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->colorcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (appearance_vbox), vbox, FALSE, FALSE, 0);
text = g_strconcat ("<b>", _("Options"), "</b>", NULL);
label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
"label", text,
"use-markup", TRUE,
"xalign", 0.0,
NULL));
g_free (text);
options_vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX,
"homogeneous", FALSE,
"spacing", 6,
NULL));
alignment = gtk_alignment_new (1, 1, 1, 1);
g_object_set (G_OBJECT (alignment),
"left-padding", 12,
"top-padding", 12,
"child", options_vbox,
NULL);
options_frame = GTK_WIDGET (g_object_new (GTK_TYPE_FRAME,
"label-widget", label,
"shadow-type", GTK_SHADOW_NONE,
"child", alignment,
NULL));
gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->editcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->stickycheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->confirmcheck, FALSE, FALSE, 0);
global_vbox = g_object_new (GTK_TYPE_VBOX,
"border-width", 6,
"homogeneous", FALSE,
"spacing", 18,
"child", appearance_frame,
"child", options_frame,
NULL);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pref)->vbox), global_vbox, FALSE, FALSE, 0);
pref->priv->editcheck_handler = g_signal_connect (pref->priv->editcheck, "toggled", G_CALLBACK (change_edit_check), pref);
pref->priv->stickycheck_handler = g_signal_connect (pref->priv->stickycheck, "toggled", G_CALLBACK (change_sticky_check), pref);
pref->priv->confirmcheck_handler = g_signal_connect (pref->priv->confirmcheck, "toggled", G_CALLBACK (change_confirm_check), pref);
pref->priv->colorcheck_handler = g_signal_connect (pref->priv->colorcheck, "toggled", G_CALLBACK (change_color_check), pref);
pref->priv->fontcheck_handler = g_signal_connect (pref->priv->fontcheck, "toggled", G_CALLBACK (change_font_check), pref);
pref->priv->text_handler = g_signal_connect (pref->priv->textbutton, "color-set", G_CALLBACK (change_text_color), pref);
pref->priv->back_handler = g_signal_connect (pref->priv->backbutton, "color-set", G_CALLBACK (change_back_color), pref);
pref->priv->font_handler = g_signal_connect (pref->priv->fontbutton, "font-set", G_CALLBACK (change_font_face), pref);
pref->priv->notify_font_handler = g_signal_connect_swapped (xpad_settings (), "notify::fontname", G_CALLBACK (notify_fontname), pref);
pref->priv->notify_text_handler = g_signal_connect_swapped (xpad_settings (), "notify::text-color", G_CALLBACK (notify_text_color), pref);
pref->priv->notify_back_handler = g_signal_connect_swapped (xpad_settings (), "notify::back-color", G_CALLBACK (notify_back_color), pref);
pref->priv->notify_sticky_handler = g_signal_connect_swapped (xpad_settings (), "notify::sticky", G_CALLBACK (notify_sticky), pref);
pref->priv->notify_edit_handler = g_signal_connect_swapped (xpad_settings (), "notify::edit-lock", G_CALLBACK (notify_edit), pref);
pref->priv->notify_confirm_handler = g_signal_connect_swapped (xpad_settings (), "notify::confirm-destroy", G_CALLBACK (notify_confirm), pref);
g_object_unref (size_group_labels);
gtk_widget_show_all (GTK_DIALOG (pref)->vbox);
/* Make window not so squished */
gtk_widget_size_request (GTK_WIDGET (pref), &req);
g_object_set (G_OBJECT (pref), "default-width", (gint) (req.height * 0.8), NULL);
}
void
bluetooth_connection_new (GtkWindow *parent,
const char *detail,
NMClient *client,
PageNewConnectionResultFunc result_func,
gpointer user_data)
{
gint response;
NMAMobileWizard *wizard = NULL;
WizardInfo *info;
GtkWidget *dialog, *content, *alignment, *vbox, *label, *dun_radio, *panu_radio;
info = g_malloc0 (sizeof (WizardInfo));
info->result_func = result_func;
info->client = g_object_ref (client);
info->user_data = user_data;
info->type = NM_SETTING_BLUETOOTH_TYPE_PANU;
dialog = gtk_dialog_new_with_buttons (_("Bluetooth Type"),
parent,
GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
content = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
alignment = gtk_alignment_new (0, 0, 0.5, 0.5);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12);
gtk_box_pack_start (GTK_BOX (content), alignment, TRUE, FALSE, 6);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (alignment), vbox);
label = gtk_label_new (_("Select the type of the Bluetooth connection profile."));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 12);
panu_radio = gtk_radio_button_new_with_mnemonic (NULL, _("_Personal Area Network"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (panu_radio), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), panu_radio, FALSE, FALSE, 6);
dun_radio = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (panu_radio),
_("_Dial-Up Network"));
gtk_box_pack_start (GTK_BOX (vbox), dun_radio, FALSE, FALSE, 6);
gtk_widget_show_all (dialog);
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_OK) {
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dun_radio))) {
info->type = NM_SETTING_BLUETOOTH_TYPE_DUN;
wizard = nma_mobile_wizard_new (parent, NULL, NM_DEVICE_MODEM_CAPABILITY_NONE, FALSE,
new_connection_mobile_wizard_done, info);
} else {
info->type = NM_SETTING_BLUETOOTH_TYPE_PANU;
}
}
gtk_widget_destroy (dialog);
if (wizard)
nma_mobile_wizard_present (wizard);
else
new_connection_mobile_wizard_done (NULL, (response != GTK_RESPONSE_OK), NULL, info);
}
