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; }