/* Retrieve the selected key ID. */ const gchar* gpa_receive_key_dialog_get_id (GpaReceiveKeyDialog *dialog) { return gtk_entry_get_text (GTK_ENTRY (dialog->entry)); }
static int passphrase_dialog(char *message) { const char *failed; char *passphrase, *local; char **messages; int result, i, grab_server, grab_pointer; GtkWidget *dialog, *entry, *label; GdkGrabStatus status; grab_server = (getenv("GNOME_SSH_ASKPASS_GRAB_SERVER") != NULL); grab_pointer = (getenv("GNOME_SSH_ASKPASS_GRAB_POINTER") != NULL); dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL, "%s", message); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), entry, FALSE, FALSE, 0); gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE); gtk_widget_grab_focus(entry); gtk_widget_show(entry); gtk_window_set_title(GTK_WINDOW(dialog), "OpenSSH"); gtk_window_set_position (GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); gtk_label_set_line_wrap(GTK_LABEL((GTK_MESSAGE_DIALOG(dialog))->label), TRUE); /* Make <enter> close dialog */ gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); g_signal_connect(G_OBJECT(entry), "activate", G_CALLBACK(ok_dialog), dialog); /* Grab focus */ gtk_widget_show_now(dialog); if (grab_server) { gdk_x11_grab_server(); } if (grab_pointer) { status = gdk_pointer_grab((GTK_WIDGET(dialog))->window, TRUE, 0, NULL, NULL, GDK_CURRENT_TIME); if (status != GDK_GRAB_SUCCESS) { failed = "mouse"; goto nograb; } } status = gdk_keyboard_grab((GTK_WIDGET(dialog))->window, FALSE, GDK_CURRENT_TIME); if (status != GDK_GRAB_SUCCESS) { failed = "keyboard"; goto nograbkb; } result = gtk_dialog_run(GTK_DIALOG(dialog)); /* Ungrab */ if (grab_server) XUngrabServer(GDK_DISPLAY()); if (grab_pointer) gdk_pointer_ungrab(GDK_CURRENT_TIME); gdk_keyboard_ungrab(GDK_CURRENT_TIME); gdk_flush(); /* Report passphrase if user selected OK */ passphrase = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry))); if (result == GTK_RESPONSE_OK) { local = g_locale_from_utf8(passphrase, strlen(passphrase), NULL, NULL, NULL); if (local != NULL) { puts(local); memset(local, '\0', strlen(local)); g_free(local); } else { puts(passphrase); } } /* Zero passphrase in memory */ memset(passphrase, '\b', strlen(passphrase)); gtk_entry_set_text(GTK_ENTRY(entry), passphrase); memset(passphrase, '\0', strlen(passphrase)); g_free(passphrase); gtk_widget_destroy(dialog); return (result == GTK_RESPONSE_OK ? 0 : -1); /* At least one grab failed - ungrab what we got, and report the failure to the user. Note that XGrabServer() cannot fail. */ nograbkb: gdk_pointer_ungrab(GDK_CURRENT_TIME); nograb: if (grab_server) XUngrabServer(GDK_DISPLAY()); gtk_widget_destroy(dialog); report_failed_grab(failed); return (-1); }
range_update_dynamics(data); } static void range_entry(GtkWidget *widget _U_, gpointer data) { const gchar *entry_text; GtkWidget *entry; packet_range_t *range; range = (packet_range_t *)g_object_get_data(G_OBJECT(data), RANGE_VALUES_KEY); entry = (GtkWidget *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_ENTRY_KEY); gtk_toggle_button_set_active((GtkToggleButton *)g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_KEY), TRUE); entry_text = gtk_entry_get_text (GTK_ENTRY (entry)); packet_range_convert_str(range, entry_text); range_update_dynamics(data); } static void range_entry_in_event(GtkWidget *widget _U_, GdkEventFocus *event _U_, gpointer user_data _U_) { /* This event is called, if the "enter" key is pressed while the key focus (right name?) */ /* is in the range entry field. */ /* Calling range_entry() isn't necessary as all changes are already done while the */ /* entry was edited. Calling it here will cause a NULL pointer exception, */ /* so don't do: <range_entry(widget, user_data); as we did before. */
static gboolean ui_to_setting (CEPageIP6 *page) { const gchar *method; gboolean ignore_auto_dns; gboolean ignore_auto_routes; gboolean never_default; GList *children, *l; gboolean ret = TRUE; if (!gtk_switch_get_active (page->enabled)) { method = NM_SETTING_IP6_CONFIG_METHOD_IGNORE; } else { switch (gtk_combo_box_get_active (page->method)) { case IP6_METHOD_MANUAL: method = NM_SETTING_IP6_CONFIG_METHOD_MANUAL; break; case IP6_METHOD_LINK_LOCAL: method = NM_SETTING_IP6_CONFIG_METHOD_LINK_LOCAL; break; case IP6_METHOD_DHCP: method = NM_SETTING_IP6_CONFIG_METHOD_DHCP; break; default: case IP6_METHOD_AUTO: method = NM_SETTING_IP6_CONFIG_METHOD_AUTO; break; } } nm_setting_ip6_config_clear_addresses (page->setting); if (g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_MANUAL)) children = gtk_container_get_children (GTK_CONTAINER (page->address_list)); else children = NULL; for (l = children; l; l = l->next) { GtkWidget *row = l->data; GtkEntry *entry; const gchar *text_address; const gchar *text_prefix; const gchar *text_gateway; struct in6_addr tmp_addr; struct in6_addr tmp_gateway; guint32 prefix; gchar *end; NMIP6Address *addr; gboolean have_gateway = FALSE; entry = GTK_ENTRY (g_object_get_data (G_OBJECT (row), "address")); if (!entry) continue; text_address = gtk_entry_get_text (entry); text_prefix = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "prefix"))); text_gateway = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "gateway"))); if (!*text_address && !*text_prefix && !*text_gateway) { /* ignore empty rows */ widget_unset_error (GTK_WIDGET (entry)); widget_unset_error (g_object_get_data (G_OBJECT (row), "prefix")); widget_unset_error (g_object_get_data (G_OBJECT (row), "gateway")); continue; } if (inet_pton (AF_INET6, text_address, &tmp_addr) <= 0) { widget_set_error (GTK_WIDGET (entry)); ret = FALSE; } else { widget_unset_error (GTK_WIDGET (entry)); } prefix = strtoul (text_prefix, &end, 10); if (!end || *end || prefix == 0 || prefix > 128) { widget_set_error (g_object_get_data (G_OBJECT (row), "prefix")); ret = FALSE; } else { widget_unset_error (g_object_get_data (G_OBJECT (row), "prefix")); } if (text_gateway && *text_gateway) { if (inet_pton (AF_INET6, text_gateway, &tmp_gateway) <= 0) { widget_set_error (g_object_get_data (G_OBJECT (row), "gateway")); ret = FALSE; } else { if (!IN6_IS_ADDR_UNSPECIFIED (&tmp_gateway)) have_gateway = TRUE; widget_unset_error (g_object_get_data (G_OBJECT (row), "gateway")); } } else { widget_unset_error (g_object_get_data (G_OBJECT (row), "gateway")); } if (!ret) continue; addr = nm_ip6_address_new (); nm_ip6_address_set_address (addr, &tmp_addr); nm_ip6_address_set_prefix (addr, prefix); if (have_gateway) nm_ip6_address_set_gateway (addr, &tmp_gateway); nm_setting_ip6_config_add_address (page->setting, addr); } g_list_free (children); nm_setting_ip6_config_clear_dns (page->setting); if (g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_AUTO) || g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_DHCP) || g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_MANUAL)) children = gtk_container_get_children (GTK_CONTAINER (page->dns_list)); else children = NULL; for (l = children; l; l = l->next) { GtkWidget *row = l->data; GtkEntry *entry; const gchar *text; struct in6_addr tmp_addr; entry = GTK_ENTRY (g_object_get_data (G_OBJECT (row), "address")); if (!entry) continue; text = gtk_entry_get_text (entry); if (!*text) { /* ignore empty rows */ widget_unset_error (GTK_WIDGET (entry)); continue; } if (inet_pton (AF_INET6, text, &tmp_addr) <= 0) { widget_set_error (GTK_WIDGET (entry)); ret = FALSE; } else { widget_unset_error (GTK_WIDGET (entry)); nm_setting_ip6_config_add_dns (page->setting, &tmp_addr); } } g_list_free (children); nm_setting_ip6_config_clear_routes (page->setting); if (g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_AUTO) || g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_DHCP) || g_str_equal (method, NM_SETTING_IP6_CONFIG_METHOD_MANUAL)) children = gtk_container_get_children (GTK_CONTAINER (page->routes_list)); else children = NULL; for (l = children; l; l = l->next) { GtkWidget *row = l->data; GtkEntry *entry; const gchar *text_address; const gchar *text_prefix; const gchar *text_gateway; const gchar *text_metric; struct in6_addr dest, gateway; guint32 prefix, metric; gchar *end; NMIP6Route *route; entry = GTK_ENTRY (g_object_get_data (G_OBJECT (row), "address")); if (!entry) continue; text_address = gtk_entry_get_text (entry); text_prefix = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "prefix"))); text_gateway = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "gateway"))); text_metric = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "metric"))); if (!*text_address && !*text_prefix && !*text_gateway && !*text_metric) { /* ignore empty rows */ widget_unset_error (GTK_WIDGET (entry)); widget_unset_error (g_object_get_data (G_OBJECT (row), "prefix")); widget_unset_error (g_object_get_data (G_OBJECT (row), "gateway")); widget_unset_error (g_object_get_data (G_OBJECT (row), "metric")); continue; } if (inet_pton (AF_INET6, text_address, &dest) <= 0) { widget_set_error (GTK_WIDGET (entry)); ret = FALSE; } else { widget_unset_error (GTK_WIDGET (entry)); } prefix = strtoul (text_prefix, &end, 10); if (!end || *end || prefix == 0 || prefix > 128) { widget_set_error (g_object_get_data (G_OBJECT (row), "prefix")); ret = FALSE; } else { widget_unset_error (g_object_get_data (G_OBJECT (row), "prefix")); } if (inet_pton (AF_INET6, text_gateway, &gateway) <= 0) { widget_set_error (g_object_get_data (G_OBJECT (row), "gateway")); ret = FALSE; } else { widget_unset_error (g_object_get_data (G_OBJECT (row), "gateway")); } metric = 0; if (*text_metric) { errno = 0; metric = strtoul (text_metric, NULL, 10); if (errno) { widget_set_error (g_object_get_data (G_OBJECT (row), "metric")); ret = FALSE; } else { widget_unset_error (g_object_get_data (G_OBJECT (row), "metric")); } } else { widget_unset_error (g_object_get_data (G_OBJECT (row), "metric")); } if (!ret) continue; route = nm_ip6_route_new (); nm_ip6_route_set_dest (route, &dest); nm_ip6_route_set_prefix (route, prefix); nm_ip6_route_set_next_hop (route, &gateway); nm_ip6_route_set_metric (route, metric); nm_setting_ip6_config_add_route (page->setting, route); nm_ip6_route_unref (route); } g_list_free (children); if (!ret) goto out; ignore_auto_dns = !gtk_switch_get_active (page->auto_dns); ignore_auto_routes = !gtk_switch_get_active (page->auto_routes); never_default = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (page->never_default)); g_object_set (page->setting, NM_SETTING_IP6_CONFIG_METHOD, method, NM_SETTING_IP6_CONFIG_IGNORE_AUTO_DNS, ignore_auto_dns, NM_SETTING_IP6_CONFIG_IGNORE_AUTO_ROUTES, ignore_auto_routes, NM_SETTING_IP6_CONFIG_NEVER_DEFAULT, never_default, NULL); out: return ret; }
void _parse_output(gchar * string) { GError *error = NULL; GRegex *regex; GMatchInfo *matches; regex = g_regex_new (REGEX, 0, 0, &error); if (error) { g_error ("%s", error->message); g_error_free (error); } else { gboolean result; result = g_regex_match (regex, string, 0, &matches); /* XXX */ // printf("%d\n",result); if (result) { // updating = FALSE; const gchar *link = gtk_entry_get_text (GTK_ENTRY (gui->urlTxt)); // gchar *buffer; // gchar *caption; gchar *percent; gchar *size; gchar *size_unit; gchar *speed; gchar *speed_unit; gchar *minutes; gchar *seconds; gdouble downloaded; gdouble fraction; percent = g_match_info_fetch (matches, 1); size = g_match_info_fetch (matches, 2); size_unit = g_match_info_fetch (matches, 3); speed = g_match_info_fetch (matches, 4); speed_unit = g_match_info_fetch (matches, 5); minutes = g_match_info_fetch (matches, 6); // seconds = g_match_info_fetch (matches, 7); // caption = g_strdup_printf ("Downloading <b>%s</b>.\n%s alrededor de <b>%s</b> %s y <b>%s</b> %s a <b>%s%s</b>.", // link, minutes, minutes, minutes, seconds, seconds, speed, speed_unit); fraction = g_strtod (percent, NULL) / 100.0; downloaded = g_strtod (size, NULL) * fraction; // gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (ui->progress), fraction); // buffer = g_strdup_printf ("Descargados %.02g%s de %s%s (%s%%)", downloaded, size_unit, size, size_unit, percent); // gtk_progress_bar_set_text (GTK_PROGRESS_BAR (ui->progress), buffer); // gtk_label_set_markup (GTK_LABEL (ui->label), caption); // printf("Downloading <b>%s</b>.\n%s alrededor de <b>%s</b> %s y <b>%s</b> %s a <b>%s%s</b>.", // link, minutes, minutes, minutes, seconds, seconds, speed, speed_unit); // printf("Descargados %.02g%s de %s%s (%s%%)", downloaded, size_unit, size, size_unit, percent); printf("Completed %s of %s%s in %s%s ETA %s\n", percent, size, size_unit, speed, speed_unit, minutes); // g_free (caption); // g_free (buffer); g_free (percent); g_free (size); g_free (size_unit); g_free (speed); g_free (speed_unit); g_free (minutes); // g_free (seconds); while (gtk_events_pending ()) { gtk_main_iteration (); } } else { printf("%s", string); } g_match_info_matches (matches); } g_regex_unref (regex); }
int configure_wireless(fwnet_interface_t *interface) { extern GtkWidget *assistant; GtkWidget *phboxtemp, *labeltemp; GtkWidget *pBoite = gtk_dialog_new_with_buttons(_("Configure Wireless"), GTK_WINDOW(assistant), GTK_DIALOG_MODAL, GTK_STOCK_OK,GTK_RESPONSE_OK, GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL, NULL); phboxtemp = gtk_hbox_new(FALSE, 5); GtkWidget *labelinfo = gtk_label_new(_("In order to use wireless, you must set your extended netwok name (ESSID).\n" "If you have a WEP encryption key, then please enter it below.\n" "Examples: 4567-89AB-CD or s:password\n" "If you have a WPA passphrase, then please enter it below.\n" "Example: secret\n" "If you want to use a custom driver (not the generic one, called 'wext'), then please enter it below.\n" "If unsure enter nothing")); GtkWidget *imagewifi = gtk_image_new_from_file(g_strdup_printf("%s/wifi.png", IMAGEDIR)); gtk_box_pack_start(GTK_BOX(phboxtemp), imagewifi, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(phboxtemp), labelinfo, TRUE, TRUE, 5); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), phboxtemp, FALSE, FALSE, 5); phboxtemp = gtk_hbox_new(FALSE, 0); labeltemp = gtk_label_new(_("Essid : ")); gtk_box_pack_start(GTK_BOX(phboxtemp), labeltemp, FALSE, FALSE, 5); GtkWidget *pEntryEssid = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(phboxtemp), pEntryEssid, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), phboxtemp, FALSE, FALSE, 5); phboxtemp = gtk_hbox_new(FALSE, 0); labeltemp = gtk_label_new(_("WEP encryption key : ")); gtk_box_pack_start(GTK_BOX(phboxtemp), labeltemp, FALSE, FALSE, 5); GtkWidget *pEntryWepKey = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(phboxtemp), pEntryWepKey, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), phboxtemp, FALSE, FALSE, 5); phboxtemp = gtk_hbox_new(FALSE, 0); labeltemp = gtk_label_new(_("WPA encryption passphrase : ")); gtk_box_pack_start(GTK_BOX(phboxtemp), labeltemp, FALSE, FALSE, 5); GtkWidget *pEntryWpaPass = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(phboxtemp), pEntryWpaPass, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), phboxtemp, FALSE, FALSE, 5); phboxtemp = gtk_hbox_new(FALSE, 0); labeltemp = gtk_label_new(_("WPA Driver : ")); gtk_box_pack_start(GTK_BOX(phboxtemp), labeltemp, FALSE, FALSE, 5); GtkWidget *pEntryWpaDriver = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(phboxtemp), pEntryWpaDriver, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), phboxtemp, FALSE, FALSE, 5); /* Affichage des elements de la boite de dialogue */ gtk_widget_show_all(GTK_DIALOG(pBoite)->vbox); /* On lance la boite de dialogue et on recupere la reponse */ switch (gtk_dialog_run(GTK_DIALOG(pBoite))) { /* L utilisateur valide */ case GTK_RESPONSE_OK: snprintf(interface->essid, FWNET_ESSID_MAX_SIZE, (char*)gtk_entry_get_text(GTK_ENTRY(pEntryEssid))); snprintf(interface->key, FWNET_ENCODING_TOKEN_MAX, (char*)gtk_entry_get_text(GTK_ENTRY(pEntryWepKey))); snprintf(interface->wpa_psk, PATH_MAX, (char*)gtk_entry_get_text(GTK_ENTRY(pEntryWpaPass))); snprintf(interface->wpa_driver, PATH_MAX, (char*)gtk_entry_get_text(GTK_ENTRY(pEntryWpaDriver))); break; /* L utilisateur annule */ case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_NONE: default: break; } /* Destruction de la boite de dialogue */ gtk_widget_destroy(pBoite); return 0; }
int dsl_config(fwnet_profile_t *profile) { extern GtkWidget *assistant; GtkWidget *phboxtemp, *labeltemp; int i; char *uname, *passwd, *passverify, *iface; GtkTreeIter iter; GtkTreeModel *model; GtkWidget *pBoite = gtk_dialog_new_with_buttons(_("Configure DSL connexion"), GTK_WINDOW(assistant), GTK_DIALOG_MODAL, GTK_STOCK_OK,GTK_RESPONSE_OK, GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL, NULL); GtkWidget *labelinfo = gtk_label_new(_("Enter DSL parameters")); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), labelinfo, FALSE, FALSE, 5); phboxtemp = gtk_hbox_new(FALSE, 0); labeltemp = gtk_label_new(_("PPPOE username : "******"PPPOE password : "******"Re-enter PPPOE password : "******"Associate with interface : ")); gtk_box_pack_start(GTK_BOX(phboxtemp), labeltemp, FALSE, FALSE, 5); GtkWidget *intercombodsl = gtk_combo_box_new_text(); gtk_box_pack_start(GTK_BOX(phboxtemp), intercombodsl, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), phboxtemp, FALSE, FALSE, 5); if(iflist != NULL) { gtk_combo_box_append_text(GTK_COMBO_BOX(intercombodsl), ""); for(i=0; i<g_list_length(iflist); i+=2) { gtk_combo_box_append_text(GTK_COMBO_BOX(intercombodsl), (char*)g_list_nth_data(iflist, i)); } } /* Affichage des elements de la boite de dialogue */ gtk_widget_show_all(GTK_DIALOG(pBoite)->vbox); /* On lance la boite de dialogue et on recupere la reponse */ switch (gtk_dialog_run(GTK_DIALOG(pBoite))) { /* L utilisateur valide */ case GTK_RESPONSE_OK: uname = (char*)gtk_entry_get_text(GTK_ENTRY(pEntryName)); passwd = (char*)gtk_entry_get_text(GTK_ENTRY(pEntryPass)); passverify = (char*)gtk_entry_get_text(GTK_ENTRY(pEntryVerify)); gtk_combo_box_get_active_iter(GTK_COMBO_BOX(intercombo), &iter); model = gtk_combo_box_get_model(GTK_COMBO_BOX(intercombo)); gtk_tree_model_get (model, &iter, 0, &iface, -1); if(strcmp(passverify, passwd)) { fwife_error("Passwords do not match! Try again."); gtk_widget_destroy(pBoite); dsl_config(profile); return 0; } else { snprintf(profile->adsl_username, PATH_MAX, uname); snprintf(profile->adsl_password, PATH_MAX, passwd); if(strcmp(iface, "")) snprintf(profile->adsl_interface, IF_NAMESIZE, iface); } break; /* L utilisateur annule */ case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_NONE: default: break; } /* Destruction de la boite de dialogue */ gtk_widget_destroy(pBoite); return 0; }
void gnc_stock_split_assistant_finish (GtkAssistant *assistant, gpointer user_data) { StockSplitInfo *info = user_data; GList *account_commits; GList *node; gnc_numeric amount; Transaction *trans; Account *account; Split *split; time64 date; account = info->acct; g_return_if_fail (account != NULL); amount = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (info->distribution_edit)); g_return_if_fail (!gnc_numeric_zero_p (amount)); gnc_suspend_gui_refresh (); trans = xaccMallocTransaction (gnc_get_current_book ()); xaccTransBeginEdit (trans); xaccTransSetCurrency (trans, gnc_default_currency ()); date = gnc_date_edit_get_date (GNC_DATE_EDIT (info->date_edit)); xaccTransSetDatePostedSecsNormalized (trans, date); { const char *description; description = gtk_entry_get_text (GTK_ENTRY (info->description_entry)); xaccTransSetDescription (trans, description); } split = xaccMallocSplit (gnc_get_current_book ()); xaccAccountBeginEdit (account); account_commits = g_list_prepend (NULL, account); xaccTransAppendSplit (trans, split); xaccAccountInsertSplit (account, split); xaccSplitSetAmount (split, amount); xaccSplitMakeStockSplit (split); /* Set split-action with gnc_set_num_action which is the same as * xaccSplitSetAction with these arguments */ /* Translators: This string has a disambiguation prefix */ gnc_set_num_action (NULL, split, NULL, Q_("Action Column|Split")); amount = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (info->price_edit)); if (gnc_numeric_positive_p (amount)) { QofBook *book; GNCPrice *price; GNCPriceDB *pdb; GNCCurrencyEdit *ce; Timespec ts; ce = GNC_CURRENCY_EDIT (info->price_currency_edit); ts.tv_sec = date; ts.tv_nsec = 0; price = gnc_price_create (gnc_get_current_book ()); gnc_price_begin_edit (price); gnc_price_set_commodity (price, xaccAccountGetCommodity (account)); gnc_price_set_currency (price, gnc_currency_edit_get_currency (ce)); gnc_price_set_time (price, ts); gnc_price_set_source (price, "user:stock-split"); gnc_price_set_typestr (price, "unknown"); gnc_price_set_value (price, amount); gnc_price_commit_edit (price); book = gnc_get_current_book (); pdb = gnc_pricedb_get_db (book); if (!gnc_pricedb_add_price (pdb, price)) gnc_error_dialog (info->window, "%s", _("Error adding price.")); gnc_price_unref (price); } amount = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (info->cash_edit)); if (gnc_numeric_positive_p (amount)) { const char *memo; memo = gtk_entry_get_text (GTK_ENTRY (info->memo_entry)); /* asset split */ account = gnc_tree_view_account_get_selected_account (GNC_TREE_VIEW_ACCOUNT(info->asset_tree)); split = xaccMallocSplit (gnc_get_current_book ()); xaccAccountBeginEdit (account); account_commits = g_list_prepend (account_commits, account); xaccAccountInsertSplit (account, split); xaccTransAppendSplit (trans, split); xaccSplitSetAmount (split, amount); xaccSplitSetValue (split, amount); xaccSplitSetMemo (split, memo); /* income split */ account = gnc_tree_view_account_get_selected_account (GNC_TREE_VIEW_ACCOUNT(info->income_tree)); split = xaccMallocSplit (gnc_get_current_book ()); xaccAccountBeginEdit (account); account_commits = g_list_prepend (account_commits, account); xaccAccountInsertSplit (account, split); xaccTransAppendSplit (trans, split); xaccSplitSetAmount (split, gnc_numeric_neg (amount)); xaccSplitSetValue (split, gnc_numeric_neg (amount)); xaccSplitSetMemo (split, memo); } xaccTransCommitEdit (trans); for (node = account_commits; node; node = node->next) xaccAccountCommitEdit (node->data); g_list_free (account_commits); gnc_resume_gui_refresh (); gnc_close_gui_component_by_data (ASSISTANT_STOCK_SPLIT_CM_CLASS, info); }
static gboolean formhistory_check_master_password (GtkWidget* parent, FormHistoryPriv* priv) { GtkWidget* dialog; GtkWidget* content_area; GtkWidget* hbox; GtkWidget* image; GtkWidget* label; GtkWidget* entry; const gchar* title; static int alive; gboolean ret = FALSE; /* Password is set */ if (priv->master_password && *priv->master_password) return TRUE; /* Other prompt is active */ if (alive == 1) return FALSE; /* Prompt was cancelled */ if (priv->master_password_canceled == 1) return FALSE; alive = 1; title = _("Form history"); dialog = gtk_dialog_new_with_buttons (title, GTK_WINDOW (parent), GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_DIALOG_AUTHENTICATION); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_container_set_border_width (GTK_CONTAINER (content_area), 5); hbox = gtk_hbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); label = gtk_label_new (_("Master password required\n" "to open password database")); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, TRUE, 0); entry = gtk_entry_new (); g_object_set (entry, "truncate-multiline", TRUE, NULL); gtk_entry_set_visibility(GTK_ENTRY (entry),FALSE); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); gtk_box_pack_start (GTK_BOX (content_area), entry, FALSE, TRUE, 0); gtk_widget_show_all (entry); gtk_widget_show_all (hbox); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { /* FIXME: add password verification */ katze_assign (priv->master_password, g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)))); ret = TRUE; } else priv->master_password_canceled = 1; gtk_widget_destroy (dialog); alive = 0; return ret; }
void read_rek() { rk->kod_top.new_plus(iceb_u_fromutf((char*)gtk_entry_get_text(GTK_ENTRY(entry[E_KOD_TOP])))); rk->kod_mat.new_plus(iceb_u_fromutf((char*)gtk_entry_get_text(GTK_ENTRY(entry[E_KOD_MAT])))); }
/** * vtable_dialog_get_table_name: * */ const gchar * vtable_dialog_get_table_name (VtableDialog *dlg) { g_return_val_if_fail (IS_VTABLE_DIALOG (dlg), NULL); return gtk_entry_get_text (GTK_ENTRY (dlg->priv->tname_entry)); }
static void mpg123_configurewin_ok(GtkWidget * widget, gpointer data) { ConfigFile *cfg; gchar *filename; if (GTK_TOGGLE_BUTTON(decode_res_16)->active) mpg123_cfg.resolution = 16; else if (GTK_TOGGLE_BUTTON(decode_res_8)->active) mpg123_cfg.resolution = 8; if (GTK_TOGGLE_BUTTON(decode_ch_stereo)->active) mpg123_cfg.channels = 2; else if (GTK_TOGGLE_BUTTON(decode_ch_mono)->active) mpg123_cfg.channels = 1; if (GTK_TOGGLE_BUTTON(decode_freq_1to1)->active) mpg123_cfg.downsample = 0; else if (GTK_TOGGLE_BUTTON(decode_freq_1to2)->active) mpg123_cfg.downsample = 1; if (GTK_TOGGLE_BUTTON(decode_freq_1to4)->active) mpg123_cfg.downsample = 2; if (GTK_TOGGLE_BUTTON(detect_by_content)->active) mpg123_cfg.detect_by = DETECT_CONTENT; else if (GTK_TOGGLE_BUTTON(detect_by_extension)->active) mpg123_cfg.detect_by = DETECT_EXTENSION; else if (GTK_TOGGLE_BUTTON(detect_by_both)->active) mpg123_cfg.detect_by = DETECT_BOTH; else mpg123_cfg.detect_by = DETECT_EXTENSION; #ifdef USE_SIMD if (GTK_TOGGLE_BUTTON(auto_select)->active) mpg123_cfg.default_synth = SYNTH_AUTO; else if (GTK_TOGGLE_BUTTON(decoder_fpu)->active) mpg123_cfg.default_synth = SYNTH_FPU; else if (GTK_TOGGLE_BUTTON(decoder_mmx)->active) mpg123_cfg.default_synth = SYNTH_MMX; else mpg123_cfg.default_synth = SYNTH_3DNOW; #endif mpg123_cfg.http_buffer_size = (gint) GTK_ADJUSTMENT(streaming_size_adj)->value; mpg123_cfg.http_prebuffer = (gint) GTK_ADJUSTMENT(streaming_pre_adj)->value; mpg123_cfg.use_proxy = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_proxy_use)); g_free(mpg123_cfg.proxy_host); mpg123_cfg.proxy_host = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_host_entry))); mpg123_cfg.proxy_port = atoi(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_port_entry))); mpg123_cfg.proxy_use_auth = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_proxy_auth_use)); if(mpg123_cfg.proxy_user) g_free(mpg123_cfg.proxy_user); mpg123_cfg.proxy_user = NULL; if(strlen(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_user_entry))) > 0) mpg123_cfg.proxy_user = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_user_entry))); if(mpg123_cfg.proxy_pass) g_free(mpg123_cfg.proxy_pass); mpg123_cfg.proxy_pass = NULL; if(strlen(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_pass_entry))) > 0) mpg123_cfg.proxy_pass = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_pass_entry))); mpg123_cfg.save_http_stream = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_save_use)); if (mpg123_cfg.save_http_path) g_free(mpg123_cfg.save_http_path); mpg123_cfg.save_http_path = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_save_entry))); mpg123_cfg.cast_title_streaming = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_cast_title)); mpg123_cfg.use_udp_channel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_udp_title)); mpg123_cfg.title_override = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(title_override)); mpg123_cfg.disable_id3v2 = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(title_id3v2_disable)); g_free(mpg123_cfg.id3_format); mpg123_cfg.id3_format = g_strdup(gtk_entry_get_text(GTK_ENTRY(title_id3_entry))); filename = g_strconcat(g_get_home_dir(), "/.xmms/config", NULL); cfg = xmms_cfg_open_file(filename); if (!cfg) cfg = xmms_cfg_new(); xmms_cfg_write_int(cfg, "MPG123", "resolution", mpg123_cfg.resolution); xmms_cfg_write_int(cfg, "MPG123", "channels", mpg123_cfg.channels); xmms_cfg_write_int(cfg, "MPG123", "downsample", mpg123_cfg.downsample); xmms_cfg_write_int(cfg, "MPG123", "http_buffer_size", mpg123_cfg.http_buffer_size); xmms_cfg_write_int(cfg, "MPG123", "http_prebuffer", mpg123_cfg.http_prebuffer); xmms_cfg_write_boolean(cfg, "MPG123", "use_proxy", mpg123_cfg.use_proxy); xmms_cfg_write_string(cfg, "MPG123", "proxy_host", mpg123_cfg.proxy_host); xmms_cfg_write_int(cfg, "MPG123", "proxy_port", mpg123_cfg.proxy_port); xmms_cfg_write_boolean(cfg, "MPG123", "proxy_use_auth", mpg123_cfg.proxy_use_auth); if(mpg123_cfg.proxy_user) xmms_cfg_write_string(cfg, "MPG123", "proxy_user", mpg123_cfg.proxy_user); else xmms_cfg_remove_key(cfg, "MPG123", "proxy_user"); if(mpg123_cfg.proxy_pass) xmms_cfg_write_string(cfg, "MPG123", "proxy_pass", mpg123_cfg.proxy_pass); else xmms_cfg_remove_key(cfg, "MPG123", "proxy_pass"); xmms_cfg_write_boolean(cfg, "MPG123", "save_http_stream", mpg123_cfg.save_http_stream); xmms_cfg_write_string(cfg, "MPG123", "save_http_path", mpg123_cfg.save_http_path); xmms_cfg_write_boolean(cfg, "MPG123", "cast_title_streaming", mpg123_cfg.cast_title_streaming); xmms_cfg_write_boolean(cfg, "MPG123", "use_udp_channel", mpg123_cfg.use_udp_channel); xmms_cfg_write_boolean(cfg, "MPG123", "title_override", mpg123_cfg.title_override); xmms_cfg_write_boolean(cfg, "MPG123", "disable_id3v2", mpg123_cfg.disable_id3v2); xmms_cfg_write_string(cfg, "MPG123", "id3_format", mpg123_cfg.id3_format); xmms_cfg_write_int(cfg, "MPG123", "detect_by", mpg123_cfg.detect_by); #ifdef USE_SIMD xmms_cfg_write_int(cfg, "MPG123", "default_synth", mpg123_cfg.default_synth); #endif xmms_cfg_write_file(cfg, filename); xmms_cfg_free(cfg); g_free(filename); gtk_widget_destroy(mpg123_configurewin); }
gdouble xmi_msim_gui_compound_dialog_get_weight(XmiMsimGuiCompoundDialog *dialog) { return strtod(gtk_entry_get_text(GTK_ENTRY(dialog->weightEntry)), NULL); }
gchar *xmi_msim_gui_compound_dialog_get_compound(XmiMsimGuiCompoundDialog *dialog) { return g_strdup(gtk_entry_get_text(GTK_ENTRY(dialog->compoundEntry))); }
static void search_prev_clicked (GtkWidget *button, GtkWidget *entry) { search (gtk_entry_get_text (GTK_ENTRY (entry)), FALSE); }
void cb_ask_for_information (ScreenshooterJob *job, GtkListStore *liststore, const gchar *message, gpointer unused) { GtkWidget *dialog; GtkWidget *information_label; GtkWidget *vbox, *main_alignment; GtkWidget *table; GtkWidget *user_entry, *password_entry, *title_entry, *comment_entry; GtkWidget *user_label, *password_label, *title_label, *comment_label; GtkTreeIter iter; gint response; g_return_if_fail (SCREENSHOOTER_IS_JOB (job)); g_return_if_fail (GTK_IS_LIST_STORE (liststore)); g_return_if_fail (message != NULL); TRACE ("Create the dialog to ask for user information."); /* Create the information dialog */ dialog = xfce_titled_dialog_new_with_buttons (_("Details about the screenshot for ZimageZ"), NULL, GTK_DIALOG_NO_SEPARATOR, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG(dialog)->vbox), 12); gtk_window_set_icon_name (GTK_WINDOW (dialog), "gtk-info"); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); /* Create the main alignment for the dialog */ main_alignment = gtk_alignment_new (0, 0, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (main_alignment), 6, 0, 12, 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_alignment, TRUE, TRUE, 0); /* Create the main box for the dialog */ vbox = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_container_add (GTK_CONTAINER (main_alignment), vbox); /* Create the information label */ information_label = gtk_label_new (""); gtk_label_set_markup (GTK_LABEL (information_label), message); gtk_misc_set_alignment (GTK_MISC (information_label), 0, 0); gtk_container_add (GTK_CONTAINER (vbox), information_label); /* Create the layout table */ table = gtk_table_new (4, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 12); gtk_container_add (GTK_CONTAINER (vbox), table); /* Create the user label */ user_label = gtk_label_new (_("User:"******"Your Zimagez user name, if you do not have one yet" " please create one on the Web page linked above")); gtk_entry_set_activates_default (GTK_ENTRY (user_entry), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), user_entry, 1, 2, 0, 1); /* Create the password label */ password_label = gtk_label_new (_("Password:"******"The password for the user above")); gtk_entry_set_visibility (GTK_ENTRY (password_entry), FALSE); gtk_entry_set_activates_default (GTK_ENTRY (password_entry), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), password_entry, 1, 2, 1, 2); /* Create the title label */ title_label = gtk_label_new (_("Title:")); gtk_misc_set_alignment (GTK_MISC (title_label), 0, 0.5); gtk_table_attach (GTK_TABLE (table), title_label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0); /* Create the title entry */ title_entry = gtk_entry_new (); gtk_widget_set_tooltip_text (title_entry, _("The title of the screenshot, it will be used when" " displaying the screenshot on ZimageZ")); gtk_entry_set_activates_default (GTK_ENTRY (title_entry), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), title_entry, 1, 2, 2, 3); /* Create the comment label */ comment_label = gtk_label_new (_("Comment:")); gtk_misc_set_alignment (GTK_MISC (comment_label), 0, 0.5); gtk_table_attach (GTK_TABLE (table), comment_label, 0, 1, 3, 4, GTK_FILL, GTK_FILL, 0, 0); /* Create the comment entry */ comment_entry = gtk_entry_new (); gtk_widget_set_tooltip_text (comment_entry, _("A comment on the screenshot, it will be used when" " displaying the screenshot on ZimageZ")); gtk_entry_set_activates_default (GTK_ENTRY (comment_entry), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), comment_entry, 1, 2, 3, 4); /* Set the values */ gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter); do { gint field_index; gchar *field_value = NULL; gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter, 0, &field_index, 1, &field_value, -1); switch (field_index) { case USER: gtk_entry_set_text (GTK_ENTRY (user_entry), field_value); break; case PASSWORD: gtk_entry_set_text (GTK_ENTRY (password_entry), field_value); break; case TITLE: gtk_entry_set_text (GTK_ENTRY (title_entry), field_value); break; case COMMENT: gtk_entry_set_text (GTK_ENTRY (comment_entry), field_value); break; default: break; } g_free (field_value); } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter)); gtk_widget_show_all (GTK_DIALOG(dialog)->vbox); response = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_hide (dialog); if (response == GTK_RESPONSE_CANCEL || response == GTK_RESPONSE_DELETE_EVENT) { exo_job_cancel (EXO_JOB (job)); } else if (response == GTK_RESPONSE_OK) { gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter); do { gint field_index; gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter, 0, &field_index, -1); switch (field_index) { case USER: gtk_list_store_set (liststore, &iter, 1, gtk_entry_get_text (GTK_ENTRY (user_entry)), -1); break; case PASSWORD: gtk_list_store_set (liststore, &iter, 1, gtk_entry_get_text (GTK_ENTRY (password_entry)), -1); break; case TITLE: gtk_list_store_set (liststore, &iter, 1, gtk_entry_get_text (GTK_ENTRY (title_entry)), -1); break; case COMMENT: gtk_list_store_set (liststore, &iter, 1, gtk_entry_get_text (GTK_ENTRY (comment_entry)), -1); break; default: break; } } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter)); } gtk_widget_destroy (dialog); }
static void search_next_clicked (GtkWidget *button, GtkWidget *entry) { search (gtk_entry_get_text (GTK_ENTRY (entry)), TRUE); }
/* * display the interface selection dialog */ static void gtkui_unified_sniff(void) { GList *iface_list; const char *iface_desc = NULL; char err[100]; GtkWidget *iface_combo; pcap_if_t *dev; GtkWidget *dialog, *label, *hbox, *image; DEBUG_MSG("gtk_unified_sniff"); dialog = gtk_dialog_new_with_buttons(EC_PROGRAM" Input", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), 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_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); label = gtk_label_new ("Network interface : "); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); /* make a list of network interfaces */ iface_list = NULL; for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { iface_list = g_list_append(iface_list, dev->description); } /* make a drop down box and assign the list to it */ iface_combo = gtk_combo_new(); gtk_combo_set_popdown_strings (GTK_COMBO (iface_combo), iface_list); gtk_box_pack_start (GTK_BOX (hbox), iface_combo, FALSE, FALSE, 0); /* hitting Enter in the drop down box clicks OK */ g_object_set_data(G_OBJECT (GTK_COMBO (iface_combo)->entry), "dialog", dialog); g_signal_connect(G_OBJECT (GTK_COMBO (iface_combo)->entry), "activate", G_CALLBACK (gtkui_dialog_enter), NULL); /* list is stored in the widget, can safely free this copy */ g_list_free(iface_list); /* render the contents of the dialog */ gtk_widget_show_all (hbox); /* show the dialog itself and become interactive */ if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { iface_desc = gtk_entry_get_text(GTK_ENTRY (GTK_COMBO (iface_combo)->entry)); for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { if(!strncmp(dev->description, iface_desc, IFACE_LEN)) { SAFE_FREE(GBL_OPTIONS->iface); SAFE_CALLOC(GBL_OPTIONS->iface, IFACE_LEN, sizeof(char)); strncpy(GBL_OPTIONS->iface, dev->name, IFACE_LEN); break; } } /* if no match in list */ if(GBL_OPTIONS->iface == NULL) { snprintf(err, 100, "Invalid interface: %s", iface_desc); gtkui_error(err); gtk_widget_destroy(dialog); return; } /* exit setup iterface */ gtk_widget_destroy(dialog); gtk_main_quit(); return; } gtk_widget_destroy(dialog); }
int configure_static(fwnet_interface_t *interface, GtkTreeIter iter) { extern GtkWidget *assistant; GtkWidget *phboxtemp, *labeltemp; char option[50]; char *ipaddr, *netmask, *gateway; GtkWidget *pBoite = gtk_dialog_new_with_buttons(_("Configure static network"), GTK_WINDOW(assistant), GTK_DIALOG_MODAL, GTK_STOCK_OK,GTK_RESPONSE_OK, NULL); GtkWidget *labelinfo = gtk_label_new(_("Enter static network parameters :")); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), labelinfo, FALSE, FALSE, 5); phboxtemp = gtk_hbox_new(FALSE, 0); labeltemp = gtk_label_new(_("IP Address : ")); gtk_box_pack_start(GTK_BOX(phboxtemp), labeltemp, FALSE, FALSE, 5); GtkWidget *pEntryIP = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(phboxtemp), pEntryIP, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), phboxtemp, FALSE, FALSE, 5); phboxtemp = gtk_hbox_new(FALSE, 0); labeltemp = gtk_label_new(_("Network Mask : ")); gtk_box_pack_start(GTK_BOX(phboxtemp), labeltemp, FALSE, FALSE, 5); GtkWidget *pEntryNetmask = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(phboxtemp), pEntryNetmask, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), phboxtemp, FALSE, FALSE, 5); phboxtemp = gtk_hbox_new(FALSE, 0); labeltemp = gtk_label_new(_("Gateway : ")); gtk_box_pack_start(GTK_BOX(phboxtemp), labeltemp, FALSE, FALSE, 5); GtkWidget *pEntryGateway = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(phboxtemp), pEntryGateway, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), phboxtemp, FALSE, FALSE, 5); /* Affichage des elements de la boite de dialogue */ gtk_widget_show_all(GTK_DIALOG(pBoite)->vbox); /* On lance la boite de dialogue et on recupere la reponse */ switch (gtk_dialog_run(GTK_DIALOG(pBoite))) { /* L utilisateur valide */ case GTK_RESPONSE_OK: ipaddr = (char*)gtk_entry_get_text(GTK_ENTRY(pEntryIP)); netmask = (char*)gtk_entry_get_text(GTK_ENTRY(pEntryNetmask)); if(strlen(ipaddr)) snprintf(option, 49, "%s netmask %s", ipaddr, netmask); interface->options = g_list_append(interface->options, strdup(option)); gateway = (char*)gtk_entry_get_text(GTK_ENTRY(pEntryGateway)); if(strlen(gateway)) snprintf(interface->gateway, FWNET_GW_MAX_SIZE, "default gw %s", gateway); GtkTreeView *treeview = (GtkTreeView *)viewif; GtkTreeModel *model = gtk_tree_view_get_model (treeview); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COLUMN_NET_IP, ipaddr,COLUMN_NET_NETMASK, netmask, COLUMN_NET_GATEWAY, gateway, -1); break; /* L utilisateur annule */ case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_NONE: default: break; } /* Destruction de la boite de dialogue */ gtk_widget_destroy(pBoite); return 0; }
/* * display the interface selection for bridged sniffing */ static void gtkui_bridged_sniff(void) { GtkWidget *dialog, *vbox, *hbox, *image; GtkWidget *hbox_big, *label, *combo1, *combo2; GList *iface_list; const char *iface_desc = NULL; char err[100]; pcap_if_t *dev; DEBUG_MSG("gtk_bridged_sniff"); dialog = gtk_dialog_new_with_buttons("Bridged Sniffing", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); hbox_big = gtk_hbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox_big, FALSE, FALSE, 0); gtk_widget_show(hbox_big); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.1); gtk_box_pack_start (GTK_BOX (hbox_big), image, FALSE, FALSE, 5); gtk_widget_show(image); vbox = gtk_vbox_new (FALSE, 2); gtk_container_set_border_width(GTK_CONTAINER (vbox), 5); gtk_box_pack_start (GTK_BOX (hbox_big), vbox, TRUE, TRUE, 0); gtk_widget_show(vbox); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_widget_show(hbox); label = gtk_label_new ("First network interface : "); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_box_pack_start(GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_widget_show(label); /* make a list of network interfaces */ iface_list = NULL; for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { iface_list = g_list_append(iface_list, dev->description); } /* make a drop down box and assign the list to it */ combo1 = gtk_combo_new(); gtk_combo_set_popdown_strings (GTK_COMBO (combo1), iface_list); gtk_box_pack_start (GTK_BOX (hbox), combo1, FALSE, FALSE, 0); gtk_widget_show(combo1); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_widget_show(hbox); label = gtk_label_new ("Second network interface : "); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_box_pack_start(GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_widget_show(label); /* make a drop down box and assign the list to it */ combo2 = gtk_combo_new(); gtk_combo_set_popdown_strings (GTK_COMBO (combo2), iface_list); gtk_box_pack_start (GTK_BOX (hbox), combo2, FALSE, FALSE, 0); gtk_widget_show(combo2); /* pick the second interface by default, since they can't match */ if(iface_list && iface_list->next) gtk_entry_set_text(GTK_ENTRY (GTK_COMBO (combo2)->entry), iface_list->next->data); /* list is stored in the widget, can safely free this copy */ g_list_free(iface_list); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); iface_desc = gtk_entry_get_text(GTK_ENTRY (GTK_COMBO (combo1)->entry)); for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { if(!strncmp(dev->description, iface_desc, IFACE_LEN)) { SAFE_FREE(GBL_OPTIONS->iface); SAFE_CALLOC(GBL_OPTIONS->iface, IFACE_LEN, sizeof(char)); strncpy(GBL_OPTIONS->iface, dev->name, IFACE_LEN); break; } } /* if no match in list */ if(GBL_OPTIONS->iface == NULL) { snprintf(err, 100, "Invalid interface: %s", iface_desc); gtkui_error(err); gtk_widget_destroy(dialog); return; } iface_desc = gtk_entry_get_text(GTK_ENTRY (GTK_COMBO (combo2)->entry)); for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { if(!strncmp(dev->description, iface_desc, IFACE_LEN)) { SAFE_FREE(GBL_OPTIONS->iface_bridge); SAFE_CALLOC(GBL_OPTIONS->iface_bridge, IFACE_LEN, sizeof(char)); strncpy(GBL_OPTIONS->iface_bridge, dev->name, IFACE_LEN); break; } } /* if no match in list */ if(GBL_OPTIONS->iface_bridge == NULL) { snprintf(err, 100, "Invalid interface: %s", iface_desc); gtkui_error(err); gtk_widget_destroy(dialog); return; } bridged_sniff(); } gtk_widget_destroy(dialog); }
static void prefs_ok_cb(GtkWidget *widget, gpointer data) { gchar *rcpath; const gchar *address; gboolean startup; gboolean unreadonly; GtkTreeModel *model; gint nfolder; gchar **folders; GtkTreeIter iter; gboolean valid; int nindex; gchar *folder; gsize sz; gchar *buf; rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "autoforwardrc", NULL); g_keyfile = g_key_file_new(); g_key_file_load_from_file(g_keyfile, rcpath, G_KEY_FILE_KEEP_COMMENTS, NULL); address = gtk_entry_get_text(GTK_ENTRY(g_address)); if (address!=NULL){ g_key_file_set_string (g_keyfile, "forward", "to", address); } startup = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g_startup)); g_key_file_set_boolean (g_keyfile, "forward", "startup", startup); debug_print("startup:%s\n", startup ? "true" : "false"); unreadonly = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g_unreadonly)); g_key_file_set_boolean (g_keyfile, "forward", "unreadonly", unreadonly); debug_print("unread only:%s\n", g_unreadonly_flg ? "true" : "false"); g_key_file_set_boolean (g_keyfile, "forward", "all", g_forward_flg); debug_print("forward all:%s\n", g_forward_flg ? "true" : "false"); /**/ model = GTK_TREE_MODEL(g_folders); nfolder = gtk_tree_model_iter_n_children(model, NULL); if (nfolder > 0){ folders = malloc(sizeof(gchar*)*nfolder); nindex = 0; for (valid = gtk_tree_model_get_iter_first(model, &iter); valid; valid = gtk_tree_model_iter_next(model, &iter)) { gtk_tree_model_get(model, &iter, 0, &folder, -1); folders[nindex] = folder; g_print("%d:%s\n", nindex, folder); nindex++; } g_key_file_set_string_list(g_keyfile, "forward", "folder", (const gchar * const*)folders, nfolder); }else{ g_key_file_remove_key(g_keyfile, "forward", "folder", NULL); } buf=g_key_file_to_data(g_keyfile, &sz, NULL); g_file_set_contents(rcpath, buf, sz, NULL); g_free(rcpath); gtk_widget_destroy(GTK_WIDGET(data)); }
void gui_prefs_fetch(GtkWidget *w) { prefs.gui_plist_sel_browse = fetch_enum_value( g_object_get_data(G_OBJECT(w), PLIST_SEL_BROWSE_KEY), selection_mode_vals); prefs.gui_ptree_sel_browse = fetch_enum_value( g_object_get_data(G_OBJECT(w), PTREE_SEL_BROWSE_KEY), selection_mode_vals); prefs.gui_geometry_save_position = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GEOMETRY_POSITION_KEY)); prefs.gui_geometry_save_size = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GEOMETRY_SIZE_KEY)); prefs.gui_geometry_save_maximized = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GEOMETRY_MAXIMIZED_KEY)); #if defined(HAVE_IGE_MAC_INTEGRATION) || defined(HAVE_GTKOSXAPPLICATION) prefs.gui_macosx_style = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), MACOSX_STYLE_KEY)); #endif #ifdef _WIN32 prefs.gui_console_open = fetch_enum_value( g_object_get_data(G_OBJECT(w), GUI_CONSOLE_OPEN_KEY), gui_console_open_vals); #endif prefs.gui_fileopen_style = fetch_preference_radio_buttons_val( g_object_get_data(G_OBJECT(w), GUI_FILEOPEN_KEY), gui_fileopen_vals); g_free(prefs.gui_fileopen_dir); prefs.gui_fileopen_dir = g_strdup(gtk_entry_get_text( GTK_ENTRY(g_object_get_data(G_OBJECT(w), GUI_FILEOPEN_DIR_KEY)))); prefs.gui_ask_unsaved = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GUI_ASK_UNSAVED_KEY)); prefs.gui_find_wrap = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GUI_FIND_WRAP_KEY)); prefs.gui_use_pref_save = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GUI_USE_PREF_SAVE_KEY)); prefs.gui_version_in_start_page = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GUI_SHOW_VERSION_KEY)); prefs.gui_auto_scroll_on_expand = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GUI_AUTO_SCROLL_KEY)); if (browser_needs_pref()) { g_free(prefs.gui_webbrowser); prefs.gui_webbrowser = g_strdup(gtk_entry_get_text( GTK_ENTRY(g_object_get_data(G_OBJECT(w), GUI_WEBBROWSER_KEY)))); } prefs.gui_expert_composite_eyecandy = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GUI_EXPERT_EYECANDY_KEY)); /* * XXX - we need to have a way to fetch the preferences into * local storage and only set the permanent preferences if there * weren't any errors in those fetches, as there are several * places where there *can* be a bad preference value. */ if (font_fetch()) { if (strcmp(new_font_name, prefs.gui_font_name) != 0) { font_changed = TRUE; g_free(prefs.gui_font_name); prefs.gui_font_name = g_strdup(new_font_name); } } }
/** * @see https://developers.facebook.com/docs/authentication/ * @returs NULL if the user cancel the operation or a valid token */ static gchar *facebook_get_user_auth_token(dt_storage_facebook_gui_data_t *ui) { ///////////// open the authentication url in a browser GError *error = NULL; gtk_show_uri(gdk_screen_get_default(), FB_WS_BASE_URL"dialog/oauth?" "client_id=" FB_API_KEY "&redirect_uri="FB_WS_BASE_URL"connect/login_success.html" "&scope=user_photos,publish_stream" "&response_type=token", gtk_get_current_event_time(), &error); ////////////// build & show the validation dialog gchar *text1 = _("step 1: a new window or tab of your browser should have been " "loaded. you have to login into your facebook account there " "and authorize darktable to upload photos before continuing."); gchar *text2 = _("step 2: paste your browser URL and click the OK button once " "you are done."); GtkWidget *window = dt_ui_main_window(darktable.gui->ui); GtkDialog *fb_auth_dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL, _("facebook authentication"))); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (fb_auth_dialog), "%s\n\n%s", text1, text2); GtkWidget *entry = gtk_entry_new(); GtkWidget *hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(gtk_label_new(_("URL:"))), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(entry), TRUE, TRUE, 0); GtkWidget *fbauthdialog_vbox = gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG(fb_auth_dialog)); gtk_box_pack_end(GTK_BOX(fbauthdialog_vbox), hbox, TRUE, TRUE, 0); gtk_widget_show_all(GTK_WIDGET(fb_auth_dialog)); ////////////// wait for the user to enter the validation URL gint result; gchar *token = NULL; const char *replyurl; while (TRUE) { result = gtk_dialog_run (GTK_DIALOG (fb_auth_dialog)); if (result == GTK_RESPONSE_CANCEL) break; replyurl = gtk_entry_get_text(GTK_ENTRY(entry)); if (replyurl == NULL || g_strcmp0(replyurl, "") == 0) { gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(fb_auth_dialog), "%s\n\n%s\n\n<span foreground=\"" MSGCOLOR_RED "\" ><small>%s</small></span>", text1, text2, _("please enter the validation URL")); continue; } token = fb_extract_token_from_url(replyurl); if (token != NULL)//we have a valid token break; else gtk_message_dialog_format_secondary_markup( GTK_MESSAGE_DIALOG(fb_auth_dialog), "%s\n\n%s%s\n\n<span foreground=\"" MSGCOLOR_RED "\"><small>%s</small></span>", text1, text2, _("the given URL is not valid, it should look like: "), FB_WS_BASE_URL"connect/login_success.html?..."); } gtk_widget_destroy(GTK_WIDGET(fb_auth_dialog)); return token; }
// main program /////////////////////////////////////////////////////////////////////////////////////////////////// int main(int argc, char *argv[]) { int return_value = EXIT_ERROR; PinDialogInfo pindialog; char caller_path[1024]; gtk_init(&argc, &argv); // initialize gtk+ putenv("LANGUAGE="); bindtextdomain("dialogs-beid", DATAROOTDIR "/locale"); textdomain("dialogs-beid"); // create new message dialog with CANCEL and OK buttons in standard places, in center of user's screen /////////////////////////////////////////////////////////////////////////////////////////////////////////////////// if(argc < 2 || (strlen(argv[1]) == 0)) { fprintf(stderr, "E: required argument: PIN name"); exit(EXIT_ERROR); } if (get_parent_path(caller_path, sizeof(caller_path) - 2) > 0) { pindialog.dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, gettext("Request from Application [%s]:\n\nPlease enter your current eID %s, followed by your new eID %s (twice)"), caller_path, argv[1], argv[1]); } else { fprintf(stderr, "Failed To Determine Parent Process. Aborting.\n"); exit(EXIT_ERROR); } pindialog.cancelbutton = GTK_BUTTON(gtk_dialog_add_button (GTK_DIALOG(pindialog.dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL)); pindialog.okbutton = GTK_BUTTON(gtk_dialog_add_button (GTK_DIALOG(pindialog.dialog), GTK_STOCK_OK, GTK_RESPONSE_OK)); gtk_dialog_set_default_response(GTK_DIALOG(pindialog.dialog), GTK_RESPONSE_OK); gtk_window_set_title(GTK_WINDOW(pindialog.dialog), gettext("beID: Change PIN Code")); gtk_window_set_position(GTK_WINDOW(pindialog.dialog), GTK_WIN_POS_CENTER); g_signal_connect(pindialog.dialog, "delete-event", G_CALLBACK(on_delete_event), &pindialog); // create original, new, and verify new pin entry fields with labels, in a table /////////////////////////////////////////////////////////////////////////////////////////////////////////// pindialog.newPinsTable = gtk_table_new(3, 2, TRUE); // table of 4 rows, 3 columns pindialog.originalPinLabel = gtk_label_new(gettext("Current PIN:")); pindialog.newPin0Label = gtk_label_new(gettext("New PIN:")); pindialog.newPin1Label = gtk_label_new(gettext("New PIN (again):")); pindialog.originalPinEntry = gtk_entry_new(); pindialog.newPin0Entry = gtk_entry_new(); pindialog.newPin1Entry = gtk_entry_new(); // set max lengths gtk_entry_set_max_length(GTK_ENTRY(pindialog.originalPinEntry), MAX_PIN_LENGTH); gtk_entry_set_max_length(GTK_ENTRY(pindialog.newPin0Entry), MAX_PIN_LENGTH); gtk_entry_set_max_length(GTK_ENTRY(pindialog.newPin1Entry), MAX_PIN_LENGTH); // disable visibilities gtk_entry_set_visibility(GTK_ENTRY(pindialog.originalPinEntry), FALSE); gtk_entry_set_visibility(GTK_ENTRY(pindialog.newPin0Entry), FALSE); gtk_entry_set_visibility(GTK_ENTRY(pindialog.newPin1Entry), FALSE); // put labels and entries in a table gtk_table_attach(GTK_TABLE(pindialog.newPinsTable), pindialog.originalPinLabel, 0, 1, 0, 1, (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), 2, 2); gtk_table_attach(GTK_TABLE(pindialog.newPinsTable), pindialog.newPin0Label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), 2, 2); gtk_table_attach(GTK_TABLE(pindialog.newPinsTable), pindialog.newPin1Label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), 2, 2); gtk_table_attach(GTK_TABLE(pindialog.newPinsTable), pindialog.originalPinEntry, 1, 2, 0, 1, (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), 2, 2); gtk_table_attach(GTK_TABLE(pindialog.newPinsTable), pindialog.newPin0Entry, 1, 2, 1, 2, (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), 2, 2); gtk_table_attach(GTK_TABLE(pindialog.newPinsTable), pindialog.newPin1Entry, 1, 2, 2, 3, (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), 2, 2); // connect signals to filter and read inputs g_signal_connect(pindialog.originalPinEntry, "insert_text", G_CALLBACK(insert_only_digits), (gpointer) & pindialog); g_signal_connect(pindialog.newPin0Entry, "insert_text", G_CALLBACK(insert_only_digits), (gpointer) & pindialog); g_signal_connect(pindialog.newPin1Entry, "insert_text", G_CALLBACK(insert_only_digits), (gpointer) & pindialog); g_signal_connect(pindialog.originalPinEntry, "changed", G_CALLBACK(pins_changed), (gpointer) & pindialog); g_signal_connect(pindialog.newPin0Entry, "changed", G_CALLBACK(pins_changed), (gpointer) & pindialog); g_signal_connect(pindialog.newPin1Entry, "changed", G_CALLBACK(pins_changed), (gpointer) & pindialog); // add all these objects to the dialog /////////////////////////////////////////////////////////////////////////////////////////////////////////// gtk_container_set_border_width(GTK_CONTAINER(pindialog.dialog), 10); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(pindialog.dialog))), pindialog.newPinsTable, TRUE, TRUE, 2); // initial state for OK button ///////////////////////////////////////////////////////////////////////////////////////////////////////// update_ok_button(&pindialog); // show all these widgets, and run the dialog as a modal dialog until it is closed by the user ////////////////////////////////////////////////////////////////////////////////////////////// gtk_widget_show_all(GTK_WIDGET(pindialog.dialog)); switch (gtk_dialog_run(GTK_DIALOG(pindialog.dialog))) { case GTK_RESPONSE_OK: // if the user chose OK { const char *oldpin = gtk_entry_get_text(GTK_ENTRY(pindialog.originalPinEntry)); const char *newpin = gtk_entry_get_text(GTK_ENTRY(pindialog.newPin0Entry)); printf("%s:%s\n", oldpin, newpin); // output the PINs to stdout return_value = EXIT_OK; // and return OK } break; default: // otherwise printf("CANCEL\n"); return_value = EXIT_OK; // output CANCEL and return ok (cancel is not an error) break; } // properly dispose of the dialog (which disposes of all it's children), and exit with specific return value ///////////////////////////////////////////////////////////////////////////////////////////////////////////// gtk_widget_destroy(pindialog.dialog); exit(return_value); }
static void search_init (GtkWidget *entry, GeditViewFrame *frame) { const gchar *entry_text; /* renew the flush timeout */ if (frame->priv->typeselect_flush_timeout != 0) { g_source_remove (frame->priv->typeselect_flush_timeout); frame->priv->typeselect_flush_timeout = g_timeout_add (GEDIT_VIEW_FRAME_SEARCH_DIALOG_TIMEOUT, (GSourceFunc)search_entry_flush_timeout, frame); } entry_text = gtk_entry_get_text (GTK_ENTRY (entry)); if (frame->priv->search_mode == SEARCH) { update_search (frame); run_search (frame, entry_text, FALSE, frame->priv->wrap_around, TRUE); } else { if (*entry_text != '\0') { gboolean moved, moved_offset; gint line; gint offset_line = 0; gint line_offset = 0; gchar **split_text = NULL; const gchar *text; GtkTextIter iter; GeditDocument *doc; doc = gedit_view_frame_get_document (frame); gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc), &iter, frame->priv->start_mark); split_text = g_strsplit (entry_text, ":", -1); if (g_strv_length (split_text) > 1) { text = split_text[0]; } else { text = entry_text; } if (*text == '-') { gint cur_line = gtk_text_iter_get_line (&iter); if (*(text + 1) != '\0') offset_line = MAX (atoi (text + 1), 0); line = MAX (cur_line - offset_line, 0); } else if (*entry_text == '+') { gint cur_line = gtk_text_iter_get_line (&iter); if (*(text + 1) != '\0') offset_line = MAX (atoi (text + 1), 0); line = cur_line + offset_line; } else { line = MAX (atoi (text) - 1, 0); } if (split_text[1] != NULL) { line_offset = atoi (split_text[1]); } g_strfreev (split_text); moved = gedit_document_goto_line (doc, line); moved_offset = gedit_document_goto_line_offset (doc, line, line_offset); gedit_view_scroll_to_cursor (GEDIT_VIEW (frame->priv->view)); if (!moved || !moved_offset) { set_entry_background (frame, frame->priv->search_entry, GEDIT_SEARCH_ENTRY_NOT_FOUND); } else { set_entry_background (frame, frame->priv->search_entry, GEDIT_SEARCH_ENTRY_NORMAL); } } } }
void on_bt_wine_port_ok_clicked (GtkButton *button, gpointer user_data) { FILE * fd; FILE * fo; int find=0; char enr[512]; char enr2[512]; char ftemp[512]; strcpy(ftemp,XWineDir); strcat(ftemp,"/temp.conf"); /* Ports Séries */ fd=fopen(FichierConfig,"rt"); fo=fopen(ftemp,"wt"); fgets(enr, 512, fd); while (!feof(fd)) { if (chaine_contient(enr,"[serialports]")) { find=1; fputs(enr,fo); strcpy(enr2,"\"Com1\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_COM1")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"Com2\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_COM2")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"Com3\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_COM3")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"Com4\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_COM4")))); strcat(enr2,"\"\n"); fputs(enr2,fo); } else if (chaine_contient(enr,"#") || chaine_contient(enr,"[")) find=0; if (!find) fputs(enr,fo); fgets(enr, 512, fd); } fclose(fd); fclose(fo); // Ports Parallèles fo=fopen(FichierConfig,"wt"); fd=fopen(ftemp,"rt"); find=0; fgets(enr, 512, fd); while (!feof(fd)) { if (chaine_contient(enr,"[parallelports]")) { find=1; fputs(enr,fo); strcpy(enr2,"\"Lpt1\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPT1")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"Lpt2\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPT2")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"Lpt3\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPT3")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"Lpt4\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPT4")))); strcat(enr2,"\"\n"); fputs(enr2,fo); } else if (chaine_contient(enr,"#") || chaine_contient(enr,"[")) find=0; if (!find) fputs(enr,fo); fgets(enr, 512, fd); } fclose(fd); fclose(fo); // Imprimantes fd=fopen(FichierConfig,"rt"); fo=fopen(ftemp,"wt"); find=0; fgets(enr, 512, fd); while (!feof(fd)) { if (chaine_contient(enr,"[spooler]")) { find=1; fputs(enr,fo); strcpy(enr2,"\"LPT1:\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPR1")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"LPT2:\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPR2")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"LPT3:\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPR3")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"LPT4:\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPR4")))); strcat(enr2,"\"\n"); fputs(enr2,fo); } else if (chaine_contient(enr,"#") || chaine_contient(enr,"[")) find=0; if (!find) fputs(enr,fo); fgets(enr, 512, fd); } fclose(fd); fclose(fo); /* Recopier le fichier Config */ fd=fopen(FichierConfig,"wt"); fo=fopen(ftemp,"rt"); fgets(enr, 512, fo); while (!feof(fo)) { fputs(enr,fd); fgets(enr, 512, fo); } fclose(fd); fclose(fo); ecrire_dans_log(texte[178],texte[191]); gtk_widget_destroy(W_WINE_PORT); }
tlv* ajouter_dated(int opt){ /* Cette fonction va permettre de remplir un tlv dated, en appelant une fonction qui * sera adapter à remplir le sous tlv du type spécifié. * Elle renvoie un pointeur sur tlv, et NULL si quelque chose est arrivé. */ GtkWidget* pBoite; GtkWidget* pEntry; const gchar* type; int len,i,valid=1; time_t now; tlv* tlvDated=NULL; // L'interface graphique demande à l'utilisateur de choisir le type du sous tlv pBoite = gtk_dialog_new_with_buttons("Choix du dated", GTK_WINDOW(pWindow2), GTK_DIALOG_MODAL, GTK_STOCK_OK,GTK_RESPONSE_OK, GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL, NULL); pEntry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(pEntry), "Entrez le type du TLV voulu"); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pEntry, TRUE, FALSE, 0); gtk_widget_show_all(GTK_DIALOG(pBoite)->vbox); switch (gtk_dialog_run(GTK_DIALOG(pBoite))){ case GTK_RESPONSE_OK: type = gtk_entry_get_text(GTK_ENTRY(pEntry)); len = strlen(type); // on vérifie qu'il s'agit bien d'un nombre ou d'un chiffre for(i = 0; i < len; i++){ if((type[i]< '0') || (type[i]> '9')){ valid = 0; break; } } if(valid == 0){ // Si la valeur rentrée n'est pas valide dialog = gtk_message_dialog_new(GTK_WINDOW(pBoite),GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,GTK_BUTTONS_OK,"Vous devez saisir un nombre entier!"); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); gtk_widget_destroy(pBoite); }else{ int n=atol(type); if(n > 1 && n <= TLV_MAX){ tlv* tlv=NULL; switch (n) { // On va agir selon le type du tlv case 2 : // Dans le cas d'un message texte tlvDated=newTlv(6); // On remplie le tlv tlvDated->nbTlv=1; if((tlvDated->tlvList=malloc(2*sizeof(struct tlv*)))==NULL){ perror("malloc"); exit(EXIT_FAILURE); } time(&now); tlvDated->time=now; // on appelle la fonction pour un sous-tlv texte tlv=ajouter_texte(2); if(tlv==NULL){ // Si le tlv a retourné NULL freeTlv(tlvDated); gtk_widget_destroy(pBoite); return NULL; } if(tlv->lenght > 16777216){ // Si la taille du Tlv est trop grande freeTlv(tlv); freeTlv(tlvDated); gtk_widget_destroy(pBoite); return NULL; } tlvDated->lenght=tlv->lenght+4+4; //+4 pour le tlv, +4 pour le time tlvDated->tlvList[0]=tlv; break; case 3 : tlvDated=newTlv(6); tlvDated->nbTlv=1; if((tlvDated->tlvList=malloc(2*sizeof(struct tlv*)))==NULL){ perror("malloc"); exit(EXIT_FAILURE); } tlvDated->tlvList[0]=ajouter_png(3); if(tlvDated->tlvList[0]==NULL){ freeTlv(tlvDated); gtk_widget_destroy(pBoite); return NULL; } if(tlvDated->tlvList[0]->lenght > 16777216){ freeTlv(tlv); freeTlv(tlvDated); gtk_widget_destroy(pBoite); return NULL; } time(&now); tlvDated->time=now; tlvDated->lenght=tlvDated->tlvList[0]->lenght+4+4; break; case 4 : tlvDated=newTlv(6); tlvDated->nbTlv=1; if((tlvDated->tlvList=malloc(2*sizeof(struct tlv*)))==NULL){ perror("malloc"); exit(EXIT_FAILURE); } tlvDated->tlvList[0]=ajouter_jpeg(4); if(tlvDated->tlvList[0]==NULL){ freeTlv(tlvDated); gtk_widget_destroy(pBoite); return NULL; } if(tlvDated->tlvList[0]->lenght > 16777216){ freeTlv(tlv); freeTlv(tlvDated); gtk_widget_destroy(pBoite); return NULL; } time(&now); tlvDated->time=now; tlvDated->lenght=tlvDated->tlvList[0]->lenght+4+4; break; case 5 : tlvDated=newTlv(6); tlvDated->nbTlv=1; if((tlvDated->tlvList=malloc(2*sizeof(struct tlv*)))==NULL){ perror("malloc"); exit(EXIT_FAILURE); } tlvDated->tlvList[0]=ajouter_compound(5); if(tlvDated->tlvList[0]==NULL){ freeTlv(tlvDated); gtk_widget_destroy(pBoite); return NULL; } if(tlvDated->tlvList[0]->lenght > 16777216){ freeTlv(tlv); freeTlv(tlvDated); gtk_widget_destroy(pBoite); return NULL; } time(&now); tlvDated->time=now; tlvDated->lenght=tlvDated->tlvList[0]->lenght+4+4; break; case 6 : tlvDated=newTlv(6); tlvDated->nbTlv=1; if((tlvDated->tlvList=malloc(2*sizeof(struct tlv*)))==NULL){ perror("malloc"); exit(EXIT_FAILURE); } tlvDated->tlvList[0]=ajouter_dated(6); if(tlvDated->tlvList[0]==NULL){ freeTlv(tlvDated); gtk_widget_destroy(pBoite); return NULL; } if(tlvDated->tlvList[0]->lenght > 16777216){ freeTlv(tlv); freeTlv(tlvDated); gtk_widget_destroy(pBoite); return NULL; } time(&now); tlvDated->time=now; tlvDated->lenght=tlvDated->tlvList[0]->lenght+4+4; break; } gtk_widget_destroy(pBoite); }else { // Si le chiffre ne spécifiait aucun TLV dialog = gtk_message_dialog_new(GTK_WINDOW(pBoite),GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,GTK_BUTTONS_OK,"Vous devez rentrer un nombre compris dans les types de TLV"); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); gtk_widget_destroy(pBoite); return NULL; } } break; case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_NONE: default: dialog = gtk_message_dialog_new(GTK_WINDOW(pBoite),GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,GTK_BUTTONS_OK,"Vous n'avez rien saisi!"); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); gtk_widget_destroy(pBoite); return NULL; break; } if(opt==0){ // si la fonction est appelée par l'interface graphique (pas de parent). num_msg++; char* num_msg2=NULL; struct stat statBuf; int fd; if((num_msg2=malloc(10*sizeof(char)))==NULL){ perror("malloc"); exit(EXIT_FAILURE); } sprintf(num_msg2,"%d",num_msg); GtkTextIter end; GtkTextBuffer *buf; buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pTextView)); gtk_text_view_set_wrap_mode((GTK_TEXT_VIEW(pTextView)),GTK_WRAP_WORD); gtk_text_view_set_justification((GTK_TEXT_VIEW(pTextView)),GTK_JUSTIFY_CENTER); gtk_text_buffer_get_end_iter(buf,&end); gtk_text_buffer_insert(buf, &end, num_msg2, -1); gtk_text_buffer_insert(buf, &end, "------------------------------------------------------------------------------------------------------------------------------------\n", -1); if((fd=open(pathToDazibao,O_RDWR|O_APPEND))==-1){ perror("open"); exit(EXIT_FAILURE); } if(fstat(fd,&statBuf)==-1){ perror("fstat"); exit(EXIT_FAILURE); } posM[num_msg]=statBuf.st_size; ajouterMessageDated(fd,tlvDated,0); close(fd); return NULL; }else{ return tlvDated; } return NULL; }
static void search_entry_changed (GtkWidget *entry) { search (gtk_entry_get_text (GTK_ENTRY (entry)), TRUE); }
gboolean keypress(GtkWidget* w, GdkEventKey *ev, gpointer d) { Client *c = (Client *)d; if(ev->type != GDK_KEY_PRESS) return FALSE; if(GTK_WIDGET_HAS_FOCUS(c->searchbar)) { switch(ev->keyval) { case GDK_Escape: hidesearch(c); return TRUE; case GDK_Return: webkit_web_view_search_text(c->view, gtk_entry_get_text(GTK_ENTRY(c->searchbar)), FALSE, !(ev->state & GDK_SHIFT_MASK), TRUE); return TRUE; case GDK_Left: case GDK_Right: case GDK_r: return FALSE; } } else if(GTK_WIDGET_HAS_FOCUS(c->urlbar)) { switch(ev->keyval) { case GDK_Escape: hideurl(c); return TRUE; case GDK_Return: loaduri(c, gtk_entry_get_text(GTK_ENTRY(c->urlbar))); hideurl(c); return TRUE; case GDK_Left: case GDK_Right: case GDK_r: return FALSE; } } else if(ev->state == GDK_CONTROL_MASK || ev->state == (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) { switch(ev->keyval) { case GDK_r: case GDK_R: if((ev->state & GDK_SHIFT_MASK)) webkit_web_view_reload_bypass_cache(c->view); else webkit_web_view_reload(c->view); return TRUE; case GDK_b: return TRUE; case GDK_g: showurl(c); return TRUE; case GDK_slash: showsearch(c); return TRUE; case GDK_Left: webkit_web_view_go_back(c->view); return TRUE; case GDK_Right: webkit_web_view_go_forward(c->view); return TRUE; } } else { switch(ev->keyval) { case GDK_k: webkit_web_view_move_cursor(c->view, GTK_MOVEMENT_DISPLAY_LINES, -1); return TRUE; case GDK_j: webkit_web_view_move_cursor(c->view, GTK_MOVEMENT_DISPLAY_LINES, 1); return TRUE; } } return FALSE; }
static void search_entry_cb (GtkWidget * entry, session * sess) { search_search (sess, gtk_entry_get_text (GTK_ENTRY (entry))); }