/* Create a configuration dialog box window that belongs to Wireshark's * main window and add the name of the current profile name to its title bar */ GtkWidget * dlg_conf_window_new(const gchar *title) { const char *profile_name; gchar *win_name; GtkWidget *win; /* * Set window title to reflect which preferences profile we are * working with. */ profile_name = get_profile_name(); win_name = g_strdup_printf("%s - Profile: %s", title, profile_name); win = dlg_window_new(win_name); g_free(win_name); return win; }
void filter_expression_save_dlg(gpointer data) { GtkWidget *main_vb, *main_filter_save_hb, *filter_save_frame, *filter_save_type_vb, *filter_save_type_hb, *entry_hb, *bbox, *ok_bt, *cancel_bt, *help_bt, *filter_text_box, *label_text_box; const char *expr; /* The filter requested */ expr = gtk_entry_get_text(GTK_ENTRY(data)); if (filter_save_frame_w != NULL) { /* There's already a "Filter Save" dialog box; reactivate it. */ reactivate_window(filter_save_frame_w); return; } filter_save_frame_w = dlg_window_new("Wireshark: Save Filter"); /* Container for each row of widgets */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); gtk_container_add(GTK_CONTAINER(filter_save_frame_w), main_vb); gtk_widget_show(main_vb); /* */ main_filter_save_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX (main_vb), main_filter_save_hb, TRUE, TRUE, 0); gtk_widget_show(main_filter_save_hb); /* Filter Save frame */ filter_save_frame = gtk_frame_new("Save Filter as..."); gtk_box_pack_start(GTK_BOX(main_filter_save_hb), filter_save_frame, TRUE, TRUE, 0); gtk_widget_show(filter_save_frame); filter_save_type_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(filter_save_type_vb), 3); gtk_container_add(GTK_CONTAINER(filter_save_frame), filter_save_type_vb); gtk_widget_show(filter_save_type_vb); /* filter_save type row */ filter_save_type_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX (filter_save_type_vb), filter_save_type_hb, TRUE, TRUE, 0); gtk_widget_show(filter_save_type_hb); /* filter_save row */ entry_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_box_pack_start(GTK_BOX(filter_save_type_vb), entry_hb, FALSE, FALSE, 0); gtk_widget_show(entry_hb); filter_text_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(entry_hb), filter_text_box, TRUE, TRUE, 0); g_signal_connect(filter_text_box, "changed", G_CALLBACK(filter_te_syntax_check_cb), NULL); g_signal_connect(filter_text_box, "key-press-event", G_CALLBACK (filter_string_te_key_pressed_cb), NULL); g_signal_connect(filter_save_frame_w, "key-press-event", G_CALLBACK (filter_parent_dlg_key_pressed_cb), NULL); gtk_entry_set_text(GTK_ENTRY(filter_text_box), expr); gtk_widget_show(filter_text_box); label_text_box = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(entry_hb), label_text_box, TRUE, TRUE, 0); gtk_entry_set_text(GTK_ENTRY(label_text_box), "Filter"); gtk_widget_show(label_text_box); /* Button row */ bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL); gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0); gtk_widget_show(bbox); ok_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK); g_signal_connect(ok_bt, "clicked", G_CALLBACK(filter_save_ok_cb), filter_save_frame_w); cancel_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL); g_signal_connect(cancel_bt, "clicked", G_CALLBACK(filter_save_close_cb), filter_save_frame_w); help_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP); g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_FILTER_SAVE_DIALOG); g_object_set_data(G_OBJECT(filter_save_frame_w), E_FILTER_SAVE_EXPR_KEY, filter_text_box); g_object_set_data(G_OBJECT(filter_save_frame_w), E_FILTER_SAVE_LABEL_KEY, label_text_box); dlg_set_activate(label_text_box, ok_bt); /* Give the initial focus to the "offset" entry box. */ gtk_widget_grab_focus(label_text_box); g_signal_connect(filter_save_frame_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL); g_signal_connect(filter_save_frame_w, "destroy", G_CALLBACK(filter_save_frame_destroy_cb), NULL); gtk_widget_show(filter_save_frame_w); window_present(filter_save_frame_w); }
packet_info *pinfo = &cfile.edt->pi; guint i; rule_info = g_new0(rule_info_t, 1); COPY_ADDRESS(&(rule_info->dl_src), &(pinfo->dl_src)); COPY_ADDRESS(&(rule_info->dl_dst), &(pinfo->dl_dst)); COPY_ADDRESS(&(rule_info->net_src), &(pinfo->net_src)); COPY_ADDRESS(&(rule_info->net_dst), &(pinfo->net_dst)); rule_info->ptype = pinfo->ptype; rule_info->srcport = pinfo->srcport; rule_info->destport = pinfo->destport; rule_info->inbound = TRUE; rule_info->deny = TRUE; rule_info->product = 0; rule_w = dlg_window_new("Firewall ACL Rules"); gtk_widget_set_name(rule_w, "Firewall ACL rule window"); gtk_container_set_border_width(GTK_CONTAINER(rule_w), 6); /* setup the container */ tooltips = gtk_tooltips_new (); vbox = gtk_vbox_new(FALSE, 6); gtk_container_add(GTK_CONTAINER(rule_w), vbox); /* rule type selectors hbox */ hbox = gtk_hbox_new(FALSE, 1); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); /* product selector */
/* * Create and pop up the progress dialog; allocate a "progdlg_t" * and initialize it to contain all information the implementation * needs in order to manipulate the dialog, and return a pointer to * it. * * The first argument is the task to do, e.g. "Loading". * The second argument is the item to do, e.g. "capture.cap". * The third argument is TRUE if the "terminate this operation" button should * be a "Stop" button (meaning that the operation is stopped, but not undone), * and FALSE if it should be a "Cancel" button (meaning that it's stopped * and anything it's done would be undone) * The fourth argument is a pointer to a Boolean variable that will be * set to TRUE if the user hits that button. * * XXX - provide a way to specify the progress in units, with the total * number of units specified as an argument when the progress dialog * is created; updates would be given in units, with the progress dialog * code computing the percentage, and the progress bar would have a * label "0" on the left and <total number of units> on the right, with * a label in the middle giving the number of units we've processed * so far. This could be used when filtering packets, for example; we * wouldn't always use it, as we have no idea how many packets are to * be read. */ progdlg_t * create_progress_dlg(const gchar *task_title, const gchar *item_title, gboolean terminate_is_stop, gboolean *stop_flag) { progdlg_t *dlg; GtkWidget *dlg_w, *main_vb, *title_lb, *status_lb, *elapsed_lb, *time_left_lb, *percentage_lb; GtkWidget *prog_bar, *bbox, *cancel_bt; GtkWidget *static_vb, *tmp_lb, *main_hb, *dynamic_vb, *percentage_hb; gchar *task_title_dup; gchar *item_title_dup; dlg = g_malloc(sizeof (progdlg_t)); /* limit the item_title to some reasonable length */ item_title_dup = g_strdup(item_title); if (strlen(item_title_dup) > 110) { g_strlcpy(&item_title_dup[100], "...", 4); } dlg->title = g_strdup_printf("%s: %s", task_title, item_title_dup); dlg_w = dlg_window_new(dlg->title); gtk_window_set_modal(GTK_WINDOW(dlg_w), TRUE); /* * Container for dialog widgets. */ main_vb = gtk_vbox_new(FALSE, 1); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); gtk_container_add(GTK_CONTAINER(dlg_w), main_vb); /* * Static labels (left dialog side, labels aligned to the right) */ static_vb = gtk_vbox_new(FALSE, 1); task_title_dup = g_strdup_printf ("%s:", task_title); tmp_lb = gtk_label_new(task_title_dup); gtk_misc_set_alignment(GTK_MISC(tmp_lb), 1.0f, 0.0f); gtk_box_pack_start(GTK_BOX(static_vb), tmp_lb, FALSE, TRUE, 3); tmp_lb = gtk_label_new("Status:"); gtk_misc_set_alignment(GTK_MISC(tmp_lb), 1.0f, 0.0f); gtk_box_pack_start(GTK_BOX(static_vb), tmp_lb, FALSE, TRUE, 3); tmp_lb = gtk_label_new("Elapsed Time:"); gtk_misc_set_alignment(GTK_MISC(tmp_lb), 1.0f, 0.0f); gtk_box_pack_start(GTK_BOX(static_vb), tmp_lb, FALSE, TRUE, 3); tmp_lb = gtk_label_new("Time Left:"); gtk_misc_set_alignment(GTK_MISC(tmp_lb), 1.0f, 0.0f); gtk_box_pack_start(GTK_BOX(static_vb), tmp_lb, FALSE, TRUE, 3); tmp_lb = gtk_label_new("Progress:"); gtk_misc_set_alignment(GTK_MISC(tmp_lb), 1.0f, 0.0f); gtk_box_pack_start(GTK_BOX(static_vb), tmp_lb, FALSE, TRUE, 3); /* * Dynamic labels (right dialog side, labels aligned to the left) */ dynamic_vb = gtk_vbox_new(FALSE, 1); /* * Put the item_title here as a label indicating what we're * doing; set its alignment and padding so it's aligned on the * left. */ title_lb = gtk_label_new(item_title_dup); gtk_box_pack_start(GTK_BOX(dynamic_vb), title_lb, FALSE, TRUE, 3); gtk_misc_set_alignment(GTK_MISC(title_lb), 0.0f, 0.0f); gtk_misc_set_padding(GTK_MISC(title_lb), 0, 0); /* same for "Status" */ status_lb = gtk_label_new(""); gtk_box_pack_start(GTK_BOX(dynamic_vb), status_lb, FALSE, TRUE, 3); gtk_misc_set_alignment(GTK_MISC(status_lb), 0.0f, 0.0f); gtk_misc_set_padding(GTK_MISC(status_lb), 0, 0); dlg->status_lb = (GtkLabel *) status_lb; /* same for "Elapsed Time" */ elapsed_lb = gtk_label_new("00:00"); gtk_box_pack_start(GTK_BOX(dynamic_vb), elapsed_lb, FALSE, TRUE, 3); gtk_misc_set_alignment(GTK_MISC(elapsed_lb), 0.0f, 0.0f); gtk_misc_set_padding(GTK_MISC(elapsed_lb), 0, 0); dlg->elapsed_lb = (GtkLabel *) elapsed_lb; /* same for "Time Left" */ time_left_lb = gtk_label_new("--:--"); gtk_box_pack_start(GTK_BOX(dynamic_vb), time_left_lb, FALSE, TRUE, 3); gtk_misc_set_alignment(GTK_MISC(time_left_lb), 0.0f, 0.0f); gtk_misc_set_padding(GTK_MISC(time_left_lb), 0, 0); dlg->time_left_lb = (GtkLabel *) time_left_lb; /* * The progress bar (in its own horizontal box, including * percentage value) */ percentage_hb = gtk_hbox_new(FALSE, 1); gtk_box_pack_start(GTK_BOX(dynamic_vb), percentage_hb, FALSE, TRUE, 3); prog_bar = gtk_progress_bar_new(); gtk_box_pack_start(GTK_BOX(percentage_hb), prog_bar, FALSE, TRUE, 3); percentage_lb = gtk_label_new(" 0%"); gtk_misc_set_alignment(GTK_MISC(percentage_lb), 0.0f, 0.0f); gtk_box_pack_start(GTK_BOX(percentage_hb), percentage_lb, FALSE, TRUE, 3); dlg->percentage_lb = (GtkLabel *) percentage_lb; /* * Attach a pointer to the progress bar widget to the top-level widget. */ g_object_set_data(G_OBJECT(dlg_w), PROG_BAR_KEY, prog_bar); /* * Static and dynamic boxes are now complete */ main_hb = gtk_hbox_new(FALSE, 1); gtk_box_pack_start(GTK_BOX(main_hb), static_vb, FALSE, TRUE, 3); gtk_box_pack_start(GTK_BOX(main_hb), dynamic_vb, FALSE, TRUE, 3); gtk_box_pack_start(GTK_BOX(main_vb), main_hb, FALSE, TRUE, 3); /* Button row */ bbox = dlg_button_row_new(terminate_is_stop ? GTK_STOCK_STOP : GTK_STOCK_CANCEL, NULL); gtk_container_add(GTK_CONTAINER(main_vb), bbox); gtk_widget_show(bbox); cancel_bt = g_object_get_data(G_OBJECT(bbox), terminate_is_stop ? GTK_STOCK_STOP : GTK_STOCK_CANCEL); gtk_widget_grab_default(cancel_bt); /* * Allow user to either click the "Cancel"/"Stop" button, or * the close button on the window, to stop an operation in * progress. */ g_signal_connect(cancel_bt, "clicked", G_CALLBACK(stop_cb), stop_flag); g_signal_connect(dlg_w, "delete_event", G_CALLBACK(delete_event_cb), stop_flag); gtk_widget_show_all(dlg_w); dlg->dlg_w = dlg_w; g_get_current_time(&dlg->start_time); memset(&dlg->last_time, 0, sizeof(dlg->last_time)); g_free(task_title_dup); g_free(item_title_dup); return dlg; }
#include "ui/gtk/help_dlg.h" /* Capture callback data keys */ #define E_GOTO_FNUMBER_KEY "goto_fnumber_te" static void goto_frame_ok_cb(GtkWidget *ok_bt, gpointer parent_w); void goto_frame_cb(GtkWidget *w _U_, gpointer d _U_) { GtkWidget *goto_frame_w, *main_vb, *fnumber_hb, *fnumber_lb, *fnumber_te, *bbox, *ok_bt, *cancel_bt, *help_bt; goto_frame_w = dlg_window_new("Wireshark: Go To Packet"); /* Container for each row of widgets */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); gtk_container_add(GTK_CONTAINER(goto_frame_w), main_vb); gtk_widget_show(main_vb); /* Frame number row */ fnumber_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE); gtk_container_add(GTK_CONTAINER(main_vb), fnumber_hb); gtk_widget_show(fnumber_hb); fnumber_lb = gtk_label_new("Packet number:"); gtk_box_pack_start(GTK_BOX(fnumber_hb), fnumber_lb, FALSE, FALSE, 0); gtk_widget_show(fnumber_lb);
static GtkWidget * display_simple_dialog(gint type, gint btn_mask, char *message) { GtkWidget *win, *main_vb, *top_hb, *msg_vb, *type_pm, *msg_label, *ask_cb, *bbox, *ok_bt, *yes_bt, *bt, *save_bt, *dont_save_bt; GdkPixmap *pixmap; GdkBitmap *mask; GtkStyle *style; GdkColormap *cmap; const gchar **icon; /* Main window */ switch (type) { case ESD_TYPE_WARN : icon = stock_dialog_warning_48_xpm; break; case ESD_TYPE_CONFIRMATION: icon = stock_dialog_warning_48_xpm; break; case ESD_TYPE_ERROR: icon = stock_dialog_error_48_xpm; break; case ESD_TYPE_STOP : icon = stock_dialog_stop_48_xpm; break; case ESD_TYPE_INFO : default : icon = stock_dialog_info_48_xpm; break; } /* * The GNOME HIG: * * http://developer.gnome.org/projects/gup/hig/1.0/windows.html#alert-windows * * says that the title should be empty for alert boxes, so there's "less * visual noise and confounding text." * * The Windows HIG: * * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnwue/html/ch09f.asp * * says it should * * ...appropriately identify the source of the message -- usually * the name of the object. For example, if the message results * from editing a document, the title text is the name of the * document, optionally followed by the application name. If the * message results from a non-document object, then use the * application name." * * and notes that the title is important "because message boxes might * not always the the result of current user interaction" (e.g., some * app might randomly pop something up, e.g. some browser letting you * know that it couldn't fetch something because of a timeout). * * It also says not to use "warning" or "caution", as there's already * an icon that tells you what type of alert it is, and that you * shouldn't say "error", as that provides no useful information. * * So we give it a title on Win32, and don't give it one on UN*X. * For now, we give it a Win32 title of just "Wireshark"; we should * arguably take an argument for the title. */ if(btn_mask == ESD_BTN_NONE) { win = splash_window_new(); } else { #ifdef _WIN32 win = dlg_window_new("Wireshark"); #else win = dlg_window_new(""); #endif } gtk_window_set_modal(GTK_WINDOW(win), TRUE); gtk_container_set_border_width(GTK_CONTAINER(win), 6); /* Container for our rows */ main_vb = gtk_vbox_new(FALSE, 12); gtk_container_add(GTK_CONTAINER(win), main_vb); gtk_widget_show(main_vb); /* Top row: Icon and message text */ top_hb = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 6); gtk_container_add(GTK_CONTAINER(main_vb), top_hb); gtk_widget_show(top_hb); /* icon */ style = gtk_widget_get_style(win); cmap = gdk_colormap_get_system(); pixmap = gdk_pixmap_colormap_create_from_xpm_d(NULL, cmap, &mask, &style->bg[GTK_STATE_NORMAL], (gchar **) icon); type_pm = gtk_image_new_from_pixmap(pixmap, mask); gtk_misc_set_alignment (GTK_MISC (type_pm), 0.5f, 0.0f); gtk_container_add(GTK_CONTAINER(top_hb), type_pm); gtk_widget_show(type_pm); /* column for message and optional check button */ msg_vb = gtk_vbox_new(FALSE, 6); gtk_box_set_spacing(GTK_BOX(msg_vb), 24); gtk_container_add(GTK_CONTAINER(top_hb), msg_vb); gtk_widget_show(msg_vb); /* message */ msg_label = gtk_label_new(message); gtk_label_set_markup(GTK_LABEL(msg_label), message); gtk_label_set_selectable(GTK_LABEL(msg_label), TRUE); #if GTK_CHECK_VERSION(2,9,0) g_object_set(gtk_widget_get_settings(msg_label), "gtk-label-select-on-focus", FALSE, NULL); #endif gtk_label_set_justify(GTK_LABEL(msg_label), GTK_JUSTIFY_FILL); gtk_misc_set_alignment (GTK_MISC (type_pm), 0.5f, 0.0f); gtk_container_add(GTK_CONTAINER(msg_vb), msg_label); gtk_label_set_line_wrap(GTK_LABEL(msg_label), TRUE); gtk_widget_show(msg_label); if(btn_mask == ESD_BTN_NONE) { gtk_widget_show(win); return win; } /* optional check button */ ask_cb = gtk_check_button_new_with_label("replace with text..."); gtk_container_add(GTK_CONTAINER(msg_vb), ask_cb); g_object_set_data(G_OBJECT(win), CHECK_BUTTON, ask_cb); /* Button row */ switch(btn_mask) { case(ESD_BTN_OK): bbox = dlg_button_row_new(GTK_STOCK_OK, NULL); break; case(ESD_BTN_OK | ESD_BTN_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTN_CLEAR | ESD_BTN_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_CLEAR, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTNS_YES_NO_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_YES, GTK_STOCK_NO, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTNS_SAVE_DONTSAVE_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_SAVE, WIRESHARK_STOCK_DONT_SAVE, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTNS_SAVE_QUIT_DONTSAVE_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_SAVE, WIRESHARK_STOCK_QUIT_DONT_SAVE, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTNS_YES_NO): bbox = dlg_button_row_new(GTK_STOCK_YES, GTK_STOCK_NO, NULL); break; default: g_assert_not_reached(); bbox = NULL; break; } gtk_container_add(GTK_CONTAINER(main_vb), bbox); gtk_widget_show(bbox); ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK); if(ok_bt) { g_object_set_data(G_OBJECT(ok_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_OK)); g_signal_connect(ok_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } save_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_SAVE); if (save_bt) { g_object_set_data(G_OBJECT(save_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_SAVE)); g_signal_connect(save_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } dont_save_bt = g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_DONT_SAVE); if (dont_save_bt) { g_object_set_data(G_OBJECT(dont_save_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_DONT_SAVE)); g_signal_connect(dont_save_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } dont_save_bt = g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_QUIT_DONT_SAVE); if (dont_save_bt) { g_object_set_data(G_OBJECT(dont_save_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_QUIT_DONT_SAVE)); g_signal_connect(dont_save_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLEAR); if(bt) { g_object_set_data(G_OBJECT(bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_CLEAR)); g_signal_connect(bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } yes_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_YES); if(yes_bt) { g_object_set_data(G_OBJECT(yes_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_YES)); g_signal_connect(yes_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_NO); if(bt) { g_object_set_data(G_OBJECT(bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_NO)); g_signal_connect(bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL); if(bt) { g_object_set_data(G_OBJECT(bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_CANCEL)); window_set_cancel_button(win, bt, simple_dialog_cancel_cb); } if(!bt) { if(yes_bt) { window_set_cancel_button(win, yes_bt, simple_dialog_cancel_cb); } else { window_set_cancel_button(win, ok_bt, simple_dialog_cancel_cb); } } dlg_button_focus_nth(bbox, 0); gtk_widget_show(win); return win; }
} void addr_resolution_dlg (GtkAction *action _U_, gpointer data _U_) { GtkWidget *vbox; GtkWidget *view; GtkWidget *scroll; GtkWidget *bbox; GtkWidget *ok_bt, *cancel_bt, *help_bt; GtkTextBuffer *buffer; addr_resolution_dlg_w = dlg_window_new ("Address Resolution"); gtk_widget_set_size_request (addr_resolution_dlg_w, 750, 350); gtk_window_set_resizable (GTK_WINDOW (addr_resolution_dlg_w), TRUE); gtk_container_set_border_width (GTK_CONTAINER (addr_resolution_dlg_w), DLG_OUTER_MARGIN); vbox = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, DLG_UNRELATED_SPACING, FALSE); gtk_container_add (GTK_CONTAINER (addr_resolution_dlg_w), vbox); gtk_widget_show (vbox); view = gtk_text_view_new (); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_WORD); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(view, user_font_get_regular()); #else gtk_widget_modify_font(view, user_font_get_regular());
*rr_fr, *rr_box, *tot_fr, *tot_box; gchar string_buff[SUM_STR_MAX]; double seconds; int i; int tot_invokes, tot_rr; double tot_invokes_size, tot_rr_size; /* initialize the tally */ summary_fill_in(&cfile, &summary); /* initial computations */ seconds = summary.stop_time - summary.start_time; sum_open_w = dlg_window_new("GSM MAP Statistics: Summary"); /* transient_for top_level */ gtk_window_set_destroy_with_parent (GTK_WINDOW(sum_open_w), TRUE); /* Container for each row of widgets */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); gtk_container_add(GTK_CONTAINER(sum_open_w), main_vb); gtk_widget_show(main_vb); /* File frame */ file_fr = gtk_frame_new("File"); gtk_box_pack_start(GTK_BOX (main_vb), file_fr, TRUE, TRUE, 0); gtk_widget_show(file_fr); file_box = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE); gtk_container_add(GTK_CONTAINER(file_fr), file_box);