void
entry_print_result (void)
{
if (options.entry_data.numeric)
{
guint prec = gtk_spin_button_get_digits (GTK_SPIN_BUTTON (entry));
g_print ("%.*f\n", prec, gtk_spin_button_get_value (GTK_SPIN_BUTTON (entry)));
}
else if (is_combo)
{
if (options.common_data.num_output)
g_print ("%d\n", gtk_combo_box_get_active (GTK_COMBO_BOX (entry)) + 1);
else
{
#if GTK_CHECK_VERSION(2,24,0)
g_print ("%s\n", gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (entry)));
#else
g_print ("%s\n", gtk_combo_box_get_active_text (GTK_COMBO_BOX (entry)));
#endif
}
}
else
g_print ("%s\n", gtk_entry_get_text (GTK_ENTRY (entry)));
}
/* Create a new GncPeriodSelect widget which is used to select a
* accounting period like "previous month" or "this year".
*
* @param starting_labels If set to TRUE then all the labels will
* refer to the "Start of...". If FALSE, labels will refer to "End
* of...".
*
* @return A GncPeriodSelect widget.
*/
GtkWidget *
gnc_period_select_new (gboolean starting_labels)
{
GncPeriodSelectPrivate *priv;
GncPeriodSelect *period;
const gchar *label;
gint i;
period = g_object_new(GNC_TYPE_PERIOD_SELECT, NULL);
/* Set up private data structures */
priv = GNC_PERIOD_SELECT_GET_PRIVATE(period);
priv->selector = gtk_combo_box_text_new();
priv->start = starting_labels;
/* Add the internal widgets to the hbox */
gtk_box_pack_start(GTK_BOX(period), priv->selector, TRUE, TRUE, 0);
gtk_widget_show(priv->selector);
/* Find out when the combo box changes */
g_signal_connect(G_OBJECT(priv->selector), "changed",
G_CALLBACK(gnc_period_sample_combobox_changed), period);
/* Build all the labels except the fiscal year labels */
for (i = 0; i < GNC_ACCOUNTING_PERIOD_CYEAR_LAST; i++)
{
label = starting_labels ? _(start_strings[i]) : _(end_strings[i]);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->selector), label);
}
/* Track changes to date formatting */
gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL, GNC_PREF_DATE_FORMAT,
gnc_period_sample_new_date_format, period);
return GTK_WIDGET (period);
}
static void
matedialog_entry_dialog_response (GtkWidget *widget, int response, gpointer data)
{
MateDialogData *zen_data = data;
const gchar *text;
switch (response) {
case GTK_RESPONSE_OK:
zen_data->exit_code = matedialog_util_return_exit_code (MATEDIALOG_OK);
if (n_entries > 1) {
#if GTK_CHECK_VERSION(2,24,0)
text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (entry));
#else
text = gtk_combo_box_get_active_text (GTK_COMBO_BOX (entry));
#endif
}
else {
text = gtk_entry_get_text (GTK_ENTRY (entry));
}
if (text != NULL)
g_print ("%s\n", text);
break;
case GTK_RESPONSE_CANCEL:
zen_data->exit_code = matedialog_util_return_exit_code (MATEDIALOG_CANCEL);
break;
default:
/* Esc dialog */
zen_data->exit_code = matedialog_util_return_exit_code (MATEDIALOG_ESC);
break;
}
gtk_main_quit ();
}
int main( int argc, char * argv[] ) {
GtkWidget * window;
GtkWidget * fixed;
GtkWidget * combo;
GtkWidget * label;
gtk_init( &argc, &argv );
window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW(window), "GtkCombo" );
gtk_window_set_position( GTK_WINDOW(window), GTK_WIN_POS_CENTER );
gtk_window_set_default_size( GTK_WINDOW(window), 230, 150 );
fixed = gtk_fixed_new();
combo = gtk_combo_box_text_new();
gtk_combo_box_text_append_text( GTK_COMBO_BOX_TEXT(combo), "Ubuntu" );
gtk_combo_box_text_append_text( GTK_COMBO_BOX_TEXT(combo), "Mandriva" );
gtk_combo_box_text_append_text( GTK_COMBO_BOX_TEXT(combo), "Fedora" );
gtk_combo_box_text_append_text( GTK_COMBO_BOX_TEXT(combo), "Mint" );
gtk_combo_box_text_append_text( GTK_COMBO_BOX_TEXT(combo), "Gentoo" );
gtk_combo_box_text_append_text( GTK_COMBO_BOX_TEXT(combo), "Debian" );
gtk_fixed_put( GTK_FIXED(fixed), combo, 50, 50 );
gtk_container_add( GTK_CONTAINER(window), fixed );
label = gtk_label_new( "-" );
gtk_fixed_put( GTK_FIXED(fixed), label, 50, 110 );
g_signal_connect_swapped( G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), G_OBJECT(window) );
g_signal_connect( G_OBJECT(combo), "changed",
G_CALLBACK(combo_selected), (gpointer) label );
gtk_widget_show_all( window );
gtk_main();
return 0;
}
static void
connect_wifi_page (CEPageWifi *page)
{
NMSettingConnection *sc;
GtkWidget *widget;
const GByteArray *ssid;
gchar *utf8_ssid;
GPtrArray *bssid_array;
gchar **bssid_list;
const GByteArray *s_bssid;
gchar *s_bssid_str;
gchar **mac_list;
const GByteArray *s_mac;
gchar *s_mac_str;
gint i;
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder,
"entry_ssid"));
ssid = nm_setting_wireless_get_ssid (page->setting);
if (ssid)
utf8_ssid = nm_utils_ssid_to_utf8 (ssid);
else
utf8_ssid = g_strdup ("");
gtk_entry_set_text (GTK_ENTRY (widget), utf8_ssid);
g_free (utf8_ssid);
g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page);
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder,
"combo_bssid"));
bssid_array = g_ptr_array_new ();
for (i = 0; i < nm_setting_wireless_get_num_seen_bssids (page->setting); i++) {
g_ptr_array_add (bssid_array, g_strdup (nm_setting_wireless_get_seen_bssid (page->setting, i)));
}
g_ptr_array_add (bssid_array, NULL);
bssid_list = (gchar **) g_ptr_array_free (bssid_array, FALSE);
s_bssid = nm_setting_wireless_get_bssid (page->setting);
s_bssid_str = s_bssid ? nm_utils_hwaddr_ntoa (s_bssid->data, ARPHRD_ETHER) : NULL;
ce_page_setup_mac_combo (GTK_COMBO_BOX_TEXT (widget), s_bssid_str, bssid_list);
g_free (s_bssid_str);
g_strfreev (bssid_list);
g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page);
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder,
"combo_mac"));
mac_list = ce_page_get_mac_list (CE_PAGE (page)->client, NM_TYPE_DEVICE_WIFI,
NM_DEVICE_WIFI_PERMANENT_HW_ADDRESS);
s_mac = nm_setting_wireless_get_mac_address (page->setting);
s_mac_str = s_mac ? nm_utils_hwaddr_ntoa (s_mac->data, ARPHRD_ETHER) : NULL;
ce_page_setup_mac_combo (GTK_COMBO_BOX_TEXT (widget), s_mac_str, mac_list);
g_free (s_mac_str);
g_strfreev (mac_list);
g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page);
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder,
"entry_cloned_mac"));
ce_page_mac_to_entry (nm_setting_wireless_get_cloned_mac_address (page->setting),
ARPHRD_ETHER, GTK_ENTRY (widget));
g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page);
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder,
"auto_connect_check"));
sc = nm_connection_get_setting_connection (CE_PAGE (page)->connection);
g_object_bind_property (sc, "autoconnect",
widget, "active",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
g_signal_connect_swapped (widget, "toggled", G_CALLBACK (ce_page_changed), page);
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder,
"all_user_check"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
nm_setting_connection_get_num_permissions (sc) == 0);
g_signal_connect (widget, "toggled",
G_CALLBACK (all_user_changed), page);
g_signal_connect_swapped (widget, "toggled", G_CALLBACK (ce_page_changed), page);
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "combo_zone"));
firewall_ui_setup (sc, widget, CE_PAGE (page)->cancellable);
g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page);
}
static void configure_response_cb(GtkDialog *dialog, gint response, gpointer user_data)
{
if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY)
{
GKeyFile *config = g_key_file_new();
gchar *data;
gchar *config_dir = g_path_get_dirname(sc_info->config_file);
GtkComboBox *combo = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(dialog), "combo"));
setptr(sc_info->default_language, gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo)));
#ifdef HAVE_ENCHANT_1_5
setptr(sc_info->dictionary_dir, g_strdup(gtk_entry_get_text(GTK_ENTRY(
g_object_get_data(G_OBJECT(dialog), "dict_dir")))));
#endif
sc_speller_reinit_enchant_dict();
sc_info->check_while_typing = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
g_object_get_data(G_OBJECT(dialog), "check_type"))));
sc_info->use_msgwin = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
g_object_get_data(G_OBJECT(dialog), "check_msgwin"))));
sc_info->show_toolbar_item = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
g_object_get_data(G_OBJECT(dialog), "check_toolbar"))));
sc_info->show_editor_menu_item = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
g_object_get_data(G_OBJECT(dialog), "check_editor_menu"))));
g_key_file_load_from_file(config, sc_info->config_file, G_KEY_FILE_NONE, NULL);
if (sc_info->default_language != NULL) /* lang may be NULL */
g_key_file_set_string(config, "spellcheck", "language", sc_info->default_language);
g_key_file_set_boolean(config, "spellcheck", "check_while_typing",
sc_info->check_while_typing);
g_key_file_set_boolean(config, "spellcheck", "use_msgwin",
sc_info->use_msgwin);
g_key_file_set_boolean(config, "spellcheck", "show_toolbar_item",
sc_info->show_toolbar_item);
g_key_file_set_boolean(config, "spellcheck", "show_editor_menu_item",
sc_info->show_editor_menu_item);
if (sc_info->dictionary_dir != NULL)
g_key_file_set_string(config, "spellcheck", "dictionary_dir",
sc_info->dictionary_dir);
sc_gui_update_toolbar();
sc_gui_update_menu();
populate_dict_combo(combo);
if (! g_file_test(config_dir, G_FILE_TEST_IS_DIR) && utils_mkdir(config_dir, TRUE) != 0)
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR,
_("Plugin configuration directory could not be created."));
}
else
{
/* write config to file */
data = g_key_file_to_data(config, NULL, NULL);
utils_write_file(sc_info->config_file, data);
g_free(data);
}
g_free(config_dir);
g_key_file_free(config);
}
}
/*
* attach v4l2 controls tab widget
* args:
* parent - tab parent widget
*
* asserts:
* parent is not null
*
* returns: error code (0 -OK)
*/
int gui_attach_gtk3_v4l2ctrls(GtkWidget *parent)
{
/*assertions*/
assert(parent != NULL);
if(debug_level > 1)
printf("GUVCVIEW: attaching v4l2 controls\n");
GtkWidget *img_controls_grid = gtk_grid_new();
gtk_widget_show (img_controls_grid);
gtk_grid_set_column_homogeneous (GTK_GRID(img_controls_grid), FALSE);
gtk_widget_set_hexpand (img_controls_grid, TRUE);
gtk_widget_set_halign (img_controls_grid, GTK_ALIGN_FILL);
gtk_grid_set_row_spacing (GTK_GRID(img_controls_grid), 4);
gtk_grid_set_column_spacing (GTK_GRID (img_controls_grid), 4);
gtk_container_set_border_width (GTK_CONTAINER (img_controls_grid), 2);
int i = 0;
int n = 0;
v4l2_ctrl_t *current = v4l2core_get_control_list();
for(; current != NULL; current = current->next, ++n)
{
if(current == NULL)
{
fprintf(stderr, "GUVCVIEW: ERROR (attach gtk3 controls) empty control in list\n");
break;
}
if(!is_control_panel &&
(current->control.id == V4L2_CID_FOCUS_LOGITECH ||
current->control.id == V4L2_CID_FOCUS_ABSOLUTE))
{
++n; /*add a virtual software autofocus control*/
}
widget_list_size = n + 1;
control_widgets_list = realloc(control_widgets_list, sizeof(control_widgets_t) * widget_list_size);
if(control_widgets_list == NULL)
{
fprintf(stderr,"GUVCVIEW: FATAL memory allocation failure (gui_attach_gtk3_v4l2ctrls): %s\n", strerror(errno));
exit(-1);
}
/*label*/
char *tmp;
tmp = g_strdup_printf ("%s:", current->name);
control_widgets_list[widget_list_size - 1].label = gtk_label_new (tmp);
g_free(tmp);
gtk_widget_show (control_widgets_list[widget_list_size - 1].label);
#if GTK_VER_AT_LEAST(3,15)
gtk_label_set_xalign(GTK_LABEL(control_widgets_list[widget_list_size - 1].label), 1);
gtk_label_set_yalign(GTK_LABEL(control_widgets_list[widget_list_size - 1].label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (control_widgets_list[widget_list_size - 1].label), 1, 0.5);
#endif
control_widgets_list[widget_list_size - 1].id = current->control.id;
control_widgets_list[widget_list_size - 1].widget = NULL;
control_widgets_list[widget_list_size - 1].widget2 = NULL; /*usually a spin button*/
switch (current->control.type)
{
case V4L2_CTRL_TYPE_INTEGER:
switch (current->control.id)
{
//special cases
case V4L2_CID_PAN_RELATIVE:
case V4L2_CID_TILT_RELATIVE:
{
control_widgets_list[n].widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1);
GtkWidget *PanTilt1 = NULL;
GtkWidget *PanTilt2 = NULL;
if(current->control.id == V4L2_CID_PAN_RELATIVE)
{
PanTilt1 = gtk_button_new_with_label(_("Left"));
PanTilt2 = gtk_button_new_with_label(_("Right"));
}
else
{
PanTilt1 = gtk_button_new_with_label(_("Down"));
PanTilt2 = gtk_button_new_with_label(_("Up"));
}
gtk_widget_show (PanTilt1);
gtk_widget_show (PanTilt2);
gtk_box_pack_start(GTK_BOX(control_widgets_list[n].widget),PanTilt1,TRUE,TRUE,2);
gtk_box_pack_start(GTK_BOX(control_widgets_list[n].widget),PanTilt2,TRUE,TRUE,2);
g_object_set_data (G_OBJECT (PanTilt1), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (PanTilt2), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signals*/
g_signal_connect (GTK_BUTTON(PanTilt1), "clicked",
G_CALLBACK (button_PanTilt1_clicked), NULL);
g_signal_connect (GTK_BUTTON(PanTilt2), "clicked",
G_CALLBACK (button_PanTilt2_clicked), NULL);
gtk_widget_show (control_widgets_list[n].widget);
control_widgets_list[n].widget2 = gtk_spin_button_new_with_range(-256, 256, 64);
gtk_editable_set_editable(GTK_EDITABLE(control_widgets_list[n].widget2), TRUE);
if(current->control.id == V4L2_CID_PAN_RELATIVE)
gtk_spin_button_set_value (GTK_SPIN_BUTTON(control_widgets_list[n].widget2), v4l2core_get_pan_step());
else
gtk_spin_button_set_value (GTK_SPIN_BUTTON(control_widgets_list[n].widget2),v4l2core_get_tilt_step());
/*connect signal*/
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_signal_connect(GTK_SPIN_BUTTON(control_widgets_list[n].widget2),"value-changed",
G_CALLBACK (pan_tilt_step_changed), NULL);
gtk_widget_show (control_widgets_list[n].widget2);
break;
}
case V4L2_CID_PAN_RESET:
case V4L2_CID_TILT_RESET:
{
control_widgets_list[n].widget = gtk_button_new_with_label(" ");
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget), "clicked",
G_CALLBACK (button_clicked), NULL);
break;
};
case V4L2_CID_LED1_MODE_LOGITECH:
{
char* LEDMenu[4] = {_("Off"),_("On"),_("Blinking"),_("Auto")};
/*turn it into a menu control*/
if(!current->menu)
current->menu = calloc(4+1, sizeof(struct v4l2_querymenu));
else
current->menu = realloc(current->menu, (4+1) * sizeof(struct v4l2_querymenu));
if(current->menu == NULL)
{
fprintf(stderr,"GUVCVIEW: FATAL memory allocation failure (gui_attach_gtk3_v4l2ctrls): %s\n", strerror(errno));
exit(-1);
}
current->menu[0].id = current->control.id;
current->menu[0].index = 0;
current->menu[0].name[0] = 'N'; /*just set something here*/
current->menu[1].id = current->control.id;
current->menu[1].index = 1;
current->menu[1].name[0] = 'O';
current->menu[2].id = current->control.id;
current->menu[2].index = 2;
current->menu[2].name[0] = 'B';
current->menu[3].id = current->control.id;
current->menu[3].index = 3;
current->menu[3].name[0] = 'A';
current->menu[4].id = current->control.id;
current->menu[4].index = current->control.maximum+1;
current->menu[4].name[0] = '\0';
int j = 0;
int def = 0;
control_widgets_list[n].widget = gtk_combo_box_text_new ();
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget),
(char *) LEDMenu[j]);
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(control_widgets_list[n].widget), def);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget), "changed",
G_CALLBACK (combo_changed), NULL);
break;
}
case V4L2_CID_RAW_BITS_PER_PIXEL_LOGITECH:
{
/*turn it into a menu control*/
char* BITSMenu[2] = {_("8 bit"),_("12 bit")};
/*turn it into a menu control*/
if(!current->menu)
current->menu = calloc(2+1, sizeof(struct v4l2_querymenu));
else
current->menu = realloc(current->menu, (2+1) * sizeof(struct v4l2_querymenu));
if(current->menu == NULL)
{
fprintf(stderr,"GUVCVIEW: FATAL memory allocation failure (gui_attach_gtk3_v4l2ctrls): %s\n", strerror(errno));
exit(-1);
}
current->menu[0].id = current->control.id;
current->menu[0].index = 0;
current->menu[0].name[0] = 'o'; /*just set something here*/
current->menu[1].id = current->control.id;
current->menu[1].index = 1;
current->menu[1].name[0] = 'd';
current->menu[2].id = current->control.id;
current->menu[2].index = 2;
current->menu[2].name[0] = '\0';
int j = 0;
int def = 0;
control_widgets_list[n].widget = gtk_combo_box_text_new ();
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
//if (debug_level > 0)
// printf("GUVCVIEW: adding menu entry %d: %d, %s\n",j, current->menu[j].index, current->menu[j].name);
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget),
(char *) BITSMenu[j]);
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(control_widgets_list[n].widget), def);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget), "changed",
G_CALLBACK (combo_changed), NULL);
break;
}
case V4L2_CID_FOCUS_LOGITECH:
case V4L2_CID_FOCUS_ABSOLUTE:
if(!is_control_panel)
{
/*add a virtual control for software autofocus*/
control_widgets_list[n-1].widget = gtk_check_button_new_with_label (_("Auto Focus (continuous)"));
control_widgets_list[n-1].widget2 = gtk_button_new_with_label (_("set Focus"));
gtk_widget_show (control_widgets_list[n-1].widget);
gtk_widget_show (control_widgets_list[n-1].widget2);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (control_widgets_list[n-1].widget), FALSE);
g_signal_connect (G_OBJECT (control_widgets_list[n-1].widget), "toggled",
G_CALLBACK (autofocus_changed), NULL);
g_signal_connect (G_OBJECT (control_widgets_list[n-1].widget2), "clicked",
G_CALLBACK (setfocus_clicked), NULL);
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n-1].widget, 1, i, 1 , 1);
gtk_widget_set_halign (control_widgets_list[n-1].widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (control_widgets_list[n-1].widget, TRUE);
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n-1].widget2, 2, i, 1 , 1);
i++;
}
default: /*standard case - hscale + spin*/
{
/* check for valid range */
if((current->control.maximum > current->control.minimum) && (current->control.step != 0))
{
GtkAdjustment *adjustment = gtk_adjustment_new (
current->value,
current->control.minimum,
current->control.maximum,
current->control.step,
current->control.step*10,
0);
control_widgets_list[n].widget = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adjustment);
gtk_scale_set_draw_value (GTK_SCALE (control_widgets_list[n].widget), FALSE);
gtk_scale_set_digits(GTK_SCALE(control_widgets_list[n].widget), 0);
gtk_widget_show (control_widgets_list[n].widget);
control_widgets_list[n].widget2= gtk_spin_button_new(adjustment, current->control.step, 0);
gtk_editable_set_editable(GTK_EDITABLE(control_widgets_list[n].widget2),TRUE);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
if(!is_control_panel &&
(current->control.id == V4L2_CID_FOCUS_LOGITECH ||
current->control.id == V4L2_CID_FOCUS_ABSOLUTE))
{
g_object_set_data (G_OBJECT (control_widgets_list[n-1].widget), "control_entry",
control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n-1].widget), "control2_entry",
control_widgets_list[n].widget2);
}
/*connect signals*/
g_signal_connect (GTK_SCALE(control_widgets_list[n].widget), "value-changed",
G_CALLBACK (slider_changed), NULL);
g_signal_connect(GTK_SPIN_BUTTON(control_widgets_list[n].widget2),"value-changed",
G_CALLBACK (spin_changed), NULL);
}
else
fprintf(stderr, "GUVCVIEW: (Invalid range) [MAX <= MIN] for control id: 0x%08x \n", current->control.id);
break;
}
}
break;
#ifdef V4L2_CTRL_TYPE_INTEGER64
case V4L2_CTRL_TYPE_INTEGER64:
widget = gtk_entry_new();
gtk_entry_set_max_length(control_widgets_list[n].widget, current->control.maximum);
//control_widgets_list[n].widget2 = gtk_button_new_from_stock(GTK_STOCK_APPLY);
control_widgets_list[n].widget2 = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_widget_show (control_widgets_list[n].widget);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_entry",
widget);
/*connect signal*/
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget2), "clicked",
G_CALLBACK (int64_button_clicked), NULL);
break;
#endif
#ifdef V4L2_CTRL_TYPE_STRING
case V4L2_CTRL_TYPE_STRING:
control_widgets_list[n].widget = gtk_entry_new();
gtk_entry_set_max_length(control_widgets_list[n].widget, current->control.maximum);
//control_widgets_list[n].widget2= gtk_button_new_from_stock(GTK_STOCK_APPLY);
control_widgets_list[n].widget2 = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_widget_show (control_widgets_list[n].widget);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_entry",
widget);
/*connect signal*/
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget2), "clicked",
G_CALLBACK (string_button_clicked), NULL);
break;
#endif
#ifdef V4L2_CTRL_TYPE_BITMASK
case V4L2_CTRL_TYPE_BITMASK:
control_widgets_list[n].widget = gtk_entry_new();
//control_widgets_list[n].widget2 = gtk_button_new_from_stock(GTK_STOCK_APPLY);
control_widgets_list[n].widget2 = gtk_button_new_with_mnemonic (_("_Apply"));
gtk_widget_show (control_widgets_list[n].widget);
gtk_widget_show (control_widgets_list[n].widget2);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_info",
GINT_TO_POINTER(current->control.id));
g_object_set_data (G_OBJECT (control_widgets_list[n].widget2), "control_entry",
widget);
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget2), "clicked",
G_CALLBACK (bitmask_button_clicked), NULL);
break;
#endif
#ifdef V4L2_CTRL_TYPE_INTEGER_MENU
case V4L2_CTRL_TYPE_INTEGER_MENU:
#endif
case V4L2_CTRL_TYPE_MENU:
if(current->menu)
{
int j = 0;
int def = 0;
control_widgets_list[n].widget = gtk_combo_box_text_new ();
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
if(current->control.type == V4L2_CTRL_TYPE_MENU)
{
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget),
(char *) current->menu_entry[j]);
}
#ifdef V4L2_CTRL_TYPE_INTEGER_MENU
else
{
char buffer[30]="0";
snprintf(buffer, "%" PRIu64 "", 29, current->menu[j].value);
gtk_combo_box_text_append_text (
GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget), buffer);
}
#endif
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(control_widgets_list[n].widget), def);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget), "changed",
G_CALLBACK (combo_changed), NULL);
}
break;
case V4L2_CTRL_TYPE_BUTTON:
control_widgets_list[n].widget = gtk_button_new_with_label(" ");
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
g_signal_connect (GTK_BUTTON(control_widgets_list[n].widget), "clicked",
G_CALLBACK (button_clicked), NULL);
break;
case V4L2_CTRL_TYPE_BOOLEAN:
if(current->control.id ==V4L2_CID_DISABLE_PROCESSING_LOGITECH)
{
control_widgets_list[n].widget2 = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"GBGB... | RGRG...");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"GRGR... | BGBG...");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"BGBG... | GRGR...");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(control_widgets_list[n].widget2),
"RGRG... | GBGB...");
v4l2core_set_bayer_pix_order(0);
gtk_combo_box_set_active(GTK_COMBO_BOX(control_widgets_list[n].widget2), v4l2core_get_bayer_pix_order());
gtk_widget_show (control_widgets_list[n].widget2);
/*connect signal*/
g_signal_connect (GTK_COMBO_BOX_TEXT (control_widgets_list[n].widget2), "changed",
G_CALLBACK (bayer_pix_ord_changed), NULL);
uint8_t isbayer = (current->value ? TRUE : FALSE);
v4l2core_set_isbayer(isbayer);
}
control_widgets_list[n].widget = gtk_check_button_new();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (control_widgets_list[n].widget),
current->value ? TRUE : FALSE);
gtk_widget_show (control_widgets_list[n].widget);
g_object_set_data (G_OBJECT (control_widgets_list[n].widget), "control_info",
GINT_TO_POINTER(current->control.id));
/*connect signal*/
g_signal_connect (GTK_TOGGLE_BUTTON(control_widgets_list[n].widget), "toggled",
G_CALLBACK (check_changed), NULL);
break;
default:
printf("control[%d]:(unknown - 0x%x) 0x%x '%s'\n",i ,current->control.type,
current->control.id, current->control.name);
break;
}
/*attach widgets to grid*/
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n].label, 0, i, 1 , 1);
if(control_widgets_list[n].widget)
{
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n].widget, 1, i, 1 , 1);
gtk_widget_set_halign (control_widgets_list[n].widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (control_widgets_list[n].widget, TRUE);
}
if(control_widgets_list[n].widget2)
{
gtk_grid_attach(GTK_GRID(img_controls_grid), control_widgets_list[n].widget2, 2, i, 1 , 1);
}
i++;
}
/*add control grid to parent container*/
gtk_container_add(GTK_CONTAINER(parent), img_controls_grid);
gui_gtk3_update_controls_state();
return 0;
}
GtkWidget *AP_UnixDialog_Lists::_constructWindowContents (void)
{
GtkWidget *vbox2;
GtkWidget *hbox2;
GtkWidget *vbox4;
GtkWidget *table1;
GtkWidget *style_om;
GtkWidget *type_om;
GtkWidget *type_lb;
GtkWidget *style_lb;
GtkWidget *customized_cb;
GtkWidget *frame1;
GtkWidget *table2;
GtkComboBox *font_om;
GtkListStore *font_om_menu;
GtkWidget *format_en;
GtkWidget *decimal_en;
GtkAdjustment *start_sb_adj;
GtkWidget *start_sb;
GtkAdjustment *text_align_sb_adj;
GtkWidget *text_align_sb;
GtkAdjustment *label_align_sb_adj;
GtkWidget *label_align_sb;
GtkWidget *format_lb;
GtkWidget *font_lb;
GtkWidget *delimiter_lb;
GtkWidget *start_at_lb;
GtkWidget *text_align_lb;
GtkWidget *label_align_lb;
GtkWidget *vbox3;
GtkWidget *preview_lb;
GtkWidget *hbox1;
GSList *action_group = NULL;
GtkWidget *start_list_rb;
GtkWidget *apply_list_rb;
GtkWidget *resume_list_rb;
GtkWidget *preview_area;
GtkWidget *preview_frame;
const XAP_StringSet * pSS = m_pApp->getStringSet();
UT_UTF8String s;
GtkWidget * wNoteBook = NULL;
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox2);
if(!isModal())
{
// Note Book creation
wNoteBook = gtk_notebook_new ();
gtk_widget_show(wNoteBook);
// Container for the lists
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageProperties,s);
GtkWidget * lbPageLists = gtk_label_new(s.utf8_str());
gtk_widget_show(lbPageLists);
gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),vbox2,lbPageLists);
m_iPageLists = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),vbox2);
// Container for Text Folding
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageFolding,s);
GtkWidget * lbPageFolding = gtk_label_new(s.utf8_str());
GtkWidget * wFoldingTable = gtk_table_new(6,3,FALSE);
gtk_widget_show(lbPageFolding);
gtk_widget_show(wFoldingTable);
gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),wFoldingTable,lbPageFolding);
m_iPageFold = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),wFoldingTable);
// Left Spacing Here
GtkWidget * lbLeftSpacer = gtk_label_new("");
gtk_misc_set_padding(GTK_MISC(lbLeftSpacer),8,0);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbLeftSpacer,0,1,0,6,GTK_SHRINK,GTK_FILL,0,0);
gtk_widget_show(lbLeftSpacer);
// Bold markup
GtkWidget * lbFoldHeading = gtk_label_new("<b>%s</b>");
gtk_label_set_use_markup(GTK_LABEL(lbFoldHeading),TRUE);
localizeLabelMarkup(lbFoldHeading,pSS,AP_STRING_ID_DLG_Lists_FoldingLevelexp);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbFoldHeading,1,3,0,1,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(lbFoldHeading);
// Mid Left Spacing Here
GtkWidget * lbMidLeftSpacer = gtk_label_new("");
gtk_misc_set_padding(GTK_MISC(lbMidLeftSpacer),8,0);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbMidLeftSpacer,1,2,1,6,GTK_SHRINK,GTK_FILL,0,0);
gtk_widget_show(lbMidLeftSpacer);
m_vecFoldCheck.clear();
m_vecFoldID.clear();
UT_uint32 ID =0;
// RadioButtons
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel0,s);
GtkWidget * wF = gtk_radio_button_new_with_label(NULL, s.utf8_str());
GSList *wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"0");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,1,2,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel1,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"1");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,2,3,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel2,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"2");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,3,4,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel3,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"3");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,4,5,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel4,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"4");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,5,6,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
gtk_widget_show(wFoldingTable);
gtk_notebook_set_current_page(GTK_NOTEBOOK(wNoteBook),m_iPageLists);
}
// List Page
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 8);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
vbox4 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
gtk_widget_show (vbox4);
gtk_box_pack_start (GTK_BOX (hbox2), vbox4, FALSE, TRUE, 0);
table1 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox4), table1, FALSE, TRUE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table1), 4);
style_om = gtk_combo_box_text_new();
gtk_widget_show (style_om);
gtk_table_attach (GTK_TABLE (table1), style_om, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
m_wListStyleNone_menu = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_INT);
_fillNoneStyleMenu(m_wListStyleNone_menu.obj());
m_wListStyleNumbered_menu = gtk_list_store_new (2, G_TYPE_STRING,
G_TYPE_INT);
_fillNumberedStyleMenu(m_wListStyleNumbered_menu.obj());
m_wListStyleBulleted_menu = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_INT);
_fillBulletedStyleMenu(m_wListStyleBulleted_menu.obj());
// This is the default list. Change if the list style changes
//
m_wListStyle_menu = m_wListStyleNumbered_menu;
gtk_combo_box_set_model(GTK_COMBO_BOX (style_om),
GTK_TREE_MODEL(m_wListStyleNumbered_menu.obj()));
type_om = gtk_combo_box_text_new();
gtk_widget_show (type_om);
gtk_table_attach (GTK_TABLE (table1), type_om, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_none,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_bullet,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_numbered,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
gtk_combo_box_set_active(GTK_COMBO_BOX(type_om), 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type,s);
type_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (type_lb);
gtk_table_attach (GTK_TABLE (table1), type_lb, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (type_lb), 0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Style,s);
style_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (style_lb);
gtk_table_attach (GTK_TABLE (table1), style_lb, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (style_lb), 0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_SetDefault,s);
customized_cb = gtk_dialog_add_button (GTK_DIALOG(m_wMainWindow), s.utf8_str(), BUTTON_RESET);
gtk_widget_show (customized_cb);
/* todo
gtk_table_attach (GTK_TABLE (table1), customized_cb, 0, 2, 2, 3,
(GtkAttachOptions) (GTK_SHRINK),
(GtkAttachOptions) (0), 0, 0);
*/
frame1 = gtk_frame_new (NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame1), GTK_SHADOW_NONE);
//gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox4), frame1, TRUE, TRUE, 0);
table2 = gtk_table_new (6, 2, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (frame1), table2);
gtk_container_set_border_width (GTK_CONTAINER (table2), 4);
gtk_widget_set_sensitive (table2, TRUE);
gtk_table_set_row_spacings (GTK_TABLE (table2), 4);
gtk_table_set_col_spacings (GTK_TABLE (table2), 4);
font_om_menu = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
_fillFontMenu(font_om_menu);
font_om = GTK_COMBO_BOX(gtk_combo_box_new());
gtk_combo_box_set_model(font_om, GTK_TREE_MODEL(font_om_menu));
gtk_widget_show (GTK_WIDGET(font_om));
gtk_table_attach (GTK_TABLE (table2), GTK_WIDGET(font_om), 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
format_en = gtk_entry_new ();
gtk_entry_set_max_length(GTK_ENTRY(format_en), 20);
gtk_widget_show (format_en);
gtk_table_attach (GTK_TABLE (table2), format_en, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_entry_set_text (GTK_ENTRY (format_en), "%L");
decimal_en = gtk_entry_new ();
gtk_widget_show (decimal_en);
gtk_table_attach (GTK_TABLE (table2), decimal_en, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_entry_set_text (GTK_ENTRY (format_en), "");
start_sb_adj = (GtkAdjustment*)gtk_adjustment_new (1, 0, G_MAXINT32, 1, 10, 10);
start_sb = gtk_spin_button_new (GTK_ADJUSTMENT (start_sb_adj), 1, 0);
gtk_widget_show (start_sb);
gtk_table_attach (GTK_TABLE (table2), start_sb, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
text_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0.25, 0, 10, 0.01, 0.2, 1);
text_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (text_align_sb_adj), 0.05, 2);
gtk_widget_show (text_align_sb);
gtk_table_attach (GTK_TABLE (table2), text_align_sb, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (text_align_sb), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (text_align_sb), TRUE);
label_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0, 0, 10, 0.01, 0.2, 1);
label_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (label_align_sb_adj), 0.05, 2);
gtk_widget_show (label_align_sb);
gtk_table_attach (GTK_TABLE (table2), label_align_sb, 1, 2, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (label_align_sb), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (label_align_sb), TRUE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Format,s);
format_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (format_lb);
gtk_table_attach (GTK_TABLE (table2), format_lb, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (format_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Font,s);
font_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (font_lb);
gtk_table_attach (GTK_TABLE (table2), font_lb, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (font_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_DelimiterString,s);
delimiter_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (delimiter_lb);
gtk_table_attach (GTK_TABLE (table2), delimiter_lb, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (delimiter_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start,s);
start_at_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (start_at_lb);
gtk_table_attach (GTK_TABLE (table2), start_at_lb, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (start_at_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Align,s);
text_align_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (text_align_lb);
gtk_table_attach (GTK_TABLE (table2), text_align_lb, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (text_align_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Indent,s);
label_align_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (label_align_lb);
gtk_table_attach (GTK_TABLE (table2), label_align_lb, 0, 1, 5, 6,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_align_lb), 0.0, 0.5);
vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox3);
gtk_box_pack_start (GTK_BOX (hbox2), vbox3, TRUE, TRUE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Preview,s);
preview_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (preview_lb);
gtk_box_pack_start (GTK_BOX (vbox3), preview_lb, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (preview_lb), 0.0, 0.5);
preview_frame = gtk_frame_new (NULL);
gtk_widget_show (preview_frame);
gtk_box_pack_start (GTK_BOX (vbox3), preview_frame, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (preview_frame), 3);
gtk_frame_set_shadow_type (GTK_FRAME (preview_frame), GTK_SHADOW_NONE);
preview_area = createDrawingArea ();
gtk_widget_set_size_request (preview_area,180,225);
gtk_widget_show (preview_area);
gtk_container_add (GTK_CONTAINER (preview_frame), preview_area);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
if(!isModal())
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start_New,s);
start_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (start_list_rb));
if(!isModal())
gtk_widget_show (start_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), start_list_rb, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (start_list_rb), TRUE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Apply_Current,s);
apply_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (apply_list_rb));
if(!isModal())
gtk_widget_show (apply_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), apply_list_rb, FALSE, FALSE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Resume,s);
resume_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (resume_list_rb));
if(!isModal())
gtk_widget_show (resume_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), resume_list_rb, FALSE, FALSE, 0);
// Save useful widgets in member variables
if(isModal())
{
m_wContents = vbox2;
}
else
{
m_wContents = wNoteBook;
}
m_wStartNewList = start_list_rb;
m_wStartNew_label = gtk_bin_get_child(GTK_BIN(start_list_rb));
m_wApplyCurrent = apply_list_rb;
m_wStartSubList = resume_list_rb;
m_wStartSub_label = gtk_bin_get_child(GTK_BIN(resume_list_rb));
m_wRadioGroup = action_group;
m_wPreviewArea = preview_area;
m_wDelimEntry = format_en;
m_oAlignList_adj = text_align_sb_adj;
m_wAlignListSpin = text_align_sb;
m_oIndentAlign_adj = label_align_sb_adj;
m_wIndentAlignSpin = label_align_sb;
m_wDecimalEntry = decimal_en;
m_oStartSpin_adj = start_sb_adj;
m_wStartSpin = start_sb;
m_wFontOptions = font_om;
m_wFontOptions_menu = font_om_menu;
m_wCustomFrame = frame1;
m_wCustomLabel = customized_cb;
m_wCustomTable = table2;
m_wListStyleBox = GTK_COMBO_BOX(style_om);
m_wListTypeBox = GTK_COMBO_BOX(type_om);
m_wListType_menu = m_wListStyleNumbered_menu;
// Start by hiding the Custom frame
//
// gtk_widget_hide(m_wCustomFrame);
gtk_widget_show(m_wCustomFrame);
setbisCustomized(false);
return m_wContents;
}
/**
Sprawdzenie słowa, na którym aktualnie znajduje się kursor. Ewentualne dodanie do słownika.
@param[in] item element menu.
@param[in] data wskaźnik na wartość.
*/
static void WhatCheck (GtkMenuItem *item, gpointer data) {
GtkWidget *dialog;
GtkTextIter start, end;
char *word;
gunichar *wword;
//load_dictionary_from_menu(&dict);
// Znajdujemy pozycję kursora
gtk_text_buffer_get_iter_at_mark(editor_buf, &start,
gtk_text_buffer_get_insert(editor_buf));
// Jeśli nie wewnątrz słowa, kończymy
if (!gtk_text_iter_inside_word(&start)) {
dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"Kursor musi być w środku słowa");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return;
}
// Znajdujemy początek i koniec słowa, a potem samo słowo
end = start;
gtk_text_iter_backward_word_start(&start);
gtk_text_iter_forward_word_end(&end);
word = gtk_text_iter_get_text(&start, &end);
// Zamieniamy na wide char (no prawie)
wword = g_utf8_to_ucs4_fast(word, -1, NULL);
if (!make_lowercase(wword)) {
dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
"Podane słowo nie jest słowem słownikowym.");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
else {
// Sprawdzamy
if (dictionary_find(dict, (wchar_t *)wword)) {
dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
"Wszystko w porządku,\nśpij spokojnie");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
else {
// Czas korekty
GtkWidget *vbox, *label, *combo;
struct word_list hints;
int i;
wchar_t **words;
dictionary_hints(dict, (wchar_t *)wword, &hints);
words = (wchar_t **) word_list_get(&hints);
dialog = gtk_dialog_new_with_buttons("Korekta", NULL, 0,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
GTK_STOCK_ADD,
GTK_RESPONSE_APPLY,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
NULL);
// W treści dialogu dwa elementy
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
// Tekst
label = gtk_label_new("Słowo nie znajduje się w słowniku. Wybierz \njedną z propozycji lub dodaj słowa do słownika.");
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 1);
// Spuszczane menu
combo = gtk_combo_box_text_new();
for (i = 0; i < word_list_size(&hints); i++) {
// Combo box lubi mieć Gtk
char *uword = g_ucs4_to_utf8((gunichar *)words[i], -1, NULL, NULL, NULL);
// Dodajemy kolejny element
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), uword);
g_free(uword);
}
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
gtk_box_pack_start(GTK_BOX(vbox), combo, FALSE, FALSE, 1);
gtk_widget_show(combo);
gint click = gtk_dialog_run(GTK_DIALOG(dialog));
if (click == GTK_RESPONSE_ACCEPT) {
char *korekta =
gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo));
// Usuwamy stare
gtk_text_buffer_delete(editor_buf, &start, &end);
// Wstawiamy nowe
gtk_text_buffer_insert(editor_buf, &start, korekta, -1);
g_free(korekta);
}
// Proponujemy dodanie słowa do słownika
else if (click == GTK_RESPONSE_APPLY)
dictionary_insert(dict, wword);
gtk_widget_destroy(dialog);
}
}
g_free(word);
g_free(wword);
}
/* check for udev events for v4l2 devices*/
gboolean
check_v4l2_udev_events(gpointer data)
{
struct ALL_DATA * all_data = (struct ALL_DATA *) data;
struct vdIn *videoIn = all_data->videoIn;
struct GLOBAL *global = all_data->global;
struct GWIDGET *gwidget = all_data->gwidget;
fd_set fds;
struct timeval tv;
int ret;
FD_ZERO(&fds);
FD_SET(videoIn->udev_fd, &fds);
tv.tv_sec = 0;
tv.tv_usec = 0;
ret = select(videoIn->udev_fd+1, &fds, NULL, NULL, &tv);
/* Check if our file descriptor has received data. */
if (ret > 0 && FD_ISSET(videoIn->udev_fd, &fds))
{
/* Make the call to receive the device.
select() ensured that this will not block. */
struct udev_device *dev = udev_monitor_receive_device(videoIn->udev_mon);
if (dev)
{
if (global->debug)
{
g_print("Got Device event\n");
g_print(" Node: %s\n", udev_device_get_devnode(dev));
g_print(" Subsystem: %s\n", udev_device_get_subsystem(dev));
g_print(" Devtype: %s\n", udev_device_get_devtype(dev));
g_print(" Action: %s\n",udev_device_get_action(dev));
}
/*update device list*/
g_signal_handlers_block_by_func(GTK_COMBO_BOX_TEXT(gwidget->Devices),
G_CALLBACK (Devices_changed), all_data);
/* clear out the old device list... */
if(videoIn->listDevices != NULL) freeDevices(videoIn->listDevices);
GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model (GTK_COMBO_BOX(gwidget->Devices)));
gtk_list_store_clear(store);
/*create new device list*/
videoIn->listDevices = enum_devices( videoIn->videodevice, videoIn->udev, global->debug );
if (videoIn->listDevices->num_devices < 1)
{
//use current
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(gwidget->Devices),
videoIn->videodevice);
gtk_combo_box_set_active(GTK_COMBO_BOX(gwidget->Devices),0);
}
else
{
int i=0;
for(i=0;i<(videoIn->listDevices->num_devices);i++)
{
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(gwidget->Devices),
videoIn->listDevices->listVidDevices[i].name);
if(videoIn->listDevices->listVidDevices[i].current)
gtk_combo_box_set_active(GTK_COMBO_BOX(gwidget->Devices),i);
}
}
g_signal_handlers_unblock_by_func(GTK_COMBO_BOX_TEXT(gwidget->Devices),
G_CALLBACK (Devices_changed), all_data);
udev_device_unref(dev);
}
else
g_printerr("No Device from receive_device(). An error occured.\n");
}
return(TRUE);
}
void
pixmap_save_cb(GtkWidget *w, gpointer pixmap_ptr _U_)
{
GtkWidget *save_as_w;
#if GTK_CHECK_VERSION(2,22,0)
surface_info_t *surface_info = g_object_get_data(G_OBJECT(w), "surface-info");
#else
GdkPixmap *pixmap = g_object_get_data(G_OBJECT(w), "pixmap");
#endif
GdkPixbuf *pixbuf;
GdkPixbufFormat *pixbuf_format;
GtkWidget *main_vb, *save_as_type_hb, *type_lb, *type_cm;
GSList *file_formats,*ffp;
GdkWindow *parent;
gchar *format_name;
guint format_index = 0;
guint default_index = 0;
gchar *filename, *file_type;
GError *error = NULL;
gboolean ret;
GtkWidget *msg_dialog;
#if GTK_CHECK_VERSION(2,22,0)
pixbuf = gdk_pixbuf_get_from_surface (surface_info->surface,
0, 0, surface_info->width, surface_info->height);
#else
pixbuf = gdk_pixbuf_get_from_drawable(NULL, pixmap, NULL,
0, 0, 0, 0, -1, -1);
#endif
if(!pixbuf) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"%sCould not get image from graph%s",
simple_dialog_primary_start(),
simple_dialog_primary_end());
return;
}
save_as_w = file_selection_new("Wireshark: Save Graph As ...",
FILE_SELECTION_SAVE);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(save_as_w), TRUE);
/* Container for each row of widgets */
main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
file_selection_set_extra_widget(save_as_w, main_vb);
gtk_widget_show(main_vb);
save_as_type_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE);
gtk_box_pack_start(GTK_BOX(main_vb), save_as_type_hb, FALSE, FALSE, 0);
gtk_widget_show(save_as_type_hb);
type_lb = gtk_label_new("File type: ");
gtk_box_pack_start(GTK_BOX(save_as_type_hb), type_lb, FALSE, FALSE, 0);
gtk_widget_show(type_lb);
type_cm = gtk_combo_box_text_new();
gtk_box_pack_start(GTK_BOX(save_as_type_hb), type_cm, FALSE, FALSE, 0);
/* List all of the file formats the gdk-pixbuf library supports */
file_formats = gdk_pixbuf_get_formats();
ffp = file_formats;
while(ffp) {
pixbuf_format = ffp->data;
if (gdk_pixbuf_format_is_writable(pixbuf_format)) {
format_name = gdk_pixbuf_format_get_name(pixbuf_format);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(type_cm),
format_name);
if (!(g_ascii_strcasecmp(format_name, "png")))
default_index = format_index;
format_index++;
}
ffp = g_slist_next(ffp);
}
g_slist_free(file_formats);
gtk_combo_box_set_active(GTK_COMBO_BOX(type_cm), default_index);
gtk_widget_show(type_cm);
gtk_widget_show(save_as_w);
window_present(save_as_w);
parent = gtk_widget_get_parent_window(w);
gdk_window_set_transient_for(gtk_widget_get_window(save_as_w), parent);
/*
* Loop until the user either selects a file or gives up.
*/
for (;;) {
if (gtk_dialog_run(GTK_DIALOG(save_as_w)) != GTK_RESPONSE_ACCEPT) {
/* They clicked "Cancel" or closed the dialog or.... */
window_destroy(save_as_w);
return;
}
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(save_as_w));
/* Perhaps the user specified a directory instead of a file.
Check whether they did. */
if (test_for_directory(filename) == EISDIR) {
/* It's a directory - set the file selection box to display that
directory, and leave the selection box displayed. */
set_last_open_dir(filename);
g_free(filename);
file_selection_set_current_folder(save_as_w,
get_last_open_dir());
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(save_as_w), "");
continue;
}
file_type = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(type_cm));
ret = gdk_pixbuf_save(pixbuf, filename, file_type, &error, NULL);
g_free(filename);
g_free(file_type);
if (!ret) {
msg_dialog = gtk_message_dialog_new(GTK_WINDOW(save_as_w),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"%s", error->message);
gtk_dialog_run(GTK_DIALOG(msg_dialog));
gtk_widget_destroy(msg_dialog);
continue;
}
window_destroy(save_as_w);
return;
}
}
int
main (int argc, char *argv[])
{
GtkWidget *win;
GtkWidget *box;
GtkWidget *button;
GtkWidget *button2;
GtkBuilder *builder;
GMenuModel *model;
GSimpleActionGroup *actions;
GtkWidget *overlay;
GtkWidget *grid;
GtkWidget *popover;
GtkWidget *popover2;
GtkWidget *label;
GtkWidget *check;
GtkWidget *combo;
gtk_init (&argc, &argv);
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (win), 400, 600);
actions = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (actions), entries, G_N_ELEMENTS (entries), NULL);
gtk_widget_insert_action_group (win, "top", G_ACTION_GROUP (actions));
overlay = gtk_overlay_new ();
gtk_container_add (GTK_CONTAINER (win), overlay);
grid = gtk_grid_new ();
gtk_widget_set_halign (grid, GTK_ALIGN_FILL);
gtk_widget_set_valign (grid, GTK_ALIGN_FILL);
gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
gtk_container_add (GTK_CONTAINER (overlay), grid);
label = gtk_label_new ("");
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_vexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
label = gtk_label_new ("");
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_vexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 3, 6, 1, 1);
builder = gtk_builder_new_from_file ("popover.ui");
model = (GMenuModel *)gtk_builder_get_object (builder, "menu");
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_menu_button_new ();
gtk_container_add (GTK_CONTAINER (box), button);
button2 = gtk_menu_button_new ();
gtk_container_add (GTK_CONTAINER (box), button2);
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), model);
gtk_menu_button_set_use_popover (GTK_MENU_BUTTON (button), TRUE);
popover = GTK_WIDGET (gtk_menu_button_get_popover (GTK_MENU_BUTTON (button)));
builder = gtk_builder_new_from_file ("popover2.ui");
popover2 = (GtkWidget *)gtk_builder_get_object (builder, "popover");
gtk_menu_button_set_popover (GTK_MENU_BUTTON (button2), popover2);
g_object_set (box, "margin", 10, NULL);
gtk_widget_set_halign (box, GTK_ALIGN_END);
gtk_widget_set_valign (box, GTK_ALIGN_START);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), box);
label = gtk_label_new ("Popover hexpand");
check = gtk_check_button_new ();
g_object_bind_property (check, "active", popover, "hexpand", G_BINDING_DEFAULT);
g_object_bind_property (check, "active", popover2, "hexpand", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 1, 1, 1);
gtk_grid_attach (GTK_GRID (grid), check, 2, 1, 1, 1);
label = gtk_label_new ("Popover vexpand");
check = gtk_check_button_new ();
g_object_bind_property (check, "active", popover, "vexpand", G_BINDING_DEFAULT);
g_object_bind_property (check, "active", popover2, "vexpand", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 2, 1, 1);
gtk_grid_attach (GTK_GRID (grid), check, 2, 2, 1, 1);
label = gtk_label_new ("Button direction");
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "up", "Up");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "down", "Down");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "left", "Left");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "right", "Right");
g_object_bind_property (combo, "active", button, "direction", G_BINDING_DEFAULT);
g_object_bind_property (combo, "active", button2, "direction", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 3, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 3, 1, 1);
label = gtk_label_new ("Button halign");
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "fill", "Fill");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "start", "Start");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "end", "End");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "center", "Center");
g_object_bind_property (combo, "active", box, "halign", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 4, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 4, 1, 1);
label = gtk_label_new ("Button valign");
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "fill", "Fill");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "start", "Start");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "end", "End");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "center", "Center");
g_object_bind_property (combo, "active", box, "valign", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 5, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 5, 1, 1);
gtk_widget_show_all (win);
gtk_main ();
return 0;
}
static void _lib_geotagging_gpx_callback(GtkWidget *widget, dt_lib_module_t *self)
{
dt_lib_geotagging_t *d = (dt_lib_geotagging_t *)self->data;
/* bring a filechooser to select the gpx file to apply to selection */
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new(
_("open GPX file"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_OPEN, _("_cancel"), GTK_RESPONSE_CANCEL,
_("_open"), GTK_RESPONSE_ACCEPT, (char *)NULL);
char *last_directory = dt_conf_get_string("ui_last/gpx_last_directory");
if(last_directory != NULL)
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_directory);
g_free(last_directory);
}
GtkFileFilter *filter;
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_custom(filter, GTK_FILE_FILTER_FILENAME | GTK_FILE_FILTER_MIME_TYPE,
_lib_geotagging_filter_gpx, NULL, NULL);
gtk_file_filter_set_name(filter, _("GPS data exchange format"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_pattern(filter, "*");
gtk_file_filter_set_name(filter, _("all files"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
// add time zone selection
GtkWidget *extra_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
GtkWidget *label = gtk_label_new(_("camera time zone"));
gtk_widget_set_tooltip_text(label, _("most cameras don't store the time zone in EXIF. "
"give the correct time zone so the GPX data can be correctly matched"));
GtkWidget *tz_selection = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), "UTC");
gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), 0);
GList *iter = d->timezones;
int i = 0;
gchar *old_tz = dt_conf_get_string("plugins/lighttable/geotagging/tz");
if(iter)
{
do
{
i++;
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), (gchar *)iter->data);
if(!strcmp((gchar *)iter->data, old_tz)) gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), i);
} while((iter = g_list_next(iter)) != NULL);
}
g_free(old_tz);
gtk_box_pack_start(GTK_BOX(extra_box), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(extra_box), tz_selection, FALSE, FALSE, 0);
gtk_widget_show_all(extra_box);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser), extra_box);
if(gtk_dialog_run(GTK_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
{
gchar *folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(filechooser));
dt_conf_set_string("ui_last/gpx_last_directory", folder);
g_free(folder);
gchar *tz = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(tz_selection));
dt_conf_set_string("plugins/lighttable/geotagging/tz", tz);
gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));
dt_control_gpx_apply(filename, -1, tz);
g_free(filename);
g_free(tz);
}
gtk_widget_destroy(extra_box);
gtk_widget_destroy(filechooser);
// dt_control_queue_redraw_center();
}
/**
* Create the toolbar for the integrated UI
* @return Main toolbar (GtkToolbar*) for the integrated UI main window
*/
static GtkWidget *
create_integrated_ui_toolbar (void)
{
GtkToolbar *toolbar;
GtkToolItem *sep;
GtkWidget *w;
GError *error = NULL;
gchar *uifile;
uifile = build_ui_filename ("ui/toolbar-ui.xml");
if (!gtk_ui_manager_add_ui_from_file (_ui_manager, uifile, &error)) {
g_warning ("building menus failed: %s", error->message);
g_error_free (error);
error = NULL;
toolbar = GTK_TOOLBAR (gtk_toolbar_new ());
}
else {
toolbar = GTK_TOOLBAR(gtk_ui_manager_get_widget (_ui_manager, "/Toolbar"));
}
g_free (uifile);
/* Zoom Combo Box Entry */
w = gtk_combo_box_text_new_with_entry ();
g_object_set_data (G_OBJECT (toolbar),
DIA_INTEGRATED_TOOLBAR_ZOOM_COMBO,
w);
integrated_ui_toolbar_add_custom_item (toolbar, w);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), ZOOM_FIT);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("800%"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("400%"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("300%"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("200%"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("150%"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("100%"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("75%"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("50%"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("25%"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("10%"));
g_signal_connect (G_OBJECT (w),
"changed",
G_CALLBACK (integrated_ui_toolbar_zoom_combo_selection_changed),
NULL);
/* Get the combo's GtkEntry child to set the width for the widget */
w = gtk_bin_get_child (GTK_BIN (w));
gtk_entry_set_width_chars (GTK_ENTRY (w), 6);
g_signal_connect (G_OBJECT (w), "activate",
G_CALLBACK(integrated_ui_toolbar_zoom_activate),
NULL);
/* Seperator */
sep = gtk_separator_tool_item_new ();
gtk_toolbar_insert (toolbar, sep, -1);
gtk_widget_show (GTK_WIDGET (sep));
/* Snap to grid */
w = dia_toggle_button_new_with_icon_names ("dia-grid-on",
"dia-grid-off");
g_signal_connect (G_OBJECT (w), "toggled",
G_CALLBACK (integrated_ui_toolbar_grid_snap_toggle), toolbar);
gtk_widget_set_tooltip_text (w, _("Toggles snap-to-grid."));
g_object_set_data (G_OBJECT (toolbar),
DIA_INTEGRATED_TOOLBAR_SNAP_GRID,
w);
integrated_ui_toolbar_add_custom_item (toolbar, w);
/* Object Snapping */
w = dia_toggle_button_new_with_icon_names ("dia-mainpoints-on",
"dia-mainpoints-off");
g_signal_connect (G_OBJECT (w), "toggled",
G_CALLBACK (integrated_ui_toolbar_object_snap_toggle), toolbar);
gtk_widget_set_tooltip_text (w, _("Toggles object snapping."));
g_object_set_data (G_OBJECT (toolbar),
DIA_INTEGRATED_TOOLBAR_OBJECT_SNAP,
w);
integrated_ui_toolbar_add_custom_item (toolbar, w);
sep = gtk_separator_tool_item_new ();
gtk_toolbar_insert (toolbar, sep, -1);
gtk_widget_show (GTK_WIDGET (sep));
return GTK_WIDGET (toolbar);
}
{
gtk_window_present(GTK_WINDOW(man_addr_resolv_dlg));
}
static void
man_addr_resolv_ok(GtkWidget *w _U_, gpointer data _U_)
{
GtkWidget *addr_cb, *name_te, *resolv_cb;
const gchar *name;
gchar *addr;
gboolean active, redissect = FALSE;
addr_cb = (GtkWidget *)g_object_get_data(G_OBJECT(man_addr_resolv_dlg), "address");
name_te = (GtkWidget *)g_object_get_data(G_OBJECT(man_addr_resolv_dlg), "name");
addr = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(addr_cb));
name = gtk_entry_get_text(GTK_ENTRY(name_te));
if (strlen(addr) && strlen(name)) {
if (!add_ip_name_from_string(addr, name)) {
GtkWidget *dialog = (GtkWidget *)simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"Illegal IP address: \"%s\".", addr);
simple_dialog_set_cb(dialog, man_addr_ill_addr_cb, NULL);
g_free(addr);
return;
} else {
redissect = TRUE;
}
}
g_free(addr);
static GtkWidget *create_editor_widgets(radio_conf_t * conf)
{
GtkWidget *table;
GtkWidget *label;
table = gtk_grid_new();
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_grid_set_column_homogeneous(GTK_GRID(table), FALSE);
gtk_grid_set_row_homogeneous(GTK_GRID(table), FALSE);
gtk_grid_set_column_spacing(GTK_GRID(table), 5);
gtk_grid_set_row_spacing(GTK_GRID(table), 5);
/* Config name */
label = gtk_label_new(_("Name"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 0, 1, 1);
name = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(name), 25);
g_signal_connect(name, "changed", G_CALLBACK(name_changed), NULL);
gtk_widget_set_tooltip_text(name,
_("Enter a short name for this configuration, "
"e.g. IC910-1.\n"
"Allowed characters: "
"0..9, a..z, A..Z, - and _"));
gtk_grid_attach(GTK_GRID(table), name, 1, 0, 3, 1);
/* Host */
label = gtk_label_new(_("Host"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 1, 1, 1);
host = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(host), 50);
gtk_entry_set_text(GTK_ENTRY(host), "localhost");
gtk_widget_set_tooltip_text(host,
_("Enter the host where rigctld is running. "
"You can use both host name and IP address, "
"e.g. 192.168.1.100\n\n"
"If gpredict and rigctld are running on the "
"same computer use localhost"));
gtk_grid_attach(GTK_GRID(table), host, 1, 1, 3, 1);
/* port */
label = gtk_label_new(_("Port"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 2, 1, 1);
port = gtk_spin_button_new_with_range(1024, 65535, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(port), 4532);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(port), 0);
gtk_widget_set_tooltip_text(port,
_("Enter the port number where rigctld is "
"listening"));
gtk_grid_attach(GTK_GRID(table), port, 1, 2, 1, 1);
/* radio type */
label = gtk_label_new(_("Radio type"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
//gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4);
gtk_grid_attach(GTK_GRID(table), label, 0, 3, 1, 1);
type = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type), _("RX only"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type), _("TX only"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type), _("Simplex TRX"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type), _("Duplex TRX"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type),
_("FT817/857/897 (auto)"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type),
_("FT817/857/897 (manual)"));
gtk_combo_box_set_active(GTK_COMBO_BOX(type), RIG_TYPE_RX);
g_signal_connect(type, "changed", G_CALLBACK(type_changed), NULL);
gtk_widget_set_tooltip_markup(type,
_("<b>RX only:</b> The radio shall only be "
"used as receiver. If <i>Monitor PTT "
"status</i> is checked the doppler tuning "
"will be suspended while PTT is ON "
"(manual TX). If not, the controller will "
"always perform doppler tuning and "
"you cannot use the same RIG for uplink.\n\n"
"<b>TX only:</b> The radio shall only be "
"used for uplink. If <i>Monitor PTT status</i>"
" is checked the doppler tuning will be "
"suspended while PTT is OFF (manual RX).\n\n"
"<b>Simplex TRX:</b> The radio should be "
"used for both up- and downlink but in "
"simplex mode only. This option requires "
"that the PTT status is monitored (otherwise "
"gpredict cannot know whether to tune the "
"RX or the TX).\n\n"
"<b>Duplex:</b> The radio is a full duplex "
"radio, such as the IC910H. Gpredict will "
"be continuously tuning both uplink and "
"downlink simultaneously and not care about "
"PTT setting.\n\n"
"<b>FT817/857/897 (auto):</b> "
"This is a special mode that can be used with "
"YAESU FT-817, 857 and 897 radios. These radios"
" do not allow computer control while in TX mode."
" Therefore, TX Doppler correction is applied "
"while the radio is in RX mode by toggling "
"between VFO A/B.\n\n"
"<b>FT817/857/897 (manual):</b> "
"This is similar to the previous mode except"
" that switching to TX is done by pressing the"
" SPACE key on the keyboard. Gpredict will "
"then update the TX Doppler before actually"
" switching to TX."));
gtk_grid_attach(GTK_GRID(table), type, 1, 3, 2, 1);
/* ptt */
label = gtk_label_new(_("PTT status"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 4, 1, 1);
ptt = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(ptt), _("None"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(ptt), _("Read PTT"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(ptt), _("Read DCD"));
gtk_combo_box_set_active(GTK_COMBO_BOX(ptt), 0);
g_signal_connect(ptt, "changed", G_CALLBACK(ptt_changed), NULL);
gtk_widget_set_tooltip_markup(ptt,
_("Select PTT type.\n\n"
"<b>None:</b>\nDon't read PTT status from this radio.\n\n"
"<b>Read PTT:</b>\nRead PTT status using get_ptt CAT command. "
"You have to check that your radio and hamlib supports this.\n\n"
"<b>Read DCD:</b>\nRead PTT status using get_dcd command. "
"This can be used if your radio does not support the read_ptt "
"CAT command and you have a special interface that can "
"read squelch status and send it via CTS."));
gtk_grid_attach(GTK_GRID(table), ptt, 1, 4, 2, 1);
/* VFO Up/Down */
label = gtk_label_new(_("VFO Up/Down"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 5, 1, 1);
vfo = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo), _("Not applicable"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo),
_("MAIN \342\206\221 / SUB \342\206\223"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo),
_("SUB \342\206\221 / MAIN \342\206\223"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo),
_("A \342\206\221 / B \342\206\223"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(vfo),
_("B \342\206\221 / A \342\206\223"));
gtk_combo_box_set_active(GTK_COMBO_BOX(vfo), 0);
g_signal_connect(vfo, "changed", G_CALLBACK(vfo_changed), NULL);
gtk_widget_set_tooltip_markup(vfo,
_
("Select which VFO to use for uplink and downlink. "
"This setting is used for full-duplex radios only, "
"such as the IC-910H, FT-847 and the TS-2000.\n\n"
"<b>IC-910H:</b> MAIN\342\206\221 / SUB\342\206\223\n"
"<b>FT-847:</b> SUB\342\206\221 / MAIN\342\206\223\n"
"<b>TS-2000:</b> B\342\206\221 / A\342\206\223"));
gtk_grid_attach(GTK_GRID(table), vfo, 1, 5, 2, 1);
/* Downconverter LO frequency */
label = gtk_label_new(_("LO Down"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 6, 1, 1);
lo = gtk_spin_button_new_with_range(-10000, 10000, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lo), 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(lo), 0);
gtk_widget_set_tooltip_text(lo,
_
("Enter the frequency of the local oscillator "
" of the downconverter, if any."));
gtk_grid_attach(GTK_GRID(table), lo, 1, 6, 2, 1);
label = gtk_label_new(_("MHz"));
g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 3, 6, 1, 1);
/* Upconverter LO frequency */
label = gtk_label_new(_("LO Up"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 7, 1, 1);
loup = gtk_spin_button_new_with_range(-10000, 10000, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(loup), 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(loup), 0);
gtk_widget_set_tooltip_text(loup,
_
("Enter the frequency of the local oscillator "
"of the upconverter, if any."));
gtk_grid_attach(GTK_GRID(table), loup, 1, 7, 2, 1);
label = gtk_label_new(_("MHz"));
g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 3, 7, 1, 1);
/* AOS / LOS signalling */
label = gtk_label_new(_("Signalling"));
g_object_set(label, "xalign", 1.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 8, 1, 1);
sigaos = gtk_check_button_new_with_label(_("AOS"));
gtk_grid_attach(GTK_GRID(table), sigaos, 1, 8, 1, 1);
gtk_widget_set_tooltip_text(sigaos,
_("Enable AOS signalling for this radio."));
siglos = gtk_check_button_new_with_label(_("LOS"));
gtk_grid_attach(GTK_GRID(table), siglos, 2, 8, 1, 1);
gtk_widget_set_tooltip_text(siglos,
_("Enable LOS signalling for this radio."));
if (conf->name != NULL)
update_widgets(conf);
gtk_widget_show_all(table);
return table;
}
/**
* Notehead selection dialog
* Displays the notehead type in a Combobox
* Callback - insert_notehead
*/
void
set_notehead (GtkAction * action, DenemoScriptParam * param)
{
DenemoProject *gui = Denemo.project;
GtkWidget *dialog;
GtkWidget *label;
GtkWidget *combo;
GtkWidget *content_area;
static GList *list = NULL; //NOTE required for gtk<2.24
guint i;
if (!action)
{
if (((DenemoScriptParam *) param)->string && ((DenemoScriptParam *) param)->string->len)
{
insertnotehead (gui->movement, ((DenemoScriptParam *) param)->string->str);
((DenemoScriptParam *) param)->status = TRUE;
return;
}
else
{
if (param)
((DenemoScriptParam *) param)->status = FALSE;
return;
}
}
if (!list)
{
for (i = 0; i < 4; i++)
{
list = g_list_append (list, _(notehead[i]));
}
}
dialog = gtk_dialog_new_with_buttons (_("Change Notehead"), GTK_WINDOW (Denemo.window), (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), _("_OK"), GTK_RESPONSE_ACCEPT, _("_Cancel"), GTK_RESPONSE_REJECT, NULL);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
label = gtk_label_new (_("Select Notehead Type"));
gtk_container_add (GTK_CONTAINER (content_area), label);
#if GTK_MAJOR_VERSION==3
combo = gtk_combo_box_text_new ();
for (i = 0; i < G_N_ELEMENTS (notehead); i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), notehead[i]);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
#else
combo = gtk_combo_new ();
gtk_combo_set_popdown_strings (GTK_COMBO (combo), list);
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), _(notehead[0]));
gtk_combo_box_set_active (GTK_COMBO (combo), 0);
#endif
gtk_container_add (GTK_CONTAINER (content_area), combo);
gtk_widget_grab_focus (combo);
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
gtk_widget_show_all (dialog);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
#if GTK_MAJOR_VERSION==3
gint num = gtk_combo_box_get_active (GTK_COMBO_BOX (combo));
insertnotehead (gui->movement, notehead[num]);
#else
gchar *noteheadstring = (gchar *) gtk_entry_get_text (GTK_ENTRY (GTK_COMBO (combo)->entry));
insertnotehead (gui->movement, noteheadstring);
#endif
}
gtk_widget_destroy (dialog);
displayhelper (gui);
}
void
gui_init (dt_imageio_module_storage_t *self)
{
self->gui_data = (dt_storage_flickr_gui_data_t *)g_malloc(sizeof(dt_storage_flickr_gui_data_t));
memset(self->gui_data,0,sizeof(dt_storage_flickr_gui_data_t));
dt_storage_flickr_gui_data_t *ui= self->gui_data;
self->widget = gtk_vbox_new(FALSE, 0);
GtkWidget *hbox1=gtk_hbox_new(FALSE,5);
GtkWidget *hbox0=gtk_hbox_new(FALSE,5);
GtkWidget *vbox1=gtk_vbox_new(FALSE,0);
GtkWidget *vbox2=gtk_vbox_new(FALSE,5);
ui->label1 = GTK_LABEL( gtk_label_new( _("flickr user") ) );
ui->label3 = GTK_LABEL( gtk_label_new( _("photosets") ) );
ui->labelPerms = GTK_LABEL( gtk_label_new( _("visible to") ) );
ui->label4 = GTK_LABEL( gtk_label_new( NULL ) );
set_status(ui,_("click login button to start"), "#ffffff");
ui->label5 = GTK_LABEL( gtk_label_new( _("title") ) );
ui->label6 = GTK_LABEL( gtk_label_new( _("summary") ) );
gtk_misc_set_alignment(GTK_MISC(ui->label1), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->labelPerms), 0.0, 0.9);
gtk_misc_set_alignment(GTK_MISC(ui->label3), 0.0, 0.7);
gtk_misc_set_alignment(GTK_MISC(ui->label5), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label6), 0.0, 0.5);
ui->entry1 = GTK_ENTRY( gtk_entry_new() );
ui->entry3 = GTK_ENTRY( gtk_entry_new() ); // Album title
ui->entry4 = GTK_ENTRY( gtk_entry_new() ); // Album summary
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry1));
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry3));
dt_gui_key_accel_block_on_focus_connect (GTK_WIDGET (ui->entry4));
/*
gtk_widget_add_events(GTK_WIDGET(ui->entry1), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry1), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry1), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(ui->entry2), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry2), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry2), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(ui->entry3), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry3), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry3), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(ui->entry4), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry4), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry4), "focus-out-event", G_CALLBACK(focus_out), NULL);
*/
GHashTable* table = dt_pwstorage_get("flickr");
gchar* _username = g_strdup( g_hash_table_lookup(table, "username"));
g_hash_table_destroy(table);
gtk_entry_set_text( ui->entry1, _username == NULL?"":_username );
gtk_entry_set_text( ui->entry3, _("my new photoset") );
gtk_entry_set_text( ui->entry4, _("exported from darktable") );
GtkWidget *albumlist=gtk_hbox_new(FALSE,0);
ui->comboBox1 = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new()); // Available albums
dt_ellipsize_combo(GTK_COMBO_BOX(ui->comboBox1));
ui->dtbutton1 = DTGTK_BUTTON( dtgtk_button_new(dtgtk_cairo_paint_refresh,0) );
g_object_set(G_OBJECT(ui->dtbutton1), "tooltip-text", _("refresh album list"), (char *)NULL);
ui->button = GTK_BUTTON(gtk_button_new_with_label(_("login")));
g_object_set(G_OBJECT(ui->button), "tooltip-text", _("flickr login"), (char *)NULL);
gtk_widget_set_sensitive( GTK_WIDGET(ui->comboBox1), FALSE);
gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(ui->comboBox1), combobox_separator,ui->comboBox1,NULL);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->dtbutton1), FALSE, FALSE, 0);
ui->checkButton2 = GTK_CHECK_BUTTON( gtk_check_button_new_with_label(_("export tags")) );
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON( ui->checkButton2 ),TRUE);
ui->permsComboBox = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new());
gtk_combo_box_text_append_text(ui->permsComboBox, _("you"));
gtk_combo_box_text_append_text(ui->permsComboBox, _("friends"));
gtk_combo_box_text_append_text(ui->permsComboBox, _("family"));
gtk_combo_box_text_append_text(ui->permsComboBox, _("friends + family"));
gtk_combo_box_text_append_text(ui->permsComboBox, _("everyone"));
gtk_combo_box_set_active(GTK_COMBO_BOX(ui->permsComboBox), 0); // Set default permission to private
gtk_box_pack_start(GTK_BOX(self->widget), hbox0, TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->label1 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->entry1 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( hbox0 ), GTK_WIDGET( ui->button ), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( hbox1 ), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( hbox1 ), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( gtk_label_new("")), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->labelPerms ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label3 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->label4 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->checkButton2 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->permsComboBox ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( albumlist ), TRUE, FALSE, 0);
// Create Album
ui->hbox1=GTK_BOX(gtk_hbox_new(FALSE,5));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox1), TRUE);
vbox1=gtk_vbox_new(FALSE,0);
vbox2=gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox1), TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label5 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label6 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry3 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry4 ), TRUE, FALSE, 0);
// Setup signals
// add signal on realize and hide gtk_widget_hide(GTK_WIDGET(ui->hbox1));
g_signal_connect(G_OBJECT(ui->dtbutton1), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->button), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->entry1), "changed", G_CALLBACK(flickr_entry_changed), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->comboBox1), "changed", G_CALLBACK(flickr_album_changed), (gpointer)ui);
/**
dont' populate the combo on startup, save 3 second
// If username and password is stored, let's populate the combo
if( _username && _password )
{
ui->user_token = _password;
refresh_albums(ui);
}
*/
if( _username )
g_free (_username);
gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox1), 0);
}
static void
set_font_size (GtkWidget *widget, gint size)
{
const gchar *class[3] = { "small-font", "medium-font", "large-font" };
gtk_style_context_add_class (gtk_widget_get_style_context (widget), class[size]);
}
int
main (int argc,
char **argv)
{
GtkWidget *window, *label, *entry, *button, *grid, *notebook;
GtkWidget *vbox, *hbox, *grid_hbox, *spin, *spin2, *toggle, *combo, *image;
GtkAdjustment *adjustment;
int i, j;
GtkCssProvider *provider;
gtk_init ();
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (provider,
".small-font { font-size: 5px; }"
".medium-font { font-size: 10px; }"
".large-font { font-size: 15px; }", -1);
gtk_style_context_add_provider_for_display (gdk_display_get_default (),
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (provider);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
notebook = gtk_notebook_new ();
gtk_container_add (GTK_CONTAINER (window), notebook);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
vbox, gtk_label_new ("hboxes"));
for (j = 0; j < 2; j++)
{
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
char *aligns_names[] = { "FILL", "BASELINE" };
GtkAlign aligns[] = { GTK_ALIGN_FILL, GTK_ALIGN_BASELINE};
label = gtk_label_new (aligns_names[j]);
gtk_container_add (GTK_CONTAINER (hbox), label);
for (i = 0; i < 3; i++) {
label = gtk_label_new ("│XYyj,Ö...");
set_font_size (label, i);
gtk_widget_set_valign (label, aligns[j]);
gtk_container_add (GTK_CONTAINER (hbox), label);
}
for (i = 0; i < 3; i++) {
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "│XYyj,Ö...");
set_font_size (entry, i);
gtk_widget_set_valign (entry, aligns[j]);
gtk_container_add (GTK_CONTAINER (hbox), entry);
}
spin = gtk_spin_button_new (NULL, 0, 1);
gtk_orientable_set_orientation (GTK_ORIENTABLE (spin), GTK_ORIENTATION_VERTICAL);
gtk_widget_set_valign (spin, aligns[j]);
gtk_container_add (GTK_CONTAINER (hbox), spin);
spin = gtk_spin_button_new (NULL, 0, 1);
gtk_widget_set_valign (spin, aligns[j]);
gtk_container_add (GTK_CONTAINER (hbox), spin);
}
grid_hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[0]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[1]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[2]);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 1);
gtk_container_add (GTK_CONTAINER (hbox), combo);
for (j = 0; j < 2; j++)
{
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (baseline_position_changed), hbox);
if (j == 0)
label = gtk_label_new ("Baseline:");
else
label = gtk_label_new ("Normal:");
gtk_container_add (GTK_CONTAINER (hbox), label);
for (i = 0; i < 3; i++)
{
button = gtk_button_new_with_label ("│Xyj,Ö");
set_font_size (button, i);
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
for (i = 0; i < 3; i++)
{
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("│Xyj,Ö"));
gtk_container_add (GTK_CONTAINER (box), gtk_image_new_from_icon_name ("face-sad"));
gtk_container_add (GTK_CONTAINER (button), box);
set_font_size (button, i);
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
image = gtk_image_new_from_icon_name ("face-sad");
gtk_image_set_pixel_size (GTK_IMAGE (image), 34);
if (j == 0)
gtk_widget_set_valign (image, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), image);
button = gtk_toggle_button_new_with_label ("│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
button = gtk_toggle_button_new_with_label ("│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
button = gtk_check_button_new_with_label ("│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
button = gtk_radio_button_new_with_label (NULL, "│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
vbox, gtk_label_new ("grid"));
grid_hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
label = gtk_label_new ("Align me:");
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), label);
grid = gtk_grid_new ();
gtk_widget_set_valign (grid, GTK_ALIGN_BASELINE);
gtk_grid_set_column_spacing (GTK_GRID (grid), 8);
gtk_grid_set_row_spacing (GTK_GRID (grid), 8);
for (j = 0; j < 4; j++)
{
char *labels[] = { "Normal:", "Baseline (top):", "Baseline (center):", "Baseline (bottom):"};
label = gtk_label_new (labels[j]);
gtk_grid_attach (GTK_GRID (grid),
label,
0, j,
1, 1);
gtk_widget_set_vexpand (label, TRUE);
if (j != 0)
gtk_grid_set_row_baseline_position (GTK_GRID (grid),
j, (GtkBaselinePosition)(j-1));
for (i = 0; i < 3; i++)
{
label = gtk_label_new ("Xyjg,Ö.");
set_font_size (label, i);
if (j != 0)
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
gtk_grid_attach (GTK_GRID (grid),
label,
i+1, j,
1, 1);
}
for (i = 0; i < 3; i++)
{
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("│Xyj,Ö"));
gtk_container_add (GTK_CONTAINER (box), gtk_image_new_from_icon_name ("face-sad"));
gtk_container_add (GTK_CONTAINER (button), box);
set_font_size (button, i);
if (j != 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_grid_attach (GTK_GRID (grid),
button,
i+4, j,
1, 1);
}
}
gtk_container_add (GTK_CONTAINER (hbox), grid);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
adjustment = gtk_adjustment_new (0.0, -1.0, 5.0, 1.0, 1.0, 0.0);
spin = gtk_spin_button_new (adjustment, 1.0, 0);
g_signal_connect (spin, "value-changed", (GCallback)baseline_row_value_changed, grid);
gtk_container_add (GTK_CONTAINER (hbox), spin);
toggle = gtk_toggle_button_new_with_label ("Homogeneous");
g_signal_connect (toggle, "toggled", (GCallback)homogeneous_changed, grid);
gtk_container_add (GTK_CONTAINER (hbox), toggle);
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[0]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[1]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[2]);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 1);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (baseline_position_changed), grid_hbox);
gtk_container_add (GTK_CONTAINER (hbox), combo);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
vbox, gtk_label_new ("button box"));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
adjustment = gtk_adjustment_new (34.0, 1.0, 64.0, 1.0, 1.0, 0.0);
spin = gtk_spin_button_new (adjustment, 1.0, 0);
gtk_container_add (GTK_CONTAINER (hbox), spin);
adjustment = gtk_adjustment_new (16.0, 1.0, 64.0, 1.0, 1.0, 0.0);
spin2 = gtk_spin_button_new (adjustment, 1.0, 0);
gtk_container_add (GTK_CONTAINER (hbox), spin2);
for (j = 0; j < 3; j++)
{
hbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
gtk_box_set_baseline_position (GTK_BOX (hbox), j);
label = gtk_label_new (baseline_pos_str[j]);
gtk_container_add (GTK_CONTAINER (hbox), label);
gtk_widget_set_vexpand (label, TRUE);
image = gtk_image_new_from_icon_name ("face-sad");
gtk_image_set_pixel_size (GTK_IMAGE (image), 34);
gtk_container_add (GTK_CONTAINER (hbox), image);
g_signal_connect (spin, "value-changed", (GCallback)image_size_value_changed, image);
for (i = 0; i < 3; i++)
{
button = gtk_button_new_with_label ("│Xyj,Ö");
set_font_size (button, i);
if (i != 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
for (i = 0; i < 3; i++)
{
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("│Xyj,Ö"));
image = gtk_image_new_from_icon_name ("face-sad");
gtk_image_set_pixel_size (GTK_IMAGE (image), 16);
gtk_container_add (GTK_CONTAINER (box), image);
gtk_container_add (GTK_CONTAINER (button), box);
if (i == 0)
g_signal_connect (spin2, "value-changed", (GCallback)image_size_value_changed, image);
set_font_size (button, i);
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
}
gtk_widget_show (window);
gtk_main ();
return 0;
}
/**
* e_webdav_discover_content_refresh:
* @content: a WebDAV discovery content, created by e_webdav_discover_content_new()
* @display_name: (allow-none): optional display name to use for scratch sources
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
* @callback: (scope async): a #GAsyncReadyCallback to call when the request
* is satisfied
* @user_data: (closure): data to pass to the callback function
*
* Asynchronously starts refresh of the @content. This means to access the server
* and search it for available sources. The @content shows a feedback and a Cancel
* button during the operation.
*
* The @display_name is used only if the @content wasn't created with an #ESource and
* it's shown in the password prompts, if there are required any.
*
* When the operation is finished, @callback will be called. You can then
* call e_webdav_discover_content_refresh_finish() to get the result of the operation.
*
* Since: 3.18
**/
void
e_webdav_discover_content_refresh (GtkWidget *content,
const gchar *display_name,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
EWebDAVDiscoverContentData *data;
RefreshData *rd;
ESource *source;
SoupURI *soup_uri;
GtkWidget *label;
g_return_if_fail (GTK_IS_GRID (content));
data = g_object_get_data (G_OBJECT (content), WEBDAV_DISCOVER_CONTENT_DATA_KEY);
g_return_if_fail (data != NULL);
g_return_if_fail (data->base_url != NULL);
soup_uri = soup_uri_new (data->base_url);
if (!soup_uri) {
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (G_OBJECT (content), callback, user_data, e_webdav_discover_content_refresh);
g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Invalid URL"));
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
}
if (!soup_uri_get_user (soup_uri)) {
GSimpleAsyncResult *simple;
soup_uri_free (soup_uri);
simple = g_simple_async_result_new (G_OBJECT (content), callback, user_data, e_webdav_discover_content_refresh);
g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("User name not filled"));
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
}
rd = g_new0 (RefreshData, 1);
rd->content = g_object_ref (content);
rd->cancellable = cancellable ? g_object_ref (cancellable) : g_cancellable_new ();
rd->simple = g_simple_async_result_new (G_OBJECT (content), callback, user_data, e_webdav_discover_content_refresh);
rd->base_url = g_strdup (data->base_url);
rd->credentials = NULL;
if (data->source) {
source = g_object_ref (data->source);
} else {
ESourceWebdav *webdav_extension;
ESourceAuthentication *auth_extension;
source = e_source_new_with_uid (data->base_url, NULL, NULL);
g_return_if_fail (source != NULL);
webdav_extension = e_source_get_extension (source, E_SOURCE_EXTENSION_WEBDAV_BACKEND);
auth_extension = e_source_get_extension (source, E_SOURCE_EXTENSION_AUTHENTICATION);
if (display_name && *display_name)
e_source_set_display_name (source, display_name);
e_source_webdav_set_soup_uri (webdav_extension, soup_uri);
e_source_authentication_set_host (auth_extension, soup_uri_get_host (soup_uri));
e_source_authentication_set_port (auth_extension, soup_uri_get_port (soup_uri));
e_source_authentication_set_user (auth_extension, soup_uri_get_user (soup_uri));
}
gtk_list_store_clear (GTK_LIST_STORE (gtk_tree_view_get_model (data->sources_tree_view)));
if (data->email_addresses_combo)
gtk_combo_box_text_remove_all (GTK_COMBO_BOX_TEXT (data->email_addresses_combo));
if (data->info_bar)
gtk_widget_destroy (GTK_WIDGET (data->info_bar));
data->info_bar = GTK_INFO_BAR (gtk_info_bar_new_with_buttons (_("Cancel"), GTK_RESPONSE_CANCEL, NULL));
gtk_info_bar_set_message_type (data->info_bar, GTK_MESSAGE_INFO);
gtk_info_bar_set_show_close_button (data->info_bar, FALSE);
label = gtk_label_new (_("Searching server sources..."));
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (data->info_bar)), label);
gtk_widget_show (label);
gtk_widget_show (GTK_WIDGET (data->info_bar));
g_signal_connect (data->info_bar, "response", G_CALLBACK (e_webdav_discover_info_bar_response_cb), rd);
gtk_widget_set_sensitive (GTK_WIDGET (data->sources_tree_view), FALSE);
if (data->email_addresses_combo)
gtk_widget_set_sensitive (GTK_WIDGET (data->email_addresses_combo), FALSE);
gtk_grid_attach (GTK_GRID (content), GTK_WIDGET (data->info_bar), 0, 2, 1, 1);
e_webdav_discover_sources (source, rd->base_url, E_WEBDAV_DISCOVER_SUPPORTS_NONE, rd->credentials, rd->cancellable,
e_webdav_discover_content_refresh_done_cb, rd);
g_object_unref (source);
soup_uri_free (soup_uri);
}
static void
activate (GtkApplication* app,
gpointer user_data)
{
GtkWidget *window;
GtkWidget *bases, *keyLength, *errorBits, *errorTolerance, *playButton,
*mode, *peerIp, *eveRate, *eveStrategy, *channelNoise,
*genBias;
GtkWidget *windowBox, *optionGrid, *playGrid, *playBox;
GtkWidget *baseLabel, *keyLengthLabel, *errorBitsLabel,
*errorToleranceLabel, *peerIpLabel, *eveRateLabel,
*eveStrategyLabel, *channelNoiseLabel, *genBiasLabel;
GtkWidget *tty1;
GtkWidget *tty2;
window = gtk_application_window_new (app);
gtk_window_set_title (GTK_WINDOW (window), "Quantum Network Simulator");
gtk_window_set_default_size (GTK_WINDOW (window), 1280, 720);
windowBox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_container_add(GTK_CONTAINER(window), windowBox);
playBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(windowBox), playBox);
optionGrid = gtk_grid_new ();
gtk_container_add(GTK_CONTAINER(playBox), optionGrid);
playGrid = gtk_grid_new ();
gtk_grid_set_column_spacing(GTK_GRID(playGrid), 20);
gtk_container_add(GTK_CONTAINER(playBox), playGrid);
mode = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Superposition Tutorial");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Measurement Tutorial");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Classic BB84 Tutorial");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Polybase BB84 Tutorial");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Bias BB84 Tutorial");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Freestyle BB84");
gtk_grid_attach(GTK_GRID( optionGrid ), mode, 0, 0, 2, 1);
baseLabel = gtk_label_new("Number of bases");
bases = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), baseLabel , 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), bases , 1, 1, 1, 1);
keyLengthLabel = gtk_label_new("Key Length");
keyLength = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), keyLengthLabel , 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), keyLength, 1, 2, 1, 1);
errorBitsLabel = gtk_label_new("Number of error detection bits");
errorBits = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorBitsLabel , 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorBits , 1, 3, 1, 1);
errorToleranceLabel = gtk_label_new("Number of error bits to tolerate");
errorTolerance = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 0, 4, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 1, 4, 1, 1);
errorToleranceLabel = gtk_label_new("Peer IP");
errorTolerance = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 0, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 0, 1, 1);
errorToleranceLabel = gtk_label_new("Eve Eavesdrop Rate");
errorTolerance = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 1, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 1, 1, 1);
errorToleranceLabel = gtk_label_new("Eve Eavesdrop Strategy");
errorTolerance = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 2, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 2, 1, 1);
errorToleranceLabel = gtk_label_new("Generator Bias");
errorTolerance = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 3, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 3, 1, 1);
errorToleranceLabel = gtk_label_new("Channel Noise");
errorTolerance = gtk_entry_new ();
gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 4, 1, 1);
gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 4, 1, 1);
playButton = gtk_button_new_with_label("PLAY QUANTUM ALGORITHM");
g_signal_connect (playButton, "clicked", G_CALLBACK(playAlgorithm), playButton);
// g_signal_connect_swapped (playButton, "clicked", G_CALLBACK(gtk_widget_destroy), window);
gtk_grid_attach(GTK_GRID( optionGrid ), playButton, 0, 5, 4, 1);
char *startTerm[2] = {0,0};
startTerm[0] = vte_get_user_shell();
GPid pidTerm;
tty1 = vte_terminal_new();
vte_terminal_fork_command_full(VTE_TERMINAL(tty1),
VTE_PTY_DEFAULT,
NULL, //"/tmp",
startTerm,
NULL,
(GSpawnFlags)(G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH),
NULL,
NULL,
NULL,
NULL );
gtk_widget_set_size_request(tty1, 600, 400);
gtk_grid_attach(GTK_GRID (playGrid ), tty1, 0, 6, 4, 15);
gtk_widget_set_sensitive(tty1, FALSE);
tty2 = vte_terminal_new();
vte_terminal_fork_command_full(VTE_TERMINAL(tty2),
VTE_PTY_DEFAULT,
NULL, //"/tmp",
startTerm,
NULL,
(GSpawnFlags)(G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH),
NULL,
NULL,
NULL,
NULL );
gtk_widget_set_size_request(tty2, 600, 400);
gtk_grid_attach(GTK_GRID (playGrid ), tty2, 4, 6, 4, 15);
gtk_widget_set_sensitive(tty2, FALSE);
g_object_set_data(G_OBJECT(playButton), "tty1", VTE_TERMINAL(tty1));
g_object_set_data(G_OBJECT(playButton), "tty2", VTE_TERMINAL(tty2));
g_object_set_data(G_OBJECT(playButton), "in_mode", GTK_COMBO_BOX_TEXT(mode));
g_object_set_data(G_OBJECT(playButton), "in_bases", GTK_ENTRY(bases));
g_object_set_data(G_OBJECT(playButton), "in_keyLength", GTK_ENTRY(keyLength));
g_object_set_data(G_OBJECT(playButton), "in_errorBits", GTK_ENTRY(errorBits));
g_object_set_data(G_OBJECT(playButton), "in_errorTolerance", GTK_ENTRY(errorTolerance));
gtk_widget_show_all (window);
}
void gui_init(dt_lib_module_t *self)
{
unsigned int i;
GtkWidget *container = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5));
GtkWidget *output_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5));
GtkWidget *output_options = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5));
GtkWidget *picker_subrow = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(2));
GtkWidget *restrict_button;
GtkWidget *samples_label = dt_ui_section_label_new(_("live samples"));
GtkWidget *samples_options_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(2));
// Initializing self data structure
dt_lib_colorpicker_t *data = (dt_lib_colorpicker_t *)calloc(1, sizeof(dt_lib_colorpicker_t));
self->data = (void *)data;
data->rgb.red = 0.7;
data->rgb.green = 0.7;
data->rgb.blue = 0.7;
data->rgb.alpha = 1.0;
// Initializing proxy functions and data
darktable.lib->proxy.colorpicker.module = self;
darktable.lib->proxy.colorpicker.size = dt_conf_get_int("ui_last/colorpicker_size");
darktable.lib->proxy.colorpicker.display_samples = dt_conf_get_int("ui_last/colorpicker_display_samples");
darktable.lib->proxy.colorpicker.live_samples = NULL;
darktable.lib->proxy.colorpicker.picked_color_rgb_mean = (uint8_t *)malloc(sizeof(uint8_t) * 3);
darktable.lib->proxy.colorpicker.picked_color_rgb_min = (uint8_t *)malloc(sizeof(uint8_t) * 3);
darktable.lib->proxy.colorpicker.picked_color_rgb_max = (uint8_t *)malloc(sizeof(uint8_t) * 3);
darktable.lib->proxy.colorpicker.picked_color_lab_mean = (float *)malloc(sizeof(float) * 3);
darktable.lib->proxy.colorpicker.picked_color_lab_min = (float *)malloc(sizeof(float) * 3);
darktable.lib->proxy.colorpicker.picked_color_lab_max = (float *)malloc(sizeof(float) * 3);
for(i = 0; i < 3; i++)
darktable.lib->proxy.colorpicker.picked_color_rgb_mean[i]
= darktable.lib->proxy.colorpicker.picked_color_rgb_min[i]
= darktable.lib->proxy.colorpicker.picked_color_rgb_max[i] = 0;
for(i = 0; i < 3; i++)
darktable.lib->proxy.colorpicker.picked_color_lab_mean[i]
= darktable.lib->proxy.colorpicker.picked_color_lab_min[i]
= darktable.lib->proxy.colorpicker.picked_color_lab_max[i] = 0;
darktable.lib->proxy.colorpicker.update_panel = _update_picker_output;
darktable.lib->proxy.colorpicker.update_samples = _update_samples_output;
darktable.lib->proxy.colorpicker.set_sample_area = _set_sample_area;
darktable.lib->proxy.colorpicker.set_sample_point = _set_sample_point;
// Setting up the GUI
self->widget = container;
gtk_box_pack_start(GTK_BOX(container), output_row, TRUE, TRUE, 0);
// The color patch
data->color_patch = gtk_drawing_area_new();
gtk_widget_set_size_request(data->color_patch, DT_PIXEL_APPLY_DPI(100), DT_PIXEL_APPLY_DPI(100));
g_signal_connect(G_OBJECT(data->color_patch), "draw", G_CALLBACK(main_draw_callback), data);
gtk_box_pack_start(GTK_BOX(output_row), data->color_patch, FALSE, FALSE, 0);
// The picker button, output selectors and label
gtk_box_pack_start(GTK_BOX(output_row), output_options, TRUE, TRUE, 0);
data->size_selector = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->size_selector), _("point"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->size_selector), _("area"));
gtk_combo_box_set_active(GTK_COMBO_BOX(data->size_selector), dt_conf_get_int("ui_last/colorpicker_size"));
gtk_widget_set_size_request(data->size_selector, DT_PIXEL_APPLY_DPI(30), -1);
gtk_box_pack_start(GTK_BOX(picker_subrow), data->size_selector, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->size_selector), "changed", G_CALLBACK(_size_changed), (gpointer)self);
data->picker_button = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_BOX);
gtk_widget_set_size_request(data->picker_button, DT_PIXEL_APPLY_DPI(50), -1);
gtk_box_pack_start(GTK_BOX(picker_subrow), data->picker_button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(data->picker_button), "toggled", G_CALLBACK(_picker_button_toggled), self);
gtk_box_pack_start(GTK_BOX(output_options), picker_subrow, TRUE, TRUE, 0);
data->statistic_selector = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->statistic_selector), _("mean"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->statistic_selector), _("min"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->statistic_selector), _("max"));
gtk_combo_box_set_active(GTK_COMBO_BOX(data->statistic_selector),
dt_conf_get_int("ui_last/colorpicker_mode"));
gtk_widget_set_sensitive(data->statistic_selector, dt_conf_get_int("ui_last/colorpicker_size"));
gtk_box_pack_start(GTK_BOX(output_options), data->statistic_selector, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->statistic_selector), "changed", G_CALLBACK(_statistic_changed), self);
data->color_mode_selector = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->color_mode_selector), _("RGB"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->color_mode_selector), _("Lab"));
gtk_combo_box_set_active(GTK_COMBO_BOX(data->color_mode_selector),
dt_conf_get_int("ui_last/colorpicker_model"));
gtk_box_pack_start(GTK_BOX(output_options), data->color_mode_selector, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->color_mode_selector), "changed", G_CALLBACK(_color_mode_changed), self);
data->output_label = gtk_label_new("");
gtk_label_set_justify(GTK_LABEL(data->output_label), GTK_JUSTIFY_CENTER);
gtk_widget_set_size_request(data->output_label, DT_PIXEL_APPLY_DPI(80), -1);
gtk_box_pack_start(GTK_BOX(output_options), data->output_label, FALSE, FALSE, 0);
restrict_button = gtk_check_button_new_with_label(_("restrict histogram to selection"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(restrict_button),
dt_conf_get_int("ui_last/colorpicker_restrict_histogram"));
darktable.lib->proxy.colorpicker.restrict_histogram
= dt_conf_get_int("ui_last/colorpicker_restrict_histogram");
gtk_box_pack_start(GTK_BOX(container), restrict_button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(restrict_button), "toggled", G_CALLBACK(_restrict_histogram_changed), NULL);
// Adding the live samples section
gtk_box_pack_start(GTK_BOX(container), samples_label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(container), samples_options_row, TRUE, TRUE, 0);
data->samples_statistic_selector = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_statistic_selector), _("mean"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_statistic_selector), _("min"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_statistic_selector), _("max"));
gtk_combo_box_set_active(GTK_COMBO_BOX(data->samples_statistic_selector),
dt_conf_get_int("ui_last/colorsamples_mode"));
gtk_box_pack_start(GTK_BOX(samples_options_row), data->samples_statistic_selector, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->samples_statistic_selector), "changed",
G_CALLBACK(_samples_statistic_changed), self);
data->samples_mode_selector = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_mode_selector), _("RGB"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(data->samples_mode_selector), _("Lab"));
gtk_combo_box_set_active(GTK_COMBO_BOX(data->samples_mode_selector),
dt_conf_get_int("ui_last/colorsamples_model"));
gtk_box_pack_start(GTK_BOX(samples_options_row), data->samples_mode_selector, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->samples_mode_selector), "changed", G_CALLBACK(_samples_mode_changed), self);
data->add_sample_button = gtk_button_new_with_label(_("add"));
gtk_widget_set_sensitive(data->add_sample_button, FALSE);
gtk_box_pack_start(GTK_BOX(samples_options_row), data->add_sample_button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(data->add_sample_button), "clicked", G_CALLBACK(_add_sample), self);
data->samples_container = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(2));
gtk_box_pack_start(GTK_BOX(container), data->samples_container, TRUE, TRUE, 0);
data->display_samples_check_box = gtk_check_button_new_with_label(_("display sample areas on image"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->display_samples_check_box),
dt_conf_get_int("ui_last/colorpicker_display_samples"));
gtk_box_pack_start(GTK_BOX(container), data->display_samples_check_box, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->display_samples_check_box), "toggled", G_CALLBACK(_display_samples_changed),
NULL);
}
void create_alert_form(GtkWidget *widget, char* type) {
UNUSED(widget);
GtkWidget *windowAlertForm;
GtkWidget *compte_cat_list, *type_temps_list;
GtkWidget *montant_field;
GtkWidget *button_create_alert, *button_exit;
GtkWidget *grid;
windowAlertForm = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(windowAlertForm), "Creation d'alerte");
gtk_window_set_default_size(GTK_WINDOW(windowAlertForm), 400,400);
gtk_window_set_position(GTK_WINDOW(windowAlertForm), GTK_WIN_POS_CENTER);
grid = gtk_grid_new();
gtk_container_add(GTK_CONTAINER(windowAlertForm), grid);
montant_field = gtk_entry_new();
compte_cat_list = gtk_combo_box_text_new();
char **listCompteCat;
if (strcmp(type, "max_cat") == 0) {
listCompteCat = bdd_get_categorie();
gtk_entry_set_placeholder_text(GTK_ENTRY(montant_field), "maximum autorise");
} else if (strcmp(type, "min_account") == 0) {
listCompteCat = bdd_get_libelle_account();
gtk_entry_set_placeholder_text(GTK_ENTRY(montant_field), "minimum autorise");
}
while(*listCompteCat != NULL) {
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(compte_cat_list), NULL, *listCompteCat);
listCompteCat++;
}
gtk_combo_box_set_active(GTK_COMBO_BOX(compte_cat_list), 0);
type_temps_list = gtk_combo_box_text_new();
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(type_temps_list), NULL, "monthly");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(type_temps_list), NULL, "yearly");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(type_temps_list), NULL, "total");
gtk_combo_box_set_active(GTK_COMBO_BOX(type_temps_list), 0);
//linking GtkWidgets to entries to send to create_alert function
alert_entry_t *entries = (alert_entry_t*) malloc(sizeof(alert_entry_t));
strcpy(entries->type, type);
entries->type_temps = type_temps_list;
entries->compte_cat = compte_cat_list;
entries->montant = montant_field;
button_create_alert = gtk_button_new_with_label("Create Alert");
g_signal_connect(GTK_BUTTON(button_create_alert), "clicked", G_CALLBACK(create_alert), entries);
button_exit = gtk_button_new_with_label("Exit form");
g_signal_connect(GTK_BUTTON(button_exit), "clicked", G_CALLBACK(close_window), windowAlertForm);
gtk_grid_attach(GTK_GRID(grid), compte_cat_list, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(grid), type_temps_list, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(grid), montant_field, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(grid), button_create_alert, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(grid), button_exit, 0, 4, 1, 1);
gtk_widget_show_all(windowAlertForm);
}
void DisplayDialog()
{
int return_value;
GtkWidget *dialog;
GtkWidget *main_frame, *main_box;
GtkWidget *mixing_frame, *mixing_box;
GtkWidget *int_label, *int_box;
GtkWidget *effects_check;
GtkWidget *dealias_filter;
GtkWidget *debug_check;
GtkWidget *debug_button;
GtkWidget *output_frame, *output_box;
GtkWidget *mod_label, *mod_box;
GtkWidget *api_label, *api_box;
#if SDL_MAJOR_VERSION >= 2
GtkWidget *sdl_api_label, *sdl_api_box;
#endif
GtkWidget *latency_label, *latency_slide;
GtkWidget *sync_label, *sync_box;
GtkWidget *advanced_button;
/* Create the widgets */
dialog = gtk_dialog_new_with_buttons(
"SPU2-X Config",
NULL, /* parent window*/
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
"OK", GTK_RESPONSE_ACCEPT,
"Cancel", GTK_RESPONSE_REJECT,
NULL);
int_label = gtk_label_new("Interpolation:");
int_box = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "0 - Nearest (fastest/bad quality)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "1 - Linear (simple/okay sound)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "2 - Cubic (artificial highs)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "3 - Hermite (better highs)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(int_box), "4 - Catmull-Rom (PS2-like/slow)");
gtk_combo_box_set_active(GTK_COMBO_BOX(int_box), Interpolation);
effects_check = gtk_check_button_new_with_label("Disable Effects Processing");
dealias_filter = gtk_check_button_new_with_label("Use the de-alias filter (overemphasizes the highs)");
debug_check = gtk_check_button_new_with_label("Enable Debug Options");
debug_button = gtk_button_new_with_label("Debug...");
mod_label = gtk_label_new("Module:");
mod_box = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(mod_box), "0 - No Sound (emulate SPU2 only)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(mod_box), "1 - PortAudio (cross-platform)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(mod_box), "2 - SDL Audio (recommended for PulseAudio)");
//gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(mod_box), "3 - Alsa (probably doesn't work)");
gtk_combo_box_set_active(GTK_COMBO_BOX(mod_box), OutputModule);
api_label = gtk_label_new("PortAudio API:");
api_box = gtk_combo_box_text_new();
#ifdef __linux__
// In order to keep it the menu light, I only put linux major api
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(api_box), "0 - ALSA (recommended)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(api_box), "1 - OSS (legacy)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(api_box), "2 - JACK");
#else
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(api_box), "OSS");
#endif
gtk_combo_box_set_active(GTK_COMBO_BOX(api_box), OutputAPI);
#if SDL_MAJOR_VERSION >= 2
sdl_api_label = gtk_label_new("SDL API:");
sdl_api_box = gtk_combo_box_text_new();
// YES It sucks ...
for (int i = 0; i < SDL_GetNumAudioDrivers(); ++i) {
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sdl_api_box), SDL_GetAudioDriver(i));
}
gtk_combo_box_set_active(GTK_COMBO_BOX(sdl_api_box), SdlOutputAPI);
#endif
latency_label = gtk_label_new("Latency:");
const int min_latency = SynchMode == 0 ? LATENCY_MIN_TIMESTRETCH : LATENCY_MIN;
#if GTK_MAJOR_VERSION < 3
latency_slide = gtk_hscale_new_with_range(min_latency, LATENCY_MAX, 5);
#else
latency_slide = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, min_latency, LATENCY_MAX, 5);
#endif
gtk_range_set_value(GTK_RANGE(latency_slide), SndOutLatencyMS);
sync_label = gtk_label_new("Synchronization Mode:");
sync_box = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sync_box), "TimeStretch (Recommended)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sync_box), "Async Mix (Breaks some games!)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(sync_box), "None (Audio can skip.)");
gtk_combo_box_set_active(GTK_COMBO_BOX(sync_box), SynchMode);
advanced_button = gtk_button_new_with_label("Advanced...");
#if GTK_MAJOR_VERSION < 3
main_box = gtk_hbox_new(false, 5);
#else
main_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
#endif
main_frame = gtk_frame_new("SPU2-X Config");
gtk_container_add(GTK_CONTAINER(main_frame), main_box);
#if GTK_MAJOR_VERSION < 3
mixing_box = gtk_vbox_new(false, 5);
#else
mixing_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
#endif
mixing_frame = gtk_frame_new("Mixing Settings:");
gtk_container_add(GTK_CONTAINER(mixing_frame), mixing_box);
#if GTK_MAJOR_VERSION < 3
output_box = gtk_vbox_new(false, 5);
#else
output_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
#endif
output_frame = gtk_frame_new("Output Settings:");
gtk_container_add(GTK_CONTAINER(output_frame), output_box);
gtk_container_add(GTK_CONTAINER(mixing_box), int_label);
gtk_container_add(GTK_CONTAINER(mixing_box), int_box);
gtk_container_add(GTK_CONTAINER(mixing_box), effects_check);
gtk_container_add(GTK_CONTAINER(mixing_box), dealias_filter);
gtk_container_add(GTK_CONTAINER(mixing_box), debug_check);
gtk_container_add(GTK_CONTAINER(mixing_box), debug_button);
gtk_container_add(GTK_CONTAINER(output_box), mod_label);
gtk_container_add(GTK_CONTAINER(output_box), mod_box);
gtk_container_add(GTK_CONTAINER(output_box), api_label);
gtk_container_add(GTK_CONTAINER(output_box), api_box);
#if SDL_MAJOR_VERSION >= 2
gtk_container_add(GTK_CONTAINER(output_box), sdl_api_label);
gtk_container_add(GTK_CONTAINER(output_box), sdl_api_box);
#endif
gtk_container_add(GTK_CONTAINER(output_box), sync_label);
gtk_container_add(GTK_CONTAINER(output_box), sync_box);
gtk_container_add(GTK_CONTAINER(output_box), latency_label);
gtk_container_add(GTK_CONTAINER(output_box), latency_slide);
gtk_container_add(GTK_CONTAINER(output_box), advanced_button);
gtk_container_add(GTK_CONTAINER(main_box), mixing_frame);
gtk_container_add(GTK_CONTAINER(main_box), output_frame);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(effects_check), EffectsDisabled);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dealias_filter), postprocess_filter_dealias);
//FinalVolume;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(debug_check), DebugEnabled);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), main_frame);
gtk_widget_show_all(dialog);
g_signal_connect(sync_box, "changed", G_CALLBACK(cb_adjust_latency), latency_slide);
g_signal_connect_swapped(advanced_button, "clicked", G_CALLBACK(advanced_dialog), advanced_button);
g_signal_connect_swapped(debug_button, "clicked", G_CALLBACK(debug_dialog), debug_button);
return_value = gtk_dialog_run(GTK_DIALOG(dialog));
if (return_value == GTK_RESPONSE_ACCEPT) {
DebugEnabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(debug_check));
postprocess_filter_dealias = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dealias_filter));
if (gtk_combo_box_get_active(GTK_COMBO_BOX(int_box)) != -1)
Interpolation = gtk_combo_box_get_active(GTK_COMBO_BOX(int_box));
EffectsDisabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(effects_check));
//FinalVolume;
if (gtk_combo_box_get_active(GTK_COMBO_BOX(mod_box)) != -1)
OutputModule = gtk_combo_box_get_active(GTK_COMBO_BOX(mod_box));
if (gtk_combo_box_get_active(GTK_COMBO_BOX(api_box)) != -1) {
OutputAPI = gtk_combo_box_get_active(GTK_COMBO_BOX(api_box));
#ifdef __linux__
switch (OutputAPI) {
case 0:
PortaudioOut->SetApiSettings(L"ALSA");
break;
case 1:
PortaudioOut->SetApiSettings(L"OSS");
break;
case 2:
PortaudioOut->SetApiSettings(L"JACK");
break;
default:
PortaudioOut->SetApiSettings(L"Unknown");
}
#else
switch (OutputAPI) {
case 0:
PortaudioOut->SetApiSettings(L"OSS");
break;
default:
PortaudioOut->SetApiSettings(L"Unknown");
}
#endif
}
#if SDL_MAJOR_VERSION >= 2
if (gtk_combo_box_get_active(GTK_COMBO_BOX(sdl_api_box)) != -1) {
SdlOutputAPI = gtk_combo_box_get_active(GTK_COMBO_BOX(sdl_api_box));
// YES It sucks ...
SDLOut->SetApiSettings(wxString(SDL_GetAudioDriver(SdlOutputAPI), wxConvUTF8));
}
#endif
SndOutLatencyMS = gtk_range_get_value(GTK_RANGE(latency_slide));
if (gtk_combo_box_get_active(GTK_COMBO_BOX(sync_box)) != -1)
SynchMode = gtk_combo_box_get_active(GTK_COMBO_BOX(sync_box));
}
gtk_widget_destroy(dialog);
}
/*
* update the controls widgets state
* args:
* none
*
* asserts:
* none
*
* returns: none
*/
void gui_gtk3_update_controls_state()
{
v4l2_ctrl_t *current = v4l2core_get_control_list();
for(; current != NULL; current = current->next)
{
if(current == NULL)
{
fprintf(stderr, "GUVCVIEW: ERROR (update controls state) empty control in list\n");
break;
}
control_widgets_t *cur_widget = gui_gtk3_get_widgets_by_id(current->control.id);
if(!cur_widget)
{
fprintf(stderr, "GUVCVIEW: (update widget state): control %x doesn't have a widget set\n", current->control.id);
continue;
}
/*update controls values*/
switch(current->control.type)
{
#ifdef V4L2_CTRL_TYPE_STRING
case V4L2_CTRL_TYPE_STRING:
{
char *text_input = g_strescape(current->string, "");
gtk_entry_set_text (GTK_ENTRY(cur_widget->widget), text_input);
g_free(text_input);
break;
}
#endif
case V4L2_CTRL_TYPE_BOOLEAN:
/*disable widget signals*/
g_signal_handlers_block_by_func(GTK_TOGGLE_BUTTON(cur_widget->widget),
G_CALLBACK (check_changed), NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cur_widget->widget),
current->value ? TRUE : FALSE);
/*enable widget signals*/
g_signal_handlers_unblock_by_func(GTK_TOGGLE_BUTTON(cur_widget->widget),
G_CALLBACK (check_changed), NULL);
break;
#ifdef V4L2_CTRL_TYPE_BITMASK
case V4L2_CTRL_TYPE_BITMASK:
{
char *text_input = g_strdup_printf("0x%x", current->value);
gtk_entry_set_text (GTK_ENTRY(cur_widget->widget), text_input);
g_free(text_input);
break;
}
#endif
#ifdef V4L2_CTRL_TYPE_INTEGER64
case V4L2_CTRL_TYPE_INTEGER64:
{
char *text_input = g_strdup_printf("0x%" PRIx64 "", c->value64);
gtk_entry_set_text (GTK_ENTRY(cur_widget->widget), text_input);
g_free(text_input);
break;
}
#endif
case V4L2_CTRL_TYPE_INTEGER:
if( current->control.id != V4L2_CID_PAN_RELATIVE &&
current->control.id != V4L2_CID_TILT_RELATIVE &&
current->control.id != V4L2_CID_PAN_RESET &&
current->control.id != V4L2_CID_TILT_RESET &&
current->control.id != V4L2_CID_LED1_MODE_LOGITECH &&
current->control.id != V4L2_CID_RAW_BITS_PER_PIXEL_LOGITECH )
{
/*disable widget signals*/
g_signal_handlers_block_by_func(GTK_SCALE (cur_widget->widget),
G_CALLBACK (slider_changed), NULL);
gtk_range_set_value (GTK_RANGE (cur_widget->widget), current->value);
/*enable widget signals*/
g_signal_handlers_unblock_by_func(GTK_SCALE (cur_widget->widget),
G_CALLBACK (slider_changed), NULL);
if(cur_widget->widget2)
{
/*disable widget signals*/
g_signal_handlers_block_by_func(GTK_SPIN_BUTTON(cur_widget->widget2),
G_CALLBACK (spin_changed), NULL);
gtk_spin_button_set_value (GTK_SPIN_BUTTON(cur_widget->widget2), current->value);
/*enable widget signals*/
g_signal_handlers_unblock_by_func(GTK_SPIN_BUTTON(cur_widget->widget2),
G_CALLBACK (spin_changed), NULL);
}
}
break;
#ifdef V4L2_CTRL_TYPE_INTEGER_MENU
case V4L2_CTRL_TYPE_INTEGER_MENU:
#endif
case V4L2_CTRL_TYPE_MENU:
{
/*disable widget signals*/
g_signal_handlers_block_by_func(GTK_COMBO_BOX_TEXT(cur_widget->widget),
G_CALLBACK (combo_changed), NULL);
/*get new index*/
int j = 0;
int def = 0;
for (j = 0; current->menu[j].index <= current->control.maximum; j++)
{
if(current->value == current->menu[j].index)
def = j;
}
gtk_combo_box_set_active(GTK_COMBO_BOX(cur_widget->widget), def);
/*enable widget signals*/
g_signal_handlers_unblock_by_func(GTK_COMBO_BOX_TEXT(cur_widget->widget),
G_CALLBACK (combo_changed), NULL);
break;
}
default:
break;
}
/*update flags (enable disable)*/
if((current->control.flags & V4L2_CTRL_FLAG_GRABBED) ||
(current->control.flags & V4L2_CTRL_FLAG_DISABLED))
{
if(cur_widget->label)
gtk_widget_set_sensitive (cur_widget->label, FALSE);
if(cur_widget->widget)
gtk_widget_set_sensitive (cur_widget->widget, FALSE);
if(cur_widget->widget2)
gtk_widget_set_sensitive (cur_widget->widget2, FALSE);
}
else
{
if(cur_widget->label)
gtk_widget_set_sensitive (cur_widget->label, TRUE);
if(cur_widget->widget)
gtk_widget_set_sensitive (cur_widget->widget, TRUE);
if(cur_widget->widget2)
gtk_widget_set_sensitive (cur_widget->widget2, TRUE);
}
}
}
static void mateweather_pref_create(MateWeatherPref* pref)
{
GtkWidget* pref_vbox;
GtkWidget* pref_notebook;
#ifdef RADARMAP
GtkWidget* radar_toggle_hbox;
#endif /* RADARMAP */
GtkWidget* pref_basic_update_alignment;
GtkWidget* pref_basic_update_lbl;
GtkWidget* pref_basic_update_hbox;
GObject* pref_basic_update_spin_adj;
GtkWidget* pref_basic_update_sec_lbl;
GtkWidget* pref_basic_note_lbl;
GtkWidget* pref_loc_hbox;
GtkWidget* pref_loc_note_lbl;
GtkWidget* scrolled_window;
GtkWidget* label;
GtkWidget* value_hbox;
GtkWidget* tree_label;
GtkTreeSelection *selection;
GtkWidget* pref_basic_vbox;
GtkWidget* vbox;
GtkWidget* frame;
GtkWidget* temp_label;
GtkWidget* temp_combo;
GtkWidget* speed_label;
GtkWidget* speed_combo;
GtkWidget* pres_label;
GtkWidget* pres_combo;
GtkWidget* dist_label;
GtkWidget* dist_combo;
#if GTK_CHECK_VERSION (3, 0, 0)
GtkWidget* unit_grid;
#else
GtkWidget* unit_table;
#endif
GtkWidget* pref_find_label;
GtkWidget* pref_find_hbox;
GtkWidget* image;
g_object_set (pref, "destroy-with-parent", TRUE, NULL);
gtk_window_set_title (GTK_WINDOW (pref), _("Weather Preferences"));
gtk_dialog_add_buttons (GTK_DIALOG (pref), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL);
gtk_dialog_set_default_response (GTK_DIALOG (pref), GTK_RESPONSE_CLOSE);
gtk_container_set_border_width (GTK_CONTAINER (pref), 5);
gtk_window_set_resizable (GTK_WINDOW (pref), TRUE);
gtk_window_set_screen (GTK_WINDOW (pref), gtk_widget_get_screen (GTK_WIDGET (pref->priv->applet->applet)));
pref_vbox = gtk_dialog_get_content_area (GTK_DIALOG (pref));
gtk_box_set_spacing (GTK_BOX (pref_vbox), 2);
gtk_widget_show (pref_vbox);
pref_notebook = gtk_notebook_new ();
gtk_container_set_border_width (GTK_CONTAINER (pref_notebook), 5);
gtk_widget_show (pref_notebook);
gtk_box_pack_start (GTK_BOX (pref_vbox), pref_notebook, TRUE, TRUE, 0);
/*
* General settings page.
*/
#if GTK_CHECK_VERSION (3, 0, 0)
pref_basic_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
#else
pref_basic_vbox = gtk_vbox_new (FALSE, 18);
#endif
gtk_container_set_border_width (GTK_CONTAINER (pref_basic_vbox), 12);
gtk_container_add (GTK_CONTAINER (pref_notebook), pref_basic_vbox);
pref_basic_update_alignment = gtk_alignment_new (0, 0.5, 0, 1);
gtk_widget_show (pref_basic_update_alignment);
pref->priv->basic_update_btn = gtk_check_button_new_with_mnemonic (_("_Automatically update every:"));
gtk_widget_show (pref->priv->basic_update_btn);
gtk_container_add (GTK_CONTAINER (pref_basic_update_alignment), pref->priv->basic_update_btn);
g_signal_connect (G_OBJECT (pref->priv->basic_update_btn), "toggled", G_CALLBACK (auto_update_toggled), pref);
if (!g_settings_is_writable (pref->priv->applet->settings, "auto-update"))
{
hard_set_sensitive (pref->priv->basic_update_btn, FALSE);
}
/*
* Units settings page.
*/
/* Temperature Unit */
temp_label = gtk_label_new_with_mnemonic (_("_Temperature unit:"));
gtk_label_set_use_markup (GTK_LABEL (temp_label), TRUE);
gtk_label_set_justify (GTK_LABEL (temp_label), GTK_JUSTIFY_LEFT);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (temp_label), 0.0, 0.5);
#endif
gtk_widget_show (temp_label);
temp_combo = gtk_combo_box_text_new ();
pref->priv->basic_temp_combo = temp_combo;
gtk_label_set_mnemonic_widget (GTK_LABEL (temp_label), temp_combo);
//gtk_combo_box_append_text (GTK_COMBO_BOX (temp_combo), _("Default"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (temp_combo), _("Kelvin"));
/* TRANSLATORS: Celsius is sometimes referred Centigrade */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (temp_combo), _("Celsius"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (temp_combo), _("Fahrenheit"));
gtk_widget_show (temp_combo);
if ( ! g_settings_is_writable (pref->priv->applet->settings, "temperature-unit"))
{
hard_set_sensitive (pref->priv->basic_temp_combo, FALSE);
}
/* Speed Unit */
speed_label = gtk_label_new_with_mnemonic (_("_Wind speed unit:"));
gtk_label_set_use_markup (GTK_LABEL (speed_label), TRUE);
gtk_label_set_justify (GTK_LABEL (speed_label), GTK_JUSTIFY_LEFT);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (speed_label), 0.0, 0.5);
#endif
gtk_widget_show (speed_label);
speed_combo = gtk_combo_box_text_new ();
pref->priv->basic_speed_combo = speed_combo;
gtk_label_set_mnemonic_widget (GTK_LABEL (speed_label), speed_combo);
//gtk_combo_box_append_text (GTK_COMBO_BOX (speed_combo), _("Default"));
/* TRANSLATOR: The wind speed unit "meters per second" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("m/s"));
/* TRANSLATOR: The wind speed unit "kilometers per hour" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("km/h"));
/* TRANSLATOR: The wind speed unit "miles per hour" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("mph"));
/* TRANSLATOR: The wind speed unit "knots" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("knots"));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("Beaufort scale"));
gtk_widget_show (speed_combo);
if (!g_settings_is_writable (pref->priv->applet->settings, "speed-unit"))
{
hard_set_sensitive (pref->priv->basic_speed_combo, FALSE);
}
/* Pressure Unit */
pres_label = gtk_label_new_with_mnemonic (_("_Pressure unit:"));
gtk_label_set_use_markup (GTK_LABEL (pres_label), TRUE);
gtk_label_set_justify (GTK_LABEL (pres_label), GTK_JUSTIFY_LEFT);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (pres_label), 0.0, 0.5);
#endif
gtk_widget_show (pres_label);
pres_combo = gtk_combo_box_text_new ();
pref->priv->basic_pres_combo = pres_combo;
gtk_label_set_mnemonic_widget (GTK_LABEL (pres_label), pres_combo);
//gtk_combo_box_append_text (GTK_COMBO_BOX (pres_combo), _("Default"));
/* TRANSLATOR: The pressure unit "kiloPascals" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("kPa"));
/* TRANSLATOR: The pressure unit "hectoPascals" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("hPa"));
/* TRANSLATOR: The pressure unit "millibars" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("mb"));
/* TRANSLATOR: The pressure unit "millibars of mercury" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("mmHg"));
/* TRANSLATOR: The pressure unit "inches of mercury" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("inHg"));
/* TRANSLATOR: The pressure unit "atmospheres" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("atm"));
gtk_widget_show (pres_combo);
if (!g_settings_is_writable(pref->priv->applet->settings, "pressure-unit"))
{
hard_set_sensitive(pref->priv->basic_pres_combo, FALSE);
}
/* Distance Unit */
dist_label = gtk_label_new_with_mnemonic (_("_Visibility unit:"));
gtk_label_set_use_markup (GTK_LABEL (dist_label), TRUE);
gtk_label_set_justify (GTK_LABEL (dist_label), GTK_JUSTIFY_LEFT);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (dist_label), 0, 0.5);
#endif
gtk_widget_show (dist_label);
dist_combo = gtk_combo_box_text_new ();
pref->priv->basic_dist_combo = dist_combo;
gtk_label_set_mnemonic_widget (GTK_LABEL (dist_label), dist_combo);
//gtk_combo_box_append_text (GTK_COMBO_BOX (dist_combo), _("Default"));
/* TRANSLATOR: The distance unit "meters" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dist_combo), _("meters"));
/* TRANSLATOR: The distance unit "kilometers" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dist_combo), _("km"));
/* TRANSLATOR: The distance unit "miles" */
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dist_combo), _("miles"));
gtk_widget_show (dist_combo);
if ( ! g_settings_is_writable (pref->priv->applet->settings, "distance-unit"))
hard_set_sensitive (pref->priv->basic_dist_combo, FALSE);
#if GTK_CHECK_VERSION (3, 0, 0)
unit_grid = gtk_grid_new ();
gtk_grid_set_row_spacing(GTK_GRID(unit_grid), 6);
gtk_grid_set_column_spacing(GTK_GRID(unit_grid), 12);
gtk_widget_set_halign (temp_label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(unit_grid), temp_label, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(unit_grid), temp_combo, 1, 0, 1, 1);
gtk_widget_set_halign (speed_label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(unit_grid), speed_label, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(unit_grid), speed_combo, 1, 1, 1, 1);
gtk_widget_set_halign (pres_label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(unit_grid), pres_label, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(unit_grid), pres_combo, 1, 2, 1, 1);
gtk_widget_set_halign (dist_label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(unit_grid), dist_label, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(unit_grid), dist_combo, 1, 3, 1, 1);
gtk_widget_show(unit_grid);
#else
unit_table = gtk_table_new(5, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(unit_table), 6);
gtk_table_set_col_spacings(GTK_TABLE(unit_table), 12);
gtk_table_attach(GTK_TABLE(unit_table), temp_label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_table_attach_defaults(GTK_TABLE(unit_table), temp_combo, 1, 2, 0, 1);
gtk_table_attach(GTK_TABLE(unit_table), speed_label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_table_attach_defaults(GTK_TABLE(unit_table), speed_combo, 1, 2, 1, 2);
gtk_table_attach(GTK_TABLE(unit_table), pres_label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_table_attach_defaults(GTK_TABLE(unit_table), pres_combo, 1, 2, 2, 3);
gtk_table_attach(GTK_TABLE(unit_table), dist_label, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_table_attach_defaults(GTK_TABLE(unit_table), dist_combo, 1, 2, 3, 4);
gtk_widget_show(unit_table);
#endif
g_signal_connect (temp_combo, "changed", G_CALLBACK (temp_combo_changed_cb), pref);
g_signal_connect (speed_combo, "changed", G_CALLBACK (speed_combo_changed_cb), pref);
g_signal_connect (dist_combo, "changed", G_CALLBACK (dist_combo_changed_cb), pref);
g_signal_connect (pres_combo, "changed", G_CALLBACK (pres_combo_changed_cb), pref);
#ifdef RADARMAP
pref->priv->basic_radar_btn = gtk_check_button_new_with_mnemonic (_("Enable _radar map"));
gtk_widget_show (pref->priv->basic_radar_btn);
g_signal_connect (G_OBJECT (pref->priv->basic_radar_btn), "toggled", G_CALLBACK (radar_toggled), pref);
if (!g_settings_is_writable (pref->priv->applet->settings, "enable-radar-map"))
{
hard_set_sensitive(pref->priv->basic_radar_btn, FALSE);
}
#if GTK_CHECK_VERSION (3, 0, 0)
radar_toggle_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12);
#else
radar_toggle_hbox = gtk_hbox_new(FALSE, 12);
#endif
gtk_widget_show(radar_toggle_hbox);
label = gtk_label_new (" ");
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (radar_toggle_hbox), label, FALSE, FALSE, 0);
pref->priv->basic_radar_url_btn = gtk_check_button_new_with_mnemonic (_("Use _custom address for radar map"));
gtk_widget_show (pref->priv->basic_radar_url_btn);
gtk_box_pack_start (GTK_BOX (radar_toggle_hbox), pref->priv->basic_radar_url_btn, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (pref->priv->basic_radar_url_btn), "toggled", G_CALLBACK (use_radar_url_toggled), pref);
if ( ! g_settings_is_writable (pref->priv->applet->settings, "use-custom-radar-url"))
{
hard_set_sensitive (pref->priv->basic_radar_url_btn, FALSE);
}
#if GTK_CHECK_VERSION (3, 0, 0)
pref->priv->basic_radar_url_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
#else
pref->priv->basic_radar_url_hbox = gtk_hbox_new (FALSE, 12);
#endif
gtk_widget_show (pref->priv->basic_radar_url_hbox);
label = gtk_label_new (" ");
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), label, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic (_("A_ddress:"));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), label, FALSE, FALSE, 0);
pref->priv->basic_radar_url_entry = gtk_entry_new ();
gtk_widget_show (pref->priv->basic_radar_url_entry);
gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), pref->priv->basic_radar_url_entry, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (pref->priv->basic_radar_url_entry), "focus_out_event", G_CALLBACK (radar_url_changed), pref);
if ( ! g_settings_is_writable (pref->priv->applet->settings, "radar"))
{
hard_set_sensitive (pref->priv->basic_radar_url_entry, FALSE);
}
#endif /* RADARMAP */
#ifdef HAVE_LIBNOTIFY
/* setup show-notifications button */
pref->priv->basic_show_notifications_btn = gtk_check_button_new_with_mnemonic (_("Show _notifications"));
if (!g_settings_is_writable (pref->priv->applet->settings, "show-notifications"))
{
hard_set_sensitive (pref->priv->basic_show_notifications_btn, FALSE);
}
g_signal_connect (G_OBJECT (pref->priv->basic_show_notifications_btn), "toggled", G_CALLBACK (show_notifications_toggled), pref);
#endif
frame = create_hig_category (pref_basic_vbox, _("Update"));
#if GTK_CHECK_VERSION (3, 0, 0)
pref_basic_update_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
#else
pref_basic_update_hbox = gtk_hbox_new (FALSE, 12);
#endif
pref_basic_update_lbl = gtk_label_new_with_mnemonic (_("_Automatically update every:"));
gtk_widget_show (pref_basic_update_lbl);
gtk_widget_show (pref_basic_update_hbox);
pref_basic_update_spin_adj = gtk_adjustment_new (30, 1, 3600, 5, 25, 1);
pref->priv->basic_update_spin = gtk_spin_button_new (GTK_ADJUSTMENT (pref_basic_update_spin_adj), 1, 0);
gtk_widget_show (pref->priv->basic_update_spin);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (pref->priv->basic_update_spin), TRUE);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (pref->priv->basic_update_spin), GTK_UPDATE_IF_VALID);
g_signal_connect (G_OBJECT (pref->priv->basic_update_spin), "value_changed", G_CALLBACK (update_interval_changed), pref);
pref_basic_update_sec_lbl = gtk_label_new (_("minutes"));
gtk_widget_show (pref_basic_update_sec_lbl);
if ( ! g_settings_is_writable (pref->priv->applet->settings, "auto-update-interval"))
{
hard_set_sensitive (pref->priv->basic_update_spin, FALSE);
hard_set_sensitive (pref_basic_update_sec_lbl, FALSE);
}
#if GTK_CHECK_VERSION (3, 0, 0)
value_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
#else
value_hbox = gtk_hbox_new (FALSE, 6);
#endif
gtk_box_pack_start (GTK_BOX (pref_basic_update_hbox), pref_basic_update_alignment, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (pref_basic_update_hbox), value_hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (value_hbox), pref->priv->basic_update_spin, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (value_hbox), pref_basic_update_sec_lbl, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (frame), pref_basic_update_hbox);
frame = create_hig_category (pref_basic_vbox, _("Display"));
#if GTK_CHECK_VERSION (3, 0, 0)
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
#else
vbox = gtk_vbox_new (FALSE, 6);
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_box_pack_start (GTK_BOX (vbox), unit_grid, TRUE, TRUE, 0);
#else
gtk_box_pack_start (GTK_BOX (vbox), unit_table, TRUE, TRUE, 0);
#endif
#ifdef RADARMAP
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_radar_btn, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), radar_toggle_hbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_radar_url_hbox, TRUE, TRUE, 0);
#endif /* RADARMAP */
#ifdef HAVE_LIBNOTIFY
/* add the show-notification toggle button to the vbox of the display section */
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_show_notifications_btn, TRUE, TRUE, 0);
#endif
gtk_container_add (GTK_CONTAINER (frame), vbox);
pref_basic_note_lbl = gtk_label_new (_("General"));
gtk_widget_show (pref_basic_note_lbl);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (pref_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (pref_notebook), 0), pref_basic_note_lbl);
/*
* Location page.
*/
#if GTK_CHECK_VERSION (3, 0, 0)
pref_loc_hbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
#else
pref_loc_hbox = gtk_vbox_new (FALSE, 6);
#endif
gtk_container_set_border_width (GTK_CONTAINER (pref_loc_hbox), 12);
gtk_container_add (GTK_CONTAINER (pref_notebook), pref_loc_hbox);
tree_label = gtk_label_new_with_mnemonic (_("_Select a location:"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (tree_label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (tree_label), 0.0, 0.5);
#endif
gtk_box_pack_start (GTK_BOX (pref_loc_hbox), tree_label, FALSE, FALSE, 0);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
pref->priv->tree = gtk_tree_view_new ();
gtk_label_set_mnemonic_widget (GTK_LABEL (tree_label), GTK_WIDGET (pref->priv->tree));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pref->priv->tree), FALSE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pref->priv->tree));
g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (row_selected_cb), pref);
gtk_container_add (GTK_CONTAINER (scrolled_window), pref->priv->tree);
gtk_widget_show (pref->priv->tree);
gtk_widget_show (scrolled_window);
gtk_box_pack_start (GTK_BOX (pref_loc_hbox), scrolled_window, TRUE, TRUE, 0);
load_locations(pref);
#if GTK_CHECK_VERSION (3, 0, 0)
pref_find_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
#else
pref_find_hbox = gtk_hbox_new (FALSE, 6);
#endif
pref_find_label = gtk_label_new (_("_Find:"));
gtk_label_set_use_underline (GTK_LABEL (pref_find_label), TRUE);
pref->priv->find_entry = gtk_entry_new ();
gtk_label_set_mnemonic_widget (GTK_LABEL (pref_find_label), pref->priv->find_entry);
pref->priv->find_next_btn = gtk_button_new_with_mnemonic (_("Find _Next"));
gtk_widget_set_sensitive (pref->priv->find_next_btn, FALSE);
image = gtk_image_new_from_stock (GTK_STOCK_FIND, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (pref->priv->find_next_btn), image);
g_signal_connect (G_OBJECT (pref->priv->find_next_btn), "clicked", G_CALLBACK (find_next_clicked), pref);
g_signal_connect (G_OBJECT (pref->priv->find_entry), "changed", G_CALLBACK (find_entry_changed), pref);
gtk_container_set_border_width (GTK_CONTAINER (pref_find_hbox), 0);
gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref_find_label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref->priv->find_entry, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref->priv->find_next_btn, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (pref_loc_hbox), pref_find_hbox, FALSE, FALSE, 0);
if ( ! g_settings_is_writable (pref->priv->applet->settings, "location0"))
{
hard_set_sensitive (scrolled_window, FALSE);
}
pref_loc_note_lbl = gtk_label_new (_("Location"));
gtk_widget_show (pref_loc_note_lbl);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (pref_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (pref_notebook), 1), pref_loc_note_lbl);
g_signal_connect (G_OBJECT (pref), "response", G_CALLBACK (response_cb), pref);
mateweather_pref_set_accessibility (pref);
gtk_label_set_mnemonic_widget (GTK_LABEL (pref_basic_update_sec_lbl), pref->priv->basic_update_spin);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), pref->priv->basic_radar_url_entry);
}
GtkWidget* puss_create_global_options_setup_widget(gpointer tag) {
gchar* filepath;
GtkBuilder* builder;
GtkWidget* panel;
GtkWidget* w;
GError* err = 0;
const Option* option;
// create UI
builder = gtk_builder_new();
if( !builder )
return 0;
gtk_builder_set_translation_domain(builder, TEXT_DOMAIN);
filepath = g_build_filename(puss_app->module_path, "res", "puss_setup_widget.ui", NULL);
if( !filepath ) {
g_printerr("ERROR(puss) : build setup dialog filepath failed!\n");
g_object_unref(G_OBJECT(builder));
return 0;
}
gtk_builder_add_from_file(builder, filepath, &err);
g_free(filepath);
if( err ) {
g_printerr("ERROR(puss): %s\n", err->message);
g_error_free(err);
g_object_unref(G_OBJECT(builder));
return 0;
}
panel = GTK_WIDGET(g_object_ref(gtk_builder_get_object(builder, "main_panel")));
#ifdef G_OS_WIN32
{
gchar* path;
GDir* dir;
const gchar* fname;
gchar* rcfile;
gint i;
gint index = -1;
option = puss_option_manager_option_find("puss", "theme");
w = GTK_WIDGET(gtk_builder_get_object(builder, "theme_combo"));
path = gtk_rc_get_theme_dir();
dir = g_dir_open(path, 0, 0);
if( dir ) {
i = 0;
for(;;) {
fname = g_dir_read_name(dir);
if( !fname )
break;
rcfile = g_build_filename(path, fname, "gtk-2.0", "gtkrc", NULL);
if( g_file_test(rcfile, G_FILE_TEST_EXISTS) ) {
#if GTK_MAJOR_VERSION==2
gtk_combo_box_append_text(GTK_COMBO_BOX(w), fname);
#else
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(w), fname);
#endif
if( index < 0 && option->value ) {
if( g_str_equal(fname, option->value) )
index = i;
++i;
}
}
g_free(rcfile);
}
g_dir_close(dir);
}
g_free(path);
if( index >= 0 )
gtk_combo_box_set_active(GTK_COMBO_BOX(w), index);
g_signal_connect(w, "changed", G_CALLBACK(cb_combo_box_option_changed), (gpointer)option);
}
#endif
{
const gchar* const * ids;
const gchar* const * p;
gint i;
gint index = -1;
GtkSourceStyleSchemeManager* ssm = gtk_source_style_scheme_manager_get_default();
option = puss_option_manager_option_find("puss", "editor.style");
w = GTK_WIDGET(gtk_builder_get_object(builder, "style_combo"));
if( ssm ) {
gtk_source_style_scheme_manager_force_rescan(ssm);
ids = gtk_source_style_scheme_manager_get_scheme_ids(ssm);
i = 0;
for( p=ids; *p; ++p ) {
#if GTK_MAJOR_VERSION==2
gtk_combo_box_append_text(GTK_COMBO_BOX(w), *p);
#else
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(w), *p);
#endif
if( index < 0 && option->value ) {
if( g_str_equal(*p, option->value) )
index = i;
++i;
}
}
if( index >= 0 )
gtk_combo_box_set_active(GTK_COMBO_BOX(w), index);
}
g_signal_connect(w, "changed", G_CALLBACK(cb_combo_box_option_changed), (gpointer)option);
}
{
option = puss_option_manager_option_find("puss", "editor.font");
w = GTK_WIDGET(gtk_builder_get_object(builder, "font_button"));
if( option->value && option->value[0] )
gtk_font_button_set_font_name(GTK_FONT_BUTTON(w), option->value);
g_signal_connect(w, "font-set", G_CALLBACK(cb_font_button_changed), (gpointer)option);
}
{
GtkEntry* entry;
option = puss_option_manager_option_find("puss", "fileloader.charset_list");
entry = GTK_ENTRY(gtk_builder_get_object(builder, "charset_entry"));
w = GTK_WIDGET(gtk_builder_get_object(builder, "charset_apply_button"));
gtk_entry_set_text(entry, option->value);
g_signal_connect(w, "clicked", G_CALLBACK(cb_apply_button_changed), (gpointer)entry);
}
g_object_unref(G_OBJECT(builder));
return panel;
}
void
plot_add_function_show (OreganoEngine *engine, SimulationData *current)
{
GtkBuilder *gui;
GError *perror = NULL;
GtkDialog *dialog;
GtkComboBoxText *op1, *op2, *functiontype;
int i;
gint result = 0;
GtkWidget *warning;
GtkWidget *container_temp;
SimulationFunction *func = g_new0 (SimulationFunction, 1);
if ((gui = gtk_builder_new ()) == NULL) {
oregano_error (_("Could not create plot window."));
return;
}
gtk_builder_set_translation_domain (gui, NULL);
if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/plot-add-function.ui", &perror) <= 0) {
oregano_error_with_title (_("Could not create plot window."), perror->message);
g_error_free (perror);
return;
}
dialog = GTK_DIALOG (gtk_builder_get_object (gui, "toplevel"));
container_temp = GTK_WIDGET (gtk_builder_get_object (gui, "op1_alignment"));
op1 = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new ());
gtk_container_add (GTK_CONTAINER (container_temp), GTK_WIDGET (op1));
gtk_widget_show (GTK_WIDGET (op1));
container_temp = GTK_WIDGET (gtk_builder_get_object (gui, "op2_alignment"));
op2 = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new ());
gtk_container_add (GTK_CONTAINER (container_temp), GTK_WIDGET (op2));
gtk_widget_show (GTK_WIDGET (op2));
container_temp = GTK_WIDGET (gtk_builder_get_object (gui, "function_alignment"));
functiontype = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new ());
gtk_container_add (GTK_CONTAINER (container_temp), GTK_WIDGET (functiontype));
gtk_widget_show (GTK_WIDGET (functiontype));
gtk_combo_box_text_append_text (functiontype, _("Substraction"));
gtk_combo_box_text_append_text (functiontype, _("Division"));
for (i = 1; i < current->n_variables; i++) {
if (current->type != DC_TRANSFER) {
if (strchr (current->var_names[i], '#') == NULL) {
gtk_combo_box_text_append_text (op1, current->var_names[i]);
gtk_combo_box_text_append_text (op2, current->var_names[i]);
}
}
else {
gtk_combo_box_text_append_text (op1, current->var_names[i]);
gtk_combo_box_text_append_text (op2, current->var_names[i]);
}
}
gtk_combo_box_set_active (GTK_COMBO_BOX (op1),0);
gtk_combo_box_set_active (GTK_COMBO_BOX (op2),1);
gtk_combo_box_set_active (GTK_COMBO_BOX (functiontype),0);
result = gtk_dialog_run (GTK_DIALOG (dialog));
if ((result == GTK_RESPONSE_OK) &&
((gtk_combo_box_get_active (GTK_COMBO_BOX (op1)) == -1) ||
(gtk_combo_box_get_active (GTK_COMBO_BOX (op2)) == -1) ||
(gtk_combo_box_get_active (GTK_COMBO_BOX (functiontype)) == -1)))
{
warning = gtk_message_dialog_new_with_markup (
NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_OK,
_("<span weight=\"bold\" size=\"large\">Neither function, nor operators have been chosen</span>\n\n"
"Please, take care to choose a function and their associated operators"));
if (gtk_dialog_run (GTK_DIALOG (warning)) == GTK_RESPONSE_OK) {
gtk_widget_destroy (GTK_WIDGET (warning));
plot_add_function_show (engine, current);
gtk_widget_destroy (GTK_WIDGET (dialog));
return;
}
}
if ((result == GTK_RESPONSE_OK) &&
((gtk_combo_box_get_active (GTK_COMBO_BOX (op1)) != -1) &&
(gtk_combo_box_get_active (GTK_COMBO_BOX (op2)) != -1) &&
(gtk_combo_box_get_active (GTK_COMBO_BOX (functiontype)) != -1))) {
for (i = 1; i < current->n_variables; i++) {
if (g_strcmp0 (current->var_names[i], gtk_combo_box_text_get_active_text (op1)) == 0)
func->first = i;
if (g_strcmp0 (current->var_names[i], gtk_combo_box_text_get_active_text (op2)) == 0)
func->second = i;
}
current->functions = g_list_append (current->functions, func);
}
gtk_widget_destroy (GTK_WIDGET (dialog));
}
static void on_insert_numbers_activate(G_GNUC_UNUSED GtkMenuItem *menuitem, G_GNUC_UNUSED
gpointer gdata)
{
InsertNumbersDialog d;
GtkWidget *vbox, *label, *upper, *space, *button;
GtkGrid *grid;
GtkComboBoxText *combo;
const char *case_tip = _("For base 11 and above");
gchar *base_text;
gint result;
d.dialog = gtk_dialog_new_with_buttons(_("Insert Numbers"),
GTK_WINDOW(geany->main_widgets->window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
vbox = ui_dialog_vbox_new(GTK_DIALOG(d.dialog));
gtk_box_set_spacing(GTK_BOX(vbox), 9);
#if GTK_CHECK_VERSION(3, 0, 0)
grid = GTK_GRID(gtk_grid_new());
#else
grid = GTK_TABLE(gtk_table_new(3, 6, FALSE));
#endif
gtk_grid_set_row_spacing(grid, 6);
gtk_grid_set_column_spacing(grid, 6);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(grid), TRUE, TRUE, 0);
label = gtk_label_new_with_mnemonic(_("_Start:"));
gtk_grid_attach(grid, label, 0, 0, 1, 1);
d.start = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1);
set_entry(d.start, RANGE_LEN, label, RANGE_TOOLTIP);
gtk_grid_attach(grid, d.start, 1, 0, 2, 1);
label = gtk_label_new_with_mnemonic(_("S_tep:"));
gtk_grid_attach(grid, label, 3, 0, 1, 1);
d.step = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1);
set_entry(d.step, RANGE_LEN, label, RANGE_TOOLTIP);
gtk_grid_attach(grid, d.step, 4, 0, 2, 1);
label = gtk_label_new_with_mnemonic(_("_Base:"));
gtk_grid_attach(grid, label, 0, 1, 1, 1),
combo = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new_with_entry());
d.base = gtk_bin_get_child(GTK_BIN(combo));
set_entry(d.base, 2, label, "2..36");
g_signal_connect(d.base, "insert-text", G_CALLBACK(on_base_insert_text), NULL);
gtk_combo_box_text_append_text(combo, "2");
gtk_combo_box_text_append_text(combo, "8");
gtk_combo_box_text_append_text(combo, "10");
gtk_combo_box_text_append_text(combo, "16");
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_grid_attach(grid, GTK_WIDGET(combo), 1, 1, 2, 1);
gtk_widget_set_hexpand(GTK_WIDGET(combo), TRUE);
#else
gtk_table_attach(grid, GTK_WIDGET(combo), 1, 3, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0);
#endif
label = gtk_label_new(_("Letters:"));
gtk_widget_set_tooltip_text(label, case_tip);
gtk_grid_attach(grid, label, 3, 1, 1, 1);
upper = gtk_radio_button_new_with_mnemonic(NULL, _("_Upper"));
gtk_widget_set_tooltip_text(upper, case_tip);
gtk_grid_attach(grid, upper, 4, 1, 1, 1);
d.lower = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(upper));
gtk_widget_set_tooltip_text(label, case_tip);
label = gtk_label_new_with_mnemonic(_("_Lower"));
gtk_widget_set_tooltip_text(label, case_tip);
gtk_container_add(GTK_CONTAINER(d.lower), label);
gtk_grid_attach(grid, d.lower, 5, 1, 1, 1);
d.prefix = gtk_check_button_new_with_mnemonic(_("Base _prefix"));
gtk_widget_set_tooltip_text(d.prefix,
_("0 for octal, 0x for hex, + for positive decimal"));
gtk_grid_attach(grid, d.prefix, 1, 2, 2, 1);
label = gtk_label_new(_("Padding:"));
gtk_grid_attach(grid, label, 3, 2, 1, 1);
space = gtk_radio_button_new_with_mnemonic(NULL, _("Sp_ace"));
gtk_grid_attach(grid, space, 4, 2, 1, 1);
d.zero = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(space));
label = gtk_label_new_with_mnemonic(_("_Zero"));
gtk_container_add(GTK_CONTAINER(d.zero), label);
gtk_grid_attach(grid, d.zero, 5, 2, 1, 1);
button = gtk_button_new_from_stock(GTK_STOCK_OK);
g_signal_connect(button, "clicked", G_CALLBACK(on_insert_numbers_ok_clicked), &d);
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(d.dialog))), button,
TRUE, TRUE, 0);
#if GTK_CHECK_VERSION(2, 18, 0)
gtk_widget_set_can_default(button, TRUE);
#else
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
#endif
gtk_widget_grab_default(button);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.start), start_value);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.step), step_value);
base_text = g_strdup_printf("%d", base_value);
gtk_entry_set_text(GTK_ENTRY(d.base), base_text);
g_free(base_text);
gtk_button_clicked(GTK_BUTTON(lower_case ? d.lower : upper));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d.prefix), base_prefix);
gtk_button_clicked(GTK_BUTTON(pad_zeros ? d.zero : space));
gtk_widget_show_all(d.dialog);
result = gtk_dialog_run(GTK_DIALOG(d.dialog));
if (result == GTK_RESPONSE_ACCEPT)
{
if (can_insert_numbers())
{
if (end_line - start_line < 1000)
{
/* quick version */
gtk_widget_hide(d.dialog);
insert_numbers(NULL);
}
else
{
gboolean cancel = FALSE;
gtk_widget_set_sensitive(GTK_WIDGET(grid), FALSE);
gtk_widget_set_sensitive(button, FALSE);
update_display();
g_signal_connect(d.dialog, "response",
G_CALLBACK(on_insert_numbers_response), &cancel);
insert_numbers(&cancel);
}
}
else
plugin_beep(); /* reloaded or something */
}
gtk_widget_destroy(d.dialog);
}
static GtkWidget *
create_window (void)
{
GtkWidget *window, *hbox, *vbox, *flowbox_cntl, *items_cntl;
GtkWidget *flowbox, *widget, *expander, *swindow;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
gtk_widget_show (vbox);
gtk_widget_show (hbox);
gtk_container_add (GTK_CONTAINER (window), hbox);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show (swindow);
gtk_box_pack_start (GTK_BOX (hbox), swindow, TRUE, TRUE, 0);
flowbox = gtk_flow_box_new ();
gtk_widget_set_halign (flowbox, GTK_ALIGN_END);
the_flowbox = (GtkFlowBox *)flowbox;
gtk_widget_set_halign (flowbox, INITIAL_HALIGN);
gtk_widget_set_valign (flowbox, INITIAL_VALIGN);
gtk_flow_box_set_column_spacing (GTK_FLOW_BOX (flowbox), INITIAL_CSPACING);
gtk_flow_box_set_row_spacing (GTK_FLOW_BOX (flowbox), INITIAL_RSPACING);
gtk_flow_box_set_min_children_per_line (GTK_FLOW_BOX (flowbox), INITIAL_MINIMUM_LENGTH);
gtk_flow_box_set_max_children_per_line (GTK_FLOW_BOX (flowbox), INITIAL_MAXIMUM_LENGTH);
gtk_widget_show (flowbox);
gtk_container_add (GTK_CONTAINER (swindow), flowbox);
gtk_flow_box_set_hadjustment (GTK_FLOW_BOX (flowbox),
gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (swindow)));
gtk_flow_box_set_vadjustment (GTK_FLOW_BOX (flowbox),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (swindow)));
g_signal_connect (flowbox, "child-activated", G_CALLBACK (on_child_activated), NULL);
g_signal_connect (flowbox, "selected-children-changed", G_CALLBACK (on_selected_children_changed), NULL);
/* Add Flowbox test control frame */
expander = gtk_expander_new ("Flow Box controls");
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
flowbox_cntl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_widget_show (flowbox_cntl);
gtk_widget_show (expander);
gtk_container_add (GTK_CONTAINER (expander), flowbox_cntl);
gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);
widget = gtk_check_button_new_with_label ("Homogeneous");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set whether the items should be displayed at the same size");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (homogeneous_toggled), flowbox);
widget = gtk_check_button_new_with_label ("Activate on single click");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
g_object_bind_property (widget, "active",
flowbox, "activate-on-single-click",
G_BINDING_SYNC_CREATE);
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
/* Add alignment controls */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Fill");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Start");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "End");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Center");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_HALIGN);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the horizontal alignment policy");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (horizontal_alignment_changed), flowbox);
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Fill");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Start");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "End");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Center");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_VALIGN);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the vertical alignment policy");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (vertical_alignment_changed), flowbox);
/* Add Orientation control */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the flowbox orientation");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (orientation_changed), flowbox);
/* Add selection mode control */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "None");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Single");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Browse");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Multiple");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 1);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the selection mode");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (selection_mode_changed), flowbox);
/* Add minimum line length in items control */
widget = gtk_spin_button_new_with_range (1, 10, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_MINIMUM_LENGTH);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the minimum amount of items per line before wrapping");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (line_length_changed), flowbox);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (line_length_changed), flowbox);
/* Add natural line length in items control */
widget = gtk_spin_button_new_with_range (1, 10, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_MAXIMUM_LENGTH);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the natural amount of items per line ");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (max_line_length_changed), flowbox);
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (max_line_length_changed), flowbox);
/* Add horizontal/vertical spacing controls */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_widget_show (hbox);
widget = gtk_label_new ("H Spacing");
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
widget = gtk_spin_button_new_with_range (0, 30, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_CSPACING);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the horizontal spacing between children");
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL));
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL));
gtk_box_pack_start (GTK_BOX (flowbox_cntl), hbox, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_widget_show (hbox);
widget = gtk_label_new ("V Spacing");
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
widget = gtk_spin_button_new_with_range (0, 30, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_RSPACING);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the vertical spacing between children");
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL));
g_signal_connect (G_OBJECT (widget), "value-changed",
G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL));
gtk_box_pack_start (GTK_BOX (flowbox_cntl), hbox, FALSE, FALSE, 0);
/* filtering and sorting */
widget = gtk_check_button_new_with_label ("Filter");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set whether some items should be filtered out");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (filter_toggled), flowbox);
widget = gtk_check_button_new_with_label ("Sort");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set whether items should be sorted");
gtk_box_pack_start (GTK_BOX (flowbox_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (sort_toggled), flowbox);
/* Add test items control frame */
expander = gtk_expander_new ("Test item controls");
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
items_cntl = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_widget_show (items_cntl);
gtk_widget_show (expander);
gtk_container_add (GTK_CONTAINER (expander), items_cntl);
gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);
/* Add Items control */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Simple");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Focus");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Wrappy");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Stock");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Images");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the item set to use");
gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (items_changed), flowbox);
/* Add Text Orientation control */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_show (widget);
gtk_widget_set_tooltip_text (widget, "Set the item's text orientation (cant be done for stock buttons)");
gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (text_orientation_changed), flowbox);
populate_items (GTK_FLOW_BOX (flowbox));
/* This line was added only for the convenience of reproducing
* a height-for-width inside GtkScrolledWindow bug (bug 629778).
* -Tristan
*/
gtk_window_set_default_size (GTK_WINDOW (window), 390, -1);
return window;
}
