void menu_cb(GtkWidget *w, gint info) { char command[PATH_MAX+32]; /* we should malloc this */ GtkWidget *filew; GtkWidget *dialog; switch(info) { case 1: cardtree_delete(CARDTREE,NULL); RUN_LUA_COMMAND("card.CLA=0"); log_printf(LOG_INFO,"Cleared card data tree"); break; case 2: filew = gtk_file_chooser_dialog_new ("Open File", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filew), config_get_string(CONFIG_PATH_OPEN_SAVE)); if (gtk_dialog_run (GTK_DIALOG (filew)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filew)); sprintf(command,"ui.tree_load('%s')",filename); RUN_LUA_COMMAND(command); g_free (filename); filename = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filew)); config_set_string(CONFIG_PATH_OPEN_SAVE,filename); g_free(filename); } gtk_widget_destroy (filew); break; case 3: filew = gtk_file_chooser_dialog_new ("Save File", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (filew), TRUE); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filew), config_get_string(CONFIG_PATH_OPEN_SAVE)); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filew), "card.xml"); if (gtk_dialog_run (GTK_DIALOG (filew)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filew)); sprintf(command,"ui.tree_save('%s')",filename); RUN_LUA_COMMAND(command); g_free (filename); filename = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filew)); config_set_string(CONFIG_PATH_OPEN_SAVE,filename); g_free(filename); } gtk_widget_destroy (filew); break; case 4: filew = gtk_file_chooser_dialog_new ("Load script", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filew), config_get_string(CONFIG_PATH_LOAD_SCRIPT)); if (gtk_dialog_run (GTK_DIALOG (filew)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filew)); RUN_LUA_SCRIPT(filename); g_free (filename); filename = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filew)); config_set_string(CONFIG_PATH_LOAD_SCRIPT,filename); g_free(filename); } gtk_widget_destroy (filew); break; case 11: RUN_LUA_COMMAND("card.connect()"); break; case 12: RUN_LUA_COMMAND("card.warm_reset()"); break; case 13: RUN_LUA_COMMAND("card.disconnect()"); break; case 99: dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "%s", "cardpeek, version 0.1\nCopyright 2009, by 'L1L1'\nLicenced under the GPL 3"); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); default: log_printf(LOG_INFO,"menu option : %i",info); } }
int Dialog::run(){ if(m_dialog == nullptr) return -1; return gtk_dialog_run(GTK_DIALOG(m_dialog)); }
NedMidiRecordConfigDialog::NedMidiRecordConfigDialog(GtkWindow *parent, int num, int denom, int midi_pgm, int tempo_inverse, int volume, bool triplet, bool f_piano, bool dnt_split, int keysig) : m_num(num), m_denom(denom), m_pgm(midi_pgm), m_tempo_inverse(tempo_inverse), m_metro_volume(volume), m_triplet(triplet), m_f_piano(f_piano), m_dnt_split(dnt_split), m_keysig(keysig) { int i; GtkWidget *dialog; GtkWidget *time_signature_frame; GtkWidget *numerator_label; GtkWidget *denominator_label; GtkWidget *time_signature_vbox; GtkWidget *time_signature_upper_hbox; GtkWidget *time_signature_lower_hbox; GtkWidget *right_vbox; GtkWidget *instrument_scroll; GtkWidget *upper_hbox; GtkListStore *instrumend_list_store; GtkTreeIter iter; GtkCellRenderer *instrument_renderer; GtkTreeViewColumn *instrument_column; GtkTreeViewColumn *instrument_num_column; GtkTreePath* instrument_tree_path; GtkWidget *tempo_frame; GtkWidget *key_frame; GtkWidget *key_frame_left_vbox; GtkWidget *key_frame_right_vbox; GtkWidget *radio_hbox; GtkWidget *main_vbox; GtkWidget *metro_volume_frame; char Str[128]; dialog = gtk_dialog_new_with_buttons(_("Config Record"), parent, (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); g_signal_connect(dialog, "response", G_CALLBACK (OnClose), (void *) this); time_signature_frame = gtk_frame_new(_("time signature")); time_signature_vbox = gtk_vbox_new(FALSE, 5); time_signature_upper_hbox = gtk_hbox_new(FALSE, 5); time_signature_lower_hbox = gtk_hbox_new(FALSE, 5); numerator_label = gtk_label_new(_("Numerator:")); denominator_label = gtk_label_new(_("Denominator:")); m_numerator = gtk_spin_button_new_with_range (1.0, 20.0, 1.0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(m_numerator), m_num); m_denominator = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(m_denominator), "2"); gtk_combo_box_append_text(GTK_COMBO_BOX(m_denominator), "4"); gtk_combo_box_append_text(GTK_COMBO_BOX(m_denominator), "8"); gtk_combo_box_append_text(GTK_COMBO_BOX(m_denominator), "16"); if (m_denom < 4) { gtk_combo_box_set_active(GTK_COMBO_BOX(m_denominator), 0); } else if (m_denom < 8) { gtk_combo_box_set_active(GTK_COMBO_BOX(m_denominator), 1); } else if (m_denom < 16) { gtk_combo_box_set_active(GTK_COMBO_BOX(m_denominator), 2); } else { gtk_combo_box_set_active(GTK_COMBO_BOX(m_denominator), 3); } gtk_box_pack_start (GTK_BOX (time_signature_upper_hbox), numerator_label, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (time_signature_upper_hbox), m_numerator, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (time_signature_lower_hbox), denominator_label, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (time_signature_lower_hbox), m_denominator, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (time_signature_vbox), time_signature_upper_hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (time_signature_vbox), time_signature_lower_hbox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER(time_signature_frame), time_signature_vbox); m_with_triplet_button = gtk_toggle_button_new_with_label(_("triplet recognition")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_with_triplet_button), m_triplet); m_force_piano_button = gtk_toggle_button_new_with_label(_("force piano")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_force_piano_button), m_f_piano); m_dont_split_button = gtk_toggle_button_new_with_label(_("don't split tracks")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_dont_split_button), m_dnt_split); if (m_dnt_split) { gtk_widget_set_sensitive(m_force_piano_button, FALSE); } else if (m_f_piano) { gtk_widget_set_sensitive(m_dont_split_button, FALSE); } g_signal_connect(m_force_piano_button, "toggled", G_CALLBACK (OnPianoForcePressed), (void *) this); g_signal_connect(m_dont_split_button, "toggled", G_CALLBACK (OnDontSplitPressed), (void *) this); right_vbox = gtk_vbox_new(FALSE, 5); gtk_box_pack_start (GTK_BOX(right_vbox), time_signature_frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(right_vbox), m_with_triplet_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(right_vbox), m_force_piano_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(right_vbox), m_dont_split_button, FALSE, FALSE, 0); instrumend_list_store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING); for (i = 0; i < NedResource::getNumInstruments(); i++) { gtk_list_store_append (instrumend_list_store, &iter); gtk_list_store_set (instrumend_list_store, &iter, 0, i, 1, gettext(NedResource::GM_Instruments[i]), -1); } m_instrument_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(instrumend_list_store)); instrument_renderer = gtk_cell_renderer_text_new (); instrument_num_column = gtk_tree_view_column_new_with_attributes (_("no"), instrument_renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (m_instrument_list), instrument_num_column); instrument_column = gtk_tree_view_column_new_with_attributes (_("instruments"), instrument_renderer, "text", 1, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (m_instrument_list), instrument_column); m_instrument_adjustment = gtk_adjustment_new (0.0, 0.0, NedResource::getNumInstruments(), 1.0, 10.0, 10.0); instrument_scroll = gtk_vscrollbar_new(GTK_ADJUSTMENT(m_instrument_adjustment)); gtk_tree_view_set_vadjustment (GTK_TREE_VIEW (m_instrument_list), GTK_ADJUSTMENT(m_instrument_adjustment)); gtk_widget_set_size_request(m_instrument_list, INSTRUMENTS_WIDGET_WIDTH, MIDI_RECORD_CONFIG_SHOW_WINDOW_HEIGHT); sprintf(Str, "%d", m_pgm); instrument_tree_path = gtk_tree_path_new_from_string(Str); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (m_instrument_list), instrument_tree_path, NULL, FALSE, 0.0, 0.0); gtk_tree_view_set_cursor(GTK_TREE_VIEW (m_instrument_list), instrument_tree_path, NULL, FALSE); g_signal_connect(dialog, "scroll-event", G_CALLBACK (OnScroll), (void *) this); tempo_frame = gtk_frame_new(_("tempo")); m_tempo_scale = gtk_vscale_new_with_range(0.1 * 60.0, 2.4 * 60.0, 0.4 * 60.0); gtk_range_set_inverted(GTK_RANGE(m_tempo_scale), TRUE); gtk_range_set_value(GTK_RANGE(m_tempo_scale), 60.0 * (double) m_tempo_inverse / 100000.0); gtk_container_add (GTK_CONTAINER(tempo_frame), m_tempo_scale); metro_volume_frame = gtk_frame_new(_("volume")); m_metro_volume_scale = gtk_vscale_new_with_range(0.0, 127.0, 1.0); gtk_range_set_inverted(GTK_RANGE(m_metro_volume_scale), TRUE); gtk_range_set_value(GTK_RANGE(m_metro_volume_scale), m_metro_volume); gtk_container_add (GTK_CONTAINER(metro_volume_frame), m_metro_volume_scale); key_frame = gtk_frame_new(_("key")); radio_hbox = gtk_hbox_new(FALSE, 2); key_frame_left_vbox = gtk_vbox_new(FALSE, 2); key_frame_right_vbox = gtk_vbox_new(FALSE, 2); m_sig_radio_buttons[0] = gtk_radio_button_new_with_label (NULL, gettext(NedStaffContextDialog::m_keyTab[0])); gtk_box_pack_start (GTK_BOX (key_frame_left_vbox), m_sig_radio_buttons[0], FALSE, FALSE, 0); for (i = -5; i < 7; i++) { m_sig_radio_buttons[i+6] = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (m_sig_radio_buttons[0]), gettext(NedStaffContextDialog::m_keyTab[i+6])); if (i < 0) { gtk_box_pack_start (GTK_BOX (key_frame_left_vbox), m_sig_radio_buttons[i+6], FALSE, FALSE, 0); } else { gtk_box_pack_start (GTK_BOX (key_frame_right_vbox), m_sig_radio_buttons[i+6], FALSE, FALSE, 0); } } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (m_sig_radio_buttons[keysig+6]), TRUE); gtk_box_pack_start (GTK_BOX (radio_hbox), key_frame_left_vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (radio_hbox), key_frame_right_vbox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER(key_frame), radio_hbox); upper_hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start (GTK_BOX(upper_hbox), m_instrument_list, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX(upper_hbox), instrument_scroll, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(upper_hbox), right_vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(upper_hbox), tempo_frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(upper_hbox), metro_volume_frame, FALSE, FALSE, 0); main_vbox = gtk_vbox_new(FALSE, 5); gtk_box_pack_start (GTK_BOX(main_vbox), upper_hbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX(main_vbox), key_frame, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), main_vbox); gtk_widget_show_all (dialog); gtk_dialog_run(GTK_DIALOG(dialog)); }
void cheese_cmd_file_save_as (GtkWidget *widget, CheeseWindow *cheese_window) { GtkWidget *dialog; int response; char *filename; char *basename; filename = cheese_thumb_view_get_selected_image (cheese_window_get_thumbview (cheese_window)); g_return_if_fail (filename); dialog = gtk_file_chooser_dialog_new (_("Save File"), GTK_WINDOW (cheese_window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); basename = g_path_get_basename (filename); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), basename); g_free (basename); response = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_hide (dialog); if (response == GTK_RESPONSE_ACCEPT) { char *target_filename; GError *error = NULL; gboolean ok; target_filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); GFile *target = g_file_new_for_path (target_filename); GFile *source = g_file_new_for_path (filename); ok = g_file_copy (source, target, G_FILE_COPY_OVERWRITE, NULL, NULL, NULL, &error); g_object_unref (source); g_object_unref (target); if (!ok) { char *header; GtkWidget *dlg; g_error_free (error); header = g_strdup_printf (_("Could not save %s"), target_filename); dlg = gtk_message_dialog_new (GTK_WINDOW (cheese_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", header); gtk_dialog_run (GTK_DIALOG (dlg)); gtk_widget_destroy (dlg); g_free (header); } g_free (target_filename); } g_free (filename); gtk_widget_destroy (dialog); }
static void execute_action_mitem_cb (GtkMenuItem *menuitem, UiFormGrid *formgrid) { TFavoritesAction *act; GtkWidget *dlg; gchar *tmp; gint response; GtkWidget *toplevel; act = (TFavoritesAction*) g_object_get_data (G_OBJECT (menuitem), "action"); toplevel = gtk_widget_get_toplevel ((GtkWidget*) formgrid); tmp = g_strdup_printf (_("Set or confirm the parameters to execute\n" "action '%s'"), act->name); dlg = gdaui_basic_form_new_in_dialog (act->params, (GtkWindow*) toplevel, _("Execution of action"), tmp); g_free (tmp); response = gtk_dialog_run (GTK_DIALOG (dlg)); gtk_widget_destroy (dlg); if (response == GTK_RESPONSE_ACCEPT) { GError *lerror = NULL; TConnection *tcnc; tcnc = get_t_connection (formgrid); g_assert (tcnc); GObject *result; result = t_connection_execute_statement (tcnc, act->stmt, act->params, GDA_STATEMENT_MODEL_RANDOM_ACCESS, NULL, &lerror); if (result && GDA_IS_DATA_MODEL (result)) { GtkWidget *dialog, *label, *fg; GtkWidget *dcontents; gchar *tmp; dialog = gtk_dialog_new_with_buttons (act->name, NULL, 0, _("_Close"), GTK_RESPONSE_CLOSE, NULL); dcontents = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_box_set_spacing (GTK_BOX (dcontents), 5); gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE, TRUE); tmp = g_markup_printf_escaped ("<b>%s:</b>", act->name); label = gtk_label_new (""); gtk_label_set_markup (GTK_LABEL (label), tmp); g_free (tmp); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_box_pack_start (GTK_BOX (dcontents), label, FALSE, FALSE, 5); fg = ui_formgrid_new (GDA_DATA_MODEL (result), TRUE, GDAUI_DATA_PROXY_INFO_CURRENT_ROW); ui_formgrid_set_connection (UI_FORMGRID (fg), tcnc); ActionExecutedData *aed; aed = g_new0 (ActionExecutedData, 1); aed->formgrid = g_object_ref (formgrid); aed->tcnc = g_object_ref (tcnc); if (act->name) aed->name = g_strdup (act->name); aed->stmt = g_object_ref (act->stmt); aed->params = g_object_ref (act->params); if (GDA_IS_DATA_SELECT (result)) { GdaStatement *stmt; g_object_get (G_OBJECT (result), "select-stmt", &stmt, NULL); if (stmt) { ui_formgrid_handle_user_prefs (UI_FORMGRID (fg), NULL, stmt); g_object_unref (stmt); } aed->model = g_object_ref (result); g_signal_connect (aed->params, "holder-changed", G_CALLBACK (action_executed_holder_changed_cb), aed); aed->formgrid = g_object_ref (fg); aed->formgrid->priv->autoupdate_possible = TRUE; gtk_widget_show (aed->formgrid->priv->autoupdate_toggle); } gtk_box_pack_start (GTK_BOX (dcontents), fg, TRUE, TRUE, 0); gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 600); gtk_widget_show_all (dialog); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); g_signal_connect (dialog, "close", G_CALLBACK (gtk_widget_destroy), NULL); g_object_set_data_full (G_OBJECT (dialog), "aed", aed, (GDestroyNotify) action_executed_data_free); } else if (result) { if (BROWSER_IS_WINDOW (toplevel)) { browser_window_show_notice_printf (BROWSER_WINDOW (toplevel), GTK_MESSAGE_INFO, "ActionExecution", "%s", _("Action successfully executed")); } else ui_show_message (GTK_WINDOW (toplevel), "%s", _("Action successfully executed")); g_object_unref (result); } else { ui_show_error (GTK_WINDOW (toplevel), _("Error executing query: %s"), lerror && lerror->message ? lerror->message : _("No detail")); g_clear_error (&lerror); } } }
static void rompath_changed_cb (GFileMonitor *monitor, GFile *file, GFile *other_file, GFileMonitorEvent event_type) { static GtkWidget *dialog = NULL; gint response; if (dialog != NULL) return; /* Filter out events we don't care about. */ switch (event_type) { case G_FILE_MONITOR_EVENT_CHANGED: case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT: case G_FILE_MONITOR_EVENT_DELETED: case G_FILE_MONITOR_EVENT_CREATED: break; default: return; } dialog = gtk_message_dialog_new_with_markup ( GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "<big><b>%s</b></big>", _("Changes detected in ROM files")); gtk_message_dialog_format_secondary_text ( GTK_MESSAGE_DIALOG (dialog), _("GNOME Video Arcade has detected changes in your " "ROM files and will need to audit them in order to " "update the game list. However the audit may take " "several minutes to complete. Would you like to " "perform the audit now?\n\nIf you skip the audit now, " "it will be performed automatically the next time you " "start GNOME Video Arcade.")); gtk_dialog_add_buttons ( GTK_DIALOG (dialog), _("_Skip Audit"), GTK_RESPONSE_NO, _("_Audit ROM Files"), GTK_RESPONSE_YES, NULL); response = gtk_dialog_run (GTK_DIALOG (dialog)); /* Don't destroy the dialog just yet. If the file monitor * trips again while we're analyzing ROMs, we want the NULL * check at the top of the function to evaluate TRUE so we * return immediately. */ gtk_widget_hide (dialog); if (response == GTK_RESPONSE_YES) { GError *error = NULL; gva_ui_lock (); gva_main_analyze_roms (&error); gva_error_handle (&error); gva_tree_view_update (&error); gva_error_handle (&error); gva_ui_unlock (); /* Present a helpful dialog if no ROMs were found. */ warn_if_no_roms (); } else { /* Don't bother the user again during this session. */ g_signal_handlers_disconnect_by_func ( monitor, rompath_changed_cb, NULL); } gtk_widget_destroy (dialog); dialog = NULL; }
static void _really_move_to_trash (CheeseWindow *cheese_window, GList *files) { GError *error = NULL; GList *l = NULL; GList *d = NULL; gchar *primary, *secondary; GtkWidget *question_dialog; gint response; gint list_length = g_list_length (files); g_print ("received %d items to delete\n", list_length); for (l = files; l != NULL; l = l->next) { if (!g_file_test (g_file_get_path (l->data), G_FILE_TEST_EXISTS)) { g_object_unref (l->data); break; } if (!g_file_trash (l->data, NULL, &error)) { primary = g_strdup (_("Cannot move file to trash, do you want to delete immediately?")); secondary = g_strdup_printf (_("The file \"%s\" cannot be moved to the trash. Details: %s"), g_file_get_basename (l->data), error->message); question_dialog = gtk_message_dialog_new (GTK_WINDOW (cheese_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "%s", primary); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (question_dialog), "%s", secondary); gtk_dialog_add_button (GTK_DIALOG (question_dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); if (list_length > 1) { /* no need for all those buttons we have a single file to delete */ gtk_dialog_add_button (GTK_DIALOG (question_dialog), CHEESE_BUTTON_SKIP, CHEESE_RESPONSE_SKIP); gtk_dialog_add_button (GTK_DIALOG (question_dialog), CHEESE_BUTTON_SKIP_ALL, CHEESE_RESPONSE_SKIP_ALL); gtk_dialog_add_button (GTK_DIALOG (question_dialog), CHEESE_BUTTON_DELETE_ALL, CHEESE_RESPONSE_DELETE_ALL); } gtk_dialog_add_button (GTK_DIALOG (question_dialog), GTK_STOCK_DELETE, GTK_RESPONSE_ACCEPT); response = gtk_dialog_run (GTK_DIALOG (question_dialog)); gtk_widget_destroy (question_dialog); g_free (primary); g_free (secondary); g_error_free (error); error = NULL; switch (response) { case CHEESE_RESPONSE_DELETE_ALL: /* forward the list to cmd_delete */ _really_delete (cheese_window, l, TRUE); return; case GTK_RESPONSE_ACCEPT: /* create a single file list for cmd_delete */ d = g_list_append (d, g_object_ref (l->data)); _really_delete (cheese_window, d, TRUE); g_list_free (d); break; case CHEESE_RESPONSE_SKIP: /* do nothing, skip to the next item */ break; case CHEESE_RESPONSE_SKIP_ALL: case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: default: /* cancel the whole delete operation */ return; } } else { cheese_thumb_view_remove_item (cheese_window_get_thumbview (cheese_window), l->data); } g_object_unref (l->data); } }
int main (int argc, char **argv) { GksuContext *context; GError *error = NULL; gint newargc = 0; gchar **newargv = NULL; gint8 exit_status = -1; guint run_mode = DEFAULT_MODE; int c = 0; setlocale (LC_ALL, ""); bindtextdomain(PACKAGE_NAME, LOCALEDIR); bind_textdomain_codeset (PACKAGE_NAME, "UTF-8"); textdomain(PACKAGE_NAME); /* * bad, bad code... adds a second -- right after the first one, * because gtk_init will remove one of them... */ { /* to check whether a -- was already found when parsing arguments */ gboolean separator_found = 0; for (c = 0; c < argc; c++) { if (!strcmp ("--", argv[c]) && (!separator_found)) { newargv = g_realloc (newargv, sizeof(char*) * (newargc + 2)); newargv[newargc] = g_strdup (argv[c]); newargv[newargc + 1] = g_strdup (argv[c]); newargc = newargc + 2; separator_found = TRUE; } else { newargv = g_realloc (newargv, sizeof(char*) * (newargc + 1)); newargv[newargc] = g_strdup (argv[c]); newargc++; } } } gtk_init (&newargc, &newargv); context = gksu_context_new (); while ((c = getopt_long(newargc, newargv, "?hu:lpm:kt:i:gdsSwP::aD:", long_opts, NULL)) != EOF) { switch (c) { case 0: break; case 'h': help (newargv[0]); exit(0); break; case '?': help (newargv[0]); exit(0); break; case 'u': gksu_context_set_user (context, optarg); break; case 'l': gksu_context_set_login_shell (context, TRUE); break; case 'p': print_pass = TRUE; break; case 'm': gksu_context_set_message (context, optarg); break; case 'k': gksu_context_set_keep_env (context, TRUE); break; case 'g': gksu_context_set_grab (context, FALSE); if (optarg != NULL) { if (!strcasecmp (optarg, "yes")); /* ignore, already set */ else if (!strcasecmp (optarg, "no")) gksu_context_set_grab (context, FALSE); else { fprintf (stderr, _("Option not accepted for --disable-grab: %s\n"), optarg); return 1; } } break; case 'd': gksu_context_set_debug (context, TRUE); break; case 'D': if (!g_access (optarg, R_OK)) set_description_from_desktop (context, optarg); else gksu_context_set_description (context, optarg); break; case 'S': run_mode = SUDO_MODE; break; case 'w': run_mode = SU_MODE; break; case 'P': prompt = TRUE; if (optarg != NULL) { if (!strcasecmp (optarg, "yes")); /* ignore, already set */ else if (!strcasecmp (optarg, "no")) prompt = FALSE; else { fprintf (stderr, _("Option not accepted for --prompt: %s\n"), optarg); return 1; } } break; } } { /* support gksu_sudo_run */ gchar *myname = g_path_get_basename (argv[0]); if (!strcmp(myname, "gksudo")) run_mode = SUDO_MODE; g_free (myname); } if (force_grab) gksu_context_set_grab (context, TRUE); if (prompt) { GtkWidget *d; d = gtk_message_dialog_new_with_markup (NULL, 0, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, _("<b>Would you like your screen to be \"grabbed\"\n" "while you enter the password?</b>" "\n\n" "This means all applications will be paused to avoid\n" "the eavesdropping of your password by a a malicious\n" "application while you type it.")); if (gtk_dialog_run (GTK_DIALOG(d)) == GTK_RESPONSE_NO) gksu_context_set_grab (context, FALSE); else gksu_context_set_grab (context, TRUE); gtk_widget_destroy (d); } if (print_pass) { gchar *password = NULL; if ((gksu_context_get_message (context) == NULL) && (gksu_context_get_description (context) == NULL) && (gksu_context_get_command (context) == NULL)) { gk_dialog (GTK_MESSAGE_ERROR, _("<big><b>Missing options or arguments</b></big>\n\n" "You need to provide --description or --message.")); return 1; } password = gksu_ask_password_full (context, NULL, &error); if (error) { gk_dialog (GTK_MESSAGE_ERROR, _("<b>Failed to request password.</b>\n\n%s"), error->message); return 3; } if (password) printf ("%s\n", password); return 0; } /* now we can begin to care about a command */ if (newargc <= optind) request_command_and_user (context); /* previously known as gksuexec */ else { gchar *command = g_strdup (newargv[optind]); gchar *tmp = NULL; gint i = 0; if (!strncmp ("--", command, 2)) { optind = optind + 1; if (newargc <= optind) { gk_dialog (GTK_MESSAGE_ERROR, _("Missing command to run.")); return 1; } g_free (command); command = g_strdup (newargv[optind]); } for (i = optind + 1; i < newargc; i++) { // in sudo mode, check for ' and \ in string and escape it if(run_mode == SUDO_MODE && (strchr(newargv[i],'\'') || strchr(newargv[i],'\\'))) { const gchar *p = newargv[i]; gchar *q,*dest; dest = q = g_malloc(strlen(newargv[i])*2+1); while(*p) { if (*p == '\'') *q++ = '\\'; else if (*p == '\\') *q++ = '\\'; *q++ = *p++; } *q = 0; g_free(newargv[i]); newargv[i] = dest; } tmp = g_strconcat (command, " '", newargv[i], "'", NULL); g_free (command); command = tmp; } gksu_context_set_command (context, command); g_free (command); } /* * FIXME: should be moved to libgksu, which should have two new API functions: * gksu_context_launcher_context_{initiate,complete} */ { struct passwd *pwentry; pwentry = getpwnam (gksu_context_get_user (context)); if (!pwentry) { gk_dialog (GTK_MESSAGE_ERROR, _("User %s does not exist."), gksu_context_get_user (context)); return 1; } if (pwentry->pw_uid == geteuid ()) { gint retval = g_spawn_command_line_sync (gksu_context_get_command (context), NULL, NULL, NULL, NULL); return retval; } } { gint count = 0; for (count = 0; count < 3; count++) { if (error) /* wrong password was given */ { gksu_context_set_alert (context, _("<b>Incorrect password... try again.</b>")); g_error_free (error); error = NULL; } if (run_mode == SUDO_MODE) gksu_sudo_fuller (context, NULL, NULL, NULL, NULL, &exit_status, &error); else if (run_mode == SU_MODE) gksu_su_fuller (context, NULL, NULL, NULL, NULL, &exit_status, &error); else gksu_run_fuller (context, NULL, NULL, NULL, NULL, &exit_status, &error); if ((error == NULL) || (error->code != GKSU_ERROR_WRONGPASS)) break; } } if (error && (error->code != GKSU_ERROR_CANCELED)) { gk_dialog (GTK_MESSAGE_ERROR, _("<b>Failed to run %s as user %s.</b>\n\n%s"), gksu_context_get_command (context), gksu_context_get_user (context), error->message); return 3; } return exit_status; }
static gboolean confirm_delete_immediately (GtkWidget *parent_view, gint num_files, gboolean all) { GdkScreen *screen; GtkWidget *dialog, *hbox, *vbox, *image, *label; gchar *str, *prompt, *detail; int response; screen = gtk_widget_get_screen (parent_view); dialog = gtk_dialog_new (); gtk_window_set_screen (GTK_WINDOW (dialog), screen); atk_object_set_role (gtk_widget_get_accessible (dialog), ATK_ROLE_ALERT); gtk_window_set_title (GTK_WINDOW (dialog), _("Delete Immediately?")); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_widget_realize (dialog); gdk_window_set_transient_for (gtk_widget_get_window (GTK_WIDGET (dialog)), gdk_screen_get_root_window (screen)); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 14); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_widget_show (hbox); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, FALSE, FALSE, 0); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_widget_show (image); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); if (all) { prompt = _("Cannot move items to trash, do you want to delete them immediately?"); detail = g_strdup_printf ("None of the %d selected items can be moved to the Trash", num_files); } else { prompt = _("Cannot move some items to trash, do you want to delete these immediately?"); detail = g_strdup_printf ("%d of the selected items cannot be moved to the Trash", num_files); } str = g_strconcat ("<span weight=\"bold\" size=\"larger\">", prompt, "</span>", NULL); label = gtk_label_new (str); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (str); label = gtk_label_new (detail); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (detail); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_DELETE, GTK_RESPONSE_YES); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES); response = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (GTK_WIDGET (dialog)); return response == GTK_RESPONSE_YES; }
void show_hide_advanced (GtkWidget *button, gpointer data) { GtkWidget *parent, *tmp; GtkWidget *dialog; GtkWidget *vbox; GtkWidget *label; GtkWidget *check_login; GtkWidget *check_presenv; GksuContext *context = (GksuContext*)data; gint response; parent = gtk_widget_get_parent (button); while ((tmp = gtk_widget_get_parent (parent)) != NULL) parent = tmp; dialog = gtk_dialog_new_with_buttons (_("Advanced options"), GTK_WINDOW(parent), GTK_DIALOG_MODAL, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_dialog_set_has_separator (GTK_DIALOG(dialog), FALSE); gtk_container_set_border_width (GTK_CONTAINER(dialog), 4); /* vbox points to the dialog's vbox */ vbox = GTK_DIALOG(dialog)->vbox; gtk_box_set_spacing (GTK_BOX(vbox), 3); /* label */ label = gtk_label_new (""); gtk_label_set_markup (GTK_LABEL(label), _("<b>Options to use when changing user</b>")); gtk_box_pack_start (GTK_BOX(vbox), label, TRUE, TRUE, 5); gtk_widget_show (label); /* login shell? (--login) */ check_login = gtk_check_button_new_with_mnemonic (_("_login shell")); if (gksu_context_get_login_shell (context) == TRUE) /* window may have been opened before */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check_login), TRUE); gtk_box_pack_start (GTK_BOX(vbox), check_login, TRUE, TRUE, 0); gtk_widget_show (check_login); /* preserve environment (--preserve-env) */ check_presenv = gtk_check_button_new_with_mnemonic (_("_preserve environment")); if (gksu_context_get_keep_env (context) == TRUE) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check_presenv), TRUE); gtk_box_pack_start (GTK_BOX(vbox), check_presenv, TRUE, TRUE, 0); gtk_widget_show (check_presenv); response = gtk_dialog_run (GTK_DIALOG(dialog)); if (response == GTK_RESPONSE_NONE) return; if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(check_login))) gksu_context_set_login_shell (context, TRUE); else gksu_context_set_login_shell (context, FALSE); if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(check_presenv))) gksu_context_set_keep_env (context, TRUE); else gksu_context_set_keep_env (context, FALSE); gtk_widget_destroy (dialog); }
void request_command_and_user (GksuContext *context) { GtkWidget *dialog; GtkWidget *hbox; GtkWidget *lvbox; GtkWidget *rvbox; GtkWidget *image; GtkWidget *label_cmd; GtkWidget *entry_cmd; GtkWidget *label_user; GtkWidget *combo_user; /* advanced stuff */ GtkWidget *advanced_button; gint response; gchar *tmp = NULL; dialog = gtk_dialog_new_with_buttons (_("Run program"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_has_separator (GTK_DIALOG(dialog), FALSE); /* horizontal box */ hbox = gtk_hbox_new (FALSE, 4); gtk_container_set_border_width (GTK_CONTAINER(hbox), 5); gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, TRUE, 2); /* left vertical box */ lvbox = gtk_vbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX(hbox), lvbox, TRUE, TRUE, 0); /* command */ label_cmd = gtk_label_new (_("Run:")); gtk_label_set_justify (GTK_LABEL(label_cmd), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX(lvbox), label_cmd, TRUE, TRUE, 0); entry_cmd = gtk_entry_new (); gtk_signal_connect (GTK_OBJECT(entry_cmd), "activate", GTK_SIGNAL_FUNC(response_ok_cb), dialog); gtk_box_pack_start (GTK_BOX(lvbox), entry_cmd, TRUE, TRUE, 0); /* user name */ label_user = gtk_label_new (_("As user:"******"/pixmaps/gksu-icon.png"); gtk_box_pack_start (GTK_BOX(rvbox), image, TRUE, TRUE, 0); /* advanced button */ advanced_button = gtk_button_new_with_mnemonic (_("_Advanced")); g_signal_connect (G_OBJECT(advanced_button), "clicked", G_CALLBACK(show_hide_advanced), context); gtk_box_pack_start (GTK_BOX(rvbox), advanced_button, TRUE, FALSE, 0); /* let the magic begin! */ gtk_widget_show_all (dialog); while (TRUE) { response = gtk_dialog_run (GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: case GTK_RESPONSE_NONE: exit (0); } tmp = gtk_editable_get_chars (GTK_EDITABLE(entry_cmd), 0, -1); if (tmp) { gksu_context_set_command (context, tmp); g_free (tmp); } tmp = gtk_combo_box_get_active_text (GTK_COMBO_BOX(combo_user)); if (tmp) { gksu_context_set_user (context, tmp); g_free (tmp); } if (!strcmp (gksu_context_get_user (context), "")) { gk_dialog (GTK_MESSAGE_ERROR, _("Missing command to run.")); } else { gtk_widget_destroy (dialog); break; } } }
static void tip_model_dialog(TipModelArgs *args) { enum { RESPONSE_RESET = 1, RESPONSE_PREVIEW = 2 }; GtkWidget *dialog, *table, *hbox, *spin; TipModelControls controls; GwyPixmapLayer *layer; GwyDataField *dfield; GwySIUnit *unit; GQuark quark; gint response, row; dialog = gtk_dialog_new_with_buttons(_("Model Tip"), NULL, 0, NULL); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), gwy_stock_like_button_new(_("_Update"), GTK_STOCK_EXECUTE), RESPONSE_PREVIEW); gtk_dialog_add_button(GTK_DIALOG(dialog), _("_Reset"), RESPONSE_RESET); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); hbox = gtk_hbox_new(FALSE, 3); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 4); controls.args = args; controls.vxres = 200; controls.vyres = 200; /* set up initial tip field */ quark = gwy_app_get_data_key_for_id(args->object.id); dfield = GWY_DATA_FIELD(gwy_container_get_object(args->object.data, quark)); controls.tip = gwy_data_field_new_alike(dfield, TRUE); gwy_data_field_resample(controls.tip, controls.vxres, controls.vyres, GWY_INTERPOLATION_NONE); gwy_data_field_clear(controls.tip); /*set up data of rescaled image of the tip*/ controls.vtip = gwy_container_new(); gwy_app_sync_data_items(args->object.data, controls.vtip, args->object.id, 0, FALSE, GWY_DATA_ITEM_PALETTE, 0); dfield = gwy_data_field_new_alike(controls.tip, TRUE); gwy_container_set_object_by_name(controls.vtip, "/0/data", dfield); g_object_unref(dfield); /* set up resampled view */ controls.view = gwy_data_view_new(controls.vtip); layer = gwy_layer_basic_new(); gwy_pixmap_layer_set_data_key(layer, "/0/data"); gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/0/base/palette"); gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer); /* set up tip model controls */ gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4); table = gtk_table_new(6, 4, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(hbox), table, FALSE, FALSE, 4); row = 0; controls.type = create_preset_menu(G_CALLBACK(tip_type_cb), &controls, args->type); gwy_table_attach_hscale(table, row, _("Tip _type:"), NULL, GTK_OBJECT(controls.type), GWY_HSCALE_WIDGET); row++; controls.nsides = gtk_adjustment_new(args->nsides, 3, 24, 1, 5, 0); gwy_table_attach_hscale(table, row, _("_Number of sides:"), NULL, controls.nsides, 0); row++; controls.angle = gtk_adjustment_new(args->angle, 0.1, 89.9, 0.1, 1, 0); spin = gwy_table_attach_hscale(table, row, _("Tip _slope:"), _("deg"), controls.angle, 0); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 2); row++; controls.theta = gtk_adjustment_new(args->theta, 0, 360, 0.1, 1, 0); spin = gwy_table_attach_hscale(table, row, _("Tip _rotation:"), _("deg"), controls.theta, 0); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 2); row++; controls.radius = gtk_adjustment_new(1.0, 0.01, 1000.0, 0.01, 1.0, 0.0); controls.radius_spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.radius), 0.1, 2); gtk_table_attach(GTK_TABLE(table), controls.radius_spin, 2, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); controls.radius_label = gtk_label_new_with_mnemonic(_("Tip _apex radius:")); gtk_misc_set_alignment(GTK_MISC(controls.radius_label), 0.0, 0.5); gtk_label_set_mnemonic_widget(GTK_LABEL(controls.radius_label), controls.radius_spin); gtk_table_attach(GTK_TABLE(table), controls.radius_label, 0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); unit = gwy_data_field_get_si_unit_xy(dfield); controls.radius_unit = gwy_combo_box_metric_unit_new(G_CALLBACK(radius_changed_cb), &controls, -12, -3, unit, -9); gtk_table_attach(GTK_TABLE(table), controls.radius_unit, 3, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); g_signal_connect(controls.radius, "value-changed", G_CALLBACK(radius_changed_cb), &controls); row++; controls.labsize = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(controls.labsize), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), controls.labsize, 0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; controls.tipdone = FALSE; tip_model_dialog_update_controls(&controls, args); preview(&controls, args); gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: tip_model_dialog_update_values(&controls, args); gtk_widget_destroy(dialog); tip_model_dialog_abandon(&controls); case GTK_RESPONSE_NONE: return; break; case GTK_RESPONSE_OK: tip_model_do(args, &controls); break; case RESPONSE_RESET: args->nsides = tip_model_defaults.nsides; args->angle = tip_model_defaults.angle; args->radius = tip_model_defaults.radius; args->theta = tip_model_defaults.theta; args->type = tip_model_defaults.type; tip_model_dialog_update_controls(&controls, args); break; case RESPONSE_PREVIEW: tip_model_dialog_update_values(&controls, args); preview(&controls, args); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); tip_model_dialog_update_values(&controls, args); gtk_widget_destroy(dialog); tip_model_dialog_abandon(&controls); }
/*! \brief Opens a new page from a file. * \par Function Description * This function opens the file whose name is <B>filename</B> in a * new PAGE of <B>toplevel</B>. * * If there is no page for <B>filename</B> in <B>toplevel</B>'s list * of pages, it creates a new PAGE, loads the file in it and returns * a pointer on the new page. Otherwise it returns a pointer on the * existing page. * * If the filename passed is NULL, this function creates an empty, * untitled page. The name of the untitled page is build from * configuration data ('untitled-name') and a counter for uniqueness. * * The opened page becomes the current page of <B>toplevel</B>. * * \param [in] toplevel The toplevel environment. * \param [in] filename The name of the file to open or NULL for a blank page. * \returns A pointer on the new page. * * \bug This code should check to make sure any untitled filename * does not conflict with a file on disk. */ PAGE* x_window_open_page (GSCHEM_TOPLEVEL *w_current, const gchar *filename) { TOPLEVEL *toplevel = w_current->toplevel; PAGE *old_current, *page; gchar *fn; g_return_val_if_fail (toplevel != NULL, NULL); /* Generate untitled filename if none was specified */ if (filename == NULL) { gchar *cwd, *tmp; cwd = g_get_current_dir (); tmp = g_strdup_printf ("%s_%d.sch", toplevel->untitled_name, ++w_current->num_untitled); fn = g_build_filename (cwd, tmp, NULL); g_free(cwd); g_free(tmp); } else { fn = g_strdup (filename); } /* Return existing page if it is already loaded */ page = s_page_search (toplevel, fn); if ( page != NULL ) { g_free(fn); return page; } old_current = toplevel->page_current; page = s_page_new (toplevel, fn); s_page_goto (toplevel, page); /* Load from file if necessary, otherwise just print a message */ if (filename != NULL) { GError *err = NULL; if (!quiet_mode) s_log_message (_("Loading schematic [%s]\n"), fn); if (!f_open (toplevel, (gchar *) fn, &err)) { GtkWidget *dialog; g_warning ("%s\n", err->message); dialog = gtk_message_dialog_new (GTK_WINDOW (w_current->main_window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", err->message); gtk_window_set_title (GTK_WINDOW (dialog), _("Failed to load file")); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); g_error_free (err); } else { recent_files_add (fn); } } else { if (!quiet_mode) s_log_message (_("New file [%s]\n"), toplevel->page_current->page_filename); } if (scm_hook_empty_p (new_page_hook) == SCM_BOOL_F) scm_run_hook (new_page_hook, scm_cons (g_make_page_smob (toplevel, page), SCM_EOL)); a_zoom_extents (w_current, s_page_objects (toplevel->page_current), A_PAN_DONT_REDRAW); o_undo_savestate (w_current, UNDO_ALL); if ( old_current != NULL ) s_page_goto (toplevel, old_current); /* This line is generally un-needed, however if some code * wants to open a page, yet not bring it to the front, it is * needed needed to add it into the page manager. Otherwise, * it will get done in x_window_set_current_page(...) */ x_pagesel_update (w_current); /* ??? */ g_free (fn); return page; }
char* gui_select_reader(unsigned list_size, const char** list) { GtkWidget *dialog; GtkWidget *label; GtkWidget *combo; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *img; unsigned i; gint result; char *retval; dialog = gtk_dialog_new_with_buttons("Select card reader", GTK_WINDOW(MAIN_WINDOW), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); img = gtk_image_new_from_stock(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); vbox = gtk_vbox_new(FALSE,0); label = gtk_label_new("Select a card reader to use"); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 10); combo = gtk_combo_box_new_text(); gtk_box_pack_start(GTK_BOX(vbox), combo, FALSE, FALSE, 10); for (i=0;i<list_size;i++) { gtk_combo_box_append_text(GTK_COMBO_BOX(combo),list[i]); } gtk_combo_box_append_text(GTK_COMBO_BOX(combo),"none"); gtk_combo_box_set_active(GTK_COMBO_BOX(combo),0); hbox = gtk_hbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 10); gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 10); gtk_widget_show_all(hbox); gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), hbox); result = gtk_dialog_run (GTK_DIALOG (dialog)); switch (result) { case GTK_RESPONSE_ACCEPT: retval = gtk_combo_box_get_active_text(GTK_COMBO_BOX(combo)); log_printf(LOG_INFO,"Selected '%s'",retval); if (strcmp(retval,"none")==0) { g_free(retval); retval = NULL; } break; default: retval = NULL; log_printf(LOG_INFO,"Select empty"); break; } gtk_widget_destroy (dialog); return retval; /*if (retval) g_free(retval); return NULL;*/ }
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 = (surface_info_t *)g_object_get_data(G_OBJECT(w), "surface-info"); #else GdkPixmap *pixmap = (GdkPixmap *)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; GtkWidget *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; } parent = gtk_widget_get_toplevel(w); save_as_w = file_selection_new("Wireshark: Save Graph As ...", GTK_WINDOW(parent), FILE_SELECTION_SAVE); /* 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 = (GdkPixbufFormat *)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); /* * 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; } }
/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++ Main +++++++++++++++++++++++++++++++++++++++++++++++++++++++ */ uint8_t ADM_ocr_engine( void) { // uint32_t nbSub=0; FILE *out=NULL; head.next=NULL; ADMVideoVobSub *vobsub=NULL; uint32_t startTime,endTime; uint32_t w,h,oldw=0,oldh=0; uint32_t oldbitmapw=0; uint32_t oldbitmaph=0; uint32_t first,last; uint32_t seqNum; char text[1024]; lang_index=0; nbGlyphs=0; ReplyType reply; // Create UI && prepare callback dialog=DIA_ocr(); gtk_register_dialog(dialog); #define ASSOCIATE(x,y) gtk_dialog_add_action_widget (GTK_DIALOG (dialog), WID(x),y) ASSOCIATE(buttonStart,actionGo); ASSOCIATE(buttonOk, actionAccept); ASSOCIATE(buttonSkip, actionSkip); ASSOCIATE(buttonSkipAll, actionSkipAll); ASSOCIATE(buttonIgnore, actionIgnore); ASSOCIATE(buttonCalibrate, actionCalibrate); ASSOCIATE(buttonGlyphLoad, actionLoadGlyph); ASSOCIATE(buttonGlyphSave, actionSaveGlyph); ASSOCIATE(buttonVobsub, actionLoadVob); ASSOCIATE(buttonSrt, actionSaveSub); gtk_widget_show(dialog); // disable mainDisplay=WID(drawingareaBitmap); smallDisplay=WID(drawingareaSmall); CONNECT(drawingareaBitmap,expose_event,gui_draw); CONNECT(drawingareaSmall,expose_event,gui_draw_small); CONNECT(entry,activate,cb_accept); _again: reply=setup(); if(reply==ReplyClose) goto endIt; printf("Go go go\n"); // Everything ready go go go redraw_x=redraw_y=0; GTK_PURGE; // Time to go // Inactivate frame1=glyph frame2=in/out buttonStart gtk_widget_set_sensitive(WID(buttonStart),0); gtk_widget_set_sensitive(WID(frameGlyph),0); gtk_widget_set_sensitive(WID(frameLoad),0); gtk_widget_set_sensitive(WID(frameBitmap),1); gtk_widget_set_sensitive(WID(buttonStart),0); char *fileout; fileout=(char *)gtk_label_get_text(GTK_LABEL(WID(labelSrt))); if(!fileout) { GUI_Error_HIG(_("Incorrect output file"), NULL); goto _again; } out=fopen(fileout,"wb"); if(!out) { GUI_Error_HIG(_("Output file error"), _("Could not open \"%s\" for writing."), fileout); goto _again; } vobsub=new ADMVideoVobSub(subparam.subname,subparam.index); nbSub=vobsub->getNbImage(); if(!nbSub) { GUI_Error_HIG(_("Problem loading sub"), NULL); delete vobsub; vobsub=NULL; goto _again; } seqNum=1; // Sub number in srt file oldw=oldh=0; //****************** // Load all bitmaps //****************** for(uint32_t i=0;i<nbSub;i++) { first=last=0; bitmap=vobsub->getBitmap(i,&startTime, &endTime,&first,&last); ADM_assert(last>=first); // something ? if(!bitmap) continue; if(first==last) continue; // If the bitmap size changed or does not exist yet... if(!workArea || oldbitmapw!=bitmap->_width || oldbitmaph!=bitmap->_height) { if(workArea) { delete [] workArea; workArea=NULL; } // Workarea is actually bigger than what we use workArea=new uint8_t[bitmap->_width*(bitmap->_height)]; memset(workArea,0,bitmap->_width*(bitmap->_height)); } oldbitmaph=bitmap->_height; oldbitmapw=bitmap->_width; // w=bitmap->_width; h=last-first+1; redraw_x=w; redraw_y=h; //** // Build againPlease: mergeBitmap(bitmap->_bitmap+first*w, workArea, bitmap->_alphaMask+first*w, w, h); if(oldw!=w || oldh !=h) { GTK_PURGE; // Force redaw } // Merge GTK_PURGE; gui_draw(); GTK_PURGE; // OCR reply=ocrBitmap(workArea,w,h); if(reply==ReplyClose) goto endIt; if(reply==ReplyCalibrate) { // //printf("TADA!!!!\n"); int val; #if 0 val=minAlpha; if(DIA_GetIntegerValue(&val, 3, 7, "Minimum alpha value", "Enter new minimum alpha")) { minAlpha=val; } #endif val=minThreshold; if(DIA_GetIntegerValue(&val, 0x30, 0x80, "Minimum pixel value", "Enter new minimum pixel")) { minThreshold=val; } goto againPlease; } // gtk_label_set_text(GTK_LABEL(WID(labelText)),decodedString); fprintf(out,"%d\n",seqNum++); uint16_t hh,mm,ss,ms; ms2time(startTime, &hh, &mm, &ss, &ms); fprintf(out,"%02d:%02d:%02d,%03d --> ",hh,mm,ss,ms); ms2time(endTime, &hh, &mm, &ss, &ms); fprintf(out,"%02d:%02d:%02d,%03d\n",hh,mm,ss,ms); fprintf(out,"%s\n\n",decodedString); // oldw=w; oldh=h; // Update infos sprintf(text,"%03d/%03d",i+1,nbSub); gtk_label_set_text(GTK_LABEL(WID(labelNbLines)),text); sprintf(text,"%03d",nbGlyphs); gtk_label_set_text(GTK_LABEL(WID(labelNbGlyphs)),text); } endIt: // Final round gtk_widget_set_sensitive(WID(frameGlyph),1); gtk_widget_set_sensitive(WID(frameLoad),0); gtk_widget_set_sensitive(WID(buttonStart),0); gtk_widget_set_sensitive(WID(frameBitmap),0); // gtk_widget_set_sensitive(WID(Current_Glyph),0); if(nbGlyphs && actionSaveGlyph==gtk_dialog_run(GTK_DIALOG(dialog))) saveGlyph(); if(vobsub) delete vobsub; vobsub=NULL; if(out) fclose(out); out=NULL; gtk_unregister_dialog(dialog); gtk_widget_destroy(dialog); if(head.next) destroyGlyphTree(&head); head.next=NULL; return 1; }
void gtk_codegraph_save(GtkCodeGraph *box){ g_return_if_fail (GTK_IS_CODEGRAPH (box)); //Создается диалог выбора места сохранения тренда GtkWidget *_dialog = gtk_file_chooser_dialog_new("Сохранить", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_NONE, NULL); GtkWidget *widget = GTK_WIDGET(box); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (_dialog), "Untitled"); //Добавляем фильты по типу файлов GtkFileFilter *ffilter = gtk_file_filter_new(); ffilter = gtk_file_filter_new(); gtk_file_filter_set_name( ffilter, "Рисунок PNG"); gtk_file_filter_add_pattern( ffilter, "*.png"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (_dialog), ffilter); ffilter = gtk_file_filter_new(); gtk_file_filter_set_name( ffilter, "Файл данных MathLab"); gtk_file_filter_add_pattern( ffilter, "*.dat"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (_dialog), ffilter); //Отлавливаем конец выбора и работаем gint result = gtk_dialog_run (GTK_DIALOG (_dialog) ); gchar buff[100]; gchar *fil = NULL; gchar *dir = NULL; gchar *filename = NULL; if (result == GTK_RESPONSE_NONE){ filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (_dialog)); fil =(char*) gtk_file_filter_get_name( gtk_file_chooser_get_filter(GTK_FILE_CHOOSER (_dialog)) ); dir = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (_dialog)); if (!strcmp(fil, "Рисунок PNG" ) ) snprintf(buff,sizeof(buff), "%s.png", filename ); else if (!strcmp(fil, "Файл данных MathLab" ) ) snprintf(buff,sizeof(buff), "%s.dat", filename ); else snprintf(buff,sizeof(buff), "%s.png", filename ); } /*Если юзер передумал сохраняться*/ else{ gtk_widget_destroy (_dialog); return; } /*Ошибка при открытии файла */ FILE *fp; if ((fp=fopen(buff, "w")) == NULL ){ gchar buff[300]; gchar *homedir = (gchar*)getenv("HOME"); snprintf(buff, sizeof(buff), "Отказано в доступе.\nСохранить файл в %s не удалось. \nВыберите, другой каталог, \nнапример: %s",filename, homedir ); GtkWidget* dialog = gtk_message_dialog_new (GTK_WINDOW (NULL), (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_MESSAGE_INFO, GTK_BUTTONS_OK, buff ); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); } else{ /*Сохраняем картинку*/ cairo_surface_t *surface; if (!strcmp(fil, "Рисунок PNG" ) ){ fclose(fp); cairo_surface_t * surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, widget->allocation.width , widget->allocation.height ); cairo_t *cr_save = cairo_create (surface); gdk_cairo_set_source_pixmap(cr_save, box->priv->backing_pixmap, 0.0, 0.0); cairo_paint(cr_save); cairo_destroy (cr_save); cairo_surface_write_to_png (surface, buff); cairo_surface_destroy (surface); } /*Сохраняем данные*/ if ( !strcmp(fil, "Файл данных MathLab" ) ){ int i; int im=0; gchar buff[40]; for (i=0; i<box->priv->numPointsText; i+=2 ){ ++im; g_snprintf(buff, sizeof(buff), "%d импульс: %1.3f сек;\n",im ,box->priv->dta[i] ); fwrite(buff, strlen(buff), 1, fp); g_snprintf(buff, sizeof(buff), "%d интервал: %1.3f сек;\n",im ,box->priv->dta[i+1] ); fwrite(buff, strlen(buff), 1, fp); } fclose(fp); } } gtk_widget_destroy (_dialog); }
/****************************************************************************************** Setup (input/output files etc..) *****************************************************************************************/ ReplyType setup(void) { int sel; char text[1024]; while(1) { //gtk_widget_set_sensitive(WID(buttonAccept),0); //gtk_widget_set_sensitive(WID(buttonSkip),0); //gtk_widget_set_sensitive(WID(entryEntry),0); GTK_PURGE; // Main loop : Only accept glyph load/save // Sub & srt select & start ocr gtk_widget_set_sensitive(WID(frameGlyph),1); gtk_widget_set_sensitive(WID(frameLoad),1); gtk_widget_set_sensitive(WID(buttonStart),1); gtk_widget_set_sensitive(WID(frameBitmap),0); //gtk_widget_set_sensitive(WID(Current_Glyph),0); switch(sel=gtk_dialog_run(GTK_DIALOG(dialog))) { case actionLoadVob: { subparam.index=lang_index; subparam.subname=NULL; if(DIA_vobsub(&subparam)) { lang_index=subparam.index; gtk_label_set_text(GTK_LABEL(WID(labelVobsub)),subparam.subname); } } break; case actionSaveSub: { char *srt=NULL; GUI_FileSelWrite(_("Select SRT to save"), &srt); if(srt) { gtk_label_set_text(GTK_LABEL(WID(labelSrt)),srt); } } break; case actionLoadGlyph: { char *gly=NULL; GUI_FileSelRead(_("Select Glyoh to save"), &gly); if(gly) { loadGlyph(gly); sprintf(text,"%03d",nbGlyphs); gtk_label_set_text(GTK_LABEL(WID(labelNbGlyphs)),text); } } break; case actionSaveGlyph: if(!nbGlyphs) { GUI_Error_HIG(_("No glyphs to save"), NULL); break; } saveGlyph(); break; case GTK_RESPONSE_CLOSE: printf("Close req\n"); return ReplyClose; default: printf("Other input:%d\n",sel); } // Everything selected, check if(sel==actionGo) return ReplyOk; } }
static gboolean poly_level_dialog(PolyLevelArgs *args, GwyContainer *data, GwyDataField *dfield, GwyDataField *mfield, gint id) { enum { RESPONSE_RESET = 1 }; static const GwyEnum types[] = { { N_("Independent degrees"), TRUE, }, { N_("Limited total degree"), FALSE, }, }; GtkWidget *dialog, *table, *label, *hbox; GwyPixmapLayer *layer; PolyLevelControls controls; gint response; gint row; controls.args = args; controls.in_update = TRUE; controls.data = create_preview_data(data, dfield, mfield, id); dialog = gtk_dialog_new_with_buttons(_("Remove Polynomial Background"), NULL, 0, _("_Reset"), RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 0); table = gtk_table_new(2, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 12); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(hbox), table, FALSE, FALSE, 0); row = 0; controls.leveled_view = gwy_data_view_new(controls.data); layer = gwy_layer_basic_new(); gwy_pixmap_layer_set_data_key(layer, "/0/data"); gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/0/base/palette"); gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.leveled_view), "/0/data"); gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.leveled_view), layer); gtk_table_attach(GTK_TABLE(table), controls.leveled_view, 0, 1, row, row+1, 0, 0, 0, 0); controls.bg_view = gwy_data_view_new(controls.data); layer = gwy_layer_basic_new(); gwy_pixmap_layer_set_data_key(layer, "/1/data"); gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/1/base/palette"); gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.bg_view), "/1/data"); gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.bg_view), layer); gtk_table_attach(GTK_TABLE(table), controls.bg_view, 1, 2, row, row+1, 0, 0, 0, 0); g_object_unref(controls.data); row++; label = gtk_label_new(_("Leveled data")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); label = gtk_label_new(_("Background")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 1, 2, row, row+1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); row++; table = gtk_table_new(7 + (mfield ? 4 : 0), 4, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 0); row = 0; controls.type_group = gwy_radio_buttons_create(types, G_N_ELEMENTS(types), G_CALLBACK(poly_level_type_changed), &controls, args->independent); gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(controls.type_group->data), 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; controls.col_degree = gtk_adjustment_new(args->col_degree, 0, MAX_DEGREE, 1, 1, 0); gwy_table_attach_hscale(table, row++, _("_Horizontal polynom degree:"), NULL, controls.col_degree, 0); g_signal_connect(controls.col_degree, "value-changed", G_CALLBACK(poly_level_degree_changed), &controls); controls.row_degree = gtk_adjustment_new(args->row_degree, 0, MAX_DEGREE, 1, 1, 0); gwy_table_attach_hscale(table, row++, _("_Vertical polynom degree:"), NULL, controls.row_degree, 0); g_signal_connect(controls.row_degree, "value-changed", G_CALLBACK(poly_level_degree_changed), &controls); controls.same_degree = gtk_check_button_new_with_mnemonic(_("_Same degrees")); gtk_table_attach(GTK_TABLE(table), controls.same_degree, 0, 4, row, row+1, GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.same_degree), args->same_degree); g_signal_connect(controls.same_degree, "toggled", G_CALLBACK(poly_level_same_degree_changed), &controls); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); row++; gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(controls.type_group->next->data), 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; controls.max_degree = gtk_adjustment_new(args->max_degree, 0, MAX_DEGREE, 1, 1, 0); gwy_table_attach_hscale(table, row, _("_Maximum polynom degree:"), NULL, controls.max_degree, 0); g_signal_connect(controls.max_degree, "value-changed", G_CALLBACK(poly_level_max_degree_changed), &controls); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); row++; controls.do_extract = gtk_check_button_new_with_mnemonic(_("E_xtract background")); gtk_table_attach(GTK_TABLE(table), controls.do_extract, 0, 4, row, row+1, GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.do_extract), args->do_extract); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); row++; if (mfield) { label = gwy_label_new_header(_("Masking Mode")); gtk_table_attach(GTK_TABLE(table), label, 0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; controls.masking_group = gwy_radio_buttons_create(gwy_masking_type_get_enum(), -1, G_CALLBACK(poly_level_masking_changed), &controls, args->masking); row = gwy_radio_buttons_attach_to_table(controls.masking_group, GTK_TABLE(table), 3, row); } else controls.masking_group = NULL; controls.in_update = FALSE; gtk_widget_set_sensitive(controls.same_degree, args->independent); gwy_table_hscale_set_sensitive(controls.row_degree, args->independent); gwy_table_hscale_set_sensitive(controls.col_degree, args->independent); gwy_table_hscale_set_sensitive(controls.max_degree, !args->independent); poly_level_update_preview(&controls, args); gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: poly_level_update_values(&controls, args); gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: return FALSE; break; case GTK_RESPONSE_OK: break; case RESPONSE_RESET: *args = poly_level_defaults; poly_level_dialog_update(&controls, args); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); poly_level_update_values(&controls, args); gtk_widget_destroy(dialog); return TRUE; }
static void assistant_prepare (GtkAssistant *ass, GtkWidget *page, EnrollData *data) { const char *name; name = g_object_get_data (G_OBJECT (page), "name"); if (name == NULL) return; if (g_str_equal (name, "enroll")) { DBusGProxy *p; GError *error = NULL; GtkBuilder *dialog = data->dialog; char *path; guint i; GValue value = { 0, }; if (!dbus_g_proxy_call (data->device, "Claim", &error, G_TYPE_STRING, "", G_TYPE_INVALID, G_TYPE_INVALID)) { GtkWidget *d; char *msg; /* translators: * The variable is the name of the device, for example: * "Could you not access "Digital Persona U.are.U 4000/4000B" device */ msg = g_strdup_printf (_("Could not access '%s' device"), data->name); d = get_error_dialog (msg, dbus_g_error_get_name (error), GTK_WINDOW (data->ass)); g_error_free (error); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (d); g_free (msg); enroll_data_destroy (data); return; } data->state = STATE_CLAIMED; p = dbus_g_proxy_new_from_proxy (data->device, "org.freedesktop.DBus.Properties", NULL); if (!dbus_g_proxy_call (p, "Get", NULL, G_TYPE_STRING, "net.reactivated.Fprint.Device", G_TYPE_STRING, "num-enroll-stages", G_TYPE_INVALID, G_TYPE_VALUE, &value, G_TYPE_INVALID) || g_value_get_int (&value) < 1) { GtkWidget *d; char *msg; /* translators: * The variable is the name of the device, for example: * "Could you not access "Digital Persona U.are.U 4000/4000B" device */ msg = g_strdup_printf (_("Could not access '%s' device"), data->name); d = get_error_dialog (msg, "net.reactivated.Fprint.Error.Internal", GTK_WINDOW (data->ass)); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (d); g_free (msg); enroll_data_destroy (data); g_object_unref (p); return; } g_object_unref (p); data->num_enroll_stages = g_value_get_int (&value); /* Hide the extra "bulbs" if not needed */ for (i = MAX_ENROLL_STAGES; i > data->num_enroll_stages; i--) { char *name; name = g_strdup_printf ("image%d", i); gtk_widget_hide (WID (name)); g_free (name); } /* And set the right image */ { char *filename; filename = g_strdup_printf ("%s.png", data->finger); path = g_build_filename (MATECC_PIXMAP_DIR, filename, NULL); g_free (filename); } for (i = 1; i <= data->num_enroll_stages; i++) { char *name; name = g_strdup_printf ("image%d", i); gtk_image_set_from_file (GTK_IMAGE (WID (name)), path); g_free (name); } g_free (path); dbus_g_proxy_add_signal(data->device, "EnrollStatus", G_TYPE_STRING, G_TYPE_BOOLEAN, NULL); dbus_g_proxy_connect_signal(data->device, "EnrollStatus", G_CALLBACK(enroll_result), data, NULL); if (!dbus_g_proxy_call(data->device, "EnrollStart", &error, G_TYPE_STRING, data->finger, G_TYPE_INVALID, G_TYPE_INVALID)) { GtkWidget *d; char *msg; /* translators: * The variable is the name of the device, for example: * "Could you not access "Digital Persona U.are.U 4000/4000B" device */ msg = g_strdup_printf (_("Could not start finger capture on '%s' device"), data->name); d = get_error_dialog (msg, dbus_g_error_get_name (error), GTK_WINDOW (data->ass)); g_error_free (error); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (d); g_free (msg); enroll_data_destroy (data); return; } data->state = STATE_ENROLLING;; } else { if (data->state == STATE_ENROLLING) { dbus_g_proxy_call(data->device, "EnrollStop", NULL, G_TYPE_INVALID, G_TYPE_INVALID); data->state = STATE_CLAIMED; } if (data->state == STATE_CLAIMED) { dbus_g_proxy_call(data->device, "Release", NULL, G_TYPE_INVALID, G_TYPE_INVALID); data->state = STATE_NONE; } } }
void cheese_cmd_file_move_all_to_trash (GtkWidget *widget, CheeseWindow *cheese_window) { GtkWidget *dlg; char *prompt; int response; char *filename; GFile *file; GList *files_list = NULL; GDir *dir_videos, *dir_photos; char *path_videos, *path_photos; const char *name; prompt = g_strdup_printf (_("Really move all photos and videos to the trash?")); dlg = gtk_message_dialog_new_with_markup (GTK_WINDOW (cheese_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, "<span weight=\"bold\" size=\"larger\">%s</span>", prompt); g_free (prompt); gtk_dialog_add_button (GTK_DIALOG (dlg), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (dlg), _("_Move to Trash"), GTK_RESPONSE_OK); gtk_dialog_set_default_response (GTK_DIALOG (dlg), GTK_RESPONSE_OK); gtk_window_set_title (GTK_WINDOW (dlg), ""); gtk_widget_show_all (dlg); response = gtk_dialog_run (GTK_DIALOG (dlg)); gtk_widget_destroy (dlg); if (response != GTK_RESPONSE_OK) return; /* append all videos */ path_videos = cheese_fileutil_get_video_path (cheese_window_get_fileutil (cheese_window)); dir_videos = g_dir_open (path_videos, 0, NULL); while ((name = g_dir_read_name (dir_videos)) != NULL) { if (g_str_has_suffix (name, VIDEO_NAME_SUFFIX)) { filename = g_strjoin (G_DIR_SEPARATOR_S, path_videos, name, NULL); file = g_file_new_for_path (filename); files_list = g_list_append (files_list, file); g_free (filename); } } g_dir_close (dir_videos); /* append all photos */ path_photos = cheese_fileutil_get_photo_path (cheese_window_get_fileutil (cheese_window)); dir_photos = g_dir_open (path_photos, 0, NULL); while ((name = g_dir_read_name (dir_photos)) != NULL) { if (g_str_has_suffix (name, PHOTO_NAME_SUFFIX)) { filename = g_strjoin (G_DIR_SEPARATOR_S, path_photos, name, NULL); file = g_file_new_for_path (filename); files_list = g_list_append (files_list, file); g_free (filename); } } /* delete all items */ _really_move_to_trash (cheese_window, files_list); g_list_free (files_list); g_dir_close (dir_photos); }
static void enroll_fingerprints (GtkWindow *parent, GtkWidget *enable, GtkWidget *disable) { DBusGProxy *device, *p; GHashTable *props; GtkBuilder *dialog; EnrollData *data; GtkWidget *ass; char *msg; device = NULL; if (manager == NULL) { create_manager (); if (manager != NULL) device = get_first_device (); } else { device = get_first_device (); } if (manager == NULL || device == NULL) { GtkWidget *d; d = get_error_dialog (_("Could not access any fingerprint readers"), _("Please contact your system administrator for help."), parent); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (d); return; } data = g_new0 (EnrollData, 1); data->device = device; data->enable = enable; data->disable = disable; /* Get some details about the device */ p = dbus_g_proxy_new_from_proxy (device, "org.freedesktop.DBus.Properties", NULL); if (dbus_g_proxy_call (p, "GetAll", NULL, G_TYPE_STRING, "net.reactivated.Fprint.Device", G_TYPE_INVALID, dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &props, G_TYPE_INVALID)) { const char *scan_type; data->name = g_value_dup_string (g_hash_table_lookup (props, "name")); scan_type = g_value_dup_string (g_hash_table_lookup (props, "scan-type")); if (g_str_equal (scan_type, "swipe")) data->is_swipe = TRUE; g_hash_table_destroy (props); } g_object_unref (p); dialog = gtk_builder_new (); gtk_builder_add_from_file (dialog, MATECC_UI_DIR "/mate-about-me-fingerprint.ui", NULL); data->dialog = dialog; ass = WID ("assistant"); gtk_window_set_title (GTK_WINDOW (ass), _("Enable Fingerprint Login")); gtk_window_set_transient_for (GTK_WINDOW (ass), parent); gtk_window_set_position (GTK_WINDOW (ass), GTK_WIN_POS_CENTER_ON_PARENT); g_signal_connect (G_OBJECT (ass), "cancel", G_CALLBACK (assistant_cancelled), data); g_signal_connect (G_OBJECT (ass), "close", G_CALLBACK (assistant_cancelled), data); g_signal_connect (G_OBJECT (ass), "prepare", G_CALLBACK (assistant_prepare), data); /* Page 1 */ gtk_combo_box_set_active (GTK_COMBO_BOX (WID ("finger_combobox")), 0); g_signal_connect (G_OBJECT (WID ("radiobutton1")), "toggled", G_CALLBACK (finger_radio_button_toggled), data); g_signal_connect (G_OBJECT (WID ("radiobutton2")), "toggled", G_CALLBACK (finger_radio_button_toggled), data); g_signal_connect (G_OBJECT (WID ("radiobutton3")), "toggled", G_CALLBACK (finger_radio_button_toggled), data); g_signal_connect (G_OBJECT (WID ("finger_combobox")), "changed", G_CALLBACK (finger_combobox_changed), data); data->finger = selected_finger (dialog); g_object_set_data (G_OBJECT (WID("page1")), "name", "intro"); /* translators: * The variable is the name of the device, for example: * "To enable fingerprint login, you need to save one of your fingerprints, using the * 'Digital Persona U.are.U 4000/4000B' device." */ msg = g_strdup_printf (_("To enable fingerprint login, you need to save one of your fingerprints, using the '%s' device."), data->name); gtk_label_set_text (GTK_LABEL (WID("intro-label")), msg); g_free (msg); gtk_assistant_set_page_complete (GTK_ASSISTANT (ass), WID("page1"), TRUE); /* Page 2 */ if (data->is_swipe != FALSE) gtk_assistant_set_page_title (GTK_ASSISTANT (ass), WID("page2"), _("Swipe finger on reader")); else gtk_assistant_set_page_title (GTK_ASSISTANT (ass), WID("page2"), _("Place finger on reader")); g_object_set_data (G_OBJECT (WID("page2")), "name", "enroll"); msg = g_strdup_printf (TR(finger_str_to_msg (data->finger, data->is_swipe)), data->name); gtk_label_set_text (GTK_LABEL (WID("enroll-label")), msg); g_free (msg); /* Page 3 */ g_object_set_data (G_OBJECT (WID("page3")), "name", "summary"); data->ass = ass; gtk_widget_show_all (ass); }
/* returns TRUE if OK was pressed. */ static gboolean georef_layer_dialog ( VikGeorefLayer **vgl, gpointer vp, GtkWindow *w ) { GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Layer Properties"), w, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL ); /* Default to reject as user really needs to specify map file first */ gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT ); GtkWidget *response_w = NULL; #if GTK_CHECK_VERSION (2, 20, 0) response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT ); #endif GtkWidget *table, *wfp_hbox, *wfp_label, *wfp_button, *ce_label, *ce_spin, *cn_label, *cn_spin, *xlabel, *xspin, *ylabel, *yspin, *imagelabel, *imageentry; GtkWidget *pass_along[4]; table = gtk_table_new ( 6, 2, FALSE ); gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 0 ); wfp_hbox = gtk_hbox_new ( FALSE, 0 ); wfp_label = gtk_label_new ( _("World File Parameters:") ); wfp_button = gtk_button_new_with_label ( _("Load From File...") ); gtk_box_pack_start ( GTK_BOX(wfp_hbox), wfp_label, TRUE, TRUE, 0 ); gtk_box_pack_start ( GTK_BOX(wfp_hbox), wfp_button, FALSE, FALSE, 3 ); ce_label = gtk_label_new ( _("Corner pixel easting:") ); ce_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, 0.0, 1500000.0, 1, 5, 0 ), 1, 4 ); gtk_widget_set_tooltip_text ( GTK_WIDGET(ce_spin), _("the UTM \"easting\" value of the upper-left corner pixel of the map") ); cn_label = gtk_label_new ( _("Corner pixel northing:") ); cn_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, 0.0, 9000000.0, 1, 5, 0 ), 1, 4 ); gtk_widget_set_tooltip_text ( GTK_WIDGET(cn_spin), _("the UTM \"northing\" value of the upper-left corner pixel of the map") ); xlabel = gtk_label_new ( _("X (easting) scale (mpp): ")); ylabel = gtk_label_new ( _("Y (northing) scale (mpp): ")); xspin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, VIK_VIEWPORT_MIN_ZOOM, VIK_VIEWPORT_MAX_ZOOM, 1, 5, 0 ), 1, 8 ); gtk_widget_set_tooltip_text ( GTK_WIDGET(xspin), _("the scale of the map in the X direction (meters per pixel)") ); yspin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, VIK_VIEWPORT_MIN_ZOOM, VIK_VIEWPORT_MAX_ZOOM, 1, 5, 0 ), 1, 8 ); gtk_widget_set_tooltip_text ( GTK_WIDGET(yspin), _("the scale of the map in the Y direction (meters per pixel)") ); imagelabel = gtk_label_new ( _("Map Image:") ); imageentry = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN); if (*vgl) { gtk_spin_button_set_value ( GTK_SPIN_BUTTON(ce_spin), (*vgl)->corner.easting ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cn_spin), (*vgl)->corner.northing ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(xspin), (*vgl)->mpp_easting ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(yspin), (*vgl)->mpp_northing ); if ( (*vgl)->image ) vik_file_entry_set_filename ( VIK_FILE_ENTRY(imageentry), (*vgl)->image ); } else { VikCoord corner_coord; struct UTM utm; vik_viewport_screen_to_coord ( VIK_VIEWPORT(vp), 0, 0, &corner_coord ); vik_coord_to_utm ( &corner_coord, &utm ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(ce_spin), utm.easting ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cn_spin), utm.northing ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(xspin), vik_viewport_get_xmpp ( VIK_VIEWPORT(vp) ) ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(yspin), vik_viewport_get_ympp ( VIK_VIEWPORT(vp) ) ); } gtk_table_attach_defaults ( GTK_TABLE(table), imagelabel, 0, 1, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table), imageentry, 1, 2, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table), wfp_hbox, 0, 2, 1, 2 ); gtk_table_attach_defaults ( GTK_TABLE(table), xlabel, 0, 1, 2, 3 ); gtk_table_attach_defaults ( GTK_TABLE(table), xspin, 1, 2, 2, 3 ); gtk_table_attach_defaults ( GTK_TABLE(table), ylabel, 0, 1, 3, 4 ); gtk_table_attach_defaults ( GTK_TABLE(table), yspin, 1, 2, 3, 4 ); gtk_table_attach_defaults ( GTK_TABLE(table), ce_label, 0, 1, 4, 5 ); gtk_table_attach_defaults ( GTK_TABLE(table), ce_spin, 1, 2, 4, 5 ); gtk_table_attach_defaults ( GTK_TABLE(table), cn_label, 0, 1, 5, 6 ); gtk_table_attach_defaults ( GTK_TABLE(table), cn_spin, 1, 2, 5, 6 ); pass_along[0] = xspin; pass_along[1] = yspin; pass_along[2] = ce_spin; pass_along[3] = cn_spin; g_signal_connect_swapped ( G_OBJECT(wfp_button), "clicked", G_CALLBACK(georef_layer_dialog_load), pass_along ); if ( response_w ) gtk_widget_grab_focus ( response_w ); gtk_widget_show_all ( table ); if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT ) { if (! *vgl) { *vgl = georef_layer_new ( VIK_VIEWPORT(vp) ); vik_layer_rename ( VIK_LAYER(*vgl), vik_georef_layer_interface.name ); } (*vgl)->corner.easting = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(ce_spin) ); (*vgl)->corner.northing = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cn_spin) ); (*vgl)->mpp_easting = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(xspin) ); (*vgl)->mpp_northing = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(yspin) ); if ( (!(*vgl)->image) || strcmp( (*vgl)->image, vik_file_entry_get_filename(VIK_FILE_ENTRY(imageentry)) ) != 0 ) { georef_layer_set_image ( *vgl, vik_file_entry_get_filename(VIK_FILE_ENTRY(imageentry)) ); georef_layer_load_image ( *vgl, VIK_VIEWPORT(vp), FALSE ); } gtk_widget_destroy ( GTK_WIDGET(dialog) ); return TRUE; } gtk_widget_destroy ( GTK_WIDGET(dialog) ); return FALSE; }
ReplyType glyphToText(admGlyph *glyph,admGlyph *head,char *decodedString) { admGlyph *cand; //printf("2t: %d x %d\n",glyph->width,glyph->height); if(glyph->width<2 && glyph->height<2) { delete glyph; return ReplyOk; } cand=searchGlyph(head,glyph); if(!cand) // New glyph { char *string; // Draw it displaySmall(glyph); gtk_label_set_text(GTK_LABEL(WID(labelText)),decodedString); gtk_editable_delete_text(GTK_EDITABLE(WID(entry)), 0,-1); //gtk_widget_set_sensitive(WID(buttonAccept),1); //gtk_widget_set_sensitive(WID(buttonSkip),1); //gtk_widget_set_sensitive(WID(entryEntry),1); gtk_widget_grab_focus (WID(entry)); gtk_widget_grab_default (WID(buttonOk)); //printf("i\n"); switch(gtk_dialog_run(GTK_DIALOG(dialog))) { case actionIgnore: glyph->code=NULL; insertInGlyphTree(head,glyph); //*nbGl++; break; case actionCalibrate: return ReplyCalibrate; case actionAccept: string =gtk_editable_get_chars(GTK_EDITABLE (WID(entry)), 0, -1); if(string&& strlen(string)) { glyph->code=ADM_strdup(string); insertInGlyphTree(head,glyph); //printf("New glyph:%s\n",glyph->code); strcat(decodedString,glyph->code); //*nbGl++; } else delete glyph; break; case actionSkip: //SKIP return ReplySkip; break; case actionSkipAll: return ReplySkipAll; break; case GTK_RESPONSE_CLOSE: if(GUI_Question(QT_TR_NOOP("Sure ?"))) return ReplyClose; break; // Abort } gtk_editable_delete_text(GTK_EDITABLE(WID(entry)), 0,-1); //gtk_widget_set_sensitive(WID(buttonAccept),0); //gtk_widget_set_sensitive(WID(buttonSkip),0); //gtk_widget_set_sensitive(WID(entryEntry),0); } else { //printf("Glyph known :%s \n",cand->code); if(cand->code) strcat(decodedString,cand->code); delete glyph; } return ReplyOk; }
static void configure() { GtkBuilder *builder; GtkWidget *widget, *MainWindow; builder = gtk_builder_new(); if(!gtk_builder_add_from_file(builder, DATADIR "sio1.ui", NULL)) g_warning("We could not load the interface!"); settingsRead(); MainWindow = gtk_builder_get_object(builder, "dlgStart"); gtk_window_set_title(GTK_WINDOW(MainWindow), _("Link Cable Configuration")); widget = gtk_builder_get_object(builder, "btnCopyIP"); g_signal_connect_data(G_OBJECT(widget), "clicked", G_CALLBACK(OnCopyIP), NULL, NULL, G_CONNECT_AFTER); switch(settings.player) { case PLAYER_DISABLED: widget = gtk_builder_get_object(builder, "rbDisabled"); break; case PLAYER_MASTER: widget = gtk_builder_get_object(builder, "rbServer"); break; case PLAYER_SLAVE: widget = gtk_builder_get_object(builder, "rbClient"); break; } gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE); widget = gtk_builder_get_object(builder, "tbServerIP"); gtk_entry_set_text(GTK_ENTRY(widget), settings.ip); widget = gtk_builder_get_object(builder, "tbPort"); gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), settings.port); if(gtk_dialog_run(GTK_DIALOG(MainWindow)) == GTK_RESPONSE_OK) { widget = gtk_builder_get_object(builder, "tbServerIP"); strncpy(settings.ip, gtk_entry_get_text(GTK_ENTRY(widget)), sizeof(settings.ip) - 1); widget = gtk_builder_get_object(builder, "tbPort"); settings.port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget)); widget = gtk_builder_get_object(builder, "rbDisabled"); if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) settings.player = PLAYER_DISABLED; else { widget = gtk_builder_get_object(builder, "rbServer"); if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) settings.player = PLAYER_MASTER; else settings.player = PLAYER_SLAVE; } settingsWrite(); gtk_widget_destroy(MainWindow); } gtk_widget_destroy(MainWindow); }
void CChartDlg::Execute(const CSelection &sel, int aperIndex) { int res = 0; const gchar *tmp_file; GtkTreePath *refpath; GError *error = NULL; m_Selection = sel; m_Tags = *g_Project->Tags(); cmpack_chart_view_set_model(CMPACK_CHART_VIEW(m_Chart), NULL); cmpack_chart_view_set_image(CMPACK_CHART_VIEW(m_Chart), NULL); if (m_ChartData) { g_object_unref(m_ChartData); m_ChartData = NULL; } if (m_ImageData) { g_object_unref(m_ImageData); m_ImageData = NULL; } m_Phot.Clear(); m_Catalog.Clear(); m_Image.Clear(); m_RefType = g_Project->GetReferenceType(); switch (m_RefType) { case REF_FRAME: // Load reference frame refpath = g_Project->GetReferencePath(); if (refpath) { gchar *pht_file = g_Project->GetPhotFile(refpath); if (pht_file) { GError *error = NULL; if (m_Phot.Load(pht_file, &error)) { m_Phot.SelectAperture(aperIndex); UpdateChart(); gchar *fts_file = g_Project->GetImageFile(refpath); if (fts_file) { if (m_Image.Load(fts_file, CMPACK_BITPIX_AUTO, &error)) UpdateImage(); g_free(fts_file); } } if (error) { ShowError(m_pParent, error->message); g_error_free(error); res = -1; } g_free(pht_file); } gtk_tree_path_free(refpath); } break; case REF_CATALOG_FILE: // Load catalog file tmp_file = g_Project->GetTempCatFile()->FullPath(); if (m_Catalog.Load(tmp_file, &error)) { UpdateChart(); gchar *fts_file = SetFileExtension(tmp_file, FILE_EXTENSION_FITS); if (fts_file) { if (m_Image.Load(fts_file, CMPACK_BITPIX_AUTO, &error)) UpdateImage(); g_free(fts_file); } } if (error) { ShowError(m_pParent, error->message); g_error_free(error); res = -1; } break; default: ShowError(m_pParent, "No reference file."); res = -1; } if (res==0) { gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(m_ShowImage), m_DisplayMode==DISPLAY_IMAGE); gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(m_ShowChart), m_DisplayMode==DISPLAY_CHART); gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(m_ShowMixed), m_DisplayMode==DISPLAY_FULL); gtk_widget_set_sensitive(GTK_WIDGET(m_ShowImage), m_Image.Width()>0 && m_Image.Height()>0); gtk_widget_set_sensitive(GTK_WIDGET(m_ShowMixed), m_Image.Width()>0 && m_Image.Height()>0); gtk_dialog_run(GTK_DIALOG(m_pDlg)); } }
static void _lib_geolocation_gpx_callback(GtkWidget *widget, dt_lib_module_t *self) { dt_lib_geolocation_t *d = (dt_lib_geolocation_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, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, (char *)NULL); GtkFileFilter *filter; filter = GTK_FILE_FILTER(gtk_file_filter_new()); gtk_file_filter_add_pattern(filter, "*.gpx"); 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_hbox_new(FALSE, 5); GtkWidget *label = gtk_label_new("camera time zone"); g_object_set(G_OBJECT(label), "tooltip-text", _("most cameras don't store the time zone in exif. give the correct time zone so the gpx data can be correctly matched"), (char *)NULL); 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/geolocation/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); } 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 *tz = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(tz_selection)); dt_conf_set_string("plugins/lighttable/geolocation/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(); }
/* Main code */ int main(int argc, char* argv[]) { gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Suse Control Center"); gtk_window_set_default_size (GTK_WINDOW (window), 650, 400); g_signal_connect(G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); bool is_root = getuid () == 0; View view; { // adding groups GKeyFile *file = g_key_file_new(); std::set <std::string> groups = subfiles (YAST_GROUPS); for (std::set <std::string>::iterator it = groups.begin(); it != groups.end(); it++) { if (!g_key_file_load_from_file (file, (YAST_GROUPS + (*it)).c_str(), G_KEY_FILE_NONE, NULL)) continue; gchar* name = g_key_file_get_locale_string (file, "Desktop Entry", "Name", 0, NULL); gchar *nick = g_key_file_get_string (file, "Desktop Entry", "X-SuSE-YaST-Group", NULL); gchar *icon = g_key_file_get_string (file, "Desktop Entry", "Icon", NULL); gchar *sort_key = g_key_file_get_string (file, "Desktop Entry", "X-SuSE-YaST-SortKey", NULL); if (name && nick) view.addGroup (name, icon, nick, sort_key); if (name) g_free (name); if (nick) g_free (nick); if (icon) g_free (icon); if (sort_key) g_free (sort_key); } g_key_file_free (file); } { // adding entries GKeyFile *file = g_key_file_new(); std::set <std::string> entries = subfiles (YAST_ENTRIES); for (std::set <std::string>::iterator it = entries.begin(); it != entries.end(); it++) { if (!g_key_file_load_from_file (file, (YAST_ENTRIES + (*it)).c_str(), G_KEY_FILE_NONE, NULL)) continue; gchar *group = g_key_file_get_string (file, "Desktop Entry", "X-SuSE-YaST-Group", NULL); gchar* name = g_key_file_get_locale_string (file, "Desktop Entry", "Name", 0, NULL); gchar *icon = g_key_file_get_string (file, "Desktop Entry", "Icon", NULL); gchar *command = g_key_file_get_string (file, "Desktop Entry", "Exec", NULL); gboolean needs_root = g_key_file_get_boolean (file, "Desktop Entry", "X-SuSE-YaST-RootOnly", NULL); if (group && name && command && (!needs_root || is_root)) view.addEntry (group, name, icon, command); if (group) g_free (group); if (name) g_free (name); if (icon) g_free (icon); if (command) g_free (command); } g_key_file_free (file); } gtk_container_add (GTK_CONTAINER (window), view.getWidget()); gtk_widget_show_all (window); if (!is_root) { GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW (window), GtkDialogFlags (0), GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "You are executing the control center as an ordinary user.\n" "Only a few modules will be available."); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); } gtk_main(); return 0; }
static void delete_button_clicked (GtkWidget *button, GtrPreferencesDialog *dlg) { GtkTreeIter iter; GtkTreeModel *model; GtkTreeSelection *selection; gboolean active; GtkWidget *dialog; gchar *markup; model = gtk_tree_view_get_model (GTK_TREE_VIEW (dlg->priv->profile_treeview)); g_return_if_fail (model != NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dlg->priv->profile_treeview)); if (gtk_tree_selection_get_selected (selection, &model, &iter)) { gtk_tree_model_get (model, &iter, ACTIVE_PROFILE_COLUMN, &active, -1); if (active) { dialog = gtk_message_dialog_new (GTK_WINDOW (dlg), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, NULL); markup = g_strdup_printf("<span weight=\"bold\" size=\"large\">%s</span>", _("Impossible to remove the active profile")); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), markup); g_free(markup); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("Another profile should be selected as active before")); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); } else { dialog = gtk_message_dialog_new (GTK_WINDOW (dlg), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, NULL); markup = g_strdup_printf("<span weight=\"bold\" size=\"large\">%s</span>", _("Are you sure you want to delete this profile?")); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), markup); g_free(markup); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_DELETE, GTK_RESPONSE_YES); gtk_dialog_run (GTK_DIALOG (dialog)); g_signal_connect (GTK_DIALOG (dialog), "response", G_CALLBACK (delete_confirm_dialog_cb), dlg); } } }
gpointer x264_gtk_encode_encode (X264_Thread_Data *thread_data) { GIOStatus status; gsize size; X264_Pipe_Data pipe_data; x264_param_t *param; x264_picture_t pic; x264_t *h; hnd_t hin; hnd_t hout; int i_frame; int i_frame_total; int64_t i_start; int64_t i_end; int64_t i_file; int i_frame_size; int i_progress; int err; g_print (_("encoding...\n")); param = thread_data->param; err = _set_drivers (thread_data->in_container, thread_data->out_container); if (err < 0) { GtkWidget *no_driver; no_driver = gtk_message_dialog_new (GTK_WINDOW(thread_data->dialog), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, (err == -2) ? _("Error: unknown output file type") : _("Error: unknown input file type")); gtk_dialog_run (GTK_DIALOG (no_driver)); gtk_widget_destroy (no_driver); return NULL; } if (p_open_infile (thread_data->file_input, &hin, param)) { fprintf( stderr, _("could not open input file '%s'\n"), thread_data->file_input ); return NULL; } p_open_outfile ((char *)thread_data->file_output, &hout); i_frame_total = p_get_frame_total (hin ); if (((i_frame_total == 0) || (param->i_frame_total < i_frame_total)) && (param->i_frame_total > 0)) i_frame_total = param->i_frame_total; param->i_frame_total = i_frame_total; if ((h = x264_encoder_open (param)) == NULL) { fprintf (stderr, _("x264_encoder_open failed\n")); p_close_infile (hin); p_close_outfile (hout); g_free (param); return NULL; } if (p_set_outfile_param (hout, param)) { fprintf (stderr, _("can't set outfile param\n")); p_close_infile (hin); p_close_outfile (hout); g_free (param); return NULL; } /* Create a new pic */ x264_picture_alloc (&pic, X264_CSP_I420, param->i_width, param->i_height ); i_start = x264_mdate(); /* Encode frames */ for (i_frame = 0, i_file = 0, i_progress = 0; ((i_frame < i_frame_total) || (i_frame_total == 0)); ) { if (p_read_frame (&pic, hin, i_frame)) break; pic.i_pts = (int64_t)i_frame * param->i_fps_den; i_file += _encode_frame (h, hout, &pic); i_frame++; /* update status line (up to 1000 times per input file) */ if (param->i_log_level < X264_LOG_DEBUG && (i_frame_total ? i_frame * 1000 / i_frame_total > i_progress : i_frame % 10 == 0)) { int64_t i_elapsed = x264_mdate () - i_start; if (i_frame_total) { pipe_data.frame = i_frame; pipe_data.frame_total = i_frame_total; pipe_data.file = i_file; pipe_data.elapsed = i_elapsed; status = g_io_channel_write_chars (thread_data->io_write, (const gchar *)&pipe_data, sizeof (X264_Pipe_Data), &size, NULL); if (status != G_IO_STATUS_NORMAL) { g_print (_("Error ! %d %d %d\n"), status, sizeof (X264_Pipe_Data), size); } else { /* we force the GIOChannel to write to the pipeline */ status = g_io_channel_flush (thread_data->io_write, NULL); if (status != G_IO_STATUS_NORMAL) { g_print (_("Error ! %d\n"), status); } } } } } /* Flush delayed B-frames */ do { i_file += i_frame_size = _encode_frame (h, hout, NULL); } while (i_frame_size); i_end = x264_mdate (); x264_picture_clean (&pic); x264_encoder_close (h); fprintf (stderr, "\n"); p_close_infile (hin); p_close_outfile (hout); if (i_frame > 0) { double fps = (double)i_frame * (double)1000000 / (double)(i_end - i_start); fprintf (stderr, _("encoded %d frames, %.2f fps, %.2f kb/s\n"), i_frame, fps, (double) i_file * 8 * param->i_fps_num / ((double) param->i_fps_den * i_frame * 1000)); } gtk_widget_set_sensitive (thread_data->end_button, TRUE); gtk_widget_hide (thread_data->button); return NULL; }